@yozora/tokenizer-footnote-definition 2.1.2 → 2.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-footnote-definition",
-  "version": "2.1.2",
+  "version": "2.1.4",
   "author": {
     "name": "guanghechen",
     "url": "https://github.com/guanghechen/"
@@ -27,7 +27,7 @@
   },
   "files": [
     "lib/",
-    "src/",
+    "lib/**/*.map",
     "package.json",
     "CHANGELOG.md",
     "LICENSE",
@@ -39,9 +39,9 @@
     "test": "cross-env TS_NODE_FILES=true NODE_OPTIONS=--experimental-vm-modules jest --config ../../jest.config.mjs --rootDir ."
   },
   "dependencies": {
-    "@yozora/ast": "^2.1.2",
-    "@yozora/character": "^2.1.2",
-    "@yozora/core-tokenizer": "^2.1.2"
+    "@yozora/ast": "^2.1.4",
+    "@yozora/character": "^2.1.4",
+    "@yozora/core-tokenizer": "^2.1.4"
   },
-  "gitHead": "992bacafd173e7788e99fed34ce8b45f6ed24cfe"
+  "gitHead": "aa464ed1e3cd84892773a833910cfc53a556bf5f"
 }

package/src/index.ts

@@ -1,10 +0,0 @@
-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

@@ -1,115 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,37 +0,0 @@
-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

@@ -1,37 +0,0 @@
-import type { FootnoteDefinition, FootnoteDefinitionType } from '@yozora/ast'
-import type { INodeInterval, INodePoint } from '@yozora/character'
-import type {
-  IBaseBlockTokenizerProps,
-  IBlockToken,
-  IPartialBlockToken,
-  ITokenizer,
-} from '@yozora/core-tokenizer'
-
-export type T = FootnoteDefinitionType
-export type INode = FootnoteDefinition
-export const uniqueName = '@yozora/tokenizer-footnote-definition'
-
-export interface IToken extends IPartialBlockToken<T> {
-  /**
-   * Footnote label
-   */
-  label: INodeInterval & { nodePoints: ReadonlyArray<INodePoint> }
-  /**
-   *
-   */
-  children: IBlockToken[]
-  /**
-   * 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

@@ -1,58 +0,0 @@
-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
-}