@yozora/tokenizer-html-inline 2.1.2 → 2.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-html-inline",
-  "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,10 +39,10 @@
     "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/tokenizer-html-block": "^2.1.2"
+    "@yozora/ast": "^2.1.4",
+    "@yozora/character": "^2.1.4",
+    "@yozora/core-tokenizer": "^2.1.4",
+    "@yozora/tokenizer-html-block": "^2.1.4"
   },
-  "gitHead": "992bacafd173e7788e99fed34ce8b45f6ed24cfe"
+  "gitHead": "aa464ed1e3cd84892773a833910cfc53a556bf5f"
 }

package/src/index.ts

@@ -1,15 +0,0 @@
-export * from './util/cdata'
-export * from './util/closing'
-export * from './util/comment'
-export * from './util/declaration'
-export * from './util/instruction'
-export * from './util/open'
-export { match as htmlInlineMatch } from './match'
-export { parse as htmlInlineParse } from './parse'
-export { HtmlInlineTokenizer, HtmlInlineTokenizer as default } from './tokenizer'
-export { uniqueName as HtmlInlineTokenizerName } from './types'
-export type {
-  IThis as IHtmlInlineHookContext,
-  IToken as IHtmlInlineToken,
-  ITokenizerProps as IHtmlInlineTokenizerProps,
-} from './types'

package/src/match.ts

@@ -1,101 +0,0 @@
-import { HtmlType } from '@yozora/ast'
-import type { INodePoint } from '@yozora/character'
-import { AsciiCodePoint } from '@yozora/character'
-import type {
-  IMatchInlineHookCreator,
-  IResultOfProcessSingleDelimiter,
-} from '@yozora/core-tokenizer'
-import { eatOptionalWhitespaces, genFindDelimiter } from '@yozora/core-tokenizer'
-import type { IDelimiter, IThis, IToken, T } from './types'
-import { eatHtmlInlineCDataDelimiter } from './util/cdata'
-import { eatHtmlInlineClosingDelimiter } from './util/closing'
-import { eatHtmlInlineCommentDelimiter } from './util/comment'
-import { eatHtmlInlineDeclarationDelimiter } from './util/declaration'
-import { eatHtmlInlineInstructionDelimiter } from './util/instruction'
-import { eatHtmlInlineTokenOpenDelimiter } from './util/open'
-
-/**
- * Text between '<' and '>' that looks like an HTML tag is parsed as a raw HTML
- * tag and will be rendered in HTML without escaping. Tag and attribute names
- * are not limited to current HTML tags, so custom tags (and even, say, DocBook
- * tags) may be used.
- *
- * @see https://github.github.com/gfm/#raw-html
- */
-export const match: IMatchInlineHookCreator<T, IDelimiter, IToken, IThis> = function (api) {
-  return {
-    findDelimiter: () => genFindDelimiter<IDelimiter>(_findDelimiter),
-    processSingleDelimiter,
-  }
-
-  function _findDelimiter(startIndex: number, endIndex: number): IDelimiter | null {
-    const nodePoints: ReadonlyArray<INodePoint> = api.getNodePoints()
-
-    for (let i = startIndex; i < endIndex; ++i) {
-      i = eatOptionalWhitespaces(nodePoints, i, endIndex)
-      if (i >= endIndex) break
-
-      const c = nodePoints[i].codePoint
-      switch (c) {
-        case AsciiCodePoint.BACKSLASH:
-          i += 1
-          break
-        case AsciiCodePoint.OPEN_ANGLE: {
-          const delimiter: IDelimiter | null = tryToEatDelimiter(nodePoints, i, endIndex)
-          if (delimiter != null) return delimiter
-          break
-        }
-      }
-    }
-    return null
-  }
-
-  function processSingleDelimiter(
-    delimiter: IDelimiter,
-  ): IResultOfProcessSingleDelimiter<T, IToken> {
-    const token: IToken = {
-      ...delimiter,
-      nodeType: HtmlType,
-    }
-    return [token]
-  }
-}
-
-/**
- * Try to eat a delimiter
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- */
-function tryToEatDelimiter(
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-): IDelimiter | null {
-  let delimiter: IDelimiter | null = null
-
-  // Try open tag.
-  delimiter = eatHtmlInlineTokenOpenDelimiter(nodePoints, startIndex, endIndex)
-  if (delimiter != null) return delimiter
-
-  // Try closing tag.
-  delimiter = eatHtmlInlineClosingDelimiter(nodePoints, startIndex, endIndex)
-  if (delimiter != null) return delimiter
-
-  // Try html comment.
-  delimiter = eatHtmlInlineCommentDelimiter(nodePoints, startIndex, endIndex)
-  if (delimiter != null) return delimiter
-
-  // Try processing instruction.
-  delimiter = eatHtmlInlineInstructionDelimiter(nodePoints, startIndex, endIndex)
-  if (delimiter != null) return delimiter
-
-  // Try declaration.
-  delimiter = eatHtmlInlineDeclarationDelimiter(nodePoints, startIndex, endIndex)
-  if (delimiter != null) return delimiter
-
-  // Try CDATA section.
-  delimiter = eatHtmlInlineCDataDelimiter(nodePoints, startIndex, endIndex)
-  return delimiter
-}

package/src/parse.ts

@@ -1,20 +0,0 @@
-import { HtmlType } from '@yozora/ast'
-import type { INodePoint } from '@yozora/character'
-import { calcStringFromNodePoints } from '@yozora/character'
-import type { IParseInlineHookCreator } from '@yozora/core-tokenizer'
-import type { INode, IThis, IToken, T } from './types'
-
-export const parse: IParseInlineHookCreator<T, IToken, INode, IThis> = function (api) {
-  return {
-    parse: tokens =>
-      tokens.map(token => {
-        const { startIndex, endIndex } = token
-        const nodePoints: ReadonlyArray<INodePoint> = api.getNodePoints()
-        const value = calcStringFromNodePoints(nodePoints, startIndex, endIndex)
-        const node: INode = api.shouldReservePosition
-          ? { type: HtmlType, position: api.calcPosition(token), value }
-          : { type: HtmlType, value }
-        return node
-      }),
-  }
-}

package/src/tokenizer.ts

@@ -1,37 +0,0 @@
-import type {
-  IInlineTokenizer,
-  IMatchInlineHookCreator,
-  IParseInlineHookCreator,
-} from '@yozora/core-tokenizer'
-import { BaseInlineTokenizer, TokenizerPriority } from '@yozora/core-tokenizer'
-import { match } from './match'
-import { parse } from './parse'
-import type { IDelimiter, INode, IThis, IToken, ITokenizerProps, T } from './types'
-import { uniqueName } from './types'
-
-/**
- * Lexical Analyzer for HtmlInline.
- *
- * Text between '<' and '>' that looks like an HTML tag is parsed as a raw HTML
- * tag and will be rendered in HTML without escaping. Tag and attribute names
- * are not limited to current HTML tags, so custom tags (and even, say, DocBook
- * tags) may be used.
- *
- * @see https://github.github.com/gfm/#raw-html
- */
-export class HtmlInlineTokenizer
-  extends BaseInlineTokenizer<T, IDelimiter, IToken, INode, IThis>
-  implements IInlineTokenizer<T, IDelimiter, IToken, INode, IThis>
-{
-  /* istanbul ignore next */
-  constructor(props: ITokenizerProps = {}) {
-    super({
-      name: props.name ?? uniqueName,
-      priority: props.priority ?? TokenizerPriority.ATOMIC,
-    })
-  }
-
-  public override readonly match: IMatchInlineHookCreator<T, IDelimiter, IToken, IThis> = match
-
-  public override readonly parse: IParseInlineHookCreator<T, IToken, INode, IThis> = parse
-}

package/src/types.ts

@@ -1,52 +0,0 @@
-import type { Html, HtmlType } from '@yozora/ast'
-import type {
-  IBaseInlineTokenizerProps,
-  IPartialInlineToken,
-  ITokenizer,
-} from '@yozora/core-tokenizer'
-import type { IHtmlInlineCDataDelimiter, IHtmlInlineCDataTokenData } from './util/cdata'
-import type { IHtmlInlineClosingDelimiter, IHtmlInlineClosingTokenData } from './util/closing'
-import type { IHtmlInlineCommentDelimiter, IHtmlInlineCommentTokenData } from './util/comment'
-import type {
-  IHtmlInlineDeclarationDelimiter,
-  IHtmlInlineDeclarationTokenData,
-} from './util/declaration'
-import type {
-  IHtmlInlineInstructionDelimiter,
-  IHtmlInlineInstructionTokenData,
-} from './util/instruction'
-import type { IHtmlInlineOpenDelimiter, IHtmlInlineOpenTokenData } from './util/open'
-
-export type T = HtmlType
-export type INode = Html
-export const uniqueName = '@yozora/tokenizer-html-inline'
-
-/**
- * Text between '<' and '>' that looks like an HTML tag is parsed as a raw
- * HTML tag and will be rendered in HTML without escaping. Tag and attribute
- * names are not limited to current HTML tags, so custom tags (and even, say,
- * DocBook tags) may be used.
- *
- * @see https://github.github.com/gfm/#raw-html
- */
-export type IToken = IPartialInlineToken<T> &
-  (
-    | IHtmlInlineOpenTokenData
-    | IHtmlInlineClosingTokenData
-    | IHtmlInlineCommentTokenData
-    | IHtmlInlineInstructionTokenData
-    | IHtmlInlineDeclarationTokenData
-    | IHtmlInlineCDataTokenData
-  )
-
-export type IDelimiter =
-  | IHtmlInlineOpenDelimiter
-  | IHtmlInlineClosingDelimiter
-  | IHtmlInlineCommentDelimiter
-  | IHtmlInlineInstructionDelimiter
-  | IHtmlInlineDeclarationDelimiter
-  | IHtmlInlineCDataDelimiter
-
-export type IThis = ITokenizer
-
-export type ITokenizerProps = Partial<IBaseInlineTokenizerProps>

package/src/util/cdata.ts

@@ -1,64 +0,0 @@
-import type { INodePoint } from '@yozora/character'
-import { AsciiCodePoint } from '@yozora/character'
-import type { ITokenDelimiter } from '@yozora/core-tokenizer'
-
-export interface IHtmlInlineCDataData {
-  htmlType: 'cdata'
-}
-
-export interface IHtmlInlineCDataTokenData {
-  htmlType: 'cdata'
-}
-
-export interface IHtmlInlineCDataDelimiter extends ITokenDelimiter, IHtmlInlineCDataTokenData {
-  type: 'full'
-}
-
-/**
- * A CDATA section consists of the string `<![CDATA[`, a string of characters
- * not including the string `]]>`, and the string `]]>`.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#cdata-section
- */
-export function eatHtmlInlineCDataDelimiter(
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-): IHtmlInlineCDataDelimiter | null {
-  let i = startIndex
-  if (
-    i + 11 >= endIndex ||
-    nodePoints[i + 1].codePoint !== AsciiCodePoint.EXCLAMATION_MARK ||
-    nodePoints[i + 2].codePoint !== AsciiCodePoint.OPEN_BRACKET ||
-    nodePoints[i + 3].codePoint !== AsciiCodePoint.UPPERCASE_C ||
-    nodePoints[i + 4].codePoint !== AsciiCodePoint.UPPERCASE_D ||
-    nodePoints[i + 5].codePoint !== AsciiCodePoint.UPPERCASE_A ||
-    nodePoints[i + 6].codePoint !== AsciiCodePoint.UPPERCASE_T ||
-    nodePoints[i + 7].codePoint !== AsciiCodePoint.UPPERCASE_A ||
-    nodePoints[i + 8].codePoint !== AsciiCodePoint.OPEN_BRACKET
-  )
-    return null
-
-  const si = i + 9
-  for (i = si; i < endIndex; ++i) {
-    const p = nodePoints[i]
-    if (p.codePoint !== AsciiCodePoint.CLOSE_BRACKET) continue
-    if (i + 2 >= endIndex) return null
-    if (
-      nodePoints[i + 1].codePoint === AsciiCodePoint.CLOSE_BRACKET &&
-      nodePoints[i + 2].codePoint === AsciiCodePoint.CLOSE_ANGLE
-    ) {
-      const delimiter: IHtmlInlineCDataDelimiter = {
-        type: 'full',
-        startIndex,
-        endIndex: i + 3,
-        htmlType: 'cdata',
-      }
-      return delimiter
-    }
-  }
-  return null
-}

package/src/util/closing.ts

@@ -1,56 +0,0 @@
-import type { INodeInterval, INodePoint } from '@yozora/character'
-import { AsciiCodePoint } from '@yozora/character'
-import type { ITokenDelimiter } from '@yozora/core-tokenizer'
-import { eatOptionalWhitespaces } from '@yozora/core-tokenizer'
-import { eatHTMLTagName } from '@yozora/tokenizer-html-block'
-
-export interface IHtmlInlineClosingTagData {
-  htmlType: 'closing'
-  tagName: string
-}
-
-export interface IHtmlInlineClosingTokenData {
-  htmlType: 'closing'
-  tagName: INodeInterval
-}
-
-export interface IHtmlInlineClosingDelimiter extends ITokenDelimiter, IHtmlInlineClosingTokenData {
-  type: 'full'
-}
-
-/**
- * A closing tag consists of the string '</', a tag name, optional whitespace,
- * and the character '>'.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#closing-tag
- */
-export function eatHtmlInlineClosingDelimiter(
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-): IHtmlInlineClosingDelimiter | null {
-  let i = startIndex
-  if (i + 3 >= endIndex || nodePoints[i + 1].codePoint !== AsciiCodePoint.SLASH) return null
-
-  const tagNameStartIndex = i + 2
-  const tagNameEndIndex = eatHTMLTagName(nodePoints, tagNameStartIndex, endIndex)
-  if (tagNameEndIndex == null) return null
-
-  i = eatOptionalWhitespaces(nodePoints, tagNameEndIndex, endIndex)
-  if (i >= endIndex || nodePoints[i].codePoint !== AsciiCodePoint.CLOSE_ANGLE) return null
-
-  const delimiter: IHtmlInlineClosingDelimiter = {
-    type: 'full',
-    startIndex,
-    endIndex: i + 1,
-    htmlType: 'closing',
-    tagName: {
-      startIndex: tagNameStartIndex,
-      endIndex: tagNameEndIndex,
-    },
-  }
-  return delimiter
-}

package/src/util/comment.ts

@@ -1,87 +0,0 @@
-import type { INodePoint } from '@yozora/character'
-import { AsciiCodePoint } from '@yozora/character'
-import type { ITokenDelimiter } from '@yozora/core-tokenizer'
-
-export interface IHtmlInlineCommentData {
-  htmlType: 'comment'
-}
-
-export interface IHtmlInlineCommentTokenData {
-  htmlType: 'comment'
-}
-
-export interface IHtmlInlineCommentDelimiter extends ITokenDelimiter, IHtmlInlineCommentTokenData {
-  type: 'full'
-}
-
-/**
- * An HTML comment consists of `<!--` + text + `-->`, where text does not start
- * with `>` or `->`, does not end with `-`, and does not contain `--`.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#html-comment
- */
-export function eatHtmlInlineCommentDelimiter(
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-): IHtmlInlineCommentDelimiter | null {
-  let i = startIndex
-  if (
-    i + 6 >= endIndex ||
-    nodePoints[i + 1].codePoint !== AsciiCodePoint.EXCLAMATION_MARK ||
-    nodePoints[i + 2].codePoint !== AsciiCodePoint.MINUS_SIGN ||
-    nodePoints[i + 3].codePoint !== AsciiCodePoint.MINUS_SIGN
-  )
-    return null
-
-  // text dose not start with '>'
-  if (nodePoints[i + 4].codePoint === AsciiCodePoint.CLOSE_ANGLE) return null
-
-  // text dose not start with '->', and does not end with -
-  if (
-    nodePoints[i + 4].codePoint === AsciiCodePoint.MINUS_SIGN &&
-    nodePoints[i + 5].codePoint === AsciiCodePoint.CLOSE_ANGLE
-  )
-    return null
-
-  const si = i + 4
-  for (i = si; i < endIndex; ++i) {
-    const p = nodePoints[i]
-    if (p.codePoint !== AsciiCodePoint.MINUS_SIGN) continue
-
-    let hyphenCount = 1
-    for (; i + hyphenCount < endIndex; hyphenCount += 1) {
-      const q = nodePoints[i + hyphenCount]
-      if (q.codePoint !== AsciiCodePoint.MINUS_SIGN) break
-    }
-
-    /**
-     * Single hyphen is allowed.
-     * @see https://github.github.com/gfm/#example-644
-     */
-    if (hyphenCount < 2) continue
-
-    /**
-     * text does not contain '--' and does not end with -
-     * @see https://github.github.com/gfm/#example-645
-     */
-    if (
-      hyphenCount > 2 ||
-      i + 2 >= endIndex ||
-      nodePoints[i + 2].codePoint !== AsciiCodePoint.CLOSE_ANGLE
-    )
-      return null
-
-    const delimiter: IHtmlInlineCommentDelimiter = {
-      type: 'full',
-      startIndex,
-      endIndex: i + 3,
-      htmlType: 'comment',
-    }
-    return delimiter
-  }
-  return null
-}

package/src/util/declaration.ts

@@ -1,77 +0,0 @@
-import type { INodeInterval, INodePoint } from '@yozora/character'
-import { AsciiCodePoint, isAsciiUpperLetter, isWhitespaceCharacter } from '@yozora/character'
-import type { ITokenDelimiter } from '@yozora/core-tokenizer'
-
-export interface IHtmlInlineDeclarationData {
-  htmlType: 'declaration'
-}
-
-export interface IHtmlInlineDeclarationTokenData {
-  htmlType: 'declaration'
-  tagName: INodeInterval
-}
-
-export interface IHtmlInlineDeclarationDelimiter
-  extends ITokenDelimiter,
-    IHtmlInlineDeclarationTokenData {
-  type: 'full'
-}
-
-/**
- * A declaration consists of the string `<!`, a name consisting of one or more
- * uppercase ASCII letters, whitespace, a string of characters not including
- * the character `>`, and the character `>`.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#declaration
- */
-export function eatHtmlInlineDeclarationDelimiter(
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-): IHtmlInlineDeclarationDelimiter | null {
-  let i = startIndex
-  if (i + 4 >= endIndex || nodePoints[i + 1].codePoint !== AsciiCodePoint.EXCLAMATION_MARK)
-    return null
-
-  const tagNameStartIndex = i + 2
-
-  // Try to eating a declaration name.
-  for (i = tagNameStartIndex; i < endIndex; ++i) {
-    const p = nodePoints[i]
-    if (!isAsciiUpperLetter(p.codePoint)) break
-  }
-
-  /**
-   * If no uppercase name or a following whitespace exists,
-   * then it's not a valid declaration.
-   */
-  if (
-    i - tagNameStartIndex <= 0 ||
-    i + 1 >= endIndex ||
-    !isWhitespaceCharacter(nodePoints[i].codePoint)
-  )
-    return null
-
-  const tagNameEndIndex = i,
-    si = i + 1
-  for (i = si; i < endIndex; ++i) {
-    const p = nodePoints[i]
-    if (p.codePoint === AsciiCodePoint.CLOSE_ANGLE) {
-      const delimiter: IHtmlInlineDeclarationDelimiter = {
-        type: 'full',
-        startIndex,
-        endIndex: i + 1,
-        htmlType: 'declaration',
-        tagName: {
-          startIndex: tagNameStartIndex,
-          endIndex: tagNameEndIndex,
-        },
-      }
-      return delimiter
-    }
-  }
-  return null
-}

package/src/util/instruction.ts

@@ -1,56 +0,0 @@
-import type { INodePoint } from '@yozora/character'
-import { AsciiCodePoint } from '@yozora/character'
-import type { ITokenDelimiter } from '@yozora/core-tokenizer'
-
-/**
- *
- * @see https://github.github.com/gfm/#processing-instruction
- */
-export interface IHtmlInlineInstructionData {
-  htmlType: 'instruction'
-}
-
-export interface IHtmlInlineInstructionTokenData {
-  htmlType: 'instruction'
-}
-
-export interface IHtmlInlineInstructionDelimiter
-  extends ITokenDelimiter,
-    IHtmlInlineInstructionTokenData {
-  type: 'full'
-}
-
-/**
- * A processing instruction consists of the string `<?`, a string of characters
- * not including the string `?>`, and the string `?>`.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#processing-instruction
- */
-export function eatHtmlInlineInstructionDelimiter(
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-): IHtmlInlineInstructionDelimiter | null {
-  let i = startIndex
-  if (i + 3 >= endIndex || nodePoints[i + 1].codePoint !== AsciiCodePoint.QUESTION_MARK) return null
-
-  const si = i + 2
-  for (i = si; i < endIndex; ++i) {
-    const p = nodePoints[i]
-    if (p.codePoint !== AsciiCodePoint.QUESTION_MARK) continue
-    if (i + 1 >= endIndex) return null
-    if (nodePoints[i + 1].codePoint === AsciiCodePoint.CLOSE_ANGLE) {
-      const delimiter: IHtmlInlineInstructionDelimiter = {
-        type: 'full',
-        startIndex,
-        endIndex: i + 2,
-        htmlType: 'instruction',
-      }
-      return delimiter
-    }
-  }
-  return null
-}

package/src/util/open.ts

@@ -1,88 +0,0 @@
-import type { INodeInterval, INodePoint } from '@yozora/character'
-import { AsciiCodePoint } from '@yozora/character'
-import type { ITokenDelimiter } from '@yozora/core-tokenizer'
-import { eatOptionalWhitespaces } from '@yozora/core-tokenizer'
-import type { RawHTMLAttribute } from '@yozora/tokenizer-html-block'
-import { eatHTMLAttribute, eatHTMLTagName } from '@yozora/tokenizer-html-block'
-
-export interface IHtmlInlineOpenTagData {
-  htmlType: 'open'
-  /**
-   * HTML tag name.
-   */
-  tagName: string
-  /**
-   * HTML attributes.
-   */
-  attributes: Array<{ name: string; value?: string }>
-  /**
-   * Whether if a html tag is self closed.
-   */
-  selfClosed: boolean
-}
-
-export interface IHtmlInlineOpenTokenData {
-  htmlType: 'open'
-  tagName: INodeInterval
-  attributes: RawHTMLAttribute[]
-  selfClosed: boolean
-}
-
-export interface IHtmlInlineOpenDelimiter extends ITokenDelimiter, IHtmlInlineOpenTokenData {
-  type: 'full'
-}
-
-/**
- * An open tag consists of a '<' character, a tag name, zero or more attributes,
- * optional whitespace, an optional '/' character, and a '>' character.
- *
- * @param nodePoints
- * @param startIndex
- * @param endIndex
- * @see https://github.github.com/gfm/#open-tag
- */
-export function eatHtmlInlineTokenOpenDelimiter(
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-): IHtmlInlineOpenDelimiter | null {
-  let i = startIndex
-  if (i + 2 >= endIndex) return null
-
-  const tagNameStartIndex = i + 1
-  const tagNameEndIndex = eatHTMLTagName(nodePoints, tagNameStartIndex, endIndex)
-  if (tagNameEndIndex == null) return null
-
-  const attributes: RawHTMLAttribute[] = []
-  for (i = tagNameEndIndex; i < endIndex; ) {
-    const result = eatHTMLAttribute(nodePoints, i, endIndex)
-    if (result == null) break
-    attributes.push(result.attribute)
-    i = result.nextIndex
-  }
-
-  i = eatOptionalWhitespaces(nodePoints, i, endIndex)
-  if (i >= endIndex) return null
-
-  let selfClosed = false
-  if (nodePoints[i].codePoint === AsciiCodePoint.SLASH) {
-    i += 1
-    selfClosed = true
-  }
-
-  if (i >= endIndex || nodePoints[i].codePoint !== AsciiCodePoint.CLOSE_ANGLE) return null
-
-  const delimiter: IHtmlInlineOpenDelimiter = {
-    type: 'full',
-    startIndex,
-    endIndex: i + 1,
-    htmlType: 'open',
-    tagName: {
-      startIndex: tagNameStartIndex,
-      endIndex: tagNameEndIndex,
-    },
-    attributes,
-    selfClosed,
-  }
-  return delimiter
-}