@rse/ase 0.0.42 → 0.0.44

package/plugin/node_modules/micromark-core-commonmark/dev/lib/code-indented.js

@@ -1,202 +0,0 @@
-/**
- * @import {
- *   Construct,
- *   State,
- *   TokenizeContext,
- *   Tokenizer
- * } from 'micromark-util-types'
- */
-
-import {ok as assert} from 'devlop'
-import {factorySpace} 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) {
-  const self = this
-  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)
-    // To do: use an improved `space_or_tab` function like `markdown-rs`,
-    // so that we can drop the next state.
-    return factorySpace(
-      effects,
-      afterPrefix,
-      types.linePrefix,
-      constants.tabSize + 1
-    )(code)
-  }
-
-  /**
-   * At start, after 1 or 4 spaces.
-   *
-   * ```markdown
-   * > |     aaa
-   *         ^
-   * ```
-   *
-   * @type {State}
-   */
-  function afterPrefix(code) {
-    const tail = self.events[self.events.length - 1]
-    return tail &&
-      tail[1].type === types.linePrefix &&
-      tail[2].sliceSerialize(tail[1], true).length >= constants.tabSize
-      ? atBreak(code)
-      : nok(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.
-    //
-    // To do: use an improved `space_or_tab` function like `markdown-rs`,
-    // so that we can drop the next state.
-    return factorySpace(
-      effects,
-      afterPrefix,
-      types.linePrefix,
-      constants.tabSize + 1
-    )(code)
-  }
-
-  /**
-   * At start, after 1 or 4 spaces.
-   *
-   * ```markdown
-   * > |     aaa
-   *         ^
-   * ```
-   *
-   * @type {State}
-   */
-  function afterPrefix(code) {
-    const tail = self.events[self.events.length - 1]
-    return tail &&
-      tail[1].type === types.linePrefix &&
-      tail[2].sliceSerialize(tail[1], true).length >= constants.tabSize
-      ? ok(code)
-      : markdownLineEnding(code)
-        ? furtherStart(code)
-        : nok(code)
-  }
-}

package/plugin/node_modules/micromark-core-commonmark/dev/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/plugin/node_modules/micromark-core-commonmark/dev/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"}

package/plugin/node_modules/micromark-core-commonmark/dev/lib/code-text.js

@@ -1,257 +0,0 @@
-/**
- * @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/plugin/node_modules/micromark-core-commonmark/dev/lib/content.d.ts

@@ -1,7 +0,0 @@
-/**
- * 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/plugin/node_modules/micromark-core-commonmark/dev/lib/content.d.ts.map

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

package/plugin/node_modules/micromark-core-commonmark/dev/lib/content.js

@@ -1,185 +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 {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/plugin/node_modules/micromark-core-commonmark/dev/lib/definition.d.ts

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

package/plugin/node_modules/micromark-core-commonmark/dev/lib/definition.d.ts.map

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