@vuepress/markdown 2.0.0-beta.9 → 2.0.0-rc.1

package/dist/index.js

@@ -0,0 +1,599 @@
+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 { default as anchorPlugin } from "markdown-it-anchor";
+
+// src/plugins/assetsPlugin/resolveLink.ts
+import { path } from "@vuepress/utils";
+import { decode } from "mdurl";
+var resolveLink = (link, {
+  env,
+  absolutePathPrependBase = false,
+  relativePathPrefix,
+  strict = false
+}) => {
+  if (link.startsWith("data:"))
+    return link;
+  let resolvedLink = decode(link);
+  const isRelativePath = strict ? (
+    // in strict mode, only link that starts with `./` or `../` is considered as relative path
+    /^\.{1,2}\//.test(link)
+  ) : (
+    // in non-strict mode, link that does not start with `/` and does not have protocol is considered as relative path
+    !link.startsWith("/") && !/[A-z]+:\/\//.test(link)
+  );
+  if (isRelativePath && env.filePathRelative) {
+    resolvedLink = `${relativePathPrefix}/${path.join(
+      path.dirname(env.filePathRelative),
+      resolvedLink
+    )}`;
+  }
+  if (absolutePathPrependBase && env.base && link.startsWith("/")) {
+    resolvedLink = path.join(env.base, resolvedLink);
+  }
+  return resolvedLink;
+};
+
+// src/plugins/assetsPlugin/assetsPlugin.ts
+var assetsPlugin = (md, {
+  absolutePathPrependBase = false,
+  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, { env, absolutePathPrependBase, relativePathPrefix })
+      );
+    }
+    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=)(['"])([^\2]*?)\2/gs,
+      (_, prefix, quote, src) => `${prefix}${quote}${resolveLink(src.trim(), {
+        env,
+        absolutePathPrependBase,
+        relativePathPrefix,
+        strict: true
+      })}${quote}`
+    ).replace(
+      /(<img\b.*?srcset=)(['"])([^\2]*?)\2/gs,
+      (_, prefix, quote, srcset) => `${prefix}${quote}${srcset.split(",").map(
+        (item) => item.trim().replace(
+          /^([^ ]*?)([ \n].*)?$/,
+          (_2, url, descriptor = "") => `${resolveLink(url.trim(), {
+            env,
+            absolutePathPrependBase,
+            relativePathPrefix,
+            strict: true
+          })}${descriptor.replace(/[ \n]+/g, " ").trimEnd()}`
+        )
+      ).join(", ")}${quote}`
+    );
+    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/resolveAttr.ts
+var resolveAttr = (info, attr) => {
+  const pattern = `\\b${attr}\\s*=\\s*(?<quote>['"])(?<content>.+?)\\k<quote>(\\s|$)`;
+  const regex = new RegExp(pattern, "i");
+  const match = info.match(regex);
+  return match?.groups?.content ?? null;
+};
+
+// 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);
+    token.attrJoin("class", languageClass);
+    let result = code.startsWith("<pre") ? code : `<pre${slf.renderAttrs(token)}><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>`;
+    }
+    const title = resolveAttr(info, "title") ?? language.ext;
+    result = `<div class="${languageClass}${useLineNumbers ? " line-numbers-mode" : ""}" data-ext="${language.ext}" data-title="${title}">${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 { full as 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 { colors, fs, logger, path as path3 } from "@vuepress/utils";
+var resolveImportCode = ({ importPath, lineStart, lineEnd }, { filePath }) => {
+  let importFilePath = importPath;
+  if (!path3.isAbsolute(importPath)) {
+    if (!filePath) {
+      logger.error(
+        `Import file ${colors.magenta(importPath)} can not be resolved`
+      );
+      return {
+        importFilePath: null,
+        importCode: "Error when resolving path"
+      };
+    }
+    importFilePath = path3.resolve(filePath, "..", importPath);
+  }
+  if (!fs.existsSync(importFilePath)) {
+    logger.error(`Import file ${colors.magenta(importPath)} not found`);
+    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) {
+      ;
+      (env.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(
+        // file path may contain non-ASCII characters
+        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}`;
+    (env.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,
+    // should always enable html option
+    html: true
+  });
+  if (anchor !== false) {
+    md.use(anchorPlugin, {
+      level: [1, 2, 3, 4, 5, 6],
+      slugify,
+      permalink: anchorPlugin.permalink.headerLink({
+        class: "header-anchor",
+        // Add a span inside the link so Safari shows headings in reader view.
+        safariReaderFix: true
+      }),
+      ...anchor
+    });
+  }
+  if (assets !== false) {
+    md.use(assetsPlugin, assets);
+  }
+  if (code !== false) {
+    md.use(codePlugin, code);
+  }
+  if (component !== false) {
+    md.use(componentPlugin);
+  }
+  if (emoji !== false) {
+    md.use(emojiPlugin, emoji);
+  }
+  if (frontmatter !== false) {
+    md.use(frontmatterPlugin, {
+      ...frontmatter,
+      grayMatterOptions: {
+        excerpt: false,
+        ...frontmatter?.grayMatterOptions
+      }
+    });
+  }
+  if (headers !== false) {
+    md.use(headersPlugin, {
+      level: [2, 3],
+      slugify,
+      ...headers
+    });
+  }
+  if (importCode !== false) {
+    md.use(importCodePlugin, importCode);
+  }
+  if (links !== false) {
+    md.use(linksPlugin, links);
+  }
+  if (sfc !== false) {
+    md.use(sfcPlugin, sfc);
+  }
+  if (toc !== false) {
+    md.use(tocPlugin, {
+      level: [2, 3],
+      slugify,
+      linkTag: "router-link",
+      ...toc
+    });
+  }
+  if (title !== false) {
+    md.use(titlePlugin);
+  }
+  return md;
+};
+export {
+  anchorPlugin,
+  assetsPlugin,
+  codePlugin,
+  componentPlugin,
+  createMarkdown,
+  emojiPlugin,
+  frontmatterPlugin,
+  headersPlugin,
+  importCodePlugin,
+  linksPlugin,
+  sfcPlugin,
+  titlePlugin,
+  tocPlugin
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vuepress/markdown",
-  "version": "2.0.0-beta.9",
+  "version": "2.0.0-rc.1",
   "description": "Markdown package of VuePress",
   "keywords": [
     "vuepress",
@@ -8,33 +8,64 @@
   ],
   "homepage": "https://github.com/vuepress",
   "bugs": {
-    "url": "https://github.com/vuepress/vuepress-next/issues"
+    "url": "https://github.com/vuepress/core/issues"
   },
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/vuepress/vuepress-next.git"
+    "url": "git+https://github.com/vuepress/core.git"
   },
   "license": "MIT",
-  "author": "Evan You",
-  "main": "lib/index.js",
-  "types": "lib/index.d.ts",
+  "author": "meteorlxy",
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.js",
+    "./package.json": "./package.json"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "files": [
-    "lib"
+    "dist"
   ],
-  "scripts": {
-    "build": "tsc -b tsconfig.build.json",
-    "clean": "rimraf lib *.tsbuildinfo"
-  },
   "dependencies": {
-    "@types/markdown-it": "^12.0.1",
-    "@vuepress/shared": "2.0.0-beta.7",
-    "@vuepress/utils": "2.0.0-beta.8",
-    "markdown-it": "^12.0.4",
-    "markdown-it-anchor": "^7.1.0",
-    "markdown-it-emoji": "^2.0.0"
+    "@mdit-vue/plugin-component": "^2.0.0",
+    "@mdit-vue/plugin-frontmatter": "^2.0.0",
+    "@mdit-vue/plugin-headers": "^2.0.0",
+    "@mdit-vue/plugin-sfc": "^2.0.0",
+    "@mdit-vue/plugin-title": "^2.0.0",
+    "@mdit-vue/plugin-toc": "^2.0.0",
+    "@mdit-vue/shared": "^2.0.0",
+    "@mdit-vue/types": "^2.0.0",
+    "@types/markdown-it": "^13.0.7",
+    "@types/markdown-it-emoji": "^2.0.4",
+    "markdown-it": "^14.0.0",
+    "markdown-it-anchor": "^8.6.7",
+    "markdown-it-emoji": "^3.0.0",
+    "mdurl": "^2.0.0",
+    "@vuepress/shared": "2.0.0-rc.1",
+    "@vuepress/utils": "2.0.0-rc.1"
+  },
+  "devDependencies": {
+    "@types/mdurl": "^1.0.5"
   },
   "publishConfig": {
     "access": "public"
   },
-  "gitHead": "edccb16372fabcf160d45ae6207a871e66c81974"
-}
+  "tsup": {
+    "clean": true,
+    "dts": "./src/index.ts",
+    "entry": [
+      "./src/index.ts"
+    ],
+    "format": [
+      "esm"
+    ],
+    "outDir": "./dist",
+    "sourcemap": false,
+    "target": "es2022",
+    "tsconfig": "../../tsconfig.dts.json"
+  },
+  "scripts": {
+    "build": "tsup",
+    "clean": "rimraf dist"
+  }
+}