@yozora/tokenizer-autolink 2.1.3 → 2.1.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yozora/tokenizer-autolink",
-  "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,12 +0,0 @@
-export * from './util/email'
-export * from './util/uri'
-export { match as autolinkMatch } from './match'
-export { parse as autolinkParse } from './parse'
-export { AutolinkTokenizer, AutolinkTokenizer as default } from './tokenizer'
-export { uniqueName as AutolinkTokenizerName } from './types'
-export type {
-  IThis as IAutolinkHookContext,
-  IToken as IAutolinkToken,
-  ITokenizerProps as IAutolinkTokenizerProps,
-  AutolinkContentType,
-} from './types'

package/src/match.ts

@@ -1,79 +0,0 @@
-import { LinkType } from '@yozora/ast'
-import type { INodePoint } from '@yozora/character'
-import { AsciiCodePoint } from '@yozora/character'
-import type {
-  IMatchInlineHookCreator,
-  IResultOfProcessSingleDelimiter,
-} from '@yozora/core-tokenizer'
-import { genFindDelimiter } from '@yozora/core-tokenizer'
-import type { AutolinkContentType, IContentHelper, IDelimiter, IThis, IToken, T } from './types'
-import { eatEmailAddress } from './util/email'
-import { eatAbsoluteUri } from './util/uri'
-
-const helpers: ReadonlyArray<IContentHelper> = [
-  { contentType: 'uri', eat: eatAbsoluteUri },
-  { contentType: 'email', eat: eatEmailAddress },
-]
-
-/**
- * Autolinks are absolute URIs and email addresses inside '<' and '>'.
- * They are parsed as links, with the URL or email address as the link label.
- *
- * @see https://github.github.com/gfm/#autolink
- */
-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) {
-      if (nodePoints[i].codePoint !== AsciiCodePoint.OPEN_ANGLE) continue
-
-      let nextIndex: number = endIndex
-      let contentType: AutolinkContentType | null = null
-      for (const helper of helpers) {
-        const eatResult = helper.eat(nodePoints, i + 1, endIndex)
-        nextIndex = Math.min(nextIndex, eatResult.nextIndex)
-        if (eatResult.valid) {
-          contentType = helper.contentType
-          nextIndex = eatResult.nextIndex
-          break
-        }
-      }
-
-      // Optimization: move forward to the next latest potential position.
-      if (contentType == null) {
-        i = Math.max(i, nextIndex - 1)
-        continue
-      }
-
-      if (nextIndex < endIndex && nodePoints[nextIndex].codePoint === AsciiCodePoint.CLOSE_ANGLE) {
-        return {
-          type: 'full',
-          startIndex: i,
-          endIndex: nextIndex + 1,
-          contentType,
-        }
-      }
-      i = nextIndex - 1
-    }
-    return null
-  }
-
-  function processSingleDelimiter(
-    delimiter: IDelimiter,
-  ): IResultOfProcessSingleDelimiter<T, IToken> {
-    const token: IToken = {
-      nodeType: LinkType,
-      startIndex: delimiter.startIndex,
-      endIndex: delimiter.endIndex,
-      contentType: delimiter.contentType,
-      children: api.resolveFallbackTokens([], delimiter.startIndex + 1, delimiter.endIndex - 1),
-    }
-    return [token]
-  }
-}

package/src/parse.ts

@@ -1,31 +0,0 @@
-import type { Node } from '@yozora/ast'
-import { LinkType } from '@yozora/ast'
-import type { INodePoint } from '@yozora/character'
-import { calcStringFromNodePoints } from '@yozora/character'
-import type { IParseInlineHookCreator } from '@yozora/core-tokenizer'
-import { encodeLinkDestination } 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 nodePoints: ReadonlyArray<INodePoint> = api.getNodePoints()
-
-        // Backslash-escapes do not work inside autolink.
-        let url = calcStringFromNodePoints(nodePoints, token.startIndex + 1, token.endIndex - 1)
-
-        // Add 'mailto:' prefix to email address type autolink.
-        if (token.contentType === 'email') {
-          url = 'mailto:' + url
-        }
-
-        const encodedUrl = encodeLinkDestination(url)
-        const children: Node[] = api.parseInlineTokens(token.children)
-        const node: INode = api.shouldReservePosition
-          ? { type: LinkType, position: api.calcPosition(token), url: encodedUrl, children }
-          : { type: LinkType, url: encodedUrl, children }
-        return node
-      }),
-  }
-}

package/src/tokenizer.ts

@@ -1,36 +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 Autolink.
- * @see https://github.github.com/gfm/#autolink
- */
-export class AutolinkTokenizer
-  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,
-      /**
-       * Autolink has the same priority as inline-code.
-       * @see https://github.github.com/gfm/#example-355
-       * @see https://github.github.com/gfm/#example-356
-       */
-      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,46 +0,0 @@
-import type { Link, LinkType } from '@yozora/ast'
-import type { INodePoint } from '@yozora/character'
-import type {
-  IBaseInlineTokenizerProps,
-  IPartialInlineToken,
-  IResultOfRequiredEater,
-  ITokenDelimiter,
-  ITokenizer,
-} from '@yozora/core-tokenizer'
-
-// Content type of autolink
-export type AutolinkContentType = 'uri' | 'email'
-
-export type T = LinkType
-export type INode = Link
-export const uniqueName = '@yozora/tokenizer-autolink'
-
-export interface IToken extends IPartialInlineToken<T> {
-  /**
-   * Autolink content type: absolute uri or email.
-   */
-  contentType: AutolinkContentType
-}
-
-export interface IDelimiter extends ITokenDelimiter {
-  type: 'full'
-  /**
-   * Autolink content type: absolute uri or email.
-   */
-  contentType: AutolinkContentType
-}
-
-export type IThis = ITokenizer
-
-export type ITokenizerProps = Partial<IBaseInlineTokenizerProps>
-
-export type ContentEater = (
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-) => IResultOfRequiredEater
-
-export interface IContentHelper {
-  contentType: AutolinkContentType
-  eat: ContentEater
-}

package/src/util/email.ts

@@ -1,99 +0,0 @@
-import type { INodePoint } from '@yozora/character'
-import {
-  AsciiCodePoint,
-  isAlphanumeric,
-  isAsciiDigitCharacter,
-  isAsciiLetter,
-} from '@yozora/character'
-import type { IResultOfOptionalEater, IResultOfRequiredEater } from '@yozora/core-tokenizer'
-
-/**
- * An email address, for these purposes, is anything that matches the
- * non-normative regex from the HTML5 spec:
- *
- *  /^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}
- *   [a-zA-Z0-9])?(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$/
- *
- * @see https://github.github.com/gfm/#email-address
- */
-export function eatEmailAddress(
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-): IResultOfRequiredEater {
-  let i = startIndex
-
-  // Match /[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+/
-  for (; i < endIndex; i += 1) {
-    const c = nodePoints[i].codePoint
-    if (isAsciiLetter(c) || isAsciiDigitCharacter(c)) continue
-    if (
-      c !== AsciiCodePoint.DOT &&
-      c !== AsciiCodePoint.EXCLAMATION_MARK &&
-      c !== AsciiCodePoint.NUMBER_SIGN &&
-      c !== AsciiCodePoint.DOLLAR_SIGN &&
-      c !== AsciiCodePoint.PERCENT_SIGN &&
-      c !== AsciiCodePoint.AMPERSAND &&
-      c !== AsciiCodePoint.SINGLE_QUOTE &&
-      c !== AsciiCodePoint.ASTERISK &&
-      c !== AsciiCodePoint.PLUS_SIGN &&
-      c !== AsciiCodePoint.SLASH &&
-      c !== AsciiCodePoint.EQUALS_SIGN &&
-      c !== AsciiCodePoint.QUESTION_MARK &&
-      c !== AsciiCodePoint.CARET &&
-      c !== AsciiCodePoint.UNDERSCORE &&
-      c !== AsciiCodePoint.BACKTICK &&
-      c !== AsciiCodePoint.OPEN_BRACE &&
-      c !== AsciiCodePoint.VERTICAL_SLASH &&
-      c !== AsciiCodePoint.CLOSE_BRACE &&
-      c !== AsciiCodePoint.TILDE &&
-      c !== AsciiCodePoint.MINUS_SIGN
-    )
-      break
-  }
-
-  if (
-    i === startIndex ||
-    i + 1 >= endIndex ||
-    nodePoints[i].codePoint !== AsciiCodePoint.AT_SIGN ||
-    !isAlphanumeric(nodePoints[i + 1].codePoint)
-  )
-    return { valid: false, nextIndex: i + 1 }
-
-  i = eatAddressPart0(nodePoints, i + 2, endIndex)
-
-  // Match /(?:\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*/
-  for (; i + 1 < endIndex; ) {
-    let c = nodePoints[i].codePoint
-    if (c !== AsciiCodePoint.DOT) break
-
-    c = nodePoints[i + 1].codePoint
-    if (!isAsciiLetter(c) && !isAsciiDigitCharacter(c)) break
-    i = eatAddressPart0(nodePoints, i + 2, endIndex)
-  }
-
-  return { valid: true, nextIndex: i }
-}
-
-/**
- * Match regex /(?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?/
- *
- */
-function eatAddressPart0(
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-): IResultOfOptionalEater {
-  let i = startIndex,
-    result = -1
-
-  for (let _endIndex = Math.min(endIndex, i + 62); i < _endIndex; ++i) {
-    const c = nodePoints[i].codePoint
-    if (isAsciiLetter(c) || isAsciiDigitCharacter(c)) {
-      result = i
-      continue
-    }
-    if (c !== AsciiCodePoint.MINUS_SIGN) break
-  }
-  return result >= startIndex ? result + 1 : startIndex
-}

package/src/util/uri.ts

@@ -1,84 +0,0 @@
-import type { INodePoint } from '@yozora/character'
-import {
-  AsciiCodePoint,
-  isAlphanumeric,
-  isAsciiCharacter,
-  isAsciiControlCharacter,
-  isAsciiLetter,
-  isWhitespaceCharacter,
-} from '@yozora/character'
-import type { IResultOfRequiredEater } from '@yozora/core-tokenizer'
-
-/**
- * Try to find to autolink absolute uri strictly start from the give `startIndex`.
- *
- * An absolute URI, for these purposes, consists of a scheme followed by a
- * colon (:) followed by zero or more characters other than ASCII whitespace
- * and control characters, `<`, and `>`. If the URI includes these characters,
- * they must be percent-encoded (e.g. %20 for a space).
- *
- * @see https://github.github.com/gfm/#absolute-uri
- */
-export function eatAbsoluteUri(
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-): IResultOfRequiredEater {
-  const schema = eatAutolinkSchema(nodePoints, startIndex, endIndex)
-  let { nextIndex } = schema
-
-  if (
-    !schema.valid ||
-    nextIndex >= endIndex ||
-    nodePoints[nextIndex].codePoint !== AsciiCodePoint.COLON
-  )
-    return { valid: false, nextIndex }
-
-  for (nextIndex += 1; nextIndex < endIndex; ++nextIndex) {
-    const c = nodePoints[nextIndex].codePoint
-    if (
-      !isAsciiCharacter(c) ||
-      isWhitespaceCharacter(c) ||
-      isAsciiControlCharacter(c) ||
-      c === AsciiCodePoint.OPEN_ANGLE ||
-      c === AsciiCodePoint.CLOSE_ANGLE
-    )
-      break
-  }
-  return { valid: true, nextIndex }
-}
-
-/**
- * Try to find to autolink schema strictly start from the give `startIndex`.
- *
- * A scheme is any sequence of 2–32 characters beginning with an ASCII letter
- * and followed by any combination of ASCII letters, digits, or the symbols
- * plus (`+`), period (`.`), or hyphen (`-`).
- *
- * @see https://github.github.com/gfm/#scheme
- */
-export function eatAutolinkSchema(
-  nodePoints: ReadonlyArray<INodePoint>,
-  startIndex: number,
-  endIndex: number,
-): IResultOfRequiredEater {
-  let i = startIndex
-  const c = nodePoints[i].codePoint
-  if (!isAsciiLetter(c)) return { valid: false, nextIndex: i + 1 }
-
-  for (i += 1; i < endIndex; ++i) {
-    const d = nodePoints[i].codePoint
-    if (
-      isAlphanumeric(d) ||
-      d === AsciiCodePoint.PLUS_SIGN ||
-      d === AsciiCodePoint.DOT ||
-      d === AsciiCodePoint.MINUS_SIGN
-    )
-      continue
-    break
-  }
-
-  const count = i - startIndex
-  if (count < 2 || count > 32) return { valid: false, nextIndex: i + 1 }
-  return { valid: true, nextIndex: i }
-}