taskchef 8.6.2 → 8.7.0

package/node_modules/micromark-core-commonmark/dev/lib/character-reference.js

@@ -0,0 +1,166 @@
+/**
+ * @import {
+ *   Code,
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {decodeNamedCharacterReference} from 'decode-named-character-reference'
+import {
+  asciiAlphanumeric,
+  asciiDigit,
+  asciiHexDigit
+} from 'micromark-util-character'
+import {codes, constants, types} from 'micromark-util-symbol'
+
+/** @type {Construct} */
+export const characterReference = {
+  name: 'characterReference',
+  tokenize: tokenizeCharacterReference
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeCharacterReference(effects, ok, nok) {
+  const self = this
+  let size = 0
+  /** @type {number} */
+  let max
+  /** @type {(code: Code) => boolean} */
+  let test
+
+  return start
+
+  /**
+   * Start of character reference.
+   *
+   * ```markdown
+   * > | a&b
+   *      ^
+   * > | a{b
+   *      ^
+   * > | a	b
+   *      ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    assert(code === codes.ampersand, 'expected `&`')
+    effects.enter(types.characterReference)
+    effects.enter(types.characterReferenceMarker)
+    effects.consume(code)
+    effects.exit(types.characterReferenceMarker)
+    return open
+  }
+
+  /**
+   * After `&`, at `#` for numeric references or alphanumeric for named
+   * references.
+   *
+   * ```markdown
+   * > | a&b
+   *       ^
+   * > | a{b
+   *       ^
+   * > | a	b
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function open(code) {
+    if (code === codes.numberSign) {
+      effects.enter(types.characterReferenceMarkerNumeric)
+      effects.consume(code)
+      effects.exit(types.characterReferenceMarkerNumeric)
+      return numeric
+    }
+
+    effects.enter(types.characterReferenceValue)
+    max = constants.characterReferenceNamedSizeMax
+    test = asciiAlphanumeric
+    return value(code)
+  }
+
+  /**
+   * After `#`, at `x` for hexadecimals or digit for decimals.
+   *
+   * ```markdown
+   * > | a{b
+   *        ^
+   * > | a	b
+   *        ^
+   * ```
+   *
+   * @type {State}
+   */
+  function numeric(code) {
+    if (code === codes.uppercaseX || code === codes.lowercaseX) {
+      effects.enter(types.characterReferenceMarkerHexadecimal)
+      effects.consume(code)
+      effects.exit(types.characterReferenceMarkerHexadecimal)
+      effects.enter(types.characterReferenceValue)
+      max = constants.characterReferenceHexadecimalSizeMax
+      test = asciiHexDigit
+      return value
+    }
+
+    effects.enter(types.characterReferenceValue)
+    max = constants.characterReferenceDecimalSizeMax
+    test = asciiDigit
+    return value(code)
+  }
+
+  /**
+   * After markers (`&#x`, `&#`, or `&`), in value, before `;`.
+   *
+   * The character reference kind defines what and how many characters are
+   * allowed.
+   *
+   * ```markdown
+   * > | a&b
+   *       ^^^
+   * > | a{b
+   *        ^^^
+   * > | a	b
+   *         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function value(code) {
+    if (code === codes.semicolon && size) {
+      const token = effects.exit(types.characterReferenceValue)
+
+      if (
+        test === asciiAlphanumeric &&
+        !decodeNamedCharacterReference(self.sliceSerialize(token))
+      ) {
+        return nok(code)
+      }
+
+      // To do: `markdown-rs` uses a different name:
+      // `CharacterReferenceMarkerSemi`.
+      effects.enter(types.characterReferenceMarker)
+      effects.consume(code)
+      effects.exit(types.characterReferenceMarker)
+      effects.exit(types.characterReference)
+      return ok
+    }
+
+    if (test(code) && size++ < max) {
+      effects.consume(code)
+      return value
+    }
+
+    return nok(code)
+  }
+}

package/node_modules/micromark-core-commonmark/dev/lib/code-fenced.d.ts

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

package/node_modules/micromark-core-commonmark/dev/lib/code-fenced.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"code-fenced.d.ts","sourceRoot":"","sources":["code-fenced.js"],"names":[],"mappings":"AAgBA,wBAAwB;AACxB,yBADW,SAAS,CAKnB;+BAdS,sBAAsB"}

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

@@ -0,0 +1,472 @@
+/**
+ * @import {
+ *   Code,
+ *   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'
+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) {
+    assert(
+      code === codes.graveAccent || code === codes.tilde,
+      'expected `` ` `` or `~`'
+    )
+
+    const tail = self.events[self.events.length - 1]
+    initialPrefix =
+      tail && tail[1].type === types.linePrefix
+        ? tail[2].sliceSerialize(tail[1], true).length
+        : 0
+
+    marker = code
+    effects.enter(types.codeFenced)
+    effects.enter(types.codeFencedFence)
+    effects.enter(types.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 < constants.codeFencedSequenceSizeMin) {
+      return nok(code)
+    }
+
+    effects.exit(types.codeFencedFenceSequence)
+    return markdownSpace(code)
+      ? factorySpace(effects, infoBefore, types.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 === codes.eof || markdownLineEnding(code)) {
+      effects.exit(types.codeFencedFence)
+      return self.interrupt
+        ? ok(code)
+        : effects.check(nonLazyContinuation, atNonLazyBreak, after)(code)
+    }
+
+    effects.enter(types.codeFencedFenceInfo)
+    effects.enter(types.chunkString, {contentType: constants.contentTypeString})
+    return info(code)
+  }
+
+  /**
+   * In info.
+   *
+   * ```markdown
+   * > | ~~~js
+   *        ^
+   *   | alert(1)
+   *   | ~~~
+   * ```
+   *
+   * @type {State}
+   */
+  function info(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      effects.exit(types.chunkString)
+      effects.exit(types.codeFencedFenceInfo)
+      return infoBefore(code)
+    }
+
+    if (markdownSpace(code)) {
+      effects.exit(types.chunkString)
+      effects.exit(types.codeFencedFenceInfo)
+      return factorySpace(effects, metaBefore, types.whitespace)(code)
+    }
+
+    if (code === codes.graveAccent && 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 === codes.eof || markdownLineEnding(code)) {
+      return infoBefore(code)
+    }
+
+    effects.enter(types.codeFencedFenceMeta)
+    effects.enter(types.chunkString, {contentType: constants.contentTypeString})
+    return meta(code)
+  }
+
+  /**
+   * In meta.
+   *
+   * ```markdown
+   * > | ~~~js eval
+   *           ^
+   *   | alert(1)
+   *   | ~~~
+   * ```
+   *
+   * @type {State}
+   */
+  function meta(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      effects.exit(types.chunkString)
+      effects.exit(types.codeFencedFenceMeta)
+      return infoBefore(code)
+    }
+
+    if (code === codes.graveAccent && 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) {
+    assert(markdownLineEnding(code), 'expected eol')
+    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) {
+    assert(markdownLineEnding(code), 'expected eol')
+    effects.enter(types.lineEnding)
+    effects.consume(code)
+    effects.exit(types.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,
+          types.linePrefix,
+          initialPrefix + 1
+        )(code)
+      : beforeContentChunk(code)
+  }
+
+  /**
+   * Before code content, after optional prefix.
+   *
+   * ```markdown
+   *   | ~~~js
+   * > | alert(1)
+   *     ^
+   *   | ~~~
+   * ```
+   *
+   * @type {State}
+   */
+  function beforeContentChunk(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      return effects.check(nonLazyContinuation, atNonLazyBreak, after)(code)
+    }
+
+    effects.enter(types.codeFlowValue)
+    return contentChunk(code)
+  }
+
+  /**
+   * In code content.
+   *
+   * ```markdown
+   *   | ~~~js
+   * > | alert(1)
+   *     ^^^^^^^^
+   *   | ~~~
+   * ```
+   *
+   * @type {State}
+   */
+  function contentChunk(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      effects.exit(types.codeFlowValue)
+      return beforeContentChunk(code)
+    }
+
+    effects.consume(code)
+    return contentChunk
+  }
+
+  /**
+   * After code.
+   *
+   * ```markdown
+   *   | ~~~js
+   *   | alert(1)
+   * > | ~~~
+   *        ^
+   * ```
+   *
+   * @type {State}
+   */
+  function after(code) {
+    effects.exit(types.codeFenced)
+    return ok(code)
+  }
+
+  /**
+   * @this {TokenizeContext}
+   *   Context.
+   * @type {Tokenizer}
+   */
+  function tokenizeCloseStart(effects, ok, nok) {
+    let size = 0
+
+    return startBefore
+
+    /**
+     *
+     *
+     * @type {State}
+     */
+    function startBefore(code) {
+      assert(markdownLineEnding(code), 'expected eol')
+      effects.enter(types.lineEnding)
+      effects.consume(code)
+      effects.exit(types.lineEnding)
+      return start
+    }
+
+    /**
+     * Before closing fence, at optional whitespace.
+     *
+     * ```markdown
+     *   | ~~~js
+     *   | alert(1)
+     * > | ~~~
+     *     ^
+     * ```
+     *
+     * @type {State}
+     */
+    function start(code) {
+      // Always populated by defaults.
+      assert(
+        self.parser.constructs.disable.null,
+        'expected `disable.null` to be populated'
+      )
+
+      // To do: `enter` here or in next state?
+      effects.enter(types.codeFencedFence)
+      return markdownSpace(code)
+        ? factorySpace(
+            effects,
+            beforeSequenceClose,
+            types.linePrefix,
+            self.parser.constructs.disable.null.includes('codeIndented')
+              ? undefined
+              : constants.tabSize
+          )(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(types.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(types.codeFencedFenceSequence)
+        return markdownSpace(code)
+          ? factorySpace(effects, sequenceCloseAfter, types.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 === codes.eof || markdownLineEnding(code)) {
+        effects.exit(types.codeFencedFence)
+        return ok(code)
+      }
+
+      return nok(code)
+    }
+  }
+}

package/node_modules/micromark-core-commonmark/dev/lib/code-indented.d.ts

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

package/node_modules/micromark-core-commonmark/dev/lib/code-indented.d.ts.map

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