@alexlit/lint-kit 214.0.1 → 214.1.0

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/label-start-image.js

@@ -0,0 +1,119 @@
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   Token,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {codes, types} from 'micromark-util-symbol'
+import {labelEnd} from './label-end.js'
+
+/** @type {Construct} */
+export const labelStartImage = {
+  name: 'labelStartImage',
+  resolveAll: labelEnd.resolveAll,
+  tokenize: tokenizeLabelStartImage
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeLabelStartImage(effects, ok, nok) {
+  const self = this
+  /** @type {Token} */
+  let labelImage
+
+  return start
+
+  /**
+   * Start of label (image) start.
+   *
+   * ```markdown
+   * > | a ![b] c
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    assert(code === codes.exclamationMark, 'expected `!`')
+    effects.enter(types.labelImage)
+    effects.enter(types.labelImageMarker)
+    effects.consume(code)
+    effects.exit(types.labelImageMarker)
+    return open
+  }
+
+  /**
+   * After `!`, at `[`.
+   *
+   * ```markdown
+   * > | a ![b] c
+   *        ^
+   * ```
+   *
+   * @type {State}
+   */
+  function open(code) {
+    if (code === codes.leftSquareBracket) {
+      effects.enter(types.labelMarker)
+      effects.consume(code)
+      effects.exit(types.labelMarker)
+      labelImage = effects.exit(types.labelImage)
+      return after
+    }
+
+    return nok(code)
+  }
+
+  /**
+   * After `![`.
+   *
+   * ```markdown
+   * > | a ![b] c
+   *         ^
+   * ```
+   *
+   * This is needed in because, when GFM footnotes are enabled, images never
+   * form when started with a `^`.
+   * Instead, links form:
+   *
+   * ```markdown
+   * ![^a](b)
+   *
+   * ![^a][b]
+   *
+   * [b]: c
+   * ```
+   *
+   * ```html
+   * <p>!<a href=\"b\">^a</a></p>
+   * <p>!<a href=\"c\">^a</a></p>
+   * ```
+   *
+   * @type {State}
+   */
+  function after(code) {
+    // To do: use a new field to do this, this is still needed for
+    // `micromark-extension-gfm-footnote`, but the `label-start-link`
+    // behavior isn’t.
+    // Hidden footnotes hook.
+    /* c8 ignore next 6 */
+    if (
+      code === codes.caret &&
+      '_hiddenFootnoteSupport' in self.parser.constructs
+    ) {
+      return nok(code)
+    }
+
+    self._labelStarts = self._labelStarts || []
+    self._labelStarts.push(labelImage)
+    return ok(code)
+  }
+}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/label-start-link.d.ts

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

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/label-start-link.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"label-start-link.d.ts","sourceRoot":"","sources":["label-start-link.js"],"names":[],"mappings":"AAcA,wBAAwB;AACxB,6BADW,SAAS,CAKnB;+BAZS,sBAAsB"}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/label-start-link.js

@@ -0,0 +1,71 @@
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   Token,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {codes, types} from 'micromark-util-symbol'
+import {labelEnd} from './label-end.js'
+
+/** @type {Construct} */
+export const labelStartLink = {
+  name: 'labelStartLink',
+  resolveAll: labelEnd.resolveAll,
+  tokenize: tokenizeLabelStartLink
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeLabelStartLink(effects, ok, nok) {
+  const self = this
+  /** @type {Token} */
+  let labelLink
+
+  return start
+
+  /**
+   * Start of label (link) start.
+   *
+   * ```markdown
+   * > | a [b] c
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    assert(code === codes.leftSquareBracket, 'expected `[`')
+    effects.enter(types.labelLink)
+    effects.enter(types.labelMarker)
+    effects.consume(code)
+    effects.exit(types.labelMarker)
+    labelLink = effects.exit(types.labelLink)
+    return after
+  }
+
+  /** @type {State} */
+  function after(code) {
+    // To do: this isn’t needed in `micromark-extension-gfm-footnote`,
+    // remove.
+    // Hidden footnotes hook.
+    /* c8 ignore next 6 */
+    if (
+      code === codes.caret &&
+      '_hiddenFootnoteSupport' in self.parser.constructs
+    ) {
+      return nok(code)
+    }
+
+    self._labelStarts = self._labelStarts || []
+    self._labelStarts.push(labelLink)
+    return ok(code)
+  }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"line-ending.d.ts","sourceRoot":"","sources":["line-ending.js"],"names":[],"mappings":"AAcA,wBAAwB;AACxB,yBADW,SAAS,CACwD;+BATlE,sBAAsB"}

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

@@ -0,0 +1,34 @@
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {factorySpace} from 'micromark-factory-space'
+import {markdownLineEnding} from 'micromark-util-character'
+import {types} from 'micromark-util-symbol'
+
+/** @type {Construct} */
+export const lineEnding = {name: 'lineEnding', tokenize: tokenizeLineEnding}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeLineEnding(effects, ok) {
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    assert(markdownLineEnding(code), 'expected eol')
+    effects.enter(types.lineEnding)
+    effects.consume(code)
+    effects.exit(types.lineEnding)
+    return factorySpace(effects, ok, types.linePrefix)
+  }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"list.d.ts","sourceRoot":"","sources":["list.js"],"names":[],"mappings":"AAkBA,wBAAwB;AACxB,mBADW,SAAS,CAMnB;+BAhBS,sBAAsB"}

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

@@ -0,0 +1,306 @@
+/**
+ * @import {
+ *   Code,
+ *   Construct,
+ *   Exiter,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {factorySpace} from 'micromark-factory-space'
+import {asciiDigit, markdownSpace} from 'micromark-util-character'
+import {codes, constants, types} from 'micromark-util-symbol'
+import {blankLine} from './blank-line.js'
+import {thematicBreak} from './thematic-break.js'
+
+/** @type {Construct} */
+export const list = {
+  continuation: {tokenize: tokenizeListContinuation},
+  exit: tokenizeListEnd,
+  name: 'list',
+  tokenize: tokenizeListStart
+}
+
+/** @type {Construct} */
+const listItemPrefixWhitespaceConstruct = {
+  partial: true,
+  tokenize: tokenizeListItemPrefixWhitespace
+}
+
+/** @type {Construct} */
+const indentConstruct = {partial: true, tokenize: tokenizeIndent}
+
+// To do: `markdown-rs` parses list items on their own and later stitches them
+// together.
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeListStart(effects, ok, nok) {
+  const self = this
+  const tail = self.events[self.events.length - 1]
+  let initialSize =
+    tail && tail[1].type === types.linePrefix
+      ? tail[2].sliceSerialize(tail[1], true).length
+      : 0
+  let size = 0
+
+  return start
+
+  /** @type {State} */
+  function start(code) {
+    assert(self.containerState, 'expected state')
+    const kind =
+      self.containerState.type ||
+      (code === codes.asterisk || code === codes.plusSign || code === codes.dash
+        ? types.listUnordered
+        : types.listOrdered)
+
+    if (
+      kind === types.listUnordered
+        ? !self.containerState.marker || code === self.containerState.marker
+        : asciiDigit(code)
+    ) {
+      if (!self.containerState.type) {
+        self.containerState.type = kind
+        effects.enter(kind, {_container: true})
+      }
+
+      if (kind === types.listUnordered) {
+        effects.enter(types.listItemPrefix)
+        return code === codes.asterisk || code === codes.dash
+          ? effects.check(thematicBreak, nok, atMarker)(code)
+          : atMarker(code)
+      }
+
+      if (!self.interrupt || code === codes.digit1) {
+        effects.enter(types.listItemPrefix)
+        effects.enter(types.listItemValue)
+        return inside(code)
+      }
+    }
+
+    return nok(code)
+  }
+
+  /** @type {State} */
+  function inside(code) {
+    assert(self.containerState, 'expected state')
+    if (asciiDigit(code) && ++size < constants.listItemValueSizeMax) {
+      effects.consume(code)
+      return inside
+    }
+
+    if (
+      (!self.interrupt || size < 2) &&
+      (self.containerState.marker
+        ? code === self.containerState.marker
+        : code === codes.rightParenthesis || code === codes.dot)
+    ) {
+      effects.exit(types.listItemValue)
+      return atMarker(code)
+    }
+
+    return nok(code)
+  }
+
+  /**
+   * @type {State}
+   **/
+  function atMarker(code) {
+    assert(self.containerState, 'expected state')
+    assert(code !== codes.eof, 'eof (`null`) is not a marker')
+    effects.enter(types.listItemMarker)
+    effects.consume(code)
+    effects.exit(types.listItemMarker)
+    self.containerState.marker = self.containerState.marker || code
+    return effects.check(
+      blankLine,
+      // Can’t be empty when interrupting.
+      self.interrupt ? nok : onBlank,
+      effects.attempt(
+        listItemPrefixWhitespaceConstruct,
+        endOfPrefix,
+        otherPrefix
+      )
+    )
+  }
+
+  /** @type {State} */
+  function onBlank(code) {
+    assert(self.containerState, 'expected state')
+    self.containerState.initialBlankLine = true
+    initialSize++
+    return endOfPrefix(code)
+  }
+
+  /** @type {State} */
+  function otherPrefix(code) {
+    if (markdownSpace(code)) {
+      effects.enter(types.listItemPrefixWhitespace)
+      effects.consume(code)
+      effects.exit(types.listItemPrefixWhitespace)
+      return endOfPrefix
+    }
+
+    return nok(code)
+  }
+
+  /** @type {State} */
+  function endOfPrefix(code) {
+    assert(self.containerState, 'expected state')
+    self.containerState.size =
+      initialSize +
+      self.sliceSerialize(effects.exit(types.listItemPrefix), true).length
+    return ok(code)
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeListContinuation(effects, ok, nok) {
+  const self = this
+
+  assert(self.containerState, 'expected state')
+  self.containerState._closeFlow = undefined
+
+  return effects.check(blankLine, onBlank, notBlank)
+
+  /** @type {State} */
+  function onBlank(code) {
+    assert(self.containerState, 'expected state')
+    assert(typeof self.containerState.size === 'number', 'expected size')
+    self.containerState.furtherBlankLines =
+      self.containerState.furtherBlankLines ||
+      self.containerState.initialBlankLine
+
+    // We have a blank line.
+    // Still, try to consume at most the items size.
+    return factorySpace(
+      effects,
+      ok,
+      types.listItemIndent,
+      self.containerState.size + 1
+    )(code)
+  }
+
+  /** @type {State} */
+  function notBlank(code) {
+    assert(self.containerState, 'expected state')
+    if (self.containerState.furtherBlankLines || !markdownSpace(code)) {
+      self.containerState.furtherBlankLines = undefined
+      self.containerState.initialBlankLine = undefined
+      return notInCurrentItem(code)
+    }
+
+    self.containerState.furtherBlankLines = undefined
+    self.containerState.initialBlankLine = undefined
+    return effects.attempt(indentConstruct, ok, notInCurrentItem)(code)
+  }
+
+  /** @type {State} */
+  function notInCurrentItem(code) {
+    assert(self.containerState, 'expected state')
+    // While we do continue, we signal that the flow should be closed.
+    self.containerState._closeFlow = true
+    // As we’re closing flow, we’re no longer interrupting.
+    self.interrupt = undefined
+    // Always populated by defaults.
+    assert(
+      self.parser.constructs.disable.null,
+      'expected `disable.null` to be populated'
+    )
+    return factorySpace(
+      effects,
+      effects.attempt(list, ok, nok),
+      types.linePrefix,
+      self.parser.constructs.disable.null.includes('codeIndented')
+        ? undefined
+        : constants.tabSize
+    )(code)
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeIndent(effects, ok, nok) {
+  const self = this
+
+  assert(self.containerState, 'expected state')
+  assert(typeof self.containerState.size === 'number', 'expected size')
+
+  return factorySpace(
+    effects,
+    afterPrefix,
+    types.listItemIndent,
+    self.containerState.size + 1
+  )
+
+  /** @type {State} */
+  function afterPrefix(code) {
+    assert(self.containerState, 'expected state')
+    const tail = self.events[self.events.length - 1]
+    return tail &&
+      tail[1].type === types.listItemIndent &&
+      tail[2].sliceSerialize(tail[1], true).length === self.containerState.size
+      ? ok(code)
+      : nok(code)
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Exiter}
+ */
+function tokenizeListEnd(effects) {
+  assert(this.containerState, 'expected state')
+  assert(typeof this.containerState.type === 'string', 'expected type')
+  effects.exit(this.containerState.type)
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeListItemPrefixWhitespace(effects, ok, nok) {
+  const self = this
+
+  // Always populated by defaults.
+  assert(
+    self.parser.constructs.disable.null,
+    'expected `disable.null` to be populated'
+  )
+
+  return factorySpace(
+    effects,
+    afterPrefix,
+    types.listItemPrefixWhitespace,
+    self.parser.constructs.disable.null.includes('codeIndented')
+      ? undefined
+      : constants.tabSize + 1
+  )
+
+  /** @type {State} */
+  function afterPrefix(code) {
+    const tail = self.events[self.events.length - 1]
+
+    return !markdownSpace(code) &&
+      tail &&
+      tail[1].type === types.listItemPrefixWhitespace
+      ? ok(code)
+      : nok(code)
+  }
+}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/partial-non-lazy-continuation.d.ts

@@ -0,0 +1,4 @@
+/** @type {Construct} */
+export const nonLazyContinuation: Construct;
+import type { Construct } from 'micromark-util-types';
+//# sourceMappingURL=partial-non-lazy-continuation.d.ts.map

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/partial-non-lazy-continuation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"partial-non-lazy-continuation.d.ts","sourceRoot":"","sources":["partial-non-lazy-continuation.js"],"names":[],"mappings":"AAaA,wBAAwB;AACxB,kCADW,SAAS,CAInB;+BAXS,sBAAsB"}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/partial-non-lazy-continuation.js

@@ -0,0 +1,67 @@
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {markdownLineEnding} from 'micromark-util-character'
+import {codes, types} from 'micromark-util-symbol'
+
+/** @type {Construct} */
+export const nonLazyContinuation = {
+  partial: true,
+  tokenize: tokenizeNonLazyContinuation
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeNonLazyContinuation(effects, ok, nok) {
+  const self = this
+
+  return start
+
+  /**
+   * At eol, before continuation.
+   *
+   * ```markdown
+   * > | * ```js
+   *            ^
+   *   | b
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    if (code === codes.eof) {
+      return nok(code)
+    }
+
+    assert(markdownLineEnding(code), 'expected eol')
+    effects.enter(types.lineEnding)
+    effects.consume(code)
+    effects.exit(types.lineEnding)
+    return after
+  }
+
+  /**
+   * A continuation.
+   *
+   * ```markdown
+   *   | * ```js
+   * > | b
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function after(code) {
+    return self.parser.lazy[self.now().line] ? nok(code) : ok(code)
+  }
+}

package/packages/config-markdownlint/node_modules/micromark-core-commonmark/dev/lib/setext-underline.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"setext-underline.d.ts","sourceRoot":"","sources":["setext-underline.js"],"names":[],"mappings":"AAiBA,wBAAwB;AACxB,8BADW,SAAS,CAKnB;+BAdS,sBAAsB"}