@alexlit/lint-kit 216.0.0 → 217.0.0

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

@@ -1,99 +0,0 @@
-/**
- * @import {
- *   InitialConstruct,
- *   Initializer,
- *   State,
- *   TokenizeContext,
- *   Token
- * } from 'micromark-util-types'
- */
-
-import {ok as assert} from 'devlop'
-import {factorySpace} from 'micromark-factory-space'
-import {markdownLineEnding} from 'micromark-util-character'
-import {codes, constants, types} from 'micromark-util-symbol'
-
-/** @type {InitialConstruct} */
-export const content = {tokenize: initializeContent}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Initializer}
- *   Content.
- */
-function initializeContent(effects) {
-  const contentStart = effects.attempt(
-    this.parser.constructs.contentInitial,
-    afterContentStartConstruct,
-    paragraphInitial
-  )
-  /** @type {Token} */
-  let previous
-
-  return contentStart
-
-  /** @type {State} */
-  function afterContentStartConstruct(code) {
-    assert(
-      code === codes.eof || markdownLineEnding(code),
-      'expected eol or eof'
-    )
-
-    if (code === codes.eof) {
-      effects.consume(code)
-      return
-    }
-
-    effects.enter(types.lineEnding)
-    effects.consume(code)
-    effects.exit(types.lineEnding)
-    return factorySpace(effects, contentStart, types.linePrefix)
-  }
-
-  /** @type {State} */
-  function paragraphInitial(code) {
-    assert(
-      code !== codes.eof && !markdownLineEnding(code),
-      'expected anything other than a line ending or EOF'
-    )
-    effects.enter(types.paragraph)
-    return lineStart(code)
-  }
-
-  /** @type {State} */
-  function lineStart(code) {
-    const token = effects.enter(types.chunkText, {
-      contentType: constants.contentTypeText,
-      previous
-    })
-
-    if (previous) {
-      previous.next = token
-    }
-
-    previous = token
-
-    return data(code)
-  }
-
-  /** @type {State} */
-  function data(code) {
-    if (code === codes.eof) {
-      effects.exit(types.chunkText)
-      effects.exit(types.paragraph)
-      effects.consume(code)
-      return
-    }
-
-    if (markdownLineEnding(code)) {
-      effects.consume(code)
-      effects.exit(types.chunkText)
-      return lineStart
-    }
-
-    // Data.
-    effects.consume(code)
-    return data
-  }
-}

package/packages/config-markdownlint/node_modules/micromark/dev/lib/initialize/document.d.ts

@@ -1,10 +0,0 @@
-/** @type {InitialConstruct} */
-export const document: InitialConstruct;
-/**
- * Construct and its state.
- */
-export type StackItem = [Construct, ContainerState];
-import type { InitialConstruct } from 'micromark-util-types';
-import type { Construct } from 'micromark-util-types';
-import type { ContainerState } from 'micromark-util-types';
-//# sourceMappingURL=document.d.ts.map

package/packages/config-markdownlint/node_modules/micromark/dev/lib/initialize/document.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"document.d.ts","sourceRoot":"","sources":["document.js"],"names":[],"mappings":"AAyBA,+BAA+B;AAC/B,uBADW,gBAAgB,CAC2B;;;;wBAXzC,CAAC,SAAS,EAAE,cAAc,CAAC;sCAJ9B,sBAAsB;+BAAtB,sBAAsB;oCAAtB,sBAAsB"}

package/packages/config-markdownlint/node_modules/micromark/dev/lib/initialize/document.js

@@ -1,449 +0,0 @@
-/**
- * @import {
- *   Construct,
- *   ContainerState,
- *   InitialConstruct,
- *   Initializer,
- *   Point,
- *   State,
- *   TokenizeContext,
- *   Tokenizer,
- *   Token
- * } from 'micromark-util-types'
- */
-
-/**
- * @typedef {[Construct, ContainerState]} StackItem
- *   Construct and its state.
- */
-
-import {ok as assert} from 'devlop'
-import {factorySpace} from 'micromark-factory-space'
-import {markdownLineEnding} from 'micromark-util-character'
-import {EditMap} from 'micromark-util-edit-map'
-import {codes, constants, types} from 'micromark-util-symbol'
-
-/** @type {InitialConstruct} */
-export const document = {tokenize: initializeDocument}
-
-/** @type {Construct} */
-const containerConstruct = {tokenize: tokenizeContainer}
-
-/**
- * @this {TokenizeContext}
- *   Self.
- * @type {Initializer}
- *   Initializer.
- */
-function initializeDocument(effects) {
-  const self = this
-  /** @type {Array<StackItem>} */
-  const stack = []
-  let continued = 0
-  /** @type {TokenizeContext | undefined} */
-  let childFlow
-  /** @type {Token | undefined} */
-  let childToken
-  /** @type {number} */
-  let lineStartOffset
-
-  return start
-
-  /** @type {State} */
-  function start(code) {
-    // First we iterate through the open blocks, starting with the root
-    // document, and descending through last children down to the last open
-    // block.
-    // Each block imposes a condition that the line must satisfy if the block is
-    // to remain open.
-    // For example, a block quote requires a `>` character.
-    // A paragraph requires a non-blank line.
-    // In this phase we may match all or just some of the open blocks.
-    // But we cannot close unmatched blocks yet, because we may have a lazy
-    // continuation line.
-    if (continued < stack.length) {
-      const item = stack[continued]
-      self.containerState = item[1]
-      assert(
-        item[0].continuation,
-        'expected `continuation` to be defined on container construct'
-      )
-      return effects.attempt(
-        item[0].continuation,
-        documentContinue,
-        checkNewContainers
-      )(code)
-    }
-
-    // Done.
-    return checkNewContainers(code)
-  }
-
-  /** @type {State} */
-  function documentContinue(code) {
-    assert(
-      self.containerState,
-      'expected `containerState` to be defined after continuation'
-    )
-
-    continued++
-
-    // Note: this field is called `_closeFlow` but it also closes containers.
-    // Perhaps a good idea to rename it but it’s already used in the wild by
-    // extensions.
-    if (self.containerState._closeFlow) {
-      self.containerState._closeFlow = undefined
-
-      if (childFlow) {
-        closeFlow()
-      }
-
-      // Note: this algorithm for moving events around is similar to the
-      // algorithm when dealing with lazy lines in `writeToChild`.
-      const indexBeforeExits = self.events.length
-      let indexBeforeFlow = indexBeforeExits
-      /** @type {Point | undefined} */
-      let point
-
-      // Find the flow chunk.
-      while (indexBeforeFlow--) {
-        if (
-          self.events[indexBeforeFlow][0] === 'exit' &&
-          self.events[indexBeforeFlow][1].type === types.chunkFlow
-        ) {
-          point = self.events[indexBeforeFlow][1].end
-          break
-        }
-      }
-
-      assert(point, 'could not find previous flow chunk')
-
-      exitContainers(continued)
-
-      // Fix positions.
-      let index = indexBeforeExits
-
-      while (index < self.events.length) {
-        self.events[index][1].end = {...point}
-        index++
-      }
-
-      const editMap = new EditMap()
-      // Inject the exits earlier (they’re still also at the end).
-      editMap.add(indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits))
-      // Discard the duplicate exits.
-      editMap.add(indexBeforeExits, index - indexBeforeExits, [])
-      editMap.consume(self.events)
-
-      return checkNewContainers(code)
-    }
-
-    return start(code)
-  }
-
-  /** @type {State} */
-  function checkNewContainers(code) {
-    // Next, after consuming the continuation markers for existing blocks, we
-    // look for new block starts (e.g. `>` for a block quote).
-    // If we encounter a new block start, we close any blocks unmatched in
-    // step 1 before creating the new block as a child of the last matched
-    // block.
-    if (continued === stack.length) {
-      // No need to `check` whether there’s a container, of `exitContainers`
-      // would be moot.
-      // We can instead immediately `attempt` to parse one.
-      if (!childFlow) {
-        return documentContinued(code)
-      }
-
-      // If we have concrete content, such as block HTML or fenced code,
-      // we can’t have containers “pierce” into them, so we can immediately
-      // start.
-      if (childFlow.currentConstruct && childFlow.currentConstruct.concrete) {
-        return flowStart(code)
-      }
-
-      // If we do have flow, it could still be a blank line,
-      // but we’d be interrupting it w/ a new container if there’s a current
-      // construct.
-      // To do: next major: remove `_gfmTableDynamicInterruptHack` (no longer
-      // needed in micromark-extension-gfm-table@1.0.6).
-      self.interrupt = Boolean(
-        childFlow.currentConstruct && !childFlow._gfmTableDynamicInterruptHack
-      )
-    }
-
-    // Check if there is a new container.
-    self.containerState = {}
-    return effects.check(
-      containerConstruct,
-      thereIsANewContainer,
-      thereIsNoNewContainer
-    )(code)
-  }
-
-  /** @type {State} */
-  function thereIsANewContainer(code) {
-    if (childFlow) {
-      closeFlow()
-    }
-
-    exitContainers(continued)
-    return documentContinued(code)
-  }
-
-  /** @type {State} */
-  function thereIsNoNewContainer(code) {
-    self.parser.lazy[self.now().line] = continued !== stack.length
-    lineStartOffset = self.now().offset
-    return flowStart(code)
-  }
-
-  /** @type {State} */
-  function documentContinued(code) {
-    // Try new containers.
-    self.containerState = {}
-    return effects.attempt(
-      containerConstruct,
-      containerContinue,
-      flowStart
-    )(code)
-  }
-
-  /** @type {State} */
-  function containerContinue(code) {
-    assert(
-      self.currentConstruct,
-      'expected `currentConstruct` to be defined on tokenizer'
-    )
-    assert(
-      self.containerState,
-      'expected `containerState` to be defined on tokenizer'
-    )
-    continued++
-    stack.push([self.currentConstruct, self.containerState])
-    // Try another.
-    return documentContinued(code)
-  }
-
-  /** @type {State} */
-  function flowStart(code) {
-    if (code === codes.eof) {
-      if (childFlow) {
-        closeFlow()
-      }
-
-      exitContainers(0)
-      effects.consume(code)
-      return
-    }
-
-    childFlow = childFlow || self.parser.flow(self.now())
-    effects.enter(types.chunkFlow, {
-      _tokenizer: childFlow,
-      contentType: constants.contentTypeFlow,
-      previous: childToken
-    })
-
-    return flowContinue(code)
-  }
-
-  /** @type {State} */
-  function flowContinue(code) {
-    if (code === codes.eof) {
-      writeToChild(effects.exit(types.chunkFlow), true)
-      exitContainers(0)
-      effects.consume(code)
-      return
-    }
-
-    if (markdownLineEnding(code)) {
-      effects.consume(code)
-      writeToChild(effects.exit(types.chunkFlow))
-      // Get ready for the next line.
-      continued = 0
-      self.interrupt = undefined
-      return start
-    }
-
-    effects.consume(code)
-    return flowContinue
-  }
-
-  /**
-   * @param {Token} token
-   *   Token.
-   * @param {boolean | undefined} [endOfFile]
-   *   Whether the token is at the end of the file (default: `false`).
-   * @returns {undefined}
-   *   Nothing.
-   */
-  function writeToChild(token, endOfFile) {
-    assert(childFlow, 'expected `childFlow` to be defined when continuing')
-    const stream = self.sliceStream(token)
-    if (endOfFile) {
-      stream.push(null)
-    }
-
-    token.previous = childToken
-    if (childToken) {
-      childToken.next = token
-    }
-
-    childToken = token
-    childFlow.defineSkip(token.start)
-    childFlow.write(stream)
-
-    // Alright, so we just added a lazy line:
-    //
-    // ```markdown
-    // > a
-    // b.
-    //
-    // Or:
-    //
-    // > ~~~c
-    // d
-    //
-    // Or:
-    //
-    // > | e |
-    // f
-    // ```
-    //
-    // The construct in the second example (fenced code) does not accept lazy
-    // lines, so it marked itself as done at the end of its first line, and
-    // then the content construct parses `d`.
-    // Most constructs in markdown match on the first line: if the first line
-    // forms a construct, a non-lazy line can’t “unmake” it.
-    //
-    // The construct in the third example is potentially a GFM table, and
-    // those are *weird*.
-    // It *could* be a table, from the first line, if the following line
-    // matches a condition.
-    // In this case, that second line is lazy, which “unmakes” the first line
-    // and turns the whole into one content block.
-    //
-    // We’ve now parsed the non-lazy and the lazy line, and can figure out
-    // whether the lazy line started a new flow block.
-    // If it did, we exit the current containers between the two flow blocks.
-    if (self.parser.lazy[token.start.line]) {
-      let index = childFlow.events.length
-
-      while (index--) {
-        if (
-          // The token starts before the line ending…
-          childFlow.events[index][1].start.offset < lineStartOffset &&
-          // …and either is not ended yet…
-          (!childFlow.events[index][1].end ||
-            // …or ends after it.
-            childFlow.events[index][1].end.offset > lineStartOffset)
-        ) {
-          // Exit: there’s still something open, which means it’s a lazy line
-          // part of something.
-          return
-        }
-      }
-
-      // Note: this algorithm for moving events around is similar to the
-      // algorithm when closing flow in `documentContinue`.
-      const indexBeforeExits = self.events.length
-      let indexBeforeFlow = indexBeforeExits
-      /** @type {boolean | undefined} */
-      let seen
-      /** @type {Point | undefined} */
-      let point
-
-      // Find the previous chunk (the one before the lazy line).
-      while (indexBeforeFlow--) {
-        if (
-          self.events[indexBeforeFlow][0] === 'exit' &&
-          self.events[indexBeforeFlow][1].type === types.chunkFlow
-        ) {
-          if (seen) {
-            point = self.events[indexBeforeFlow][1].end
-            break
-          }
-
-          seen = true
-        }
-      }
-
-      assert(point, 'could not find previous flow chunk')
-
-      exitContainers(continued)
-
-      // Fix positions.
-      index = indexBeforeExits
-
-      while (index < self.events.length) {
-        self.events[index][1].end = {...point}
-        index++
-      }
-
-      const editMap = new EditMap()
-      // Inject the exits earlier (they’re still also at the end).
-      editMap.add(indexBeforeFlow + 1, 0, self.events.slice(indexBeforeExits))
-      // Discard the duplicate exits.
-      editMap.add(indexBeforeExits, index - indexBeforeExits, [])
-      editMap.consume(self.events)
-    }
-  }
-
-  /**
-   * @param {number} size
-   *   Size.
-   * @returns {undefined}
-   *   Nothing.
-   */
-  function exitContainers(size) {
-    let index = stack.length
-
-    // Exit open containers.
-    while (index-- > size) {
-      const entry = stack[index]
-      self.containerState = entry[1]
-      assert(
-        entry[0].exit,
-        'expected `exit` to be defined on container construct'
-      )
-      entry[0].exit.call(self, effects)
-    }
-
-    stack.length = size
-  }
-
-  function closeFlow() {
-    assert(
-      self.containerState,
-      'expected `containerState` to be defined when closing flow'
-    )
-    assert(childFlow, 'expected `childFlow` to be defined when closing it')
-    childFlow.write([codes.eof])
-    childToken = undefined
-    childFlow = undefined
-    self.containerState._closeFlow = undefined
-  }
-}
-
-/**
- * @this {TokenizeContext}
- *   Context.
- * @type {Tokenizer}
- *   Tokenizer.
- */
-function tokenizeContainer(effects, ok, nok) {
-  // Always populated by defaults.
-  assert(
-    this.parser.constructs.disable.null,
-    'expected `disable.null` to be populated'
-  )
-  return factorySpace(
-    effects,
-    effects.attempt(this.parser.constructs.document, ok, nok),
-    types.linePrefix,
-    this.parser.constructs.disable.null.includes('codeIndented')
-      ? undefined
-      : constants.tabSize
-  )
-}

package/packages/config-markdownlint/node_modules/micromark/dev/lib/initialize/flow.d.ts

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

package/packages/config-markdownlint/node_modules/micromark/dev/lib/initialize/flow.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"flow.d.ts","sourceRoot":"","sources":["flow.js"],"names":[],"mappings":"AAeA,+BAA+B;AAC/B,mBADW,gBAAgB,CACmB;sCAVpC,sBAAsB"}

package/packages/config-markdownlint/node_modules/micromark/dev/lib/initialize/flow.js

@@ -1,86 +0,0 @@
-/**
- * @import {
- *   InitialConstruct,
- *   Initializer,
- *   State,
- *   TokenizeContext
- * } from 'micromark-util-types'
- */
-
-import {ok as assert} from 'devlop'
-import {blankLine, content} from 'micromark-core-commonmark'
-import {factorySpace} from 'micromark-factory-space'
-import {markdownLineEnding} from 'micromark-util-character'
-import {codes, types} from 'micromark-util-symbol'
-
-/** @type {InitialConstruct} */
-export const flow = {tokenize: initializeFlow}
-
-/**
- * @this {TokenizeContext}
- *   Self.
- * @type {Initializer}
- *   Initializer.
- */
-function initializeFlow(effects) {
-  const self = this
-  const initial = effects.attempt(
-    // Try to parse a blank line.
-    blankLine,
-    atBlankEnding,
-    // Try to parse initial flow (essentially, only code).
-    effects.attempt(
-      this.parser.constructs.flowInitial,
-      afterConstruct,
-      factorySpace(
-        effects,
-        effects.attempt(
-          this.parser.constructs.flow,
-          afterConstruct,
-          effects.attempt(content, afterConstruct)
-        ),
-        types.linePrefix
-      )
-    )
-  )
-
-  return initial
-
-  /** @type {State} */
-  function atBlankEnding(code) {
-    assert(
-      code === codes.eof || markdownLineEnding(code),
-      'expected eol or eof'
-    )
-
-    if (code === codes.eof) {
-      effects.consume(code)
-      return
-    }
-
-    effects.enter(types.lineEndingBlank)
-    effects.consume(code)
-    effects.exit(types.lineEndingBlank)
-    self.currentConstruct = undefined
-    return initial
-  }
-
-  /** @type {State} */
-  function afterConstruct(code) {
-    assert(
-      code === codes.eof || markdownLineEnding(code),
-      'expected eol or eof'
-    )
-
-    if (code === codes.eof) {
-      effects.consume(code)
-      return
-    }
-
-    effects.enter(types.lineEnding)
-    effects.consume(code)
-    effects.exit(types.lineEnding)
-    self.currentConstruct = undefined
-    return initial
-  }
-}

package/packages/config-markdownlint/node_modules/micromark/dev/lib/initialize/text.d.ts

@@ -1,8 +0,0 @@
-export namespace resolver {
-    let resolveAll: Resolver;
-}
-export const string: InitialConstruct;
-export const text: InitialConstruct;
-import type { Resolver } from 'micromark-util-types';
-import type { InitialConstruct } from 'micromark-util-types';
-//# sourceMappingURL=text.d.ts.map

package/packages/config-markdownlint/node_modules/micromark/dev/lib/initialize/text.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["text.js"],"names":[],"mappings":";;;AAgBA,sCAAiD;AACjD,oCAA6C;8BATnC,sBAAsB;sCAAtB,sBAAsB"}