taskchef 8.6.2 → 8.7.1

package/node_modules/micromark-util-subtokenize/dev/index.js

@@ -0,0 +1,284 @@
+/**
+ * @import {Chunk, Event, Token} from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {splice} from 'micromark-util-chunked'
+import {codes, types} from 'micromark-util-symbol'
+import {SpliceBuffer} from './lib/splice-buffer.js'
+
+// Hidden API exposed for testing.
+export {SpliceBuffer} from './lib/splice-buffer.js'
+
+/**
+ * Tokenize subcontent.
+ *
+ * @param {Array<Event>} eventsArray
+ *   List of events.
+ * @returns {boolean}
+ *   Whether subtokens were found.
+ */
+// eslint-disable-next-line complexity
+export function subtokenize(eventsArray) {
+  /** @type {Record<string, number>} */
+  const jumps = {}
+  let index = -1
+  /** @type {Event} */
+  let event
+  /** @type {number | undefined} */
+  let lineIndex
+  /** @type {number} */
+  let otherIndex
+  /** @type {Event} */
+  let otherEvent
+  /** @type {Array<Event>} */
+  let parameters
+  /** @type {Array<Event>} */
+  let subevents
+  /** @type {boolean | undefined} */
+  let more
+  const events = new SpliceBuffer(eventsArray)
+
+  while (++index < events.length) {
+    while (index in jumps) {
+      index = jumps[index]
+    }
+
+    event = events.get(index)
+
+    // Add a hook for the GFM tasklist extension, which needs to know if text
+    // is in the first content of a list item.
+    if (
+      index &&
+      event[1].type === types.chunkFlow &&
+      events.get(index - 1)[1].type === types.listItemPrefix
+    ) {
+      assert(event[1]._tokenizer, 'expected `_tokenizer` on subtokens')
+      subevents = event[1]._tokenizer.events
+      otherIndex = 0
+
+      if (
+        otherIndex < subevents.length &&
+        subevents[otherIndex][1].type === types.lineEndingBlank
+      ) {
+        otherIndex += 2
+      }
+
+      if (
+        otherIndex < subevents.length &&
+        subevents[otherIndex][1].type === types.content
+      ) {
+        while (++otherIndex < subevents.length) {
+          if (subevents[otherIndex][1].type === types.content) {
+            break
+          }
+
+          if (subevents[otherIndex][1].type === types.chunkText) {
+            subevents[otherIndex][1]._isInFirstContentOfListItem = true
+            otherIndex++
+          }
+        }
+      }
+    }
+
+    // Enter.
+    if (event[0] === 'enter') {
+      if (event[1].contentType) {
+        Object.assign(jumps, subcontent(events, index))
+        index = jumps[index]
+        more = true
+      }
+    }
+    // Exit.
+    else if (event[1]._container) {
+      otherIndex = index
+      lineIndex = undefined
+
+      while (otherIndex--) {
+        otherEvent = events.get(otherIndex)
+
+        if (
+          otherEvent[1].type === types.lineEnding ||
+          otherEvent[1].type === types.lineEndingBlank
+        ) {
+          if (otherEvent[0] === 'enter') {
+            if (lineIndex) {
+              events.get(lineIndex)[1].type = types.lineEndingBlank
+            }
+
+            otherEvent[1].type = types.lineEnding
+            lineIndex = otherIndex
+          }
+        } else if (
+          otherEvent[1].type === types.linePrefix ||
+          otherEvent[1].type === types.listItemIndent
+        ) {
+          // Move past.
+        } else {
+          break
+        }
+      }
+
+      if (lineIndex) {
+        // Fix position.
+        event[1].end = {...events.get(lineIndex)[1].start}
+
+        // Switch container exit w/ line endings.
+        parameters = events.slice(lineIndex, index)
+        parameters.unshift(event)
+        events.splice(lineIndex, index - lineIndex + 1, parameters)
+      }
+    }
+  }
+
+  // The changes to the `events` buffer must be copied back into the eventsArray
+  splice(eventsArray, 0, Number.POSITIVE_INFINITY, events.slice(0))
+  return !more
+}
+
+/**
+ * Tokenize embedded tokens.
+ *
+ * @param {SpliceBuffer<Event>} events
+ *   Events.
+ * @param {number} eventIndex
+ *   Index.
+ * @returns {Record<string, number>}
+ *   Gaps.
+ */
+function subcontent(events, eventIndex) {
+  const token = events.get(eventIndex)[1]
+  const context = events.get(eventIndex)[2]
+  let startPosition = eventIndex - 1
+  /** @type {Array<number>} */
+  const startPositions = []
+  assert(token.contentType, 'expected `contentType` on subtokens')
+
+  let tokenizer = token._tokenizer
+
+  if (!tokenizer) {
+    tokenizer = context.parser[token.contentType](token.start)
+
+    if (token._contentTypeTextTrailing) {
+      tokenizer._contentTypeTextTrailing = true
+    }
+  }
+
+  const childEvents = tokenizer.events
+  /** @type {Array<[number, number]>} */
+  const jumps = []
+  /** @type {Record<string, number>} */
+  const gaps = {}
+  /** @type {Array<Chunk>} */
+  let stream
+  /** @type {Token | undefined} */
+  let previous
+  let index = -1
+  /** @type {Token | undefined} */
+  let current = token
+  let adjust = 0
+  let start = 0
+  const breaks = [start]
+
+  // Loop forward through the linked tokens to pass them in order to the
+  // subtokenizer.
+  while (current) {
+    // Find the position of the event for this token.
+    while (events.get(++startPosition)[1] !== current) {
+      // Empty.
+    }
+
+    assert(
+      !previous || current.previous === previous,
+      'expected previous to match'
+    )
+    assert(!previous || previous.next === current, 'expected next to match')
+
+    startPositions.push(startPosition)
+
+    if (!current._tokenizer) {
+      stream = context.sliceStream(current)
+
+      if (!current.next) {
+        stream.push(codes.eof)
+      }
+
+      if (previous) {
+        tokenizer.defineSkip(current.start)
+      }
+
+      if (current._isInFirstContentOfListItem) {
+        tokenizer._gfmTasklistFirstContentOfListItem = true
+      }
+
+      tokenizer.write(stream)
+
+      if (current._isInFirstContentOfListItem) {
+        tokenizer._gfmTasklistFirstContentOfListItem = undefined
+      }
+    }
+
+    // Unravel the next token.
+    previous = current
+    current = current.next
+  }
+
+  // Now, loop back through all events (and linked tokens), to figure out which
+  // parts belong where.
+  current = token
+
+  while (++index < childEvents.length) {
+    if (
+      // Find a void token that includes a break.
+      childEvents[index][0] === 'exit' &&
+      childEvents[index - 1][0] === 'enter' &&
+      childEvents[index][1].type === childEvents[index - 1][1].type &&
+      childEvents[index][1].start.line !== childEvents[index][1].end.line
+    ) {
+      assert(current, 'expected a current token')
+      start = index + 1
+      breaks.push(start)
+      // Help GC.
+      current._tokenizer = undefined
+      current.previous = undefined
+      current = current.next
+    }
+  }
+
+  // Help GC.
+  tokenizer.events = []
+
+  // If there’s one more token (which is the cases for lines that end in an
+  // EOF), that’s perfect: the last point we found starts it.
+  // If there isn’t then make sure any remaining content is added to it.
+  if (current) {
+    // Help GC.
+    current._tokenizer = undefined
+    current.previous = undefined
+    assert(!current.next, 'expected no next token')
+  } else {
+    breaks.pop()
+  }
+
+  // Now splice the events from the subtokenizer into the current events,
+  // moving back to front so that splice indices aren’t affected.
+  index = breaks.length
+
+  while (index--) {
+    const slice = childEvents.slice(breaks[index], breaks[index + 1])
+    const start = startPositions.pop()
+    assert(start !== undefined, 'expected a start position when splicing')
+    jumps.push([start, start + slice.length - 1])
+    events.splice(start, 2, slice)
+  }
+
+  jumps.reverse()
+  index = -1
+
+  while (++index < jumps.length) {
+    gaps[adjust + jumps[index][0]] = adjust + jumps[index][1]
+    adjust += jumps[index][1] - jumps[index][0] - 1
+  }
+
+  return gaps
+}

package/node_modules/micromark-util-subtokenize/dev/lib/splice-buffer.d.ts

@@ -0,0 +1,161 @@
+/**
+ * Some of the internal operations of micromark do lots of editing
+ * operations on very large arrays. This runs into problems with two
+ * properties of most circa-2020 JavaScript interpreters:
+ *
+ *  - Array-length modifications at the high end of an array (push/pop) are
+ *    expected to be common and are implemented in (amortized) time
+ *    proportional to the number of elements added or removed, whereas
+ *    other operations (shift/unshift and splice) are much less efficient.
+ *  - Function arguments are passed on the stack, so adding tens of thousands
+ *    of elements to an array with `arr.push(...newElements)` will frequently
+ *    cause stack overflows. (see <https://stackoverflow.com/questions/22123769/rangeerror-maximum-call-stack-size-exceeded-why>)
+ *
+ * SpliceBuffers are an implementation of gap buffers, which are a
+ * generalization of the "queue made of two stacks" idea. The splice buffer
+ * maintains a cursor, and moving the cursor has cost proportional to the
+ * distance the cursor moves, but inserting, deleting, or splicing in
+ * new information at the cursor is as efficient as the push/pop operation.
+ * This allows for an efficient sequence of splices (or pushes, pops, shifts,
+ * or unshifts) as long such edits happen at the same part of the array or
+ * generally sweep through the array from the beginning to the end.
+ *
+ * The interface for splice buffers also supports large numbers of inputs by
+ * passing a single array argument rather passing multiple arguments on the
+ * function call stack.
+ *
+ * @template T
+ *   Item type.
+ */
+export class SpliceBuffer<T> {
+    /**
+     * @param {ReadonlyArray<T> | null | undefined} [initial]
+     *   Initial items (optional).
+     * @returns
+     *   Splice buffer.
+     */
+    constructor(initial?: ReadonlyArray<T> | null | undefined);
+    /** @type {Array<T>} */
+    left: Array<T>;
+    /** @type {Array<T>} */
+    right: Array<T>;
+    /**
+     * Array access;
+     * does not move the cursor.
+     *
+     * @param {number} index
+     *   Index.
+     * @return {T}
+     *   Item.
+     */
+    get(index: number): T;
+    /**
+     * The length of the splice buffer, one greater than the largest index in the
+     * array.
+     */
+    get length(): number;
+    /**
+     * Remove and return `list[0]`;
+     * moves the cursor to `0`.
+     *
+     * @returns {T | undefined}
+     *   Item, optional.
+     */
+    shift(): T | undefined;
+    /**
+     * Slice the buffer to get an array;
+     * does not move the cursor.
+     *
+     * @param {number} start
+     *   Start.
+     * @param {number | null | undefined} [end]
+     *   End (optional).
+     * @returns {Array<T>}
+     *   Array of items.
+     */
+    slice(start: number, end?: number | null | undefined): Array<T>;
+    /**
+     * Mimics the behavior of Array.prototype.splice() except for the change of
+     * interface necessary to avoid segfaults when patching in very large arrays.
+     *
+     * This operation moves cursor is moved to `start` and results in the cursor
+     * placed after any inserted items.
+     *
+     * @param {number} start
+     *   Start;
+     *   zero-based index at which to start changing the array;
+     *   negative numbers count backwards from the end of the array and values
+     *   that are out-of bounds are clamped to the appropriate end of the array.
+     * @param {number | null | undefined} [deleteCount=0]
+     *   Delete count (default: `0`);
+     *   maximum number of elements to delete, starting from start.
+     * @param {Array<T> | null | undefined} [items=[]]
+     *   Items to include in place of the deleted items (default: `[]`).
+     * @return {Array<T>}
+     *   Any removed items.
+     */
+    splice(start: number, deleteCount?: number | null | undefined, items?: Array<T> | null | undefined): Array<T>;
+    /**
+     * Remove and return the highest-numbered item in the array, so
+     * `list[list.length - 1]`;
+     * Moves the cursor to `length`.
+     *
+     * @returns {T | undefined}
+     *   Item, optional.
+     */
+    pop(): T | undefined;
+    /**
+     * Inserts a single item to the high-numbered side of the array;
+     * moves the cursor to `length`.
+     *
+     * @param {T} item
+     *   Item.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    push(item: T): undefined;
+    /**
+     * Inserts many items to the high-numbered side of the array.
+     * Moves the cursor to `length`.
+     *
+     * @param {Array<T>} items
+     *   Items.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    pushMany(items: Array<T>): undefined;
+    /**
+     * Inserts a single item to the low-numbered side of the array;
+     * Moves the cursor to `0`.
+     *
+     * @param {T} item
+     *   Item.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    unshift(item: T): undefined;
+    /**
+     * Inserts many items to the low-numbered side of the array;
+     * moves the cursor to `0`.
+     *
+     * @param {Array<T>} items
+     *   Items.
+     * @returns {undefined}
+     *   Nothing.
+     */
+    unshiftMany(items: Array<T>): undefined;
+    /**
+     * Move the cursor to a specific position in the array. Requires
+     * time proportional to the distance moved.
+     *
+     * If `n < 0`, the cursor will end up at the beginning.
+     * If `n > length`, the cursor will end up at the end.
+     *
+     * @param {number} n
+     *   Position.
+     * @return {undefined}
+     *   Nothing.
+     */
+    setCursor(n: number): undefined;
+}
+//# sourceMappingURL=splice-buffer.d.ts.map

package/node_modules/micromark-util-subtokenize/dev/lib/splice-buffer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"splice-buffer.d.ts","sourceRoot":"","sources":["splice-buffer.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,0BAHa,CAAC;IAIZ;;;;;OAKG;IACH,sBALW,aAAa,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,EAU7C;IAJC,uBAAuB;IACvB,MADW,KAAK,CAAC,CAAC,CAAC,CACoB;IACvC,uBAAuB;IACvB,OADW,KAAK,CAAC,CAAC,CAAC,CACJ;IAGjB;;;;;;;;OAQG;IACH,WALW,MAAM,GAEL,CAAC,CAgBZ;IAED;;;OAGG;IACH,qBAEC;IAED;;;;;;OAMG;IACH,SAHa,CAAC,GAAG,SAAS,CAMzB;IAED;;;;;;;;;;OAUG;IACH,aAPW,MAAM,QAEN,MAAM,GAAG,IAAI,GAAG,SAAS,GAEvB,KAAK,CAAC,CAAC,CAAC,CA0BpB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cAbW,MAAM,gBAKN,MAAM,GAAG,IAAI,GAAG,SAAS,UAGzB,KAAK,CAAC,CAAC,CAAC,GAAG,IAAI,GAAG,SAAS,GAE1B,KAAK,CAAC,CAAC,CAAC,CAcnB;IAED;;;;;;;OAOG;IACH,OAHa,CAAC,GAAG,SAAS,CAMzB;IAED;;;;;;;;OAQG;IACH,WALW,CAAC,GAEC,SAAS,CAMrB;IAED;;;;;;;;OAQG;IACH,gBALW,KAAK,CAAC,CAAC,CAAC,GAEN,SAAS,CAMrB;IAED;;;;;;;;OAQG;IACH,cALW,CAAC,GAEC,SAAS,CAMrB;IAED;;;;;;;;OAQG;IACH,mBALW,KAAK,CAAC,CAAC,CAAC,GAEN,SAAS,CAMrB;IAED;;;;;;;;;;;OAWG;IACH,aALW,MAAM,GAEL,SAAS,CAsBpB;CACF"}