@yozora/tokenizer-indented-code 2.1.3 → 2.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-indented-code",
-  "version": "2.1.3",
+  "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.3",
-    "@yozora/character": "^2.1.3",
-    "@yozora/core-tokenizer": "^2.1.3"
+    "@yozora/ast": "^2.1.4",
+    "@yozora/character": "^2.1.4",
+    "@yozora/core-tokenizer": "^2.1.4"
   },
-  "gitHead": "9abaaff74a12d0bae0f645813241ff947a0d828c"
+  "gitHead": "aa464ed1e3cd84892773a833910cfc53a556bf5f"
 }

package/src/index.ts

@@ -1,9 +0,0 @@
-export { match as indentedCodeMatch } from './match'
-export { parse as indentedCodeParse } from './parse'
-export { IndentedCodeTokenizer, IndentedCodeTokenizer as default } from './tokenizer'
-export { uniqueName as IndentedCodeTokenizerName } from './types'
-export type {
-  IThis as IIndentedCodeHookContext,
-  IToken as IIndentedCodeToken,
-  ITokenizerProps as IIndentedCodeTokenizerProps,
-} from './types'

package/src/match.ts

@@ -1,94 +0,0 @@
-import { CodeType } from '@yozora/ast'
-import { AsciiCodePoint, VirtualCodePoint } from '@yozora/character'
-import type {
-  IMatchBlockHookCreator,
-  IPhrasingContentLine,
-  IResultOfEatContinuationText,
-  IResultOfEatOpener,
-} from '@yozora/core-tokenizer'
-import { calcEndPoint, calcStartPoint } from '@yozora/core-tokenizer'
-import type { IThis, IToken, T } from './types'
-
-/**
- * An indented code block is composed of one or more indented chunks
- * separated by blank lines. An indented chunk is a sequence of non-blank
- * lines, each indented four or more spaces. The contents of the code block
- * are the literal contents of the lines, including trailing line endings,
- * minus four spaces of indentation.
- *
- * @see https://github.github.com/gfm/#indented-code-block
- */
-export const match: IMatchBlockHookCreator<T, IToken, IThis> = function () {
-  return {
-    isContainingBlock: false,
-    eatOpener,
-    eatContinuationText,
-  }
-
-  function eatOpener(line: Readonly<IPhrasingContentLine>): IResultOfEatOpener<T, IToken> {
-    if (line.countOfPrecedeSpaces < 4) return null
-    const { nodePoints, startIndex, firstNonWhitespaceIndex, endIndex } = line
-
-    let firstIndex = startIndex + 4
-
-    /**
-     * If there exists 1-3 spaces before a tab forms the indent, the remain
-     * virtual spaces of the tab should not be a part of the contents.
-     * @see https://github.github.com/gfm/#example-2
-     */
-    if (
-      nodePoints[startIndex].codePoint === AsciiCodePoint.SPACE &&
-      nodePoints[startIndex + 3].codePoint === VirtualCodePoint.SPACE
-    ) {
-      let i = startIndex + 1
-      for (; i < firstNonWhitespaceIndex; ++i) {
-        if (nodePoints[i].codePoint === VirtualCodePoint.SPACE) break
-      }
-      firstIndex = i + 4
-    }
-
-    const nextIndex = endIndex
-    const token: IToken = {
-      nodeType: CodeType,
-      position: {
-        start: calcStartPoint(nodePoints, startIndex),
-        end: calcEndPoint(nodePoints, nextIndex - 1),
-      },
-      lines: [
-        {
-          nodePoints,
-          startIndex: firstIndex,
-          endIndex,
-          firstNonWhitespaceIndex,
-          countOfPrecedeSpaces: line.countOfPrecedeSpaces - (firstIndex - startIndex),
-        },
-      ],
-    }
-    return { token, nextIndex }
-  }
-
-  function eatContinuationText(
-    line: Readonly<IPhrasingContentLine>,
-    token: IToken,
-  ): IResultOfEatContinuationText {
-    const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex, countOfPrecedeSpaces } = line
-
-    if (countOfPrecedeSpaces < 4 && firstNonWhitespaceIndex < endIndex)
-      return { status: 'notMatched' }
-
-    /**
-     * Blank line is allowed
-     * @see https://github.github.com/gfm/#example-81
-     * @see https://github.github.com/gfm/#example-82
-     */
-    const firstIndex = Math.min(endIndex - 1, startIndex + 4)
-    token.lines.push({
-      nodePoints,
-      startIndex: firstIndex,
-      endIndex,
-      firstNonWhitespaceIndex,
-      countOfPrecedeSpaces: countOfPrecedeSpaces - (firstIndex - startIndex),
-    })
-    return { status: 'opening', nextIndex: endIndex }
-  }
-}

package/src/parse.ts

@@ -1,54 +0,0 @@
-import { CodeType } from '@yozora/ast'
-import type { INodePoint } from '@yozora/character'
-import { calcStringFromNodePoints } from '@yozora/character'
-import type { IParseBlockHookCreator } from '@yozora/core-tokenizer'
-import { mergeContentLinesFaithfully } 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 => {
-        /**
-         * Blank lines preceding or following an indented code block
-         * are not included in it
-         * @see https://github.github.com/gfm/#example-87
-         */
-        const { lines } = token
-        let startLineIndex = 0,
-          endLineIndex = lines.length
-        for (; startLineIndex < endLineIndex; ++startLineIndex) {
-          const line = lines[startLineIndex]
-          if (line.firstNonWhitespaceIndex < line.endIndex) break
-        }
-        for (; startLineIndex < endLineIndex; --endLineIndex) {
-          const line = lines[endLineIndex - 1]
-          if (line.firstNonWhitespaceIndex < line.endIndex) break
-        }
-
-        const contents: INodePoint[] = mergeContentLinesFaithfully(
-          lines,
-          startLineIndex,
-          endLineIndex,
-        )
-
-        let value: string = calcStringFromNodePoints(contents)
-        if (!/\n$/.test(value)) value += '\n'
-        const node: INode = api.shouldReservePosition
-          ? {
-              type: CodeType,
-              position: token.position,
-              lang: null,
-              meta: null,
-              value,
-            }
-          : {
-              type: CodeType,
-              lang: null,
-              meta: null,
-              value,
-            }
-        return node
-      }),
-  }
-}

package/src/tokenizer.ts

@@ -1,31 +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 IndentedCode.
- * @see https://github.github.com/gfm/#indented-code-block
- */
-export class IndentedCodeTokenizer
-  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.ATOMIC,
-    })
-  }
-
-  public override readonly match: IMatchBlockHookCreator<T, IToken, IThis> = match
-
-  public override readonly parse: IParseBlockHookCreator<T, IToken, INode, IThis> = parse
-}

package/src/types.ts

@@ -1,22 +0,0 @@
-import type { Code, CodeType } from '@yozora/ast'
-import type {
-  IBaseBlockTokenizerProps,
-  IPartialBlockToken,
-  IPhrasingContentLine,
-  ITokenizer,
-} from '@yozora/core-tokenizer'
-
-export type T = CodeType
-export type INode = Code
-export const uniqueName = '@yozora/tokenizer-indented-code'
-
-export interface IToken extends IPartialBlockToken<T> {
-  /**
-   * Lines to construct the contents of a paragraph.
-   */
-  lines: IPhrasingContentLine[]
-}
-
-export type IThis = ITokenizer
-
-export type ITokenizerProps = Partial<IBaseBlockTokenizerProps>