@nuxtjs/mdc 0.8.1 → 0.8.3

package/dist/module.d.ts

@@ -1,6 +1,84 @@
 import * as _nuxt_schema from '@nuxt/schema';
 import { BundledLanguage, LanguageRegistration, BundledTheme, ThemeRegistrationAny } from 'shiki';
-import { M as MdcThemeOptions } from './shared/mdc.a6f76af4.js';
+import { Options } from 'remark-rehype';
+import { R as RehypeHighlightOption, M as MdcConfig, a as MdcThemeOptions } from './shared/mdc.4762b8bc.js';
+export { A as Awaitable, b as HighlightResult, c as Highlighter, H as HighlighterOptions, d as defineConfig } from './shared/mdc.4762b8bc.js';
+import 'unified';
+import 'hast';
+
+type MDCText = {
+    type: 'text';
+    value: string;
+};
+type MDCComment = {
+    type: 'comment';
+    value: string;
+};
+type MDCElement = {
+    type: 'element';
+    tag: string;
+    props: Record<string, any> | undefined;
+    children: Array<MDCElement | MDCText | MDCComment>;
+};
+type MDCNode = MDCElement | MDCText | MDCComment;
+type MDCRoot = {
+    type: 'root';
+    children: Array<MDCNode>;
+};
+interface MDCData extends Record<string, any> {
+    title: string;
+    description: string;
+}
+
+interface TocLink {
+    id: string;
+    text: string;
+    depth: number;
+    children?: TocLink[];
+}
+interface Toc {
+    title: string;
+    depth: number;
+    searchDepth: number;
+    links: TocLink[];
+}
+
+interface RemarkPlugin {
+    instance?: any;
+    options?: Array<any> | Record<string, any>;
+}
+interface RehypePlugin {
+    instance?: any;
+    options?: Array<any> | Record<string, any>;
+}
+interface MDCParseOptions {
+    remark?: {
+        plugins?: Record<string, false | RemarkPlugin>;
+    };
+    rehype?: {
+        options?: Options;
+        plugins?: Record<string, false | RehypePlugin>;
+    };
+    highlight?: RehypeHighlightOption | false;
+    toc?: {
+        /**
+         * Maximum heading depth to include in the table of contents.
+         */
+        depth?: number;
+        searchDepth?: number;
+    };
+    keepComments?: boolean;
+    /**
+     * Inline mdc.config.ts
+     */
+    configs?: MdcConfig[];
+}
+interface MDCParserResult {
+    data: MDCData;
+    body: MDCRoot;
+    excerpt: MDCRoot | undefined;
+    toc: Toc | undefined;
+}
 
 interface UnistPlugin {
     src?: string;
@@ -69,6 +147,369 @@ interface ModuleOptions {
     };
 }
 
+/**
+ * Info associated with nodes by the ecosystem.
+ *
+ * This space is guaranteed to never be specified by unist or specifications
+ * implementing unist.
+ * But you can use it in utilities and plugins to store data.
+ *
+ * This type can be augmented to register custom data.
+ * For example:
+ *
+ * ```ts
+ * declare module 'unist' {
+ *   interface Data {
+ *     // `someNode.data.myId` is typed as `number | undefined`
+ *     myId?: number | undefined
+ *   }
+ * }
+ * ```
+ */
+interface Data$1 {
+}
+/**
+ * One place in a source file.
+ */
+interface Point {
+    /**
+     * Line in a source file (1-indexed integer).
+     */
+    line: number;
+    /**
+     * Column in a source file (1-indexed integer).
+     */
+    column: number;
+    /**
+     * Character in a source file (0-indexed integer).
+     */
+    offset?: number | undefined;
+}
+/**
+ * Position of a node in a source document.
+ *
+ * A position is a range between two points.
+ */
+interface Position {
+    /**
+     * Place of the first character of the parsed source region.
+     */
+    start: Point;
+    /**
+     * Place of the first character after the parsed source region.
+     */
+    end: Point;
+}
+/**
+ * Abstract unist node that contains the smallest possible value.
+ *
+ * This interface is supposed to be extended.
+ *
+ * For example, in HTML, a `text` node is a leaf that contains text.
+ */
+interface Literal$1 extends Node$1 {
+    /**
+     * Plain value.
+     */
+    value: unknown;
+}
+/**
+ * Abstract unist node.
+ *
+ * The syntactic unit in unist syntax trees are called nodes.
+ *
+ * This interface is supposed to be extended.
+ * If you can use {@link Literal} or {@link Parent}, you should.
+ * But for example in markdown, a `thematicBreak` (`***`), is neither literal
+ * nor parent, but still a node.
+ */
+interface Node$1 {
+    /**
+     * Node type.
+     */
+    type: string;
+    /**
+     * Info from the ecosystem.
+     */
+    data?: Data$1 | undefined;
+    /**
+     * Position of a node in a source document.
+     *
+     * Nodes that are generated (not in the original source document) must not
+     * have a position.
+     */
+    position?: Position | undefined;
+}
+/**
+ * Abstract unist node that contains other nodes (*children*).
+ *
+ * This interface is supposed to be extended.
+ *
+ * For example, in XML, an element is a parent of different things, such as
+ * comments, text, and further elements.
+ */
+interface Parent$1 extends Node$1 {
+    /**
+     * List of children.
+     */
+    children: Node$1[];
+}
+
+/**
+ * Info associated with hast nodes by the ecosystem.
+ *
+ * This space is guaranteed to never be specified by unist or hast.
+ * But you can use it in utilities and plugins to store data.
+ *
+ * This type can be augmented to register custom data.
+ * For example:
+ *
+ * ```ts
+ * declare module 'hast' {
+ *   interface Data {
+ *     // `someNode.data.myId` is typed as `number | undefined`
+ *     myId?: number | undefined
+ *   }
+ * }
+ * ```
+ */
+interface Data extends Data$1 {
+}
+/**
+ * Info associated with an element.
+ */
+interface Properties {
+    [PropertyName: string]: boolean | number | string | null | undefined | Array<string | number>;
+}
+/**
+ * Union of registered hast nodes that can occur in {@link Element}.
+ *
+ * To register mote custom hast nodes, add them to {@link ElementContentMap}.
+ * They will be automatically added here.
+ */
+type ElementContent = ElementContentMap[keyof ElementContentMap];
+/**
+ * Registry of all hast nodes that can occur as children of {@link Element}.
+ *
+ * For a union of all {@link Element} children, see {@link ElementContent}.
+ */
+interface ElementContentMap {
+    comment: Comment;
+    element: Element;
+    text: Text;
+}
+/**
+ * Union of registered hast nodes that can occur in {@link Root}.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap}.
+ * They will be automatically added here.
+ */
+type RootContent = RootContentMap[keyof RootContentMap];
+/**
+ * Registry of all hast nodes that can occur as children of {@link Root}.
+ *
+ * > 👉 **Note**: {@link Root} does not need to be an entire document.
+ * > it can also be a fragment.
+ *
+ * For a union of all {@link Root} children, see {@link RootContent}.
+ */
+interface RootContentMap {
+    comment: Comment;
+    doctype: Doctype;
+    element: Element;
+    text: Text;
+}
+/**
+ * Union of registered hast nodes that can occur in {@link Root}.
+ *
+ * @deprecated Use {@link RootContent} instead.
+ */
+type Content = RootContent;
+/**
+ * Union of registered hast literals.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap} and other
+ * places where relevant.
+ * They will be automatically added here.
+ */
+type Literals = Extract<Nodes, Literal$1>;
+/**
+ * Union of registered hast nodes.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap} and other
+ * places where relevant.
+ * They will be automatically added here.
+ */
+type Nodes = Root | RootContent;
+/**
+ * Union of registered hast parents.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap} and other
+ * places where relevant.
+ * They will be automatically added here.
+ */
+type Parents = Extract<Nodes, Parent$1>;
+/**
+ * Abstract hast node.
+ *
+ * This interface is supposed to be extended.
+ * If you can use {@link Literal} or {@link Parent}, you should.
+ * But for example in HTML, a `Doctype` is neither literal nor parent, but
+ * still a node.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap} and other
+ * places where relevant (such as {@link ElementContentMap}).
+ *
+ * For a union of all registered hast nodes, see {@link Nodes}.
+ */
+interface Node extends Node$1 {
+    /**
+     * Info from the ecosystem.
+     */
+    data?: Data | undefined;
+}
+/**
+ * Abstract hast node that contains the smallest possible value.
+ *
+ * This interface is supposed to be extended if you make custom hast nodes.
+ *
+ * For a union of all registered hast literals, see {@link Literals}.
+ */
+interface Literal extends Node {
+    /**
+     * Plain-text value.
+     */
+    value: string;
+}
+/**
+ * Abstract hast node that contains other hast nodes (*children*).
+ *
+ * This interface is supposed to be extended if you make custom hast nodes.
+ *
+ * For a union of all registered hast parents, see {@link Parents}.
+ */
+interface Parent extends Node {
+    /**
+     * List of children.
+     */
+    children: RootContent[];
+}
+/**
+ * HTML comment.
+ */
+interface Comment extends Literal {
+    /**
+     * Node type of HTML comments in hast.
+     */
+    type: 'comment';
+    /**
+     * Data associated with the comment.
+     */
+    data?: CommentData | undefined;
+}
+/**
+ * Info associated with hast comments by the ecosystem.
+ */
+interface CommentData extends Data {
+}
+/**
+ * HTML document type.
+ */
+interface Doctype extends Node$1 {
+    /**
+     * Node type of HTML document types in hast.
+     */
+    type: 'doctype';
+    /**
+     * Data associated with the doctype.
+     */
+    data?: DoctypeData | undefined;
+}
+/**
+ * Info associated with hast doctypes by the ecosystem.
+ */
+interface DoctypeData extends Data {
+}
+/**
+ * HTML element.
+ */
+interface Element extends Parent {
+    /**
+     * Node type of elements.
+     */
+    type: 'element';
+    /**
+     * Tag name (such as `'body'`) of the element.
+     */
+    tagName: string;
+    /**
+     * Info associated with the element.
+     */
+    properties: Properties;
+    /**
+     * Children of element.
+     */
+    children: ElementContent[];
+    /**
+     * When the `tagName` field is `'template'`, a `content` field can be
+     * present.
+     */
+    content?: Root | undefined;
+    /**
+     * Data associated with the element.
+     */
+    data?: ElementData | undefined;
+}
+/**
+ * Info associated with hast elements by the ecosystem.
+ */
+interface ElementData extends Data {
+}
+/**
+ * Document fragment or a whole document.
+ *
+ * Should be used as the root of a tree and must not be used as a child.
+ *
+ * Can also be used as the value for the content field on a `'template'` element.
+ */
+interface Root extends Parent {
+    /**
+     * Node type of hast root.
+     */
+    type: 'root';
+    /**
+     * Children of root.
+     */
+    children: RootContent[];
+    /**
+     * Data associated with the hast root.
+     */
+    data?: RootData | undefined;
+}
+/**
+ * Info associated with hast root nodes by the ecosystem.
+ */
+interface RootData extends Data {
+}
+/**
+ * HTML character data (plain text).
+ */
+interface Text extends Literal {
+    /**
+     * Node type of HTML character data (plain text) in hast.
+     */
+    type: 'text';
+    /**
+     * Data associated with the text.
+     */
+    data?: TextData | undefined;
+}
+/**
+ * Info associated with hast texts by the ecosystem.
+ */
+interface TextData extends Data {
+}
+
 declare const DefaultHighlightLangs: BundledLanguage[];
 declare const _default: _nuxt_schema.NuxtModule<ModuleOptions>;
 
@@ -101,4 +542,4 @@ declare module '@nuxt/schema' {
     }
 }
 
-export { DefaultHighlightLangs, type ModuleOptions, type UnistPlugin, _default as default };
+export { type Comment, type CommentData, type Content, type Data, DefaultHighlightLangs, type Doctype, type DoctypeData, type Element, type ElementContent, type ElementContentMap, type ElementData, type Literal, type Literals, type MDCComment, type MDCData, type MDCElement, type MDCNode, type MDCParseOptions, type MDCParserResult, type MDCRoot, type MDCText, MdcConfig, MdcThemeOptions, type ModuleOptions, type Node, type Nodes, type Parent, type Parents, type Properties, RehypeHighlightOption, type RehypePlugin, type RemarkPlugin, type Root, type RootContent, type RootContentMap, type RootData, type Text, type TextData, type Toc, type TocLink, type UnistPlugin, _default as default };

package/dist/module.json

@@ -1,9 +1,9 @@
 {
   "name": "@nuxtjs/mdc",
   "configKey": "mdc",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "builder": {
-    "@nuxt/module-builder": "0.7.1",
+    "@nuxt/module-builder": "0.8.1",
     "unbuild": "2.0.0"
   }
 }

package/dist/module.mjs

@@ -4,6 +4,7 @@ import { defu } from 'defu';
 import { resolve } from 'pathe';
 import fs from 'node:fs/promises';
 import { pascalCase } from 'scule';
+export { defineConfig } from './config.mjs';
 
 const registerMDCSlotTransformer = (resolver) => {
   extendViteConfig((config) => {

package/dist/runtime/components/MDC.vue

@@ -21,8 +21,8 @@
 import { hash } from 'ohash'
 import { useAsyncData } from 'nuxt/app'
 import { watch, computed, type PropType } from 'vue'
+import type { MDCParseOptions } from '@nuxtjs/mdc'
 import { parseMarkdown } from '../parser'
-import type { MDCParseOptions } from '../../types'
 
 const props = defineProps({
   tag: {

package/dist/runtime/components/MDCRenderer.vue.d.ts

@@ -1,5 +1,5 @@
 import type { PropType, DefineComponent } from 'vue';
-import type { MDCRoot } from '../../types.js';
+import type { MDCRoot } from '@nuxtjs/mdc';
 declare const _default: DefineComponent<{
     /**
      * Content to render

package/dist/runtime/highlighter/rehype-nuxt.d.ts

@@ -1,3 +1,3 @@
-import { type RehypeHighlightOption } from './rehype.js';
+import type { RehypeHighlightOption } from '@nuxtjs/mdc';
 export default rehypeHighlight;
 export declare function rehypeHighlight(opts?: Partial<RehypeHighlightOption>): (tree: import("hast").Root) => Promise<void>;

package/dist/runtime/highlighter/rehype.d.ts

@@ -1,8 +1,4 @@
 import type { Root } from 'hast';
-import type { Highlighter, MdcThemeOptions } from '../../types/highlighter.js';
-export interface RehypeHighlightOption {
-    theme?: MdcThemeOptions;
-    highlighter?: Highlighter;
-}
+import type { RehypeHighlightOption } from '@nuxtjs/mdc';
 export default rehypeHighlight;
 export declare function rehypeHighlight(opts: RehypeHighlightOption): (tree: Root) => Promise<void>;

package/dist/runtime/highlighter/shiki.d.ts

@@ -1,6 +1,5 @@
 import type { LanguageInput, ThemeInput } from 'shiki';
-import type { MdcConfig } from '../../types/config.js';
-import type { Highlighter } from '../../types/highlighter.js';
+import type { MdcConfig, Highlighter } from '@nuxtjs/mdc';
 export interface CreateShikiHighlighterOptions {
     themes?: ThemeInput[];
     langs?: LanguageInput[];

package/dist/runtime/highlighter/shiki.js

@@ -1,4 +1,4 @@
-import { getHighlighterCore, addClassToHast, isSpecialLang, isSpecialTheme } from "shiki/core";
+import { createHighlighterCore, addClassToHast, isSpecialLang, isSpecialTheme } from "shiki/core";
 import {
   transformerNotationDiff,
   transformerNotationErrorLevel,
@@ -16,7 +16,7 @@ export function createShikiHighlighter({
   let shiki;
   let configs;
   async function _getShiki() {
-    const shiki2 = await getHighlighterCore({
+    const shiki2 = await createHighlighterCore({
       langs,
       themes,
       loadWasm: () => import("shiki/wasm")
@@ -46,6 +46,19 @@ export function createShikiHighlighter({
   ];
   const highlighter = async (code, lang, theme, options = {}) => {
     const shiki2 = await getShiki();
+    const codeToHastOptions = {
+      defaultColor: false,
+      meta: {
+        __raw: options.meta
+      }
+    };
+    if (lang === "ts-type" || lang === "typescript-type") {
+      lang = "typescript";
+      codeToHastOptions.grammarContextCode = "let a:";
+    } else if (lang === "vue-html" || lang === "vue-template") {
+      lang = "vue";
+      codeToHastOptions.grammarContextCode = "<template>";
+    }
     const themesObject = typeof theme === "string" ? { default: theme } : theme || {};
     const loadedThemes = shiki2.getLoadedThemes();
     const loadedLanguages = shiki2.getLoadedLanguages();
@@ -80,11 +93,8 @@ export function createShikiHighlighter({
     }
     const root = shiki2.codeToHast(code.trimEnd(), {
       lang,
+      ...codeToHastOptions,
       themes: themesObject,
-      defaultColor: false,
-      meta: {
-        __raw: options.meta
-      },
       transformers: [
         ...transformers,
         {

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

@@ -1,2 +1,2 @@
-import type { MDCParseOptions } from '../../types.js';
+import type { MDCParseOptions } from '@nuxtjs/mdc';
 export declare function compileHast(this: any, options?: MDCParseOptions): void;

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

@@ -1,4 +1,4 @@
-import type { MDCParseOptions, MDCParserResult, MDCRoot } from '../../types.js';
+import type { MDCParseOptions, MDCParserResult, MDCRoot } from '@nuxtjs/mdc';
 export declare const createMarkdownParser: (inlineOptions?: MDCParseOptions) => Promise<(md: string) => Promise<MDCParserResult>>;
 export declare const parseMarkdown: (md: string, inlineOptions?: MDCParseOptions) => Promise<MDCParserResult>;
 export declare function contentHeading(body: MDCRoot): {

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

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

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

@@ -1,3 +1,3 @@
-import type { MDCNode, Toc, MDCElement, MDCRoot } from '../../types.js';
+import type { MDCNode, Toc, MDCElement, MDCRoot } from '@nuxtjs/mdc';
 export declare function generateFlatToc(body: MDCNode, options: Toc): Toc;
 export declare function generateToc(body: MDCElement | MDCRoot, options: Toc): Toc;

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

@@ -1,2 +1,3 @@
-import type { MDCParseOptions } from '../../../types.js';
-export declare const useProcessorPlugins: (processor: Processor, plugins?: Exclude<MDCParseOptions['rehype'] | MDCParseOptions['remark'], undefined>['plugins']) => Promise<void>;
+import type { Processor } from 'remark-rehype/lib';
+import type { MDCParseOptions } from '@nuxtjs/mdc';
+export declare const useProcessorPlugins: (processor: Processor, plugins?: Exclude<MDCParseOptions["rehype"] | MDCParseOptions["remark"], undefined>["plugins"]) => Promise<void>;

package/dist/runtime/utils/ast.d.ts

@@ -1,4 +1,4 @@
-import type { MDCNode } from '../../types.js';
+import type { MDCNode } from '@nuxtjs/mdc';
 export declare function flattenNodeText(node: MDCNode): string;
 export declare function flattenNode(node: MDCNode, maxDepth?: number, _depth?: number): Array<MDCNode>;
 export declare function setNodeData(node: MDCNode & {

package/dist/runtime/utils/node.d.ts

@@ -1,5 +1,5 @@
 import type { VNode } from 'vue';
-import type { MDCElement, MDCNode } from '../../types.js';
+import type { MDCElement, MDCNode } from '@nuxtjs/mdc';
 /**
  * List of text nodes
  */

package/dist/shared/mdc.4762b8bc.d.mts

@@ -0,0 +1,66 @@
+import { BuiltinTheme, Highlighter as Highlighter$1, ShikiTransformer, HighlighterCore } from 'shiki';
+import { Processor } from 'unified';
+import { ElementContent } from 'hast';
+
+type MdcThemeOptions = BuiltinTheme | string | Record<string, BuiltinTheme | string>;
+interface HighlighterOptions {
+    highlights?: number[];
+    meta?: string;
+}
+interface HighlightResult {
+    tree: ElementContent[];
+    className?: string;
+    style?: string;
+    inlineStyle?: string;
+}
+type Highlighter = (code: string, lang: string, theme: MdcThemeOptions, options: Partial<HighlighterOptions>) => Promise<HighlightResult>;
+interface RehypeHighlightOption {
+    theme?: MdcThemeOptions;
+    highlighter?: Highlighter;
+}
+
+type Awaitable<T> = T | Promise<T>;
+interface MdcConfig {
+    /**
+     * Hooks for the unified markdown pipeline
+     */
+    unified?: {
+        /**
+         * Custom setup for unified processor before other plugins
+         */
+        pre?: (processor: Processor) => Awaitable<void | Processor>;
+        /**
+         * Custom setup for unified processor after remark but before rehype
+         */
+        remark?: (processor: Processor) => Awaitable<void | Processor>;
+        /**
+         * Custom setup for unified processor after rehype
+         */
+        rehype?: (processor: Processor) => Awaitable<void | Processor>;
+        /**
+         * Custom setup for unified processor after all plugins
+         */
+        post?: (processor: Processor) => Awaitable<void | Processor>;
+    };
+    /**
+     * Custom hightlighter, available when `highlighter` is set to `custom`
+     */
+    highlighter?: Highlighter$1;
+    /**
+     * Hooks for shiki
+     */
+    shiki?: {
+        /**
+         * Get transformers for shiki
+         */
+        transformers?: ShikiTransformer[] | ((code: string, lang: string, theme: MdcThemeOptions, options: Partial<HighlighterOptions>) => Awaitable<ShikiTransformer[]>);
+        /**
+         * Custom setup for shiki instance, only called once on server or client
+         */
+        setup?: (highlighter: HighlighterCore) => Awaitable<void>;
+    };
+}
+
+declare function defineConfig(config: MdcConfig): MdcConfig;
+
+export { type Awaitable as A, type HighlighterOptions as H, type MdcConfig as M, type RehypeHighlightOption as R, type MdcThemeOptions as a, type HighlightResult as b, type Highlighter as c, defineConfig as d };