@nuxtjs/mdc 0.1.0

package/dist/runtime/components/prose/ProsePre.vue

@@ -0,0 +1,39 @@
+<template>
+  <pre :class="$props.class"><slot /></pre>
+</template>
+
+<script setup lang="ts">
+defineProps({
+  code: {
+    type: String,
+    default: ''
+  },
+  language: {
+    type: String,
+    default: null
+  },
+  filename: {
+    type: String,
+    default: null
+  },
+  highlights: {
+    type: Array as () => number[],
+    default: () => []
+  },
+  meta: {
+    type: String,
+    default: null
+  },
+  class: {
+    type: String,
+    default: null
+  }
+})
+</script>
+
+<style>
+pre code .line {
+  display: block;
+  min-height: 1rem;
+}
+</style>

package/dist/runtime/components/prose/ProseStrong.vue

@@ -0,0 +1,5 @@
+<template>
+  <strong>
+    <slot />
+  </strong>
+</template>

package/dist/runtime/components/prose/ProseTable.vue

@@ -0,0 +1,5 @@
+<template>
+  <table>
+    <slot />
+  </table>
+</template>

package/dist/runtime/components/prose/ProseTbody.vue

@@ -0,0 +1,5 @@
+<template>
+  <tbody>
+    <slot />
+  </tbody>
+</template>

package/dist/runtime/components/prose/ProseTd.vue

@@ -0,0 +1,5 @@
+<template>
+  <td>
+    <slot />
+  </td>
+</template>

package/dist/runtime/components/prose/ProseTh.vue

@@ -0,0 +1,5 @@
+<template>
+  <th>
+    <slot />
+  </th>
+</template>

package/dist/runtime/components/prose/ProseThead.vue

@@ -0,0 +1,5 @@
+<template>
+  <thead>
+    <slot />
+  </thead>
+</template>

package/dist/runtime/components/prose/ProseTr.vue

@@ -0,0 +1,5 @@
+<template>
+  <tr>
+    <slot />
+  </tr>
+</template>

package/dist/runtime/components/prose/ProseUl.vue

@@ -0,0 +1,5 @@
+<template>
+  <ul>
+    <slot />
+  </ul>
+</template>

package/dist/runtime/index.d.ts

@@ -0,0 +1,3 @@
+export { parseMarkdown } from './parser';
+export { useShikiHighlighter } from './shiki/highlighter';
+export * from './utils/node';

package/dist/runtime/index.mjs

@@ -0,0 +1,3 @@
+export { parseMarkdown } from "./parser/index.mjs";
+export { useShikiHighlighter } from "./shiki/highlighter.mjs";
+export * from "./utils/node.mjs";

package/dist/runtime/parser/compiler.d.ts

@@ -0,0 +1 @@
+export declare function compileHast(this: any): void;

package/dist/runtime/parser/compiler.mjs

@@ -0,0 +1,78 @@
+import { toString } from "hast-util-to-string";
+import Slugger from "github-slugger";
+import { validateProps } from "./utils/props.mjs";
+export function compileHast() {
+  const slugs = new Slugger();
+  function compileToJSON(node) {
+    if (node.type === "root") {
+      return {
+        type: "root",
+        children: node.children.map(compileToJSON).filter(Boolean)
+      };
+    }
+    if (node.type === "element") {
+      if (node.tagName === "p" && node.children.every((child) => child.type === "text" && /^\s*$/.test(child.value))) {
+        return null;
+      }
+      if (node.tagName === "li") {
+        let hasPreviousParagraph = false;
+        node.children = node.children?.flatMap((child) => {
+          if (child.type === "element" && child.tagName === "p") {
+            if (hasPreviousParagraph) {
+              child.children.unshift({
+                type: "element",
+                tagName: "br",
+                properties: {},
+                children: []
+              });
+            }
+            hasPreviousParagraph = true;
+            return child.children;
+          }
+          return child;
+        });
+      }
+      if (node.tagName.startsWith("h")) {
+        node.properties = node.properties || {};
+        node.properties.id = String(node.properties?.id || slugs.slug(toString(node))).replace(/-+/g, "-").replace(/^-|-$/g, "").replace(/^(\d)/, "_$1");
+      }
+      if (node.tagName === "component-slot") {
+        node.tagName = "template";
+      }
+      return {
+        type: "element",
+        tag: node.tagName,
+        props: validateProps(node.properties),
+        children: node.children.map(compileToJSON).filter(Boolean)
+      };
+    }
+    if (node.type === "text" && node.value !== "\n") {
+      return {
+        type: "text",
+        value: node.value
+      };
+    }
+    return null;
+  }
+  this.Compiler = (tree) => {
+    const body = compileToJSON(tree);
+    let excerpt = void 0;
+    const excerptIndex = tree.children.findIndex((node) => node.type === "comment" && node.value?.trim() === "more");
+    if (excerptIndex !== -1) {
+      excerpt = compileToJSON({
+        type: "root",
+        children: tree.children.slice(0, excerptIndex)
+      });
+      if (excerpt.children.find((node) => node.type === "element" && node.tag === "pre")) {
+        const lastChild = body.children[body.children.length - 1];
+        if (lastChild.type === "element" && lastChild.tag === "style") {
+          excerpt.children.push(lastChild);
+        }
+      }
+    }
+    return {
+      body,
+      excerpt
+    };
+  };
+}

package/dist/runtime/parser/handlers/code.d.ts

@@ -0,0 +1,5 @@
+import { type State } from 'mdast-util-to-hast';
+import { type Element } from 'hast';
+import { type Code } from 'mdast';
+declare const _default: (state: State, node: Code) => Element;
+export default _default;

package/dist/runtime/parser/handlers/code.mjs

@@ -0,0 +1,31 @@
+import { detab } from "detab";
+import { parseThematicBlock } from "./utils.mjs";
+export default (state, node) => {
+  const lang = (node.lang || "") + " " + (node.meta || "");
+  const { language, highlights, filename, meta } = parseThematicBlock(lang);
+  const value = node.value ? detab(node.value + "\n") : "";
+  let result = {
+    type: "element",
+    tagName: "code",
+    properties: { __ignoreMap: "" },
+    children: [{ type: "text", value }]
+  };
+  if (node.meta) {
+    result.data = { meta: node.meta };
+  }
+  state.patch(node, result);
+  result = state.applyData(node, result);
+  const properties = {
+    language,
+    filename,
+    highlights,
+    meta,
+    code: value
+  };
+  if (node.lang) {
+    properties.className = ["language-" + node.lang];
+  }
+  result = { type: "element", tagName: "pre", properties, children: [result] };
+  state.patch(node, result);
+  return result;
+};

package/dist/runtime/parser/handlers/containerComponent.d.ts

@@ -0,0 +1,10 @@
+import { type State } from 'mdast-util-to-hast';
+import { type Element, type Properties } from 'hast';
+import { type Nodes as MdastContent } from 'mdast';
+type Node = MdastContent & {
+    name: string;
+    attributes?: Properties;
+    fmAttributes?: Properties;
+};
+export default function containerComponent(state: State, node: Node): Element;
+export {};

package/dist/runtime/parser/handlers/containerComponent.mjs

@@ -0,0 +1,15 @@
+export default function containerComponent(state, node) {
+  const result = {
+    type: "element",
+    tagName: node.name,
+    properties: {
+      ...node.attributes,
+      ...node.data?.hProperties
+    },
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  result.attributes = node.attributes;
+  result.fmAttributes = node.fmAttributes;
+  return result;
+}

package/dist/runtime/parser/handlers/emphasis.d.ts

@@ -0,0 +1,6 @@
+import { type State } from 'mdast-util-to-hast';
+import { type Element, type Properties } from 'hast';
+import { type Emphasis } from 'mdast';
+export default function emphasis(state: State, node: Emphasis & {
+    attributes?: Properties;
+}): Element;

package/dist/runtime/parser/handlers/emphasis.mjs

@@ -0,0 +1,10 @@
+export default function emphasis(state, node) {
+  const result = {
+    type: "element",
+    tagName: "em",
+    properties: node.attributes || {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}

package/dist/runtime/parser/handlers/html.d.ts

@@ -0,0 +1,3 @@
+import { type State, type Raw } from 'mdast-util-to-hast';
+import { type Html } from 'mdast';
+export default function html(state: State, node: Html): import("hast").Element | Raw | undefined;

package/dist/runtime/parser/handlers/html.mjs

@@ -0,0 +1,14 @@
+import { kebabCase } from "scule";
+import { getTagName } from "./utils.mjs";
+export default function html(state, node) {
+  const tagName = getTagName(node.value);
+  if (tagName && /[A-Z]/.test(tagName)) {
+    node.value = node.value.replace(tagName, kebabCase(tagName));
+  }
+  if (state.dangerous || state.options?.allowDangerousHtml) {
+    const result = { type: "raw", value: node.value };
+    state.patch(node, result);
+    return state.applyData(node, result);
+  }
+  return void 0;
+}

package/dist/runtime/parser/handlers/image.d.ts

@@ -0,0 +1,6 @@
+import { type State } from 'mdast-util-to-hast';
+import { type Element, type Properties } from 'hast';
+import { type Image } from 'mdast';
+export default function image(state: State, node: Image & {
+    attributes?: Properties;
+}): Element;

package/dist/runtime/parser/handlers/image.mjs

@@ -0,0 +1,13 @@
+import { normalizeUri } from "micromark-util-sanitize-uri";
+export default function image(state, node) {
+  const properties = { ...node.attributes, src: normalizeUri(node.url) };
+  if (node.alt !== null && node.alt !== void 0) {
+    properties.alt = node.alt;
+  }
+  if (node.title !== null && node.title !== void 0) {
+    properties.title = node.title;
+  }
+  const result = { type: "element", tagName: "img", properties, children: [] };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}

package/dist/runtime/parser/handlers/index.d.ts

@@ -0,0 +1,22 @@
+import emphasis from './emphasis';
+import html from './html';
+import link from './link';
+import list from './list';
+import paragraph from './paragraph';
+import image from './image';
+import strong from './strong';
+import inlineCode from './inlineCode';
+import containerComponent from './containerComponent';
+declare const _default: {
+    emphasis: typeof emphasis;
+    code: (state: import("mdast-util-to-hast").State, node: import("mdast").Code) => import("hast").Element;
+    link: typeof link;
+    paragraph: typeof paragraph;
+    html: typeof html;
+    list: typeof list;
+    image: typeof image;
+    strong: typeof strong;
+    inlineCode: typeof inlineCode;
+    containerComponent: typeof containerComponent;
+};
+export default _default;

package/dist/runtime/parser/handlers/index.mjs

@@ -0,0 +1,22 @@
+import emphasis from "./emphasis.mjs";
+import code from "./code.mjs";
+import html from "./html.mjs";
+import link from "./link.mjs";
+import list from "./list.mjs";
+import paragraph from "./paragraph.mjs";
+import image from "./image.mjs";
+import strong from "./strong.mjs";
+import inlineCode from "./inlineCode.mjs";
+import containerComponent from "./containerComponent.mjs";
+export default {
+  emphasis,
+  code,
+  link,
+  paragraph,
+  html,
+  list,
+  image,
+  strong,
+  inlineCode,
+  containerComponent
+};

package/dist/runtime/parser/handlers/inlineCode.d.ts

@@ -0,0 +1,6 @@
+import { type State } from 'mdast-util-to-hast';
+import { type Element, type Properties } from 'hast';
+import { type InlineCode } from 'mdast';
+export default function inlineCode(state: State, node: InlineCode & {
+    attributes?: Properties;
+}): Element;

package/dist/runtime/parser/handlers/inlineCode.mjs

@@ -0,0 +1,12 @@
+export default function inlineCode(state, node) {
+  const text = { type: "text", value: node.value.replace(/\r?\n|\r/g, " ") };
+  state.patch(node, text);
+  const result = {
+    type: "element",
+    tagName: "code",
+    properties: node.attributes || {},
+    children: [text]
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}

package/dist/runtime/parser/handlers/link.d.ts

@@ -0,0 +1,6 @@
+import { type State } from 'mdast-util-to-hast';
+import { type Element, type Properties } from 'hast';
+import { type Link } from 'mdast';
+export default function link(state: State, node: Link & {
+    attributes?: Properties;
+}): Element;

package/dist/runtime/parser/handlers/link.mjs

@@ -0,0 +1,18 @@
+import { normalizeUri } from "micromark-util-sanitize-uri";
+export default function link(state, node) {
+  const properties = {
+    ...node.attributes || {},
+    href: normalizeUri(node.url)
+  };
+  if (node.title !== null && node.title !== void 0) {
+    properties.title = node.title;
+  }
+  const result = {
+    type: "element",
+    tagName: "a",
+    properties,
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}

package/dist/runtime/parser/handlers/list.d.ts

@@ -0,0 +1,4 @@
+import { type State } from 'mdast-util-to-hast';
+import { type Element } from 'hast';
+import { type List } from 'mdast';
+export default function list(state: State, node: List): Element;

package/dist/runtime/parser/handlers/list.mjs

@@ -0,0 +1,26 @@
+export default function list(state, node) {
+  const properties = {};
+  const results = state.all(node);
+  let index = -1;
+  if (typeof node.start === "number" && node.start !== 1) {
+    properties.start = node.start;
+  }
+  while (++index < results.length) {
+    const child = results[index];
+    if (child.type === "element" && child.tagName === "li" && child.properties && Array.isArray(child.properties.className) && child.properties.className.includes("task-list-item")) {
+      properties.className = ["contains-task-list"];
+      break;
+    }
+  }
+  if ((node.children || []).some((child) => typeof child.checked === "boolean")) {
+    properties.className = ["contains-task-list"];
+  }
+  const result = {
+    type: "element",
+    tagName: node.ordered ? "ol" : "ul",
+    properties,
+    children: state.wrap(results, true)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}

package/dist/runtime/parser/handlers/paragraph.d.ts

@@ -0,0 +1,4 @@
+import { type State } from 'mdast-util-to-hast';
+import { type Element } from 'hast';
+import { type Paragraph } from 'mdast';
+export default function paragraph(state: State, node: Paragraph): Element | import("hast").ElementContent[];

package/dist/runtime/parser/handlers/paragraph.mjs

@@ -0,0 +1,19 @@
+import { kebabCase } from "scule";
+import htmlTags from "../utils/html-tags-list.mjs";
+import { getTagName } from "./utils.mjs";
+export default function paragraph(state, node) {
+  if (node.children && node.children[0] && node.children[0].type === "html") {
+    const tagName = kebabCase(getTagName(node.children[0].value) || "div");
+    if (!htmlTags.includes(tagName)) {
+      return state.all(node);
+    }
+  }
+  const result = {
+    type: "element",
+    tagName: "p",
+    properties: {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}

package/dist/runtime/parser/handlers/strong.d.ts

@@ -0,0 +1,6 @@
+import { type State } from 'mdast-util-to-hast';
+import { type Element, type Properties } from 'hast';
+import { type Strong } from 'mdast';
+export default function strong(state: State, node: Strong & {
+    attributes?: Properties;
+}): Element;

package/dist/runtime/parser/handlers/strong.mjs

@@ -0,0 +1,10 @@
+export default function strong(state, node) {
+  const result = {
+    type: "element",
+    tagName: "strong",
+    properties: node.attributes || {},
+    children: state.all(node)
+  };
+  state.patch(node, result);
+  return state.applyData(node, result);
+}

package/dist/runtime/parser/handlers/utils.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Parses the value defined next to 3 back ticks
+ * in a codeblock and set line-highlights or
+ * filename from it
+ */
+export declare function parseThematicBlock(lang: string): {
+    language: undefined;
+    highlights: undefined;
+    fileName: undefined;
+    meta: undefined;
+    filename?: undefined;
+} | {
+    language: string | undefined;
+    highlights: number[] | undefined;
+    filename: string | undefined;
+    meta: string;
+    fileName?: undefined;
+};
+export declare function getTagName(value: string): string | null;

package/dist/runtime/parser/handlers/utils.mjs

@@ -0,0 +1,33 @@
+export function parseThematicBlock(lang) {
+  if (!lang?.trim()) {
+    return {
+      language: void 0,
+      highlights: void 0,
+      fileName: void 0,
+      meta: void 0
+    };
+  }
+  const languageMatches = lang.replace(/[{|[](.+)/, "").match(/^[^ \t]+(?=[ \t]|$)/);
+  const highlightTokensMatches = lang.match(/{([^}]*)}/);
+  const filenameMatches = lang.match(/\[((\\]|[^\]])*)\]/);
+  const meta = lang.replace(languageMatches?.[0] ?? "", "").replace(highlightTokensMatches?.[0] ?? "", "").replace(filenameMatches?.[0] ?? "", "").trim();
+  return {
+    language: languageMatches?.[0] || void 0,
+    highlights: parseHighlightedLines(highlightTokensMatches?.[1] || void 0),
+    // https://github.com/nuxt/content/pull/2169
+    filename: filenameMatches?.[1].replace(/\\]/g, "]") || void 0,
+    meta
+  };
+}
+function parseHighlightedLines(lines) {
+  const lineArray = String(lines || "").split(",").filter(Boolean).flatMap((line) => {
+    const [start, end] = line.trim().split("-").map((a) => Number(a.trim()));
+    return Array.from({ length: (end || start) - start + 1 }).map((_, i) => start + i);
+  });
+  return lineArray.length ? lineArray : void 0;
+}
+const TAG_NAME_REGEXP = /^<\/?([A-Za-z0-9-_]+) ?[^>]*>/;
+export function getTagName(value) {
+  const result = String(value).match(TAG_NAME_REGEXP);
+  return result && result[1];
+}

package/dist/runtime/parser/index.d.ts

@@ -0,0 +1,11 @@
+import type { MDCData, MDCParseOptions, MDCRoot, Toc } from '../types';
+export declare const parseMarkdown: (md: string, opts?: MDCParseOptions) => Promise<{
+    data: MDCData;
+    body: MDCRoot;
+    excerpt: MDCRoot | undefined;
+    toc: Toc | undefined;
+}>;
+export declare function contentHeading(body: MDCRoot): {
+    title: string;
+    description: string;
+};

package/dist/runtime/parser/index.mjs

@@ -0,0 +1,60 @@
+import { unified } from "unified";
+import remarkParse from "remark-parse";
+import remark2rehype from "remark-rehype";
+import remarkMDC, { parseFrontMatter } from "remark-mdc";
+import { defu } from "defu";
+import { useProcessorPlugins } from "./utils/plugins.mjs";
+import { compileHast } from "./compiler.mjs";
+import { defaults } from "./options.mjs";
+import { rehypeShiki } from "./shiki.mjs";
+import { generateToc } from "./toc.mjs";
+import { nodeTextContent } from "../utils/node.mjs";
+export const parseMarkdown = async (md, opts = {}) => {
+  const options = defu(opts, defaults);
+  const { content, data: frontmatter } = await parseFrontMatter(md);
+  const processor = unified();
+  processor.use(remarkParse);
+  processor.use(remarkMDC);
+  await useProcessorPlugins(processor, options.remark?.plugins);
+  processor.use(remark2rehype, options.rehype?.options);
+  if (options.highlight) {
+    processor.use(rehypeShiki, options.highlight);
+  }
+  await useProcessorPlugins(processor, options.rehype?.plugins);
+  processor.use(compileHast);
+  const processedFile = await processor.process({ value: content, data: frontmatter });
+  const result = processedFile.result;
+  const data = Object.assign(
+    contentHeading(result.body),
+    frontmatter,
+    processedFile?.data || {}
+  );
+  let toc;
+  if (data.toc !== false) {
+    const tocOption = defu(data.toc || {}, options.toc);
+    toc = generateToc(result.body, tocOption);
+  }
+  return {
+    data,
+    body: result.body,
+    excerpt: result.excerpt,
+    toc
+  };
+};
+export function contentHeading(body) {
+  let title = "";
+  let description = "";
+  const children = body.children.filter((node) => node.type !== "text" && node.tag !== "hr");
+  if (children.length && children[0].tag === "h1") {
+    const node = children.shift();
+    title = nodeTextContent(node);
+  }
+  if (children.length && children[0].tag === "p") {
+    const node = children.shift();
+    description = nodeTextContent(node);
+  }
+  return {
+    title,
+    description
+  };
+}

package/dist/runtime/parser/options.d.ts

@@ -0,0 +1,2 @@
+import type { MDCParseOptions } from '../types';
+export declare const defaults: MDCParseOptions;