@yozora/tokenizer-footnote-definition 2.0.4 → 2.0.5-alpha.0

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

@@ -120,20 +120,19 @@ const uniqueName = '@yozora/tokenizer-footnote-definition';
 
 class FootnoteDefinitionTokenizer 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.indent = 4;
-        this.match = match;
-        this.parse = parse;
     }
+    indent = 4;
+    match = match;
+    parse = parse;
 }
 
 exports.FootnoteDefinitionTokenizer = FootnoteDefinitionTokenizer;
 exports.FootnoteDefinitionTokenizerName = uniqueName;
-exports["default"] = FootnoteDefinitionTokenizer;
+exports.default = FootnoteDefinitionTokenizer;
 exports.eatFootnoteLabel = eatFootnoteLabel;
 exports.footnoteDefinitionMatch = match;
 exports.footnoteDefinitionParse = parse;

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

@@ -116,15 +116,14 @@ const uniqueName = '@yozora/tokenizer-footnote-definition';
 
 class FootnoteDefinitionTokenizer 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.indent = 4;
-        this.match = match;
-        this.parse = parse;
     }
+    indent = 4;
+    match = match;
+    parse = parse;
 }
 
 export { FootnoteDefinitionTokenizer, uniqueName as FootnoteDefinitionTokenizerName, FootnoteDefinitionTokenizer as default, eatFootnoteLabel, match as footnoteDefinitionMatch, parse as footnoteDefinitionParse };

package/lib/types/index.d.ts

@@ -20,8 +20,8 @@ import { FootnoteDefinitionType, FootnoteDefinition } from '@yozora/ast';
  */
 declare function eatFootnoteLabel(nodePoints: ReadonlyArray<INodePoint>, firstNonWhitespaceIndex: number, endIndex: number): number;
 
-declare type T = FootnoteDefinitionType;
-declare type INode = FootnoteDefinition;
+type T = FootnoteDefinitionType;
+type INode = FootnoteDefinition;
 declare const uniqueName = "@yozora/tokenizer-footnote-definition";
 interface IToken extends IPartialYastBlockToken<T> {
     /**
@@ -46,7 +46,7 @@ interface IToken extends IPartialYastBlockToken<T> {
 interface IThis extends ITokenizer {
     indent: number;
 }
-declare type ITokenizerProps = Partial<IBaseBlockTokenizerProps>;
+type ITokenizerProps = Partial<IBaseBlockTokenizerProps>;
 
 /**
  * A footnote reference definition consists of a footnote label, indented up

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-footnote-definition",
-  "version": "2.0.4",
+  "version": "2.0.5-alpha.0",
   "author": {
     "name": "guanghechen",
     "url": "https://github.com/guanghechen/"
@@ -11,33 +11,37 @@
     "directory": "tokenizers/footnote-definition"
   },
   "homepage": "https://github.com/yozorajs/yozora/tree/release-2.x.x/tokenizers/footnote-definition",
-  "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,10 @@
+export * from './util'
+export { match as footnoteDefinitionMatch } from './match'
+export { parse as footnoteDefinitionParse } from './parse'
+export { FootnoteDefinitionTokenizer, FootnoteDefinitionTokenizer as default } from './tokenizer'
+export { uniqueName as FootnoteDefinitionTokenizerName } from './types'
+export type {
+  IThis as IFootnoteDefinitionHookContext,
+  IToken as IFootnoteDefinitionToken,
+  ITokenizerProps as IFootnoteDefinitionTokenizerProps,
+} from './types'

package/src/match.ts

@@ -0,0 +1,115 @@
+import { FootnoteDefinitionType } from '@yozora/ast'
+import { AsciiCodePoint, calcStringFromNodePoints } from '@yozora/character'
+import type {
+  IMatchBlockHookCreator,
+  IPhrasingContentLine,
+  IResultOfEatContinuationText,
+  IResultOfEatOpener,
+  IResultOfOnClose,
+} from '@yozora/core-tokenizer'
+import { calcEndPoint, calcStartPoint, resolveLabelToIdentifier } from '@yozora/core-tokenizer'
+import type { IThis, IToken, T } from './types'
+import { eatFootnoteLabel } from './util'
+
+/**
+ * A footnote reference definition consists of a footnote label, indented up
+ * to three spaces, followed by a colon (:), optional whitespace (including up
+ * to one line ending), a footnote contents consisted by paragraph-like strings.
+ *
+ * Unlike the link label, the footnote label should be on the same line and it
+ * begins with a left bracket ([) followed by a caret (^), and ends with the
+ * first right bracket (]) that is not backslash-escaped. Between the caret of
+ * right bracket, there must be at least one non-whitespace character.
+ * Unescaped square bracket characters are not allowed inside the opening creat
+ * and closing square bracket of footnote labels. A footnote label can have at
+ * most 999 characters inside the caret and right bracket.
+ *
+ * @see https://github.github.com/gfm/#link-label
+ * @see https://github.github.com/gfm/#link-reference-definition
+ * @see https://github.com/syntax-tree/mdast-util-footnote
+ * @see https://github.com/remarkjs/remark-footnotes
+ * @see https://www.markdownguide.org/extended-syntax/#footnotes
+ */
+export const match: IMatchBlockHookCreator<T, IToken, IThis> = function (api) {
+  const { indent } = this
+  return {
+    isContainingBlock: true,
+    eatOpener,
+    eatContinuationText,
+    onClose,
+  }
+
+  function eatOpener(line: Readonly<IPhrasingContentLine>): IResultOfEatOpener<T, IToken> {
+    if (line.countOfPrecedeSpaces >= 4) return null
+
+    const { nodePoints, startIndex, firstNonWhitespaceIndex, endIndex } = line
+    const nextIndex = eatFootnoteLabel(nodePoints, firstNonWhitespaceIndex, endIndex)
+
+    // Try to match the following colon (:).
+    if (
+      nextIndex < 0 ||
+      nextIndex >= endIndex ||
+      nodePoints[nextIndex].codePoint !== AsciiCodePoint.COLON
+    ) {
+      return null
+    }
+
+    const token: IToken = {
+      nodeType: FootnoteDefinitionType,
+      position: {
+        start: calcStartPoint(nodePoints, startIndex),
+        end: calcEndPoint(nodePoints, nextIndex),
+      },
+      label: {
+        nodePoints,
+        startIndex: firstNonWhitespaceIndex,
+        endIndex: nextIndex,
+      },
+      children: [],
+    }
+    return { token, nextIndex: nextIndex + 1 }
+  }
+
+  function eatContinuationText(line: Readonly<IPhrasingContentLine>): IResultOfEatContinuationText {
+    const { startIndex, endIndex, firstNonWhitespaceIndex, countOfPrecedeSpaces } = line
+
+    // Blank line is allowed
+    if (firstNonWhitespaceIndex >= endIndex) {
+      return {
+        status: 'opening',
+        nextIndex: Math.min(endIndex - 1, startIndex + indent),
+      }
+    }
+
+    // Indent of a non-blank line is required.
+    if (countOfPrecedeSpaces >= indent) {
+      return { status: 'opening', nextIndex: startIndex + indent }
+    }
+
+    return { status: 'notMatched' }
+  }
+
+  function onClose(token: IToken): IResultOfOnClose {
+    /**
+     * Labels are trimmed and case-insensitive
+     * @see https://github.github.com/gfm/#example-174
+     * @see https://github.github.com/gfm/#example-175
+     */
+    const label = calcStringFromNodePoints(
+      token.label.nodePoints,
+      token.label.startIndex + 2,
+      token.label.endIndex - 1,
+    )
+    const identifier = resolveLabelToIdentifier(label)
+
+    // Register definition identifier.
+    api.registerFootnoteDefinitionIdentifier(identifier)
+
+    // Cache label and identifier for performance.
+
+    // eslint-disable-next-line no-param-reassign
+    token._label = label
+    // eslint-disable-next-line no-param-reassign
+    token._identifier = identifier
+  }
+}

package/src/parse.ts

@@ -0,0 +1,31 @@
+import type { Node } from '@yozora/ast'
+import { FootnoteDefinitionType } 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 label: string = token._label!
+        const identifier: string = token._identifier!
+
+        const children: Node[] = api.parseBlockTokens(token.children)
+        const node: INode = api.shouldReservePosition
+          ? {
+              type: FootnoteDefinitionType,
+              position: token.position,
+              identifier,
+              label,
+              children,
+            }
+          : {
+              type: FootnoteDefinitionType,
+              identifier,
+              label,
+              children,
+            }
+        return node
+      }),
+  }
+}

package/src/tokenizer.ts

@@ -0,0 +1,37 @@
+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 FootnoteDefinition.
+ * @see https://github.github.com/gfm/#link-label
+ * @see https://github.github.com/gfm/#link-reference-definition
+ * @see https://github.com/syntax-tree/mdast-util-footnote
+ * @see https://github.com/remarkjs/remark-footnotes
+ * @see https://www.markdownguide.org/extended-syntax/#footnotes
+ */
+export class FootnoteDefinitionTokenizer
+  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 readonly indent = 4
+
+  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,37 @@
+import type { FootnoteDefinition, FootnoteDefinitionType } from '@yozora/ast'
+import type { INodeInterval, INodePoint } from '@yozora/character'
+import type {
+  IBaseBlockTokenizerProps,
+  IPartialYastBlockToken,
+  ITokenizer,
+  IYastBlockToken,
+} from '@yozora/core-tokenizer'
+
+export type T = FootnoteDefinitionType
+export type INode = FootnoteDefinition
+export const uniqueName = '@yozora/tokenizer-footnote-definition'
+
+export interface IToken extends IPartialYastBlockToken<T> {
+  /**
+   * Footnote label
+   */
+  label: INodeInterval & { nodePoints: ReadonlyArray<INodePoint> }
+  /**
+   *
+   */
+  children: IYastBlockToken[]
+  /**
+   * Resolved definition label.
+   */
+  _label?: string
+  /**
+   * Resolved definition identifier.
+   */
+  _identifier?: string
+}
+
+export interface IThis extends ITokenizer {
+  indent: number
+}
+
+export type ITokenizerProps = Partial<IBaseBlockTokenizerProps>

package/src/util.ts

@@ -0,0 +1,58 @@
+import type { INodePoint } from '@yozora/character'
+import { AsciiCodePoint, VirtualCodePoint, isWhitespaceCharacter } from '@yozora/character'
+
+/**
+ * Try to match a footnote label.
+ *
+ * Unlike the link label, the footnote label should be on the same line and it
+ * begins with a left bracket ([) followed by a caret (^), and ends with the
+ * first right bracket (]) that is not backslash-escaped. Between the caret of
+ * right bracket, there must be at least one non-whitespace character.
+ * Unescaped square bracket characters are not allowed inside the opening creat
+ * and closing square bracket of footnote labels. A footnote label can have at
+ * most 999 characters inside the caret and right bracket.
+ *
+ * @param nodePoints
+ * @param firstNonWhitespaceIndex
+ * @param endIndex
+ * @see https://github.github.com/gfm/#link-label
+ */
+export function eatFootnoteLabel(
+  nodePoints: ReadonlyArray<INodePoint>,
+  firstNonWhitespaceIndex: number,
+  endIndex: number,
+): number {
+  let i = firstNonWhitespaceIndex
+
+  // Try to match an opening delimiter of a footnote label.
+  if (
+    i + 1 >= endIndex ||
+    nodePoints[i].codePoint !== AsciiCodePoint.OPEN_BRACKET ||
+    nodePoints[i + 1].codePoint !== AsciiCodePoint.CARET
+  ) {
+    return -1
+  }
+
+  let isEmpty = true
+  const lastIndex = Math.min(endIndex, i + 1 + 1000)
+  for (i += 2; i < lastIndex; ++i) {
+    const c = nodePoints[i].codePoint
+    switch (c) {
+      case AsciiCodePoint.BACKSLASH:
+        i += 1
+        break
+      case AsciiCodePoint.OPEN_BRACKET:
+        return -1
+      case AsciiCodePoint.CLOSE_BRACKET:
+        return isEmpty ? -1 : i + 1
+      case VirtualCodePoint.LINE_END:
+        return -1
+      default:
+        if (isEmpty && !isWhitespaceCharacter(c)) {
+          isEmpty = false
+        }
+    }
+  }
+
+  return -1
+}