Wider Blog

Input (file.md) 
  -> Tokenize (micromark + micromarkExtension)
  -> Token Stream (enter/exit events)
  -> Grow Syntax Tree (mdast-util-from-markdown + fromMarkdownExtension)
  -> Transform Tree (transform treeNode)
  -> Serialize (mdast-util-to-markdown + toMarkdownExtension)
  -> Output

-- Database examples
CREATE DATABASE my_database;
USE my_database;

-- Table examples
CREATE TABLE users (id INT, name VARCHAR(50));
ALTER TABLE users ADD email VARCHAR(100);
TRUNCATE TABLE users;
DROP TABLE users;

Strings:
- CHAR(N): Fixed-length (0-255 bytes), space-padded.
- VARCHAR(N): Variable-length (0-65536 bytes).
- TEXT types: TINYTEXT, TEXT, MEDIUMTEXT, LONGTEXT (stored on disk).
- BLOB types: TINYBLOB, BLOB, MEDIUMBLOB, LONGBLOB (binary data on disk).
- SET(<list>): Multiple choice selection.
- ENUM(<list>): Single choice selection.

Dates:
- DATE: yyyy-MM-dd
- TIME: HH:mm
- YEAR: yyyy
- DATETIME: yyyy-MM-dd HH:mm
- TIMESTAMP: yyyy-MM-dd HH:mm (can act as timestamp)

import type { Paragraph, Parent, Text, Content } from 'mdast';
import type { Content as HastContent } from 'hast';
import type { Handle, Extension as FromMarkdownExtension } from 'mdast-util-from-markdown';
import { fromHtml } from 'hast-util-from-html';

export interface Admonition extends Parent {
  type: 'admonition',
  name: string,
};
export interface admonitionHTML extends Parent {
  type: 'admonitionHTML',
}

declare module 'mdast' {
  interface BlockContentMap {
    admonitionHTML: admonitionHTML;
    admonition: Admonition;
  }
  interface ParagraphData {
    admonitionTitle?: boolean;
  }
}

const admonitionConfig: Record<string, { title: string, icon: string, class: string }> = {
  note: { title: '备注', icon: '<svg>...</svg>', class: 'admonition-note' },
  info: { title: '信息', icon: '...', class: 'admonition-info' },
  tip: { title: '提示', icon: '...', class: 'admonition-tip' },
  caution: { title: '注意', icon: '...', class: 'admonition-caution' },
  danger: { title: '危险', icon: '...', class: 'admonition-danger' },
};

// Helper to create HAST-like nodes within MDAST
function h(tagName: string, properties: Record<string, any>, children?: (Content | undefined | null | false)[]): admonitionHTML {
  const filteredChildren = children?.filter((child): child is Content => child !== undefined && child !== null && child !== false) ?? [];
  return {
    type: 'admonitionHTML',
    data: { hName: tagName, hProperties: properties },
    children: filteredChildren,
  };
}

// Transforms HTML strings (like icons) into MDAST nodes
function toMdast(node: HastContent) {
  if (node.type === 'text') return { type: 'text', value: node.value } as Text;
  if (node.type === 'element') {
    const mdastNode = { type: 'admonitionHTML', data: { hName: node.tagName, hProperties: node.properties }, children: [] } as admonitionHTML;
    node.children.map(toMdast).forEach((child) => { if (child) mdastNode.children.push(child); });
    return mdastNode;
  }
  return null;
}

function htmlTemplate(type: string, title?: string | Content, children?: (Content | undefined | null | false)[]) {
  const key = type in admonitionConfig ? type : 'note';
  const config = admonitionConfig[key];
  let titleNode = typeof title === 'string' ? { type: 'text', value: title } as Text : (title || { type: 'text', value: config.title } as Text);
  const iconNode = config.icon ? toMdast(fromHtml(config.icon, { space: 'svg', fragment: true }).children[0]) : null;

  return h('div', { class: 'my-4 rounded-lg px-4 py-2 ' + config.class }, [
    h('div', { class: 'flex items-center text-base font-bold' }, [iconNode, titleNode]),
    children && children.length > 0 && h('div', { class: 'mt-2 prose-compact text-sm' }, children)
  ]);
}

export const fromMarkdown = (): FromMarkdownExtension => {
  return {
    enter: {
      admonition: function(token) { this.enter<Admonition>({ type: 'admonition', name: '', children: [] }, token); },
      admonitionTitle: function(token) { this.enter<Paragraph>({ type: 'paragraph', data: { admonitionTitle: true }, children: [] }, token); },
    },
    exit: {
      admonition: function(token) {
        const node = this.exit(token) as Admonition;
        const titleNodeIndex = node.children.findIndex((child) => child.type === 'paragraph' && child.data?.admonitionTitle);
        const titleNode = titleNodeIndex >= 0 ? node.children.splice(titleNodeIndex, 1)[0] as Paragraph : undefined;
        if (titleNode) titleNode.data = { ...titleNode.data, hName: 'span' };
        const subtree = htmlTemplate(node.name, titleNode, node.children);
        if (subtree) Object.assign(node, subtree);
      },
      admonitionName: function(token) {
        const node = this.stack[this.stack.length - 1] as Admonition;
        if (node.type === 'admonition') node.name = this.sliceSerialize(token);
      },
      admonitionTitle: function(token) { this.exit(token); },
    }
  };
};

# 1. Extract zip to a directory, e.g., C:\Program Files\NVIDIA GPU Computing Toolkit\TensorRT\v8.x.x.x
# 2. Add <install_path>/lib and <install_path>/bin to the system PATH environment variable
# 3. Install the python wheel from the <install_path>/python directory:
pip install tensorrt-8.x.x-cp3x-none-win_amd64.whl