@yozora/tokenizer-html-inline 1.2.2 → 2.0.0-alpha.2

package/README.md

@@ -84,14 +84,14 @@ so you can use `YozoraParser` / `GfmExParser` / `GfmParser` directly.
 registered in *YastParser* as a plugin-in before it can be used.
 
 ```typescript {4,9}
-import { DefaultYastParser } from '@yozora/core-parser'
+import { DefaultParser } from '@yozora/core-parser'
 import ParagraphTokenizer from '@yozora/tokenizer-paragraph'
 import TextTokenizer from '@yozora/tokenizer-text'
 import HtmlInlineTokenizer from '@yozora/tokenizer-html-inline'
 
-const parser = new DefaultYastParser()
-  .useBlockFallbackTokenizer(new ParagraphTokenizer())
-  .useInlineFallbackTokenizer(new TextTokenizer())
+const parser = new DefaultParser()
+  .useFallbackTokenizer(new ParagraphTokenizer())
+  .useFallbackTokenizer(new TextTokenizer())
   .useTokenizer(new HtmlInlineTokenizer())
 
 // parse source markdown content
@@ -229,7 +229,6 @@ Name              | Type        | Required  | Default
 [@yozora/tokenizer-link]:                     https://github.com/yozorajs/yozora/tree/main/tokenizers/link#readme
 [@yozora/tokenizer-link-reference]:           https://github.com/yozorajs/yozora/tree/main/tokenizers/link-reference#readme
 [@yozora/tokenizer-list]:                     https://github.com/yozorajs/yozora/tree/main/tokenizers/list#readme
-[@yozora/tokenizer-list-item]:                https://github.com/yozorajs/yozora/tree/main/tokenizers/list-item#readme
 [@yozora/tokenizer-math]:                     https://github.com/yozorajs/yozora/tree/main/tokenizers/math#readme
 [@yozora/tokenizer-paragraph]:                https://github.com/yozorajs/yozora/tree/main/tokenizers/paragraph#readme
 [@yozora/tokenizer-setext-heading]:           https://github.com/yozorajs/yozora/tree/main/tokenizers/setext-heading#readme
@@ -289,7 +288,6 @@ Name              | Type        | Required  | Default
 [doc-@yozora/tokenizer-definition]:           https://yozora.guanghechen.com/docs/package/tokenizer-definition
 [doc-@yozora/tokenizer-link-reference]:       https://yozora.guanghechen.com/docs/package/tokenizer-link-reference
 [doc-@yozora/tokenizer-list]:                 https://yozora.guanghechen.com/docs/package/tokenizer-list
-[doc-@yozora/tokenizer-list-item]:            https://yozora.guanghechen.com/docs/package/tokenizer-list-item
 [doc-@yozora/tokenizer-math]:                 https://yozora.guanghechen.com/docs/package/tokenizer-math
 [doc-@yozora/tokenizer-paragraph]:            https://yozora.guanghechen.com/docs/package/tokenizer-paragraph
 [doc-@yozora/tokenizer-setext-heading]:       https://yozora.guanghechen.com/docs/package/tokenizer-setext-heading

package/lib/cjs/index.js

@@ -2,12 +2,10 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var ast = require('@yozora/ast');
 var character = require('@yozora/character');
 var coreTokenizer = require('@yozora/core-tokenizer');
 var tokenizerHtmlBlock = require('@yozora/tokenizer-html-block');
-
-const uniqueName = '@yozora/tokenizer-html-inline';
+var ast = require('@yozora/ast');
 
 function eatHtmlInlineCDataDelimiter(nodePoints, startIndex, endIndex) {
     let i = startIndex;
@@ -108,8 +106,7 @@ function eatHtmlInlineCommentDelimiter(nodePoints, startIndex, endIndex) {
 
 function eatHtmlInlineDeclarationDelimiter(nodePoints, startIndex, endIndex) {
     let i = startIndex;
-    if (i + 4 >= endIndex ||
-        nodePoints[i + 1].codePoint !== character.AsciiCodePoint.EXCLAMATION_MARK)
+    if (i + 4 >= endIndex || nodePoints[i + 1].codePoint !== character.AsciiCodePoint.EXCLAMATION_MARK)
         return null;
     const tagNameStartIndex = i + 2;
     for (i = tagNameStartIndex; i < endIndex; ++i) {
@@ -143,8 +140,7 @@ function eatHtmlInlineDeclarationDelimiter(nodePoints, startIndex, endIndex) {
 
 function eatHtmlInlineInstructionDelimiter(nodePoints, startIndex, endIndex) {
     let i = startIndex;
-    if (i + 3 >= endIndex ||
-        nodePoints[i + 1].codePoint !== character.AsciiCodePoint.QUESTION_MARK)
+    if (i + 3 >= endIndex || nodePoints[i + 1].codePoint !== character.AsciiCodePoint.QUESTION_MARK)
         return null;
     const si = i + 2;
     for (i = si; i < endIndex; ++i) {
@@ -207,15 +203,13 @@ function eatHtmlInlineTokenOpenDelimiter(nodePoints, startIndex, endIndex) {
     return delimiter;
 }
 
-class HtmlInlineTokenizer extends coreTokenizer.BaseInlineTokenizer {
-    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,
-        });
-    }
-    _findDelimiter(startIndex, endIndex, nodePoints) {
+const match = function (api) {
+    return {
+        findDelimiter: () => coreTokenizer.genFindDelimiter(_findDelimiter),
+        processSingleDelimiter,
+    };
+    function _findDelimiter(startIndex, endIndex) {
+        const nodePoints = api.getNodePoints();
         for (let i = startIndex; i < endIndex; ++i) {
             i = coreTokenizer.eatOptionalWhitespaces(nodePoints, i, endIndex);
             if (i >= endIndex)
@@ -226,7 +220,7 @@ class HtmlInlineTokenizer extends coreTokenizer.BaseInlineTokenizer {
                     i += 1;
                     break;
                 case character.AsciiCodePoint.OPEN_ANGLE: {
-                    const delimiter = this.tryToEatDelimiter(nodePoints, i, endIndex);
+                    const delimiter = tryToEatDelimiter(nodePoints, i, endIndex);
                     if (delimiter != null)
                         return delimiter;
                     break;
@@ -235,44 +229,68 @@ class HtmlInlineTokenizer extends coreTokenizer.BaseInlineTokenizer {
         }
         return null;
     }
-    processSingleDelimiter(delimiter) {
+    function processSingleDelimiter(delimiter) {
         const token = Object.assign(Object.assign({}, delimiter), { nodeType: ast.HtmlType });
         return [token];
     }
-    processToken(token, children, nodePoints) {
-        const { startIndex, endIndex } = token;
-        const value = character.calcStringFromNodePoints(nodePoints, startIndex, endIndex);
-        const result = { type: ast.HtmlType, value };
-        return result;
-    }
-    tryToEatDelimiter(nodePoints, startIndex, endIndex) {
-        let delimiter = null;
-        delimiter = eatHtmlInlineTokenOpenDelimiter(nodePoints, startIndex, endIndex);
-        if (delimiter != null)
-            return delimiter;
-        delimiter = eatHtmlInlineClosingDelimiter(nodePoints, startIndex, endIndex);
-        if (delimiter != null)
-            return delimiter;
-        delimiter = eatHtmlInlineCommentDelimiter(nodePoints, startIndex, endIndex);
-        if (delimiter != null)
-            return delimiter;
-        delimiter = eatHtmlInlineInstructionDelimiter(nodePoints, startIndex, endIndex);
-        if (delimiter != null)
-            return delimiter;
-        delimiter = eatHtmlInlineDeclarationDelimiter(nodePoints, startIndex, endIndex);
-        if (delimiter != null)
-            return delimiter;
-        delimiter = eatHtmlInlineCDataDelimiter(nodePoints, startIndex, endIndex);
+};
+function tryToEatDelimiter(nodePoints, startIndex, endIndex) {
+    let delimiter = null;
+    delimiter = eatHtmlInlineTokenOpenDelimiter(nodePoints, startIndex, endIndex);
+    if (delimiter != null)
         return delimiter;
+    delimiter = eatHtmlInlineClosingDelimiter(nodePoints, startIndex, endIndex);
+    if (delimiter != null)
+        return delimiter;
+    delimiter = eatHtmlInlineCommentDelimiter(nodePoints, startIndex, endIndex);
+    if (delimiter != null)
+        return delimiter;
+    delimiter = eatHtmlInlineInstructionDelimiter(nodePoints, startIndex, endIndex);
+    if (delimiter != null)
+        return delimiter;
+    delimiter = eatHtmlInlineDeclarationDelimiter(nodePoints, startIndex, endIndex);
+    if (delimiter != null)
+        return delimiter;
+    delimiter = eatHtmlInlineCDataDelimiter(nodePoints, startIndex, endIndex);
+    return delimiter;
+}
+
+const parse = function (api) {
+    return {
+        parse: tokens => tokens.map(token => {
+            const { startIndex, endIndex } = token;
+            const nodePoints = api.getNodePoints();
+            const value = character.calcStringFromNodePoints(nodePoints, startIndex, endIndex);
+            const node = api.shouldReservePosition
+                ? { type: ast.HtmlType, position: api.calcPosition(token), value }
+                : { type: ast.HtmlType, value };
+            return node;
+        }),
+    };
+};
+
+const uniqueName = '@yozora/tokenizer-html-inline';
+
+class HtmlInlineTokenizer extends coreTokenizer.BaseInlineTokenizer {
+    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.HtmlInlineTokenizer = HtmlInlineTokenizer;
 exports.HtmlInlineTokenizerName = uniqueName;
-exports['default'] = HtmlInlineTokenizer;
+exports["default"] = HtmlInlineTokenizer;
 exports.eatHtmlInlineCDataDelimiter = eatHtmlInlineCDataDelimiter;
 exports.eatHtmlInlineClosingDelimiter = eatHtmlInlineClosingDelimiter;
 exports.eatHtmlInlineCommentDelimiter = eatHtmlInlineCommentDelimiter;
 exports.eatHtmlInlineDeclarationDelimiter = eatHtmlInlineDeclarationDelimiter;
 exports.eatHtmlInlineInstructionDelimiter = eatHtmlInlineInstructionDelimiter;
 exports.eatHtmlInlineTokenOpenDelimiter = eatHtmlInlineTokenOpenDelimiter;
+exports.htmlInlineMatch = match;
+exports.htmlInlineParse = parse;

package/lib/esm/index.js

@@ -1,9 +1,7 @@
-import { HtmlType } from '@yozora/ast';
 import { AsciiCodePoint, isAsciiUpperLetter, isWhitespaceCharacter, calcStringFromNodePoints } from '@yozora/character';
-import { eatOptionalWhitespaces, BaseInlineTokenizer, TokenizerPriority } from '@yozora/core-tokenizer';
+import { eatOptionalWhitespaces, genFindDelimiter, BaseInlineTokenizer, TokenizerPriority } from '@yozora/core-tokenizer';
 import { eatHTMLTagName, eatHTMLAttribute } from '@yozora/tokenizer-html-block';
-
-const uniqueName = '@yozora/tokenizer-html-inline';
+import { HtmlType } from '@yozora/ast';
 
 function eatHtmlInlineCDataDelimiter(nodePoints, startIndex, endIndex) {
     let i = startIndex;
@@ -104,8 +102,7 @@ function eatHtmlInlineCommentDelimiter(nodePoints, startIndex, endIndex) {
 
 function eatHtmlInlineDeclarationDelimiter(nodePoints, startIndex, endIndex) {
     let i = startIndex;
-    if (i + 4 >= endIndex ||
-        nodePoints[i + 1].codePoint !== AsciiCodePoint.EXCLAMATION_MARK)
+    if (i + 4 >= endIndex || nodePoints[i + 1].codePoint !== AsciiCodePoint.EXCLAMATION_MARK)
         return null;
     const tagNameStartIndex = i + 2;
     for (i = tagNameStartIndex; i < endIndex; ++i) {
@@ -139,8 +136,7 @@ function eatHtmlInlineDeclarationDelimiter(nodePoints, startIndex, endIndex) {
 
 function eatHtmlInlineInstructionDelimiter(nodePoints, startIndex, endIndex) {
     let i = startIndex;
-    if (i + 3 >= endIndex ||
-        nodePoints[i + 1].codePoint !== AsciiCodePoint.QUESTION_MARK)
+    if (i + 3 >= endIndex || nodePoints[i + 1].codePoint !== AsciiCodePoint.QUESTION_MARK)
         return null;
     const si = i + 2;
     for (i = si; i < endIndex; ++i) {
@@ -203,15 +199,13 @@ function eatHtmlInlineTokenOpenDelimiter(nodePoints, startIndex, endIndex) {
     return delimiter;
 }
 
-class HtmlInlineTokenizer extends BaseInlineTokenizer {
-    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,
-        });
-    }
-    _findDelimiter(startIndex, endIndex, nodePoints) {
+const match = function (api) {
+    return {
+        findDelimiter: () => genFindDelimiter(_findDelimiter),
+        processSingleDelimiter,
+    };
+    function _findDelimiter(startIndex, endIndex) {
+        const nodePoints = api.getNodePoints();
         for (let i = startIndex; i < endIndex; ++i) {
             i = eatOptionalWhitespaces(nodePoints, i, endIndex);
             if (i >= endIndex)
@@ -222,7 +216,7 @@ class HtmlInlineTokenizer extends BaseInlineTokenizer {
                     i += 1;
                     break;
                 case AsciiCodePoint.OPEN_ANGLE: {
-                    const delimiter = this.tryToEatDelimiter(nodePoints, i, endIndex);
+                    const delimiter = tryToEatDelimiter(nodePoints, i, endIndex);
                     if (delimiter != null)
                         return delimiter;
                     break;
@@ -231,36 +225,58 @@ class HtmlInlineTokenizer extends BaseInlineTokenizer {
         }
         return null;
     }
-    processSingleDelimiter(delimiter) {
+    function processSingleDelimiter(delimiter) {
         const token = Object.assign(Object.assign({}, delimiter), { nodeType: HtmlType });
         return [token];
     }
-    processToken(token, children, nodePoints) {
-        const { startIndex, endIndex } = token;
-        const value = calcStringFromNodePoints(nodePoints, startIndex, endIndex);
-        const result = { type: HtmlType, value };
-        return result;
-    }
-    tryToEatDelimiter(nodePoints, startIndex, endIndex) {
-        let delimiter = null;
-        delimiter = eatHtmlInlineTokenOpenDelimiter(nodePoints, startIndex, endIndex);
-        if (delimiter != null)
-            return delimiter;
-        delimiter = eatHtmlInlineClosingDelimiter(nodePoints, startIndex, endIndex);
-        if (delimiter != null)
-            return delimiter;
-        delimiter = eatHtmlInlineCommentDelimiter(nodePoints, startIndex, endIndex);
-        if (delimiter != null)
-            return delimiter;
-        delimiter = eatHtmlInlineInstructionDelimiter(nodePoints, startIndex, endIndex);
-        if (delimiter != null)
-            return delimiter;
-        delimiter = eatHtmlInlineDeclarationDelimiter(nodePoints, startIndex, endIndex);
-        if (delimiter != null)
-            return delimiter;
-        delimiter = eatHtmlInlineCDataDelimiter(nodePoints, startIndex, endIndex);
+};
+function tryToEatDelimiter(nodePoints, startIndex, endIndex) {
+    let delimiter = null;
+    delimiter = eatHtmlInlineTokenOpenDelimiter(nodePoints, startIndex, endIndex);
+    if (delimiter != null)
         return delimiter;
+    delimiter = eatHtmlInlineClosingDelimiter(nodePoints, startIndex, endIndex);
+    if (delimiter != null)
+        return delimiter;
+    delimiter = eatHtmlInlineCommentDelimiter(nodePoints, startIndex, endIndex);
+    if (delimiter != null)
+        return delimiter;
+    delimiter = eatHtmlInlineInstructionDelimiter(nodePoints, startIndex, endIndex);
+    if (delimiter != null)
+        return delimiter;
+    delimiter = eatHtmlInlineDeclarationDelimiter(nodePoints, startIndex, endIndex);
+    if (delimiter != null)
+        return delimiter;
+    delimiter = eatHtmlInlineCDataDelimiter(nodePoints, startIndex, endIndex);
+    return delimiter;
+}
+
+const parse = function (api) {
+    return {
+        parse: tokens => tokens.map(token => {
+            const { startIndex, endIndex } = token;
+            const nodePoints = api.getNodePoints();
+            const value = calcStringFromNodePoints(nodePoints, startIndex, endIndex);
+            const node = api.shouldReservePosition
+                ? { type: HtmlType, position: api.calcPosition(token), value }
+                : { type: HtmlType, value };
+            return node;
+        }),
+    };
+};
+
+const uniqueName = '@yozora/tokenizer-html-inline';
+
+class HtmlInlineTokenizer extends BaseInlineTokenizer {
+    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 { HtmlInlineTokenizer, uniqueName as HtmlInlineTokenizerName, HtmlInlineTokenizer as default, eatHtmlInlineCDataDelimiter, eatHtmlInlineClosingDelimiter, eatHtmlInlineCommentDelimiter, eatHtmlInlineDeclarationDelimiter, eatHtmlInlineInstructionDelimiter, eatHtmlInlineTokenOpenDelimiter };
+export { HtmlInlineTokenizer, uniqueName as HtmlInlineTokenizerName, HtmlInlineTokenizer as default, eatHtmlInlineCDataDelimiter, eatHtmlInlineClosingDelimiter, eatHtmlInlineCommentDelimiter, eatHtmlInlineDeclarationDelimiter, eatHtmlInlineInstructionDelimiter, eatHtmlInlineTokenOpenDelimiter, match as htmlInlineMatch, parse as htmlInlineParse };

package/lib/types/index.d.ts

@@ -1,11 +1,11 @@
-import { HtmlInlineTokenizer } from './tokenizer';
 export * from './util/cdata';
 export * from './util/closing';
 export * from './util/comment';
 export * from './util/declaration';
 export * from './util/instruction';
 export * from './util/open';
-export { HtmlInlineTokenizer } from './tokenizer';
+export { match as htmlInlineMatch } from './match';
+export { parse as htmlInlineParse } from './parse';
+export { HtmlInlineTokenizer, HtmlInlineTokenizer as default } from './tokenizer';
 export { uniqueName as HtmlInlineTokenizerName } from './types';
-export type { Token as HtmlInlineToken, TokenizerProps as HtmlInlineTokenizerProps, } from './types';
-export default HtmlInlineTokenizer;
+export type { IThis as IHtmlInlineHookContext, IToken as IHtmlInlineToken, ITokenizerProps as IHtmlInlineTokenizerProps, } from './types';

package/lib/types/match.d.ts

@@ -0,0 +1,11 @@
+import type { IMatchInlineHookCreator } from '@yozora/core-tokenizer';
+import type { IDelimiter, IThis, IToken, T } from './types';
+/**
+ * Text between '<' and '>' that looks like an HTML tag is parsed as a raw HTML
+ * tag and will be rendered in HTML without escaping. Tag and attribute names
+ * are not limited to current HTML tags, so custom tags (and even, say, DocBook
+ * tags) may be used.
+ *
+ * @see https://github.github.com/gfm/#raw-html
+ */
+export declare const match: IMatchInlineHookCreator<T, IDelimiter, IToken, IThis>;

package/lib/types/parse.d.ts

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

package/lib/types/tokenizer.d.ts

@@ -1,8 +1,6 @@
-import type { YastNode } from '@yozora/ast';
-import type { NodePoint } from '@yozora/character';
-import type { ResultOfProcessSingleDelimiter, Tokenizer, TokenizerMatchInlineHook, TokenizerParseInlineHook } from '@yozora/core-tokenizer';
+import type { IInlineTokenizer, IMatchInlineHookCreator, IParseInlineHookCreator } from '@yozora/core-tokenizer';
 import { BaseInlineTokenizer } from '@yozora/core-tokenizer';
-import type { Delimiter, Node, T, Token, TokenizerProps } from './types';
+import type { IDelimiter, INode, IThis, IToken, ITokenizerProps, T } from './types';
 /**
  * Lexical Analyzer for HtmlInline.
  *
@@ -13,29 +11,8 @@ import type { Delimiter, Node, T, Token, TokenizerProps } from './types';
  *
  * @see https://github.github.com/gfm/#raw-html
  */
-export declare class HtmlInlineTokenizer extends BaseInlineTokenizer<Delimiter> implements Tokenizer, TokenizerMatchInlineHook<T, Delimiter, Token>, TokenizerParseInlineHook<T, Token, Node> {
-    constructor(props?: TokenizerProps);
-    /**
-     * @override
-     * @see BaseInlineTokenizer
-     */
-    protected _findDelimiter(startIndex: number, endIndex: number, nodePoints: ReadonlyArray<NodePoint>): Delimiter | null;
-    /**
-     * @override
-     * @see TokenizerMatchInlineHook
-     */
-    processSingleDelimiter(delimiter: Delimiter): ResultOfProcessSingleDelimiter<T, Token>;
-    /**
-     * @override
-     * @see TokenizerParseInlineHook
-     */
-    processToken(token: Token, children: YastNode[] | undefined, nodePoints: ReadonlyArray<NodePoint>): Node;
-    /**
-     * Try to eat a delimiter
-     *
-     * @param nodePoints
-     * @param startIndex
-     * @param endIndex
-     */
-    protected tryToEatDelimiter(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): Delimiter | null;
+export declare class HtmlInlineTokenizer extends BaseInlineTokenizer<T, IDelimiter, IToken, INode, IThis> implements IInlineTokenizer<T, IDelimiter, IToken, INode, IThis> {
+    constructor(props?: ITokenizerProps);
+    readonly match: IMatchInlineHookCreator<T, IDelimiter, IToken, IThis>;
+    readonly parse: IParseInlineHookCreator<T, IToken, INode, IThis>;
 }

package/lib/types/types.d.ts

@@ -1,13 +1,13 @@
-import type { Html, HtmlType } from '@yozora/ast';
-import type { BaseInlineTokenizerProps, PartialYastInlineToken } from '@yozora/core-tokenizer';
-import type { HtmlInlineCDataDelimiter, HtmlInlineCDataTokenData } from './util/cdata';
-import type { HtmlInlineClosingDelimiter, HtmlInlineClosingTokenData } from './util/closing';
-import type { HtmlInlineCommentDelimiter, HtmlInlineCommentTokenData } from './util/comment';
-import type { HtmlInlineDeclarationDelimiter, HtmlInlineDeclarationTokenData } from './util/declaration';
-import type { HtmlInlineInstructionDelimiter, HtmlInlineInstructionTokenData } from './util/instruction';
-import type { HtmlInlineOpenDelimiter, HtmlInlineOpenTokenData as HtmlInlineOpenTokenData } from './util/open';
+import type { HtmlType, IHtml } from '@yozora/ast';
+import type { IBaseInlineTokenizerProps, IPartialYastInlineToken, ITokenizer } from '@yozora/core-tokenizer';
+import type { IHtmlInlineCDataDelimiter, IHtmlInlineCDataTokenData } from './util/cdata';
+import type { IHtmlInlineClosingDelimiter, IHtmlInlineClosingTokenData } from './util/closing';
+import type { IHtmlInlineCommentDelimiter, IHtmlInlineCommentTokenData } from './util/comment';
+import type { IHtmlInlineDeclarationDelimiter, IHtmlInlineDeclarationTokenData } from './util/declaration';
+import type { IHtmlInlineInstructionDelimiter, IHtmlInlineInstructionTokenData } from './util/instruction';
+import type { IHtmlInlineOpenDelimiter, IHtmlInlineOpenTokenData as IHtmlInlineOpenTokenData } from './util/open';
 export declare type T = HtmlType;
-export declare type Node = Html;
+export declare type INode = IHtml;
 export declare const uniqueName = "@yozora/tokenizer-html-inline";
 /**
  * Text between '<' and '>' that looks like an HTML tag is parsed as a raw
@@ -17,6 +17,7 @@ export declare const uniqueName = "@yozora/tokenizer-html-inline";
  *
  * @see https://github.github.com/gfm/#raw-html
  */
-export declare type Token = PartialYastInlineToken<T> & (HtmlInlineOpenTokenData | HtmlInlineClosingTokenData | HtmlInlineCommentTokenData | HtmlInlineInstructionTokenData | HtmlInlineDeclarationTokenData | HtmlInlineCDataTokenData);
-export declare type Delimiter = HtmlInlineOpenDelimiter | HtmlInlineClosingDelimiter | HtmlInlineCommentDelimiter | HtmlInlineInstructionDelimiter | HtmlInlineDeclarationDelimiter | HtmlInlineCDataDelimiter;
-export declare type TokenizerProps = Partial<BaseInlineTokenizerProps>;
+export declare type IToken = IPartialYastInlineToken<T> & (IHtmlInlineOpenTokenData | IHtmlInlineClosingTokenData | IHtmlInlineCommentTokenData | IHtmlInlineInstructionTokenData | IHtmlInlineDeclarationTokenData | IHtmlInlineCDataTokenData);
+export declare type IDelimiter = IHtmlInlineOpenDelimiter | IHtmlInlineClosingDelimiter | IHtmlInlineCommentDelimiter | IHtmlInlineInstructionDelimiter | IHtmlInlineDeclarationDelimiter | IHtmlInlineCDataDelimiter;
+export declare type IThis = ITokenizer;
+export declare type ITokenizerProps = Partial<IBaseInlineTokenizerProps>;

package/lib/types/util/cdata.d.ts

@@ -1,12 +1,12 @@
-import type { NodePoint } from '@yozora/character';
-import type { YastTokenDelimiter } from '@yozora/core-tokenizer';
-export interface HtmlInlineCDataData {
+import type { INodePoint } from '@yozora/character';
+import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
+export interface IHtmlInlineCDataData {
     htmlType: 'cdata';
 }
-export interface HtmlInlineCDataTokenData {
+export interface IHtmlInlineCDataTokenData {
     htmlType: 'cdata';
 }
-export interface HtmlInlineCDataDelimiter extends YastTokenDelimiter, HtmlInlineCDataTokenData {
+export interface IHtmlInlineCDataDelimiter extends IYastTokenDelimiter, IHtmlInlineCDataTokenData {
     type: 'full';
 }
 /**
@@ -18,4 +18,4 @@ export interface HtmlInlineCDataDelimiter extends YastTokenDelimiter, HtmlInline
  * @param endIndex
  * @see https://github.github.com/gfm/#cdata-section
  */
-export declare function eatHtmlInlineCDataDelimiter(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): HtmlInlineCDataDelimiter | null;
+export declare function eatHtmlInlineCDataDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineCDataDelimiter | null;

package/lib/types/util/closing.d.ts

@@ -1,14 +1,14 @@
-import type { NodeInterval, NodePoint } from '@yozora/character';
-import type { YastTokenDelimiter } from '@yozora/core-tokenizer';
-export interface HtmlInlineClosingTagData {
+import type { INodeInterval, INodePoint } from '@yozora/character';
+import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
+export interface IHtmlInlineClosingTagData {
     htmlType: 'closing';
     tagName: string;
 }
-export interface HtmlInlineClosingTokenData {
+export interface IHtmlInlineClosingTokenData {
     htmlType: 'closing';
-    tagName: NodeInterval;
+    tagName: INodeInterval;
 }
-export interface HtmlInlineClosingDelimiter extends YastTokenDelimiter, HtmlInlineClosingTokenData {
+export interface IHtmlInlineClosingDelimiter extends IYastTokenDelimiter, IHtmlInlineClosingTokenData {
     type: 'full';
 }
 /**
@@ -20,4 +20,4 @@ export interface HtmlInlineClosingDelimiter extends YastTokenDelimiter, HtmlInli
  * @param endIndex
  * @see https://github.github.com/gfm/#closing-tag
  */
-export declare function eatHtmlInlineClosingDelimiter(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): HtmlInlineClosingDelimiter | null;
+export declare function eatHtmlInlineClosingDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineClosingDelimiter | null;

package/lib/types/util/comment.d.ts

@@ -1,12 +1,12 @@
-import type { NodePoint } from '@yozora/character';
-import type { YastTokenDelimiter } from '@yozora/core-tokenizer';
-export interface HtmlInlineCommentData {
+import type { INodePoint } from '@yozora/character';
+import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
+export interface IHtmlInlineCommentData {
     htmlType: 'comment';
 }
-export interface HtmlInlineCommentTokenData {
+export interface IHtmlInlineCommentTokenData {
     htmlType: 'comment';
 }
-export interface HtmlInlineCommentDelimiter extends YastTokenDelimiter, HtmlInlineCommentTokenData {
+export interface IHtmlInlineCommentDelimiter extends IYastTokenDelimiter, IHtmlInlineCommentTokenData {
     type: 'full';
 }
 /**
@@ -18,4 +18,4 @@ export interface HtmlInlineCommentDelimiter extends YastTokenDelimiter, HtmlInli
  * @param endIndex
  * @see https://github.github.com/gfm/#html-comment
  */
-export declare function eatHtmlInlineCommentDelimiter(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): HtmlInlineCommentDelimiter | null;
+export declare function eatHtmlInlineCommentDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineCommentDelimiter | null;

package/lib/types/util/declaration.d.ts

@@ -1,13 +1,13 @@
-import type { NodeInterval, NodePoint } from '@yozora/character';
-import type { YastTokenDelimiter } from '@yozora/core-tokenizer';
-export interface HtmlInlineDeclarationData {
+import type { INodeInterval, INodePoint } from '@yozora/character';
+import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
+export interface IHtmlInlineDeclarationData {
     htmlType: 'declaration';
 }
-export interface HtmlInlineDeclarationTokenData {
+export interface IHtmlInlineDeclarationTokenData {
     htmlType: 'declaration';
-    tagName: NodeInterval;
+    tagName: INodeInterval;
 }
-export interface HtmlInlineDeclarationDelimiter extends YastTokenDelimiter, HtmlInlineDeclarationTokenData {
+export interface IHtmlInlineDeclarationDelimiter extends IYastTokenDelimiter, IHtmlInlineDeclarationTokenData {
     type: 'full';
 }
 /**
@@ -20,4 +20,4 @@ export interface HtmlInlineDeclarationDelimiter extends YastTokenDelimiter, Html
  * @param endIndex
  * @see https://github.github.com/gfm/#declaration
  */
-export declare function eatHtmlInlineDeclarationDelimiter(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): HtmlInlineDeclarationDelimiter | null;
+export declare function eatHtmlInlineDeclarationDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineDeclarationDelimiter | null;

package/lib/types/util/instruction.d.ts

@@ -1,16 +1,16 @@
-import type { NodePoint } from '@yozora/character';
-import type { YastTokenDelimiter } from '@yozora/core-tokenizer';
+import type { INodePoint } from '@yozora/character';
+import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
 /**
  *
  * @see https://github.github.com/gfm/#processing-instruction
  */
-export interface HtmlInlineInstructionData {
+export interface IHtmlInlineInstructionData {
     htmlType: 'instruction';
 }
-export interface HtmlInlineInstructionTokenData {
+export interface IHtmlInlineInstructionTokenData {
     htmlType: 'instruction';
 }
-export interface HtmlInlineInstructionDelimiter extends YastTokenDelimiter, HtmlInlineInstructionTokenData {
+export interface IHtmlInlineInstructionDelimiter extends IYastTokenDelimiter, IHtmlInlineInstructionTokenData {
     type: 'full';
 }
 /**
@@ -22,4 +22,4 @@ export interface HtmlInlineInstructionDelimiter extends YastTokenDelimiter, Html
  * @param endIndex
  * @see https://github.github.com/gfm/#processing-instruction
  */
-export declare function eatHtmlInlineInstructionDelimiter(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): HtmlInlineInstructionDelimiter | null;
+export declare function eatHtmlInlineInstructionDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineInstructionDelimiter | null;

package/lib/types/util/open.d.ts

@@ -1,7 +1,7 @@
-import type { NodeInterval, NodePoint } from '@yozora/character';
-import type { YastTokenDelimiter } from '@yozora/core-tokenizer';
+import type { INodeInterval, INodePoint } from '@yozora/character';
+import type { IYastTokenDelimiter } from '@yozora/core-tokenizer';
 import type { RawHTMLAttribute } from '@yozora/tokenizer-html-block';
-export interface HtmlInlineOpenTagData {
+export interface IHtmlInlineOpenTagData {
     htmlType: 'open';
     /**
      * HTML tag name.
@@ -19,13 +19,13 @@ export interface HtmlInlineOpenTagData {
      */
     selfClosed: boolean;
 }
-export interface HtmlInlineOpenTokenData {
+export interface IHtmlInlineOpenTokenData {
     htmlType: 'open';
-    tagName: NodeInterval;
+    tagName: INodeInterval;
     attributes: RawHTMLAttribute[];
     selfClosed: boolean;
 }
-export interface HtmlInlineOpenDelimiter extends YastTokenDelimiter, HtmlInlineOpenTokenData {
+export interface IHtmlInlineOpenDelimiter extends IYastTokenDelimiter, IHtmlInlineOpenTokenData {
     type: 'full';
 }
 /**
@@ -37,4 +37,4 @@ export interface HtmlInlineOpenDelimiter extends YastTokenDelimiter, HtmlInlineO
  * @param endIndex
  * @see https://github.github.com/gfm/#open-tag
  */
-export declare function eatHtmlInlineTokenOpenDelimiter(nodePoints: ReadonlyArray<NodePoint>, startIndex: number, endIndex: number): HtmlInlineOpenDelimiter | null;
+export declare function eatHtmlInlineTokenOpenDelimiter(nodePoints: ReadonlyArray<INodePoint>, startIndex: number, endIndex: number): IHtmlInlineOpenDelimiter | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-html-inline",
-  "version": "1.2.2",
+  "version": "2.0.0-alpha.2",
   "author": {
     "name": "guanghechen",
     "url": "https://github.com/guanghechen/"
@@ -35,10 +35,10 @@
     "test": "cross-env TS_NODE_FILES=true jest --config ../../jest.config.js --rootDir ."
   },
   "dependencies": {
-    "@yozora/ast": "^1.2.2",
-    "@yozora/character": "^1.2.2",
-    "@yozora/core-tokenizer": "^1.2.2",
-    "@yozora/tokenizer-html-block": "^1.2.2"
+    "@yozora/ast": "^2.0.0-alpha.2",
+    "@yozora/character": "^2.0.0-alpha.2",
+    "@yozora/core-tokenizer": "^2.0.0-alpha.2",
+    "@yozora/tokenizer-html-block": "^2.0.0-alpha.2"
   },
-  "gitHead": "fb4b804548592c09259aabcf9cc4dd96176bd024"
+  "gitHead": "da59d85520455c59a117a35032ef1a035c10ea21"
 }