amateras 0.5.0 → 0.7.0

package/packages/idb/package.json

@@ -0,0 +1,19 @@
+{
+    "name": "@amateras/idb",
+    "peerDependencies": {
+      "@amateras/core": "workspace:*",
+      "@amateras/signal": "workspace:*",
+      "@amateras/utils": "workspace:*"
+    },
+    "imports": {
+      "#structure/*": "./src/structure/*.ts",
+      "#lib/*": "./src/lib/*.ts",
+      "#node/*": "./src/node/*.ts"
+    },
+    "exports": {
+      ".": "./src/index.ts",
+      "./structure/*": "./src/structure/*.ts",
+      "./lib/*": "./src/lib/*.ts",
+      "./node/*": "./src/node/*.ts"
+    }
+}

package/{ext → packages}/idb/src/index.ts

@@ -1,7 +1,7 @@
-import { _Object_assign } from "amateras/lib/native"
+import { _Object_assign } from "@amateras/utils"
 import { $IDBBuilder } from "#structure/builder/$IDBBuilder"
 
-declare module 'amateras/core' {
+declare module '@amateras/core' {
     export namespace $ {
         /**
          * Create {@link $IDBBuilder} with IDB name and version number.

package/{ext → packages}/idb/src/lib/$IDBRequest.ts

@@ -1,4 +1,4 @@
-import { _Promise } from "../../../../src/lib/native";
+import { _Promise } from "@amateras/utils";
 
 export const $IDBRequest = <T>(req: IDBRequest<T>, handle?: (req: IDBRequest<T>, resolve: (value: T) => void) => void) => {
     return new _Promise<T>((resolve, reject) => {

package/{ext → packages}/idb/src/structure/$IDB.ts

@@ -1,4 +1,4 @@
-import { _Array_from, _null, _Object_assign, _Object_fromEntries, _Promise, isBoolean } from "amateras/lib/native";
+import { _Array_from, _null, _Object_assign, _Object_fromEntries, _Promise, isBoolean } from "@amateras/utils";
 import { $IDBStore, type $IDBStoreConfig } from "./$IDBStore";
 import { $IDBTransaction } from "./$IDBTransaction";
 

package/{ext → packages}/idb/src/structure/$IDBCursor.ts

@@ -1,4 +1,4 @@
-import { _instanceof, _Object_assign, _Promise } from "amateras/lib/native";
+import { _instanceof, _Object_assign, _Promise } from "@amateras/utils";
 import { $IDBRequest } from "#lib/$IDBRequest";
 import { $IDBStore, type $IDBStoreConfig } from "./$IDBStore";
 import { $IDBIndex } from "./$IDBIndex";

package/{ext → packages}/idb/src/structure/$IDBIndex.ts

@@ -1,4 +1,4 @@
-import { _Object_assign } from "amateras/lib/native";
+import { _Object_assign } from "@amateras/utils";
 import type { $IDBStore, $IDBStoreConfig, QueryMultipleKeyPath } from "./$IDBStore";
 import { $IDBStoreBase } from "./$IDBStoreBase";
 import type { $IDBCursor } from "./$IDBCursor";

package/{ext → packages}/idb/src/structure/$IDBStore.ts

@@ -1,4 +1,4 @@
-import { _instanceof, _Object_assign, _Promise } from "amateras/lib/native";
+import { _instanceof, _Object_assign, _Promise } from "@amateras/utils";
 import { $IDBIndex, type $IDBIndexConfig } from "./$IDBIndex";
 import { $IDBRequest } from "#lib/$IDBRequest";
 import { $IDBStoreBase } from "./$IDBStoreBase";

package/{ext → packages}/idb/src/structure/$IDBStoreBase.ts

@@ -1,4 +1,4 @@
-import { _Array_from, _instanceof, _null, _Promise } from "amateras/lib/native";
+import { _Array_from, _instanceof, _null, _Promise } from "@amateras/utils";
 import { $IDBRequest } from "#lib/$IDBRequest";
 import { $IDBCursor } from "./$IDBCursor";
 

package/{ext → packages}/idb/src/structure/$IDBTransaction.ts

@@ -1,4 +1,4 @@
-import { _Array_from, _Object_assign, forEach } from "../../../../src/lib/native";
+import { _Array_from, _Object_assign, forEach } from "@amateras/utils";
 import type { $IDB } from "./$IDB";
 import { $IDBStore, type $IDBStoreConfig } from "./$IDBStore";
 

package/{ext → packages}/idb/src/structure/builder/$IDBBuilder.ts

@@ -1,9 +1,8 @@
 import { $IDB, type $IDBConfig } from "#structure/$IDB";
-import { _Array_from, _instanceof, _JSON_stringify, _null, _Object_assign, _Object_fromEntries, _Promise, forEach, isFunction } from "amateras/lib/native";
+import { _Array_from, _instanceof, _JSON_stringify, _null, _Object_assign, _Object_fromEntries, _Promise, forEach, isFunction, trycatch } from "@amateras/utils";
 import { $IDBStoreBuilder } from "./$IDBStoreBuilder";
 import type { $IDBIndexConfig } from "#structure/$IDBIndex";
 import type { $IDBStoreConfig } from "#structure/$IDBStore";
-import { trycatch } from "amateras/lib/trycatch";
 // optimizer variables
 const objectStoreNames = 'objectStoreNames';
 const deleteObjectStore = 'deleteObjectStore';
@@ -84,7 +83,7 @@ export class $IDBBuilder<Config extends $IDBConfig = { name: string, stores: {},
             const initialCreateDB = () => {
                 debug(`No IDB detected, create IDB`);
                 const {transaction, result: idb} = initDBRequest;
-                forEach(storeMap, (storeBuilder, name) => {
+                forEach(storeMap, ([name, storeBuilder]) => {
                     createStoresMap.set(name, storeBuilder);
                     createIndexMap.set(storeBuilder, new Map(storeBuilder.indexes))
                 })
@@ -108,11 +107,11 @@ export class $IDBBuilder<Config extends $IDBConfig = { name: string, stores: {},
                 // get unused stores
                 transaction && forEach(_Array_from(transaction[objectStoreNames]), name => storeMap.has(name) && unusedStoreNameList.push(name))
                 // check store config matches
-                forEach(storeMap, (storeBuilder, storeName) => {
+                forEach(storeMap, ([storeName, storeBuilder]) => {
                     const {keyPath, autoIncrement} = storeBuilder.config;
                     const indexMap = new Map();
                     const checkIndexes = () =>
-                        forEach(storeBuilder.indexes, (indexBuilder, indexName) => {
+                        forEach(storeBuilder.indexes, ([indexName, indexBuilder]) => {
                             const [index] = trycatch(() => store?.index(indexName));
                             const CONFIG_CHANGED = _JSON_stringify(indexBuilder.keyPath) !== _JSON_stringify(index?.keyPath)
                                 || !!indexBuilder.multiEntry !== index?.multiEntry 
@@ -182,20 +181,20 @@ export class $IDBBuilder<Config extends $IDBConfig = { name: string, stores: {},
                 /** 'versionchange' type transaction */
                 const transaction = req.transaction as IDBTransaction;
                 // create stores
-                forEach(createStoresMap, ({config}, name) => {
+                forEach(createStoresMap, ([name, {config}]) => {
                     idb[createObjectStore](name, config);
                     debug(`Store Created: ${name}`);
                 });
                 // upgrade stores
-                forEach(upgradeStoreMap, ({config}, name) => {
+                forEach(upgradeStoreMap, ([name, {config}]) => {
                     idb[deleteObjectStore](name); 
                     idb[createObjectStore](name, config);
                     debug(`Store Upgraded: ${name}`);
                 })
                 // create indexes
-                forEach(createIndexMap, (indexMap, {config: {name}}) => {
+                forEach(createIndexMap, ([{config: {name}}, indexMap]) => {
                     const store = transaction.objectStore(name);
-                    forEach(indexMap, ({keyPath, ...config}, indexName) => {
+                    forEach(indexMap, ([indexName, {keyPath, ...config}]) => {
                         // if indexes existed, delete and create again
                         if (store.indexNames.contains(indexName)) store.deleteIndex(indexName);
                         store.createIndex(indexName, keyPath, config);
@@ -208,7 +207,7 @@ export class $IDBBuilder<Config extends $IDBConfig = { name: string, stores: {},
                     debug(`Unused Store Deleted: ${name}`);
                 });
                 // open db again for insert objects
-                forEach(cachedObjectMap, (objectList, storeName) => {
+                forEach(cachedObjectMap, ([storeName, objectList]) => {
                     const store = transaction.objectStore(storeName);
                     forEach(objectList, ({key, value}) => {
                         if (store.autoIncrement || store.keyPath) store.add(value);

package/{ext → packages}/idb/src/structure/builder/$IDBStoreBuilder.ts

@@ -1,5 +1,5 @@
 import type { $IDB } from "#structure/$IDB";
-import { _null } from "amateras/lib/native";
+import { _null } from "@amateras/utils";
 import type { $IDBStoreConfig } from "#structure/$IDBStore";
 import type { $IDBIndexConfig } from "#structure/$IDBIndex";
 

package/packages/markdown/README.md

@@ -0,0 +1,53 @@
+# amateras/markdown
+
+## Usage
+```ts
+import { Markdown } from 'amateras/markdown';
+
+const markdown = new Markdown();
+
+markdown.parseHTML('# Title'); // => <h1>Title</h1>
+```
+
+## Add Custom Markdown Rules
+```ts
+markdown.lexer.blockTokenizers.set('CUSTOM_TYPE', {
+	regex: /#! (.+)/,
+	handle: matches => {
+		content: lexer.inlineTokenize(matches[1]!)
+	}
+})
+
+markdown.parser.processors.set('CUSTOM_TYPE', token => {
+	return `<custom>${markdown.parser.parse(token.content!)}</custom>`
+})
+```
+
+## Import Syntax
+```ts
+import { MarkdownParser, MarkdownLexer } from 'amateras/markdown';
+import { blockquoteProcessor, blockquoteTokenizer } from 'amateras/markdown/syntax/blockquote';
+import { headingProcessor, headingTokenizer } from 'amateras/markdown/syntax/heading';
+
+const lexer = new MarkdownLexer();
+const parser = new MarkdownParser();
+
+lexer.use(
+    blockquoteTokenizer,
+    headingTokenizer
+)
+
+parser.use(
+    blockquoteProcessor,
+    headingProcessor
+)
+
+function parseHTML(str: string) {
+    const tokens = lexer.blockTokenize(str);
+    return parser.parse(tokens);
+}
+
+parseHTML('# Title') // => <h1>Title</h1>
+parseHTML('> This is Blockquote') // => <blockquote>This is Blockquote</blockquote>
+parseHTML('- List') // => - List
+```

package/packages/markdown/package.json

@@ -0,0 +1,19 @@
+{
+    "name": "@amateras/markdown",
+    "peerDependencies": {
+      "@amateras/core": "workspace:*",
+      "@amateras/utils": "workspace:*"
+    },
+    "imports": {
+      "#structure/*": "./src/structure/*.ts",
+      "#lib/*": "./src/lib/*.ts",
+      "#node/*": "./src/node/*.ts"
+    },
+    "exports": {
+      ".": "./src/index.ts",
+      "./structure/*": "./src/structure/*.ts",
+      "./lib/*": "./src/lib/*.ts",
+      "./node/*": "./src/node/*.ts",
+      "./syntax/*": "./src/syntax/*.ts"
+    }
+}

package/packages/markdown/src/index.ts

@@ -0,0 +1,3 @@
+export * from '#structure/MarkdownLexer';
+export * from '#structure/MarkdownParser';
+export * from "#structure/Markdown";

package/packages/markdown/src/lib/type.ts

@@ -0,0 +1,26 @@
+export const INLINE = 'INLINE';
+export const BLOCK = 'BLOCK';
+export const TEXT = 'TEXT';
+export const IMAGE = 'IMAGE';
+export const LINK = 'LINK';
+export const QUICK_LINK = 'QUICK_LINK';
+export const CODE = 'CODE';
+export const ITALIC = 'ITALIC';
+export const BOLD = 'BOLD';
+export const TEXT_LINE = 'TEXT_LINE';
+export const HEADING = 'HEADING';
+export const CODE_START = 'CODE_START';
+export const CODE_LINE = 'CODE_LINE';
+export const CODE_END = 'CODE_END';
+export const UNORDERED_LIST_ITEM = 'UNORDERED_LIST_ITEM';
+export const ORDERED_LIST_ITEM = 'ORDERED_LIST_ITEM';
+export const BLOCKQUOTE = 'BLOCKQUOTE';
+export const ALERT = 'ALERT';
+export const ALERT_LINE = 'ALERT_LINE';
+export const HORIZONTAL_RULE = 'HORIZONTAL_RULE';
+export const TABLE = 'TABLE';
+export const TABLE_ROW = 'TABLE_ROW';
+export const TABLE_COLUMN = 'TABLE_COLUMN';
+export const EMPTY_LINE = 'EMPTY_LINE'
+export const INLINE_TEXT = "INLINE_TEXT";
+export const INLINE_CONTENT = "INLINE_CONTENT"

package/packages/markdown/src/lib/util.ts

@@ -0,0 +1,21 @@
+import type { BlockTokenizer, InlineTokenizer, MarkdownLexer } from "#structure/MarkdownLexer";
+import type { MarkdownParseProcessor, MarkdownParser } from "#structure/MarkdownParser";
+import { forEach } from "@amateras/utils";
+
+export const setBlockTokenizer = (lexer: MarkdownLexer, type: string, tokenizer: BlockTokenizer) => lexer.blockTokenizers.set(type, tokenizer);
+export const setInlineTokenizer = (lexer: MarkdownLexer, type: string, tokenizer: InlineTokenizer) => lexer.inlineTokenizers.set(type, tokenizer);
+
+export const setProcessor = (parser: MarkdownParser, type: string, processor: MarkdownParseProcessor) => parser.processors.set(type, processor);
+
+export const htmltag = (tagname: string, content: string) => `<${tagname}>${content}</${tagname}>`
+
+export const htmlEscapeChar = (str: string) => {
+    forEach([
+        ['&', '&amp;'],
+        ['<', '&lt;'],
+        ['>', '&gt;'],
+        ['"', '&quot;'],
+        ["'", '&#39;']
+    ] as [string, string][], group => str = str.replaceAll(...group))
+    return str;
+}

package/packages/markdown/src/structure/Markdown.ts

@@ -0,0 +1,54 @@
+import { alertProcessor, alertTokenizer } from "../syntax/alert";
+import { blockquoteProcessor, blockquoteTokenizer } from "../syntax/blockquote";
+import { boldProcessor, boldTokenizer } from "../syntax/bold";
+import { codeProcessor, codeTokenizer } from "../syntax/code";
+import { codeblockProcessor, codeblockTokenizer } from "../syntax/codeblock";
+import { headingProcessor, headingTokenizer } from "../syntax/heading";
+import { horizontalRuleProcessor, horizontalRuleTokenizer } from "../syntax/horizontalRule";
+import { imageProcessor, imageTokenizer } from "../syntax/image";
+import { italicProcessor, italicTokenizer } from "../syntax/italic";
+import { linkProcessor, linkTokenizer } from "../syntax/link";
+import { listProcessor, listTokenizer } from "../syntax/list";
+import { textLineProcessor, textProcessor } from "../syntax/text";
+import { MarkdownLexer } from "./MarkdownLexer";
+import { MarkdownParser } from "./MarkdownParser";
+
+export class Markdown {
+    lexer = new MarkdownLexer();
+    parser = new MarkdownParser();
+    constructor() {
+        this.lexer.use(
+            headingTokenizer,
+            codeblockTokenizer,
+            listTokenizer,
+            alertTokenizer,
+            blockquoteTokenizer,
+            horizontalRuleTokenizer,
+            imageTokenizer, // image tokenizer must before link
+            linkTokenizer, // link tokenizer must before bold and italic and code
+            codeTokenizer,
+            boldTokenizer,
+            italicTokenizer,
+        )
+        
+        this.parser.use(
+            textProcessor,
+            imageProcessor,
+            linkProcessor,
+            codeProcessor,
+            italicProcessor,
+            boldProcessor,
+            textLineProcessor,
+            headingProcessor,
+            codeblockProcessor,
+            listProcessor,
+            alertProcessor,
+            blockquoteProcessor,
+            horizontalRuleProcessor
+        )
+    }
+
+    parseHTML(str: string) {
+        return this.parser.parse(this.lexer.blockTokenize(str));
+    }
+}

package/packages/markdown/src/structure/MarkdownLexer.ts

@@ -0,0 +1,111 @@
+import { BLOCK, EMPTY_LINE, INLINE_CONTENT, INLINE_TEXT, TEXT_LINE } from "#lib/type";
+import { forEach, isString } from "@amateras/utils";
+
+export class MarkdownLexer {
+    blockTokenizers = new Map<string, BlockTokenizer>();
+    inlineTokenizers = new Map<string, InlineTokenizer>();
+    
+    blockTokenize(str: string) {
+        const lines = str?.split(/\r?\n/) ?? [];
+        const tokens: BlockToken[] = [];
+        let lineIndex = 0;
+        lineLoop: while (lineIndex < lines.length) {
+            let line = lines[lineIndex];
+            if (line === undefined) throw 'LINE ERROR';
+            let token: BlockToken | undefined;
+            for (const [type, tokenizer] of this.blockTokenizers) {
+                const matched = line.match(tokenizer.regex);
+                if (matched) {
+                    const {content, multiLine, data} = tokenizer.handle(matched, lineIndex, lines);
+                    token = { layout: BLOCK, type, content, data }
+                    if (multiLine) {
+                        tokens.push(token);
+                        tokens.push(...multiLine.tokens)
+                        lineIndex = multiLine.skip;
+                        continue lineLoop;
+                    }
+                    break;
+                }
+            }
+            if (!token) token = { 
+                layout: BLOCK, 
+                ...(
+                    line.length 
+                    ?   { type: TEXT_LINE, content: this.inlineTokenize(line) } 
+                    :   { type: EMPTY_LINE, content: [] }
+                )
+            };
+            tokens.push(token);
+            lineIndex++;
+        }
+        return tokens;
+    }
+
+    inlineTokenize(str: string): InlineToken[] {
+        const tokens: InlineToken[] = [];
+        let remainStr = str;
+        while (remainStr.length) {
+            let token: InlineToken | undefined;
+            for (const [type, tokenizer] of this.inlineTokenizers) {
+                const matched = remainStr.match(tokenizer.regex);
+                if (matched) {
+                    const {index, 0: matchStr} = matched;
+                    // handle before matched string
+                    if (index != 0) tokens.push(...this.inlineTokenize(remainStr.substring(0, index)));
+                    // handle matched string
+                    const {content, data} = tokenizer.handle(matched);
+                    token = { type, ...(isString(content) ? { layout: INLINE_TEXT, text: content } : { layout: INLINE_CONTENT, content })};
+                    if (data) token.data = data;
+                    remainStr = remainStr.substring(index! + matchStr.length);
+                    break;
+                }
+            }
+            if (!token) {
+                token = { type: 'TEXT', layout: INLINE_TEXT, text: remainStr };
+                remainStr = '';
+            }
+            tokens.push(token);
+        }
+        return tokens;
+    }
+
+    use(...handle: ((parser: this) => void)[]) {
+        forEach(handle, fn => fn(this));
+        return this;
+    }
+}
+
+export type BlockTokenizer = {
+    regex: RegExp;
+    handle: (matches: RegExpMatchArray, position: number, lines: string[]) => { content: (InlineToken | BlockToken)[], multiLine?: BlockTokenizerMultiLine, data?: {[key: string]: any} };
+}
+export type BlockTokenizerMultiLine = {
+    skip: number;
+    tokens: BlockToken[];
+}
+export type InlineTokenizer = {
+    regex: RegExp;
+    handle: (matches: RegExpMatchArray) => { content: InlineToken[] | string, data?: {[key: string]: any} }
+}
+
+export interface TokenBase {
+    type: string;
+    layout: 'BLOCK' | 'INLINE_CONTENT' | 'INLINE_TEXT';
+    content?: Token[];
+    text?: string;
+    data?: {[key: string]: any};
+}
+export interface BlockToken extends TokenBase {
+    layout: 'BLOCK'
+    content: Token[];
+}
+export interface InlineTextToken extends TokenBase {
+    layout: 'INLINE_TEXT'
+    text: string;
+}
+export interface InlineContentToken extends TokenBase {
+    layout: 'INLINE_CONTENT'
+    content: (InlineToken)[];
+}
+export type InlineToken = InlineTextToken | InlineContentToken;
+export type Token = BlockToken | InlineToken;

package/packages/markdown/src/structure/MarkdownParser.ts

@@ -0,0 +1,34 @@
+import { forEach, isString } from "@amateras/utils";
+import { type Token } from "./MarkdownLexer";
+
+export class MarkdownParser {
+    processors = new Map<string, MarkdownParseProcessor>();
+    
+    parse(tokens: (Token)[]) {
+        let html = '';
+        let i = 0;
+        if (!tokens) return html;
+        while (i < tokens.length) {
+            const token = tokens[i]!;
+            const processor = this.processors.get(token.type);
+            if (processor) {
+                const result = processor(token, tokens.slice(i));
+                if (isString(result)) {
+                    html += result;
+                } else {
+                    html += result.html;
+                    i += result.skipTokens;
+                }
+            }
+            i++;
+        }
+        return html;
+    }
+
+    use(...handle: ((parser: this) => void)[]) {
+        forEach(handle, fn => fn(this));
+        return this;
+    }
+}
+
+export type MarkdownParseProcessor = (token: Token, tokens: Token[]) => (string | { html: string, skipTokens: number })

package/packages/markdown/src/syntax/alert.ts

@@ -0,0 +1,46 @@
+import { ALERT, ALERT_LINE, BLOCK } from "#lib/type";
+import { setBlockTokenizer, setProcessor } from "#lib/util";
+import type { BlockToken, MarkdownLexer } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+import { uppercase } from "@amateras/utils";
+
+export const alertProcessor = (parser: MarkdownParser) => setProcessor(parser, ALERT, (token, tokens) => {
+    let html = '';
+    let i = 1;
+    while (i < tokens.length) {
+        const token = tokens[i]!;
+        if (token.type !== ALERT_LINE) break;
+        html += parser.parse(token.content![0]!.content!);
+        i++;
+    }
+    const alertType = token.data?.alertType as string;
+    return {
+        html: `<blockquote class="alert alert-${alertType}"><p class="alert-title">${uppercase(alertType, 0, 1)}</p>${html}</blockquote>`,
+        skipTokens: i
+    }
+})
+
+export const alertTokenizer = (lexer: MarkdownLexer) => setBlockTokenizer(lexer, ALERT, {
+    regex: /^> ?\[!(?:(?:NOTE)|(?:TIP)|(?:IMPORTANT)|(?:WARNING)|(?:CAUTION))\]/,
+    handle(_, position, lines) {
+        const tokens: BlockToken[] = [];
+        const match = lines[position]!.match(/> ?\[!(.+?)\]/);
+        const alertType = match?.[1]?.toLowerCase();
+        position++
+        while (position < lines.length) {
+            const line = lines[position]!;
+            const match = line.match(/^> ?(.+)/);
+            if (match) tokens.push({ layout: BLOCK, type: ALERT_LINE, content: lexer.blockTokenize(match[1]!) });
+            else break;
+            position++;
+        }
+        return {
+            content: [],
+            data: { alertType },
+            multiLine: {
+                skip: position,
+                tokens
+            }
+        }
+    },
+})

package/packages/markdown/src/syntax/blockquote.ts

@@ -0,0 +1,35 @@
+import { BLOCKQUOTE } from "#lib/type";
+import { htmltag, setBlockTokenizer, setProcessor } from "#lib/util";
+import type { MarkdownLexer } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+
+export const blockquoteProcessor = (parser: MarkdownParser) => setProcessor(parser, BLOCKQUOTE, (token, tokens) => {
+        let i = 0;
+        const blockquote = (deep: number) => {
+            let html = '';
+            while (i < tokens.length) {
+                const {type, content, data} = tokens[i]!;
+                if (type !== BLOCKQUOTE) break;
+                if (data!.deep > deep) html += blockquote(data!.deep);
+                else if (data!.deep < deep) break;
+                else { html += parser.parse(content!); i++ }
+            }
+            return htmltag('blockquote', html)
+        }
+        return {
+            html: blockquote(token.data!.deep),
+            skipTokens: i
+        }
+    })
+
+export const blockquoteTokenizer = (lexer: MarkdownLexer) => setBlockTokenizer(lexer, BLOCKQUOTE, {
+        regex: /^(>+) ?(.+)?/,
+        handle(matches) {
+            return {
+                content: lexer.blockTokenize(matches[2] ?? ''),
+                data: {
+                    deep: (matches[1]!.length - 1)
+                }
+            }
+        }
+    })

package/packages/markdown/src/syntax/bold.ts

@@ -0,0 +1,11 @@
+import { BOLD } from "#lib/type";
+import { htmltag, setInlineTokenizer, setProcessor } from "#lib/util";
+import type { MarkdownLexer } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+
+export const boldProcessor = (parser: MarkdownParser) => setProcessor(parser, BOLD, token => htmltag('b', parser.parse(token.content!)))
+
+export const boldTokenizer = (lexer: MarkdownLexer) => setInlineTokenizer(lexer, BOLD, {
+        regex: /\*\*(.+?\*?)\*\*/,
+        handle: matches => ({ content: lexer.inlineTokenize(matches[1]!) })
+    })

package/packages/markdown/src/syntax/code.ts

@@ -0,0 +1,11 @@
+import { CODE } from "#lib/type";
+import { htmlEscapeChar, htmltag, setInlineTokenizer, setProcessor } from "#lib/util";
+import type { MarkdownLexer } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+
+export const codeProcessor = (parser: MarkdownParser) => setProcessor(parser, CODE, token => htmltag('code', htmlEscapeChar(token.text!)))
+
+export const codeTokenizer = (lexer: MarkdownLexer) => setInlineTokenizer(lexer, CODE, {
+    regex: /`(.+?)`/,
+    handle: matches => ({ content: matches[1]! })
+})

package/packages/markdown/src/syntax/codeblock.ts

@@ -0,0 +1,44 @@
+import { BLOCK, CODE_END, CODE_LINE, CODE_START } from "#lib/type";
+import { htmlEscapeChar, setBlockTokenizer, setProcessor } from "#lib/util";
+import type { BlockToken, MarkdownLexer } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+
+export const codeblockProcessor = (parser: MarkdownParser) => setProcessor(parser, CODE_START, (token, tokens) => {
+        let html = '';
+        let i = 1;
+        while (i < tokens.length) {
+            const token = tokens[i]!;
+            if (token.type === CODE_END) break;
+            html += token.content![0]!.text;
+            i++;
+        }
+        return {
+            html: `<pre><code${token.data?.lang ? ` lang="${token.data.lang}"` : ''}>${htmlEscapeChar(html)}</code></pre>`,
+            skipTokens: i
+        }
+    })
+
+export const codeblockTokenizer = (lexer: MarkdownLexer) => setBlockTokenizer(lexer, CODE_START, {
+    regex: /^```(\w+)?/,
+    handle: (matches, position, lines) => {
+        const tokens: BlockToken[] = [];
+        position++;
+        while (position < lines.length) {
+            const line = lines[position]!;
+            position++;
+            if (line.includes('```')) {
+                tokens.push({ layout: BLOCK, type: CODE_END, content: [] })
+                break;
+            }
+            tokens.push({ layout: BLOCK, type: CODE_LINE, content: [{ layout: "INLINE_TEXT", type: 'CODE_TEXT', text: `${line}\n` }] });
+        }
+        return {
+            content: [],
+            data: { lang: matches[1] },
+            multiLine: {
+                skip: position,
+                tokens
+            }
+        }
+    }
+})

package/packages/markdown/src/syntax/heading.ts

@@ -0,0 +1,14 @@
+import { HEADING } from "#lib/type";
+import { htmltag, setBlockTokenizer, setProcessor } from "#lib/util";
+import type { MarkdownLexer } from "#structure/MarkdownLexer";
+import type { MarkdownParser } from "#structure/MarkdownParser";
+
+export const headingProcessor = (parser: MarkdownParser) => setProcessor(parser, HEADING, token => {
+    const tagname = `h${token.data!.level}`;
+    return htmltag(tagname, parser.parse(token.content!))
+})
+
+export const headingTokenizer = (lexer: MarkdownLexer) => setBlockTokenizer(lexer, HEADING, {
+    regex: /^(#+) (.+)/,
+    handle: matches => ({ content: lexer.inlineTokenize(matches[2]!), data: { level: matches[1]!.length } })
+})