@alexlit/lint-kit 214.0.1 → 214.1.0

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/autolink.js

@@ -0,0 +1,269 @@
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {
+  asciiAlphanumeric,
+  asciiAlpha,
+  asciiAtext,
+  asciiControl
+} from 'micromark-util-character'
+import {codes, constants, types} from 'micromark-util-symbol'
+
+/** @type {Construct} */
+export const autolink = {name: 'autolink', tokenize: tokenizeAutolink}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeAutolink(effects, ok, nok) {
+  let size = 0
+
+  return start
+
+  /**
+   * Start of an autolink.
+   *
+   * ```markdown
+   * > | a<https://example.com>b
+   *      ^
+   * > | a<user@example.com>b
+   *      ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    assert(code === codes.lessThan, 'expected `<`')
+    effects.enter(types.autolink)
+    effects.enter(types.autolinkMarker)
+    effects.consume(code)
+    effects.exit(types.autolinkMarker)
+    effects.enter(types.autolinkProtocol)
+    return open
+  }
+
+  /**
+   * After `<`, at protocol or atext.
+   *
+   * ```markdown
+   * > | a<https://example.com>b
+   *       ^
+   * > | a<user@example.com>b
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function open(code) {
+    if (asciiAlpha(code)) {
+      effects.consume(code)
+      return schemeOrEmailAtext
+    }
+
+    if (code === codes.atSign) {
+      return nok(code)
+    }
+
+    return emailAtext(code)
+  }
+
+  /**
+   * At second byte of protocol or atext.
+   *
+   * ```markdown
+   * > | a<https://example.com>b
+   *        ^
+   * > | a<user@example.com>b
+   *        ^
+   * ```
+   *
+   * @type {State}
+   */
+  function schemeOrEmailAtext(code) {
+    // ASCII alphanumeric and `+`, `-`, and `.`.
+    if (
+      code === codes.plusSign ||
+      code === codes.dash ||
+      code === codes.dot ||
+      asciiAlphanumeric(code)
+    ) {
+      // Count the previous alphabetical from `open` too.
+      size = 1
+      return schemeInsideOrEmailAtext(code)
+    }
+
+    return emailAtext(code)
+  }
+
+  /**
+   * In ambiguous protocol or atext.
+   *
+   * ```markdown
+   * > | a<https://example.com>b
+   *        ^
+   * > | a<user@example.com>b
+   *        ^
+   * ```
+   *
+   * @type {State}
+   */
+  function schemeInsideOrEmailAtext(code) {
+    if (code === codes.colon) {
+      effects.consume(code)
+      size = 0
+      return urlInside
+    }
+
+    // ASCII alphanumeric and `+`, `-`, and `.`.
+    if (
+      (code === codes.plusSign ||
+        code === codes.dash ||
+        code === codes.dot ||
+        asciiAlphanumeric(code)) &&
+      size++ < constants.autolinkSchemeSizeMax
+    ) {
+      effects.consume(code)
+      return schemeInsideOrEmailAtext
+    }
+
+    size = 0
+    return emailAtext(code)
+  }
+
+  /**
+   * After protocol, in URL.
+   *
+   * ```markdown
+   * > | a<https://example.com>b
+   *             ^
+   * ```
+   *
+   * @type {State}
+   */
+  function urlInside(code) {
+    if (code === codes.greaterThan) {
+      effects.exit(types.autolinkProtocol)
+      effects.enter(types.autolinkMarker)
+      effects.consume(code)
+      effects.exit(types.autolinkMarker)
+      effects.exit(types.autolink)
+      return ok
+    }
+
+    // ASCII control, space, or `<`.
+    if (
+      code === codes.eof ||
+      code === codes.space ||
+      code === codes.lessThan ||
+      asciiControl(code)
+    ) {
+      return nok(code)
+    }
+
+    effects.consume(code)
+    return urlInside
+  }
+
+  /**
+   * In email atext.
+   *
+   * ```markdown
+   * > | a<user.name@example.com>b
+   *              ^
+   * ```
+   *
+   * @type {State}
+   */
+  function emailAtext(code) {
+    if (code === codes.atSign) {
+      effects.consume(code)
+      return emailAtSignOrDot
+    }
+
+    if (asciiAtext(code)) {
+      effects.consume(code)
+      return emailAtext
+    }
+
+    return nok(code)
+  }
+
+  /**
+   * In label, after at-sign or dot.
+   *
+   * ```markdown
+   * > | a<user.name@example.com>b
+   *                 ^       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function emailAtSignOrDot(code) {
+    return asciiAlphanumeric(code) ? emailLabel(code) : nok(code)
+  }
+
+  /**
+   * In label, where `.` and `>` are allowed.
+   *
+   * ```markdown
+   * > | a<user.name@example.com>b
+   *                   ^
+   * ```
+   *
+   * @type {State}
+   */
+  function emailLabel(code) {
+    if (code === codes.dot) {
+      effects.consume(code)
+      size = 0
+      return emailAtSignOrDot
+    }
+
+    if (code === codes.greaterThan) {
+      // Exit, then change the token type.
+      effects.exit(types.autolinkProtocol).type = types.autolinkEmail
+      effects.enter(types.autolinkMarker)
+      effects.consume(code)
+      effects.exit(types.autolinkMarker)
+      effects.exit(types.autolink)
+      return ok
+    }
+
+    return emailValue(code)
+  }
+
+  /**
+   * In label, where `.` and `>` are *not* allowed.
+   *
+   * Though, this is also used in `emailLabel` to parse other values.
+   *
+   * ```markdown
+   * > | a<user.name@ex-ample.com>b
+   *                    ^
+   * ```
+   *
+   * @type {State}
+   */
+  function emailValue(code) {
+    // ASCII alphanumeric or `-`.
+    if (
+      (code === codes.dash || asciiAlphanumeric(code)) &&
+      size++ < constants.autolinkDomainSizeMax
+    ) {
+      const next = code === codes.dash ? emailValue : emailLabel
+      effects.consume(code)
+      return next
+    }
+
+    return nok(code)
+  }
+}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/blank-line.d.ts

@@ -0,0 +1,4 @@
+/** @type {Construct} */
+export const blankLine: Construct;
+import type { Construct } from 'micromark-util-types';
+//# sourceMappingURL=blank-line.d.ts.map

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/blank-line.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"blank-line.d.ts","sourceRoot":"","sources":["blank-line.js"],"names":[],"mappings":"AAaA,wBAAwB;AACxB,wBADW,SAAS,CACiD;+BAR3D,sBAAsB"}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/blank-line.js

@@ -0,0 +1,62 @@
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {factorySpace} from 'micromark-factory-space'
+import {markdownLineEnding, markdownSpace} from 'micromark-util-character'
+import {codes, types} from 'micromark-util-symbol'
+
+/** @type {Construct} */
+export const blankLine = {partial: true, tokenize: tokenizeBlankLine}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeBlankLine(effects, ok, nok) {
+  return start
+
+  /**
+   * Start of blank line.
+   *
+   * > 👉 **Note**: `␠` represents a space character.
+   *
+   * ```markdown
+   * > | ␠␠␊
+   *     ^
+   * > | ␊
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    return markdownSpace(code)
+      ? factorySpace(effects, after, types.linePrefix)(code)
+      : after(code)
+  }
+
+  /**
+   * At eof/eol, after optional whitespace.
+   *
+   * > 👉 **Note**: `␠` represents a space character.
+   *
+   * ```markdown
+   * > | ␠␠␊
+   *       ^
+   * > | ␊
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function after(code) {
+    return code === codes.eof || markdownLineEnding(code) ? ok(code) : nok(code)
+  }
+}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/block-quote.d.ts

@@ -0,0 +1,4 @@
+/** @type {Construct} */
+export const blockQuote: Construct;
+import type { Construct } from 'micromark-util-types';
+//# sourceMappingURL=block-quote.d.ts.map

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/block-quote.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"block-quote.d.ts","sourceRoot":"","sources":["block-quote.js"],"names":[],"mappings":"AAeA,wBAAwB;AACxB,yBADW,SAAS,CAMnB;+BAdS,sBAAsB"}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/block-quote.js

@@ -0,0 +1,162 @@
+/**
+ * @import {
+ *   Construct,
+ *   Exiter,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {factorySpace} from 'micromark-factory-space'
+import {markdownSpace} from 'micromark-util-character'
+import {codes, constants, types} from 'micromark-util-symbol'
+
+/** @type {Construct} */
+export const blockQuote = {
+  continuation: {tokenize: tokenizeBlockQuoteContinuation},
+  exit,
+  name: 'blockQuote',
+  tokenize: tokenizeBlockQuoteStart
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeBlockQuoteStart(effects, ok, nok) {
+  const self = this
+
+  return start
+
+  /**
+   * Start of block quote.
+   *
+   * ```markdown
+   * > | > a
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    if (code === codes.greaterThan) {
+      const state = self.containerState
+
+      assert(state, 'expected `containerState` to be defined in container')
+
+      if (!state.open) {
+        effects.enter(types.blockQuote, {_container: true})
+        state.open = true
+      }
+
+      effects.enter(types.blockQuotePrefix)
+      effects.enter(types.blockQuoteMarker)
+      effects.consume(code)
+      effects.exit(types.blockQuoteMarker)
+      return after
+    }
+
+    return nok(code)
+  }
+
+  /**
+   * After `>`, before optional whitespace.
+   *
+   * ```markdown
+   * > | > a
+   *      ^
+   * ```
+   *
+   * @type {State}
+   */
+  function after(code) {
+    if (markdownSpace(code)) {
+      effects.enter(types.blockQuotePrefixWhitespace)
+      effects.consume(code)
+      effects.exit(types.blockQuotePrefixWhitespace)
+      effects.exit(types.blockQuotePrefix)
+      return ok
+    }
+
+    effects.exit(types.blockQuotePrefix)
+    return ok(code)
+  }
+}
+
+/**
+ * Start of block quote continuation.
+ *
+ * ```markdown
+ *   | > a
+ * > | > b
+ *     ^
+ * ```
+ *
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeBlockQuoteContinuation(effects, ok, nok) {
+  const self = this
+
+  return contStart
+
+  /**
+   * Start of block quote continuation.
+   *
+   * Also used to parse the first block quote opening.
+   *
+   * ```markdown
+   *   | > a
+   * > | > b
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function contStart(code) {
+    if (markdownSpace(code)) {
+      // Always populated by defaults.
+      assert(
+        self.parser.constructs.disable.null,
+        'expected `disable.null` to be populated'
+      )
+
+      return factorySpace(
+        effects,
+        contBefore,
+        types.linePrefix,
+        self.parser.constructs.disable.null.includes('codeIndented')
+          ? undefined
+          : constants.tabSize
+      )(code)
+    }
+
+    return contBefore(code)
+  }
+
+  /**
+   * At `>`, after optional whitespace.
+   *
+   * Also used to parse the first block quote opening.
+   *
+   * ```markdown
+   *   | > a
+   * > | > b
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function contBefore(code) {
+    return effects.attempt(blockQuote, ok, nok)(code)
+  }
+}
+
+/** @type {Exiter} */
+function exit(effects) {
+  effects.exit(types.blockQuote)
+}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/character-escape.d.ts

@@ -0,0 +1,4 @@
+/** @type {Construct} */
+export const characterEscape: Construct;
+import type { Construct } from 'micromark-util-types';
+//# sourceMappingURL=character-escape.d.ts.map

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/character-escape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-escape.d.ts","sourceRoot":"","sources":["character-escape.js"],"names":[],"mappings":"AAaA,wBAAwB;AACxB,8BADW,SAAS,CAInB;+BAXS,sBAAsB"}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/character-escape.js

@@ -0,0 +1,69 @@
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {asciiPunctuation} from 'micromark-util-character'
+import {codes, types} from 'micromark-util-symbol'
+
+/** @type {Construct} */
+export const characterEscape = {
+  name: 'characterEscape',
+  tokenize: tokenizeCharacterEscape
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeCharacterEscape(effects, ok, nok) {
+  return start
+
+  /**
+   * Start of character escape.
+   *
+   * ```markdown
+   * > | a\*b
+   *      ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    assert(code === codes.backslash, 'expected `\\`')
+    effects.enter(types.characterEscape)
+    effects.enter(types.escapeMarker)
+    effects.consume(code)
+    effects.exit(types.escapeMarker)
+    return inside
+  }
+
+  /**
+   * After `\`, at punctuation.
+   *
+   * ```markdown
+   * > | a\*b
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function inside(code) {
+    // ASCII punctuation.
+    if (asciiPunctuation(code)) {
+      effects.enter(types.characterEscapeValue)
+      effects.consume(code)
+      effects.exit(types.characterEscapeValue)
+      effects.exit(types.characterEscape)
+      return ok
+    }
+
+    return nok(code)
+  }
+}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/character-reference.d.ts

@@ -0,0 +1,4 @@
+/** @type {Construct} */
+export const characterReference: Construct;
+import type { Construct } from 'micromark-util-types';
+//# sourceMappingURL=character-reference.d.ts.map

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/character-reference.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"character-reference.d.ts","sourceRoot":"","sources":["character-reference.js"],"names":[],"mappings":"AAmBA,wBAAwB;AACxB,iCADW,SAAS,CAInB;+BAhBS,sBAAsB"}