vuepress-plugin-md-power 1.0.0-rc.48

package/lib/node/features/caniuse.js

@@ -0,0 +1,129 @@
+import container from 'markdown-it-container';
+// @[caniuse]()
+const minLength = 12;
+// char codes of '@[caniuse'
+const START_CODES = [64, 91, 99, 97, 110, 105, 117, 115, 101];
+// regexp to match the import syntax
+const SYNTAX_RE = /^@\[caniuse(?:\s*?(embed|image)?(?:{([0-9,\-]*?)})?)\]\(([^)]*)\)/;
+function createCanIUseRuleBlock(defaultMode) {
+    return (state, startLine, endLine, silent) => {
+        const pos = state.bMarks[startLine] + state.tShift[startLine];
+        const max = state.eMarks[startLine];
+        // return false if the length is shorter than min length
+        if (pos + minLength > max)
+            return false;
+        // check if it's matched the start
+        for (let i = 0; i < START_CODES.length; i += 1) {
+            if (state.src.charCodeAt(pos + i) !== START_CODES[i])
+                return false;
+        }
+        // check if it's matched the syntax
+        const match = state.src.slice(pos, max).match(SYNTAX_RE);
+        if (!match)
+            return false;
+        // return true as we have matched the syntax
+        if (silent)
+            return true;
+        const [, mode, versions = '', feature] = match;
+        const meta = {
+            feature,
+            mode: mode || defaultMode,
+            versions,
+        };
+        const token = state.push('caniuse', '', 0);
+        token.meta = meta;
+        token.map = [startLine, startLine + 1];
+        token.info = mode || defaultMode;
+        state.line = startLine + 1;
+        return true;
+    };
+}
+function resolveCanIUse({ feature, mode, versions }) {
+    if (!feature)
+        return '';
+    if (mode === 'image') {
+        const link = 'https://caniuse.bitsofco.de/image/';
+        const alt = `Data on support for the ${feature} feature across the major browsers from caniuse.com`;
+        return `<ClientOnly><p><picture>
+      <source type="image/webp" srcset="${link}${feature}.webp">
+      <source type="image/png" srcset="${link}${feature}.png">
+      <img src="${link}${feature}.jpg" alt="${alt}" width="100%">
+    </picture></p></ClientOnly>`;
+    }
+    const periods = resolveVersions(versions);
+    const accessible = 'false';
+    const image = 'none';
+    const url = 'https://caniuse.bitsofco.de/embed/index.html';
+    const src = `${url}?feat=${feature}&periods=${periods}&accessible-colours=${accessible}&image-base=${image}`;
+    return `<ClientOnly><div class="ciu_embed" style="margin:16px 0" data-feature="${feature}"><iframe src="${src}" frameborder="0" width="100%" height="400px" title="Can I use${feature}"></iframe></div></ClientOnly>`;
+}
+function resolveVersions(versions) {
+    if (!versions)
+        return 'future_1,current,past_1,past_2';
+    const list = versions
+        .split(',')
+        .map(v => Number(v.trim()))
+        .filter(v => !Number.isNaN(v) && v >= -5 && v <= 3);
+    list.push(0);
+    const uniq = [...new Set(list)].sort((a, b) => b - a);
+    const result = [];
+    uniq.forEach((v) => {
+        if (v < 0)
+            result.push(`past_${Math.abs(v)}`);
+        if (v === 0)
+            result.push('current');
+        if (v > 0)
+            result.push(`future_${v}`);
+    });
+    return result.join(',');
+}
+/**
+ * @example
+ * ```md
+ * @[caniuse](feature_name)
+ * ```
+ */
+export const caniusePlugin = (md, { mode = 'embed' } = {}) => {
+    md.block.ruler.before('import_code', 'caniuse', createCanIUseRuleBlock(mode), {
+        alt: ['paragraph', 'reference', 'blockquote', 'list'],
+    });
+    md.renderer.rules.caniuse = (tokens, index) => {
+        const token = tokens[index];
+        const content = resolveCanIUse(token.meta);
+        token.content = content;
+        return content;
+    };
+};
+/**
+ * @deprecated use caniuse plugin
+ *
+ * 兼容旧语法
+ * @example
+ * ```md
+ * :::caniuse <feature_name>
+ * :::
+ * ```
+ */
+export function legacyCaniuse(md, { mode = 'embed' } = {}) {
+    const modeMap = ['image', 'embed'];
+    const isMode = (mode) => modeMap.includes(mode);
+    mode = isMode(mode) ? mode : modeMap[0];
+    const type = 'caniuse';
+    const validateReg = new RegExp(`^${type}\\s+(.*)$`);
+    const validate = (info) => {
+        return validateReg.test(info.trim());
+    };
+    const render = (tokens, index) => {
+        const token = tokens[index];
+        if (token.nesting === 1) {
+            const info = token.info.trim().slice(type.length).trim() || '';
+            const feature = info.split(/\s+/)[0];
+            const versions = info.match(/\{(.*)\}/)?.[1] || '';
+            return feature ? resolveCanIUse({ feature, mode, versions }) : '';
+        }
+        else {
+            return '';
+        }
+    };
+    md.use(container, type, { validate, render });
+}

package/lib/node/features/codepen.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @[codepen](user/slash)
+ * @[codepen preview](user/slash)
+ * @[codepen preview editable title="" height="400px" tab="css,result" theme="dark"](user/slash)
+ */
+import type { PluginWithOptions } from 'markdown-it';
+export declare const codepenPlugin: PluginWithOptions<never>;

package/lib/node/features/codepen.js

@@ -0,0 +1,72 @@
+import { resolveAttrs } from '../utils/resolveAttrs.js';
+import { parseRect } from '../utils/parseRect.js';
+const CODEPEN_LINK = 'https://codepen.io/';
+// @[codepen]()
+const MIN_LENGTH = 12;
+// char codes of `@[codepen`
+const START_CODES = [64, 91, 99, 111, 100, 101, 112, 101, 110];
+// regexp to match the import syntax
+const SYNTAX_RE = /^@\[codepen(?:\s+([^]*?))?\]\(([^)]*?)\)/;
+function createCodepenRuleBlock() {
+    return (state, startLine, endLine, silent) => {
+        const pos = state.bMarks[startLine] + state.tShift[startLine];
+        const max = state.eMarks[startLine];
+        // return false if the length is shorter than min length
+        if (pos + MIN_LENGTH > max)
+            return false;
+        // check if it's matched the start
+        for (let i = 0; i < START_CODES.length; i += 1) {
+            if (state.src.charCodeAt(pos + i) !== START_CODES[i])
+                return false;
+        }
+        // check if it's matched the syntax
+        const match = state.src.slice(pos, max).match(SYNTAX_RE);
+        if (!match)
+            return false;
+        // return true as we have matched the syntax
+        if (silent)
+            return true;
+        const [, info = '', source] = match;
+        const { attrs } = resolveAttrs(info);
+        const [user, slash] = source.split('/');
+        const meta = {
+            width: attrs.width ? parseRect(attrs.width) : '100%',
+            height: attrs.height ? parseRect(attrs.height) : '400px',
+            user,
+            slash,
+            title: attrs.title,
+            preview: attrs.preview,
+            editable: attrs.editable,
+            tab: attrs.tab ?? 'result',
+            theme: attrs.theme,
+        };
+        const token = state.push('codepen', '', 0);
+        token.meta = meta;
+        token.map = [startLine, startLine + 1];
+        token.info = info;
+        state.line = startLine + 1;
+        return true;
+    };
+}
+function resolveCodepen(meta) {
+    const { title = 'Codepen', height, width } = meta;
+    const params = new URLSearchParams();
+    meta.editable && params.set('editable', 'true');
+    meta.tab && params.set('default-tab', meta.tab);
+    meta.theme && params.set('theme-id', meta.theme);
+    const middle = meta.preview ? '/embed/preview/' : '/embed/';
+    const link = `${CODEPEN_LINK}${meta.user}${middle}${meta.slash}?${params.toString()}`;
+    const style = `width:${width};height:${height};margin:16px auto;border-radius:5px;`;
+    return `<iframe class="code-pen-iframe-wrapper" src="${link}" title="${title}" style="${style}" frameborder="no" loading="lazy" allowtransparency="true" allowfullscreen="true">See the Pen <a href="${CODEPEN_LINK}${meta.user}/pen/${meta.slash}">${title}</a> by ${meta.user} (<a href="${CODEPEN_LINK}${meta.user}">@${meta.user}</a>) on <a href="${CODEPEN_LINK}">CodePen</a>.</iframe>`;
+}
+export const codepenPlugin = (md) => {
+    md.block.ruler.before('import_code', 'codepen', createCodepenRuleBlock(), {
+        alt: ['paragraph', 'reference', 'blockquote', 'list'],
+    });
+    md.renderer.rules.codepen = (tokens, index) => {
+        const token = tokens[index];
+        const content = resolveCodepen(token.meta);
+        token.content = content;
+        return content;
+    };
+};

package/lib/node/features/icons/index.d.ts

@@ -0,0 +1,2 @@
+export * from './writer.js';
+export * from './plugin.js';

package/lib/node/features/icons/index.js

@@ -0,0 +1,2 @@
+export * from './writer.js';
+export * from './plugin.js';

package/lib/node/features/icons/plugin.d.ts

@@ -0,0 +1,10 @@
+/**
+ * :[mdi:11]:
+ * :[mdi:11 24px]:
+ * :[mid:11 /#ccc]:
+ * :[fluent-mdl2:toggle-filled 128px/#fff]:
+ */
+import type { PluginWithOptions } from 'markdown-it';
+type AddIcon = (iconName: string) => string | undefined;
+export declare const iconsPlugin: PluginWithOptions<AddIcon>;
+export {};

package/lib/node/features/icons/plugin.js

@@ -0,0 +1,60 @@
+import { parseRect } from '../../utils/parseRect.js';
+function createTokenizer(addIcon) {
+    return (state, silent) => {
+        let found = false;
+        const max = state.posMax;
+        const start = state.pos;
+        if (state.src.slice(start, start + 2) !== ':[')
+            return false;
+        if (silent)
+            return false;
+        // :[]:
+        if (max - start < 5)
+            return false;
+        state.pos = start + 2;
+        while (state.pos < max) {
+            if (state.src.slice(state.pos, state.pos + 2) === ']:') {
+                found = true;
+                break;
+            }
+            state.md.inline.skipToken(state);
+        }
+        if (!found || start + 2 === state.pos) {
+            state.pos = start;
+            return false;
+        }
+        const content = state.src.slice(start + 2, state.pos);
+        // 不允许前后带有空格
+        if (/^\s|\s$/.test(content)) {
+            state.pos = start;
+            return false;
+        }
+        // found!
+        state.posMax = state.pos;
+        state.pos = start + 2;
+        const [iconName, options = ''] = content.split(/\s+/);
+        const [size, color] = options.split('/');
+        const open = state.push('iconify_open', 'span', 1);
+        open.markup = ':[';
+        const className = addIcon(iconName);
+        if (className)
+            open.attrSet('class', className);
+        let style = '';
+        if (size)
+            style += `width:${parseRect(size)};height:${parseRect(size)};`;
+        if (color)
+            style += `color:${color};`;
+        if (style)
+            open.attrSet('style', style);
+        const text = state.push('text', '', 0);
+        text.content = className ? '' : iconName;
+        const close = state.push('iconify_close', 'span', -1);
+        close.markup = ']:';
+        state.pos = state.posMax + 2;
+        state.posMax = max;
+        return true;
+    };
+}
+export const iconsPlugin = (md, addIcon = () => '') => {
+    md.inline.ruler.before('emphasis', 'iconify', createTokenizer(addIcon));
+};

package/lib/node/features/icons/writer.d.ts

@@ -0,0 +1,11 @@
+import type { App } from 'vuepress/core';
+import type { IconsOptions } from '../../../shared/icons.js';
+export interface IconCacheItem {
+    className: string;
+    content: string;
+}
+export declare function createIconCSSWriter(app: App, opt?: boolean | IconsOptions): {
+    addIcon: (iconName: string) => string | undefined;
+    writeCss: () => Promise<void>;
+    initIcon: () => Promise<string | void>;
+};

package/lib/node/features/icons/writer.js

@@ -0,0 +1,100 @@
+import { getIconContentCSS, getIconData } from '@iconify/utils';
+import { fs, logger } from 'vuepress/utils';
+import { isPackageExists } from 'local-pkg';
+import { customAlphabet } from 'nanoid';
+import { interopDefault } from '../../utils/package.js';
+import { parseRect } from '../../utils/parseRect.js';
+const nanoid = customAlphabet('abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ', 8);
+const iconDataCache = new Map();
+const URL_CONTENT_RE = /(url\([^]+?\))/;
+function resolveOption(opt) {
+    const options = typeof opt === 'object' ? opt : {};
+    options.prefix ??= 'vp-mdi';
+    options.color = options.color === 'currentColor' || !options.color ? 'currentcolor' : options.color;
+    options.size = options.size ? parseRect(`${options.size}`) : '1em';
+    return options;
+}
+export function createIconCSSWriter(app, opt) {
+    const cache = new Map();
+    const isInstalled = isPackageExists('@iconify/json');
+    const write = (content) => app.writeTemp('internal/md-power/icons.css', content);
+    const options = resolveOption(opt);
+    const prefix = options.prefix;
+    const defaultContent = getDefaultContent(options);
+    async function writeCss() {
+        let css = defaultContent;
+        for (const [, { content, className }] of cache)
+            css += `.${className} {\n  --svg: ${content};\n}\n`;
+        await write(css);
+    }
+    function addIcon(iconName) {
+        if (!isInstalled)
+            return;
+        if (cache.has(iconName))
+            return cache.get(iconName).className;
+        const item = {
+            className: `${prefix}-${nanoid()}`,
+            content: '',
+        };
+        cache.set(iconName, item);
+        genIconContent(iconName, (content) => {
+            item.content = content;
+            writeCss();
+        });
+        return item.className;
+    }
+    async function initIcon() {
+        if (!opt)
+            return await write('');
+        if (!isInstalled) {
+            logger.error('[plugin-md-power]: `@iconify/json` not found! Please install `@iconify/json` first.');
+            return;
+        }
+        return await writeCss();
+    }
+    return { addIcon, writeCss, initIcon };
+}
+function getDefaultContent(options) {
+    const { prefix, size, color } = options;
+    return `[class^="${prefix}-"],
+[class*=" ${prefix}-"] {
+  display: inline-block;
+  width: ${size};
+  height: ${size};
+  vertical-align: middle;
+  color: inherit;
+  background-color: ${color};
+  -webkit-mask: var(--svg) no-repeat;
+  mask: var(--svg) no-repeat;
+  -webkit-mask-size: 100% 100%;
+  mask-size: 100% 100%;
+}
+`;
+}
+let locate;
+async function genIconContent(iconName, cb) {
+    if (!locate) {
+        const mod = await interopDefault(import('@iconify/json'));
+        locate = mod.locate;
+    }
+    const [collect, name] = iconName.split(':');
+    let iconJson = iconDataCache.get(collect);
+    if (!iconJson) {
+        const filename = locate(collect);
+        try {
+            iconJson = JSON.parse(await fs.readFile(filename, 'utf-8'));
+            iconDataCache.set(collect, iconJson);
+        }
+        catch (e) {
+            logger.warn(`[plugin-md-power] Can not find icon, ${collect} is missing!`);
+        }
+    }
+    const data = getIconData(iconJson, name);
+    if (!data)
+        return logger.error(`[plugin-md-power] Can not read icon in ${collect}, ${name} is missing!`);
+    const content = getIconContentCSS(data, {
+        height: data.height || 24,
+    });
+    const match = content.match(URL_CONTENT_RE);
+    return cb(match ? match[1] : '');
+}

package/lib/node/features/pdf.d.ts

@@ -0,0 +1,2 @@
+import type { PluginWithOptions } from 'markdown-it';
+export declare const pdfPlugin: PluginWithOptions<never>;

package/lib/node/features/pdf.js

@@ -0,0 +1,68 @@
+/**
+ * @[pdf](/xxx)
+ * @[pdf 1](/xxx)
+ * @[pdf 1 no-toolbar width="100%" height="600px" zoom="1" ratio="1:1"](/xxx)
+ */
+import { path } from 'vuepress/utils';
+import { resolveAttrs } from '../utils/resolveAttrs.js';
+import { parseRect } from '../utils/parseRect.js';
+// @[pdf]()
+const MIN_LENGTH = 8;
+// char codes of `@[pdf`
+const START_CODES = [64, 91, 112, 100, 102];
+// regexp to match the import syntax
+const SYNTAX_RE = /^@\[pdf(?:\s+(\d+))?(?:\s+([^]*?))?\]\(([^)]*?)\)/;
+function createPDFRuleBlock() {
+    return (state, startLine, endLine, silent) => {
+        const pos = state.bMarks[startLine] + state.tShift[startLine];
+        const max = state.eMarks[startLine];
+        // return false if the length is shorter than min length
+        if (pos + MIN_LENGTH > max)
+            return false;
+        // check if it's matched the start
+        for (let i = 0; i < START_CODES.length; i += 1) {
+            if (state.src.charCodeAt(pos + i) !== START_CODES[i])
+                return false;
+        }
+        // check if it's matched the syntax
+        const match = state.src.slice(pos, max).match(SYNTAX_RE);
+        if (!match)
+            return false;
+        // return true as we have matched the syntax
+        if (silent)
+            return true;
+        const [, page, info = '', src] = match;
+        const { attrs } = resolveAttrs(info);
+        const meta = {
+            src,
+            page: +page || 1,
+            noToolbar: Boolean(attrs.noToolbar ?? false),
+            zoom: +attrs.zoom || 1,
+            width: attrs.width ? parseRect(attrs.width) : '100%',
+            height: attrs.height ? parseRect(attrs.height) : '',
+            ratio: attrs.ratio ? parseRect(attrs.ratio) : '',
+            title: path.basename(src || ''),
+        };
+        const token = state.push('pdf', '', 0);
+        token.meta = meta;
+        token.map = [startLine, startLine + 1];
+        token.info = info;
+        state.line = startLine + 1;
+        return true;
+    };
+}
+function resolvePDF(meta) {
+    const { title, src, page, noToolbar, width, height, ratio, zoom } = meta;
+    return `<PDFViewer src="${src}" title="${title}" :page="${page}" :no-toolbar="${noToolbar}" width="${width}" height="${height}" ratio="${ratio}" :zoom="${zoom}" />`;
+}
+export const pdfPlugin = (md) => {
+    md.block.ruler.before('import_code', 'pdf', createPDFRuleBlock(), {
+        alt: ['paragraph', 'reference', 'blockquote', 'list'],
+    });
+    md.renderer.rules.pdf = (tokens, index) => {
+        const token = tokens[index];
+        const content = resolvePDF(token.meta);
+        token.content = content;
+        return content;
+    };
+};

package/lib/node/features/replit.d.ts

@@ -0,0 +1,7 @@
+/**
+ * @[replit](user/repl-name)
+ * @[replit](user/repl-name#filepath)
+ * @[replit title="" height="400px" width="100%" theme="dark"](user/repl-name)
+ */
+import type { PluginWithOptions } from 'markdown-it';
+export declare const replitPlugin: PluginWithOptions<never>;

package/lib/node/features/replit.js

@@ -0,0 +1,59 @@
+import { resolveAttrs } from '../utils/resolveAttrs.js';
+import { parseRect } from '../utils/parseRect.js';
+// @[replit]()
+const MIN_LENGTH = 11;
+// char codes of `@[replit`
+const START_CODES = [64, 91, 114, 101, 112, 108, 105, 116];
+// regexp to match the import syntax
+const SYNTAX_RE = /^@\[replit(?:\s+([^]*?))?\]\(([^)]*?)\)/;
+function createReplitRuleBlock() {
+    return (state, startLine, endLine, silent) => {
+        const pos = state.bMarks[startLine] + state.tShift[startLine];
+        const max = state.eMarks[startLine];
+        // return false if the length is shorter than min length
+        if (pos + MIN_LENGTH > max)
+            return false;
+        // check if it's matched the start
+        for (let i = 0; i < START_CODES.length; i += 1) {
+            if (state.src.charCodeAt(pos + i) !== START_CODES[i])
+                return false;
+        }
+        // check if it's matched the syntax
+        const match = state.src.slice(pos, max).match(SYNTAX_RE);
+        if (!match)
+            return false;
+        // return true as we have matched the syntax
+        if (silent)
+            return true;
+        const [, info = '', source] = match;
+        const { attrs } = resolveAttrs(info);
+        const meta = {
+            width: attrs.width ? parseRect(attrs.width) : '100%',
+            height: attrs.height ? parseRect(attrs.height) : '450px',
+            source: source.startsWith('@') ? source : `@${source}`,
+            title: attrs.title,
+            theme: attrs.theme || '',
+        };
+        const token = state.push('replit', '', 0);
+        token.meta = meta;
+        token.map = [startLine, startLine + 1];
+        token.info = info;
+        state.line = startLine + 1;
+        return true;
+    };
+}
+function resolveReplit(meta) {
+    const { title, height, width, source, theme } = meta;
+    return `<ReplitViewer title="${title || ''}" height="${height}" width="${width}" source="${source}" theme="${theme}" />`;
+}
+export const replitPlugin = (md) => {
+    md.block.ruler.before('import_code', 'replit', createReplitRuleBlock(), {
+        alt: ['paragraph', 'reference', 'blockquote', 'list'],
+    });
+    md.renderer.rules.replit = (tokens, index) => {
+        const token = tokens[index];
+        const content = resolveReplit(token.meta);
+        token.content = content;
+        return content;
+    };
+};

package/lib/node/features/video/bilibili.d.ts

@@ -0,0 +1,2 @@
+import type { PluginWithOptions } from 'markdown-it';
+export declare const bilibiliPlugin: PluginWithOptions<never>;

package/lib/node/features/video/bilibili.js

@@ -0,0 +1,83 @@
+/**
+ * @[bilibili](bid)
+ * @[bilibili](aid cid)
+ * @[bilibili](bid aid cid)
+ * @[bilibili p1 autoplay time=1](aid cid)
+ */
+import { URLSearchParams } from 'node:url';
+import { resolveAttrs } from '../../utils/resolveAttrs.js';
+import { parseRect } from '../../utils/parseRect.js';
+import { timeToSeconds } from '../../utils/timeToSeconds.js';
+const BILIBILI_LINK = 'https://player.bilibili.com/player.html';
+// @[bilibili]()
+const MIN_LENGTH = 13;
+// char codes of '@[bilibili'
+const START_CODES = [64, 91, 98, 105, 108, 105, 98, 105, 108, 105];
+// regexp to match the import syntax
+const SYNTAX_RE = /^@\[bilibili(?:\s+p(\d+))?(?:\s+([^]*?))?\]\(([^)]*)\)/;
+function createBilibiliRuleBlock() {
+    return (state, startLine, endLine, silent) => {
+        const pos = state.bMarks[startLine] + state.tShift[startLine];
+        const max = state.eMarks[startLine];
+        // return false if the length is shorter than min length
+        if (pos + MIN_LENGTH > max)
+            return false;
+        // check if it's matched the start
+        for (let i = 0; i < START_CODES.length; i += 1) {
+            if (state.src.charCodeAt(pos + i) !== START_CODES[i])
+                return false;
+        }
+        // check if it's matched the syntax
+        const match = state.src.slice(pos, max).match(SYNTAX_RE);
+        if (!match)
+            return false;
+        // return true as we have matched the syntax
+        if (silent)
+            return true;
+        const [, page, info = '', source = ''] = match;
+        const { attrs } = resolveAttrs(info);
+        const ids = source.trim().split(/\s+/);
+        const bvid = ids.find(id => id.startsWith('BV'));
+        const [aid, cid] = ids.filter(id => !id.startsWith('BV'));
+        const meta = {
+            page: +page || 1,
+            bvid,
+            aid,
+            cid,
+            autoplay: attrs.autoplay ?? false,
+            time: timeToSeconds(attrs.time),
+            title: attrs.title,
+            width: attrs.width ? parseRect(attrs.width) : '100%',
+            height: attrs.height ? parseRect(attrs.height) : '',
+            ratio: attrs.ratio ? parseRect(attrs.ratio) : '',
+        };
+        const token = state.push('video_bilibili', '', 0);
+        token.meta = meta;
+        token.map = [startLine, startLine + 1];
+        token.info = info;
+        state.line = startLine + 1;
+        return true;
+    };
+}
+function resolveBilibili(meta) {
+    const params = new URLSearchParams();
+    meta.bvid && params.set('bvid', meta.bvid);
+    meta.aid && params.set('aid', meta.aid);
+    meta.cid && params.set('cid', meta.cid);
+    meta.page && params.set('p', meta.page.toString());
+    meta.time && params.set('t', meta.time.toString());
+    params.set('autoplay', meta.autoplay ? '1' : '0');
+    const source = `${BILIBILI_LINK}?${params.toString()}`;
+    return `<VideoBilibili src="${source}" width="${meta.width}" height="${meta.height}" ratio="${meta.ratio}" title="${meta.title}" />`;
+}
+export const bilibiliPlugin = (md) => {
+    md.block.ruler.before('import_code', 'video_bilibili', createBilibiliRuleBlock(), {
+        alt: ['paragraph', 'reference', 'blockquote', 'list'],
+    });
+    md.renderer.rules.video_bilibili = (tokens, index) => {
+        const token = tokens[index];
+        const content = resolveBilibili(token.meta);
+        token.content = content;
+        return content;
+    };
+};

package/lib/node/features/video/youtube.d.ts

@@ -0,0 +1,2 @@
+import type { PluginWithOptions } from 'markdown-it';
+export declare const youtubePlugin: PluginWithOptions<never>;