@alexlit/lint-kit 216.0.0 → 217.0.0

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

@@ -1,422 +0,0 @@
-/**
- * @import {
- *   Code,
- *   Construct,
- *   State,
- *   TokenizeContext,
- *   Tokenizer
- * } from 'micromark-util-types'
- */
-
-import { factorySpace } from 'micromark-factory-space';
-import { markdownLineEnding, markdownSpace } from 'micromark-util-character';
-import { nonLazyContinuation } from './partial-non-lazy-continuation.js';
-
-/** @type {Construct} */
-export const codeFenced = {
-  concrete: true,
-  name: 'codeFenced',
-  tokenize: tokenizeCodeFenced
-};
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeCodeFenced(effects, ok, nok) {
-  const self = this;
-  /** @type {Construct} */
-  const closeStart = {
-    partial: true,
-    tokenize: tokenizeCloseStart
-  };
-  let initialPrefix = 0;
-  let sizeOpen = 0;
-  /** @type {NonNullable<Code>} */
-  let marker;
-  return start;
-
-  /**
-   * Start of code.
-   *
-   * ```markdown
-   * > | ~~~js
-   *     ^
-   *   | alert(1)
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function start(code) {
-    // To do: parse whitespace like `markdown-rs`.
-    return beforeSequenceOpen(code);
-  }
-
-  /**
-   * In opening fence, after prefix, at sequence.
-   *
-   * ```markdown
-   * > | ~~~js
-   *     ^
-   *   | alert(1)
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function beforeSequenceOpen(code) {
-    const tail = self.events[self.events.length - 1];
-    initialPrefix = tail && tail[1].type === "linePrefix" ? tail[2].sliceSerialize(tail[1], true).length : 0;
-    marker = code;
-    effects.enter("codeFenced");
-    effects.enter("codeFencedFence");
-    effects.enter("codeFencedFenceSequence");
-    return sequenceOpen(code);
-  }
-
-  /**
-   * In opening fence sequence.
-   *
-   * ```markdown
-   * > | ~~~js
-   *      ^
-   *   | alert(1)
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function sequenceOpen(code) {
-    if (code === marker) {
-      sizeOpen++;
-      effects.consume(code);
-      return sequenceOpen;
-    }
-    if (sizeOpen < 3) {
-      return nok(code);
-    }
-    effects.exit("codeFencedFenceSequence");
-    return markdownSpace(code) ? factorySpace(effects, infoBefore, "whitespace")(code) : infoBefore(code);
-  }
-
-  /**
-   * In opening fence, after the sequence (and optional whitespace), before info.
-   *
-   * ```markdown
-   * > | ~~~js
-   *        ^
-   *   | alert(1)
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function infoBefore(code) {
-    if (code === null || markdownLineEnding(code)) {
-      effects.exit("codeFencedFence");
-      return self.interrupt ? ok(code) : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);
-    }
-    effects.enter("codeFencedFenceInfo");
-    effects.enter("chunkString", {
-      contentType: "string"
-    });
-    return info(code);
-  }
-
-  /**
-   * In info.
-   *
-   * ```markdown
-   * > | ~~~js
-   *        ^
-   *   | alert(1)
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function info(code) {
-    if (code === null || markdownLineEnding(code)) {
-      effects.exit("chunkString");
-      effects.exit("codeFencedFenceInfo");
-      return infoBefore(code);
-    }
-    if (markdownSpace(code)) {
-      effects.exit("chunkString");
-      effects.exit("codeFencedFenceInfo");
-      return factorySpace(effects, metaBefore, "whitespace")(code);
-    }
-    if (code === 96 && code === marker) {
-      return nok(code);
-    }
-    effects.consume(code);
-    return info;
-  }
-
-  /**
-   * In opening fence, after info and whitespace, before meta.
-   *
-   * ```markdown
-   * > | ~~~js eval
-   *           ^
-   *   | alert(1)
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function metaBefore(code) {
-    if (code === null || markdownLineEnding(code)) {
-      return infoBefore(code);
-    }
-    effects.enter("codeFencedFenceMeta");
-    effects.enter("chunkString", {
-      contentType: "string"
-    });
-    return meta(code);
-  }
-
-  /**
-   * In meta.
-   *
-   * ```markdown
-   * > | ~~~js eval
-   *           ^
-   *   | alert(1)
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function meta(code) {
-    if (code === null || markdownLineEnding(code)) {
-      effects.exit("chunkString");
-      effects.exit("codeFencedFenceMeta");
-      return infoBefore(code);
-    }
-    if (code === 96 && code === marker) {
-      return nok(code);
-    }
-    effects.consume(code);
-    return meta;
-  }
-
-  /**
-   * At eol/eof in code, before a non-lazy closing fence or content.
-   *
-   * ```markdown
-   * > | ~~~js
-   *          ^
-   * > | alert(1)
-   *             ^
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function atNonLazyBreak(code) {
-    return effects.attempt(closeStart, after, contentBefore)(code);
-  }
-
-  /**
-   * Before code content, not a closing fence, at eol.
-   *
-   * ```markdown
-   *   | ~~~js
-   * > | alert(1)
-   *             ^
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function contentBefore(code) {
-    effects.enter("lineEnding");
-    effects.consume(code);
-    effects.exit("lineEnding");
-    return contentStart;
-  }
-
-  /**
-   * Before code content, not a closing fence.
-   *
-   * ```markdown
-   *   | ~~~js
-   * > | alert(1)
-   *     ^
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function contentStart(code) {
-    return initialPrefix > 0 && markdownSpace(code) ? factorySpace(effects, beforeContentChunk, "linePrefix", initialPrefix + 1)(code) : beforeContentChunk(code);
-  }
-
-  /**
-   * Before code content, after optional prefix.
-   *
-   * ```markdown
-   *   | ~~~js
-   * > | alert(1)
-   *     ^
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function beforeContentChunk(code) {
-    if (code === null || markdownLineEnding(code)) {
-      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code);
-    }
-    effects.enter("codeFlowValue");
-    return contentChunk(code);
-  }
-
-  /**
-   * In code content.
-   *
-   * ```markdown
-   *   | ~~~js
-   * > | alert(1)
-   *     ^^^^^^^^
-   *   | ~~~
-   * ```
-   *
-   * @type {State}
-   */
-  function contentChunk(code) {
-    if (code === null || markdownLineEnding(code)) {
-      effects.exit("codeFlowValue");
-      return beforeContentChunk(code);
-    }
-    effects.consume(code);
-    return contentChunk;
-  }
-
-  /**
-   * After code.
-   *
-   * ```markdown
-   *   | ~~~js
-   *   | alert(1)
-   * > | ~~~
-   *        ^
-   * ```
-   *
-   * @type {State}
-   */
-  function after(code) {
-    effects.exit("codeFenced");
-    return ok(code);
-  }
-
-  /**
-   * @this {TokenizeContext}
-   *   Context.
-   * @type {Tokenizer}
-   */
-  function tokenizeCloseStart(effects, ok, nok) {
-    let size = 0;
-    return startBefore;
-
-    /**
-     *
-     *
-     * @type {State}
-     */
-    function startBefore(code) {
-      effects.enter("lineEnding");
-      effects.consume(code);
-      effects.exit("lineEnding");
-      return start;
-    }
-
-    /**
-     * Before closing fence, at optional whitespace.
-     *
-     * ```markdown
-     *   | ~~~js
-     *   | alert(1)
-     * > | ~~~
-     *     ^
-     * ```
-     *
-     * @type {State}
-     */
-    function start(code) {
-      // Always populated by defaults.
-
-      // To do: `enter` here or in next state?
-      effects.enter("codeFencedFence");
-      return markdownSpace(code) ? factorySpace(effects, beforeSequenceClose, "linePrefix", self.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4)(code) : beforeSequenceClose(code);
-    }
-
-    /**
-     * In closing fence, after optional whitespace, at sequence.
-     *
-     * ```markdown
-     *   | ~~~js
-     *   | alert(1)
-     * > | ~~~
-     *     ^
-     * ```
-     *
-     * @type {State}
-     */
-    function beforeSequenceClose(code) {
-      if (code === marker) {
-        effects.enter("codeFencedFenceSequence");
-        return sequenceClose(code);
-      }
-      return nok(code);
-    }
-
-    /**
-     * In closing fence sequence.
-     *
-     * ```markdown
-     *   | ~~~js
-     *   | alert(1)
-     * > | ~~~
-     *     ^
-     * ```
-     *
-     * @type {State}
-     */
-    function sequenceClose(code) {
-      if (code === marker) {
-        size++;
-        effects.consume(code);
-        return sequenceClose;
-      }
-      if (size >= sizeOpen) {
-        effects.exit("codeFencedFenceSequence");
-        return markdownSpace(code) ? factorySpace(effects, sequenceCloseAfter, "whitespace")(code) : sequenceCloseAfter(code);
-      }
-      return nok(code);
-    }
-
-    /**
-     * After closing fence sequence, after optional whitespace.
-     *
-     * ```markdown
-     *   | ~~~js
-     *   | alert(1)
-     * > | ~~~
-     *        ^
-     * ```
-     *
-     * @type {State}
-     */
-    function sequenceCloseAfter(code) {
-      if (code === null || markdownLineEnding(code)) {
-        effects.exit("codeFencedFence");
-        return ok(code);
-      }
-      return nok(code);
-    }
-  }
-}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"code-indented.d.ts","sourceRoot":"","sources":["code-indented.js"],"names":[],"mappings":"AAcA,wBAAwB;AACxB,2BADW,SAAS,CAInB;+BAZS,sBAAsB"}

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

@@ -1,159 +0,0 @@
-/**
- * @import {
- *   Construct,
- *   State,
- *   TokenizeContext,
- *   Tokenizer
- * } from 'micromark-util-types'
- */
-
-import { factorySpaceMinMax } from 'micromark-factory-space';
-import { markdownLineEnding, markdownSpace } from 'micromark-util-character';
-/** @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`.
-
-    effects.enter("codeIndented");
-    return factorySpaceMinMax(effects, atBreak, nok, "linePrefix", 4, 4)(code);
-  }
-
-  /**
-   * At a break.
-   *
-   * ```markdown
-   * > |     aaa
-   *         ^  ^
-   * ```
-   *
-   * @type {State}
-   */
-  function atBreak(code) {
-    if (code === null) {
-      return after(code);
-    }
-    if (markdownLineEnding(code)) {
-      return effects.attempt(furtherStart, atBreak, after)(code);
-    }
-    effects.enter("codeFlowValue");
-    return inside(code);
-  }
-
-  /**
-   * In code content.
-   *
-   * ```markdown
-   * > |     aaa
-   *         ^^^^
-   * ```
-   *
-   * @type {State}
-   */
-  function inside(code) {
-    if (code === null || markdownLineEnding(code)) {
-      effects.exit("codeFlowValue");
-      return atBreak(code);
-    }
-    effects.consume(code);
-    return inside;
-  }
-
-  /** @type {State} */
-  function after(code) {
-    effects.exit("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("lineEnding");
-      effects.consume(code);
-      effects.exit("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, "linePrefix", 4, 4)(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/lib/code-text.d.ts

@@ -1,4 +0,0 @@
-/** @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/lib/code-text.d.ts.map

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