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

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,6 +203,8 @@ function eatHtmlInlineTokenOpenDelimiter(nodePoints, startIndex, endIndex) {
     return delimiter;
 }
 
+const uniqueName = '@yozora/tokenizer-html-inline';
+
 class HtmlInlineTokenizer extends coreTokenizer.BaseInlineTokenizer {
     constructor(props = {}) {
         var _a, _b;
@@ -214,64 +212,72 @@ class HtmlInlineTokenizer extends coreTokenizer.BaseInlineTokenizer {
             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, api) {
-        const nodePoints = api.getNodePoints();
-        for (let i = startIndex; i < endIndex; ++i) {
-            i = coreTokenizer.eatOptionalWhitespaces(nodePoints, i, endIndex);
-            if (i >= endIndex)
-                break;
-            const c = nodePoints[i].codePoint;
-            switch (c) {
-                case character.AsciiCodePoint.BACKSLASH:
-                    i += 1;
-                    break;
-                case character.AsciiCodePoint.OPEN_ANGLE: {
-                    const delimiter = this.tryToEatDelimiter(nodePoints, i, endIndex);
-                    if (delimiter != null)
-                        return delimiter;
-                    break;
+        this.match = 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)
+                        break;
+                    const c = nodePoints[i].codePoint;
+                    switch (c) {
+                        case character.AsciiCodePoint.BACKSLASH:
+                            i += 1;
+                            break;
+                        case character.AsciiCodePoint.OPEN_ANGLE: {
+                            const delimiter = tryToEatDelimiter(nodePoints, i, endIndex);
+                            if (delimiter != null)
+                                return delimiter;
+                            break;
+                        }
+                    }
                 }
+                return null;
             }
-        }
-        return null;
-    }
-    processSingleDelimiter(delimiter) {
-        const token = Object.assign(Object.assign({}, delimiter), { nodeType: ast.HtmlType });
-        return [token];
-    }
-    parseInline(token, children, api) {
-        const { startIndex, endIndex } = token;
-        const nodePoints = api.getNodePoints();
-        const value = character.calcStringFromNodePoints(nodePoints, startIndex, endIndex);
-        const result = { type: ast.HtmlType, value };
-        return result;
+            function processSingleDelimiter(delimiter) {
+                const token = Object.assign(Object.assign({}, delimiter), { nodeType: ast.HtmlType });
+                return [token];
+            }
+        };
+        this.parse = api => ({
+            parse: token => {
+                const { startIndex, endIndex } = token;
+                const nodePoints = api.getNodePoints();
+                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;
 }
 
 exports.HtmlInlineTokenizer = HtmlInlineTokenizer;
 exports.HtmlInlineTokenizerName = uniqueName;
-exports['default'] = HtmlInlineTokenizer;
+exports["default"] = HtmlInlineTokenizer;
 exports.eatHtmlInlineCDataDelimiter = eatHtmlInlineCDataDelimiter;
 exports.eatHtmlInlineClosingDelimiter = eatHtmlInlineClosingDelimiter;
 exports.eatHtmlInlineCommentDelimiter = eatHtmlInlineCommentDelimiter;

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, BaseInlineTokenizer, TokenizerPriority, genFindDelimiter } 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,6 +199,8 @@ function eatHtmlInlineTokenOpenDelimiter(nodePoints, startIndex, endIndex) {
     return delimiter;
 }
 
+const uniqueName = '@yozora/tokenizer-html-inline';
+
 class HtmlInlineTokenizer extends BaseInlineTokenizer {
     constructor(props = {}) {
         var _a, _b;
@@ -210,59 +208,67 @@ class HtmlInlineTokenizer extends BaseInlineTokenizer {
             name: (_a = props.name) !== null && _a !== void 0 ? _a : uniqueName,
             priority: (_b = props.priority) !== null && _b !== void 0 ? _b : TokenizerPriority.ATOMIC,
         });
-    }
-    _findDelimiter(startIndex, endIndex, api) {
-        const nodePoints = api.getNodePoints();
-        for (let i = startIndex; i < endIndex; ++i) {
-            i = eatOptionalWhitespaces(nodePoints, i, endIndex);
-            if (i >= endIndex)
-                break;
-            const c = nodePoints[i].codePoint;
-            switch (c) {
-                case AsciiCodePoint.BACKSLASH:
-                    i += 1;
-                    break;
-                case AsciiCodePoint.OPEN_ANGLE: {
-                    const delimiter = this.tryToEatDelimiter(nodePoints, i, endIndex);
-                    if (delimiter != null)
-                        return delimiter;
-                    break;
+        this.match = 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)
+                        break;
+                    const c = nodePoints[i].codePoint;
+                    switch (c) {
+                        case AsciiCodePoint.BACKSLASH:
+                            i += 1;
+                            break;
+                        case AsciiCodePoint.OPEN_ANGLE: {
+                            const delimiter = tryToEatDelimiter(nodePoints, i, endIndex);
+                            if (delimiter != null)
+                                return delimiter;
+                            break;
+                        }
+                    }
                 }
+                return null;
             }
-        }
-        return null;
-    }
-    processSingleDelimiter(delimiter) {
-        const token = Object.assign(Object.assign({}, delimiter), { nodeType: HtmlType });
-        return [token];
-    }
-    parseInline(token, children, api) {
-        const { startIndex, endIndex } = token;
-        const nodePoints = api.getNodePoints();
-        const value = calcStringFromNodePoints(nodePoints, startIndex, endIndex);
-        const result = { type: HtmlType, value };
-        return result;
+            function processSingleDelimiter(delimiter) {
+                const token = Object.assign(Object.assign({}, delimiter), { nodeType: HtmlType });
+                return [token];
+            }
+        };
+        this.parse = api => ({
+            parse: token => {
+                const { startIndex, endIndex } = token;
+                const nodePoints = api.getNodePoints();
+                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;
 }
 
 export { HtmlInlineTokenizer, uniqueName as HtmlInlineTokenizerName, HtmlInlineTokenizer as default, eatHtmlInlineCDataDelimiter, eatHtmlInlineClosingDelimiter, eatHtmlInlineCommentDelimiter, eatHtmlInlineDeclarationDelimiter, eatHtmlInlineInstructionDelimiter, eatHtmlInlineTokenOpenDelimiter };

package/lib/types/index.d.ts

@@ -1,11 +1,9 @@
-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 { 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 { IToken as IHtmlInlineToken, ITokenizerProps as IHtmlInlineTokenizerProps, } from './types';

package/lib/types/tokenizer.d.ts

@@ -1,8 +1,6 @@
-import type { YastNode } from '@yozora/ast';
-import type { NodePoint } from '@yozora/character';
-import type { MatchInlinePhaseApi, ParseInlinePhaseApi, 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, 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, api: Readonly<MatchInlinePhaseApi>): Delimiter | null;
-    /**
-     * @override
-     * @see TokenizerMatchInlineHook
-     */
-    processSingleDelimiter(delimiter: Delimiter): ResultOfProcessSingleDelimiter<T, Token>;
-    /**
-     * @override
-     * @see TokenizerParseInlineHook
-     */
-    parseInline(token: Token, children: YastNode[], api: Readonly<ParseInlinePhaseApi>): 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> implements IInlineTokenizer<T, IDelimiter, IToken, INode> {
+    constructor(props?: ITokenizerProps);
+    readonly match: IMatchInlineHookCreator<T, IDelimiter, IToken>;
+    readonly parse: IParseInlineHookCreator<T, IToken, INode>;
 }

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 } 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,6 @@ 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 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.3.0",
+  "version": "2.0.0-alpha.0",
   "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.3.0",
-    "@yozora/character": "^1.3.0",
-    "@yozora/core-tokenizer": "^1.3.0",
-    "@yozora/tokenizer-html-block": "^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",
+    "@yozora/tokenizer-html-block": "^2.0.0-alpha.0"
   },
-  "gitHead": "18c9b167004ad97718b2f94f25139f80598cbf7a"
+  "gitHead": "0171501339c49ffd02ed16a63447fa20a47a29a7"
 }