import {
  createResolver,
  getRoots,
  isInstalledGlobally,
  resolveEntry,
  resolveImportPath,
  resolveImportUrl,
  toAtFS
} from "./chunk-UNQ5DBLZ.js";

// package.json
var version = "0.50.0";

// node/integrations/themes.ts
import { join } from "node:path";
import fs from "fs-extra";
import { satisfies } from "semver";
var officialThemes = {
  "none": "",
  "default": "@slidev/theme-default",
  "seriph": "@slidev/theme-seriph",
  "apple-basic": "@slidev/theme-apple-basic",
  "shibainu": "@slidev/theme-shibainu",
  "bricks": "@slidev/theme-bricks"
};
var resolveTheme = createResolver("theme", officialThemes);
async function getThemeMeta(name, root) {
  const path4 = join(root, "package.json");
  if (!fs.existsSync(path4))
    return {};
  const { slidev = {}, engines = {} } = await fs.readJSON(path4);
  if (engines.slidev && !satisfies(version, engines.slidev, { includePrerelease: true }))
    throw new Error(`[slidev] theme "${name}" requires Slidev version range "${engines.slidev}" but found "${version}"`);
  return slidev;
}

// node/parser.ts
import * as parser from "@slidev/parser/fs";

// node/options.ts
import path3 from "node:path";
import { objectMap as objectMap2, uniq as uniq5 } from "@antfu/utils";
import Debug from "debug";
import fg4 from "fast-glob";
import mm from "micromatch";

// node/integrations/addons.ts
import { resolve } from "node:path";
import fs2 from "fs-extra";
import { satisfies as satisfies2 } from "semver";
async function resolveAddons(addonsInConfig) {
  const { userRoot, userPkgJson } = await getRoots();
  const resolved = [];
  const resolveAddonNameAndRoot = createResolver("addon", {});
  async function resolveAddon(name, parent) {
    const [, pkgRoot] = await resolveAddonNameAndRoot(name, parent);
    if (!pkgRoot)
      return;
    resolved.push(pkgRoot);
    const { slidev = {}, engines = {} } = await fs2.readJSON(resolve(pkgRoot, "package.json"));
    if (engines.slidev && !satisfies2(version, engines.slidev, { includePrerelease: true }))
      throw new Error(`[slidev] addon "${name}" requires Slidev version range "${engines.slidev}" but found "${version}"`);
    if (Array.isArray(slidev.addons))
      await Promise.all(slidev.addons.map((addon) => resolveAddon(addon, pkgRoot)));
  }
  if (Array.isArray(addonsInConfig))
    await Promise.all(addonsInConfig.map((addon) => resolveAddon(addon, userRoot)));
  if (Array.isArray(userPkgJson.slidev?.addons))
    await Promise.all(userPkgJson.slidev.addons.map((addon) => resolveAddon(addon, userRoot)));
  return resolved;
}

// node/setups/indexHtml.ts
import { existsSync as existsSync8, readFileSync as readFileSync2 } from "node:fs";
import { join as join13 } from "node:path";
import { slash as slash4 } from "@antfu/utils";
import { white, yellow as yellow2 } from "kolorist";
import { escapeHtml } from "markdown-it/lib/common/utils.mjs";

// node/commands/shared.ts
import { existsSync as existsSync7 } from "node:fs";
import { join as join12 } from "node:path";
import MarkdownIt from "markdown-it";
import { loadConfigFromFile, mergeConfig as mergeConfig2 } from "vite";

// node/syntax/markdown-it/markdown-it-link.ts
function MarkdownItLink(md) {
  const defaultRender = md.renderer.rules.link_open ?? ((tokens, idx, options, _env, self) => self.renderToken(tokens, idx, options));
  md.renderer.rules.link_open = function(tokens, idx, options, env, self) {
    const token = tokens[idx];
    const hrefIndex = token.attrIndex("href");
    const attr = token.attrs?.[hrefIndex];
    const href = attr?.[1] ?? "";
    if ("./#".includes(href[0]) || /^\d+$/.test(href)) {
      token.tag = "Link";
      attr[0] = "to";
      for (let i = idx + 1; i < tokens.length; i++) {
        if (tokens[i].type === "link_close") {
          tokens[i].tag = "Link";
          break;
        }
      }
    } else if (token.attrGet("target") == null) {
      token.attrPush(["target", "_blank"]);
    }
    return defaultRender(tokens, idx, options, env, self);
  };
}

// node/utils.ts
import { fileURLToPath } from "node:url";
import { createJiti } from "jiti";
import YAML from "yaml";
var jiti;
function loadModule(absolutePath) {
  jiti ??= createJiti(fileURLToPath(import.meta.url));
  return jiti.import(absolutePath);
}
function stringifyMarkdownTokens(tokens) {
  return tokens.map((token) => token.children?.filter((t) => ["text", "code_inline"].includes(t.type) && !t.content.match(/^\s*$/)).map((t) => t.content.trim()).join(" ")).filter(Boolean).join(" ");
}
function generateGoogleFontsUrl(options) {
  const weights = options.weights.flatMap((i) => options.italic ? [`0,${i}`, `1,${i}`] : [`${i}`]).sort().join(";");
  const fonts = options.webfonts.map((i) => `family=${i.replace(/^(['"])(.*)\1$/, "$1").replace(/\s+/g, "+")}:${options.italic ? "ital," : ""}wght@${weights}`).join("&");
  return `https://fonts.googleapis.com/css2?${fonts}&display=swap`;
}
function updateFrontmatterPatch(slide, frontmatter) {
  const source = slide.source;
  let doc = source.frontmatterDoc;
  if (!doc) {
    source.frontmatterStyle = "frontmatter";
    source.frontmatterDoc = doc = new YAML.Document({});
  }
  for (const [key, value] of Object.entries(frontmatter)) {
    slide.frontmatter[key] = source.frontmatter[key] = value;
    if (value == null) {
      doc.delete(key);
    } else {
      const valueNode = doc.createNode(value);
      let found = false;
      YAML.visit(doc.contents, {
        Pair(_key, node, path4) {
          if (path4.length === 1 && YAML.isScalar(node.key) && node.key.value === key) {
            node.value = valueNode;
            found = true;
            return YAML.visit.BREAK;
          }
        }
      });
      if (!found) {
        if (!YAML.isMap(doc.contents))
          doc.contents = doc.createNode({});
        doc.contents.add(
          doc.createPair(key, valueNode)
        );
      }
    }
  }
}
function getBodyJson(req) {
  return new Promise((resolve9, reject) => {
    let body = "";
    req.on("data", (chunk) => body += chunk);
    req.on("error", reject);
    req.on("end", () => {
      try {
        resolve9(JSON.parse(body) || {});
      } catch (e) {
        reject(e);
      }
    });
  });
}

// node/vite/compilerFlagsVue.ts
import { objectEntries } from "@antfu/utils";
function createVueCompilerFlagsPlugin(options) {
  const define = objectEntries(options.utils.define);
  return {
    name: "slidev:flags",
    enforce: "pre",
    transform(code, id) {
      if (!id.match(/\.vue($|\?)/) && !id.includes("?vue&"))
        return;
      const original = code;
      define.forEach(([from, to]) => {
        code = code.replaceAll(from, to);
      });
      if (original !== code)
        return code;
    }
  };
}

// node/vite/components.ts
import { join as join2 } from "node:path";
import IconsResolver from "unplugin-icons/resolver";
import Components from "unplugin-vue-components/vite";
function createComponentsPlugin({ clientRoot, roots }, pluginOptions) {
  return Components({
    extensions: ["vue", "md", "js", "ts", "jsx", "tsx"],
    dirs: [
      join2(clientRoot, "builtin"),
      ...roots.map((i) => join2(i, "components"))
    ],
    include: [/\.vue$/, /\.vue\?vue/, /\.vue\?v=/, /\.md$/, /\.md\?vue/],
    exclude: [],
    resolvers: [
      IconsResolver({
        prefix: "",
        customCollections: Object.keys(pluginOptions.icons?.customCollections || [])
      })
    ],
    dts: false,
    ...pluginOptions.components
  });
}

// node/vite/common.ts
var regexSlideReqPath = /^\/__slidev\/slides\/(\d+)\.json$/;
var regexSlideFacadeId = /^\/@slidev\/slides\/(\d+)\/(md|frontmatter)($|\?)/;
var regexSlideSourceId = /__slidev_(\d+)\.(md|frontmatter)$/;
var templateInjectionMarker = "/* @slidev-injection */";
var templateImportContextUtils = `import { useSlideContext as _useSlideContext, frontmatterToProps as _frontmatterToProps } from "@slidev/client/context.ts"`;
var templateInitContext = `const { $slidev, $nav, $clicksContext, $clicks, $page, $renderContext, $frontmatter } = _useSlideContext()`;

// node/vite/contextInjection.ts
function createContextInjectionPlugin() {
  return {
    name: "slidev:context-injection",
    async transform(code, id) {
      if (!id.endsWith(".vue") || id.includes("/@slidev/client/") || id.includes("/packages/client/"))
        return;
      if (code.includes(templateInjectionMarker) || code.includes("useSlideContext()"))
        return code;
      const imports = [
        templateImportContextUtils,
        templateInitContext,
        templateInjectionMarker
      ];
      const matchScript = code.match(/<script((?!setup).)*(setup)?.*>/);
      if (matchScript && matchScript[2]) {
        return code.replace(/(<script.*>)/g, `$1
${imports.join("\n")}
`);
      } else if (matchScript && !matchScript[2]) {
        const matchExport = code.match(/export\s+default\s+\{/);
        if (matchExport) {
          const exportIndex = (matchExport.index || 0) + matchExport[0].length;
          let component = code.slice(exportIndex);
          component = component.slice(0, component.indexOf("</script>"));
          const scriptIndex = (matchScript.index || 0) + matchScript[0].length;
          const provideImport = '\nimport { injectionSlidevContext } from "@slidev/client/constants.ts"\n';
          code = `${code.slice(0, scriptIndex)}${provideImport}${code.slice(scriptIndex)}`;
          let injectIndex = exportIndex + provideImport.length;
          let injectObject = "$slidev: { from: injectionSlidevContext },";
          const matchInject = component.match(/.*inject\s*:\s*([[{])/);
          if (matchInject) {
            injectIndex += (matchInject.index || 0) + matchInject[0].length;
            if (matchInject[1] === "[") {
              let injects = component.slice((matchInject.index || 0) + matchInject[0].length);
              const injectEndIndex = injects.indexOf("]");
              injects = injects.slice(0, injectEndIndex);
              injectObject += injects.split(",").map((inject) => `${inject}: {from: ${inject}}`).join(",");
              return `${code.slice(0, injectIndex - 1)}{
${injectObject}
}${code.slice(injectIndex + injectEndIndex + 1)}`;
            } else {
              return `${code.slice(0, injectIndex)}
${injectObject}
${code.slice(injectIndex)}`;
            }
          }
          return `${code.slice(0, injectIndex)}
inject: { ${injectObject} },
${code.slice(injectIndex)}`;
        }
      }
      return `<script setup>
${imports.join("\n")}
</script>
${code}`;
    }
  };
}

// node/vite/extendConfig.ts
import { join as join3 } from "node:path";
import { fileURLToPath as fileURLToPath2, pathToFileURL } from "node:url";
import { slash, uniq } from "@antfu/utils";
import { createResolve } from "mlly";
import { mergeConfig } from "vite";
var INCLUDE_GLOBAL = [
  "@typescript/ata",
  "file-saver",
  "lz-string",
  "prettier",
  "recordrtc",
  "typescript",
  "yaml",
  "html-to-image"
];
var INCLUDE_LOCAL = INCLUDE_GLOBAL.map((i) => `@slidev/cli > @slidev/client > ${i}`);
var EXCLUDE_GLOBAL = [
  "@antfu/utils",
  "@shikijs/monaco",
  "@shikijs/vitepress-twoslash/client",
  "@slidev/client",
  "@slidev/client/constants",
  "@slidev/client/context",
  "@slidev/client/logic/dark",
  "@slidev/parser",
  "@slidev/parser/core",
  "@slidev/rough-notation",
  "@slidev/types",
  "@unhead/vue",
  "@unocss/reset",
  "@vueuse/core",
  "@vueuse/math",
  "@vueuse/motion",
  "@vueuse/shared",
  "drauu",
  "floating-vue",
  "fuse.js",
  "mermaid",
  "monaco-editor",
  "shiki-magic-move/vue",
  "shiki",
  "shiki/core",
  "vue-demi",
  "vue-router",
  "vue"
];
var EXCLUDE_LOCAL = EXCLUDE_GLOBAL;
var ASYNC_MODULES = [
  "file-saver",
  "vue",
  "@vue"
];
function createConfigPlugin(options) {
  const resolveClientDep = createResolve({
    // Same as Vite's default resolve conditions
    conditions: ["import", "module", "browser", "default", options.mode === "build" ? "production" : "development"],
    url: pathToFileURL(options.clientRoot)
  });
  return {
    name: "slidev:config",
    async config(config) {
      const injection = {
        define: options.utils.define,
        resolve: {
          alias: [
            {
              find: /^@slidev\/client$/,
              replacement: `${toAtFS(options.clientRoot)}/index.ts`
            },
            {
              find: /^@slidev\/client\/(.*)/,
              replacement: `${toAtFS(options.clientRoot)}/$1`
            },
            {
              find: /^#slidev\/(.*)/,
              replacement: "/@slidev/$1"
            },
            {
              find: "vue",
              replacement: await resolveImportPath("vue/dist/vue.esm-bundler.js", true)
            },
            ...isInstalledGlobally.value ? await Promise.all(INCLUDE_GLOBAL.map(async (dep) => ({
              find: dep,
              replacement: fileURLToPath2(await resolveClientDep(dep))
            }))) : []
          ],
          dedupe: ["vue"]
        },
        optimizeDeps: isInstalledGlobally.value ? {
          exclude: EXCLUDE_GLOBAL,
          include: INCLUDE_GLOBAL
        } : {
          // We need to specify the full deps path for non-hoisted modules
          exclude: EXCLUDE_LOCAL,
          include: INCLUDE_LOCAL
        },
        css: {
          postcss: {
            plugins: [
              await import("postcss-nested").then((r) => (r.default || r)())
            ]
          }
        },
        server: {
          fs: {
            strict: true,
            allow: uniq([
              options.userWorkspaceRoot,
              options.clientRoot,
              // Special case for PNPM global installation
              isInstalledGlobally.value ? slash(options.cliRoot).replace(/\/\.pnpm\/.*$/gi, "") : options.cliRoot,
              ...options.roots
            ])
          }
        },
        publicDir: join3(options.userRoot, "public"),
        build: {
          rollupOptions: {
            output: {
              chunkFileNames(chunkInfo) {
                const DEFAULT = "assets/[name]-[hash].js";
                if (chunkInfo.name.includes("/"))
                  return DEFAULT;
                if (chunkInfo.moduleIds.filter((i) => isSlidevClient(i)).length > chunkInfo.moduleIds.length * 0.6)
                  return "assets/slidev/[name]-[hash].js";
                if (chunkInfo.moduleIds.filter((i) => i.match(/\/monaco-editor(-core)?\//)).length > chunkInfo.moduleIds.length * 0.6)
                  return "assets/monaco/[name]-[hash].js";
                return DEFAULT;
              },
              manualChunks(id) {
                if (id.startsWith("/@slidev-monaco-types/") || id.includes("/@slidev/monaco-types") || id.endsWith("?monaco-types&raw"))
                  return "monaco/bundled-types";
                if (id.includes("/shiki/") || id.includes("/@shikijs/"))
                  return `modules/shiki`;
                if (id.startsWith("~icons/"))
                  return "modules/unplugin-icons";
                const matchedAsyncModule = ASYNC_MODULES.find((i) => id.includes(`/node_modules/${i}`));
                if (matchedAsyncModule)
                  return `modules/${matchedAsyncModule.replace("@", "").replace("/", "-")}`;
              }
            }
          }
        },
        cacheDir: isInstalledGlobally.value ? join3(options.cliRoot, "node_modules/.vite") : void 0
      };
      function isSlidevClient(id) {
        return id.includes("/@slidev/") || id.includes("/slidev/packages/client/") || id.includes("/@vueuse/");
      }
      return mergeConfig(injection, config);
    },
    configureServer(server) {
      return () => {
        server.middlewares.use(async (req, res, next) => {
          if (req.url === "/index.html") {
            res.setHeader("Content-Type", "text/html");
            res.statusCode = 200;
            res.end(options.utils.indexHtml);
            return;
          }
          next();
        });
      };
    }
  };
}

// node/vite/hmrPatch.ts
function createHmrPatchPlugin() {
  return {
    name: "slidev:hmr-patch",
    transform(code, id) {
      if (!id.match(regexSlideSourceId))
        return;
      return code.replace("if (_rerender_only)", "if (false)");
    }
  };
}

// node/vite/icons.ts
import Icons from "unplugin-icons/vite";
function createIconsPlugin(options, pluginOptions) {
  return Icons({
    defaultClass: "slidev-icon",
    collectionsNodeResolvePath: options.utils.iconsResolvePath,
    ...pluginOptions.icons
  });
}

// node/vite/inspect.ts
async function createInspectPlugin(options, pluginOptions) {
  if (!options.inspect)
    return;
  const { default: PluginInspect } = await import("vite-plugin-inspect");
  return PluginInspect({
    dev: true,
    build: true,
    ...pluginOptions.inspect
  });
}

// node/vite/layoutWrapper.ts
import { bold, gray, red, yellow } from "kolorist";
function createLayoutWrapperPlugin({ data, utils }) {
  return {
    name: "slidev:layout-wrapper",
    async transform(code, id) {
      const match = id.match(regexSlideSourceId);
      if (!match)
        return;
      const [, no, type] = match;
      if (type !== "md")
        return;
      const index = +no - 1;
      const layouts = utils.getLayouts();
      const rawLayoutName = data.slides[index]?.frontmatter?.layout ?? data.slides[0]?.frontmatter?.defaults?.layout;
      let layoutName = rawLayoutName || (index === 0 ? "cover" : "default");
      if (!layouts[layoutName]) {
        console.error(red(`
Unknown layout "${bold(layoutName)}".${yellow(" Available layouts are:")}`) + Object.keys(layouts).map((i, idx) => (idx % 3 === 0 ? "\n    " : "") + gray(i.padEnd(15, " "))).join("  "));
        console.error();
        layoutName = "default";
      }
      const setupTag = code.match(/^<script setup.*>/m);
      if (!setupTag)
        throw new Error(`[Slidev] Internal error: <script setup> block not found in slide ${index + 1}.`);
      const templatePart = code.slice(0, setupTag.index);
      const scriptPart = code.slice(setupTag.index);
      const bodyStart = templatePart.indexOf("<template>") + 10;
      const bodyEnd = templatePart.lastIndexOf("</template>");
      let body = code.slice(bodyStart, bodyEnd).trim();
      if (body.startsWith("<div>") && body.endsWith("</div>"))
        body = body.slice(5, -6);
      return [
        templatePart.slice(0, bodyStart),
        `<InjectedLayout v-bind="_frontmatterToProps($frontmatter,${index})">
${body}
</InjectedLayout>`,
        templatePart.slice(bodyEnd),
        scriptPart.slice(0, setupTag[0].length),
        `import InjectedLayout from "${toAtFS(layouts[layoutName])}"`,
        templateImportContextUtils,
        templateInitContext,
        "$clicksContext.setup()",
        templateInjectionMarker,
        scriptPart.slice(setupTag[0].length)
      ].join("\n");
    }
  };
}

// node/vite/loaders.ts
import { notNullish, range } from "@antfu/utils";
import * as parser2 from "@slidev/parser/fs";
import equal from "fast-deep-equal";
import YAML2 from "yaml";

// node/virtual/configs.ts
import { isString } from "@antfu/utils";
var templateConfigs = {
  id: "/@slidev/configs",
  getContent({ data, remote }) {
    const config = {
      ...data.config,
      remote,
      slidesTitle: getSlideTitle(data)
    };
    if (isString(config.info))
      config.info = sharedMd.render(config.info);
    return `export default ${JSON.stringify(config)}`;
  }
};

// node/virtual/deprecated.ts
var templateLegacyRoutes = {
  id: "/@slidev/routes",
  getContent() {
    return [
      `export { slides } from '#slidev/slides'`,
      `console.warn('[slidev] #slidev/routes is deprecated, use #slidev/slides instead')`
    ].join("\n");
  }
};
var templateLegacyTitles = {
  id: "/@slidev/titles.md",
  getContent() {
    return `
<script setup lang="ts">
import TitleRenderer from '#slidev/title-renderer'
defineProps<{ no: number | string }>()
console.warn('/@slidev/titles.md is deprecated, import from #slidev/title-renderer instead')
</script>

<TitleRenderer :no="no" />
`;
  }
};

// node/virtual/global-layers.ts
import { existsSync } from "node:fs";
import { join as join4 } from "node:path";
var templateGlobalLayers = {
  id: `/@slidev/global-layers`,
  getContent({ roots }) {
    const imports = [];
    let n = 0;
    function getComponent(names) {
      const components = roots.flatMap((root) => names.map((name) => join4(root, name))).filter((i) => existsSync(i));
      imports.push(components.map((path4, i) => `import __n${n}_${i} from '${toAtFS(path4)}'`).join("\n"));
      const render = components.map((_, i) => `h(__n${n}_${i})`).join(",");
      n++;
      return `{ render: () => [${render}] }`;
    }
    const globalTop = getComponent(["global.vue", "global-top.vue", "GlobalTop.vue"]);
    const globalBottom = getComponent(["global-bottom.vue", "GlobalBottom.vue"]);
    const slideTop = getComponent(["slide-top.vue", "SlideTop.vue"]);
    const slideBottom = getComponent(["slide-bottom.vue", "SlideBottom.vue"]);
    return [
      imports.join("\n"),
      `import { h } from 'vue'`,
      `export const GlobalTop = ${globalTop}`,
      `export const GlobalBottom = ${globalBottom}`,
      `export const SlideTop = ${slideTop}`,
      `export const SlideBottom = ${slideBottom}`
    ].join("\n");
  }
};

// node/virtual/layouts.ts
import { objectMap } from "@antfu/utils";
var templateLayouts = {
  id: "/@slidev/layouts",
  getContent({ utils }) {
    const imports = [];
    const layouts = objectMap(
      utils.getLayouts(),
      (k, v) => {
        imports.push(`import __layout_${k} from "${toAtFS(v)}"`);
        return [k, `__layout_${k}`];
      }
    );
    return [
      imports.join("\n"),
      `export default {
${Object.entries(layouts).map(([k, v]) => `"${k}": ${v}`).join(",\n")}
}`
    ].join("\n\n");
  }
};

// node/virtual/monaco-deps.ts
import { resolve as resolve2 } from "node:path";
import { uniq as uniq2 } from "@antfu/utils";
var templateMonacoRunDeps = {
  id: "/@slidev/monaco-run-deps",
  async getContent({ userRoot, data }) {
    if (!data.features.monaco)
      return "";
    const deps = uniq2(data.features.monaco.deps.concat(data.config.monacoTypesAdditionalPackages));
    const importerPath = resolve2(userRoot, "./snippets/__importer__.ts");
    let result = "";
    for (let i = 0; i < deps.length; i++) {
      const specifier = deps[i];
      const resolved = await this.resolve(specifier, importerPath);
      if (!resolved)
        continue;
      result += `import * as vendored${i} from ${JSON.stringify(resolved.id)}
`;
    }
    result += "export default {\n";
    for (let i = 0; i < deps.length; i++)
      result += `${JSON.stringify(deps[i])}: vendored${i},
`;
    result += "}\n";
    return result;
  }
};

// node/virtual/monaco-types.ts
import { builtinModules } from "node:module";
import { join as join5, resolve as resolve3 } from "node:path";
import { uniq as uniq3 } from "@antfu/utils";
import fg from "fast-glob";
var templateMonacoTypes = {
  id: "/@slidev/monaco-types",
  getContent: async ({ userRoot, data, utils }) => {
    if (!data.features.monaco)
      return "";
    const typesRoot = join5(userRoot, "snippets");
    const files = await fg(["**/*.ts", "**/*.mts", "**/*.cts"], { cwd: typesRoot });
    let result = 'import { addFile } from "@slidev/client/setup/monaco.ts"\n';
    for (const file of files) {
      const url = `${toAtFS(resolve3(typesRoot, file))}?monaco-types&raw`;
      result += `addFile(() => import(${JSON.stringify(url)}), ${JSON.stringify(file)})
`;
    }
    function mapModuleNameToModule(moduleSpecifier) {
      if (moduleSpecifier.startsWith("node:"))
        return "node";
      if (builtinModules.includes(moduleSpecifier))
        return "node";
      const mainPackageName = moduleSpecifier.split("/")[0];
      if (builtinModules.includes(mainPackageName) && !mainPackageName.startsWith("@"))
        return "node";
      const [a = "", b = ""] = moduleSpecifier.split("/");
      const moduleName = a.startsWith("@") ? `${a}/${b}` : a;
      return moduleName;
    }
    let deps = [...data.config.monacoTypesAdditionalPackages];
    if (data.config.monacoTypesSource === "local")
      deps.push(...data.features.monaco.types);
    deps = uniq3(deps.map((specifier) => {
      if (specifier[0] === ".")
        return "";
      return mapModuleNameToModule(specifier);
    }).filter(Boolean));
    deps = deps.filter((pkg) => !utils.isMonacoTypesIgnored(pkg));
    for (const pkg of deps) {
      result += `import(${JSON.stringify(`/@slidev-monaco-types/resolve?${new URLSearchParams({ pkg })}`)})
`;
    }
    return result;
  }
};

// node/virtual/nav-controls.ts
import { existsSync as existsSync2 } from "node:fs";
import { join as join6 } from "node:path";
var templateNavControls = {
  id: "/@slidev/custom-nav-controls",
  getContent({ roots }) {
    const components = roots.flatMap((root) => {
      return [
        join6(root, "custom-nav-controls.vue"),
        join6(root, "CustomNavControls.vue")
      ];
    }).filter((i) => existsSync2(i));
    const imports = components.map((i, idx) => `import __n${idx} from '${toAtFS(i)}'`).join("\n");
    const render = components.map((i, idx) => `h(__n${idx})`).join(",");
    return `${imports}
import { h } from 'vue'
export default {
  render: () => [${render}],
}`;
  }
};

// node/virtual/setups.ts
import { existsSync as existsSync3 } from "node:fs";
import { join as join7 } from "node:path";
function createSetupTemplate(name) {
  return {
    id: `/@slidev/setups/${name}`,
    getContent({ roots }) {
      const setups = roots.flatMap((i) => {
        const path4 = join7(i, "setup", name);
        return [".ts", ".mts", ".js", ".mjs"].map((ext) => path4 + ext);
      }).filter((i) => existsSync3(i));
      const imports = [];
      setups.forEach((path4, idx) => {
        imports.push(`import __n${idx} from '${toAtFS(path4)}'`);
      });
      imports.push(`export default [${setups.map((_, idx) => `__n${idx}`).join(",")}]`);
      return imports.join("\n");
    }
  };
}
var setupModules = ["shiki", "code-runners", "monaco", "mermaid", "main", "root", "routes", "shortcuts", "context-menu"];
var templateSetups = setupModules.map(createSetupTemplate);

// node/virtual/shiki.ts
import { uniq as uniq4 } from "@antfu/utils";
var templateShiki = {
  id: "/@slidev/shiki",
  getContent: async ({ utils }) => {
    const options = utils.shikiOptions;
    const langs = await resolveLangs(options.langs || ["markdown", "vue", "javascript", "typescript", "html", "css"]);
    const resolvedThemeOptions = "themes" in options ? {
      themes: Object.fromEntries(await Promise.all(
        Object.entries(options.themes).map(async ([name, value]) => [name, await resolveTheme2(value)])
      ))
    } : {
      theme: await resolveTheme2(options.theme || "vitesse-dark")
    };
    const themes = resolvedThemeOptions.themes ? Object.values(resolvedThemeOptions.themes) : [resolvedThemeOptions.theme];
    const themeOptionsNames = resolvedThemeOptions.themes ? { themes: Object.fromEntries(Object.entries(resolvedThemeOptions.themes).map(([name, value]) => [name, typeof value === "string" ? value : value.name])) } : { theme: typeof resolvedThemeOptions.theme === "string" ? resolvedThemeOptions.theme : resolvedThemeOptions.theme.name };
    async function normalizeGetter(p) {
      const r = typeof p === "function" ? p() : p;
      return r.default || r;
    }
    async function resolveLangs(langs2) {
      const awaited = await Promise.all(langs2.map((lang) => normalizeGetter(lang)));
      return uniq4(awaited.flat());
    }
    async function resolveTheme2(theme) {
      return typeof theme === "string" ? theme : await normalizeGetter(theme);
    }
    const langsInit = await Promise.all(
      langs.map(async (lang) => typeof lang === "string" ? `import('${await resolveImportUrl(`shiki/langs/${lang}.mjs`)}')` : JSON.stringify(lang))
    );
    const themesInit = await Promise.all(themes.map(async (theme) => typeof theme === "string" ? `import('${await resolveImportUrl(`shiki/themes/${theme}.mjs`)}')` : JSON.stringify(theme)));
    const langNames = langs.flatMap((lang) => typeof lang === "string" ? lang : lang.name);
    const lines = [];
    lines.push(
      `import { createHighlighterCore } from "${await resolveImportUrl("shiki/core")}"`,
      `export { shikiToMonaco } from "${await resolveImportUrl("@shikijs/monaco")}"`,
      `export const languages = ${JSON.stringify(langNames)}`,
      `export const themes = ${JSON.stringify(themeOptionsNames.themes || themeOptionsNames.theme)}`,
      "export const shiki = createHighlighterCore({",
      `  themes: [${themesInit.join(",")}],`,
      `  langs: [${langsInit.join(",")}],`,
      `  loadWasm: import('${await resolveImportUrl("shiki/wasm")}'),`,
      "})",
      "let highlight",
      "export async function getHighlighter() {",
      "  if (highlight) return highlight",
      "  const highlighter = await shiki",
      "  highlight = (code, lang, options) => highlighter.codeToHtml(code, {",
      "    lang,",
      `    theme: ${JSON.stringify(themeOptionsNames.theme)},`,
      `    themes: ${JSON.stringify(themeOptionsNames.themes)},`,
      "    defaultColor: false,",
      "    ...options,",
      "  })",
      "  return highlight",
      "}"
    );
    return lines.join("\n");
  }
};

// node/virtual/slides.ts
var VIRTUAL_SLIDE_PREFIX = "/@slidev/slides/";
var templateSlides = {
  id: "/@slidev/slides",
  getContent({ data, utils }) {
    const layouts = utils.getLayouts();
    const statements = [
      `import { defineAsyncComponent, shallowRef } from 'vue'`,
      `import SlideError from '${layouts.error}'`,
      `import SlideLoading from '@slidev/client/internals/SlideLoading.vue'`,
      `const componentsCache = new Array(${data.slides.length})`,
      `const getAsyncComponent = (idx, loader) => defineAsyncComponent({`,
      `  loader,`,
      `  delay: 300,`,
      `  loadingComponent: SlideLoading,`,
      `  errorComponent: SlideError,`,
      `  onError: e => console.error('Failed to load slide ' + (idx + 1), e) `,
      `})`
    ];
    const slides = data.slides.map((_, idx) => {
      const no = idx + 1;
      statements.push(
        `import { meta as f${no} } from '${VIRTUAL_SLIDE_PREFIX}${no}/frontmatter'`,
        // For some unknown reason, import error won't be caught by the error component. Catch it here.
        `const load${no} = async () => {`,
        `  try { return componentsCache[${idx}] ??= await import('${VIRTUAL_SLIDE_PREFIX}${no}/md') }`,
        `  catch (e) { console.error('slide failed to load', e); return SlideError }`,
        `}`
      );
      return `{ no: ${no}, meta: f${no}, load: load${no}, component: getAsyncComponent(${idx}, load${no}) }`;
    });
    return [
      ...statements,
      `const data = [
${slides.join(",\n")}
]`,
      `if (import.meta.hot) {`,
      `  import.meta.hot.data.slides ??= shallowRef()`,
      `  import.meta.hot.data.slides.value = data`,
      `  import.meta.hot.dispose(() => componentsCache.length = 0)`,
      `  import.meta.hot.accept()`,
      `}`,
      `export const slides = import.meta.hot ? import.meta.hot.data.slides : shallowRef(data)`
    ].join("\n");
  }
};

// node/virtual/styles.ts
import { existsSync as existsSync4 } from "node:fs";
import { join as join8 } from "node:path";
var templateStyle = {
  id: "/@slidev/styles",
  async getContent({ data, clientRoot, roots }) {
    function resolveUrlOfClient(name) {
      return toAtFS(join8(clientRoot, name));
    }
    const imports = [
      `import "${resolveUrlOfClient("styles/vars.css")}"`,
      `import "${resolveUrlOfClient("styles/index.css")}"`,
      `import "${resolveUrlOfClient("styles/code.css")}"`,
      `import "${resolveUrlOfClient("styles/katex.css")}"`,
      `import "${resolveUrlOfClient("styles/transitions.css")}"`
    ];
    for (const root of roots) {
      const styles = [
        join8(root, "styles", "index.ts"),
        join8(root, "styles", "index.js"),
        join8(root, "styles", "index.css"),
        join8(root, "styles.css"),
        join8(root, "style.css")
      ];
      for (const style of styles) {
        if (existsSync4(style)) {
          imports.push(`import "${toAtFS(style)}"`);
          continue;
        }
      }
    }
    if (data.features.katex)
      imports.push(`import "${await resolveImportUrl("katex/dist/katex.min.css")}"`);
    if (data.config.highlighter === "shiki") {
      imports.push(
        `import "${await resolveImportUrl("@shikijs/vitepress-twoslash/style.css")}"`,
        `import "${resolveUrlOfClient("styles/shiki-twoslash.css")}"`,
        `import "${await resolveImportUrl("shiki-magic-move/style.css")}"`
      );
    }
    imports.unshift(
      `import "${await resolveImportUrl("@unocss/reset/tailwind.css")}"`,
      'import "uno:preflights.css"',
      'import "uno:typography.css"',
      'import "uno:shortcuts.css"'
    );
    imports.push('import "uno.css"');
    return imports.join("\n");
  }
};

// node/virtual/titles.ts
var templateTitleRendererMd = {
  id: "/@slidev/title-renderer.md",
  getContent({ data }) {
    const lines = data.slides.map(({ title }, i) => `<template ${i === 0 ? "v-if" : "v-else-if"}="no === ${i + 1}">

${title}

</template>`);
    lines.push(
      `<script setup lang="ts">`,
      `import { useSlideContext } from '@slidev/client/context.ts'`,
      `import { computed } from 'vue'`,
      `const props = defineProps<{ no?: number | string }>()`,
      `const { $page } = useSlideContext()`,
      `const no = computed(() => +(props.no ?? $page.value))`,
      `</script>`
    );
    return lines.join("\n");
  }
};
var templateTitleRenderer = {
  id: "/@slidev/title-renderer",
  async getContent() {
    return 'export { default } from "/@slidev/title-renderer.md"';
  }
};

// node/virtual/index.ts
var templates = [
  templateShiki,
  templateMonacoTypes,
  templateMonacoRunDeps,
  templateConfigs,
  templateStyle,
  templateGlobalLayers,
  templateNavControls,
  templateSlides,
  templateLayouts,
  templateTitleRenderer,
  templateTitleRendererMd,
  ...templateSetups,
  // Deprecated
  templateLegacyRoutes,
  templateLegacyTitles
];

// node/vite/loaders.ts
function renderNote(text = "") {
  let clickCount = 0;
  const html = sharedMd.render(
    text.replace(/\[click(?::(\d+))?\]/gi, (_, count = 1) => {
      clickCount += Number(count);
      return `<span class="slidev-note-click-mark" data-clicks="${clickCount}"></span>`;
    })
  );
  return html;
}
function withRenderedNote(data) {
  return {
    ...data,
    noteHTML: renderNote(data?.note)
  };
}
function createSlidesLoader(options, serverOptions) {
  const { data, mode, utils } = options;
  const hmrSlidesIndexes = /* @__PURE__ */ new Set();
  let server;
  let skipHmr = null;
  let sourceIds = resolveSourceIds(data);
  function resolveSourceIds(data2) {
    const ids = {
      md: [],
      frontmatter: []
    };
    for (const type of ["md", "frontmatter"]) {
      for (let i = 0; i < data2.slides.length; i++) {
        ids[type].push(`${data2.slides[i].source.filepath}__slidev_${i + 1}.${type}`);
      }
    }
    return ids;
  }
  function updateServerWatcher() {
    if (!server)
      return;
    server.watcher.add(Object.keys(data.watchFiles));
  }
  function getFrontmatter(pageNo) {
    return {
      ...data.headmatter?.defaults || {},
      ...data.slides[pageNo]?.frontmatter || {}
    };
  }
  return {
    name: "slidev:loader",
    enforce: "pre",
    configureServer(_server) {
      server = _server;
      updateServerWatcher();
      server.middlewares.use(async (req, res, next) => {
        const match = req.url?.match(regexSlideReqPath);
        if (!match)
          return next();
        const [, no] = match;
        const idx = Number.parseInt(no) - 1;
        if (req.method === "GET") {
          res.write(JSON.stringify(withRenderedNote(data.slides[idx])));
          return res.end();
        } else if (req.method === "POST") {
          const body = await getBodyJson(req);
          const slide = data.slides[idx];
          if (body.content && body.content !== slide.source.content)
            hmrSlidesIndexes.add(idx);
          if (body.content)
            slide.content = slide.source.content = body.content;
          if (body.frontmatterRaw != null) {
            if (body.frontmatterRaw.trim() === "") {
              slide.source.frontmatterDoc = slide.source.frontmatterStyle = void 0;
            } else {
              const parsed = YAML2.parseDocument(body.frontmatterRaw);
              if (parsed.errors.length)
                console.error("ERROR when saving frontmatter", parsed.errors);
              else
                slide.source.frontmatterDoc = parsed;
            }
          }
          if (body.note)
            slide.note = slide.source.note = body.note;
          if (body.frontmatter)
            updateFrontmatterPatch(slide, body.frontmatter);
          parser2.prettifySlide(slide.source);
          const fileContent = await parser2.save(data.markdownFiles[slide.source.filepath]);
          if (body.skipHmr) {
            skipHmr = {
              filePath: slide.source.filepath,
              fileContent
            };
            server?.moduleGraph.invalidateModule(
              server.moduleGraph.getModuleById(sourceIds.md[idx])
            );
            if (body.frontmatter) {
              server?.moduleGraph.invalidateModule(
                server.moduleGraph.getModuleById(sourceIds.frontmatter[idx])
              );
            }
          }
          res.statusCode = 200;
          res.write(JSON.stringify(withRenderedNote(slide)));
          return res.end();
        }
        next();
      });
    },
    async handleHotUpdate(ctx) {
      const forceChangedSlides = data.watchFiles[ctx.file];
      if (!forceChangedSlides)
        return;
      for (const index of forceChangedSlides) {
        hmrSlidesIndexes.add(index);
      }
      const newData = await serverOptions.loadData?.({
        [ctx.file]: await ctx.read()
      });
      if (!newData)
        return [];
      if (skipHmr && newData.markdownFiles[skipHmr.filePath]?.raw === skipHmr.fileContent) {
        skipHmr = null;
        return [];
      }
      const moduleIds = /* @__PURE__ */ new Set();
      const newSourceIds = resolveSourceIds(newData);
      for (const type of ["md", "frontmatter"]) {
        const old = sourceIds[type];
        const newIds = newSourceIds[type];
        for (let i = 0; i < newIds.length; i++) {
          if (old[i] !== newIds[i]) {
            moduleIds.add(`${VIRTUAL_SLIDE_PREFIX}${i + 1}/${type}`);
          }
        }
      }
      sourceIds = newSourceIds;
      if (data.slides.length !== newData.slides.length) {
        moduleIds.add(templateSlides.id);
      }
      if (!equal(data.headmatter.defaults, newData.headmatter.defaults)) {
        moduleIds.add(templateSlides.id);
        range(data.slides.length).map((i) => hmrSlidesIndexes.add(i));
      }
      if (!equal(data.config, newData.config))
        moduleIds.add(templateConfigs.id);
      if (!equal(data.features, newData.features)) {
        setTimeout(() => {
          ctx.server.hot.send({ type: "full-reload" });
        }, 1);
      }
      const length = Math.min(data.slides.length, newData.slides.length);
      for (let i = 0; i < length; i++) {
        const a = data.slides[i];
        const b = newData.slides[i];
        if (!hmrSlidesIndexes.has(i) && a.content.trim() === b.content.trim() && a.title?.trim() === b.title?.trim() && equal(a.frontmatter, b.frontmatter)) {
          if (a.note !== b.note) {
            ctx.server.hot.send(
              "slidev:update-note",
              {
                no: i + 1,
                note: b.note || "",
                noteHTML: renderNote(b.note || "")
              }
            );
          }
          continue;
        }
        ctx.server.hot.send(
          "slidev:update-slide",
          {
            no: i + 1,
            data: withRenderedNote(newData.slides[i])
          }
        );
        hmrSlidesIndexes.add(i);
      }
      Object.assign(data, newData);
      Object.assign(utils, createDataUtils(options));
      if (hmrSlidesIndexes.size > 0)
        moduleIds.add(templateTitleRendererMd.id);
      const vueModules = Array.from(hmrSlidesIndexes).flatMap((idx) => {
        const frontmatter = ctx.server.moduleGraph.getModuleById(sourceIds.frontmatter[idx]);
        const main = ctx.server.moduleGraph.getModuleById(sourceIds.md[idx]);
        const styles = main ? [...main.clientImportedModules].find((m) => m.id?.includes(`&type=style`)) : void 0;
        return [
          frontmatter,
          main,
          styles
        ];
      });
      hmrSlidesIndexes.clear();
      const moduleEntries = [
        ...ctx.modules.filter((i) => i.id === templateMonacoRunDeps.id || i.id === templateMonacoTypes.id),
        ...vueModules,
        ...Array.from(moduleIds).map((id) => ctx.server.moduleGraph.getModuleById(id))
      ].filter(notNullish).filter((i) => !i.id?.startsWith("/@id/@vite-icons"));
      updateServerWatcher();
      return moduleEntries;
    },
    resolveId: {
      order: "pre",
      handler(id) {
        if (id.startsWith("/@slidev/") || id.includes("__slidev_"))
          return id;
        return null;
      }
    },
    async load(id) {
      const template = templates.find((i) => i.id === id);
      if (template) {
        return {
          code: await template.getContent.call(this, options),
          map: { mappings: "" }
        };
      }
      const matchFacade = id.match(regexSlideFacadeId);
      if (matchFacade) {
        const [, no, type] = matchFacade;
        const idx = +no - 1;
        const sourceId = JSON.stringify(sourceIds[type][idx]);
        return [
          `export * from ${sourceId}`,
          `export { default } from ${sourceId}`
        ].join("\n");
      }
      const matchSource = id.match(regexSlideSourceId);
      if (matchSource) {
        const [, no, type] = matchSource;
        const idx = +no - 1;
        const slide = data.slides[idx];
        if (!slide)
          return;
        if (type === "md") {
          return {
            code: slide.content,
            map: { mappings: "" }
          };
        } else if (type === "frontmatter") {
          const slideBase = {
            ...withRenderedNote(slide),
            frontmatter: void 0,
            source: void 0,
            importChain: void 0,
            // remove raw content in build, optimize the bundle size
            ...mode === "build" ? { raw: "", content: "", note: "" } : {}
          };
          const fontmatter = getFrontmatter(idx);
          return {
            code: [
              "// @unocss-include",
              'import { computed, reactive, shallowReactive } from "vue"',
              `export const frontmatterData = ${JSON.stringify(fontmatter)}`,
              // handle HMR, update frontmatter with update
              "if (import.meta.hot) {",
              "  const firstLoad = !import.meta.hot.data.frontmatter",
              "  import.meta.hot.data.frontmatter ??= reactive(frontmatterData)",
              "  import.meta.hot.accept(({ frontmatterData: update }) => {",
              "    if (firstLoad) return",
              "    const frontmatter = import.meta.hot.data.frontmatter",
              "    Object.keys(frontmatter).forEach(key => {",
              "      if (!(key in update)) delete frontmatter[key]",
              "    })",
              "    Object.assign(frontmatter, update)",
              "  })",
              "}",
              "export const frontmatter = import.meta.hot ? import.meta.hot.data.frontmatter : reactive(frontmatterData)",
              "export default frontmatter",
              "export const meta = shallowReactive({",
              "  get layout(){ return frontmatter.layout },",
              "  get transition(){ return frontmatter.transition },",
              "  get class(){ return frontmatter.class },",
              "  get clicks(){ return frontmatter.clicks },",
              "  get name(){ return frontmatter.name },",
              "  get preload(){ return frontmatter.preload },",
              // No need to be reactive, as it's only used once after reload
              "  slide: {",
              `    ...(${JSON.stringify(slideBase)}),`,
              `    frontmatter,`,
              `    filepath: ${JSON.stringify(mode === "dev" ? slide.source.filepath : "")},`,
              `    start: ${JSON.stringify(slide.source.start)},`,
              `    id: ${idx},`,
              `    no: ${no},`,
              "  },",
              "  __clicksContext: null,",
              "  __preloaded: false,",
              "})"
            ].join("\n"),
            map: { mappings: "" }
          };
        }
      }
      if (data.markdownFiles[id])
        return "";
    }
  };
}

// node/vite/markdown.ts
import MagicString from "magic-string-stack";
import Markdown from "unplugin-vue-markdown/vite";

// ../../node_modules/.pnpm/@hedgedoc+markdown-it-plugins@2.1.4_patch_hash=tuyuxytl56b2vxulpkzt2wf4o4_markdown-it@14.1.0/node_modules/@hedgedoc/markdown-it-plugins/dist/esm/image-size/specialCharacters.js
var SpecialCharacters;
(function(SpecialCharacters2) {
  SpecialCharacters2[SpecialCharacters2["EXCLAMATION_MARK"] = 33] = "EXCLAMATION_MARK";
  SpecialCharacters2[SpecialCharacters2["OPENING_BRACKET"] = 91] = "OPENING_BRACKET";
  SpecialCharacters2[SpecialCharacters2["OPENING_PARENTHESIS"] = 40] = "OPENING_PARENTHESIS";
  SpecialCharacters2[SpecialCharacters2["WHITESPACE"] = 32] = "WHITESPACE";
  SpecialCharacters2[SpecialCharacters2["NEW_LINE"] = 10] = "NEW_LINE";
  SpecialCharacters2[SpecialCharacters2["EQUALS"] = 61] = "EQUALS";
  SpecialCharacters2[SpecialCharacters2["LOWER_CASE_X"] = 120] = "LOWER_CASE_X";
  SpecialCharacters2[SpecialCharacters2["NUMBER_ZERO"] = 48] = "NUMBER_ZERO";
  SpecialCharacters2[SpecialCharacters2["NUMBER_NINE"] = 57] = "NUMBER_NINE";
  SpecialCharacters2[SpecialCharacters2["PERCENTAGE"] = 37] = "PERCENTAGE";
  SpecialCharacters2[SpecialCharacters2["CLOSING_PARENTHESIS"] = 41] = "CLOSING_PARENTHESIS";
})(SpecialCharacters || (SpecialCharacters = {}));

// ../../node_modules/.pnpm/@hedgedoc+markdown-it-plugins@2.1.4_patch_hash=tuyuxytl56b2vxulpkzt2wf4o4_markdown-it@14.1.0/node_modules/@hedgedoc/markdown-it-plugins/dist/esm/task-lists/index.js
import Token from "markdown-it/lib/token.mjs";
var checkboxRegex = /^ *\[([\sx])] /i;
function taskLists(md, options = { enabled: false, label: false, lineNumber: false }) {
  md.core.ruler.after("inline", "task-lists", (state) => processToken(state, options));
  md.renderer.rules.taskListItemCheckbox = (tokens) => {
    const token = tokens[0];
    const checkedAttribute = token.attrGet("checked") ? 'checked="" ' : "";
    const disabledAttribute = token.attrGet("disabled") ? 'disabled="" ' : "";
    const line = token.attrGet("line");
    const idAttribute = `id="${token.attrGet("id")}" `;
    const dataLineAttribute = line && options.lineNumber ? `data-line="${line}" ` : "";
    return `<input class="task-list-item-checkbox" type="checkbox" ${checkedAttribute}${disabledAttribute}${dataLineAttribute}${idAttribute}/>`;
  };
  md.renderer.rules.taskListItemLabel_close = () => {
    return "</label>";
  };
  md.renderer.rules.taskListItemLabel_open = (tokens) => {
    const token = tokens[0];
    const id = token.attrGet("id");
    return `<label for="${id}">`;
  };
}
function processToken(state, options) {
  const allTokens = state.tokens;
  for (let i = 2; i < allTokens.length; i++) {
    if (!isTodoItem(allTokens, i)) {
      continue;
    }
    todoify(allTokens[i], options);
    allTokens[i - 2].attrJoin("class", `task-list-item ${options.enabled ? " enabled" : ""}`);
    const parentToken = findParentToken(allTokens, i - 2);
    if (parentToken) {
      const classes = parentToken.attrGet("class") ?? "";
      if (!classes.match(/(^| )contains-task-list/)) {
        parentToken.attrJoin("class", "contains-task-list");
      }
    }
  }
  return false;
}
function findParentToken(tokens, index) {
  const targetLevel = tokens[index].level - 1;
  for (let currentTokenIndex = index - 1; currentTokenIndex >= 0; currentTokenIndex--) {
    if (tokens[currentTokenIndex].level === targetLevel) {
      return tokens[currentTokenIndex];
    }
  }
  return void 0;
}
function isTodoItem(tokens, index) {
  return isInline(tokens[index]) && isParagraph(tokens[index - 1]) && isListItem(tokens[index - 2]) && startsWithTodoMarkdown(tokens[index]);
}
function todoify(token, options) {
  if (token.children == null) {
    return;
  }
  const id = generateIdForToken(token);
  token.children.splice(0, 0, createCheckboxToken(token, options.enabled, id));
  token.children[1].content = token.children[1].content.replace(checkboxRegex, "");
  if (options.label) {
    token.children.splice(1, 0, createLabelBeginToken(id));
    token.children.push(createLabelEndToken());
  }
}
function generateIdForToken(token) {
  if (token.map) {
    return `task-item-${token.map[0]}`;
  } else {
    return `task-item-${Math.ceil(Math.random() * (1e4 * 1e3) - 1e3)}`;
  }
}
function createCheckboxToken(token, enabled, id) {
  const checkbox = new Token("taskListItemCheckbox", "", 0);
  if (!enabled) {
    checkbox.attrSet("disabled", "true");
  }
  if (token.map) {
    checkbox.attrSet("line", token.map[0].toString());
  }
  checkbox.attrSet("id", id);
  const checkboxRegexResult = checkboxRegex.exec(token.content);
  const isChecked = checkboxRegexResult?.[1].toLowerCase() === "x";
  if (isChecked) {
    checkbox.attrSet("checked", "true");
  }
  return checkbox;
}
function createLabelBeginToken(id) {
  const labelBeginToken = new Token("taskListItemLabel_open", "", 1);
  labelBeginToken.attrSet("id", id);
  return labelBeginToken;
}
function createLabelEndToken() {
  return new Token("taskListItemLabel_close", "", -1);
}
function isInline(token) {
  return token.type === "inline";
}
function isParagraph(token) {
  return token.type === "paragraph_open";
}
function isListItem(token) {
  return token.type === "list_item_open";
}
function startsWithTodoMarkdown(token) {
  return checkboxRegex.test(token.content);
}

// node/syntax/markdown-it/index.ts
import MarkdownItFootnote from "markdown-it-footnote";
import MarkdownItMdc from "markdown-it-mdc";

// node/setups/load.ts
import { resolve as resolve4 } from "node:path";
import { deepMergeWithArray } from "@antfu/utils";
import fs3 from "fs-extra";
async function loadSetups(roots, filename, args, extraLoader) {
  const returns = [];
  for (const root of roots) {
    const path4 = resolve4(root, "setup", filename);
    if (fs3.existsSync(path4)) {
      const { default: setup } = await loadModule(path4);
      const ret = await setup(...args);
      if (ret)
        returns.push(ret);
    }
    if (extraLoader)
      returns.push(...await extraLoader(root));
  }
  return returns;
}

// node/setups/katex.ts
async function setupKatex(roots) {
  const options = await loadSetups(roots, "katex.ts", []);
  return Object.assign(
    { strict: false },
    ...options
  );
}

// node/syntax/markdown-it/markdown-it-escape-code.ts
function MarkdownItEscapeInlineCode(md) {
  const codeInline = md.renderer.rules.code_inline;
  md.renderer.rules.code_inline = (tokens, idx, options, env, self) => {
    const result = codeInline(tokens, idx, options, env, self);
    return result.replace(/^<code/, "<code v-pre");
  };
}

// node/syntax/markdown-it/markdown-it-katex.ts
import katex from "katex";
function isValidDelim(state, pos) {
  const max = state.posMax;
  let can_open = true;
  let can_close = true;
  const prevChar = pos > 0 ? state.src.charCodeAt(pos - 1) : -1;
  const nextChar = pos + 1 <= max ? state.src.charCodeAt(pos + 1) : -1;
  if (prevChar === 32 || prevChar === 9 || /* \t */
  nextChar >= 48 && nextChar <= 57)
    can_close = false;
  if (nextChar === 32 || nextChar === 9)
    can_open = false;
  return {
    can_open,
    can_close
  };
}
function math_inline(state, silent) {
  let match, token, res, pos;
  if (state.src[state.pos] !== "$")
    return false;
  res = isValidDelim(state, state.pos);
  if (!res.can_open) {
    if (!silent)
      state.pending += "$";
    state.pos += 1;
    return true;
  }
  const start = state.pos + 1;
  match = start;
  while ((match = state.src.indexOf("$", match)) !== -1) {
    pos = match - 1;
    while (state.src[pos] === "\\") pos -= 1;
    if ((match - pos) % 2 === 1)
      break;
    match += 1;
  }
  if (match === -1) {
    if (!silent)
      state.pending += "$";
    state.pos = start;
    return true;
  }
  if (match - start === 0) {
    if (!silent)
      state.pending += "$$";
    state.pos = start + 1;
    return true;
  }
  res = isValidDelim(state, match);
  if (!res.can_close) {
    if (!silent)
      state.pending += "$";
    state.pos = start;
    return true;
  }
  if (!silent) {
    token = state.push("math_inline", "math", 0);
    token.markup = "$";
    token.content = state.src.slice(start, match);
  }
  state.pos = match + 1;
  return true;
}
function math_block(state, start, end, silent) {
  let firstLine;
  let lastLine;
  let next;
  let lastPos;
  let found = false;
  let pos = state.bMarks[start] + state.tShift[start];
  let max = state.eMarks[start];
  if (pos + 2 > max)
    return false;
  if (state.src.slice(pos, pos + 2) !== "$$")
    return false;
  pos += 2;
  firstLine = state.src.slice(pos, max);
  if (silent)
    return true;
  if (firstLine.trim().slice(-2) === "$$") {
    firstLine = firstLine.trim().slice(0, -2);
    found = true;
  }
  for (next = start; !found; ) {
    next++;
    if (next >= end)
      break;
    pos = state.bMarks[next] + state.tShift[next];
    max = state.eMarks[next];
    if (pos < max && state.tShift[next] < state.blkIndent) {
      break;
    }
    if (state.src.slice(pos, max).trim().slice(-2) === "$$") {
      lastPos = state.src.slice(0, max).lastIndexOf("$$");
      lastLine = state.src.slice(pos, lastPos);
      found = true;
    }
  }
  state.line = next + 1;
  const token = state.push("math_block", "math", 0);
  token.block = true;
  token.content = (firstLine && firstLine.trim() ? `${firstLine}
` : "") + state.getLines(start + 1, next, state.tShift[start], true) + (lastLine && lastLine.trim() ? lastLine : "");
  token.map = [start, state.line];
  token.markup = "$$";
  return true;
}
function MarkdownItKatex(md, options) {
  const katexInline = function(latex) {
    options.displayMode = false;
    try {
      return katex.renderToString(latex, options);
    } catch (error) {
      if (options.throwOnError)
        console.warn(error);
      return latex;
    }
  };
  const inlineRenderer = function(tokens, idx) {
    return katexInline(tokens[idx].content);
  };
  const katexBlock = function(latex) {
    options.displayMode = true;
    try {
      return `<p>${katex.renderToString(latex, options)}</p>`;
    } catch (error) {
      if (options.throwOnError)
        console.warn(error);
      return latex;
    }
  };
  const blockRenderer = function(tokens, idx) {
    return `${katexBlock(tokens[idx].content)}
`;
  };
  md.inline.ruler.after("escape", "math_inline", math_inline);
  md.block.ruler.after("blockquote", "math_block", math_block, {
    alt: ["paragraph", "reference", "blockquote", "list"]
  });
  md.renderer.rules.math_inline = inlineRenderer;
  md.renderer.rules.math_block = blockRenderer;
}

// node/syntax/markdown-it/markdown-it-shiki.ts
import { isTruthy } from "@antfu/utils";
import { fromHighlighter } from "@shikijs/markdown-it/core";

// node/syntax/transform/utils.ts
function normalizeRangeStr(rangeStr = "") {
  return !rangeStr.trim() ? [] : rangeStr.trim().split(/\|/g).map((i) => i.trim());
}
function getCodeBlocks(md) {
  const codeblocks = Array.from(md.matchAll(/^```[\s\S]*?^```/gm)).map((m) => {
    const start = m.index;
    const end = m.index + m[0].length;
    const startLine = md.slice(0, start).match(/\n/g)?.length || 0;
    const endLine = md.slice(0, end).match(/\n/g)?.length || 0;
    return [start, end, startLine, endLine];
  });
  return {
    codeblocks,
    isInsideCodeblocks(idx) {
      return codeblocks.some(([s, e]) => s <= idx && idx <= e);
    },
    isLineInsideCodeblocks(line) {
      return codeblocks.some(([, , s, e]) => s <= line && line <= e);
    }
  };
}
function escapeVueInCode(md) {
  return md.replace(/\{\{/g, "&lbrace;&lbrace;");
}

// node/syntax/markdown-it/markdown-it-shiki.ts
async function MarkdownItShiki({ data: { config }, mode, utils }) {
  const transformers = [
    ...utils.shikiOptions.transformers || [],
    (config.twoslash === true || config.twoslash === mode) && (await import("@shikijs/vitepress-twoslash")).transformerTwoslash({
      explicitTrigger: true,
      twoslashOptions: {
        handbookOptions: {
          noErrorValidation: true
        }
      }
    }),
    {
      pre(pre) {
        this.addClassToHast(pre, "slidev-code");
        delete pre.properties.tabindex;
      },
      postprocess(code) {
        return escapeVueInCode(code);
      }
    }
  ].filter(isTruthy);
  return fromHighlighter(utils.shiki, {
    ...utils.shikiOptions,
    transformers
  });
}

// node/syntax/markdown-it/markdown-it-v-drag.ts
import { SourceMapConsumer } from "source-map-js";
var dragComponentRegex = /<(v-?drag-?\w*)([\s>])/i;
var dragDirectiveRegex = /(?<![</\w])v-drag(=".*?")?/i;
function MarkdownItVDrag(md, markdownTransformMap) {
  const visited = /* @__PURE__ */ new WeakSet();
  const sourceMapConsumers = /* @__PURE__ */ new WeakMap();
  function getSourceMapConsumer(id) {
    const s = markdownTransformMap.get(id);
    if (!s)
      return void 0;
    let smc = sourceMapConsumers.get(s);
    if (smc)
      return smc;
    const sourceMap = s.generateMap();
    smc = new SourceMapConsumer({
      ...sourceMap,
      version: sourceMap.version.toString()
    });
    sourceMapConsumers.set(s, smc);
    return smc;
  }
  const _parse = md.parse;
  md.parse = function(src, env) {
    const smc = getSourceMapConsumer(env.id);
    const toOriginalPos = smc ? (line) => smc.originalPositionFor({ line: line + 1, column: 0 }).line - 1 : (line) => line;
    function toMarkdownSource(map, idx) {
      const start = toOriginalPos(map[0]);
      const end = toOriginalPos(map[1]);
      return `[${start},${Math.max(start + 1, end)},${idx}]`;
    }
    function replaceChildren(token, regex, replacement) {
      for (const child of token.children ?? []) {
        if (child.type === "html_block" || child.type === "html_inline") {
          child.content = child.content.replace(regex, replacement);
        }
        replaceChildren(child, regex, replacement);
      }
    }
    return _parse.call(this, src, env).map((token) => {
      if (!["html_block", "html_inline", "inline"].includes(token.type) || !token.content.includes("drag") || visited.has(token))
        return token;
      token.content = token.content.replace(dragComponentRegex, (_, tag, space, idx) => {
        const replacement = `<${tag} :markdownSource="${toMarkdownSource(token.map, idx)}"${space}`;
        replaceChildren(token, dragComponentRegex, replacement);
        return replacement;
      }).replace(dragDirectiveRegex, (_, value, idx) => {
        const replacement = `v-drag${value ?? ""} :markdownSource="${toMarkdownSource(token.map, idx)}"`;
        replaceChildren(token, dragDirectiveRegex, replacement);
        return replacement;
      });
      visited.add(token);
      return token;
    });
  };
}

// node/syntax/markdown-it/index.ts
async function useMarkdownItPlugins(md, options, markdownTransformMap) {
  const { roots, data: { features, config } } = options;
  if (config.highlighter === "shiki") {
    md.use(await MarkdownItShiki(options));
  }
  md.use(MarkdownItLink);
  md.use(MarkdownItEscapeInlineCode);
  md.use(MarkdownItFootnote);
  md.use(taskLists, { enabled: true, lineNumber: true, label: true });
  if (features.katex)
    md.use(MarkdownItKatex, await setupKatex(roots));
  md.use(MarkdownItVDrag, markdownTransformMap);
  if (config.mdc)
    md.use(MarkdownItMdc);
}

// node/setups/transformers.ts
async function setupTransformers(roots) {
  const returns = await loadSetups(roots, "transformers.ts", []);
  const result = {
    pre: [],
    preCodeblock: [],
    postCodeblock: [],
    post: []
  };
  for (const r of [...returns].reverse()) {
    if (r.pre)
      result.pre.push(...r.pre);
    if (r.preCodeblock)
      result.preCodeblock.push(...r.preCodeblock);
  }
  for (const r of returns) {
    if (r.postCodeblock)
      result.postCodeblock.push(...r.postCodeblock);
    if (r.post)
      result.post.push(...r.post);
  }
  return result;
}

// node/syntax/transform/code-wrapper.ts
var reCodeBlock = /^```([\w'-]+)?\s*(?:\{([\w*,|-]+)\}\s*?(\{[^}]*\})?([^\r\n]*))?\r?\n([ \t]*\S[\s\S]*?)^```$/gm;
function transformCodeWrapper(ctx) {
  ctx.s.replace(
    reCodeBlock,
    (full, lang = "", rangeStr = "", options = "", attrs = "", code) => {
      const ranges = normalizeRangeStr(rangeStr);
      code = code.trimEnd();
      options = options.trim() || "{}";
      return `
<CodeBlockWrapper v-bind="${options}" :ranges='${JSON.stringify(ranges)}'>

\`\`\`${lang}${attrs}
${code}
\`\`\`

</CodeBlockWrapper>`;
    }
  );
}

// node/syntax/transform/in-page-css.ts
function transformPageCSS(ctx) {
  const codeBlocks = getCodeBlocks(ctx.s.original);
  ctx.s.replace(
    /(\n<style[^>]*>)([\s\S]+?)(<\/style>)/g,
    (full, start, css, end, index) => {
      if (codeBlocks.isInsideCodeblocks(index))
        return full;
      if (!start.includes("scoped"))
        start = start.replace("<style", "<style scoped");
      return `${start}
${css}${end}`;
    }
  );
}

// node/syntax/transform/katex-wrapper.ts
function transformKaTexWrapper(ctx) {
  ctx.s.replace(
    /^\$\$(?:\s*\{([\w*,|-]+)\}\s*?(?:(\{[^}]*\})\s*?)?)?\n(\S[\s\S]*?)^\$\$/gm,
    (full, rangeStr = "", options = "", code) => {
      const ranges = !rangeStr.trim() ? [] : rangeStr.trim().split(/\|/g).map((i) => i.trim());
      code = code.trimEnd();
      options = options.trim() || "{}";
      return `<KaTexBlockWrapper v-bind="${options}" :ranges='${JSON.stringify(ranges)}'>

$$
${code}
$$
</KaTexBlockWrapper>
`;
    }
  );
}

// node/syntax/transform/magic-move.ts
import lz from "lz-string";
import { codeToKeyedTokens } from "shiki-magic-move/core";
var reMagicMoveBlock = /^````(?:md|markdown) magic-move *(\{[^}]*\})?([^ \n]*)\n([\s\S]+?)^````$/gm;
function parseLineNumbersOption(options) {
  return /lines: *true/.test(options) ? true : /lines: *false/.test(options) ? false : void 0;
}
function transformMagicMove(ctx) {
  ctx.s.replace(
    reMagicMoveBlock,
    (full, options = "{}", _attrs = "", body) => {
      const matches = Array.from(body.matchAll(reCodeBlock));
      if (!matches.length)
        throw new Error("Magic Move block must contain at least one code block");
      const defaultLineNumbers = parseLineNumbersOption(options) ?? ctx.options.data.config.lineNumbers;
      const ranges = matches.map((i) => normalizeRangeStr(i[2]));
      const steps = matches.map((i) => {
        const lineNumbers = parseLineNumbersOption(i[3]) ?? defaultLineNumbers;
        return codeToKeyedTokens(ctx.options.utils.shiki, i[5].trimEnd(), {
          ...ctx.options.utils.shikiOptions,
          lang: i[1]
        }, lineNumbers);
      });
      const compressed = lz.compressToBase64(JSON.stringify(steps));
      return `<ShikiMagicMove v-bind="${options}" steps-lz="${compressed}" :step-ranges='${JSON.stringify(ranges)}' />`;
    }
  );
}

// node/syntax/transform/mermaid.ts
import lz2 from "lz-string";
function transformMermaid(ctx) {
  ctx.s.replace(
    /^```mermaid *(\{[^\n]*\})?\n([\s\S]+?)\n```/gm,
    (full, options = "", code = "") => {
      code = code.trim();
      options = options.trim() || "{}";
      const encoded = lz2.compressToBase64(code);
      return `<Mermaid code-lz="${encoded}" v-bind="${options}" />`;
    }
  );
}

// node/syntax/transform/monaco.ts
import lz3 from "lz-string";
function transformMonaco(ctx) {
  const enabled = ctx.options.data.config.monaco === true || ctx.options.data.config.monaco === ctx.options.mode;
  if (!enabled) {
    ctx.s.replace(/\{monaco([\w:,-]*)\}/g, "");
    return;
  }
  ctx.s.replace(
    /^```(\w+) *\{monaco-diff\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^~~~ *\n([\s\S]+?)^```/gm,
    (full, lang = "ts", options = "{}", code, diff) => {
      lang = lang.trim();
      options = options.trim() || "{}";
      const encoded = lz3.compressToBase64(code);
      const encodedDiff = lz3.compressToBase64(diff);
      return `<Monaco code-lz="${encoded}" diff-lz="${encodedDiff}" lang="${lang}" v-bind="${options}" />`;
    }
  );
  ctx.s.replace(
    /^```(\w+) *\{monaco\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^```/gm,
    (full, lang = "ts", options = "{}", code) => {
      lang = lang.trim();
      options = options.trim() || "{}";
      const encoded = lz3.compressToBase64(code);
      return `<Monaco code-lz="${encoded}" lang="${lang}" v-bind="${options}" />`;
    }
  );
  ctx.s.replace(
    /^```(\w+) *\{monaco-run\} *(?:(\{[^\n]*\}) *)?\n([\s\S]+?)^```/gm,
    (full, lang = "ts", options = "{}", code) => {
      lang = lang.trim();
      options = options.trim() || "{}";
      const encoded = lz3.compressToBase64(code);
      return `<Monaco runnable code-lz="${encoded}" lang="${lang}" v-bind="${options}" />`;
    }
  );
}

// node/syntax/transform/plant-uml.ts
import { encode as encodePlantUml } from "plantuml-encoder";
function transformPlantUml(ctx) {
  const server = ctx.options.data.config.plantUmlServer;
  ctx.s.replace(
    /^```plantuml[^\n{}]*(\{[^}\n]*\})?\n([\s\S]+?)\n```/gm,
    (full, options = "", content = "") => {
      const code = encodePlantUml(content.trim());
      options = options.trim() || "{}";
      return `<PlantUml :code="'${code}'" :server="'${server}'" v-bind="${options}" />`;
    }
  );
}

// node/syntax/transform/slot-sugar.ts
function transformSlotSugar(ctx) {
  const linesWithNewline = ctx.s.original.split(/(\r?\n)/g);
  const codeBlocks = getCodeBlocks(ctx.s.original);
  const lines = [];
  for (let i = 0; i < linesWithNewline.length; i += 2) {
    const line = linesWithNewline[i];
    const newline = linesWithNewline[i + 1] || "";
    lines.push(line + newline);
  }
  let prevSlot = false;
  let offset = 0;
  lines.forEach((line) => {
    const start = offset;
    offset += line.length;
    if (codeBlocks.isInsideCodeblocks(offset))
      return;
    const match = line.match(/^::\s*([\w.\-:]+)\s*::(\s*)$/);
    if (match) {
      ctx.s.overwrite(start, offset - match[2].length, `${prevSlot ? "\n\n</template>\n" : "\n"}<template v-slot:${match[1]}="slotProps">
`);
      prevSlot = true;
    }
  });
  if (prevSlot)
    ctx.s.append("\n\n</template>");
}

// node/syntax/transform/snippet.ts
import path2 from "node:path";
import { slash as slash2 } from "@antfu/utils";
import fs5 from "fs-extra";
import lz4 from "lz-string";

// node/vite/monacoWrite.ts
import fs4 from "node:fs/promises";
import path from "node:path";
var monacoWriterWhitelist = /* @__PURE__ */ new Set();
function createMonacoWriterPlugin({ userRoot }) {
  return {
    name: "slidev:monaco-write",
    apply: "serve",
    configureServer(server) {
      server.ws.on("connection", (socket) => {
        socket.on("message", async (data) => {
          let json;
          try {
            json = JSON.parse(data.toString());
          } catch {
            return;
          }
          if (json.type === "custom" && json.event === "slidev:monaco-write") {
            const { file, content } = json.data;
            if (!monacoWriterWhitelist.has(file)) {
              console.error(`[Slidev] Unauthorized file write: ${file}`);
              return;
            }
            const filepath = path.join(userRoot, file);
            console.log("[Slidev] Writing file:", filepath);
            await fs4.writeFile(filepath, content, "utf-8");
          }
        });
      });
    }
  };
}

// node/syntax/transform/snippet.ts
function dedent(text) {
  const lines = text.split("\n");
  const minIndentLength = lines.reduce((acc, line) => {
    for (let i = 0; i < line.length; i++) {
      if (line[i] !== " " && line[i] !== "	")
        return Math.min(i, acc);
    }
    return acc;
  }, Number.POSITIVE_INFINITY);
  if (minIndentLength < Number.POSITIVE_INFINITY)
    return lines.map((x) => x.slice(minIndentLength)).join("\n");
  return text;
}
function findRegion(lines, regionName) {
  const regionRegexps = [
    // javascript, typescript, java
    [/^\/\/ ?#?region ([\w*-]+)$/, /^\/\/ ?#?endregion/],
    // css, less, scss
    [/^\/\* ?#region ([\w*-]+) ?\*\/$/, /^\/\* ?#endregion[\s\w*-]*\*\/$/],
    // C, C++
    [/^#pragma region ([\w*-]+)$/, /^#pragma endregion/],
    // HTML, markdown
    [/^<!-- #?region ([\w*-]+) -->$/, /^<!-- #?region[\s\w*-]*-->$/],
    // Visual Basic
    [/^#Region ([\w*-]+)$/, /^#End Region/],
    // Bat
    [/^::#region ([\w*-]+)$/, /^::#endregion/],
    // C#, PHP, Powershell, Python, perl & misc
    [/^# ?region ([\w*-]+)$/, /^# ?endregion/]
  ];
  let endReg = null;
  let start = -1;
  for (const [lineId, line] of lines.entries()) {
    if (endReg === null) {
      for (const [startReg, end] of regionRegexps) {
        const match = line.trim().match(startReg);
        if (match && match[1] === regionName) {
          start = lineId + 1;
          endReg = end;
          break;
        }
      }
    } else if (endReg.test(line.trim())) {
      return {
        start,
        end: lineId,
        regexp: endReg
      };
    }
  }
  return null;
}
var reMonacoWrite = /^\{monaco-write\}/;
function transformSnippet({ s, slide, options }) {
  const watchFiles = options.data.watchFiles;
  const dir = path2.dirname(slide.source?.filepath ?? options.entry ?? options.userRoot);
  s.replace(
    // eslint-disable-next-line regexp/no-super-linear-backtracking
    /^<<<\s*(\S.*?)(#[\w-]+)?\s*(?:\s(\S+?))?\s*(\{.*)?$/gm,
    (full, filepath = "", regionName = "", lang = "", meta = "") => {
      const src = slash2(
        /^@\//.test(filepath) ? path2.resolve(options.userRoot, filepath.slice(2)) : path2.resolve(dir, filepath)
      );
      meta = meta.trim();
      lang = lang.trim();
      lang = lang || path2.extname(filepath).slice(1);
      const isAFile = fs5.statSync(src).isFile();
      if (!fs5.existsSync(src) || !isAFile) {
        throw new Error(isAFile ? `Code snippet path not found: ${src}` : `Invalid code snippet option`);
      }
      let content = fs5.readFileSync(src, "utf8");
      if (regionName) {
        const lines = content.split(/\r?\n/);
        const region = findRegion(lines, regionName.slice(1));
        if (region) {
          content = dedent(
            lines.slice(region.start, region.end).filter((line) => !region.regexp.test(line.trim())).join("\n")
          );
        }
      }
      if (meta.match(reMonacoWrite)) {
        monacoWriterWhitelist.add(filepath);
        lang = lang.trim();
        meta = meta.replace(reMonacoWrite, "").trim() || "{}";
        const encoded = lz4.compressToBase64(content);
        return `<Monaco writable=${JSON.stringify(filepath)} code-lz="${encoded}" lang="${lang}" v-bind="${meta}" />`;
      } else {
        watchFiles[src] ??= /* @__PURE__ */ new Set();
        watchFiles[src].add(slide.index);
      }
      return `\`\`\`${lang} ${meta}
${content}
\`\`\``;
    }
  );
}

// node/syntax/transform/index.ts
async function getMarkdownTransformers(options) {
  const extras = await setupTransformers(options.roots);
  return [
    ...extras.pre,
    transformSnippet,
    options.data.config.highlighter === "shiki" && transformMagicMove,
    ...extras.preCodeblock,
    transformMermaid,
    transformPlantUml,
    options.data.features.monaco && transformMonaco,
    ...extras.postCodeblock,
    transformCodeWrapper,
    options.data.features.katex && transformKaTexWrapper,
    transformPageCSS,
    transformSlotSugar,
    ...extras.post
  ];
}

// node/vite/markdown.ts
async function createMarkdownPlugin(options, { markdown: mdOptions }) {
  const markdownTransformMap = /* @__PURE__ */ new Map();
  const transformers = await getMarkdownTransformers(options);
  return Markdown({
    include: [/\.md$/],
    wrapperClasses: "",
    headEnabled: false,
    frontmatter: false,
    escapeCodeTagInterpolation: false,
    markdownItOptions: {
      quotes: `""''`,
      html: true,
      xhtmlOut: true,
      linkify: true,
      ...mdOptions?.markdownItOptions
    },
    ...mdOptions,
    async markdownItSetup(md) {
      await useMarkdownItPlugins(md, options, markdownTransformMap);
      await mdOptions?.markdownItSetup?.(md);
    },
    transforms: {
      ...mdOptions?.transforms,
      before(code, id) {
        if (options.data.markdownFiles[id])
          return "";
        code = mdOptions?.transforms?.before?.(code, id) ?? code;
        const match = id.match(regexSlideSourceId);
        if (!match)
          return code;
        const s = new MagicString(code);
        markdownTransformMap.set(id, s);
        const ctx = {
          s,
          slide: options.data.slides[+match[1] - 1],
          options
        };
        for (const transformer of transformers) {
          if (!transformer)
            continue;
          transformer(ctx);
          if (!ctx.s.isEmpty())
            ctx.s.commit();
        }
        return s.toString();
      }
    }
  });
}

// node/vite/monacoTypes.ts
import fs6 from "node:fs/promises";
import { dirname, resolve as resolve5 } from "node:path";
import { slash as slash3 } from "@antfu/utils";
import fg2 from "fast-glob";
import { findDepPkgJsonPath } from "vitefu";
function createMonacoTypesLoader({ userRoot, utils }) {
  return {
    name: "slidev:monaco-types-loader",
    resolveId(id) {
      if (id.startsWith("/@slidev-monaco-types/"))
        return id;
      return null;
    },
    async load(id) {
      if (!id.startsWith("/@slidev-monaco-types/"))
        return null;
      const url = new URL(id, "http://localhost");
      if (url.pathname === "/@slidev-monaco-types/resolve") {
        const query = new URLSearchParams(url.search);
        const pkg = query.get("pkg");
        const importer = query.get("importer") ?? userRoot;
        const pkgJsonPath = await findDepPkgJsonPath(pkg, importer);
        if (!pkgJsonPath)
          throw new Error(`Package "${pkg}" not found in "${importer}"`);
        const root = slash3(dirname(pkgJsonPath));
        const pkgJson = JSON.parse(await fs6.readFile(pkgJsonPath, "utf-8"));
        let deps = Object.keys(pkgJson.dependencies ?? {});
        deps = deps.filter((pkg2) => !utils.isMonacoTypesIgnored(pkg2));
        return [
          `import "/@slidev-monaco-types/load?${new URLSearchParams({ root, name: pkgJson.name })}"`,
          ...deps.map((dep) => `import "/@slidev-monaco-types/resolve?${new URLSearchParams({ pkg: dep, importer: root })}"`)
        ].join("\n");
      }
      if (url.pathname === "/@slidev-monaco-types/load") {
        const query = new URLSearchParams(url.search);
        const root = query.get("root");
        const name = query.get("name");
        const files = await fg2(
          [
            "**/*.ts",
            "**/*.mts",
            "**/*.cts",
            "package.json"
          ],
          {
            cwd: root,
            followSymbolicLinks: true,
            ignore: ["**/node_modules/**"]
          }
        );
        if (!files.length)
          return "/** No files found **/";
        return [
          'import { addFile } from "@slidev/client/setup/monaco.ts"',
          ...files.map((file) => `addFile(() => import(${JSON.stringify(`${toAtFS(resolve5(root, file))}?monaco-types&raw`)}), ${JSON.stringify(`node_modules/${name}/${file}`)})`)
        ].join("\n");
      }
    }
  };
}

// node/vite/remoteAssets.ts
async function createRemoteAssetsPlugin({ data: { config }, mode }, pluginOptions) {
  if (!(config.remoteAssets === true || config.remoteAssets === mode))
    return;
  const { VitePluginRemoteAssets, DefaultRules } = await import("vite-plugin-remote-assets");
  return VitePluginRemoteAssets({
    resolveMode: (id) => id.endsWith("index.html") ? "relative" : "@fs",
    awaitDownload: mode === "build",
    ...pluginOptions.remoteAssets,
    rules: [
      ...DefaultRules,
      {
        match: /\b(https?:\/\/image.unsplash\.com.*?)(?=[`'")\]])/gi,
        ext: ".png"
      },
      ...pluginOptions.remoteAssets?.rules ?? []
    ]
  });
}

// node/vite/serverRef.ts
import ServerRef from "vite-plugin-vue-server-ref";

// node/integrations/drawings.ts
import { basename, dirname as dirname2, join as join9, resolve as resolve6 } from "node:path";
import fg3 from "fast-glob";
import fs7 from "fs-extra";
function resolveDrawingsDir(options) {
  return options.data.config.drawings.persist ? resolve6(
    dirname2(options.entry),
    options.data.config.drawings.persist
  ) : void 0;
}
async function loadDrawings(options) {
  const dir = resolveDrawingsDir(options);
  if (!dir || !fs7.existsSync(dir))
    return {};
  const files = await fg3("*.svg", {
    onlyFiles: true,
    cwd: dir,
    absolute: true,
    suppressErrors: true
  });
  const obj = {};
  await Promise.all(files.map(async (path4) => {
    const num = +basename(path4, ".svg");
    if (Number.isNaN(num))
      return;
    const content = await fs7.readFile(path4, "utf8");
    const lines = content.split(/\n/g);
    obj[num.toString()] = lines.slice(1, -1).join("\n");
  }));
  return obj;
}
async function writeDrawings(options, drawing) {
  const dir = resolveDrawingsDir(options);
  if (!dir)
    return;
  const width = options.data.config.canvasWidth;
  const height = Math.round(width / options.data.config.aspectRatio);
  const SVG_HEAD = `<svg width="${width}" height="${height}" xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink">`;
  await fs7.ensureDir(dir);
  return Promise.all(
    Object.entries(drawing).map(async ([key, value]) => {
      if (!value)
        return;
      const svg = `${SVG_HEAD}
${value}
</svg>`;
      await fs7.writeFile(join9(dir, `${key}.svg`), svg, "utf-8");
    })
  );
}

// node/integrations/snapshots.ts
import { dirname as dirname3, join as join10, resolve as resolve7 } from "node:path";
import fs8 from "fs-extra";
function resolveSnapshotsDir(options) {
  return resolve7(dirname3(options.entry), ".slidev/snapshots");
}
async function loadSnapshots(options) {
  const dir = resolveSnapshotsDir(options);
  const file = join10(dir, "snapshots.json");
  if (!dir || !fs8.existsSync(file))
    return {};
  return JSON.parse(await fs8.readFile(file, "utf8"));
}
async function writeSnapshots(options, data) {
  const dir = resolveSnapshotsDir(options);
  if (!dir)
    return;
  await fs8.ensureDir(dir);
  await fs8.writeFile(join10(dir, "snapshots.json"), JSON.stringify(data, null, 2), "utf-8");
}

// node/vite/serverRef.ts
async function createServerRefPlugin(options, pluginOptions) {
  return ServerRef({
    debug: false,
    // process.env.NODE_ENV === 'development',
    state: {
      sync: false,
      nav: {
        page: 0,
        clicks: 0
      },
      drawings: await loadDrawings(options),
      snapshots: await loadSnapshots(options),
      ...pluginOptions.serverRef?.state
    },
    onChanged(key, data, patch, timestamp) {
      pluginOptions.serverRef?.onChanged?.(key, data, patch, timestamp);
      if (options.data.config.drawings.persist && key === "drawings")
        writeDrawings(options, patch ?? data);
      if (key === "snapshots")
        writeSnapshots(options, data);
    }
  });
}

// node/vite/staticCopy.ts
import { existsSync as existsSync5 } from "node:fs";
import { join as join11 } from "node:path";
async function createStaticCopyPlugin({ themeRoots, addonRoots }, pluginOptions) {
  const publicDirs = [...themeRoots, ...addonRoots].map((i) => join11(i, "public")).filter(existsSync5);
  if (!publicDirs.length)
    return;
  const { viteStaticCopy } = await import("vite-plugin-static-copy");
  return viteStaticCopy({
    silent: true,
    targets: publicDirs.map((dir) => ({
      src: `${dir}/*`,
      dest: "theme"
    })),
    ...pluginOptions.staticCopy
  });
}

// node/vite/unocss.ts
import UnoCSS from "unocss/vite";

// node/setups/unocss.ts
import { existsSync as existsSync6, readFileSync } from "node:fs";
import { resolve as resolve8 } from "node:path";
import { mergeConfigs, presetIcons } from "unocss";
async function setupUnocss({ clientRoot, roots, data, utils }) {
  async function loadFileConfigs(root) {
    return (await Promise.all([
      resolve8(root, "uno.config.ts"),
      resolve8(root, "unocss.config.ts")
    ].map(async (i) => {
      if (!existsSync6(i))
        return void 0;
      const loaded = await loadModule(i);
      return "default" in loaded ? loaded.default : loaded;
    }))).filter((x) => !!x);
  }
  const configs = [
    {
      presets: [
        presetIcons({
          collectionsNodeResolvePath: utils.iconsResolvePath,
          collections: {
            slidev: {
              logo: () => readFileSync(resolve8(clientRoot, "assets/logo.svg"), "utf-8")
            }
          }
        })
      ]
    },
    ...await loadFileConfigs(clientRoot),
    ...await loadSetups(roots, "unocss.ts", [], loadFileConfigs)
  ].filter(Boolean);
  const config = mergeConfigs(configs);
  config.theme ||= {};
  config.theme.fontFamily ||= {};
  config.theme.fontFamily.sans ||= data.config.fonts.sans.join(",");
  config.theme.fontFamily.mono ||= data.config.fonts.mono.join(",");
  config.theme.fontFamily.serif ||= data.config.fonts.serif.join(",");
  return config;
}

// node/vite/unocss.ts
async function createUnocssPlugin(options, pluginOptions) {
  return UnoCSS({
    configFile: false,
    ...await setupUnocss(options),
    ...pluginOptions.unocss
  });
}

// node/vite/vue.ts
import Vue from "@vitejs/plugin-vue";
import VueJsx from "@vitejs/plugin-vue-jsx";
var customElements = /* @__PURE__ */ new Set([
  // katex
  "annotation",
  "math",
  "menclose",
  "mfrac",
  "mglyph",
  "mi",
  "mlabeledtr",
  "mn",
  "mo",
  "mover",
  "mpadded",
  "mphantom",
  "mroot",
  "mrow",
  "mspace",
  "msqrt",
  "mstyle",
  "msub",
  "msubsup",
  "msup",
  "mtable",
  "mtd",
  "mtext",
  "mtr",
  "munder",
  "munderover",
  "semantics"
]);
async function createVuePlugin(_options, pluginOptions) {
  const {
    vue: vueOptions = {},
    vuejsx: vuejsxOptions = {}
  } = pluginOptions;
  const VuePlugin = Vue({
    include: [/\.vue$/, /\.vue\?vue/, /\.vue\?v=/, /\.md$/, /\.md\?vue/],
    exclude: [],
    ...vueOptions,
    template: {
      ...vueOptions?.template,
      compilerOptions: {
        ...vueOptions?.template?.compilerOptions,
        isCustomElement(tag) {
          return customElements.has(tag) || vueOptions?.template?.compilerOptions?.isCustomElement?.(tag);
        }
      }
    }
  });
  const VueJsxPlugin = VueJsx(vuejsxOptions);
  return [
    VueJsxPlugin,
    VuePlugin
  ];
}

// node/vite/index.ts
function ViteSlidevPlugin(options, pluginOptions = {}, serverOptions = {}) {
  return Promise.all([
    createSlidesLoader(options, serverOptions),
    createMarkdownPlugin(options, pluginOptions),
    createLayoutWrapperPlugin(options),
    createContextInjectionPlugin(),
    createVuePlugin(options, pluginOptions),
    createHmrPatchPlugin(),
    createComponentsPlugin(options, pluginOptions),
    createIconsPlugin(options, pluginOptions),
    createRemoteAssetsPlugin(options, pluginOptions),
    createServerRefPlugin(options, pluginOptions),
    createConfigPlugin(options),
    createMonacoTypesLoader(options),
    createMonacoWriterPlugin(options),
    createVueCompilerFlagsPlugin(options),
    createUnocssPlugin(options, pluginOptions),
    createStaticCopyPlugin(options, pluginOptions),
    createInspectPlugin(options, pluginOptions)
  ]);
}

// node/commands/shared.ts
var sharedMd = MarkdownIt({ html: true });
sharedMd.use(MarkdownItLink);
function getSlideTitle(data) {
  const tokens = sharedMd.parseInline(data.config.title, {});
  const title = stringifyMarkdownTokens(tokens);
  const slideTitle = data.config.titleTemplate.replace("%s", title);
  return slideTitle === "Slidev - Slidev" ? "Slidev" : slideTitle;
}
async function resolveViteConfigs(options, baseConfig, overrideConfigs, command, serverOptions) {
  const configEnv = {
    mode: command === "build" ? "production" : "development",
    command
  };
  const files = options.roots.map((i) => join12(i, "vite.config.ts"));
  for (const file of files) {
    if (!existsSync7(file))
      continue;
    const viteConfig = await loadConfigFromFile(configEnv, file);
    if (!viteConfig?.config)
      continue;
    baseConfig = mergeConfig2(baseConfig, viteConfig.config);
  }
  baseConfig = mergeConfig2(baseConfig, overrideConfigs);
  baseConfig = mergeConfig2(baseConfig, {
    configFile: false,
    root: options.userRoot,
    plugins: await ViteSlidevPlugin(options, baseConfig.slidev, serverOptions),
    define: {
      // Fixes Vue production mode breaking PDF Export #1245
      __VUE_PROD_DEVTOOLS__: false
    }
  });
  return baseConfig;
}

// node/setups/indexHtml.ts
function toAttrValue(unsafe) {
  return JSON.stringify(escapeHtml(String(unsafe)));
}
function setupIndexHtml({ mode, entry, clientRoot, userRoot, roots, data }) {
  let main = readFileSync2(join13(clientRoot, "index.html"), "utf-8");
  let head = "";
  let body = "";
  const { info, author, keywords } = data.headmatter;
  head += [
    `<meta name="slidev:version" content="${version}">`,
    mode === "dev" && `<meta charset="slidev:entry" content="${slash4(entry)}">`,
    `<link rel="icon" href="${data.config.favicon}">`,
    `<title>${getSlideTitle(data)}</title>`,
    info && `<meta name="description" content=${toAttrValue(info)}>`,
    author && `<meta name="author" content=${toAttrValue(author)}>`,
    keywords && `<meta name="keywords" content=${toAttrValue(Array.isArray(keywords) ? keywords.join(", ") : keywords)}>`
  ].filter(Boolean).join("\n");
  for (const root of roots) {
    const path4 = join13(root, "index.html");
    if (!existsSync8(path4))
      continue;
    const index = readFileSync2(path4, "utf-8");
    if (root === userRoot && index.includes("<!DOCTYPE")) {
      console.error(yellow2(`[Slidev] Ignored provided index.html with doctype declaration. (${white(path4)})`));
      console.error(yellow2("This file may be generated by Slidev, please remove it from your project."));
      continue;
    }
    head += `
${(index.match(/<head>([\s\S]*?)<\/head>/i)?.[1] || "").trim()}`;
    body += `
${(index.match(/<body>([\s\S]*?)<\/body>/i)?.[1] || "").trim()}`;
  }
  if (data.features.tweet)
    body += '\n<script async src="https://platform.twitter.com/widgets.js"></script>';
  if (data.config.fonts.webfonts.length && data.config.fonts.provider !== "none")
    head += `
<link rel="stylesheet" href="${generateGoogleFontsUrl(data.config.fonts)}" type="text/css">`;
  if (data.headmatter.lang)
    main = main.replace('<html lang="en">', `<html lang="${data.headmatter.lang}">`);
  main = main.replace("__ENTRY__", toAtFS(join13(clientRoot, "main.ts"))).replace("<!-- head -->", head).replace("<!-- body -->", body);
  return main;
}

// node/setups/shiki.ts
import fs9 from "node:fs/promises";
import { bundledLanguages, createHighlighter } from "shiki";
var cachedRoots;
var cachedShiki;
async function setupShiki(roots) {
  if (cachedRoots === roots)
    return cachedShiki;
  cachedShiki?.shiki.dispose();
  const options = await loadSetups(
    roots,
    "shiki.ts",
    [{
      /** @deprecated */
      async loadTheme(path4) {
        console.warn("[slidev] `loadTheme` in `setup/shiki.ts` is deprecated. Pass directly the theme name it's supported by Shiki. For custom themes, load it manually via `JSON.parse(fs.readFileSync(path, 'utf-8'))` and pass the raw JSON object instead.");
        return JSON.parse(await fs9.readFile(path4, "utf-8"));
      }
    }]
  );
  const mergedOptions = Object.assign({}, ...options);
  if ("theme" in mergedOptions && "themes" in mergedOptions)
    delete mergedOptions.theme;
  if (mergedOptions.theme && typeof mergedOptions.theme !== "string" && !mergedOptions.theme.name && !mergedOptions.theme.tokenColors) {
    mergedOptions.themes = mergedOptions.theme;
    delete mergedOptions.theme;
  }
  if (!mergedOptions.theme && !mergedOptions.themes) {
    mergedOptions.themes = {
      dark: "vitesse-dark",
      light: "vitesse-light"
    };
  }
  if (mergedOptions.themes)
    mergedOptions.defaultColor = false;
  const shiki = await createHighlighter({
    ...mergedOptions,
    langs: mergedOptions.langs ?? Object.keys(bundledLanguages),
    themes: "themes" in mergedOptions ? Object.values(mergedOptions.themes) : [mergedOptions.theme]
  });
  cachedRoots = roots;
  return cachedShiki = {
    shiki,
    shikiOptions: mergedOptions
  };
}

// node/options.ts
var debug = Debug("slidev:options");
async function resolveOptions(entryOptions, mode) {
  const entry = await resolveEntry(entryOptions.entry);
  const rootsInfo = await getRoots(entry);
  const loaded = await parser.load(rootsInfo.userRoot, entry, void 0, mode);
  let themeRaw = entryOptions.theme || loaded.headmatter.theme;
  themeRaw = themeRaw === null ? "none" : themeRaw || "default";
  const [theme, themeRoot] = await resolveTheme(themeRaw, entry);
  const themeRoots = themeRoot ? [themeRoot] : [];
  const themeMeta = themeRoot ? await getThemeMeta(theme, themeRoot) : void 0;
  const config = parser.resolveConfig(loaded.headmatter, themeMeta, entryOptions.entry);
  const addonRoots = await resolveAddons(config.addons);
  const roots = uniq5([...themeRoots, ...addonRoots, rootsInfo.userRoot]);
  if (entryOptions.download)
    config.download ||= entryOptions.download;
  debug({
    ...rootsInfo,
    ...entryOptions,
    config,
    mode,
    entry,
    themeRaw,
    theme,
    themeRoots,
    addonRoots,
    roots
  });
  const data = {
    ...loaded,
    config,
    themeMeta
  };
  const resolved = {
    ...rootsInfo,
    ...entryOptions,
    data,
    mode,
    entry,
    themeRaw,
    theme,
    themeRoots,
    addonRoots,
    roots
  };
  return {
    ...resolved,
    utils: await createDataUtils(resolved)
  };
}
async function createDataUtils(resolved) {
  const monacoTypesIgnorePackagesMatches = (resolved.data.config.monacoTypesIgnorePackages || []).map((i) => mm.matcher(i));
  let _layouts_cache_time = 0;
  let _layouts_cache = {};
  return {
    ...await setupShiki(resolved.roots),
    indexHtml: setupIndexHtml(resolved),
    define: getDefine(resolved),
    iconsResolvePath: [resolved.clientRoot, ...resolved.roots].reverse(),
    isMonacoTypesIgnored: (pkg) => monacoTypesIgnorePackagesMatches.some((i) => i(pkg)),
    getLayouts: () => {
      const now = Date.now();
      if (now - _layouts_cache_time < 2e3)
        return _layouts_cache;
      const layouts = {};
      for (const root of [resolved.clientRoot, ...resolved.roots]) {
        const layoutPaths = fg4.sync("layouts/**/*.{vue,ts}", {
          cwd: root,
          absolute: true,
          suppressErrors: true
        });
        for (const layoutPath of layoutPaths) {
          const layoutName = path3.basename(layoutPath).replace(/\.\w+$/, "");
          layouts[layoutName] = layoutPath;
        }
      }
      _layouts_cache_time = now;
      _layouts_cache = layouts;
      return layouts;
    }
  };
}
function getDefine(options) {
  const matchMode = (mode) => mode === true || mode === options.mode;
  return objectMap2(
    {
      __DEV__: options.mode === "dev",
      __SLIDEV_CLIENT_ROOT__: toAtFS(options.clientRoot),
      __SLIDEV_HASH_ROUTE__: options.data.config.routerMode === "hash",
      __SLIDEV_FEATURE_DRAWINGS__: matchMode(options.data.config.drawings.enabled),
      __SLIDEV_FEATURE_EDITOR__: options.mode === "dev" && options.data.config.editor !== false,
      __SLIDEV_FEATURE_DRAWINGS_PERSIST__: !!options.data.config.drawings.persist,
      __SLIDEV_FEATURE_RECORD__: matchMode(options.data.config.record),
      __SLIDEV_FEATURE_PRESENTER__: matchMode(options.data.config.presenter),
      __SLIDEV_FEATURE_PRINT__: options.mode === "export" || options.mode === "build" && [true, "true", "auto"].includes(options.data.config.download),
      __SLIDEV_FEATURE_BROWSER_EXPORTER__: matchMode(options.data.config.browserExporter),
      __SLIDEV_FEATURE_WAKE_LOCK__: matchMode(options.data.config.wakeLock),
      __SLIDEV_HAS_SERVER__: options.mode !== "build"
    },
    (v, k) => [v, JSON.stringify(k)]
  );
}

export {
  version,
  resolveAddons,
  resolveTheme,
  getThemeMeta,
  parser,
  loadSetups,
  resolveOptions,
  createDataUtils,
  ViteSlidevPlugin,
  resolveViteConfigs
};