@yozora/tokenizer-definition 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 DefinitionTokenizer from '@yozora/tokenizer-definition'
 
-const parser = new DefaultYastParser()
-  .useBlockFallbackTokenizer(new ParagraphTokenizer())
-  .useInlineFallbackTokenizer(new TextTokenizer())
+const parser = new DefaultParser()
+  .useFallbackTokenizer(new ParagraphTokenizer())
+  .useFallbackTokenizer(new TextTokenizer())
   .useTokenizer(new DefinitionTokenizer())
 
 // parse source markdown content
@@ -242,7 +242,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
@@ -302,7 +301,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,16 +2,14 @@
 
 Object.defineProperty(exports, '__esModule', { value: true });
 
-var ast = require('@yozora/ast');
 var character = require('@yozora/character');
 var coreTokenizer = require('@yozora/core-tokenizer');
+var ast = require('@yozora/ast');
 
-const uniqueName = '@yozora/tokenizer-definition';
-
-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,
@@ -20,79 +18,78 @@ function eatAndCollectLinkDestination(nodePoints, startIndex, endIndex, token) {
     }
     const firstNonWhitespaceIndex = coreTokenizer.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 === character.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 character.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 character.AsciiCodePoint.OPEN_ANGLE:
                 case character.VirtualCodePoint.LINE_END:
-                    return { nextIndex: -1, token };
+                    return { nextIndex: -1, state: state };
                 case character.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 character.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 character.AsciiCodePoint.OPEN_PARENTHESIS:
-                token.openParensCount += 1;
-                token.nodePoints.push(p);
+                state.openParensCount += 1;
+                state.nodePoints.push(p);
                 break;
             case character.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 (character.isWhitespaceCharacter(p.codePoint) ||
-                    character.isAsciiControlCharacter(p.codePoint)) {
-                    token.saturated = true;
-                    return { nextIndex: i, token };
+                if (character.isWhitespaceCharacter(p.codePoint) || character.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,
@@ -100,50 +97,50 @@ function eatAndCollectLinkLabel(nodePoints, startIndex, endIndex, token) {
     }
     const firstNonWhitespaceIndex = coreTokenizer.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 !== character.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 character.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 character.AsciiCodePoint.OPEN_BRACKET:
-                return { nextIndex: -1, token };
+                return { nextIndex: -1, state: state };
             case character.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 (!character.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,
@@ -151,25 +148,25 @@ function eatAndCollectLinkTitle(nodePoints, startIndex, endIndex, token) {
     }
     const firstNonWhitespaceIndex = coreTokenizer.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 character.AsciiCodePoint.DOUBLE_QUOTE:
             case character.AsciiCodePoint.SINGLE_QUOTE:
             case character.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 character.AsciiCodePoint.DOUBLE_QUOTE:
         case character.AsciiCodePoint.SINGLE_QUOTE: {
             for (; i < endIndex; ++i) {
@@ -177,17 +174,17 @@ function eatAndCollectLinkTitle(nodePoints, startIndex, endIndex, token) {
                 switch (p.codePoint) {
                     case character.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;
@@ -198,49 +195,46 @@ function eatAndCollectLinkTitle(nodePoints, startIndex, endIndex, token) {
                 switch (p.codePoint) {
                     case character.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 character.AsciiCodePoint.OPEN_PARENTHESIS:
-                        return { nextIndex: -1, token };
+                        return { nextIndex: -1, state: state };
                     case character.AsciiCodePoint.CLOSE_PARENTHESIS:
-                        if (i + 1 >= endIndex ||
-                            nodePoints[i + 1].codePoint === character.VirtualCodePoint.LINE_END) {
-                            token.nodePoints.push(p);
-                            token.saturated = true;
+                        if (i + 1 >= endIndex || nodePoints[i + 1].codePoint === character.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 coreTokenizer.BaseBlockTokenizer {
-    constructor(props = {}) {
-        var _a, _b;
-        super({
-            name: (_a = props.name) !== null && _a !== void 0 ? _a : uniqueName,
-            priority: (_b = props.priority) !== null && _b !== void 0 ? _b : coreTokenizer.TokenizerPriority.ATOMIC,
-        });
-        this.isContainingBlock = false;
-    }
-    eatOpener(line) {
+const match = function (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 = () => {
@@ -250,7 +244,7 @@ class DefinitionTokenizer extends coreTokenizer.BaseBlockTokenizer {
                     start: coreTokenizer.calcStartYastNodePoint(nodePoints, startIndex),
                     end: coreTokenizer.calcEndYastNodePoint(nodePoints, endIndex - 1),
                 },
-                label: linkLabelCollectResult.token,
+                label: labelState,
                 destination: null,
                 title: null,
                 lineNoOfLabel: lineNo,
@@ -260,11 +254,10 @@ class DefinitionTokenizer extends coreTokenizer.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 !== character.AsciiCodePoint.COLON)
@@ -274,39 +267,36 @@ class DefinitionTokenizer extends coreTokenizer.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 = coreTokenizer.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 = coreTokenizer.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' };
@@ -314,12 +304,11 @@ class DefinitionTokenizer extends coreTokenizer.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 };
             }
@@ -334,15 +323,13 @@ class DefinitionTokenizer extends coreTokenizer.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 = coreTokenizer.eatOptionalWhitespaces(nodePoints, destinationEndIndex, endIndex);
             if (i >= endIndex) {
-                token.destination = linkDestinationCollectResult.token;
+                token.destination = destinationState;
                 token.lines.push(line);
                 return { status: 'opening', nextIndex: endIndex };
             }
@@ -352,12 +339,12 @@ class DefinitionTokenizer extends coreTokenizer.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 &&
-                coreTokenizer.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 &&
+                coreTokenizer.eatOptionalWhitespaces(nodePoints, titleEndIndex, endIndex) < endIndex)) {
             if (token.lineNoOfDestination === token.lineNoOfTitle) {
                 return { status: 'failedAndRollback', lines: token.lines };
             }
@@ -373,7 +360,7 @@ class DefinitionTokenizer extends coreTokenizer.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) {
@@ -401,31 +388,48 @@ class DefinitionTokenizer extends coreTokenizer.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 === character.AsciiCodePoint.OPEN_ANGLE
-            ? character.calcEscapedStringFromNodePoints(destinationPoints, 1, destinationPoints.length - 1, true)
-            : character.calcEscapedStringFromNodePoints(destinationPoints, 0, destinationPoints.length, true);
-        const url = coreTokenizer.encodeLinkDestination(destination);
-        const title = token.title == null
-            ? undefined
-            : character.calcEscapedStringFromNodePoints(token.title.nodePoints, 1, token.title.nodePoints.length - 1);
-        const node = {
-            type: ast.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 === character.AsciiCodePoint.OPEN_ANGLE
+                ? character.calcEscapedStringFromNodePoints(destinationPoints, 1, destinationPoints.length - 1, true)
+                : character.calcEscapedStringFromNodePoints(destinationPoints, 0, destinationPoints.length, true);
+            const url = coreTokenizer.encodeLinkDestination(destination);
+            const title = token.title == null
+                ? undefined
+                : character.calcEscapedStringFromNodePoints(token.title.nodePoints, 1, token.title.nodePoints.length - 1);
+            const node = api.shouldReservePosition
+                ? { type: ast.DefinitionType, position: token.position, identifier, label, url, title }
+                : { type: ast.DefinitionType, identifier, label, url, title };
+            return node;
+        }),
+    };
+};
+
+const uniqueName = '@yozora/tokenizer-definition';
+
+class DefinitionTokenizer extends coreTokenizer.BaseBlockTokenizer {
+    constructor(props = {}) {
+        var _a, _b;
+        super({
+            name: (_a = props.name) !== null && _a !== void 0 ? _a : uniqueName,
+            priority: (_b = props.priority) !== null && _b !== void 0 ? _b : coreTokenizer.TokenizerPriority.ATOMIC,
+        });
+        this.match = match;
+        this.parse = parse;
     }
 }
 
 exports.DefinitionTokenizer = DefinitionTokenizer;
 exports.DefinitionTokenizerName = uniqueName;
-exports['default'] = DefinitionTokenizer;
+exports["default"] = DefinitionTokenizer;
+exports.definitionMatch = match;
+exports.definitionParse = parse;
 exports.eatAndCollectLinkDestination = eatAndCollectLinkDestination;
 exports.eatAndCollectLinkLabel = eatAndCollectLinkLabel;
 exports.eatAndCollectLinkTitle = eatAndCollectLinkTitle;