@alexlit/lint-kit 214.0.1 → 214.2.0

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

@@ -0,0 +1,178 @@
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {factorySpaceMinMax} from 'micromark-factory-space'
+import {markdownLineEnding, markdownSpace} from 'micromark-util-character'
+import {codes, constants, types} from 'micromark-util-symbol'
+
+/** @type {Construct} */
+export const codeIndented = {
+  name: 'codeIndented',
+  tokenize: tokenizeCodeIndented
+}
+
+/** @type {Construct} */
+const furtherStart = {partial: true, tokenize: tokenizeFurtherStart}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeCodeIndented(effects, ok, nok) {
+  return start
+
+  /**
+   * Start of code (indented).
+   *
+   * > **Parsing note**: it is not needed to check if this first line is a
+   * > filled line (that it has a non-whitespace character), because blank lines
+   * > are parsed already, so we never run into that.
+   *
+   * ```markdown
+   * > |     aaa
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    // To do: manually check if interrupting like `markdown-rs`.
+    assert(markdownSpace(code))
+    effects.enter(types.codeIndented)
+    return factorySpaceMinMax(
+      effects,
+      atBreak,
+      nok,
+      types.linePrefix,
+      constants.tabSize,
+      constants.tabSize
+    )(code)
+  }
+
+  /**
+   * At a break.
+   *
+   * ```markdown
+   * > |     aaa
+   *         ^  ^
+   * ```
+   *
+   * @type {State}
+   */
+  function atBreak(code) {
+    if (code === codes.eof) {
+      return after(code)
+    }
+
+    if (markdownLineEnding(code)) {
+      return effects.attempt(furtherStart, atBreak, after)(code)
+    }
+
+    effects.enter(types.codeFlowValue)
+    return inside(code)
+  }
+
+  /**
+   * In code content.
+   *
+   * ```markdown
+   * > |     aaa
+   *         ^^^^
+   * ```
+   *
+   * @type {State}
+   */
+  function inside(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      effects.exit(types.codeFlowValue)
+      return atBreak(code)
+    }
+
+    effects.consume(code)
+    return inside
+  }
+
+  /** @type {State} */
+  function after(code) {
+    effects.exit(types.codeIndented)
+    // To do: allow interrupting like `markdown-rs`.
+    // Feel free to interrupt.
+    // tokenizer.interrupt = false
+    return ok(code)
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeFurtherStart(effects, ok, nok) {
+  const self = this
+
+  return furtherStart
+
+  /**
+   * At eol, trying to parse another indent.
+   *
+   * ```markdown
+   * > |     aaa
+   *            ^
+   *   |     bbb
+   * ```
+   *
+   * @type {State}
+   */
+  function furtherStart(code) {
+    // To do: improve `lazy` / `pierce` handling.
+    // If this is a lazy line, it can’t be code.
+    if (self.parser.lazy[self.now().line]) {
+      return nok(code)
+    }
+
+    if (markdownLineEnding(code)) {
+      effects.enter(types.lineEnding)
+      effects.consume(code)
+      effects.exit(types.lineEnding)
+      return furtherStart
+    }
+
+    // To do: the code here in `micromark-js` is a bit different from
+    // `markdown-rs` because there it can attempt spaces.
+    // We can’t yet.
+    return factorySpaceMinMax(
+      effects,
+      ok,
+      onNotEnoughPrefix,
+      types.linePrefix,
+      constants.tabSize,
+      constants.tabSize
+    )(code)
+  }
+
+  /**
+   * After not enough of a prefix.
+   *
+   * A following line ending is another (potentially blank) line to try,
+   * anything else means this isn’t a continuation.
+   *
+   * ```markdown
+   * > |     aaa
+   *
+   *   |     bbb
+   * ```
+   *
+   * @type {State}
+   */
+  function onNotEnoughPrefix(code) {
+    return markdownLineEnding(code) ? furtherStart(code) : nok(code)
+  }
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"code-text.d.ts","sourceRoot":"","sources":["code-text.js"],"names":[],"mappings":"AAgBA,wBAAwB;AACxB,uBADW,SAAS,CAMnB;+BAbS,sBAAsB"}

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

@@ -0,0 +1,257 @@
+/**
+ * @import {
+ *   Construct,
+ *   Previous,
+ *   Resolver,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer,
+ *   Token
+ * } 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 codeText = {
+  name: 'codeText',
+  previous,
+  resolve: resolveCodeText,
+  tokenize: tokenizeCodeText
+}
+
+// To do: next major: don’t resolve, like `markdown-rs`.
+/** @type {Resolver} */
+function resolveCodeText(events) {
+  let tailExitIndex = events.length - 4
+  let headEnterIndex = 3
+  /** @type {number} */
+  let index
+  /** @type {number | undefined} */
+  let enter
+
+  // If we start and end with an EOL or a space.
+  if (
+    (events[headEnterIndex][1].type === types.lineEnding ||
+      events[headEnterIndex][1].type === 'space') &&
+    (events[tailExitIndex][1].type === types.lineEnding ||
+      events[tailExitIndex][1].type === 'space')
+  ) {
+    index = headEnterIndex
+
+    // And we have data.
+    while (++index < tailExitIndex) {
+      if (events[index][1].type === types.codeTextData) {
+        // Then we have padding.
+        events[headEnterIndex][1].type = types.codeTextPadding
+        events[tailExitIndex][1].type = types.codeTextPadding
+        headEnterIndex += 2
+        tailExitIndex -= 2
+        break
+      }
+    }
+  }
+
+  // Merge adjacent spaces and data.
+  index = headEnterIndex - 1
+  tailExitIndex++
+
+  while (++index <= tailExitIndex) {
+    if (enter === undefined) {
+      if (
+        index !== tailExitIndex &&
+        events[index][1].type !== types.lineEnding
+      ) {
+        enter = index
+      }
+    } else if (
+      index === tailExitIndex ||
+      events[index][1].type === types.lineEnding
+    ) {
+      events[enter][1].type = types.codeTextData
+
+      if (index !== enter + 2) {
+        events[enter][1].end = events[index - 1][1].end
+        events.splice(enter + 2, index - enter - 2)
+        tailExitIndex -= index - enter - 2
+        index = enter + 2
+      }
+
+      enter = undefined
+    }
+  }
+
+  return events
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Previous}
+ */
+function previous(code) {
+  // If there is a previous code, there will always be a tail.
+  return (
+    code !== codes.graveAccent ||
+    this.events[this.events.length - 1][1].type === types.characterEscape
+  )
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeCodeText(effects, ok, nok) {
+  const self = this
+  let sizeOpen = 0
+  /** @type {number} */
+  let size
+  /** @type {Token} */
+  let token
+
+  return start
+
+  /**
+   * Start of code (text).
+   *
+   * ```markdown
+   * > | `a`
+   *     ^
+   * > | \`a`
+   *      ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    assert(code === codes.graveAccent, 'expected `` ` ``')
+    assert(previous.call(self, self.previous), 'expected correct previous')
+    effects.enter(types.codeText)
+    effects.enter(types.codeTextSequence)
+    return sequenceOpen(code)
+  }
+
+  /**
+   * In opening sequence.
+   *
+   * ```markdown
+   * > | `a`
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function sequenceOpen(code) {
+    if (code === codes.graveAccent) {
+      effects.consume(code)
+      sizeOpen++
+      return sequenceOpen
+    }
+
+    effects.exit(types.codeTextSequence)
+    return between(code)
+  }
+
+  /**
+   * Between something and something else.
+   *
+   * ```markdown
+   * > | `a`
+   *      ^^
+   * ```
+   *
+   * @type {State}
+   */
+  function between(code) {
+    // EOF.
+    if (code === codes.eof) {
+      return nok(code)
+    }
+
+    // To do: next major: don’t do spaces in resolve, but when compiling,
+    // like `markdown-rs`.
+    // Tabs don’t work, and virtual spaces don’t make sense.
+    if (code === codes.space) {
+      effects.enter('space')
+      effects.consume(code)
+      effects.exit('space')
+      return between
+    }
+
+    // Closing fence? Could also be data.
+    if (code === codes.graveAccent) {
+      token = effects.enter(types.codeTextSequence)
+      size = 0
+      return sequenceClose(code)
+    }
+
+    if (markdownLineEnding(code)) {
+      effects.enter(types.lineEnding)
+      effects.consume(code)
+      effects.exit(types.lineEnding)
+      return between
+    }
+
+    // Data.
+    effects.enter(types.codeTextData)
+    return data(code)
+  }
+
+  /**
+   * In data.
+   *
+   * ```markdown
+   * > | `a`
+   *      ^
+   * ```
+   *
+   * @type {State}
+   */
+  function data(code) {
+    if (
+      code === codes.eof ||
+      code === codes.space ||
+      code === codes.graveAccent ||
+      markdownLineEnding(code)
+    ) {
+      effects.exit(types.codeTextData)
+      return between(code)
+    }
+
+    effects.consume(code)
+    return data
+  }
+
+  /**
+   * In closing sequence.
+   *
+   * ```markdown
+   * > | `a`
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function sequenceClose(code) {
+    // More.
+    if (code === codes.graveAccent) {
+      effects.consume(code)
+      size++
+      return sequenceClose
+    }
+
+    // Done!
+    if (size === sizeOpen) {
+      effects.exit(types.codeTextSequence)
+      effects.exit(types.codeText)
+      return ok(code)
+    }
+
+    // More or less accents: mark as data.
+    token.type = types.codeTextData
+    return data(code)
+  }
+}

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

@@ -0,0 +1,7 @@
+/**
+ * No name because it must not be turned off.
+ * @type {Construct}
+ */
+export const content: Construct;
+import type { Construct } from 'micromark-util-types';
+//# sourceMappingURL=content.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"content.d.ts","sourceRoot":"","sources":["content.js"],"names":[],"mappings":"AAiBA;;;GAGG;AACH,sBAFU,SAAS,CAEwD;+BAbjE,sBAAsB"}

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

@@ -0,0 +1,185 @@
+/**
+ * @import {
+ *   Construct,
+ *   Resolver,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer,
+ *   Token
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {factorySpace} from 'micromark-factory-space'
+import {markdownLineEnding} from 'micromark-util-character'
+import {subtokenize} from 'micromark-util-subtokenize'
+import {codes, constants, types} from 'micromark-util-symbol'
+
+/**
+ * No name because it must not be turned off.
+ * @type {Construct}
+ */
+export const content = {resolve: resolveContent, tokenize: tokenizeContent}
+
+/** @type {Construct} */
+const continuationConstruct = {partial: true, tokenize: tokenizeContinuation}
+
+/**
+ * Content is transparent: it’s parsed right now. That way, definitions are also
+ * parsed right now: before text in paragraphs (specifically, media) are parsed.
+ *
+ * @type {Resolver}
+ */
+function resolveContent(events) {
+  subtokenize(events)
+  return events
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeContent(effects, ok) {
+  /** @type {Token | undefined} */
+  let previous
+
+  return chunkStart
+
+  /**
+   * Before a content chunk.
+   *
+   * ```markdown
+   * > | abc
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function chunkStart(code) {
+    assert(
+      code !== codes.eof && !markdownLineEnding(code),
+      'expected no eof or eol'
+    )
+
+    effects.enter(types.content)
+    previous = effects.enter(types.chunkContent, {
+      contentType: constants.contentTypeContent
+    })
+    return chunkInside(code)
+  }
+
+  /**
+   * In a content chunk.
+   *
+   * ```markdown
+   * > | abc
+   *     ^^^
+   * ```
+   *
+   * @type {State}
+   */
+  function chunkInside(code) {
+    if (code === codes.eof) {
+      return contentEnd(code)
+    }
+
+    // To do: in `markdown-rs`, each line is parsed on its own, and everything
+    // is stitched together resolving.
+    if (markdownLineEnding(code)) {
+      return effects.check(
+        continuationConstruct,
+        contentContinue,
+        contentEnd
+      )(code)
+    }
+
+    // Data.
+    effects.consume(code)
+    return chunkInside
+  }
+
+  /**
+   *
+   *
+   * @type {State}
+   */
+  function contentEnd(code) {
+    effects.exit(types.chunkContent)
+    effects.exit(types.content)
+    return ok(code)
+  }
+
+  /**
+   *
+   *
+   * @type {State}
+   */
+  function contentContinue(code) {
+    assert(markdownLineEnding(code), 'expected eol')
+    effects.consume(code)
+    effects.exit(types.chunkContent)
+    assert(previous, 'expected previous token')
+    previous.next = effects.enter(types.chunkContent, {
+      contentType: constants.contentTypeContent,
+      previous
+    })
+    previous = previous.next
+    return chunkInside
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeContinuation(effects, ok, nok) {
+  const self = this
+
+  return startLookahead
+
+  /**
+   *
+   *
+   * @type {State}
+   */
+  function startLookahead(code) {
+    assert(markdownLineEnding(code), 'expected a line ending')
+    effects.exit(types.chunkContent)
+    effects.enter(types.lineEnding)
+    effects.consume(code)
+    effects.exit(types.lineEnding)
+    return factorySpace(effects, prefixed, types.linePrefix)
+  }
+
+  /**
+   *
+   *
+   * @type {State}
+   */
+  function prefixed(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      return nok(code)
+    }
+
+    // Always populated by defaults.
+    assert(
+      self.parser.constructs.disable.null,
+      'expected `disable.null` to be populated'
+    )
+
+    const tail = self.events[self.events.length - 1]
+
+    if (
+      !self.parser.constructs.disable.null.includes('codeIndented') &&
+      tail &&
+      tail[1].type === types.linePrefix &&
+      tail[2].sliceSerialize(tail[1], true).length >= constants.tabSize
+    ) {
+      return ok(code)
+    }
+
+    return effects.interrupt(self.parser.constructs.flow, nok, ok)(code)
+  }
+}

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

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

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

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