@yozora/tokenizer-blockquote 2.0.4 → 2.0.5-alpha.0

package/lib/cjs/{index.js → index.cjs}

@@ -81,18 +81,17 @@ const uniqueName = '@yozora/tokenizer-blockquote';
 
 class BlockquoteTokenizer 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.CONTAINING_BLOCK,
+            name: props.name ?? uniqueName,
+            priority: props.priority ?? coreTokenizer.TokenizerPriority.CONTAINING_BLOCK,
         });
-        this.match = match;
-        this.parse = parse;
     }
+    match = match;
+    parse = parse;
 }
 
 exports.BlockquoteTokenizer = BlockquoteTokenizer;
 exports.BlockquoteTokenizerName = uniqueName;
 exports.blockquoteMatch = match;
 exports.blockquoteParse = parse;
-exports["default"] = BlockquoteTokenizer;
+exports.default = BlockquoteTokenizer;

package/lib/esm/{index.js → index.mjs}

@@ -77,14 +77,13 @@ const uniqueName = '@yozora/tokenizer-blockquote';
 
 class BlockquoteTokenizer 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.CONTAINING_BLOCK,
+            name: props.name ?? uniqueName,
+            priority: props.priority ?? TokenizerPriority.CONTAINING_BLOCK,
         });
-        this.match = match;
-        this.parse = parse;
     }
+    match = match;
+    parse = parse;
 }
 
 export { BlockquoteTokenizer, uniqueName as BlockquoteTokenizerName, match as blockquoteMatch, parse as blockquoteParse, BlockquoteTokenizer as default };

package/lib/types/index.d.ts

@@ -1,8 +1,8 @@
 import { IPartialYastBlockToken, IYastBlockToken, ITokenizer, IBaseBlockTokenizerProps, IMatchBlockHookCreator, IParseBlockHookCreator, BaseBlockTokenizer, IBlockTokenizer } from '@yozora/core-tokenizer';
 import { BlockquoteType, Blockquote } from '@yozora/ast';
 
-declare type T = BlockquoteType;
-declare type INode = Blockquote;
+type T = BlockquoteType;
+type INode = Blockquote;
 declare const uniqueName = "@yozora/tokenizer-blockquote";
 interface IToken extends IPartialYastBlockToken<T> {
     /**
@@ -10,8 +10,8 @@ interface IToken extends IPartialYastBlockToken<T> {
      */
     children: IYastBlockToken[];
 }
-declare type IThis = ITokenizer;
-declare type ITokenizerProps = Partial<IBaseBlockTokenizerProps>;
+type IThis = ITokenizer;
+type ITokenizerProps = Partial<IBaseBlockTokenizerProps>;
 
 /**
  * A block quote marker consists of 0-3 spaces of initial indent, plus

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-blockquote",
-  "version": "2.0.4",
+  "version": "2.0.5-alpha.0",
   "author": {
     "name": "guanghechen",
     "url": "https://github.com/guanghechen/"
@@ -11,33 +11,37 @@
     "directory": "tokenizers/blockquote"
   },
   "homepage": "https://github.com/yozorajs/yozora/tree/release-2.x.x/tokenizers/blockquote",
-  "main": "lib/cjs/index.js",
-  "module": "lib/esm/index.js",
-  "types": "lib/types/index.d.ts",
-  "source": "src/index.ts",
+  "type": "module",
+  "exports": {
+    "types": "./lib/types/index.d.ts",
+    "import": "./lib/esm/index.mjs",
+    "require": "./lib/cjs/index.cjs"
+  },
+  "source": "./src/index.ts",
+  "types": "./lib/types/index.d.ts",
+  "main": "./lib/cjs/index.cjs",
+  "module": "./lib/esm/index.mjs",
   "license": "MIT",
   "engines": {
     "node": ">= 16.0.0"
   },
   "files": [
     "lib/",
-    "!lib/**/*.js.map",
-    "!lib/**/*.d.ts.map",
+    "src/",
     "package.json",
     "CHANGELOG.md",
     "LICENSE",
     "README.md"
   ],
   "scripts": {
-    "build": "cross-env NODE_ENV=production rollup -c ../../rollup.config.js",
-    "prebuild": "rimraf lib/",
+    "build": "rimraf lib/ && cross-env NODE_ENV=production rollup -c ../../rollup.config.mjs",
     "prepublishOnly": "cross-env ROLLUP_SHOULD_SOURCEMAP=false yarn build",
-    "test": "cross-env TS_NODE_FILES=true jest --config ../../jest.config.js --rootDir ."
+    "test": "cross-env TS_NODE_FILES=true NODE_OPTIONS=--experimental-vm-modules jest --config ../../jest.config.mjs --rootDir ."
   },
   "dependencies": {
-    "@yozora/ast": "^2.0.4",
-    "@yozora/character": "^2.0.4",
-    "@yozora/core-tokenizer": "^2.0.4"
+    "@yozora/ast": "^2.0.5-alpha.0",
+    "@yozora/character": "^2.0.5-alpha.0",
+    "@yozora/core-tokenizer": "^2.0.5-alpha.0"
   },
-  "gitHead": "c980b95254394dcacba0cbb4bea251350b09397c"
+  "gitHead": "8bf941fe4ef82947165b0f3cc123cd493665e13b"
 }

package/src/index.ts

@@ -0,0 +1,9 @@
+export { match as blockquoteMatch } from './match'
+export { parse as blockquoteParse } from './parse'
+export { BlockquoteTokenizer, BlockquoteTokenizer as default } from './tokenizer'
+export { uniqueName as BlockquoteTokenizerName } from './types'
+export type {
+  IThis as IBlockquoteHookContext,
+  IToken as IBlockquoteToken,
+  ITokenizerProps as IBlockquoteTokenizerProps,
+} from './types'

package/src/match.ts

@@ -0,0 +1,133 @@
+import { BlockquoteType } from '@yozora/ast'
+import { AsciiCodePoint, VirtualCodePoint, isSpaceCharacter } from '@yozora/character'
+import type {
+  IMatchBlockHookCreator,
+  IPhrasingContentLine,
+  IResultOfEatAndInterruptPreviousSibling,
+  IResultOfEatContinuationText,
+  IResultOfEatOpener,
+  IYastBlockToken,
+} from '@yozora/core-tokenizer'
+import { calcEndPoint, calcStartPoint } from '@yozora/core-tokenizer'
+import type { IThis, IToken, T } from './types'
+
+/**
+ * A block quote marker consists of 0-3 spaces of initial indent, plus
+ *  (a) the character > together with a following space, or
+ *  (b) a single character > not followed by a space.
+ *
+ * The following rules define block quotes:
+ *  - Basic case. If a string of lines Ls constitute a sequence of blocks Bs,
+ *    then the result of prepending a block quote marker to the beginning of
+ *    each line in Ls is a block quote containing Bs.
+ *
+ *  - Laziness. If a string of lines Ls constitute a block quote with contents
+ *    Bs, then the result of deleting the initial block quote marker from one
+ *    or more lines in which the next non-whitespace character after the block
+ *    quote marker is paragraph continuation text is a block quote with Bs as
+ *    its content. Paragraph continuation text is text that will be parsed as
+ *    part of the content of a paragraph, but does not occur at the beginning
+ *    of the paragraph.
+ *
+ *  - Consecutiveness. A document cannot contain two block quotes in a row
+ *    unless there is a blank line between them.
+ *
+ * @see https://github.com/syntax-tree/mdast#blockquote
+ * @see https://github.github.com/gfm/#block-quotes
+ */
+export const match: IMatchBlockHookCreator<T, IToken, IThis> = function () {
+  return {
+    isContainingBlock: true,
+    eatOpener,
+    eatAndInterruptPreviousSibling,
+    eatContinuationText,
+  }
+
+  function eatOpener(line: Readonly<IPhrasingContentLine>): IResultOfEatOpener<T, IToken> {
+    /**
+     * The '>' characters can be indented 1-3 spaces
+     * @see https://github.github.com/gfm/#example-209
+     */
+    if (line.countOfPrecedeSpaces >= 4) return null
+
+    const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex } = line
+    if (
+      firstNonWhitespaceIndex >= endIndex ||
+      nodePoints[firstNonWhitespaceIndex].codePoint !== AsciiCodePoint.CLOSE_ANGLE
+    )
+      return null
+
+    /**
+     * A block quote marker consists of 0-3 spaces of initial indent, plus
+     *  (a) the character > together with a following space, or
+     *  (b) a single character > not followed by a space.
+     * @see https://github.github.com/gfm/#block-quote-marker
+     */
+    let nextIndex = firstNonWhitespaceIndex + 1
+    if (nextIndex < endIndex && isSpaceCharacter(nodePoints[nextIndex].codePoint)) {
+      nextIndex += 1
+      /**
+       * When the '>' followed by a tab, it is treated as if it were expanded
+       * into three spaces.
+       * @see https://github.github.com/gfm/#example-6
+       */
+      if (nextIndex < endIndex && nodePoints[nextIndex].codePoint === VirtualCodePoint.SPACE) {
+        nextIndex += 1
+      }
+    }
+
+    const token: IToken = {
+      nodeType: BlockquoteType,
+      position: {
+        start: calcStartPoint(nodePoints, startIndex),
+        end: calcEndPoint(nodePoints, nextIndex - 1),
+      },
+      children: [],
+    }
+    return { token, nextIndex }
+  }
+
+  function eatAndInterruptPreviousSibling(
+    line: Readonly<IPhrasingContentLine>,
+    prevSiblingToken: Readonly<IYastBlockToken>,
+  ): IResultOfEatAndInterruptPreviousSibling<T, IToken> {
+    const result = eatOpener(line)
+    if (result == null) return null
+    return {
+      token: result.token,
+      nextIndex: result.nextIndex,
+      remainingSibling: prevSiblingToken,
+    }
+  }
+
+  function eatContinuationText(
+    line: Readonly<IPhrasingContentLine>,
+    token: IToken,
+    parentToken: Readonly<IYastBlockToken>,
+  ): IResultOfEatContinuationText {
+    const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex, countOfPrecedeSpaces } = line
+
+    if (
+      countOfPrecedeSpaces >= 4 ||
+      firstNonWhitespaceIndex >= endIndex ||
+      nodePoints[firstNonWhitespaceIndex].codePoint !== AsciiCodePoint.CLOSE_ANGLE
+    ) {
+      /**
+       * It is a consequence of the Laziness rule that any number of initial
+       * `>`s may be omitted on a continuation line of a nested block quote
+       * @see https://github.github.com/gfm/#example-229
+       */
+      if (parentToken.nodeType === BlockquoteType) {
+        return { status: 'opening', nextIndex: startIndex }
+      }
+      return { status: 'notMatched' }
+    }
+
+    const nextIndex =
+      firstNonWhitespaceIndex + 1 < endIndex &&
+      isSpaceCharacter(nodePoints[firstNonWhitespaceIndex + 1].codePoint)
+        ? firstNonWhitespaceIndex + 2
+        : firstNonWhitespaceIndex + 1
+    return { status: 'opening', nextIndex }
+  }
+}

package/src/parse.ts

@@ -0,0 +1,17 @@
+import type { Node } from '@yozora/ast'
+import { BlockquoteType } from '@yozora/ast'
+import type { IParseBlockHookCreator } from '@yozora/core-tokenizer'
+import type { INode, IThis, IToken, T } from './types'
+
+export const parse: IParseBlockHookCreator<T, IToken, INode, IThis> = function (api) {
+  return {
+    parse: tokens =>
+      tokens.map(token => {
+        const children: Node[] = api.parseBlockTokens(token.children)
+        const node: INode = api.shouldReservePosition
+          ? { type: BlockquoteType, position: token.position, children }
+          : { type: BlockquoteType, children }
+        return node
+      }),
+  }
+}

package/src/tokenizer.ts

@@ -0,0 +1,32 @@
+import type {
+  IBlockTokenizer,
+  IMatchBlockHookCreator,
+  IParseBlockHookCreator,
+} from '@yozora/core-tokenizer'
+import { BaseBlockTokenizer, TokenizerPriority } from '@yozora/core-tokenizer'
+import { match } from './match'
+import { parse } from './parse'
+import type { INode, IThis, IToken, ITokenizerProps, T } from './types'
+import { uniqueName } from './types'
+
+/**
+ * Lexical Analyzer for Blockquote.
+ * @see https://github.com/syntax-tree/mdast#blockquote
+ * @see https://github.github.com/gfm/#block-quotes
+ */
+export class BlockquoteTokenizer
+  extends BaseBlockTokenizer<T, IToken, INode, IThis>
+  implements IBlockTokenizer<T, IToken, INode, IThis>
+{
+  /* istanbul ignore next */
+  constructor(props: ITokenizerProps = {}) {
+    super({
+      name: props.name ?? uniqueName,
+      priority: props.priority ?? TokenizerPriority.CONTAINING_BLOCK,
+    })
+  }
+
+  public override readonly match: IMatchBlockHookCreator<T, IToken, IThis> = match
+
+  public override readonly parse: IParseBlockHookCreator<T, IToken, INode, IThis> = parse
+}

package/src/types.ts

@@ -0,0 +1,22 @@
+import type { Blockquote, BlockquoteType } from '@yozora/ast'
+import type {
+  IBaseBlockTokenizerProps,
+  IPartialYastBlockToken,
+  ITokenizer,
+  IYastBlockToken,
+} from '@yozora/core-tokenizer'
+
+export type T = BlockquoteType
+export type INode = Blockquote
+export const uniqueName = '@yozora/tokenizer-blockquote'
+
+export interface IToken extends IPartialYastBlockToken<T> {
+  /**
+   *
+   */
+  children: IYastBlockToken[]
+}
+
+export type IThis = ITokenizer
+
+export type ITokenizerProps = Partial<IBaseBlockTokenizerProps>