@yozora/tokenizer-table 2.0.4 → 2.0.5

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

@@ -180,7 +180,7 @@ const match = function (api) {
         for (let c = cells.length; c < columns.length; ++c) {
             const cell = {
                 nodeType: ast.TableCellType,
-                position: { start: Object.assign({}, endPoint), end: Object.assign({}, endPoint) },
+                position: { start: { ...endPoint }, end: { ...endPoint } },
                 lines: [],
             };
             cells.push(cell);
@@ -237,18 +237,17 @@ const uniqueName = '@yozora/tokenizer-table';
 
 class TableTokenizer 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.INTERRUPTABLE_BLOCK,
+            name: props.name ?? uniqueName,
+            priority: props.priority ?? coreTokenizer.TokenizerPriority.INTERRUPTABLE_BLOCK,
         });
-        this.match = match;
-        this.parse = parse;
     }
+    match = match;
+    parse = parse;
 }
 
 exports.TableTokenizer = TableTokenizer;
 exports.TableTokenizerName = uniqueName;
-exports["default"] = TableTokenizer;
+exports.default = TableTokenizer;
 exports.tableMatch = match;
 exports.tableParse = parse;

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

@@ -176,7 +176,7 @@ const match = function (api) {
         for (let c = cells.length; c < columns.length; ++c) {
             const cell = {
                 nodeType: TableCellType,
-                position: { start: Object.assign({}, endPoint), end: Object.assign({}, endPoint) },
+                position: { start: { ...endPoint }, end: { ...endPoint } },
                 lines: [],
             };
             cells.push(cell);
@@ -233,14 +233,13 @@ const uniqueName = '@yozora/tokenizer-table';
 
 class TableTokenizer 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.INTERRUPTABLE_BLOCK,
+            name: props.name ?? uniqueName,
+            priority: props.priority ?? TokenizerPriority.INTERRUPTABLE_BLOCK,
         });
-        this.match = match;
-        this.parse = parse;
     }
+    match = match;
+    parse = parse;
 }
 
 export { TableTokenizer, uniqueName as TableTokenizerName, TableTokenizer as default, match as tableMatch, parse as tableParse };

package/lib/types/index.d.ts

@@ -1,8 +1,8 @@
 import { IPartialYastBlockToken, ITokenizer, IBaseBlockTokenizerProps, IPhrasingContentLine, IMatchBlockHookCreator, IParseBlockHookCreator, BaseBlockTokenizer, IBlockTokenizer } from '@yozora/core-tokenizer';
 import { TableType, TableColumn, TableRowType, TableCellType, Position, Table } from '@yozora/ast';
 
-declare type T = TableType;
-declare type INode = Table;
+type T = TableType;
+type INode = Table;
 declare const uniqueName = "@yozora/tokenizer-table";
 interface IToken extends IPartialYastBlockToken<TableType> {
     /**
@@ -14,8 +14,8 @@ interface IToken extends IPartialYastBlockToken<TableType> {
      */
     rows: ITableRowToken[];
 }
-declare type IThis = ITokenizer;
-declare type ITokenizerProps = Partial<IBaseBlockTokenizerProps>;
+type IThis = ITokenizer;
+type ITokenizerProps = Partial<IBaseBlockTokenizerProps>;
 interface ITableRowToken extends IPartialYastBlockToken<TableRowType> {
     cells: ITableCellToken[];
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-table",
-  "version": "2.0.4",
+  "version": "2.0.5",
   "author": {
     "name": "guanghechen",
     "url": "https://github.com/guanghechen/"
@@ -11,33 +11,37 @@
     "directory": "tokenizers/table"
   },
   "homepage": "https://github.com/yozorajs/yozora/tree/release-2.x.x/tokenizers/table",
-  "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",
+    "@yozora/character": "^2.0.5",
+    "@yozora/core-tokenizer": "^2.0.5"
   },
-  "gitHead": "c980b95254394dcacba0cbb4bea251350b09397c"
+  "gitHead": "7ba3bab49fe65cf2f57082c0503af73da9356cf0"
 }

package/src/index.ts

@@ -0,0 +1,11 @@
+export { match as tableMatch } from './match'
+export { parse as tableParse } from './parse'
+export { TableTokenizer, TableTokenizer as default } from './tokenizer'
+export { uniqueName as TableTokenizerName } from './types'
+export type {
+  IThis as ITableHookContext,
+  ITableCellToken,
+  ITableRowToken,
+  IToken as ITableToken,
+  ITokenizerProps as ITableTokenizerProps,
+} from './types'

package/src/match.ts

@@ -0,0 +1,416 @@
+import type { AlignType, Point, TableColumn } from '@yozora/ast'
+import { TableCellType, TableRowType, TableType } from '@yozora/ast'
+import { AsciiCodePoint, isWhitespaceCharacter } from '@yozora/character'
+import type {
+  IMatchBlockHookCreator,
+  IPhrasingContentLine,
+  IResultOfEatAndInterruptPreviousSibling,
+  IResultOfEatLazyContinuationText,
+  IResultOfEatOpener,
+  IYastBlockToken,
+} from '@yozora/core-tokenizer'
+import { calcEndPoint, calcStartPoint } from '@yozora/core-tokenizer'
+import type { ITableCellToken, ITableRowToken, IThis, IToken, T } from './types'
+
+/**
+ * A table is an arrangement of data with rows and columns, consisting of
+ * a single header row, a delimiter row separating the header from the data,
+ * and zero or more data rows.
+ *
+ * Each row consists of cells containing arbitrary text, in which inlines
+ * are parsed, separated by pipes (|). A leading and trailing pipe is also
+ * recommended for clarity of reading, and if there’s otherwise parsing
+ * ambiguity. Spaces between pipes and cell content are trimmed. Block-level
+ * elements cannot be inserted in a table.
+ *
+ * @see https://github.github.com/gfm/#table
+ * @see https://github.com/syntax-tree/mdast#tablerow
+ * @see https://github.com/syntax-tree/mdast#tablecell
+ */
+export const match: IMatchBlockHookCreator<T, IToken, IThis> = function (api) {
+  return {
+    isContainingBlock: false,
+    eatOpener,
+    eatAndInterruptPreviousSibling,
+    eatLazyContinuationText,
+  }
+
+  function eatOpener(): IResultOfEatOpener<T, IToken> {
+    return null
+  }
+
+  function eatAndInterruptPreviousSibling(
+    line: Readonly<IPhrasingContentLine>,
+    prevSiblingToken: Readonly<IYastBlockToken>,
+  ): IResultOfEatAndInterruptPreviousSibling<T, IToken> {
+    /**
+     * Four spaces is too much
+     * @see https://github.github.com/gfm/#example-57
+     */
+    if (line.countOfPrecedeSpaces >= 4) return null
+
+    const { nodePoints, endIndex, firstNonWhitespaceIndex } = line
+    if (firstNonWhitespaceIndex >= endIndex) return null
+
+    const columns: TableColumn[] = []
+
+    /**
+     * eat leading optional pipe
+     */
+    let c = nodePoints[firstNonWhitespaceIndex].codePoint
+    let cIndex =
+      c === AsciiCodePoint.VERTICAL_SLASH ? firstNonWhitespaceIndex + 1 : firstNonWhitespaceIndex
+    for (; cIndex < endIndex; ) {
+      for (; cIndex < endIndex; ++cIndex) {
+        c = nodePoints[cIndex].codePoint
+        if (!isWhitespaceCharacter(c)) break
+      }
+      if (cIndex >= endIndex) break
+
+      // eat left optional colon
+      let leftColon = false
+      if (c === AsciiCodePoint.COLON) {
+        leftColon = true
+        cIndex += 1
+      }
+
+      let hyphenCount = 0
+      for (; cIndex < endIndex; ++cIndex) {
+        c = nodePoints[cIndex].codePoint
+        if (c !== AsciiCodePoint.MINUS_SIGN) break
+        hyphenCount += 1
+      }
+
+      // hyphen must be exist
+      if (hyphenCount <= 0) return null
+
+      // eat right optional colon
+      let rightColon = false
+      if (cIndex < endIndex && c === AsciiCodePoint.COLON) {
+        rightColon = true
+        cIndex += 1
+      }
+
+      // eating next pipe
+      for (; cIndex < endIndex; ++cIndex) {
+        c = nodePoints[cIndex].codePoint
+        if (isWhitespaceCharacter(c)) continue
+        if (c === AsciiCodePoint.VERTICAL_SLASH) {
+          cIndex += 1
+          break
+        }
+
+        // There are other non-white space characters
+        return null
+      }
+
+      let align: AlignType = null
+      if (leftColon && rightColon) align = 'center'
+      else if (leftColon) align = 'left'
+      else if (rightColon) align = 'right'
+      const column: TableColumn = { align }
+      columns.push(column)
+    }
+
+    if (columns.length <= 0) return null
+
+    const lines = api.extractPhrasingLines(prevSiblingToken)
+    if (lines == null || lines.length < 1) return null
+
+    /**
+     * The header row must match the delimiter row in the number of cells.
+     * If not, a table will not be recognized
+     * @see https://github.github.com/gfm/#example-203
+     */
+    let cellCount = 0,
+      hasNonWhitespaceBeforePipe = false
+    const previousLine = lines[lines.length - 1]
+    for (let pIndex = previousLine.startIndex; pIndex < previousLine.endIndex; ++pIndex) {
+      const p = nodePoints[pIndex]
+      if (isWhitespaceCharacter(p.codePoint)) continue
+
+      if (p.codePoint === AsciiCodePoint.VERTICAL_SLASH) {
+        if (hasNonWhitespaceBeforePipe || cellCount > 0) cellCount += 1
+        hasNonWhitespaceBeforePipe = false
+        continue
+      }
+
+      hasNonWhitespaceBeforePipe = true
+
+      /**
+       * Include a pipe in a cell’s content by escaping it,
+       * including inside other inline spans
+       */
+      if (p.codePoint === AsciiCodePoint.BACKSLASH) pIndex += 1
+    }
+    if (hasNonWhitespaceBeforePipe && columns.length > 1) cellCount += 1
+    if (cellCount !== columns.length) return null
+
+    const row = calcTableRow(previousLine, columns)
+    const nextIndex = endIndex
+    const token: IToken = {
+      nodeType: TableType,
+      position: {
+        start: calcStartPoint(previousLine.nodePoints, previousLine.startIndex),
+        end: calcEndPoint(nodePoints, nextIndex - 1),
+      },
+      columns,
+      rows: [row],
+    }
+    return {
+      token,
+      nextIndex,
+      remainingSibling: api.rollbackPhrasingLines(
+        lines.slice(0, lines.length - 1),
+        prevSiblingToken,
+      ),
+    }
+  }
+
+  function eatLazyContinuationText(
+    line: Readonly<IPhrasingContentLine>,
+    token: IToken,
+  ): IResultOfEatLazyContinuationText {
+    if (line.firstNonWhitespaceIndex >= line.endIndex) {
+      return { status: 'notMatched' }
+    }
+
+    const row = calcTableRow(line, token.columns)
+    if (row == null) return { status: 'notMatched' }
+
+    token.rows.push(row)
+    return { status: 'opening', nextIndex: line.endIndex }
+  }
+
+  // process table row
+  function calcTableRow(line: IPhrasingContentLine, columns: TableColumn[]): ITableRowToken {
+    const { nodePoints, startIndex, endIndex, firstNonWhitespaceIndex } = line
+
+    // eat leading pipe
+    let p = nodePoints[firstNonWhitespaceIndex]
+    let i =
+      p.codePoint === AsciiCodePoint.VERTICAL_SLASH
+        ? firstNonWhitespaceIndex + 1
+        : firstNonWhitespaceIndex
+
+    // eat table cells
+    const cells: ITableCellToken[] = []
+    for (; i < endIndex; i += 1) {
+      /**
+       * Spaces between pipes and cell content are trimmed
+       */
+      for (; i < endIndex; ++i) {
+        p = nodePoints[i]
+        if (!isWhitespaceCharacter(p.codePoint)) break
+      }
+
+      // Start point of the table-cell.
+      const startPoint: Point =
+        i < endIndex ? calcStartPoint(nodePoints, i) : calcEndPoint(nodePoints, endIndex - 1)
+
+      // Eating cell contents.
+      const cellStartIndex = i,
+        cellFirstNonWhitespaceIndex = i
+      for (; i < endIndex; ++i) {
+        p = nodePoints[i]
+        /**
+         * Include a pipe in a cell’s content by escaping it,
+         * including inside other inline spans
+         */
+        if (p.codePoint === AsciiCodePoint.BACKSLASH) {
+          i += 1
+          continue
+        }
+
+        // pipe are boundary character
+        if (p.codePoint === AsciiCodePoint.VERTICAL_SLASH) break
+      }
+      let cellEndIndex = i
+      for (; cellEndIndex > cellStartIndex; --cellEndIndex) {
+        const p = nodePoints[cellEndIndex - 1]
+        if (!isWhitespaceCharacter(p.codePoint)) break
+      }
+
+      // End point of the table-cell
+      const endPoint: Point = calcEndPoint(nodePoints, i - 1)
+
+      const lines: IPhrasingContentLine[] =
+        cellFirstNonWhitespaceIndex >= cellEndIndex
+          ? []
+          : [
+              {
+                nodePoints,
+                startIndex: cellStartIndex,
+                endIndex: cellEndIndex,
+                firstNonWhitespaceIndex: cellFirstNonWhitespaceIndex,
+                countOfPrecedeSpaces: cellFirstNonWhitespaceIndex - cellStartIndex,
+              },
+            ]
+
+      const cell: ITableCellToken = {
+        nodeType: TableCellType,
+        position: { start: startPoint, end: endPoint },
+        lines: lines,
+      }
+      cells.push(cell)
+
+      /**
+       * If there are greater, the excess is ignored
+       * @see https://github.github.com/gfm/#example-204
+       */
+      if (cells.length >= columns.length) break
+    }
+
+    // Start point of the table-row
+    const startPoint: Point = calcStartPoint(nodePoints, startIndex)
+
+    // End point of the table-row
+    const endPoint: Point = calcEndPoint(nodePoints, endIndex - 1)
+
+    /**
+     * The remainder of the table’s rows may vary in the number of cells.
+     * If there are a number of cells fewer than the number of cells in
+     * the header row, empty cells are inserted. If there are greater,
+     * the excess is ignored
+     * @see https://github.github.com/gfm/#example-204
+     */
+    for (let c = cells.length; c < columns.length; ++c) {
+      const cell: ITableCellToken = {
+        nodeType: TableCellType,
+        position: { start: { ...endPoint }, end: { ...endPoint } },
+        lines: [],
+      }
+      cells.push(cell)
+    }
+
+    const row: ITableRowToken = {
+      nodeType: TableRowType,
+      position: { start: startPoint, end: endPoint },
+      cells,
+    }
+    return row
+  }
+}
+
+/**
+ * Find delimiter row
+ *
+ * The delimiter row consists of cells whose only content are
+ * hyphens (-), and optionally, a leading or trailing colon (:),
+ * or both, to indicate left, right, or center alignment respectively.
+ * @see https://github.github.com/gfm/#delimiter-row
+ */
+// function calcTableColumn(
+//   nodePoints: ReadonlyArray<INodePoint>,
+//   currentLine: IPhrasingContentLine,
+//   previousLine: IPhrasingContentLine,
+// ): TableColumn[] | null {
+//   /**
+//    * The previous line of the delimiter line must not be blank line
+//    */
+//   if (previousLine.firstNonWhitespaceIndex >= previousLine.endIndex) {
+//     return null
+//   }
+
+//   /**
+//    * Four spaces is too much
+//    * @see https://github.github.com/gfm/#example-57
+//    */
+//   if (currentLine.firstNonWhitespaceIndex - currentLine.startIndex >= 4) return null
+
+//   const columns: TableColumn[] = []
+
+//   /**
+//    * eat leading optional pipe
+//    */
+//   let p = nodePoints[currentLine.firstNonWhitespaceIndex]
+//   let cIndex =
+//     p.codePoint === AsciiCodePoint.VERTICAL_SLASH
+//       ? currentLine.firstNonWhitespaceIndex + 1
+//       : currentLine.firstNonWhitespaceIndex
+
+//   for (; cIndex < currentLine.endIndex; ) {
+//     for (; cIndex < currentLine.endIndex; ++cIndex) {
+//       p = nodePoints[cIndex]
+//       if (!isWhitespaceCharacter(p.codePoint)) break
+//     }
+//     if (cIndex >= currentLine.endIndex) break
+
+//     // eat left optional colon
+//     let leftColon = false
+//     if (p.codePoint === AsciiCodePoint.COLON) {
+//       leftColon = true
+//       cIndex += 1
+//     }
+
+//     let hyphenCount = 0
+//     for (; cIndex < currentLine.endIndex; ++cIndex) {
+//       p = nodePoints[cIndex]
+//       if (p.codePoint !== AsciiCodePoint.MINUS_SIGN) break
+//       hyphenCount += 1
+//     }
+
+//     // hyphen must be exist
+//     if (hyphenCount <= 0) return null
+
+//     // eat right optional colon
+//     let rightColon = false
+//     if (cIndex < currentLine.endIndex && p.codePoint === AsciiCodePoint.COLON) {
+//       rightColon = true
+//       cIndex += 1
+//     }
+
+//     // eating next pipe
+//     for (; cIndex < currentLine.endIndex; ++cIndex) {
+//       p = nodePoints[cIndex]
+//       if (isWhitespaceCharacter(p.codePoint)) continue
+//       if (p.codePoint === AsciiCodePoint.VERTICAL_SLASH) {
+//         cIndex += 1
+//         break
+//       }
+
+//       // There are other non-white space characters
+//       return null
+//     }
+
+//     let align: AlignType = null
+//     if (leftColon && rightColon) align = 'center'
+//     else if (leftColon) align = 'left'
+//     else if (rightColon) align = 'right'
+//     const column: TableColumn = { align }
+//     columns.push(column)
+//   }
+
+//   if (columns.length <= 0) return null
+
+//   /**
+//    * The header row must match the delimiter row in the number of cells.
+//    * If not, a table will not be recognized
+//    * @see https://github.github.com/gfm/#example-203
+//    */
+//   let cellCount = 0,
+//     hasNonWhitespaceBeforePipe = false
+//   for (let pIndex = previousLine.startIndex; pIndex < previousLine.endIndex; ++pIndex) {
+//     const p = nodePoints[pIndex]
+//     if (isWhitespaceCharacter(p.codePoint)) continue
+
+//     if (p.codePoint === AsciiCodePoint.VERTICAL_SLASH) {
+//       if (hasNonWhitespaceBeforePipe || cellCount > 0) cellCount += 1
+//       hasNonWhitespaceBeforePipe = false
+//       continue
+//     }
+
+//     hasNonWhitespaceBeforePipe = true
+
+//     /**
+//      * Include a pipe in a cell’s content by escaping it,
+//      * including inside other inline spans
+//      */
+//     if (p.codePoint === AsciiCodePoint.BACKSLASH) pIndex += 1
+//   }
+//   if (hasNonWhitespaceBeforePipe && columns.length > 1) cellCount += 1
+//   if (cellCount !== columns.length) return null
+
+//   // Successfully matched to a legal table delimiter line
+//   return columns
+// }

package/src/parse.ts

@@ -0,0 +1,53 @@
+import type { Node, TableCell, TableRow } from '@yozora/ast'
+import { TableCellType, TableRowType, TableType } from '@yozora/ast'
+import type { INodePoint } from '@yozora/character'
+import { AsciiCodePoint } from '@yozora/character'
+import type { IParseBlockHookCreator } from '@yozora/core-tokenizer'
+import { mergeAndStripContentLines } from '@yozora/core-tokenizer'
+import type { INode, IThis, IToken, T } from './types'
+
+export const parse: IParseBlockHookCreator<T, IToken, INode, IThis> = api => ({
+  parse: tokens =>
+    tokens.map(token => {
+      const tableRows: TableRow[] = token.rows.map((row): TableRow => {
+        const tableCells: TableCell[] = row.cells.map((cell): TableCell => {
+          /**
+           * Include a pipe in a cell’s content by escaping it, including inside
+           * other inline spans
+           * @see https://github.github.com/gfm/#example-200
+           */
+          const contents: INodePoint[] = []
+          {
+            const nodePoints: INodePoint[] = mergeAndStripContentLines(cell.lines)
+            for (let i = 0, endIndex = nodePoints.length; i < endIndex; ++i) {
+              const p = nodePoints[i]
+              if (p.codePoint === AsciiCodePoint.BACKSLASH && i + 1 < endIndex) {
+                const q: INodePoint = nodePoints[i + 1]
+                if (q.codePoint !== AsciiCodePoint.VERTICAL_SLASH) contents.push(p)
+                contents.push(q)
+                i += 1
+              } else {
+                contents.push(p)
+              }
+            }
+          }
+
+          const children: Node[] = api.processInlines(contents)
+          const tableCell: TableCell = api.shouldReservePosition
+            ? { type: TableCellType, position: cell.position, children }
+            : { type: TableCellType, children }
+          return tableCell
+        })
+
+        const tableRow: TableRow = api.shouldReservePosition
+          ? { type: TableRowType, position: row.position, children: tableCells }
+          : { type: TableRowType, children: tableCells }
+        return tableRow
+      })
+
+      const table: INode = api.shouldReservePosition
+        ? { type: TableType, position: token.position, columns: token.columns, children: tableRows }
+        : { type: TableType, columns: token.columns, children: tableRows }
+      return table
+    }),
+})

package/src/tokenizer.ts

@@ -0,0 +1,33 @@
+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 Table, table-row and table-cell.
+ * @see https://github.github.com/gfm/#table
+ * @see https://github.com/syntax-tree/mdast#tablerow
+ * @see https://github.com/syntax-tree/mdast#tablecell
+ */
+export class TableTokenizer
+  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.INTERRUPTABLE_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,42 @@
+import type {
+  Position,
+  Table,
+  TableCellType,
+  TableColumn,
+  TableRowType,
+  TableType,
+} from '@yozora/ast'
+import type {
+  IBaseBlockTokenizerProps,
+  IPartialYastBlockToken,
+  IPhrasingContentLine,
+  ITokenizer,
+} from '@yozora/core-tokenizer'
+
+export type T = TableType
+export type INode = Table
+export const uniqueName = '@yozora/tokenizer-table'
+
+export interface IToken extends IPartialYastBlockToken<TableType> {
+  /**
+   * Table column configuration items
+   */
+  columns: TableColumn[]
+  /**
+   * Table rows
+   */
+  rows: ITableRowToken[]
+}
+
+export type IThis = ITokenizer
+
+export type ITokenizerProps = Partial<IBaseBlockTokenizerProps>
+
+export interface ITableRowToken extends IPartialYastBlockToken<TableRowType> {
+  cells: ITableCellToken[]
+}
+
+export interface ITableCellToken extends IPartialYastBlockToken<TableCellType> {
+  position: Position
+  lines: IPhrasingContentLine[]
+}