@yozora/tokenizer-html-inline 2.1.3 → 2.1.5

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
-}