@yozora/tokenizer-definition 1.2.2 → 2.0.0-alpha.2

package/lib/esm/index.js

@@ -1,13 +1,11 @@
-import { DefinitionType } from '@yozora/ast';
 import { AsciiCodePoint, VirtualCodePoint, isWhitespaceCharacter, isAsciiControlCharacter, calcStringFromNodePoints, calcEscapedStringFromNodePoints } from '@yozora/character';
-import { eatOptionalWhitespaces, BaseBlockTokenizer, TokenizerPriority, calcEndYastNodePoint, resolveLabelToIdentifier, encodeLinkDestination, calcStartYastNodePoint } from '@yozora/core-tokenizer';
-
-const uniqueName = '@yozora/tokenizer-definition';
+import { eatOptionalWhitespaces, calcEndYastNodePoint, resolveLabelToIdentifier, calcStartYastNodePoint, encodeLinkDestination, BaseBlockTokenizer, TokenizerPriority } from '@yozora/core-tokenizer';
+import { DefinitionType } from '@yozora/ast';
 
-function eatAndCollectLinkDestination(nodePoints, startIndex, endIndex, token) {
+function eatAndCollectLinkDestination(nodePoints, startIndex, endIndex, state) {
     let i = startIndex;
-    if (token == null) {
-        token = {
+    if (state == null) {
+        state = {
             saturated: false,
             nodePoints: [],
             hasOpenAngleBracket: false,
@@ -16,79 +14,78 @@ function eatAndCollectLinkDestination(nodePoints, startIndex, endIndex, token) {
     }
     const firstNonWhitespaceIndex = eatOptionalWhitespaces(nodePoints, i, endIndex);
     if (firstNonWhitespaceIndex >= endIndex)
-        return { nextIndex: -1, token };
-    if (token.nodePoints.length <= 0) {
+        return { nextIndex: -1, state: state };
+    if (state.nodePoints.length <= 0) {
         i = firstNonWhitespaceIndex;
         const p = nodePoints[i];
         if (p.codePoint === AsciiCodePoint.OPEN_ANGLE) {
             i += 1;
-            token.hasOpenAngleBracket = true;
-            token.nodePoints.push(p);
+            state.hasOpenAngleBracket = true;
+            state.nodePoints.push(p);
         }
     }
-    if (token.hasOpenAngleBracket) {
+    if (state.hasOpenAngleBracket) {
         for (; i < endIndex; ++i) {
             const p = nodePoints[i];
             switch (p.codePoint) {
                 case AsciiCodePoint.BACKSLASH:
                     if (i + 1 < endIndex) {
-                        token.nodePoints.push(p);
-                        token.nodePoints.push(nodePoints[i + 1]);
+                        state.nodePoints.push(p);
+                        state.nodePoints.push(nodePoints[i + 1]);
                     }
                     i += 1;
                     break;
                 case AsciiCodePoint.OPEN_ANGLE:
                 case VirtualCodePoint.LINE_END:
-                    return { nextIndex: -1, token };
+                    return { nextIndex: -1, state: state };
                 case AsciiCodePoint.CLOSE_ANGLE:
-                    token.saturated = true;
-                    token.nodePoints.push(p);
-                    return { nextIndex: i + 1, token };
+                    state.saturated = true;
+                    state.nodePoints.push(p);
+                    return { nextIndex: i + 1, state: state };
                 default:
-                    token.nodePoints.push(p);
+                    state.nodePoints.push(p);
             }
         }
-        return { nextIndex: i, token };
+        return { nextIndex: i, state: state };
     }
     for (; i < endIndex; ++i) {
         const p = nodePoints[i];
         switch (p.codePoint) {
             case AsciiCodePoint.BACKSLASH:
                 if (i + 1 < endIndex) {
-                    token.nodePoints.push(p);
-                    token.nodePoints.push(nodePoints[i + 1]);
+                    state.nodePoints.push(p);
+                    state.nodePoints.push(nodePoints[i + 1]);
                 }
                 i += 1;
                 break;
             case AsciiCodePoint.OPEN_PARENTHESIS:
-                token.openParensCount += 1;
-                token.nodePoints.push(p);
+                state.openParensCount += 1;
+                state.nodePoints.push(p);
                 break;
             case AsciiCodePoint.CLOSE_PARENTHESIS:
-                token.openParensCount -= 1;
-                token.nodePoints.push(p);
-                if (token.openParensCount < 0) {
-                    return { nextIndex: i, token };
+                state.openParensCount -= 1;
+                state.nodePoints.push(p);
+                if (state.openParensCount < 0) {
+                    return { nextIndex: i, state: state };
                 }
                 break;
             default:
-                if (isWhitespaceCharacter(p.codePoint) ||
-                    isAsciiControlCharacter(p.codePoint)) {
-                    token.saturated = true;
-                    return { nextIndex: i, token };
+                if (isWhitespaceCharacter(p.codePoint) || isAsciiControlCharacter(p.codePoint)) {
+                    state.saturated = true;
+                    return { nextIndex: i, state: state };
                 }
-                token.nodePoints.push(p);
+                state.nodePoints.push(p);
                 break;
         }
     }
-    token.saturated = true;
-    return { nextIndex: i, token };
+    state.saturated = true;
+    return { nextIndex: i, state: state };
 }
 
-function eatAndCollectLinkLabel(nodePoints, startIndex, endIndex, token) {
+function eatAndCollectLinkLabel(nodePoints, startIndex, endIndex, state) {
     let i = startIndex;
-    if (token == null) {
-        token = {
+    if (state == null) {
+        state = {
             saturated: false,
             nodePoints: [],
             hasNonWhitespaceCharacter: false,
@@ -96,50 +93,50 @@ function eatAndCollectLinkLabel(nodePoints, startIndex, endIndex, token) {
     }
     const firstNonWhitespaceIndex = eatOptionalWhitespaces(nodePoints, i, endIndex);
     if (firstNonWhitespaceIndex >= endIndex)
-        return { nextIndex: -1, token };
-    if (token.nodePoints.length <= 0) {
+        return { nextIndex: -1, state: state };
+    if (state.nodePoints.length <= 0) {
         i = firstNonWhitespaceIndex;
         const p = nodePoints[i];
         if (p.codePoint !== AsciiCodePoint.OPEN_BRACKET) {
-            return { nextIndex: -1, token };
+            return { nextIndex: -1, state: state };
         }
         i += 1;
-        token.nodePoints.push(p);
+        state.nodePoints.push(p);
     }
     for (; i < endIndex; ++i) {
         const p = nodePoints[i];
         switch (p.codePoint) {
             case AsciiCodePoint.BACKSLASH:
-                token.hasNonWhitespaceCharacter = true;
+                state.hasNonWhitespaceCharacter = true;
                 if (i + 1 < endIndex) {
-                    token.nodePoints.push(p);
-                    token.nodePoints.push(nodePoints[i + 1]);
+                    state.nodePoints.push(p);
+                    state.nodePoints.push(nodePoints[i + 1]);
                 }
                 i += 1;
                 break;
             case AsciiCodePoint.OPEN_BRACKET:
-                return { nextIndex: -1, token };
+                return { nextIndex: -1, state: state };
             case AsciiCodePoint.CLOSE_BRACKET:
-                token.nodePoints.push(p);
-                if (token.hasNonWhitespaceCharacter) {
-                    token.saturated = true;
-                    return { nextIndex: i + 1, token };
+                state.nodePoints.push(p);
+                if (state.hasNonWhitespaceCharacter) {
+                    state.saturated = true;
+                    return { nextIndex: i + 1, state: state };
                 }
-                return { nextIndex: -1, token };
+                return { nextIndex: -1, state: state };
             default:
                 if (!isWhitespaceCharacter(p.codePoint)) {
-                    token.hasNonWhitespaceCharacter = true;
+                    state.hasNonWhitespaceCharacter = true;
                 }
-                token.nodePoints.push(p);
+                state.nodePoints.push(p);
         }
     }
-    return { nextIndex: 1, token };
+    return { nextIndex: 1, state: state };
 }
 
-function eatAndCollectLinkTitle(nodePoints, startIndex, endIndex, token) {
+function eatAndCollectLinkTitle(nodePoints, startIndex, endIndex, state) {
     let i = startIndex;
-    if (token == null) {
-        token = {
+    if (state == null) {
+        state = {
             saturated: false,
             nodePoints: [],
             wrapSymbol: null,
@@ -147,25 +144,25 @@ function eatAndCollectLinkTitle(nodePoints, startIndex, endIndex, token) {
     }
     const firstNonWhitespaceIndex = eatOptionalWhitespaces(nodePoints, i, endIndex);
     if (firstNonWhitespaceIndex >= endIndex)
-        return { nextIndex: -1, token };
-    if (token.nodePoints.length <= 0) {
+        return { nextIndex: -1, state: state };
+    if (state.nodePoints.length <= 0) {
         i = firstNonWhitespaceIndex;
         const p = nodePoints[i];
         switch (p.codePoint) {
             case AsciiCodePoint.DOUBLE_QUOTE:
             case AsciiCodePoint.SINGLE_QUOTE:
             case AsciiCodePoint.OPEN_PARENTHESIS:
-                token.wrapSymbol = p.codePoint;
-                token.nodePoints.push(p);
+                state.wrapSymbol = p.codePoint;
+                state.nodePoints.push(p);
                 i += 1;
                 break;
             default:
-                return { nextIndex: -1, token };
+                return { nextIndex: -1, state: state };
         }
     }
-    if (token.wrapSymbol == null)
-        return { nextIndex: -1, token };
-    switch (token.wrapSymbol) {
+    if (state.wrapSymbol == null)
+        return { nextIndex: -1, state: state };
+    switch (state.wrapSymbol) {
         case AsciiCodePoint.DOUBLE_QUOTE:
         case AsciiCodePoint.SINGLE_QUOTE: {
             for (; i < endIndex; ++i) {
@@ -173,17 +170,17 @@ function eatAndCollectLinkTitle(nodePoints, startIndex, endIndex, token) {
                 switch (p.codePoint) {
                     case AsciiCodePoint.BACKSLASH:
                         if (i + 1 < endIndex) {
-                            token.nodePoints.push(p);
-                            token.nodePoints.push(nodePoints[i + 1]);
+                            state.nodePoints.push(p);
+                            state.nodePoints.push(nodePoints[i + 1]);
                         }
                         i += 1;
                         break;
-                    case token.wrapSymbol:
-                        token.saturated = true;
-                        token.nodePoints.push(p);
-                        return { nextIndex: i + 1, token };
+                    case state.wrapSymbol:
+                        state.saturated = true;
+                        state.nodePoints.push(p);
+                        return { nextIndex: i + 1, state: state };
                     default:
-                        token.nodePoints.push(p);
+                        state.nodePoints.push(p);
                 }
             }
             break;
@@ -194,49 +191,46 @@ function eatAndCollectLinkTitle(nodePoints, startIndex, endIndex, token) {
                 switch (p.codePoint) {
                     case AsciiCodePoint.BACKSLASH:
                         if (i + 1 < endIndex) {
-                            token.nodePoints.push(p);
-                            token.nodePoints.push(nodePoints[i + 1]);
+                            state.nodePoints.push(p);
+                            state.nodePoints.push(nodePoints[i + 1]);
                         }
                         i += 1;
                         break;
                     case AsciiCodePoint.OPEN_PARENTHESIS:
-                        return { nextIndex: -1, token };
+                        return { nextIndex: -1, state: state };
                     case AsciiCodePoint.CLOSE_PARENTHESIS:
-                        if (i + 1 >= endIndex ||
-                            nodePoints[i + 1].codePoint === VirtualCodePoint.LINE_END) {
-                            token.nodePoints.push(p);
-                            token.saturated = true;
+                        if (i + 1 >= endIndex || nodePoints[i + 1].codePoint === VirtualCodePoint.LINE_END) {
+                            state.nodePoints.push(p);
+                            state.saturated = true;
                             break;
                         }
-                        return { nextIndex: -1, token };
+                        return { nextIndex: -1, state: state };
                     default:
-                        token.nodePoints.push(p);
+                        state.nodePoints.push(p);
                 }
             }
             break;
         }
     }
-    return { nextIndex: endIndex, token };
+    return { nextIndex: endIndex, state: state };
 }
 
-class DefinitionTokenizer 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 (api) {
+    return {
+        isContainingBlock: false,
+        eatOpener,
+        eatContinuationText,
+        onClose,
+    };
+    function eatOpener(line) {
         if (line.countOfPrecedeSpaces >= 4)
             return null;
         const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex } = line;
         if (firstNonWhitespaceIndex >= endIndex)
             return null;
         let i = firstNonWhitespaceIndex;
-        const linkLabelCollectResult = eatAndCollectLinkLabel(nodePoints, i, endIndex, null);
-        if (linkLabelCollectResult.nextIndex < 0)
+        const { nextIndex: labelEndIndex, state: labelState } = eatAndCollectLinkLabel(nodePoints, i, endIndex, null);
+        if (labelEndIndex < 0)
             return null;
         const lineNo = nodePoints[startIndex].line;
         const createInitState = () => {
@@ -246,7 +240,7 @@ class DefinitionTokenizer extends BaseBlockTokenizer {
                     start: calcStartYastNodePoint(nodePoints, startIndex),
                     end: calcEndYastNodePoint(nodePoints, endIndex - 1),
                 },
-                label: linkLabelCollectResult.token,
+                label: labelState,
                 destination: null,
                 title: null,
                 lineNoOfLabel: lineNo,
@@ -256,11 +250,10 @@ class DefinitionTokenizer extends BaseBlockTokenizer {
             };
             return token;
         };
-        if (!linkLabelCollectResult.token.saturated) {
+        if (!labelState.saturated) {
             const token = createInitState();
             return { token, nextIndex: endIndex };
         }
-        const labelEndIndex = linkLabelCollectResult.nextIndex;
         if (labelEndIndex < 0 ||
             labelEndIndex + 1 >= endIndex ||
             nodePoints[labelEndIndex].codePoint !== AsciiCodePoint.COLON)
@@ -270,39 +263,36 @@ class DefinitionTokenizer extends BaseBlockTokenizer {
             const token = createInitState();
             return { token, nextIndex: endIndex };
         }
-        const linkDestinationCollectResult = eatAndCollectLinkDestination(nodePoints, i, endIndex, null);
-        if (linkDestinationCollectResult.nextIndex < 0)
+        const { nextIndex: destinationEndIndex, state: destinationState } = eatAndCollectLinkDestination(nodePoints, i, endIndex, null);
+        if (destinationEndIndex < 0)
             return null;
-        if (!linkDestinationCollectResult.token.saturated &&
-            linkDestinationCollectResult.nextIndex !== endIndex)
+        if (!destinationState.saturated && destinationEndIndex !== endIndex)
             return null;
-        const destinationEndIndex = linkDestinationCollectResult.nextIndex;
         i = eatOptionalWhitespaces(nodePoints, destinationEndIndex, endIndex);
         if (i >= endIndex) {
             const token = createInitState();
-            token.destination = linkDestinationCollectResult.token;
+            token.destination = destinationState;
             token.lineNoOfDestination = lineNo;
             return { token, nextIndex: endIndex };
         }
         if (i === destinationEndIndex)
             return null;
-        const linkTitleCollectResult = eatAndCollectLinkTitle(nodePoints, i, endIndex, null);
-        if (linkTitleCollectResult.nextIndex >= 0) {
-            i = linkTitleCollectResult.nextIndex;
-        }
+        const { nextIndex: titleEndIndex, state: titleState } = eatAndCollectLinkTitle(nodePoints, i, endIndex, null);
+        if (titleEndIndex >= 0)
+            i = titleEndIndex;
         if (i < endIndex) {
             const k = eatOptionalWhitespaces(nodePoints, i, endIndex);
             if (k < endIndex)
                 return null;
         }
         const token = createInitState();
-        token.destination = linkDestinationCollectResult.token;
-        token.title = linkTitleCollectResult.token;
+        token.destination = destinationState;
+        token.title = titleState;
         token.lineNoOfDestination = lineNo;
         token.lineNoOfTitle = lineNo;
         return { token, nextIndex: endIndex };
     }
-    eatContinuationText(line, token) {
+    function eatContinuationText(line, token) {
         var _a;
         if (token.title != null && token.title.saturated)
             return { status: 'notMatched' };
@@ -310,12 +300,11 @@ class DefinitionTokenizer extends BaseBlockTokenizer {
         const lineNo = nodePoints[startIndex].line;
         let i = firstNonWhitespaceIndex;
         if (!token.label.saturated) {
-            const linkLabelCollectResult = eatAndCollectLinkLabel(nodePoints, i, endIndex, token.label);
-            if (linkLabelCollectResult.nextIndex < 0) {
+            const { nextIndex: labelEndIndex, state: labelState } = eatAndCollectLinkLabel(nodePoints, i, endIndex, token.label);
+            if (labelEndIndex < 0) {
                 return { status: 'failedAndRollback', lines: token.lines };
             }
-            const labelEndIndex = linkLabelCollectResult.nextIndex;
-            if (!linkLabelCollectResult.token.saturated) {
+            if (!labelState.saturated) {
                 token.lines.push(line);
                 return { status: 'opening', nextIndex: endIndex };
             }
@@ -330,15 +319,13 @@ class DefinitionTokenizer extends BaseBlockTokenizer {
             if (i >= endIndex) {
                 return { status: 'failedAndRollback', lines: token.lines };
             }
-            const linkDestinationCollectResult = eatAndCollectLinkDestination(nodePoints, i, endIndex, null);
-            if (linkDestinationCollectResult.nextIndex < 0 ||
-                !linkDestinationCollectResult.token.saturated) {
+            const { nextIndex: destinationEndIndex, state: destinationState } = eatAndCollectLinkDestination(nodePoints, i, endIndex, null);
+            if (destinationEndIndex < 0 || !destinationState.saturated) {
                 return { status: 'failedAndRollback', lines: token.lines };
             }
-            const destinationEndIndex = linkDestinationCollectResult.nextIndex;
             i = eatOptionalWhitespaces(nodePoints, destinationEndIndex, endIndex);
             if (i >= endIndex) {
-                token.destination = linkDestinationCollectResult.token;
+                token.destination = destinationState;
                 token.lines.push(line);
                 return { status: 'opening', nextIndex: endIndex };
             }
@@ -348,12 +335,12 @@ class DefinitionTokenizer extends BaseBlockTokenizer {
         if (token.lineNoOfTitle < 0) {
             token.lineNoOfTitle = lineNo;
         }
-        const linkTitleCollectResult = eatAndCollectLinkTitle(nodePoints, i, endIndex, token.title);
-        token.title = linkTitleCollectResult.token;
-        if (linkTitleCollectResult.nextIndex < 0 ||
-            linkTitleCollectResult.token.nodePoints.length <= 0 ||
-            (linkTitleCollectResult.token.saturated &&
-                eatOptionalWhitespaces(nodePoints, linkTitleCollectResult.nextIndex, endIndex) < endIndex)) {
+        const { nextIndex: titleEndIndex, state: titleState } = eatAndCollectLinkTitle(nodePoints, i, endIndex, token.title);
+        token.title = titleState;
+        if (titleEndIndex < 0 ||
+            titleState.nodePoints.length <= 0 ||
+            (titleState.saturated &&
+                eatOptionalWhitespaces(nodePoints, titleEndIndex, endIndex) < endIndex)) {
             if (token.lineNoOfDestination === token.lineNoOfTitle) {
                 return { status: 'failedAndRollback', lines: token.lines };
             }
@@ -369,7 +356,7 @@ class DefinitionTokenizer extends BaseBlockTokenizer {
         const saturated = (_a = token.title) === null || _a === void 0 ? void 0 : _a.saturated;
         return { status: saturated ? 'closing' : 'opening', nextIndex: endIndex };
     }
-    onClose(token, api) {
+    function onClose(token) {
         let result;
         if (token.title == null || !token.title.saturated) {
             if (!token.label.saturated) {
@@ -397,26 +384,41 @@ class DefinitionTokenizer extends BaseBlockTokenizer {
         token._identifier = identifier;
         return result;
     }
-    parseBlock(token) {
-        const label = token._label;
-        const identifier = token._identifier;
-        const destinationPoints = token.destination.nodePoints;
-        const destination = destinationPoints[0].codePoint === AsciiCodePoint.OPEN_ANGLE
-            ? calcEscapedStringFromNodePoints(destinationPoints, 1, destinationPoints.length - 1, true)
-            : calcEscapedStringFromNodePoints(destinationPoints, 0, destinationPoints.length, true);
-        const url = encodeLinkDestination(destination);
-        const title = token.title == null
-            ? undefined
-            : calcEscapedStringFromNodePoints(token.title.nodePoints, 1, token.title.nodePoints.length - 1);
-        const node = {
-            type: DefinitionType,
-            identifier,
-            label,
-            url,
-            title,
-        };
-        return node;
+};
+
+const parse = function (api) {
+    return {
+        parse: tokens => tokens.map(token => {
+            const label = token._label;
+            const identifier = token._identifier;
+            const destinationPoints = token.destination.nodePoints;
+            const destination = destinationPoints[0].codePoint === AsciiCodePoint.OPEN_ANGLE
+                ? calcEscapedStringFromNodePoints(destinationPoints, 1, destinationPoints.length - 1, true)
+                : calcEscapedStringFromNodePoints(destinationPoints, 0, destinationPoints.length, true);
+            const url = encodeLinkDestination(destination);
+            const title = token.title == null
+                ? undefined
+                : calcEscapedStringFromNodePoints(token.title.nodePoints, 1, token.title.nodePoints.length - 1);
+            const node = api.shouldReservePosition
+                ? { type: DefinitionType, position: token.position, identifier, label, url, title }
+                : { type: DefinitionType, identifier, label, url, title };
+            return node;
+        }),
+    };
+};
+
+const uniqueName = '@yozora/tokenizer-definition';
+
+class DefinitionTokenizer 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 { DefinitionTokenizer, uniqueName as DefinitionTokenizerName, DefinitionTokenizer as default, eatAndCollectLinkDestination, eatAndCollectLinkLabel, eatAndCollectLinkTitle };
+export { DefinitionTokenizer, uniqueName as DefinitionTokenizerName, DefinitionTokenizer as default, match as definitionMatch, parse as definitionParse, eatAndCollectLinkDestination, eatAndCollectLinkLabel, eatAndCollectLinkTitle };

package/lib/types/index.d.ts

@@ -1,8 +1,8 @@
-import { DefinitionTokenizer } from './tokenizer';
 export * from './util/link-destination';
 export * from './util/link-label';
 export * from './util/link-title';
-export { DefinitionTokenizer } from './tokenizer';
+export { match as definitionMatch } from './match';
+export { parse as definitionParse } from './parse';
+export { DefinitionTokenizer, DefinitionTokenizer as default } from './tokenizer';
 export { uniqueName as DefinitionTokenizerName } from './types';
-export type { Token as DefinitionToken, TokenizerProps as DefinitionTokenizerProps, } from './types';
-export default DefinitionTokenizer;
+export type { IThis as IDefinitionHookContext, IToken as IDefinitionToken, ITokenizerProps as IDefinitionTokenizerProps, } from './types';

package/lib/types/match.d.ts

@@ -0,0 +1,18 @@
+import type { IMatchBlockHookCreator } from '@yozora/core-tokenizer';
+import type { IThis, IToken, T } from './types';
+/**
+ * A link reference definition consists of a link label, indented up to three
+ * spaces, followed by a colon (:), optional whitespace (including up to one
+ * line ending), a link destination, optional whitespace (including up to one
+ * line ending), and an optional link title, which if it is present must be
+ * separated from the link destination by whitespace. No further non-whitespace
+ * characters may occur on the line.
+ *
+ * A link reference definition does not correspond to a structural element of
+ * a document. Instead, it defines a label which can be used in reference
+ * links and reference-style images elsewhere in the document. Link reference
+ * definitions can come either before or after the links that use them.
+ *
+ * @see https://github.github.com/gfm/#link-reference-definition
+ */
+export declare const match: IMatchBlockHookCreator<T, IToken, IThis>;

package/lib/types/parse.d.ts

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

package/lib/types/tokenizer.d.ts

@@ -1,44 +1,12 @@
-import type { MatchBlockPhaseApi, PhrasingContentLine, ResultOfEatContinuationText, ResultOfEatOpener, ResultOfOnClose, ResultOfParse, Tokenizer, TokenizerMatchBlockHook, TokenizerParseBlockHook } from '@yozora/core-tokenizer';
+import type { IBlockTokenizer, IMatchBlockHookCreator, IParseBlockHookCreator } from '@yozora/core-tokenizer';
 import { BaseBlockTokenizer } from '@yozora/core-tokenizer';
-import type { Node, T, Token, TokenizerProps } from './types';
+import type { INode, IThis, IToken, ITokenizerProps, T } from './types';
 /**
  * Lexical Analyzer for Definition.
- *
- * A link reference definition consists of a link label, indented up to three
- * spaces, followed by a colon (:), optional whitespace (including up to one
- * line ending), a link destination, optional whitespace (including up to one
- * line ending), and an optional link title, which if it is present must be
- * separated from the link destination by whitespace. No further non-whitespace
- * characters may occur on the line.
- *
- * A link reference definition does not correspond to a structural element of
- * a document. Instead, it defines a label which can be used in reference
- * links and reference-style images elsewhere in the document. Link reference
- * definitions can come either before or after the links that use them.
- *
  * @see https://github.github.com/gfm/#link-reference-definition
  */
-export declare class DefinitionTokenizer 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
-     */
-    eatContinuationText(line: Readonly<PhrasingContentLine>, token: Token): ResultOfEatContinuationText;
-    /**
-     * @override
-     * @see TokenizerMatchBlockHook
-     */
-    onClose(token: Token, api: Readonly<MatchBlockPhaseApi>): ResultOfOnClose;
-    /**
-     * @override
-     * @see TokenizerParseBlockHook
-     */
-    parseBlock(token: Readonly<Token>): ResultOfParse<T, Node>;
+export declare class DefinitionTokenizer extends BaseBlockTokenizer<T, IToken, INode, IThis> implements IBlockTokenizer<T, IToken, INode, IThis> {
+    constructor(props?: ITokenizerProps);
+    readonly match: IMatchBlockHookCreator<T, IToken, IThis>;
+    readonly parse: IParseBlockHookCreator<T, IToken, INode, IThis>;
 }

package/lib/types/types.d.ts

@@ -1,16 +1,16 @@
-import type { Definition, DefinitionType } from '@yozora/ast';
-import type { BaseBlockTokenizerProps, PartialYastBlockToken, PhrasingContentLine } from '@yozora/core-tokenizer';
+import type { DefinitionType, IDefinition } from '@yozora/ast';
+import type { IBaseBlockTokenizerProps, IPartialYastBlockToken, IPhrasingContentLine, ITokenizer } from '@yozora/core-tokenizer';
 import type { LinkDestinationCollectingState } from './util/link-destination';
 import type { LinkLabelCollectingState } from './util/link-label';
 import type { LinkTitleCollectingState } from './util/link-title';
 export declare type T = DefinitionType;
-export declare type Node = Definition;
+export declare type INode = IDefinition;
 export declare const uniqueName = "@yozora/tokenizer-definition";
-export interface Token extends PartialYastBlockToken<T> {
+export interface IToken extends IPartialYastBlockToken<T> {
     /**
      *
      */
-    lines: Array<Readonly<PhrasingContentLine>>;
+    lines: Array<Readonly<IPhrasingContentLine>>;
     /**
      * Link label
      * Trimmed, Case-Insensitive
@@ -45,4 +45,5 @@ export interface Token extends PartialYastBlockToken<T> {
      */
     _identifier?: string;
 }
-export declare type TokenizerProps = Partial<BaseBlockTokenizerProps>;
+export declare type IThis = ITokenizer;
+export declare type ITokenizerProps = Partial<IBaseBlockTokenizerProps>;