@yozora/tokenizer-html-block 1.3.0 → 2.0.0-alpha.0

package/lib/cjs/index.js

@@ -2,20 +2,114 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var ast = require('@yozora/ast');
 var character = require('@yozora/character');
 var coreTokenizer = require('@yozora/core-tokenizer');
+var ast = require('@yozora/ast');
+
+function eatHTMLAttribute(nodePoints, startIndex, endIndex) {
+    let i = coreTokenizer.eatOptionalWhitespaces(nodePoints, startIndex, endIndex);
+    if (i <= startIndex || i >= endIndex)
+        return null;
+    const attrNameStartIndex = i;
+    let c = nodePoints[i].codePoint;
+    if (!character.isAsciiLetter(c) && c !== character.AsciiCodePoint.UNDERSCORE && c !== character.AsciiCodePoint.COLON)
+        return null;
+    for (i = attrNameStartIndex + 1; i < endIndex; ++i) {
+        c = nodePoints[i].codePoint;
+        if (character.isAsciiLetter(c) ||
+            character.isAsciiDigitCharacter(c) ||
+            c === character.AsciiCodePoint.UNDERSCORE ||
+            c === character.AsciiCodePoint.DOT ||
+            c === character.AsciiCodePoint.COLON ||
+            c === character.AsciiCodePoint.MINUS_SIGN)
+            continue;
+        break;
+    }
+    const attrNameEndIndex = i;
+    const attribute = {
+        name: {
+            startIndex: attrNameStartIndex,
+            endIndex: attrNameEndIndex,
+        },
+    };
+    i = coreTokenizer.eatOptionalWhitespaces(nodePoints, attrNameEndIndex, endIndex);
+    if (i < endIndex && nodePoints[i].codePoint === character.AsciiCodePoint.EQUALS_SIGN) {
+        i = coreTokenizer.eatOptionalWhitespaces(nodePoints, i + 1, endIndex);
+        if (i < endIndex) {
+            const mark = nodePoints[i].codePoint;
+            switch (mark) {
+                case character.AsciiCodePoint.DOUBLE_QUOTE: {
+                    const attrValueStartIndex = i + 1;
+                    for (i = attrValueStartIndex; i < endIndex; ++i) {
+                        c = nodePoints[i].codePoint;
+                        if (c === character.AsciiCodePoint.DOUBLE_QUOTE)
+                            break;
+                    }
+                    const attrValueEndIndex = i;
+                    if (i < endIndex && nodePoints[i].codePoint === character.AsciiCodePoint.DOUBLE_QUOTE) {
+                        attribute.value = {
+                            startIndex: attrValueStartIndex,
+                            endIndex: attrValueEndIndex,
+                        };
+                        i += 1;
+                    }
+                    break;
+                }
+                case character.AsciiCodePoint.SINGLE_QUOTE: {
+                    const attrValueStartIndex = i + 1;
+                    for (i = attrValueStartIndex; i < endIndex; ++i) {
+                        c = nodePoints[i].codePoint;
+                        if (c === character.AsciiCodePoint.SINGLE_QUOTE)
+                            break;
+                    }
+                    const attrValueEndIndex = i;
+                    if (i < endIndex && nodePoints[i].codePoint === character.AsciiCodePoint.SINGLE_QUOTE) {
+                        attribute.value = {
+                            startIndex: attrValueStartIndex,
+                            endIndex: attrValueEndIndex,
+                        };
+                        i += 1;
+                    }
+                    break;
+                }
+                default: {
+                    const attrValueStartIndex = i;
+                    for (; i < endIndex; ++i) {
+                        c = nodePoints[i].codePoint;
+                        if (character.isWhitespaceCharacter(c) ||
+                            c === character.AsciiCodePoint.DOUBLE_QUOTE ||
+                            c === character.AsciiCodePoint.SINGLE_QUOTE ||
+                            c === character.AsciiCodePoint.EQUALS_SIGN ||
+                            c === character.AsciiCodePoint.OPEN_ANGLE ||
+                            c === character.AsciiCodePoint.CLOSE_ANGLE ||
+                            c === character.AsciiCodePoint.BACKTICK)
+                            break;
+                    }
+                    const attrValueEndIndex = i;
+                    if (attrValueEndIndex > attrValueStartIndex) {
+                        attribute.value = {
+                            startIndex: attrValueStartIndex,
+                            endIndex: attrValueEndIndex,
+                        };
+                    }
+                    break;
+                }
+            }
+            if (attribute.value != null) {
+                return { attribute, nextIndex: i };
+            }
+        }
+    }
+    return { attribute, nextIndex: attrNameEndIndex };
+}
 
 function eatHTMLTagName(nodePoints, startIndex, endIndex) {
-    if (startIndex >= endIndex ||
-        !character.isAsciiLetter(nodePoints[startIndex].codePoint))
+    if (startIndex >= endIndex || !character.isAsciiLetter(nodePoints[startIndex].codePoint))
         return null;
     let i = startIndex;
     for (; i < endIndex; ++i) {
         const c = nodePoints[i].codePoint;
-        if (character.isAsciiLetter(c) ||
-            character.isAsciiDigitCharacter(c) ||
-            c === character.AsciiCodePoint.MINUS_SIGN)
+        if (character.isAsciiLetter(c) || character.isAsciiDigitCharacter(c) || c === character.AsciiCodePoint.MINUS_SIGN)
             continue;
         return i;
     }
@@ -211,107 +305,6 @@ function eatStartCondition6(nodePoints, startIndex, endIndex, tagName) {
     return null;
 }
 
-function eatHTMLAttribute(nodePoints, startIndex, endIndex) {
-    let i = coreTokenizer.eatOptionalWhitespaces(nodePoints, startIndex, endIndex);
-    if (i <= startIndex || i >= endIndex)
-        return null;
-    const attrNameStartIndex = i;
-    let c = nodePoints[i].codePoint;
-    if (!character.isAsciiLetter(c) &&
-        c !== character.AsciiCodePoint.UNDERSCORE &&
-        c !== character.AsciiCodePoint.COLON)
-        return null;
-    for (i = attrNameStartIndex + 1; i < endIndex; ++i) {
-        c = nodePoints[i].codePoint;
-        if (character.isAsciiLetter(c) ||
-            character.isAsciiDigitCharacter(c) ||
-            c === character.AsciiCodePoint.UNDERSCORE ||
-            c === character.AsciiCodePoint.DOT ||
-            c === character.AsciiCodePoint.COLON ||
-            c === character.AsciiCodePoint.MINUS_SIGN)
-            continue;
-        break;
-    }
-    const attrNameEndIndex = i;
-    const attribute = {
-        name: {
-            startIndex: attrNameStartIndex,
-            endIndex: attrNameEndIndex,
-        },
-    };
-    i = coreTokenizer.eatOptionalWhitespaces(nodePoints, attrNameEndIndex, endIndex);
-    if (i < endIndex && nodePoints[i].codePoint === character.AsciiCodePoint.EQUALS_SIGN) {
-        i = coreTokenizer.eatOptionalWhitespaces(nodePoints, i + 1, endIndex);
-        if (i < endIndex) {
-            const mark = nodePoints[i].codePoint;
-            switch (mark) {
-                case character.AsciiCodePoint.DOUBLE_QUOTE: {
-                    const attrValueStartIndex = i + 1;
-                    for (i = attrValueStartIndex; i < endIndex; ++i) {
-                        c = nodePoints[i].codePoint;
-                        if (c === character.AsciiCodePoint.DOUBLE_QUOTE)
-                            break;
-                    }
-                    const attrValueEndIndex = i;
-                    if (i < endIndex &&
-                        nodePoints[i].codePoint === character.AsciiCodePoint.DOUBLE_QUOTE) {
-                        attribute.value = {
-                            startIndex: attrValueStartIndex,
-                            endIndex: attrValueEndIndex,
-                        };
-                        i += 1;
-                    }
-                    break;
-                }
-                case character.AsciiCodePoint.SINGLE_QUOTE: {
-                    const attrValueStartIndex = i + 1;
-                    for (i = attrValueStartIndex; i < endIndex; ++i) {
-                        c = nodePoints[i].codePoint;
-                        if (c === character.AsciiCodePoint.SINGLE_QUOTE)
-                            break;
-                    }
-                    const attrValueEndIndex = i;
-                    if (i < endIndex &&
-                        nodePoints[i].codePoint === character.AsciiCodePoint.SINGLE_QUOTE) {
-                        attribute.value = {
-                            startIndex: attrValueStartIndex,
-                            endIndex: attrValueEndIndex,
-                        };
-                        i += 1;
-                    }
-                    break;
-                }
-                default: {
-                    const attrValueStartIndex = i;
-                    for (; i < endIndex; ++i) {
-                        c = nodePoints[i].codePoint;
-                        if (character.isWhitespaceCharacter(c) ||
-                            c === character.AsciiCodePoint.DOUBLE_QUOTE ||
-                            c === character.AsciiCodePoint.SINGLE_QUOTE ||
-                            c === character.AsciiCodePoint.EQUALS_SIGN ||
-                            c === character.AsciiCodePoint.OPEN_ANGLE ||
-                            c === character.AsciiCodePoint.CLOSE_ANGLE ||
-                            c === character.AsciiCodePoint.BACKTICK)
-                            break;
-                    }
-                    const attrValueEndIndex = i;
-                    if (attrValueEndIndex > attrValueStartIndex) {
-                        attribute.value = {
-                            startIndex: attrValueStartIndex,
-                            endIndex: attrValueEndIndex,
-                        };
-                    }
-                    break;
-                }
-            }
-            if (attribute.value != null) {
-                return { attribute, nextIndex: i };
-            }
-        }
-    }
-    return { attribute, nextIndex: attrNameEndIndex };
-}
-
 const excludedTags = ['pre', 'script', 'style'];
 function eatStartCondition7(nodePoints, startIndex, endIndex, tagName, potentialOpenTag) {
     if (excludedTags.includes(tagName) || startIndex >= endIndex)
@@ -342,33 +335,28 @@ function eatStartCondition7(nodePoints, startIndex, endIndex, tagName, potential
     return endIndex;
 }
 
-const uniqueName = '@yozora/tokenizer-html-block';
-
-class HtmlBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
-    constructor(props = {}) {
-        var _a, _b;
-        super({
-            name: (_a = props.name) !== null && _a !== void 0 ? _a : uniqueName,
-            priority: (_b = props.priority) !== null && _b !== void 0 ? _b : coreTokenizer.TokenizerPriority.ATOMIC,
-        });
-        this.isContainingBlock = false;
-    }
-    eatOpener(line) {
+const match = function () {
+    return {
+        isContainingBlock: false,
+        eatOpener,
+        eatAndInterruptPreviousSibling,
+        eatContinuationText,
+    };
+    function eatOpener(line) {
         if (line.countOfPrecedeSpaces >= 4)
             return null;
         const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex } = line;
         if (firstNonWhitespaceIndex >= endIndex ||
-            nodePoints[firstNonWhitespaceIndex].codePoint !==
-                character.AsciiCodePoint.OPEN_ANGLE)
+            nodePoints[firstNonWhitespaceIndex].codePoint !== character.AsciiCodePoint.OPEN_ANGLE)
             return null;
         const i = firstNonWhitespaceIndex + 1;
-        const startResult = this.eatStartCondition(nodePoints, i, endIndex);
+        const startResult = eatStartCondition(nodePoints, i, endIndex);
         if (startResult == null)
             return null;
         const { condition } = startResult;
         let saturated = false;
         if (condition !== 6 && condition !== 7) {
-            const endResult = this.eatEndCondition(nodePoints, startResult.nextIndex, endIndex, condition);
+            const endResult = eatEndCondition(nodePoints, startResult.nextIndex, endIndex, condition);
             if (endResult != null)
                 saturated = true;
         }
@@ -384,8 +372,8 @@ class HtmlBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
         };
         return { token, nextIndex, saturated };
     }
-    eatAndInterruptPreviousSibling(line, prevSiblingToken) {
-        const result = this.eatOpener(line);
+    function eatAndInterruptPreviousSibling(line, prevSiblingToken) {
+        const result = eatOpener(line);
         if (result == null || result.token.condition === 7)
             return null;
         const { token, nextIndex } = result;
@@ -395,9 +383,9 @@ class HtmlBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
             remainingSibling: prevSiblingToken,
         };
     }
-    eatContinuationText(line, token) {
+    function eatContinuationText(line, token) {
         const { nodePoints, endIndex, firstNonWhitespaceIndex } = line;
-        const nextIndex = this.eatEndCondition(nodePoints, firstNonWhitespaceIndex, endIndex, token.condition);
+        const nextIndex = eatEndCondition(nodePoints, firstNonWhitespaceIndex, endIndex, token.condition);
         if (nextIndex === -1)
             return { status: 'notMatched' };
         token.lines.push(line);
@@ -405,15 +393,7 @@ class HtmlBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
             return { status: 'closing', nextIndex: endIndex };
         return { status: 'opening', nextIndex: endIndex };
     }
-    parseBlock(token) {
-        const contents = coreTokenizer.mergeContentLinesFaithfully(token.lines);
-        const node = {
-            type: 'html',
-            value: character.calcStringFromNodePoints(contents),
-        };
-        return node;
-    }
-    eatStartCondition(nodePoints, startIndex, endIndex) {
+    function eatStartCondition(nodePoints, startIndex, endIndex) {
         let nextIndex = null;
         if (startIndex >= endIndex)
             return null;
@@ -469,7 +449,7 @@ class HtmlBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
             return { nextIndex, condition: 7 };
         return null;
     }
-    eatEndCondition(nodePoints, startIndex, endIndex, condition) {
+    function eatEndCondition(nodePoints, startIndex, endIndex, condition) {
         switch (condition) {
             case 1: {
                 const nextIndex = eatEndCondition1(nodePoints, startIndex, endIndex);
@@ -498,10 +478,39 @@ class HtmlBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
             }
         }
     }
+};
+
+const parse = function () {
+    return {
+        parse: token => {
+            const contents = coreTokenizer.mergeContentLinesFaithfully(token.lines);
+            const node = {
+                type: 'html',
+                value: character.calcStringFromNodePoints(contents),
+            };
+            return node;
+        },
+    };
+};
+
+const uniqueName = '@yozora/tokenizer-html-block';
+
+class HtmlBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
+    constructor(props = {}) {
+        var _a, _b;
+        super({
+            name: (_a = props.name) !== null && _a !== void 0 ? _a : uniqueName,
+            priority: (_b = props.priority) !== null && _b !== void 0 ? _b : coreTokenizer.TokenizerPriority.ATOMIC,
+        });
+        this.match = match;
+        this.parse = parse;
+    }
 }
 
 exports.HtmlBlockTokenizer = HtmlBlockTokenizer;
 exports.HtmlBlockTokenizerName = uniqueName;
-exports['default'] = HtmlBlockTokenizer;
+exports["default"] = HtmlBlockTokenizer;
 exports.eatHTMLAttribute = eatHTMLAttribute;
 exports.eatHTMLTagName = eatHTMLTagName;
+exports.htmlBlockMatch = match;
+exports.htmlBlockParse = parse;

package/lib/esm/index.js

@@ -1,17 +1,111 @@
+import { isAsciiLetter, AsciiCodePoint, isAsciiDigitCharacter, isWhitespaceCharacter, calcStringFromNodePoints, isAsciiUpperLetter } from '@yozora/character';
+import { eatOptionalWhitespaces, calcStartYastNodePoint, calcEndYastNodePoint, mergeContentLinesFaithfully, BaseBlockTokenizer, TokenizerPriority } from '@yozora/core-tokenizer';
 import { HtmlType } from '@yozora/ast';
-import { isAsciiLetter, isAsciiDigitCharacter, AsciiCodePoint, isWhitespaceCharacter, calcStringFromNodePoints, isAsciiUpperLetter } from '@yozora/character';
-import { eatOptionalWhitespaces, BaseBlockTokenizer, TokenizerPriority, calcStartYastNodePoint, calcEndYastNodePoint, mergeContentLinesFaithfully } from '@yozora/core-tokenizer';
+
+function eatHTMLAttribute(nodePoints, startIndex, endIndex) {
+    let i = eatOptionalWhitespaces(nodePoints, startIndex, endIndex);
+    if (i <= startIndex || i >= endIndex)
+        return null;
+    const attrNameStartIndex = i;
+    let c = nodePoints[i].codePoint;
+    if (!isAsciiLetter(c) && c !== AsciiCodePoint.UNDERSCORE && c !== AsciiCodePoint.COLON)
+        return null;
+    for (i = attrNameStartIndex + 1; i < endIndex; ++i) {
+        c = nodePoints[i].codePoint;
+        if (isAsciiLetter(c) ||
+            isAsciiDigitCharacter(c) ||
+            c === AsciiCodePoint.UNDERSCORE ||
+            c === AsciiCodePoint.DOT ||
+            c === AsciiCodePoint.COLON ||
+            c === AsciiCodePoint.MINUS_SIGN)
+            continue;
+        break;
+    }
+    const attrNameEndIndex = i;
+    const attribute = {
+        name: {
+            startIndex: attrNameStartIndex,
+            endIndex: attrNameEndIndex,
+        },
+    };
+    i = eatOptionalWhitespaces(nodePoints, attrNameEndIndex, endIndex);
+    if (i < endIndex && nodePoints[i].codePoint === AsciiCodePoint.EQUALS_SIGN) {
+        i = eatOptionalWhitespaces(nodePoints, i + 1, endIndex);
+        if (i < endIndex) {
+            const mark = nodePoints[i].codePoint;
+            switch (mark) {
+                case AsciiCodePoint.DOUBLE_QUOTE: {
+                    const attrValueStartIndex = i + 1;
+                    for (i = attrValueStartIndex; i < endIndex; ++i) {
+                        c = nodePoints[i].codePoint;
+                        if (c === AsciiCodePoint.DOUBLE_QUOTE)
+                            break;
+                    }
+                    const attrValueEndIndex = i;
+                    if (i < endIndex && nodePoints[i].codePoint === AsciiCodePoint.DOUBLE_QUOTE) {
+                        attribute.value = {
+                            startIndex: attrValueStartIndex,
+                            endIndex: attrValueEndIndex,
+                        };
+                        i += 1;
+                    }
+                    break;
+                }
+                case AsciiCodePoint.SINGLE_QUOTE: {
+                    const attrValueStartIndex = i + 1;
+                    for (i = attrValueStartIndex; i < endIndex; ++i) {
+                        c = nodePoints[i].codePoint;
+                        if (c === AsciiCodePoint.SINGLE_QUOTE)
+                            break;
+                    }
+                    const attrValueEndIndex = i;
+                    if (i < endIndex && nodePoints[i].codePoint === AsciiCodePoint.SINGLE_QUOTE) {
+                        attribute.value = {
+                            startIndex: attrValueStartIndex,
+                            endIndex: attrValueEndIndex,
+                        };
+                        i += 1;
+                    }
+                    break;
+                }
+                default: {
+                    const attrValueStartIndex = i;
+                    for (; i < endIndex; ++i) {
+                        c = nodePoints[i].codePoint;
+                        if (isWhitespaceCharacter(c) ||
+                            c === AsciiCodePoint.DOUBLE_QUOTE ||
+                            c === AsciiCodePoint.SINGLE_QUOTE ||
+                            c === AsciiCodePoint.EQUALS_SIGN ||
+                            c === AsciiCodePoint.OPEN_ANGLE ||
+                            c === AsciiCodePoint.CLOSE_ANGLE ||
+                            c === AsciiCodePoint.BACKTICK)
+                            break;
+                    }
+                    const attrValueEndIndex = i;
+                    if (attrValueEndIndex > attrValueStartIndex) {
+                        attribute.value = {
+                            startIndex: attrValueStartIndex,
+                            endIndex: attrValueEndIndex,
+                        };
+                    }
+                    break;
+                }
+            }
+            if (attribute.value != null) {
+                return { attribute, nextIndex: i };
+            }
+        }
+    }
+    return { attribute, nextIndex: attrNameEndIndex };
+}
 
 function eatHTMLTagName(nodePoints, startIndex, endIndex) {
-    if (startIndex >= endIndex ||
-        !isAsciiLetter(nodePoints[startIndex].codePoint))
+    if (startIndex >= endIndex || !isAsciiLetter(nodePoints[startIndex].codePoint))
         return null;
     let i = startIndex;
     for (; i < endIndex; ++i) {
         const c = nodePoints[i].codePoint;
-        if (isAsciiLetter(c) ||
-            isAsciiDigitCharacter(c) ||
-            c === AsciiCodePoint.MINUS_SIGN)
+        if (isAsciiLetter(c) || isAsciiDigitCharacter(c) || c === AsciiCodePoint.MINUS_SIGN)
             continue;
         return i;
     }
@@ -207,107 +301,6 @@ function eatStartCondition6(nodePoints, startIndex, endIndex, tagName) {
     return null;
 }
 
-function eatHTMLAttribute(nodePoints, startIndex, endIndex) {
-    let i = eatOptionalWhitespaces(nodePoints, startIndex, endIndex);
-    if (i <= startIndex || i >= endIndex)
-        return null;
-    const attrNameStartIndex = i;
-    let c = nodePoints[i].codePoint;
-    if (!isAsciiLetter(c) &&
-        c !== AsciiCodePoint.UNDERSCORE &&
-        c !== AsciiCodePoint.COLON)
-        return null;
-    for (i = attrNameStartIndex + 1; i < endIndex; ++i) {
-        c = nodePoints[i].codePoint;
-        if (isAsciiLetter(c) ||
-            isAsciiDigitCharacter(c) ||
-            c === AsciiCodePoint.UNDERSCORE ||
-            c === AsciiCodePoint.DOT ||
-            c === AsciiCodePoint.COLON ||
-            c === AsciiCodePoint.MINUS_SIGN)
-            continue;
-        break;
-    }
-    const attrNameEndIndex = i;
-    const attribute = {
-        name: {
-            startIndex: attrNameStartIndex,
-            endIndex: attrNameEndIndex,
-        },
-    };
-    i = eatOptionalWhitespaces(nodePoints, attrNameEndIndex, endIndex);
-    if (i < endIndex && nodePoints[i].codePoint === AsciiCodePoint.EQUALS_SIGN) {
-        i = eatOptionalWhitespaces(nodePoints, i + 1, endIndex);
-        if (i < endIndex) {
-            const mark = nodePoints[i].codePoint;
-            switch (mark) {
-                case AsciiCodePoint.DOUBLE_QUOTE: {
-                    const attrValueStartIndex = i + 1;
-                    for (i = attrValueStartIndex; i < endIndex; ++i) {
-                        c = nodePoints[i].codePoint;
-                        if (c === AsciiCodePoint.DOUBLE_QUOTE)
-                            break;
-                    }
-                    const attrValueEndIndex = i;
-                    if (i < endIndex &&
-                        nodePoints[i].codePoint === AsciiCodePoint.DOUBLE_QUOTE) {
-                        attribute.value = {
-                            startIndex: attrValueStartIndex,
-                            endIndex: attrValueEndIndex,
-                        };
-                        i += 1;
-                    }
-                    break;
-                }
-                case AsciiCodePoint.SINGLE_QUOTE: {
-                    const attrValueStartIndex = i + 1;
-                    for (i = attrValueStartIndex; i < endIndex; ++i) {
-                        c = nodePoints[i].codePoint;
-                        if (c === AsciiCodePoint.SINGLE_QUOTE)
-                            break;
-                    }
-                    const attrValueEndIndex = i;
-                    if (i < endIndex &&
-                        nodePoints[i].codePoint === AsciiCodePoint.SINGLE_QUOTE) {
-                        attribute.value = {
-                            startIndex: attrValueStartIndex,
-                            endIndex: attrValueEndIndex,
-                        };
-                        i += 1;
-                    }
-                    break;
-                }
-                default: {
-                    const attrValueStartIndex = i;
-                    for (; i < endIndex; ++i) {
-                        c = nodePoints[i].codePoint;
-                        if (isWhitespaceCharacter(c) ||
-                            c === AsciiCodePoint.DOUBLE_QUOTE ||
-                            c === AsciiCodePoint.SINGLE_QUOTE ||
-                            c === AsciiCodePoint.EQUALS_SIGN ||
-                            c === AsciiCodePoint.OPEN_ANGLE ||
-                            c === AsciiCodePoint.CLOSE_ANGLE ||
-                            c === AsciiCodePoint.BACKTICK)
-                            break;
-                    }
-                    const attrValueEndIndex = i;
-                    if (attrValueEndIndex > attrValueStartIndex) {
-                        attribute.value = {
-                            startIndex: attrValueStartIndex,
-                            endIndex: attrValueEndIndex,
-                        };
-                    }
-                    break;
-                }
-            }
-            if (attribute.value != null) {
-                return { attribute, nextIndex: i };
-            }
-        }
-    }
-    return { attribute, nextIndex: attrNameEndIndex };
-}
-
 const excludedTags = ['pre', 'script', 'style'];
 function eatStartCondition7(nodePoints, startIndex, endIndex, tagName, potentialOpenTag) {
     if (excludedTags.includes(tagName) || startIndex >= endIndex)
@@ -338,33 +331,28 @@ function eatStartCondition7(nodePoints, startIndex, endIndex, tagName, potential
     return endIndex;
 }
 
-const uniqueName = '@yozora/tokenizer-html-block';
-
-class HtmlBlockTokenizer extends BaseBlockTokenizer {
-    constructor(props = {}) {
-        var _a, _b;
-        super({
-            name: (_a = props.name) !== null && _a !== void 0 ? _a : uniqueName,
-            priority: (_b = props.priority) !== null && _b !== void 0 ? _b : TokenizerPriority.ATOMIC,
-        });
-        this.isContainingBlock = false;
-    }
-    eatOpener(line) {
+const match = function () {
+    return {
+        isContainingBlock: false,
+        eatOpener,
+        eatAndInterruptPreviousSibling,
+        eatContinuationText,
+    };
+    function eatOpener(line) {
         if (line.countOfPrecedeSpaces >= 4)
             return null;
         const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex } = line;
         if (firstNonWhitespaceIndex >= endIndex ||
-            nodePoints[firstNonWhitespaceIndex].codePoint !==
-                AsciiCodePoint.OPEN_ANGLE)
+            nodePoints[firstNonWhitespaceIndex].codePoint !== AsciiCodePoint.OPEN_ANGLE)
             return null;
         const i = firstNonWhitespaceIndex + 1;
-        const startResult = this.eatStartCondition(nodePoints, i, endIndex);
+        const startResult = eatStartCondition(nodePoints, i, endIndex);
         if (startResult == null)
             return null;
         const { condition } = startResult;
         let saturated = false;
         if (condition !== 6 && condition !== 7) {
-            const endResult = this.eatEndCondition(nodePoints, startResult.nextIndex, endIndex, condition);
+            const endResult = eatEndCondition(nodePoints, startResult.nextIndex, endIndex, condition);
             if (endResult != null)
                 saturated = true;
         }
@@ -380,8 +368,8 @@ class HtmlBlockTokenizer extends BaseBlockTokenizer {
         };
         return { token, nextIndex, saturated };
     }
-    eatAndInterruptPreviousSibling(line, prevSiblingToken) {
-        const result = this.eatOpener(line);
+    function eatAndInterruptPreviousSibling(line, prevSiblingToken) {
+        const result = eatOpener(line);
         if (result == null || result.token.condition === 7)
             return null;
         const { token, nextIndex } = result;
@@ -391,9 +379,9 @@ class HtmlBlockTokenizer extends BaseBlockTokenizer {
             remainingSibling: prevSiblingToken,
         };
     }
-    eatContinuationText(line, token) {
+    function eatContinuationText(line, token) {
         const { nodePoints, endIndex, firstNonWhitespaceIndex } = line;
-        const nextIndex = this.eatEndCondition(nodePoints, firstNonWhitespaceIndex, endIndex, token.condition);
+        const nextIndex = eatEndCondition(nodePoints, firstNonWhitespaceIndex, endIndex, token.condition);
         if (nextIndex === -1)
             return { status: 'notMatched' };
         token.lines.push(line);
@@ -401,15 +389,7 @@ class HtmlBlockTokenizer extends BaseBlockTokenizer {
             return { status: 'closing', nextIndex: endIndex };
         return { status: 'opening', nextIndex: endIndex };
     }
-    parseBlock(token) {
-        const contents = mergeContentLinesFaithfully(token.lines);
-        const node = {
-            type: 'html',
-            value: calcStringFromNodePoints(contents),
-        };
-        return node;
-    }
-    eatStartCondition(nodePoints, startIndex, endIndex) {
+    function eatStartCondition(nodePoints, startIndex, endIndex) {
         let nextIndex = null;
         if (startIndex >= endIndex)
             return null;
@@ -465,7 +445,7 @@ class HtmlBlockTokenizer extends BaseBlockTokenizer {
             return { nextIndex, condition: 7 };
         return null;
     }
-    eatEndCondition(nodePoints, startIndex, endIndex, condition) {
+    function eatEndCondition(nodePoints, startIndex, endIndex, condition) {
         switch (condition) {
             case 1: {
                 const nextIndex = eatEndCondition1(nodePoints, startIndex, endIndex);
@@ -494,6 +474,33 @@ class HtmlBlockTokenizer extends BaseBlockTokenizer {
             }
         }
     }
+};
+
+const parse = function () {
+    return {
+        parse: token => {
+            const contents = mergeContentLinesFaithfully(token.lines);
+            const node = {
+                type: 'html',
+                value: calcStringFromNodePoints(contents),
+            };
+            return node;
+        },
+    };
+};
+
+const uniqueName = '@yozora/tokenizer-html-block';
+
+class HtmlBlockTokenizer extends BaseBlockTokenizer {
+    constructor(props = {}) {
+        var _a, _b;
+        super({
+            name: (_a = props.name) !== null && _a !== void 0 ? _a : uniqueName,
+            priority: (_b = props.priority) !== null && _b !== void 0 ? _b : TokenizerPriority.ATOMIC,
+        });
+        this.match = match;
+        this.parse = parse;
+    }
 }
 
-export { HtmlBlockTokenizer, uniqueName as HtmlBlockTokenizerName, HtmlBlockTokenizer as default, eatHTMLAttribute, eatHTMLTagName };
+export { HtmlBlockTokenizer, uniqueName as HtmlBlockTokenizerName, HtmlBlockTokenizer as default, eatHTMLAttribute, eatHTMLTagName, match as htmlBlockMatch, parse as htmlBlockParse };

package/lib/types/conditions/c1.d.ts

@@ -1,4 +1,4 @@
-import type { NodePoint } from '@yozora/character';
+import type { INodePoint } from '@yozora/character';
 /**
  * Eat block html start condition 1:
  *
@@ -11,7 +11,7 @@ import type { NodePoint } from '@yozora/character';
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatStartCondition1(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number, tagName: string): number | null;
+export declare function eatStartCondition1(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number, tagName: string): number | null;
 /**
  * Eat block html end condition 1:
  *
@@ -23,4 +23,4 @@ export declare function eatStartCondition1(nodePoints: ReadonlyArray<NodePoint>,
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatEndCondition1(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): number | null;
+export declare function eatEndCondition1(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): number | null;

package/lib/types/conditions/c2.d.ts

@@ -1,4 +1,4 @@
-import type { NodePoint } from '@yozora/character';
+import type { INodePoint } from '@yozora/character';
 /**
  * Eat block html start condition 2:
  *
@@ -9,7 +9,7 @@ import type { NodePoint } from '@yozora/character';
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatStartCondition2(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): number | null;
+export declare function eatStartCondition2(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): number | null;
 /**
  * Eat block html end condition 2:
  *
@@ -20,4 +20,4 @@ export declare function eatStartCondition2(nodePoints: ReadonlyArray<NodePoint>,
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatEndCondition2(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): number | null;
+export declare function eatEndCondition2(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): number | null;

package/lib/types/conditions/c3.d.ts

@@ -1,4 +1,4 @@
-import type { NodePoint } from '@yozora/character';
+import type { INodePoint } from '@yozora/character';
 /**
  * Eat block html start condition 3:
  *
@@ -9,7 +9,7 @@ import type { NodePoint } from '@yozora/character';
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatStartCondition3(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): number | null;
+export declare function eatStartCondition3(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): number | null;
 /**
  * Eat block html end condition 3:
  *
@@ -20,4 +20,4 @@ export declare function eatStartCondition3(nodePoints: ReadonlyArray<NodePoint>,
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatEndCondition3(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): number | null;
+export declare function eatEndCondition3(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): number | null;

package/lib/types/conditions/c4.d.ts

@@ -1,4 +1,4 @@
-import type { NodePoint } from '@yozora/character';
+import type { INodePoint } from '@yozora/character';
 /**
  * Eat block html start condition 4:
  *
@@ -9,7 +9,7 @@ import type { NodePoint } from '@yozora/character';
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatStartCondition4(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): number | null;
+export declare function eatStartCondition4(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): number | null;
 /**
  * Eat block html end condition 4:
  *
@@ -20,4 +20,4 @@ export declare function eatStartCondition4(nodePoints: ReadonlyArray<NodePoint>,
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatEndCondition4(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): number | null;
+export declare function eatEndCondition4(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): number | null;

package/lib/types/conditions/c5.d.ts

@@ -1,4 +1,4 @@
-import type { NodePoint } from '@yozora/character';
+import type { INodePoint } from '@yozora/character';
 /**
  * Eat block html start condition 5:
  *
@@ -9,7 +9,7 @@ import type { NodePoint } from '@yozora/character';
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatStartCondition5(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): number | null;
+export declare function eatStartCondition5(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): number | null;
 /**
  * Eat block html end condition 5:
  *
@@ -20,4 +20,4 @@ export declare function eatStartCondition5(nodePoints: ReadonlyArray<NodePoint>,
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatEndCondition5(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): number | null;
+export declare function eatEndCondition5(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): number | null;

package/lib/types/conditions/c6.d.ts

@@ -1,4 +1,4 @@
-import type { NodePoint } from '@yozora/character';
+import type { INodePoint } from '@yozora/character';
 /**
  * Eat block html start condition 6:
  *
@@ -19,4 +19,4 @@ import type { NodePoint } from '@yozora/character';
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatStartCondition6(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number, tagName: string): number | null;
+export declare function eatStartCondition6(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number, tagName: string): number | null;

package/lib/types/conditions/c7.d.ts

@@ -1,4 +1,4 @@
-import type { NodePoint } from '@yozora/character';
+import type { INodePoint } from '@yozora/character';
 /**
  * Eat block html start condition 7:
  *
@@ -11,4 +11,4 @@ import type { NodePoint } from '@yozora/character';
  * @param endIndex
  * @see https://github.github.com/gfm/#start-condition
  */
-export declare function eatStartCondition7(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number, tagName: string, potentialOpenTag: boolean): number | null;
+export declare function eatStartCondition7(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number, tagName: string, potentialOpenTag: boolean): number | null;

package/lib/types/index.d.ts

@@ -1,7 +1,7 @@
-import { HtmlBlockTokenizer } from './tokenizer';
 export * from './util/eat-html-attribute';
 export * from './util/eat-html-tagname';
-export { HtmlBlockTokenizer } from './tokenizer';
+export { match as htmlBlockMatch } from './match';
+export { parse as htmlBlockParse } from './parse';
+export { HtmlBlockTokenizer, HtmlBlockTokenizer as default } from './tokenizer';
 export { uniqueName as HtmlBlockTokenizerName } from './types';
-export type { Token as HtmlBlockToken, TokenizerProps as HtmlBlockTokenizerProps, } from './types';
-export default HtmlBlockTokenizer;
+export type { IHookContext as IHtmlBlockHookContext, IToken as IHtmlBlockToken, ITokenizerProps as IHtmlBlockTokenizerProps, } from './types';

package/lib/types/match.d.ts

@@ -0,0 +1,10 @@
+import type { IMatchBlockHookCreator } from '@yozora/core-tokenizer';
+import type { IHookContext, IToken, T } from './types';
+/**
+ * An HTML block is a group of lines that is treated as raw HTML (and will not
+ * be escaped in HTML output).
+ *
+ * @see https://github.com/syntax-tree/mdast#html
+ * @see https://github.github.com/gfm/#html-blocks
+ */
+export declare const match: IMatchBlockHookCreator<T, IToken, IHookContext>;

package/lib/types/parse.d.ts

@@ -0,0 +1,3 @@
+import type { IParseBlockHookCreator } from '@yozora/core-tokenizer';
+import type { IHookContext, INode, IToken, T } from './types';
+export declare const parse: IParseBlockHookCreator<T, IToken, INode, IHookContext>;

package/lib/types/tokenizer.d.ts

@@ -1,57 +1,13 @@
-import type { NodePoint } from '@yozora/character';
-import type { PhrasingContentLine, ResultOfEatAndInterruptPreviousSibling, ResultOfEatContinuationText, ResultOfEatOpener, ResultOfParse, Tokenizer, TokenizerMatchBlockHook, TokenizerParseBlockHook, YastBlockToken } from '@yozora/core-tokenizer';
+import type { IBlockTokenizer, IMatchBlockHookCreator, IParseBlockHookCreator } from '@yozora/core-tokenizer';
 import { BaseBlockTokenizer } from '@yozora/core-tokenizer';
-import type { HtmlBlockConditionType, Node, T, Token, TokenizerProps } from './types';
+import type { IHookContext, INode, IToken, ITokenizerProps, T } from './types';
 /**
  * Lexical Analyzer for HtmlBlock.
- *
- * An HTML block is a group of lines that is treated as raw HTML (and will not
- * be escaped in HTML output).
- *
  * @see https://github.com/syntax-tree/mdast#html
  * @see https://github.github.com/gfm/#html-blocks
  */
-export declare class HtmlBlockTokenizer extends BaseBlockTokenizer implements Tokenizer, TokenizerMatchBlockHook<T, Token>, TokenizerParseBlockHook<T, Token, Node> {
-    readonly isContainingBlock = false;
-    constructor(props?: TokenizerProps);
-    /**
-     * @override
-     * @see TokenizerMatchBlockHook
-     */
-    eatOpener(line: Readonly<PhrasingContentLine>): ResultOfEatOpener<T, Token>;
-    /**
-     * @override
-     * @see TokenizerMatchBlockHook
-     */
-    eatAndInterruptPreviousSibling(line: Readonly<PhrasingContentLine>, prevSiblingToken: Readonly<YastBlockToken>): ResultOfEatAndInterruptPreviousSibling<T, Token>;
-    /**
-     * @override
-     * @see TokenizerMatchBlockHook
-     */
-    eatContinuationText(line: Readonly<PhrasingContentLine>, token: Token): ResultOfEatContinuationText;
-    /**
-     * @override
-     * @see TokenizerParseBlockHook
-     */
-    parseBlock(token: Readonly<Token>): ResultOfParse<T, Node>;
-    /**
-     * Resolve html block start condition.
-     *
-     * @param nodePoints
-     * @param startIndex
-     * @param endIndex
-     */
-    protected eatStartCondition(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): {
-        condition: HtmlBlockConditionType;
-        nextIndex: number;
-    } | null;
-    /**
-     * Resolve html block end condition.
-     *
-     * @param nodePoints
-     * @param startIndex
-     * @param endIndex
-     * @param condition
-     */
-    protected eatEndCondition(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number, condition: HtmlBlockConditionType): -1 | number | null;
+export declare class HtmlBlockTokenizer extends BaseBlockTokenizer<T, IToken, INode, IHookContext> implements IBlockTokenizer<T, IToken, INode, IHookContext> {
+    constructor(props?: ITokenizerProps);
+    readonly match: IMatchBlockHookCreator<T, IToken, IHookContext>;
+    readonly parse: IParseBlockHookCreator<T, IToken, INode, IHookContext>;
 }

package/lib/types/types.d.ts

@@ -1,13 +1,13 @@
-import type { Html, HtmlType } from '@yozora/ast';
-import type { BaseBlockTokenizerProps, PartialYastBlockToken, PhrasingContentLine } from '@yozora/core-tokenizer';
+import type { HtmlType, IHtml } from '@yozora/ast';
+import type { IBaseBlockTokenizerProps, IPartialYastBlockToken, IPhrasingContentLine, ITokenizer } from '@yozora/core-tokenizer';
 export declare type T = HtmlType;
-export declare type Node = Html;
+export declare type INode = IHtml;
 export declare const uniqueName = "@yozora/tokenizer-html-block";
 export declare type HtmlBlockConditionType = 1 | 2 | 3 | 4 | 5 | 6 | 7;
 /**
  * Middle state during the whole match and parse phase.
  */
-export interface Token extends PartialYastBlockToken<T> {
+export interface IToken extends IPartialYastBlockToken<T> {
     /**
      * Number of conditions defined in GFM:
      *
@@ -58,6 +58,7 @@ export interface Token extends PartialYastBlockToken<T> {
     /**
      * Contents
      */
-    lines: Array<Readonly<PhrasingContentLine>>;
+    lines: Array<Readonly<IPhrasingContentLine>>;
 }
-export declare type TokenizerProps = Partial<BaseBlockTokenizerProps>;
+export declare type IHookContext = ITokenizer;
+export declare type ITokenizerProps = Partial<IBaseBlockTokenizerProps>;

package/lib/types/util/eat-html-attribute.d.ts

@@ -1,13 +1,13 @@
-import type { NodeInterval, NodePoint } from '@yozora/character';
+import type { INodeInterval, INodePoint } from '@yozora/character';
 export interface RawHTMLAttribute {
     /**
      * Attribute name.
      */
-    name: NodeInterval;
+    name: INodeInterval;
     /**
      * Attribute value.
      */
-    value?: NodeInterval;
+    value?: INodeInterval;
 }
 /**
  * An attribute consists of whitespace, an attribute name, and an optional
@@ -18,7 +18,7 @@ export interface RawHTMLAttribute {
  * @param endIndex
  * @see https://github.github.com/gfm/#attribute
  */
-export declare function eatHTMLAttribute(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): {
+export declare function eatHTMLAttribute(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): {
     attribute: RawHTMLAttribute;
     nextIndex: number;
 } | null;

package/lib/types/util/eat-html-tagname.d.ts

@@ -1,4 +1,4 @@
-import type { NodePoint } from '@yozora/character';
+import type { INodePoint } from '@yozora/character';
 /**
  * A tag name consists of an ASCII letter followed by zero or more ASCII
  * letters, digits, or hyphens (-).
@@ -8,4 +8,4 @@ import type { NodePoint } from '@yozora/character';
  * @param endIndex
  * @see https://github.github.com/gfm/#tag-name
  */
-export declare function eatHTMLTagName(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): number | null;
+export declare function eatHTMLTagName(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): number | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-html-block",
-  "version": "1.3.0",
+  "version": "2.0.0-alpha.0",
   "author": {
     "name": "guanghechen",
     "url": "https://github.com/guanghechen/"
@@ -35,9 +35,9 @@
     "test": "cross-env TS_NODE_FILES=true jest --config ../../jest.config.js --rootDir ."
   },
   "dependencies": {
-    "@yozora/ast": "^1.3.0",
-    "@yozora/character": "^1.3.0",
-    "@yozora/core-tokenizer": "^1.3.0"
+    "@yozora/ast": "^2.0.0-alpha.0",
+    "@yozora/character": "^2.0.0-alpha.0",
+    "@yozora/core-tokenizer": "^2.0.0-alpha.0"
   },
-  "gitHead": "18c9b167004ad97718b2f94f25139f80598cbf7a"
+  "gitHead": "0171501339c49ffd02ed16a63447fa20a47a29a7"
 }