@yozora/tokenizer-fenced-block 2.1.2 → 2.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-fenced-block",
-  "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",
@@ -38,9 +38,9 @@
     "prepublishOnly": "cross-env ROLLUP_SHOULD_SOURCEMAP=false yarn build"
   },
   "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,8 +0,0 @@
-export { match as fencedBlockMatch } from './match'
-export { FencedBlockTokenizer, FencedBlockTokenizer as default } from './tokenizer'
-export { FencedBlockType } from './types'
-export type {
-  IFencedBlockHookContext,
-  IToken as IFencedBlockToken,
-  ITokenizerProps as IFencedBlockTokenizerProps,
-} from './types'

package/src/match.ts

@@ -1,170 +0,0 @@
-import type { NodeType } from '@yozora/ast'
-import type { INodePoint } from '@yozora/character'
-import { calcTrimBoundaryOfCodePoints, isSpaceCharacter } from '@yozora/character'
-import type {
-  IBlockToken,
-  IMatchBlockHook,
-  IMatchBlockPhaseApi,
-  IPhrasingContentLine,
-  IResultOfEatAndInterruptPreviousSibling,
-  IResultOfEatContinuationText,
-  IResultOfEatOpener,
-} from '@yozora/core-tokenizer'
-import { calcEndPoint, calcStartPoint, eatOptionalCharacters } from '@yozora/core-tokenizer'
-import type { IFencedBlockHookContext, IToken } from './types'
-
-export function match<
-  T extends NodeType = NodeType,
-  IThis extends IFencedBlockHookContext<T> = IFencedBlockHookContext<T>,
->(this: IThis, _api: IMatchBlockPhaseApi): IMatchBlockHook<T, IToken<T>> {
-  const { nodeType, markers, markersRequired, checkInfoString } = this
-  return {
-    isContainingBlock: false,
-    eatOpener,
-    eatAndInterruptPreviousSibling,
-    eatContinuationText,
-  }
-
-  function eatOpener(line: Readonly<IPhrasingContentLine>): IResultOfEatOpener<T, IToken<T>> {
-    /**
-     * Four spaces indentation produces an indented code block
-     * @see https://github.github.com/gfm/#example-104
-     */
-    if (line.countOfPrecedeSpaces >= 4) return null
-
-    const { endIndex, firstNonWhitespaceIndex } = line
-    if (firstNonWhitespaceIndex + markersRequired - 1 >= endIndex) return null
-
-    const { nodePoints, startIndex } = line
-    const marker: number = nodePoints[firstNonWhitespaceIndex].codePoint
-    if (markers.indexOf(marker) < 0) return null
-
-    const i = eatOptionalCharacters(nodePoints, firstNonWhitespaceIndex + 1, endIndex, marker)
-    const countOfMark = i - firstNonWhitespaceIndex
-
-    /**
-     * The number of marker is not enough.
-     * @see https://github.github.com/gfm/#example-91
-     */
-    if (countOfMark < markersRequired) return null
-
-    /**
-     * Eating Information string
-     * The line with the opening block fence may optionally contain some text
-     * following the block fence; this is trimmed of leading and trailing
-     * whitespace and called the info string. If the info string comes after
-     * a backtick fence, it may not contain any backtick characters. (The
-     * reason for this restriction is that otherwise some inline code would
-     * be incorrectly interpreted as the beginning of a fenced code block.)
-     * @see https://github.github.com/gfm/#info-string
-     */
-    const [iLft, iRht] = calcTrimBoundaryOfCodePoints(nodePoints, i, endIndex)
-    const infoString: INodePoint[] = nodePoints.slice(iLft, iRht)
-
-    /**
-     * Check if info string is valid, such as info strings for backtick code
-     * blocks cannot contain backticks.
-     * @see https://github.github.com/gfm/#example-115
-     * @see https://github.github.com/gfm/#example-116
-     */
-    if (checkInfoString != null && !checkInfoString(infoString, marker, countOfMark)) {
-      return null
-    }
-
-    const nextIndex = endIndex
-    const token: IToken<T> = {
-      nodeType: nodeType as T,
-      position: {
-        start: calcStartPoint(nodePoints, startIndex),
-        end: calcEndPoint(nodePoints, nextIndex - 1),
-      },
-      indent: firstNonWhitespaceIndex - startIndex,
-      marker: marker!,
-      markerCount: countOfMark,
-      lines: [],
-      infoString,
-    }
-    return { token, nextIndex }
-  }
-
-  function eatAndInterruptPreviousSibling(
-    line: Readonly<IPhrasingContentLine>,
-    prevSiblingToken: Readonly<IBlockToken>,
-  ): IResultOfEatAndInterruptPreviousSibling<T, IToken<T>> {
-    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<T>,
-  ): IResultOfEatContinuationText {
-    const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex, countOfPrecedeSpaces } = line
-
-    /**
-     * Check closing block fence
-     *
-     * The closing block fence may be indented up to three spaces, and may be
-     * followed only by spaces, which are ignored. If the end of the containing
-     * block (or document) is reached and no closing block fence has been found,
-     * the code block contains all of the lines after the opening block fence
-     * until the end of the containing block (or document). (An alternative spec
-     * would require backtracking in the event that a closing block fence is not
-     * found. But this makes parsing much less efficient, and there seems to be
-     * no real down side to the behavior described here.)
-     * @see https://github.github.com/gfm/#code-fence
-     *
-     * Closing fence indented with at most 3 spaces
-     * @see https://github.github.com/gfm/#example-107
-     */
-    if (countOfPrecedeSpaces < 4 && firstNonWhitespaceIndex < endIndex) {
-      let i = eatOptionalCharacters(nodePoints, firstNonWhitespaceIndex, endIndex, token.marker)
-      const markerCount = i - firstNonWhitespaceIndex
-
-      /**
-       * The closing block fence must be at least as long as the opening fence
-       * @see https://github.github.com/gfm/#example-94
-       */
-      if (markerCount >= token.markerCount) {
-        // The closing block fence may be followed only by spaces.
-        for (; i < endIndex; ++i) {
-          const c = nodePoints[i].codePoint
-          if (!isSpaceCharacter(c)) break
-        }
-
-        if (i + 1 >= endIndex) {
-          return { status: 'closing', nextIndex: endIndex }
-        }
-      }
-    }
-
-    /**
-     * Eating code content
-     *
-     * The content of the code block consists of all subsequent lines, until a
-     * closing block fence of the same type as the code block began with
-     * (backticks or tildes), and with at least as many backticks or tildes as
-     * the opening block fence. If the leading block fence is indented N spaces,
-     * then up to N spaces of indentation are removed from each line of the
-     * content (if present).
-     *
-     * If a content line is not indented, it is preserved unchanged. If it is
-     * indented less than N spaces, all of the indentation is removed, but the
-     * line feed should be preserve.
-     */
-    const firstIndex = Math.min(startIndex + token.indent, firstNonWhitespaceIndex, endIndex - 1)
-    token.lines.push({
-      nodePoints,
-      startIndex: firstIndex,
-      endIndex,
-      firstNonWhitespaceIndex,
-      countOfPrecedeSpaces,
-    })
-    return { status: 'opening', nextIndex: endIndex }
-  }
-}

package/src/tokenizer.ts

@@ -1,44 +0,0 @@
-import type { Node, NodeType } from '@yozora/ast'
-import type { ICodePoint } from '@yozora/character'
-import type { IBlockTokenizer, IMatchBlockHookCreator } from '@yozora/core-tokenizer'
-import { BaseBlockTokenizer, TokenizerPriority } from '@yozora/core-tokenizer'
-import { match } from './match'
-import type { IFencedBlockHookContext, IToken, ITokenizerProps } from './types'
-
-/**
- * Lexical Matcher for FencedBlock.
- *
- * A block fence is a sequence of fence-marker characters (different marker
- * cannot be mixed.) A fenced block begins with a block fence, indented no more
- * than three spaces.
- *
- * @see https://github.com/syntax-tree/mdast#code
- * @see https://github.github.com/gfm/#code-fence
- */
-export abstract class FencedBlockTokenizer<
-    T extends NodeType = NodeType,
-    INode extends Node<T> = Node<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: ICodePoint[] = []
-  protected readonly markersRequired: number
-  protected readonly checkInfoString: ITokenizerProps<T>['checkInfoString']
-
-  /* istanbul ignore next */
-  constructor(props: ITokenizerProps<T>) {
-    super({
-      name: props.name,
-      priority: props.priority ?? TokenizerPriority.FENCED_BLOCK,
-    })
-    this.nodeType = props.nodeType
-    this.markers = props.markers
-    this.markersRequired = props.markersRequired
-    this.checkInfoString = props.checkInfoString
-  }
-
-  public override readonly match: IMatchBlockHookCreator<T, IToken<T>, IThis> = match
-}

package/src/types.ts

@@ -1,91 +0,0 @@
-import type { NodeType } from '@yozora/ast'
-import type { ICodePoint, INodePoint } from '@yozora/character'
-import type {
-  IBaseBlockTokenizerProps,
-  IPartialBlockToken,
-  IPhrasingContentLine,
-  ITokenizer,
-} from '@yozora/core-tokenizer'
-
-export const FencedBlockType = 'fencedBlock'
-// eslint-disable-next-line @typescript-eslint/no-redeclare
-export type FencedBlockType = typeof FencedBlockType
-
-export interface IToken<T extends NodeType> extends IPartialBlockToken<T> {
-  /**
-   * Line indent of a fenced block.
-   */
-  indent: number
-  /**
-   * Fence marker.
-   */
-  marker: number
-  /**
-   * The number of fence marker.
-   */
-  markerCount: number
-  /**
-   * Lines to construct the contents of a paragraph.
-   */
-  lines: IPhrasingContentLine[]
-  /**
-   * Meta info string
-   */
-  infoString: INodePoint[]
-}
-
-export interface IFencedBlockHookContext<T extends NodeType> extends ITokenizer {
-  /**
-   * 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 NodeType> extends Partial<IBaseBlockTokenizerProps> {
-  /**
-   * ITokenizer name.
-   */
-  name: string
-  /**
-   * 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
-}