@yozora/tokenizer-fenced-block 1.2.0 → 2.0.0-alpha.0

package/lib/cjs/index.js

@@ -5,43 +5,36 @@ Object.defineProperty(exports, '__esModule', { value: true });
 var character = require('@yozora/character');
 var coreTokenizer = require('@yozora/core-tokenizer');
 
-class FencedBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
-    constructor(props) {
-        var _a;
-        super({
-            name: props.name,
-            priority: (_a = props.priority) !== null && _a !== void 0 ? _a : coreTokenizer.TokenizerPriority.FENCED_BLOCK,
-        });
-        this.isContainingBlock = false;
-        this.markers = [];
-        this.nodeType = props.nodeType;
-        this.markers = props.markers;
-        this.markersRequired = props.markersRequired;
-        this.checkInfoString = props.checkInfoString;
-    }
-    eatOpener(line) {
+function match(_api) {
+    const { nodeType, markers, markersRequired, checkInfoString } = this;
+    return {
+        isContainingBlock: false,
+        eatOpener,
+        eatAndInterruptPreviousSibling,
+        eatContinuationText,
+    };
+    function eatOpener(line) {
         if (line.countOfPrecedeSpaces >= 4)
             return null;
         const { endIndex, firstNonWhitespaceIndex } = line;
-        if (firstNonWhitespaceIndex + this.markersRequired - 1 >= endIndex)
+        if (firstNonWhitespaceIndex + markersRequired - 1 >= endIndex)
             return null;
         const { nodePoints, startIndex } = line;
         const marker = nodePoints[firstNonWhitespaceIndex].codePoint;
-        if (this.markers.indexOf(marker) < 0)
+        if (markers.indexOf(marker) < 0)
             return null;
         const i = coreTokenizer.eatOptionalCharacters(nodePoints, firstNonWhitespaceIndex + 1, endIndex, marker);
         const countOfMark = i - firstNonWhitespaceIndex;
-        if (countOfMark < this.markersRequired)
+        if (countOfMark < markersRequired)
             return null;
         const [iLft, iRht] = character.calcTrimBoundaryOfCodePoints(nodePoints, i, endIndex);
         const infoString = nodePoints.slice(iLft, iRht);
-        if (this.checkInfoString != null &&
-            !this.checkInfoString(infoString, marker, countOfMark)) {
+        if (checkInfoString != null && !checkInfoString(infoString, marker, countOfMark)) {
             return null;
         }
         const nextIndex = endIndex;
         const token = {
-            nodeType: this.nodeType,
+            nodeType: nodeType,
             position: {
                 start: coreTokenizer.calcStartYastNodePoint(nodePoints, startIndex),
                 end: coreTokenizer.calcEndYastNodePoint(nodePoints, nextIndex - 1),
@@ -54,8 +47,8 @@ class FencedBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
         };
         return { token, nextIndex };
     }
-    eatAndInterruptPreviousSibling(line, prevSiblingToken) {
-        const result = this.eatOpener(line);
+    function eatAndInterruptPreviousSibling(line, prevSiblingToken) {
+        const result = eatOpener(line);
         if (result == null)
             return null;
         return {
@@ -64,8 +57,8 @@ class FencedBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
             remainingSibling: prevSiblingToken,
         };
     }
-    eatContinuationText(line, token) {
-        const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex, countOfPrecedeSpaces, } = line;
+    function eatContinuationText(line, token) {
+        const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex, countOfPrecedeSpaces } = line;
         if (countOfPrecedeSpaces < 4 && firstNonWhitespaceIndex < endIndex) {
             let i = coreTokenizer.eatOptionalCharacters(nodePoints, firstNonWhitespaceIndex, endIndex, token.marker);
             const markerCount = i - firstNonWhitespaceIndex;
@@ -92,8 +85,25 @@ class FencedBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
     }
 }
 
+class FencedBlockTokenizer extends coreTokenizer.BaseBlockTokenizer {
+    constructor(props) {
+        var _a;
+        super({
+            name: props.name,
+            priority: (_a = props.priority) !== null && _a !== void 0 ? _a : coreTokenizer.TokenizerPriority.FENCED_BLOCK,
+        });
+        this.markers = [];
+        this.match = match;
+        this.nodeType = props.nodeType;
+        this.markers = props.markers;
+        this.markersRequired = props.markersRequired;
+        this.checkInfoString = props.checkInfoString;
+    }
+}
+
 const FencedBlockType = 'fencedBlock';
 
 exports.FencedBlockTokenizer = FencedBlockTokenizer;
 exports.FencedBlockType = FencedBlockType;
-exports['default'] = FencedBlockTokenizer;
+exports["default"] = FencedBlockTokenizer;
+exports.fencedMatch = match;

package/lib/esm/index.js

@@ -1,43 +1,36 @@
 import { calcTrimBoundaryOfCodePoints, isSpaceCharacter } from '@yozora/character';
-import { BaseBlockTokenizer, TokenizerPriority, eatOptionalCharacters, calcStartYastNodePoint, calcEndYastNodePoint } from '@yozora/core-tokenizer';
+import { eatOptionalCharacters, calcStartYastNodePoint, calcEndYastNodePoint, BaseBlockTokenizer, TokenizerPriority } from '@yozora/core-tokenizer';
 
-class FencedBlockTokenizer extends BaseBlockTokenizer {
-    constructor(props) {
-        var _a;
-        super({
-            name: props.name,
-            priority: (_a = props.priority) !== null && _a !== void 0 ? _a : TokenizerPriority.FENCED_BLOCK,
-        });
-        this.isContainingBlock = false;
-        this.markers = [];
-        this.nodeType = props.nodeType;
-        this.markers = props.markers;
-        this.markersRequired = props.markersRequired;
-        this.checkInfoString = props.checkInfoString;
-    }
-    eatOpener(line) {
+function match(_api) {
+    const { nodeType, markers, markersRequired, checkInfoString } = this;
+    return {
+        isContainingBlock: false,
+        eatOpener,
+        eatAndInterruptPreviousSibling,
+        eatContinuationText,
+    };
+    function eatOpener(line) {
         if (line.countOfPrecedeSpaces >= 4)
             return null;
         const { endIndex, firstNonWhitespaceIndex } = line;
-        if (firstNonWhitespaceIndex + this.markersRequired - 1 >= endIndex)
+        if (firstNonWhitespaceIndex + markersRequired - 1 >= endIndex)
             return null;
         const { nodePoints, startIndex } = line;
         const marker = nodePoints[firstNonWhitespaceIndex].codePoint;
-        if (this.markers.indexOf(marker) < 0)
+        if (markers.indexOf(marker) < 0)
             return null;
         const i = eatOptionalCharacters(nodePoints, firstNonWhitespaceIndex + 1, endIndex, marker);
         const countOfMark = i - firstNonWhitespaceIndex;
-        if (countOfMark < this.markersRequired)
+        if (countOfMark < markersRequired)
             return null;
         const [iLft, iRht] = calcTrimBoundaryOfCodePoints(nodePoints, i, endIndex);
         const infoString = nodePoints.slice(iLft, iRht);
-        if (this.checkInfoString != null &&
-            !this.checkInfoString(infoString, marker, countOfMark)) {
+        if (checkInfoString != null && !checkInfoString(infoString, marker, countOfMark)) {
             return null;
         }
         const nextIndex = endIndex;
         const token = {
-            nodeType: this.nodeType,
+            nodeType: nodeType,
             position: {
                 start: calcStartYastNodePoint(nodePoints, startIndex),
                 end: calcEndYastNodePoint(nodePoints, nextIndex - 1),
@@ -50,8 +43,8 @@ class FencedBlockTokenizer extends BaseBlockTokenizer {
         };
         return { token, nextIndex };
     }
-    eatAndInterruptPreviousSibling(line, prevSiblingToken) {
-        const result = this.eatOpener(line);
+    function eatAndInterruptPreviousSibling(line, prevSiblingToken) {
+        const result = eatOpener(line);
         if (result == null)
             return null;
         return {
@@ -60,8 +53,8 @@ class FencedBlockTokenizer extends BaseBlockTokenizer {
             remainingSibling: prevSiblingToken,
         };
     }
-    eatContinuationText(line, token) {
-        const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex, countOfPrecedeSpaces, } = line;
+    function eatContinuationText(line, token) {
+        const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex, countOfPrecedeSpaces } = line;
         if (countOfPrecedeSpaces < 4 && firstNonWhitespaceIndex < endIndex) {
             let i = eatOptionalCharacters(nodePoints, firstNonWhitespaceIndex, endIndex, token.marker);
             const markerCount = i - firstNonWhitespaceIndex;
@@ -88,6 +81,22 @@ class FencedBlockTokenizer extends BaseBlockTokenizer {
     }
 }
 
+class FencedBlockTokenizer extends BaseBlockTokenizer {
+    constructor(props) {
+        var _a;
+        super({
+            name: props.name,
+            priority: (_a = props.priority) !== null && _a !== void 0 ? _a : TokenizerPriority.FENCED_BLOCK,
+        });
+        this.markers = [];
+        this.match = match;
+        this.nodeType = props.nodeType;
+        this.markers = props.markers;
+        this.markersRequired = props.markersRequired;
+        this.checkInfoString = props.checkInfoString;
+    }
+}
+
 const FencedBlockType = 'fencedBlock';
 
-export { FencedBlockTokenizer, FencedBlockType, FencedBlockTokenizer as default };
+export { FencedBlockTokenizer, FencedBlockType, FencedBlockTokenizer as default, match as fencedMatch };

package/lib/types/index.d.ts

@@ -1,5 +1,4 @@
-import { FencedBlockTokenizer } from './tokenizer';
-export { FencedBlockTokenizer } from './tokenizer';
-export type { Token as FencedBlockToken, TokenizerProps as FencedBlockTokenizerProps, } from './types';
+export { match as fencedMatch } from './match';
+export { FencedBlockTokenizer, FencedBlockTokenizer as default } from './tokenizer';
 export { FencedBlockType } from './types';
-export default FencedBlockTokenizer;
+export type { IFencedBlockHookContext, IToken as IFencedBlockToken, ITokenizerProps as IFencedBlockTokenizerProps, } from './types';

package/lib/types/match.d.ts

@@ -0,0 +1,4 @@
+import type { YastNodeType } from '@yozora/ast';
+import type { IMatchBlockHook, IMatchBlockPhaseApi } from '@yozora/core-tokenizer';
+import type { IFencedBlockHookContext, IToken } from './types';
+export declare function match<T extends YastNodeType = YastNodeType, IThis extends IFencedBlockHookContext<T> = IFencedBlockHookContext<T>>(this: IThis, _api: IMatchBlockPhaseApi): IMatchBlockHook<T, IToken<T>>;

package/lib/types/tokenizer.d.ts

@@ -1,8 +1,8 @@
-import type { YastNodeType } from '@yozora/ast';
-import type { CodePoint } from '@yozora/character';
-import type { PhrasingContentLine, ResultOfEatAndInterruptPreviousSibling, ResultOfEatContinuationText, ResultOfEatOpener, Tokenizer, TokenizerMatchBlockHook, YastBlockToken } from '@yozora/core-tokenizer';
+import type { IYastNode, YastNodeType } from '@yozora/ast';
+import type { ICodePoint } from '@yozora/character';
+import type { IBlockTokenizer, IMatchBlockHookCreator } from '@yozora/core-tokenizer';
 import { BaseBlockTokenizer } from '@yozora/core-tokenizer';
-import type { FencedBlockType, Token, TokenizerProps } from './types';
+import type { IFencedBlockHookContext, IToken, ITokenizerProps } from './types';
 /**
  * Lexical Matcher for FencedBlock.
  *
@@ -13,26 +13,11 @@ import type { FencedBlockType, Token, TokenizerProps } from './types';
  * @see https://github.com/syntax-tree/mdast#code
  * @see https://github.github.com/gfm/#code-fence
  */
-export declare class FencedBlockTokenizer<T extends YastNodeType = FencedBlockType> extends BaseBlockTokenizer implements Tokenizer, TokenizerMatchBlockHook<T, Token<T>> {
-    readonly isContainingBlock: boolean;
+export declare abstract class FencedBlockTokenizer<T extends YastNodeType = YastNodeType, INode extends IYastNode<T> = IYastNode<T>, IThis extends IFencedBlockHookContext<T> = IFencedBlockHookContext<T>> extends BaseBlockTokenizer<T, IToken<T>, INode, any> implements IBlockTokenizer<T, IToken<T>, INode, IThis> {
     protected readonly nodeType: T;
-    protected readonly markers: CodePoint[];
+    protected readonly markers: ICodePoint[];
     protected readonly markersRequired: number;
-    protected readonly checkInfoString: TokenizerProps<T>['checkInfoString'];
-    constructor(props: TokenizerProps<T>);
-    /**
-     * @override
-     * @see TokenizerMatchBlockHook
-     */
-    eatOpener(line: Readonly<PhrasingContentLine>): ResultOfEatOpener<T, Token<T>>;
-    /**
-     * @override
-     * @see TokenizerMatchBlockHook
-     */
-    eatAndInterruptPreviousSibling(line: Readonly<PhrasingContentLine>, prevSiblingToken: Readonly<YastBlockToken>): ResultOfEatAndInterruptPreviousSibling<T, Token<T>>;
-    /**
-     * @override
-     * @see TokenizerMatchBlockHook
-     */
-    eatContinuationText(line: Readonly<PhrasingContentLine>, token: Token<T>): ResultOfEatContinuationText;
+    protected readonly checkInfoString: ITokenizerProps<T>['checkInfoString'];
+    constructor(props: ITokenizerProps<T>);
+    readonly match: IMatchBlockHookCreator<T, IToken<T>, IThis>;
 }

package/lib/types/types.d.ts

@@ -1,9 +1,9 @@
 import type { YastNodeType } from '@yozora/ast';
-import type { CodePoint, NodePoint } from '@yozora/character';
-import type { BaseBlockTokenizerProps, PartialYastBlockToken, PhrasingContentLine } from '@yozora/core-tokenizer';
+import type { ICodePoint, INodePoint } from '@yozora/character';
+import type { IBaseBlockTokenizerProps, IPartialYastBlockToken, IPhrasingContentLine, ITokenizer } from '@yozora/core-tokenizer';
 export declare const FencedBlockType = "fencedBlock";
 export declare type FencedBlockType = typeof FencedBlockType;
-export interface Token<T extends YastNodeType> extends PartialYastBlockToken<T> {
+export interface IToken<T extends YastNodeType> extends IPartialYastBlockToken<T> {
     /**
      * Line indent of a fenced block.
      */
@@ -19,15 +19,36 @@ export interface Token<T extends YastNodeType> extends PartialYastBlockToken<T>
     /**
      * Lines to construct the contents of a paragraph.
      */
-    lines: PhrasingContentLine[];
+    lines: IPhrasingContentLine[];
     /**
      * Meta info string
      */
-    infoString: NodePoint[];
+    infoString: INodePoint[];
 }
-export interface TokenizerProps<T extends YastNodeType> extends Partial<BaseBlockTokenizerProps> {
+export interface IFencedBlockHookContext<T extends YastNodeType> extends ITokenizer {
     /**
-     * Tokenizer name.
+     * Type of special FencedBlock token and FencedBlock node.
+     */
+    nodeType: T;
+    /**
+     * Available fence markers.
+     */
+    markers: ICodePoint[];
+    /**
+     * The minimum amount required
+     */
+    markersRequired: number;
+    /**
+     * Check if the info string is valid.
+     * @param infoString
+     * @param marker
+     * @param countOfMarker
+     */
+    checkInfoString?(infoString: Readonly<INodePoint[]>, marker: ICodePoint, countOfMarker: number): boolean;
+}
+export interface ITokenizerProps<T extends YastNodeType> extends Partial<IBaseBlockTokenizerProps> {
+    /**
+     * ITokenizer name.
      */
     name: string;
     /**
@@ -37,7 +58,7 @@ export interface TokenizerProps<T extends YastNodeType> extends Partial<BaseBloc
     /**
      * Available fence markers.
      */
-    markers: CodePoint[];
+    markers: ICodePoint[];
     /**
      * The minimum amount required
      */
@@ -48,5 +69,5 @@ export interface TokenizerProps<T extends YastNodeType> extends Partial<BaseBloc
      * @param marker
      * @param countOfMarker
      */
-    checkInfoString?(infoString: Readonly<NodePoint[]>, marker: CodePoint, countOfMarker: number): boolean;
+    checkInfoString?(infoString: Readonly<INodePoint[]>, marker: ICodePoint, countOfMarker: number): boolean;
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-fenced-block",
-  "version": "1.2.0",
+  "version": "2.0.0-alpha.0",
   "author": {
     "name": "guanghechen",
     "url": "https://github.com/guanghechen/"
@@ -34,9 +34,9 @@
     "prepublishOnly": "cross-env ROLLUP_SHOULD_SOURCEMAP=false yarn build"
   },
   "dependencies": {
-    "@yozora/ast": "^1.2.0",
-    "@yozora/character": "^1.2.0",
-    "@yozora/core-tokenizer": "^1.2.0"
+    "@yozora/ast": "^2.0.0-alpha.0",
+    "@yozora/character": "^2.0.0-alpha.0",
+    "@yozora/core-tokenizer": "^2.0.0-alpha.0"
   },
-  "gitHead": "86da40e50d2fe9acace68695288e15e012e6cd0d"
+  "gitHead": "0171501339c49ffd02ed16a63447fa20a47a29a7"
 }