@alexlit/lint-kit 216.1.0 → 217.0.0

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

@@ -1,295 +0,0 @@
-/**
- * @import {
- *   Construct,
- *   State,
- *   TokenizeContext,
- *   Tokenizer
- * } from 'micromark-util-types'
- */
-
-import {ok as assert} from 'devlop'
-import {factoryDestination} from 'micromark-factory-destination'
-import {factoryLabel} from 'micromark-factory-label'
-import {factorySpace} from 'micromark-factory-space'
-import {factoryTitle} from 'micromark-factory-title'
-import {factoryWhitespace} from 'micromark-factory-whitespace'
-import {
-  markdownLineEndingOrSpace,
-  markdownLineEnding,
-  markdownSpace
-} from 'micromark-util-character'
-import {normalizeIdentifier} from 'micromark-util-normalize-identifier'
-import {codes, types} from 'micromark-util-symbol'
-
-/** @type {Construct} */
-export const definition = {name: 'definition', tokenize: tokenizeDefinition}
-
-/** @type {Construct} */
-const titleBefore = {partial: true, tokenize: tokenizeTitleBefore}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeDefinition(effects, ok, nok) {
-  const self = this
-  /** @type {string} */
-  let identifier
-
-  return start
-
-  /**
-   * At start of a definition.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function start(code) {
-    // Do not interrupt paragraphs (but do follow definitions).
-    // To do: do `interrupt` the way `markdown-rs` does.
-    // To do: parse whitespace the way `markdown-rs` does.
-    effects.enter(types.definition)
-    return before(code)
-  }
-
-  /**
-   * After optional whitespace, at `[`.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function before(code) {
-    // To do: parse whitespace the way `markdown-rs` does.
-    assert(code === codes.leftSquareBracket, 'expected `[`')
-    return factoryLabel.call(
-      self,
-      effects,
-      labelAfter,
-      // Note: we don’t need to reset the way `markdown-rs` does.
-      nok,
-      types.definitionLabel,
-      types.definitionLabelMarker,
-      types.definitionLabelString
-    )(code)
-  }
-
-  /**
-   * After label.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *        ^
-   * ```
-   *
-   * @type {State}
-   */
-  function labelAfter(code) {
-    identifier = normalizeIdentifier(
-      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
-    )
-
-    if (code === codes.colon) {
-      effects.enter(types.definitionMarker)
-      effects.consume(code)
-      effects.exit(types.definitionMarker)
-      return markerAfter
-    }
-
-    return nok(code)
-  }
-
-  /**
-   * After marker.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *         ^
-   * ```
-   *
-   * @type {State}
-   */
-  function markerAfter(code) {
-    // Note: whitespace is optional.
-    return markdownLineEndingOrSpace(code)
-      ? factoryWhitespace(effects, destinationBefore)(code)
-      : destinationBefore(code)
-  }
-
-  /**
-   * Before destination.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *          ^
-   * ```
-   *
-   * @type {State}
-   */
-  function destinationBefore(code) {
-    return factoryDestination(
-      effects,
-      destinationAfter,
-      // Note: we don’t need to reset the way `markdown-rs` does.
-      nok,
-      types.definitionDestination,
-      types.definitionDestinationLiteral,
-      types.definitionDestinationLiteralMarker,
-      types.definitionDestinationRaw,
-      types.definitionDestinationString
-    )(code)
-  }
-
-  /**
-   * After destination.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *           ^
-   * ```
-   *
-   * @type {State}
-   */
-  function destinationAfter(code) {
-    return effects.attempt(titleBefore, after, after)(code)
-  }
-
-  /**
-   * After definition.
-   *
-   * ```markdown
-   * > | [a]: b
-   *           ^
-   * > | [a]: b "c"
-   *               ^
-   * ```
-   *
-   * @type {State}
-   */
-  function after(code) {
-    return markdownSpace(code)
-      ? factorySpace(effects, afterWhitespace, types.whitespace)(code)
-      : afterWhitespace(code)
-  }
-
-  /**
-   * After definition, after optional whitespace.
-   *
-   * ```markdown
-   * > | [a]: b
-   *           ^
-   * > | [a]: b "c"
-   *               ^
-   * ```
-   *
-   * @type {State}
-   */
-  function afterWhitespace(code) {
-    if (code === codes.eof || markdownLineEnding(code)) {
-      effects.exit(types.definition)
-
-      // Note: we don’t care about uniqueness.
-      // It’s likely that that doesn’t happen very frequently.
-      // It is more likely that it wastes precious time.
-      self.parser.defined.push(identifier)
-
-      // To do: `markdown-rs` interrupt.
-      // // You’d be interrupting.
-      // tokenizer.interrupt = true
-      return ok(code)
-    }
-
-    return nok(code)
-  }
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeTitleBefore(effects, ok, nok) {
-  return titleBefore
-
-  /**
-   * After destination, at whitespace.
-   *
-   * ```markdown
-   * > | [a]: b
-   *           ^
-   * > | [a]: b "c"
-   *           ^
-   * ```
-   *
-   * @type {State}
-   */
-  function titleBefore(code) {
-    return markdownLineEndingOrSpace(code)
-      ? factoryWhitespace(effects, beforeMarker)(code)
-      : nok(code)
-  }
-
-  /**
-   * At title.
-   *
-   * ```markdown
-   *   | [a]: b
-   * > | "c"
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function beforeMarker(code) {
-    return factoryTitle(
-      effects,
-      titleAfter,
-      nok,
-      types.definitionTitle,
-      types.definitionTitleMarker,
-      types.definitionTitleString
-    )(code)
-  }
-
-  /**
-   * After title.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *               ^
-   * ```
-   *
-   * @type {State}
-   */
-  function titleAfter(code) {
-    return markdownSpace(code)
-      ? factorySpace(
-          effects,
-          titleAfterOptionalWhitespace,
-          types.whitespace
-        )(code)
-      : titleAfterOptionalWhitespace(code)
-  }
-
-  /**
-   * After title, after optional whitespace.
-   *
-   * ```markdown
-   * > | [a]: b "c"
-   *               ^
-   * ```
-   *
-   * @type {State}
-   */
-  function titleAfterOptionalWhitespace(code) {
-    return code === codes.eof || markdownLineEnding(code) ? ok(code) : nok(code)
-  }
-}

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

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

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

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

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

@@ -1,65 +0,0 @@
-/**
- * @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 hardBreakEscape = {
-  name: 'hardBreakEscape',
-  tokenize: tokenizeHardBreakEscape
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeHardBreakEscape(effects, ok, nok) {
-  return start
-
-  /**
-   * Start of a hard break (escape).
-   *
-   * ```markdown
-   * > | a\
-   *      ^
-   *   | b
-   * ```
-   *
-   * @type {State}
-   */
-  function start(code) {
-    assert(code === codes.backslash, 'expected `\\`')
-    effects.enter(types.hardBreakEscape)
-    effects.consume(code)
-    return after
-  }
-
-  /**
-   * After `\`, at eol.
-   *
-   * ```markdown
-   * > | a\
-   *       ^
-   *   | b
-   * ```
-   *
-   *  @type {State}
-   */
-  function after(code) {
-    if (markdownLineEnding(code)) {
-      effects.exit(types.hardBreakEscape)
-      return ok(code)
-    }
-
-    return nok(code)
-  }
-}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"heading-atx.d.ts","sourceRoot":"","sources":["heading-atx.js"],"names":[],"mappings":"AAqBA,wBAAwB;AACxB,yBADW,SAAS,CAKnB;+BAlBS,sBAAsB"}

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

@@ -1,229 +0,0 @@
-/**
- * @import {
- *   Construct,
- *   Resolver,
- *   State,
- *   TokenizeContext,
- *   Tokenizer,
- *   Token
- * } from 'micromark-util-types'
- */
-
-import {ok as assert} from 'devlop'
-import {factorySpace} from 'micromark-factory-space'
-import {
-  markdownLineEndingOrSpace,
-  markdownLineEnding,
-  markdownSpace
-} from 'micromark-util-character'
-import {splice} from 'micromark-util-chunked'
-import {codes, constants, types} from 'micromark-util-symbol'
-
-/** @type {Construct} */
-export const headingAtx = {
-  name: 'headingAtx',
-  resolve: resolveHeadingAtx,
-  tokenize: tokenizeHeadingAtx
-}
-
-/** @type {Resolver} */
-function resolveHeadingAtx(events, context) {
-  let contentEnd = events.length - 2
-  let contentStart = 3
-
-  // Prefix whitespace, part of the opening.
-  if (events[contentStart][1].type === types.whitespace) {
-    contentStart += 2
-  }
-
-  // Suffix whitespace, part of the closing.
-  if (
-    contentEnd - 2 > contentStart &&
-    events[contentEnd][1].type === types.whitespace
-  ) {
-    contentEnd -= 2
-  }
-
-  if (
-    events[contentEnd][1].type === types.atxHeadingSequence &&
-    (contentStart === contentEnd - 1 ||
-      (contentEnd - 4 > contentStart &&
-        events[contentEnd - 2][1].type === types.whitespace))
-  ) {
-    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4
-  }
-
-  if (contentEnd > contentStart) {
-    const content = {
-      type: types.atxHeadingText,
-      start: events[contentStart][1].start,
-      end: events[contentEnd][1].end
-    }
-    const text = {
-      type: types.chunkText,
-      start: events[contentStart][1].start,
-      end: events[contentEnd][1].end,
-      contentType: constants.contentTypeText
-    }
-
-    splice(events, contentStart, contentEnd - contentStart + 1, [
-      ['enter', content, context],
-      ['enter', text, context],
-      ['exit', text, context],
-      ['exit', content, context]
-    ])
-  }
-
-  return events
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeHeadingAtx(effects, ok, nok) {
-  let size = 0
-
-  return start
-
-  /**
-   * Start of a heading (atx).
-   *
-   * ```markdown
-   * > | ## aa
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function start(code) {
-    // To do: parse indent like `markdown-rs`.
-    effects.enter(types.atxHeading)
-    return before(code)
-  }
-
-  /**
-   * After optional whitespace, at `#`.
-   *
-   * ```markdown
-   * > | ## aa
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function before(code) {
-    assert(code === codes.numberSign, 'expected `#`')
-    effects.enter(types.atxHeadingSequence)
-    return sequenceOpen(code)
-  }
-
-  /**
-   * In opening sequence.
-   *
-   * ```markdown
-   * > | ## aa
-   *     ^
-   * ```
-   *
-   * @type {State}
-   */
-  function sequenceOpen(code) {
-    if (
-      code === codes.numberSign &&
-      size++ < constants.atxHeadingOpeningFenceSizeMax
-    ) {
-      effects.consume(code)
-      return sequenceOpen
-    }
-
-    // Always at least one `#`.
-    if (code === codes.eof || markdownLineEndingOrSpace(code)) {
-      effects.exit(types.atxHeadingSequence)
-      return atBreak(code)
-    }
-
-    return nok(code)
-  }
-
-  /**
-   * After something, before something else.
-   *
-   * ```markdown
-   * > | ## aa
-   *       ^
-   * ```
-   *
-   * @type {State}
-   */
-  function atBreak(code) {
-    if (code === codes.numberSign) {
-      effects.enter(types.atxHeadingSequence)
-      return sequenceFurther(code)
-    }
-
-    if (code === codes.eof || markdownLineEnding(code)) {
-      effects.exit(types.atxHeading)
-      // To do: interrupt like `markdown-rs`.
-      // // Feel free to interrupt.
-      // tokenizer.interrupt = false
-      return ok(code)
-    }
-
-    if (markdownSpace(code)) {
-      return factorySpace(effects, atBreak, types.whitespace)(code)
-    }
-
-    // To do: generate `data` tokens, add the `text` token later.
-    // Needs edit map, see: `markdown.rs`.
-    effects.enter(types.atxHeadingText)
-    return data(code)
-  }
-
-  /**
-   * In further sequence (after whitespace).
-   *
-   * Could be normal “visible” hashes in the heading or a final sequence.
-   *
-   * ```markdown
-   * > | ## aa ##
-   *           ^
-   * ```
-   *
-   * @type {State}
-   */
-  function sequenceFurther(code) {
-    if (code === codes.numberSign) {
-      effects.consume(code)
-      return sequenceFurther
-    }
-
-    effects.exit(types.atxHeadingSequence)
-    return atBreak(code)
-  }
-
-  /**
-   * In text.
-   *
-   * ```markdown
-   * > | ## aa
-   *        ^
-   * ```
-   *
-   * @type {State}
-   */
-  function data(code) {
-    if (
-      code === codes.eof ||
-      code === codes.numberSign ||
-      markdownLineEndingOrSpace(code)
-    ) {
-      effects.exit(types.atxHeadingText)
-      return atBreak(code)
-    }
-
-    effects.consume(code)
-    return data
-  }
-}

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"html-flow.d.ts","sourceRoot":"","sources":["html-flow.js"],"names":[],"mappings":"AAwBA,wBAAwB;AACxB,uBADW,SAAS,CAMnB;+BAtBS,sBAAsB"}