@vuepress/markdown 2.0.0-beta.50-pre → 2.0.0-beta.50-pre.1

package/dist/index.d.ts

@@ -0,0 +1,272 @@
+import { SfcPluginOptions } from '@mdit-vue/plugin-sfc';
+export { MarkdownSfcBlocks, SfcPluginOptions, sfcPlugin } from '@mdit-vue/plugin-sfc';
+import { MarkdownItEnv } from '@mdit-vue/types';
+import { PageHeader, PageFrontmatter } from '@vuepress/shared';
+import MarkdownIt, { PluginWithOptions } from 'markdown-it';
+import { FrontmatterPluginOptions } from '@mdit-vue/plugin-frontmatter';
+export { FrontmatterPluginOptions, frontmatterPlugin } from '@mdit-vue/plugin-frontmatter';
+import { HeadersPluginOptions } from '@mdit-vue/plugin-headers';
+export { HeadersPluginOptions, headersPlugin } from '@mdit-vue/plugin-headers';
+import { TocPluginOptions } from '@mdit-vue/plugin-toc';
+export { TocPluginOptions, tocPlugin } from '@mdit-vue/plugin-toc';
+import anchorPlugin from 'markdown-it-anchor';
+export { default as anchorPlugin } from 'markdown-it-anchor';
+import emojiPlugin from 'markdown-it-emoji';
+export { default as emojiPlugin } from 'markdown-it-emoji';
+export { ComponentPluginOptions, componentPlugin } from '@mdit-vue/plugin-component';
+export { titlePlugin } from '@mdit-vue/plugin-title';
+import { RuleBlock } from 'markdown-it/lib/parser_block.js';
+
+declare type AnchorPluginOptions = anchorPlugin.AnchorOptions;
+
+interface AssetsPluginOptions {
+    /**
+     * Prefix to add to relative assets links
+     */
+    relativePathPrefix?: string;
+}
+/**
+ * Plugin to handle assets links
+ */
+declare const assetsPlugin: PluginWithOptions<AssetsPluginOptions>;
+
+declare const resolveLink: (link: string, relativePathPrefix: string, env: MarkdownEnv) => string;
+
+interface CodePluginOptions {
+    /**
+     * Enable highlight lines or not
+     */
+    highlightLines?: boolean;
+    /**
+     * Enable line numbers or not
+     *
+     * - A `boolean` value is to enable line numbers or not.
+     * - A `number` value is the minimum number of lines to enable line numbers
+     */
+    lineNumbers?: boolean | number;
+    /**
+     * Wrap the `<pre>` tag with an extra `<div>` or not. Do not disable it unless you
+     * understand what's it for
+     *
+     * - Required for `highlightLines`
+     * - Required for `lineNumbers`
+     * - Required for language display of default theme
+     */
+    preWrapper?: boolean;
+    /**
+     * Add `v-pre` directive or not
+     */
+    vPre?: {
+        /**
+         * Add `v-pre` directive to `<pre>` tag of code block or not
+         */
+        block?: boolean;
+        /**
+         * Add `v-pre` directive to `<code>` tag of inline code or not
+         */
+        inline?: boolean;
+    };
+}
+/**
+ * Code plugin
+ */
+declare const codePlugin: PluginWithOptions<CodePluginOptions>;
+
+/**
+ * Language type for syntax highlight
+ */
+interface HighlightLanguage {
+    /**
+     * Name of the language
+     *
+     * The name to be used for the class name,
+     * e.g. `class="language-typescript"`
+     */
+    name: string;
+    /**
+     * Extension of the language
+     *
+     * The file extension, which will be used for the
+     * class name, e.g. `class="ext-ts"`
+     */
+    ext: string;
+    /**
+     * Aliases that point to this language
+     *
+     * Do not conflict with other languages
+     */
+    aliases: string[];
+}
+declare const languageBash: HighlightLanguage;
+declare const languageCsharp: HighlightLanguage;
+declare const languageDocker: HighlightLanguage;
+declare const languageFsharp: HighlightLanguage;
+declare const languageJavascript: HighlightLanguage;
+declare const languageKotlin: HighlightLanguage;
+declare const languageMarkdown: HighlightLanguage;
+declare const languagePython: HighlightLanguage;
+declare const languageRuby: HighlightLanguage;
+declare const languageRust: HighlightLanguage;
+declare const languageStylus: HighlightLanguage;
+declare const languageTypescript: HighlightLanguage;
+declare const languageYaml: HighlightLanguage;
+
+declare type HighlightLinesRange = [number, number];
+/**
+ * Resolve highlight-lines ranges from token info
+ */
+declare const resolveHighlightLines: (info: string) => HighlightLinesRange[] | null;
+/**
+ * Check if a line number is in ranges
+ */
+declare const isHighlightLine: (lineNumber: number, ranges: HighlightLinesRange[]) => boolean;
+
+/**
+ * Resolve language for highlight from token info
+ */
+declare const resolveLanguage: (info: string) => HighlightLanguage;
+
+/**
+ * Resolve the `:line-numbers` / `:no-line-numbers` mark from token info
+ */
+declare const resolveLineNumbers: (info: string) => boolean | null;
+
+/**
+ * Resolve the `:v-pre` / `:no-v-pre` mark from token info
+ */
+declare const resolveVPre: (info: string) => boolean | null;
+
+declare type EmojiPluginOptions = emojiPlugin.Options;
+
+interface ImportCodePluginOptions {
+    /**
+     * A function to handle the import path
+     */
+    handleImportPath?: (str: string) => string;
+}
+declare const importCodePlugin: PluginWithOptions<ImportCodePluginOptions>;
+
+declare const createImportCodeBlockRule: ({ handleImportPath }: ImportCodePluginOptions) => RuleBlock;
+
+interface ImportCodeTokenMeta {
+    importPath: string;
+    lineStart: number;
+    lineEnd?: number;
+}
+
+declare const resolveImportCode: ({ importPath, lineStart, lineEnd }: ImportCodeTokenMeta, { filePath }: MarkdownEnv) => {
+    importFilePath: string | null;
+    importCode: string;
+};
+
+interface LinksPluginOptions {
+    /**
+     * Tag for internal links
+     *
+     * @default 'RouterLink'
+     */
+    internalTag?: 'a' | 'RouterLink';
+    /**
+     * Additional attributes for external links
+     *
+     * @default
+     * ```js
+     * ({
+     *   target: '_blank',
+     *   rel: 'noopener noreferrer',
+     * })
+     * ```
+     */
+    externalAttrs?: Record<string, string>;
+}
+/**
+ * Process links in markdown file
+ *
+ * - internal links: convert them into `<RouterLink>`
+ * - external links: add extra attrs and external icon
+ */
+declare const linksPlugin: PluginWithOptions<LinksPluginOptions>;
+
+/**
+ * Resolve relative and absolute paths according to the `base` and `filePathRelative`
+ */
+declare const resolvePaths: (rawPath: string, base: string, filePathRelative: string | null) => {
+    absolutePath: string;
+    relativePath: string;
+};
+
+declare type Markdown = MarkdownIt;
+
+interface MarkdownOptions extends MarkdownIt.Options {
+    anchor?: false | AnchorPluginOptions;
+    assets?: false | AssetsPluginOptions;
+    code?: false | CodePluginOptions;
+    component?: false;
+    emoji?: false | EmojiPluginOptions;
+    frontmatter?: false | FrontmatterPluginOptions;
+    headers?: false | HeadersPluginOptions;
+    title?: false;
+    importCode?: false | ImportCodePluginOptions;
+    links?: false | LinksPluginOptions;
+    sfc?: false | SfcPluginOptions;
+    slugify?: MarkdownSlugifyFunction;
+    toc?: false | TocPluginOptions;
+}
+/**
+ * Headers in markdown file
+ */
+declare type MarkdownHeader = PageHeader;
+/**
+ * Internal links in markdown file
+ *
+ * Used for file existence check
+ */
+interface MarkdownLink {
+    raw: string;
+    relative: string;
+    absolute: string;
+}
+/**
+ * The `env` object to be passed to markdown-it render function
+ *
+ * Input some meta data for markdown file parsing and rendering
+ *
+ * Output some resources from the markdown file
+ */
+interface MarkdownEnv extends MarkdownItEnv {
+    /**
+     * Base / publicPath of current site
+     */
+    base?: string;
+    /**
+     * Absolute file path of the markdown file
+     */
+    filePath?: string | null;
+    /**
+     * Relative file path of the markdown file
+     */
+    filePathRelative?: string | null;
+    /**
+     * Frontmatter of the markdown file
+     */
+    frontmatter?: PageFrontmatter;
+    /**
+     * Imported file that extracted by importCodePlugin
+     */
+    importedFiles?: string[];
+    /**
+     * Links that extracted by linksPlugin
+     */
+    links?: MarkdownLink[];
+}
+/**
+ * Type of `slugify` function
+ */
+declare type MarkdownSlugifyFunction = (str: string) => string;
+
+/**
+ * Create vuepress customized markdown-it instance
+ */
+declare const createMarkdown: ({ anchor, assets, code, component, emoji, frontmatter, headers, title, importCode, links, sfc, slugify, toc, ...markdownItOptions }?: MarkdownOptions) => Markdown;
+
+export { AnchorPluginOptions, AssetsPluginOptions, CodePluginOptions, EmojiPluginOptions, HighlightLanguage, HighlightLinesRange, ImportCodePluginOptions, ImportCodeTokenMeta, LinksPluginOptions, Markdown, MarkdownEnv, MarkdownHeader, MarkdownLink, MarkdownOptions, MarkdownSlugifyFunction, assetsPlugin, codePlugin, createImportCodeBlockRule, createMarkdown, importCodePlugin, isHighlightLine, languageBash, languageCsharp, languageDocker, languageFsharp, languageJavascript, languageKotlin, languageMarkdown, languagePython, languageRuby, languageRust, languageStylus, languageTypescript, languageYaml, linksPlugin, resolveHighlightLines, resolveImportCode, resolveLanguage, resolveLineNumbers, resolveLink, resolvePaths, resolveVPre };

package/dist/index.js

@@ -0,0 +1,583 @@
+var __defProp = Object.defineProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/markdown.ts
+import { slugify as defaultSlugify } from "@mdit-vue/shared";
+import MarkdownIt from "markdown-it";
+
+// src/plugins.ts
+import {
+  componentPlugin
+} from "@mdit-vue/plugin-component";
+import {
+  frontmatterPlugin
+} from "@mdit-vue/plugin-frontmatter";
+import {
+  headersPlugin
+} from "@mdit-vue/plugin-headers";
+import { sfcPlugin } from "@mdit-vue/plugin-sfc";
+import { titlePlugin } from "@mdit-vue/plugin-title";
+import { tocPlugin } from "@mdit-vue/plugin-toc";
+
+// src/plugins/anchorPlugin.ts
+import anchorPlugin from "markdown-it-anchor";
+
+// src/plugins/assetsPlugin/resolveLink.ts
+import { path } from "@vuepress/utils";
+import { decode } from "mdurl";
+var resolveLink = (link, relativePathPrefix, env) => {
+  let resolvedLink = decode(link);
+  if (/^\.{1,2}\//.test(link) && env.filePathRelative) {
+    resolvedLink = `${relativePathPrefix}/${path.join(
+      path.dirname(env.filePathRelative),
+      resolvedLink
+    )}`;
+  }
+  return resolvedLink;
+};
+
+// src/plugins/assetsPlugin/assetsPlugin.ts
+var assetsPlugin = (md, { relativePathPrefix = "@source" } = {}) => {
+  const rawImageRule = md.renderer.rules.image;
+  md.renderer.rules.image = (tokens, idx, options, env, self) => {
+    const token = tokens[idx];
+    const link = token.attrGet("src");
+    if (link) {
+      token.attrSet("src", resolveLink(link, relativePathPrefix, env));
+    }
+    return rawImageRule(tokens, idx, options, env, self);
+  };
+  const createHtmlRule = (rawHtmlRule) => (tokens, idx, options, env, self) => {
+    tokens[idx].content = tokens[idx].content.replace(
+      /(<img\b.*?src=")([^"]*)(")/gs,
+      (_, prefix, src, suffix) => `${prefix}${resolveLink(
+        src.trim(),
+        relativePathPrefix,
+        env
+      )}${suffix}`
+    ).replace(
+      /(<img\b.*?srcset=")([^"]*)(")/gs,
+      (_, prefix, srcset, suffix) => `${prefix}${srcset.split(",").map(
+        (item) => item.trim().replace(
+          /^([^ ]*?)([ \n].*)?$/,
+          (_2, url, descriptor = "") => `${resolveLink(
+            url.trim(),
+            relativePathPrefix,
+            env
+          )}${descriptor.replace(/[ \n]+/g, " ").trimEnd()}`
+        )
+      ).join(", ")}${suffix}`
+    );
+    return rawHtmlRule(tokens, idx, options, env, self);
+  };
+  const rawHtmlBlockRule = md.renderer.rules.html_block;
+  const rawHtmlInlineRule = md.renderer.rules.html_inline;
+  md.renderer.rules.html_block = createHtmlRule(rawHtmlBlockRule);
+  md.renderer.rules.html_inline = createHtmlRule(rawHtmlInlineRule);
+};
+
+// src/plugins/codePlugin/resolveHighlightLines.ts
+var resolveHighlightLines = (info) => {
+  const match = info.match(/{([\d,-]+)}/);
+  if (match === null) {
+    return null;
+  }
+  return match[1].split(",").map((item) => {
+    const range = item.split("-");
+    if (range.length === 1) {
+      range.push(range[0]);
+    }
+    return range.map((str) => Number.parseInt(str, 10));
+  });
+};
+var isHighlightLine = (lineNumber, ranges) => ranges.some(([start, end]) => lineNumber >= start && lineNumber <= end);
+
+// src/plugins/codePlugin/languages.ts
+var languages_exports = {};
+__export(languages_exports, {
+  languageBash: () => languageBash,
+  languageCsharp: () => languageCsharp,
+  languageDocker: () => languageDocker,
+  languageFsharp: () => languageFsharp,
+  languageJavascript: () => languageJavascript,
+  languageKotlin: () => languageKotlin,
+  languageMarkdown: () => languageMarkdown,
+  languagePython: () => languagePython,
+  languageRuby: () => languageRuby,
+  languageRust: () => languageRust,
+  languageStylus: () => languageStylus,
+  languageTypescript: () => languageTypescript,
+  languageYaml: () => languageYaml
+});
+var languageBash = {
+  name: "bash",
+  ext: "sh",
+  aliases: ["bash", "sh", "shell", "zsh"]
+};
+var languageCsharp = {
+  name: "csharp",
+  ext: "cs",
+  aliases: ["cs", "csharp"]
+};
+var languageDocker = {
+  name: "docker",
+  ext: "docker",
+  aliases: ["docker", "dockerfile"]
+};
+var languageFsharp = {
+  name: "fsharp",
+  ext: "fs",
+  aliases: ["fs", "fsharp"]
+};
+var languageJavascript = {
+  name: "javascript",
+  ext: "js",
+  aliases: ["javascript", "js"]
+};
+var languageKotlin = {
+  name: "kotlin",
+  ext: "kt",
+  aliases: ["kotlin", "kt"]
+};
+var languageMarkdown = {
+  name: "markdown",
+  ext: "md",
+  aliases: ["markdown", "md"]
+};
+var languagePython = {
+  name: "python",
+  ext: "py",
+  aliases: ["py", "python"]
+};
+var languageRuby = {
+  name: "ruby",
+  ext: "rb",
+  aliases: ["rb", "ruby"]
+};
+var languageRust = {
+  name: "rust",
+  ext: "rs",
+  aliases: ["rs", "rust"]
+};
+var languageStylus = {
+  name: "stylus",
+  ext: "styl",
+  aliases: ["styl", "stylus"]
+};
+var languageTypescript = {
+  name: "typescript",
+  ext: "ts",
+  aliases: ["ts", "typescript"]
+};
+var languageYaml = {
+  name: "yaml",
+  ext: "yml",
+  aliases: ["yaml", "yml"]
+};
+
+// src/plugins/codePlugin/resolveLanguage.ts
+var languagesMap;
+var getLanguagesMap = () => {
+  if (!languagesMap) {
+    languagesMap = Object.values(languages_exports).reduce((result, item) => {
+      item.aliases.forEach((alias) => {
+        result[alias] = item;
+      });
+      return result;
+    }, {});
+  }
+  return languagesMap;
+};
+var resolveLanguage = (info) => {
+  const alias = info.match(/^([^ :[{]+)/)?.[1] || "text";
+  return getLanguagesMap()[alias] ?? {
+    name: alias,
+    ext: alias,
+    aliases: [alias]
+  };
+};
+
+// src/plugins/codePlugin/resolveLineNumbers.ts
+var resolveLineNumbers = (info) => {
+  if (/:line-numbers\b/.test(info)) {
+    return true;
+  }
+  if (/:no-line-numbers\b/.test(info)) {
+    return false;
+  }
+  return null;
+};
+
+// src/plugins/codePlugin/resolveVPre.ts
+var resolveVPre = (info) => {
+  if (/:v-pre\b/.test(info)) {
+    return true;
+  }
+  if (/:no-v-pre\b/.test(info)) {
+    return false;
+  }
+  return null;
+};
+
+// src/plugins/codePlugin/codePlugin.ts
+var codePlugin = (md, {
+  highlightLines = true,
+  lineNumbers = true,
+  preWrapper = true,
+  vPre: { block: vPreBlock = true, inline: vPreInline = true } = {}
+} = {}) => {
+  md.renderer.rules.fence = (tokens, idx, options, env, slf) => {
+    const token = tokens[idx];
+    const info = token.info ? md.utils.unescapeAll(token.info).trim() : "";
+    const language = resolveLanguage(info);
+    const languageClass = `${options.langPrefix}${language.name}`;
+    const code = options.highlight?.(token.content, language.name, "") || md.utils.escapeHtml(token.content);
+    let result = code.startsWith("<pre") ? code : `<pre class="${languageClass}"><code>${code}</code></pre>`;
+    const useVPre = resolveVPre(info) ?? vPreBlock;
+    if (useVPre) {
+      result = `<pre v-pre${result.slice("<pre".length)}`;
+    }
+    if (!preWrapper) {
+      return result;
+    }
+    const lines = code.split("\n").slice(0, -1);
+    const highlightLinesRanges = highlightLines ? resolveHighlightLines(info) : null;
+    if (highlightLinesRanges) {
+      const highlightLinesCode = lines.map((_, index) => {
+        if (isHighlightLine(index + 1, highlightLinesRanges)) {
+          return '<div class="highlight-line">&nbsp;</div>';
+        }
+        return "<br>";
+      }).join("");
+      result = `${result}<div class="highlight-lines">${highlightLinesCode}</div>`;
+    }
+    const useLineNumbers = resolveLineNumbers(info) ?? (typeof lineNumbers === "number" ? lines.length >= lineNumbers : lineNumbers);
+    if (useLineNumbers) {
+      const lineNumbersCode = lines.map(() => `<div class="line-number"></div>`).join("");
+      result = `${result}<div class="line-numbers" aria-hidden="true">${lineNumbersCode}</div>`;
+    }
+    result = `<div class="${languageClass} ext-${language.ext}${useLineNumbers ? " line-numbers-mode" : ""}">${result}</div>`;
+    return result;
+  };
+  if (vPreInline) {
+    const rawInlineCodeRule = md.renderer.rules.code_inline;
+    md.renderer.rules.code_inline = (tokens, idx, options, env, slf) => {
+      const result = rawInlineCodeRule(tokens, idx, options, env, slf);
+      return `<code v-pre${result.slice("<code".length)}`;
+    };
+  }
+};
+
+// src/plugins/emojiPlugin.ts
+import emojiPlugin from "markdown-it-emoji";
+
+// src/plugins/importCodePlugin/createImportCodeBlockRule.ts
+import { path as path2 } from "@vuepress/utils";
+var MIN_LENGTH = 9;
+var START_CODES = [64, 91, 99, 111, 100, 101];
+var SYNTAX_RE = /^@\[code(?:{(?:(\d+)?-(\d+)?)})?(?: ([^\]]+))?\]\(([^)]*)\)/;
+var createImportCodeBlockRule = ({ handleImportPath = (str) => str }) => (state, startLine, endLine, silent) => {
+  if (state.sCount[startLine] - state.blkIndent >= 4) {
+    return false;
+  }
+  const pos = state.bMarks[startLine] + state.tShift[startLine];
+  const max = state.eMarks[startLine];
+  if (pos + MIN_LENGTH > max)
+    return false;
+  for (let i = 0; i < START_CODES.length; i += 1) {
+    if (state.src.charCodeAt(pos + i) !== START_CODES[i]) {
+      return false;
+    }
+  }
+  const match = state.src.slice(pos, max).match(SYNTAX_RE);
+  if (!match)
+    return false;
+  if (silent)
+    return true;
+  const [, lineStart, lineEnd, info, importPath] = match;
+  const meta = {
+    importPath: handleImportPath(importPath),
+    lineStart: lineStart ? Number.parseInt(lineStart, 10) : 0,
+    lineEnd: lineEnd ? Number.parseInt(lineEnd, 10) : void 0
+  };
+  const token = state.push("import_code", "code", 0);
+  token.info = info ?? path2.extname(meta.importPath).slice(1);
+  token.markup = "```";
+  token.map = [startLine, startLine + 1];
+  token.meta = meta;
+  state.line = startLine + 1;
+  return true;
+};
+
+// src/plugins/importCodePlugin/resolveImportCode.ts
+import { fs, path as path3 } from "@vuepress/utils";
+var resolveImportCode = ({ importPath, lineStart, lineEnd }, { filePath }) => {
+  let importFilePath = importPath;
+  if (!path3.isAbsolute(importPath)) {
+    if (!filePath) {
+      return {
+        importFilePath: null,
+        importCode: "Error when resolving path"
+      };
+    }
+    importFilePath = path3.resolve(filePath, "..", importPath);
+  }
+  if (!fs.existsSync(importFilePath)) {
+    return {
+      importFilePath,
+      importCode: "File not found"
+    };
+  }
+  const fileContent = fs.readFileSync(importFilePath).toString();
+  return {
+    importFilePath,
+    importCode: fileContent.split("\n").slice(lineStart ? lineStart - 1 : lineStart, lineEnd).join("\n").replace(/\n?$/, "\n")
+  };
+};
+
+// src/plugins/importCodePlugin/importCodePlugin.ts
+var importCodePlugin = (md, options = {}) => {
+  md.block.ruler.before(
+    "fence",
+    "import_code",
+    createImportCodeBlockRule(options),
+    {
+      alt: ["paragraph", "reference", "blockquote", "list"]
+    }
+  );
+  md.renderer.rules.import_code = (tokens, idx, options2, env, slf) => {
+    const token = tokens[idx];
+    const { importFilePath, importCode } = resolveImportCode(token.meta, env);
+    token.content = importCode;
+    if (importFilePath) {
+      const importedFiles = env.importedFiles || (env.importedFiles = []);
+      importedFiles.push(importFilePath);
+    }
+    return md.renderer.rules.fence(tokens, idx, options2, env, slf);
+  };
+};
+
+// src/plugins/linksPlugin/linksPlugin.ts
+import { isLinkExternal } from "@vuepress/shared";
+
+// src/plugins/linksPlugin/resolvePaths.ts
+import { removeLeadingSlash } from "@vuepress/shared";
+import { path as path4 } from "@vuepress/utils";
+var resolvePaths = (rawPath, base, filePathRelative) => {
+  let absolutePath;
+  let relativePath;
+  if (rawPath.startsWith("/")) {
+    if (rawPath.endsWith(".md")) {
+      absolutePath = path4.join(base, rawPath);
+      relativePath = removeLeadingSlash(rawPath);
+    } else {
+      absolutePath = rawPath;
+      relativePath = path4.relative(base, absolutePath);
+    }
+  } else {
+    if (filePathRelative) {
+      relativePath = path4.join(
+        path4.dirname(encodeURI(filePathRelative)),
+        rawPath
+      );
+      absolutePath = path4.join(base, relativePath);
+    } else {
+      relativePath = rawPath.replace(/^(?:\.\/)?(.*)$/, "$1");
+      absolutePath = relativePath;
+    }
+  }
+  return {
+    absolutePath,
+    relativePath
+  };
+};
+
+// src/plugins/linksPlugin/linksPlugin.ts
+var linksPlugin = (md, options = {}) => {
+  const internalTag = options.internalTag || "RouterLink";
+  const externalAttrs = {
+    target: "_blank",
+    rel: "noopener noreferrer",
+    ...options.externalAttrs
+  };
+  let hasOpenInternalLink = false;
+  const handleLinkOpen = (tokens, idx, env) => {
+    const token = tokens[idx];
+    const hrefIndex = token.attrIndex("href");
+    if (hrefIndex < 0) {
+      return;
+    }
+    const hrefAttr = token.attrs[hrefIndex];
+    const hrefLink = hrefAttr[1];
+    const { base = "/", filePathRelative = null } = env;
+    if (isLinkExternal(hrefLink, base)) {
+      Object.entries(externalAttrs).forEach(
+        ([key, val]) => token.attrSet(key, val)
+      );
+      return;
+    }
+    const internalLinkMatch = hrefLink.match(
+      /^((?:.*)(?:\/|\.md|\.html))(#.*)?$/
+    );
+    if (!internalLinkMatch) {
+      return;
+    }
+    const rawPath = internalLinkMatch[1];
+    const rawHash = internalLinkMatch[2] || "";
+    const { relativePath, absolutePath } = resolvePaths(
+      rawPath,
+      base,
+      filePathRelative
+    );
+    const normalizedPath = absolutePath.replace(new RegExp(`^${base}`), "/").replace(/(^|\/)(README|index).md$/i, "$1").replace(/\.md$/, ".html");
+    if (internalTag === "RouterLink") {
+      token.tag = internalTag;
+      hrefAttr[0] = "to";
+      hasOpenInternalLink = true;
+    }
+    hrefAttr[1] = `${normalizedPath}${rawHash}`;
+    const links = env.links || (env.links = []);
+    links.push({
+      raw: hrefLink,
+      relative: relativePath,
+      absolute: absolutePath
+    });
+  };
+  md.renderer.rules.link_open = (tokens, idx, options2, env, self) => {
+    handleLinkOpen(tokens, idx, env);
+    return self.renderToken(tokens, idx, options2);
+  };
+  md.renderer.rules.link_close = (tokens, idx, options2, env, self) => {
+    if (hasOpenInternalLink) {
+      hasOpenInternalLink = false;
+      tokens[idx].tag = internalTag;
+    }
+    return self.renderToken(tokens, idx, options2);
+  };
+};
+
+// src/markdown.ts
+var createMarkdown = ({
+  anchor,
+  assets,
+  code,
+  component,
+  emoji,
+  frontmatter,
+  headers,
+  title,
+  importCode,
+  links,
+  sfc,
+  slugify = defaultSlugify,
+  toc,
+  ...markdownItOptions
+} = {}) => {
+  const md = MarkdownIt({
+    ...markdownItOptions,
+    html: true
+  });
+  if (emoji !== false) {
+    md.use(emojiPlugin, emoji);
+  }
+  if (anchor !== false) {
+    md.use(anchorPlugin, {
+      level: [1, 2, 3, 4, 5, 6],
+      slugify,
+      permalink: anchorPlugin.permalink.ariaHidden({
+        class: "header-anchor",
+        symbol: "#",
+        space: true,
+        placement: "before"
+      }),
+      ...anchor
+    });
+  }
+  if (toc !== false) {
+    md.use(tocPlugin, {
+      level: [2, 3],
+      slugify,
+      linkTag: "router-link",
+      ...toc
+    });
+  }
+  if (headers !== false) {
+    md.use(headersPlugin, {
+      level: [2, 3],
+      slugify,
+      ...headers
+    });
+  }
+  if (title !== false) {
+    md.use(titlePlugin);
+  }
+  if (component !== false) {
+    md.use(componentPlugin);
+  }
+  if (frontmatter !== false) {
+    md.use(frontmatterPlugin, {
+      ...frontmatter,
+      grayMatterOptions: {
+        excerpt: true,
+        excerpt_separator: "<!-- more -->",
+        ...frontmatter?.grayMatterOptions
+      }
+    });
+  }
+  if (assets !== false) {
+    md.use(assetsPlugin, assets);
+  }
+  if (sfc !== false) {
+    md.use(sfcPlugin, sfc);
+  }
+  if (links !== false) {
+    md.use(linksPlugin, links);
+  }
+  if (code !== false) {
+    md.use(codePlugin, code);
+  }
+  if (importCode !== false) {
+    md.use(importCodePlugin, importCode);
+  }
+  return md;
+};
+export {
+  anchorPlugin,
+  assetsPlugin,
+  codePlugin,
+  componentPlugin,
+  createImportCodeBlockRule,
+  createMarkdown,
+  emojiPlugin,
+  frontmatterPlugin,
+  headersPlugin,
+  importCodePlugin,
+  isHighlightLine,
+  languageBash,
+  languageCsharp,
+  languageDocker,
+  languageFsharp,
+  languageJavascript,
+  languageKotlin,
+  languageMarkdown,
+  languagePython,
+  languageRuby,
+  languageRust,
+  languageStylus,
+  languageTypescript,
+  languageYaml,
+  linksPlugin,
+  resolveHighlightLines,
+  resolveImportCode,
+  resolveLanguage,
+  resolveLineNumbers,
+  resolveLink,
+  resolvePaths,
+  resolveVPre,
+  sfcPlugin,
+  titlePlugin,
+  tocPlugin
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vuepress/markdown",
-  "version": "2.0.0-beta.50-pre",
+  "version": "2.0.0-beta.50-pre.1",
   "description": "Markdown package of VuePress",
   "keywords": [
     "vuepress",
@@ -24,7 +24,7 @@
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "files": [
-    "./dist"
+    "dist"
   ],
   "dependencies": {
     "@mdit-vue/plugin-component": "^0.9.0",
@@ -37,8 +37,8 @@
     "@mdit-vue/types": "^0.9.0",
     "@types/markdown-it": "^12.2.3",
     "@types/markdown-it-emoji": "^2.0.2",
-    "@vuepress/shared": "2.0.0-beta.50-pre",
-    "@vuepress/utils": "2.0.0-beta.50-pre",
+    "@vuepress/shared": "2.0.0-beta.50-pre.1",
+    "@vuepress/utils": "2.0.0-beta.50-pre.1",
     "markdown-it": "^13.0.1",
     "markdown-it-anchor": "^8.6.4",
     "markdown-it-emoji": "^2.0.2",