@alexlit/lint-kit 216.1.0 → 217.0.1

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

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"label-end.d.ts","sourceRoot":"","sources":["label-end.js"],"names":[],"mappings":"AAuBA,wBAAwB;AACxB,uBADW,SAAS,CAMnB;+BApBS,sBAAsB"}

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

@@ -1,658 +0,0 @@
-/**
- * @import {
- *   Construct,
- *   Event,
- *   Resolver,
- *   State,
- *   TokenizeContext,
- *   Tokenizer,
- *   Token
- * } from 'micromark-util-types'
- */
-
-import {ok as assert} from 'devlop'
-import {factoryDestination} from 'micromark-factory-destination'
-import {factoryLabel} from 'micromark-factory-label'
-import {factoryTitle} from 'micromark-factory-title'
-import {factoryWhitespace} from 'micromark-factory-whitespace'
-import {markdownLineEndingOrSpace} from 'micromark-util-character'
-import {push, splice} from 'micromark-util-chunked'
-import {normalizeIdentifier} from 'micromark-util-normalize-identifier'
-import {resolveAll} from 'micromark-util-resolve-all'
-import {codes, constants, types} from 'micromark-util-symbol'
-
-/** @type {Construct} */
-export const labelEnd = {
-  name: 'labelEnd',
-  resolveAll: resolveAllLabelEnd,
-  resolveTo: resolveToLabelEnd,
-  tokenize: tokenizeLabelEnd
-}
-
-/** @type {Construct} */
-const resourceConstruct = {tokenize: tokenizeResource}
-/** @type {Construct} */
-const referenceFullConstruct = {tokenize: tokenizeReferenceFull}
-/** @type {Construct} */
-const referenceCollapsedConstruct = {tokenize: tokenizeReferenceCollapsed}
-
-/** @type {Resolver} */
-function resolveAllLabelEnd(events) {
-  let index = -1
-  /** @type {Array<Event>} */
-  const newEvents = []
-  while (++index < events.length) {
-    const token = events[index][1]
-    newEvents.push(events[index])
-
-    if (
-      token.type === types.labelImage ||
-      token.type === types.labelLink ||
-      token.type === types.labelEnd
-    ) {
-      // Remove the marker.
-      const offset = token.type === types.labelImage ? 4 : 2
-      token.type = types.data
-      index += offset
-    }
-  }
-
-  // If the events are equal, we don't have to copy newEvents to events
-  if (events.length !== newEvents.length) {
-    splice(events, 0, events.length, newEvents)
-  }
-
-  return events
-}
-
-/** @type {Resolver} */
-function resolveToLabelEnd(events, context) {
-  let index = events.length
-  let offset = 0
-  /** @type {number | undefined} */
-  let open
-  /** @type {number | undefined} */
-  let close
-  /** @type {Array<Event>} */
-  let media
-
-  // Find an opening.
-  while (index--) {
-    const token = events[index][1]
-
-    if (open) {
-      // If we see another link, or inactive link label, we’ve been here before.
-      if (
-        token.type === types.link ||
-        (token.type === types.labelLink && token._inactive)
-      ) {
-        break
-      }
-
-      // Mark other link openings as inactive, as we can’t have links in
-      // links.
-      if (events[index][0] === 'enter' && token.type === types.labelLink) {
-        token._inactive = true
-      }
-    } else if (close) {
-      if (
-        events[index][0] === 'enter' &&
-        (token.type === types.labelImage || token.type === types.labelLink) &&
-        !token._balanced
-      ) {
-        open = index
-
-        if (token.type !== types.labelLink) {
-          offset = 2
-          break
-        }
-      }
-    } else if (token.type === types.labelEnd) {
-      close = index
-    }
-  }
-
-  assert(open !== undefined, '`open` is supposed to be found')
-  assert(close !== undefined, '`close` is supposed to be found')
-
-  const group = {
-    type: events[open][1].type === types.labelLink ? types.link : types.image,
-    start: {...events[open][1].start},
-    end: {...events[events.length - 1][1].end}
-  }
-
-  const label = {
-    type: types.label,
-    start: {...events[open][1].start},
-    end: {...events[close][1].end}
-  }
-
-  const text = {
-    type: types.labelText,
-    start: {...events[open + offset + 2][1].end},
-    end: {...events[close - 2][1].start}
-  }
-
-  media = [
-    ['enter', group, context],
-    ['enter', label, context]
-  ]
-
-  // Opening marker.
-  media = push(media, events.slice(open + 1, open + offset + 3))
-
-  // Text open.
-  media = push(media, [['enter', text, context]])
-
-  // Always populated by defaults.
-  assert(
-    context.parser.constructs.insideSpan.null,
-    'expected `insideSpan.null` to be populated'
-  )
-  // Between.
-  media = push(
-    media,
-    resolveAll(
-      context.parser.constructs.insideSpan.null,
-      events.slice(open + offset + 4, close - 3),
-      context
-    )
-  )
-
-  // Text close, marker close, label close.
-  media = push(media, [
-    ['exit', text, context],
-    events[close - 2],
-    events[close - 1],
-    ['exit', label, context]
-  ])
-
-  // Reference, resource, or so.
-  media = push(media, events.slice(close + 1))
-
-  // Media close.
-  media = push(media, [['exit', group, context]])
-
-  splice(events, open, events.length, media)
-
-  return events
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeLabelEnd(effects, ok, nok) {
-  const self = this
-  const labelStarts = self._labelStarts
-  /** @type {Token} */
-  let labelStart
-  /** @type {boolean} */
-  let defined
-
-  if (labelStarts) {
-    // Discard ones that failed to close,
-    // they’re not needed anymore.
-    while (
-      labelStarts.length > 0 &&
-      labelStarts[labelStarts.length - 1]._balanced
-    ) {
-      labelStarts.pop()
-    }
-
-    labelStart = labelStarts[labelStarts.length - 1]
-  }
-
-  return start
-
-  /**
-   * Start of label end.
-   *
-   * ```markdown
-   * > | [a](b) c
-   *       ^
-   * > | [a][b] c
-   *       ^
-   * > | [a][] b
-   *       ^
-   * > | [a] b
-   * ```
-   *
-   * @type {State}
-   */
-  function start(code) {
-    assert(code === codes.rightSquareBracket, 'expected `]`')
-
-    // If there is not an okay opening.
-    if (!labelStart) {
-      return nok(code)
-    }
-
-    // If the corresponding label (link) start is marked as inactive,
-    // it means we’d be wrapping a link, like this:
-    //
-    // ```markdown
-    // > | a [b [c](d) e](f) g.
-    //                  ^
-    // ```
-    //
-    // We can’t have that, so it’s just balanced brackets.
-    if (labelStart._inactive) {
-      return labelEndNok(code)
-    }
-
-    defined = self.parser.defined.includes(
-      normalizeIdentifier(
-        self.sliceSerialize({start: labelStart.end, end: self.now()})
-      )
-    )
-    effects.enter(types.labelEnd)
-    effects.enter(types.labelMarker)
-    effects.consume(code)
-    effects.exit(types.labelMarker)
-    effects.exit(types.labelEnd)
-    return after
-  }
-
-  /**
-   * After `]`.
-   *
-   * ```markdown
-   * > | [a](b) c
-   *       ^
-   * > | [a][b] c
-   *       ^
-   * > | [a][] b
-   *       ^
-   * > | [a] b
-   *       ^
-   * ```
-   *
-   * @type {State}
-   */
-  function after(code) {
-    // Note: `markdown-rs` also parses GFM footnotes here, which for us is in
-    // an extension.
-
-    // Resource (`[asd](fgh)`)?
-    if (code === codes.leftParenthesis) {
-      return effects.attempt(
-        resourceConstruct,
-        labelEndOk,
-        defined ? labelEndOk : labelEndNok
-      )(code)
-    }
-
-    // Full (`[asd][fgh]`) or collapsed (`[asd][]`) reference?
-    if (code === codes.leftSquareBracket) {
-      return effects.attempt(
-        referenceFullConstruct,
-        labelEndOk,
-        defined ? referenceNotFull : labelEndNok
-      )(code)
-    }
-
-    // Shortcut (`[asd]`) reference?
-    return defined ? labelEndOk(code) : labelEndNok(code)
-  }
-
-  /**
-   * After `]`, at `[`, but not at a full reference.
-   *
-   * > 👉 **Note**: we only get here if the label is defined.
-   *
-   * ```markdown
-   * > | [a][] b
-   *        ^
-   * > | [a] b
-   *        ^
-   * ```
-   *
-   * @type {State}
-   */
-  function referenceNotFull(code) {
-    return effects.attempt(
-      referenceCollapsedConstruct,
-      labelEndOk,
-      labelEndNok
-    )(code)
-  }
-
-  /**
-   * Done, we found something.
-   *
-   * ```markdown
-   * > | [a](b) c
-   *           ^
-   * > | [a][b] c
-   *           ^
-   * > | [a][] b
-   *          ^
-   * > | [a] b
-   *        ^
-   * ```
-   *
-   * @type {State}
-   */
-  function labelEndOk(code) {
-    // Note: `markdown-rs` does a bunch of stuff here.
-    // This label start is now used up: discard it so it’s never found again.
-    assert(labelStarts, 'expected `labelStarts` to be populated')
-    labelStarts.pop()
-    return ok(code)
-  }
-
-  /**
-   * Done, it’s nothing.
-   *
-   * There was an okay opening, but we didn’t match anything.
-   *
-   * ```markdown
-   * > | [a](b c
-   *        ^
-   * > | [a][b c
-   *        ^
-   * > | [a] b
-   *        ^
-   * ```
-   *
-   * @type {State}
-   */
-  function labelEndNok(code) {
-    labelStart._balanced = true
-    return nok(code)
-  }
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeResource(effects, ok, nok) {
-  return resourceStart
-
-  /**
-   * At a resource.
-   *
-   * ```markdown
-   * > | [a](b) c
-   *        ^
-   * ```
-   *
-   * @type {State}
-   */
-  function resourceStart(code) {
-    assert(code === codes.leftParenthesis, 'expected left paren')
-    effects.enter(types.resource)
-    effects.enter(types.resourceMarker)
-    effects.consume(code)
-    effects.exit(types.resourceMarker)
-    return resourceBefore
-  }
-
-  /**
-   * In resource, after `(`, at optional whitespace.
-   *
-   * ```markdown
-   * > | [a](b) c
-   *         ^
-   * ```
-   *
-   * @type {State}
-   */
-  function resourceBefore(code) {
-    return markdownLineEndingOrSpace(code)
-      ? factoryWhitespace(effects, resourceOpen)(code)
-      : resourceOpen(code)
-  }
-
-  /**
-   * In resource, after optional whitespace, at `)` or a destination.
-   *
-   * ```markdown
-   * > | [a](b) c
-   *         ^
-   * ```
-   *
-   * @type {State}
-   */
-  function resourceOpen(code) {
-    if (code === codes.rightParenthesis) {
-      return resourceEnd(code)
-    }
-
-    return factoryDestination(
-      effects,
-      resourceDestinationAfter,
-      resourceDestinationMissing,
-      types.resourceDestination,
-      types.resourceDestinationLiteral,
-      types.resourceDestinationLiteralMarker,
-      types.resourceDestinationRaw,
-      types.resourceDestinationString,
-      constants.linkResourceDestinationBalanceMax
-    )(code)
-  }
-
-  /**
-   * In resource, after destination, at optional whitespace.
-   *
-   * ```markdown
-   * > | [a](b) c
-   *          ^
-   * ```
-   *
-   * @type {State}
-   */
-  function resourceDestinationAfter(code) {
-    return markdownLineEndingOrSpace(code)
-      ? factoryWhitespace(effects, resourceBetween)(code)
-      : resourceEnd(code)
-  }
-
-  /**
-   * At invalid destination.
-   *
-   * ```markdown
-   * > | [a](<<) b
-   *         ^
-   * ```
-   *
-   * @type {State}
-   */
-  function resourceDestinationMissing(code) {
-    return nok(code)
-  }
-
-  /**
-   * In resource, after destination and whitespace, at `(` or title.
-   *
-   * ```markdown
-   * > | [a](b ) c
-   *           ^
-   * ```
-   *
-   * @type {State}
-   */
-  function resourceBetween(code) {
-    if (
-      code === codes.quotationMark ||
-      code === codes.apostrophe ||
-      code === codes.leftParenthesis
-    ) {
-      return factoryTitle(
-        effects,
-        resourceTitleAfter,
-        nok,
-        types.resourceTitle,
-        types.resourceTitleMarker,
-        types.resourceTitleString
-      )(code)
-    }
-
-    return resourceEnd(code)
-  }
-
-  /**
-   * In resource, after title, at optional whitespace.
-   *
-   * ```markdown
-   * > | [a](b "c") d
-   *              ^
-   * ```
-   *
-   * @type {State}
-   */
-  function resourceTitleAfter(code) {
-    return markdownLineEndingOrSpace(code)
-      ? factoryWhitespace(effects, resourceEnd)(code)
-      : resourceEnd(code)
-  }
-
-  /**
-   * In resource, at `)`.
-   *
-   * ```markdown
-   * > | [a](b) d
-   *          ^
-   * ```
-   *
-   * @type {State}
-   */
-  function resourceEnd(code) {
-    if (code === codes.rightParenthesis) {
-      effects.enter(types.resourceMarker)
-      effects.consume(code)
-      effects.exit(types.resourceMarker)
-      effects.exit(types.resource)
-      return ok
-    }
-
-    return nok(code)
-  }
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeReferenceFull(effects, ok, nok) {
-  const self = this
-
-  return referenceFull
-
-  /**
-   * In a reference (full), at the `[`.
-   *
-   * ```markdown
-   * > | [a][b] d
-   *        ^
-   * ```
-   *
-   * @type {State}
-   */
-  function referenceFull(code) {
-    assert(code === codes.leftSquareBracket, 'expected left bracket')
-    return factoryLabel.call(
-      self,
-      effects,
-      referenceFullAfter,
-      referenceFullMissing,
-      types.reference,
-      types.referenceMarker,
-      types.referenceString
-    )(code)
-  }
-
-  /**
-   * In a reference (full), after `]`.
-   *
-   * ```markdown
-   * > | [a][b] d
-   *          ^
-   * ```
-   *
-   * @type {State}
-   */
-  function referenceFullAfter(code) {
-    return self.parser.defined.includes(
-      normalizeIdentifier(
-        self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
-      )
-    )
-      ? ok(code)
-      : nok(code)
-  }
-
-  /**
-   * In reference (full) that was missing.
-   *
-   * ```markdown
-   * > | [a][b d
-   *        ^
-   * ```
-   *
-   * @type {State}
-   */
-  function referenceFullMissing(code) {
-    return nok(code)
-  }
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- */
-function tokenizeReferenceCollapsed(effects, ok, nok) {
-  return referenceCollapsedStart
-
-  /**
-   * In reference (collapsed), at `[`.
-   *
-   * > 👉 **Note**: we only get here if the label is defined.
-   *
-   * ```markdown
-   * > | [a][] d
-   *        ^
-   * ```
-   *
-   * @type {State}
-   */
-  function referenceCollapsedStart(code) {
-    // We only attempt a collapsed label if there’s a `[`.
-    assert(code === codes.leftSquareBracket, 'expected left bracket')
-    effects.enter(types.reference)
-    effects.enter(types.referenceMarker)
-    effects.consume(code)
-    effects.exit(types.referenceMarker)
-    return referenceCollapsedOpen
-  }
-
-  /**
-   * In reference (collapsed), at `]`.
-   *
-   * > 👉 **Note**: we only get here if the label is defined.
-   *
-   * ```markdown
-   * > | [a][] d
-   *         ^
-   * ```
-   *
-   *  @type {State}
-   */
-  function referenceCollapsedOpen(code) {
-    if (code === codes.rightSquareBracket) {
-      effects.enter(types.referenceMarker)
-      effects.consume(code)
-      effects.exit(types.referenceMarker)
-      effects.exit(types.reference)
-      return ok
-    }
-
-    return nok(code)
-  }
-}

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

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

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

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