@tiangong-lca/pcr 0.3.1 → 0.4.0

package/node_modules/micromark/lib/initialize/document.js

@@ -0,0 +1,370 @@
+/**
+ * @import {
+ *   Construct,
+ *   ContainerState,
+ *   InitialConstruct,
+ *   Initializer,
+ *   Point,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer,
+ *   Token
+ * } from 'micromark-util-types'
+ */
+
+/**
+ * @typedef {[Construct, ContainerState]} StackItem
+ *   Construct and its state.
+ */
+
+import { factorySpace } from 'micromark-factory-space';
+import { markdownLineEnding } from 'micromark-util-character';
+import { EditMap } from 'micromark-util-edit-map';
+/** @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];
+      return effects.attempt(item[0].continuation, documentContinue, checkNewContainers)(code);
+    }
+
+    // Done.
+    return checkNewContainers(code);
+  }
+
+  /** @type {State} */
+  function documentContinue(code) {
+    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 === "chunkFlow") {
+          point = self.events[indexBeforeFlow][1].end;
+          break;
+        }
+      }
+      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) {
+    continued++;
+    stack.push([self.currentConstruct, self.containerState]);
+    // Try another.
+    return documentContinued(code);
+  }
+
+  /** @type {State} */
+  function flowStart(code) {
+    if (code === null) {
+      if (childFlow) {
+        closeFlow();
+      }
+      exitContainers(0);
+      effects.consume(code);
+      return;
+    }
+    childFlow = childFlow || self.parser.flow(self.now());
+    effects.enter("chunkFlow", {
+      _tokenizer: childFlow,
+      contentType: "flow",
+      previous: childToken
+    });
+    return flowContinue(code);
+  }
+
+  /** @type {State} */
+  function flowContinue(code) {
+    if (code === null) {
+      writeToChild(effects.exit("chunkFlow"), true);
+      exitContainers(0);
+      effects.consume(code);
+      return;
+    }
+    if (markdownLineEnding(code)) {
+      effects.consume(code);
+      writeToChild(effects.exit("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) {
+    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 === "chunkFlow") {
+          if (seen) {
+            point = self.events[indexBeforeFlow][1].end;
+            break;
+          }
+          seen = true;
+        }
+      }
+      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];
+      entry[0].exit.call(self, effects);
+    }
+    stack.length = size;
+  }
+  function closeFlow() {
+    childFlow.write([null]);
+    childToken = undefined;
+    childFlow = undefined;
+    self.containerState._closeFlow = undefined;
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ *   Tokenizer.
+ */
+function tokenizeContainer(effects, ok, nok) {
+  // Always populated by defaults.
+
+  return factorySpace(effects, effects.attempt(this.parser.constructs.document, ok, nok), "linePrefix", this.parser.constructs.disable.null.includes('codeIndented') ? undefined : 4);
+}

package/node_modules/micromark/lib/initialize/flow.d.ts

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

package/node_modules/micromark/lib/initialize/flow.d.ts.map

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

package/node_modules/micromark/lib/initialize/flow.js

@@ -0,0 +1,58 @@
+/**
+ * @import {
+ *   InitialConstruct,
+ *   Initializer,
+ *   State,
+ *   TokenizeContext
+ * } from 'micromark-util-types'
+ */
+
+import { blankLine, content } from 'micromark-core-commonmark';
+import { factorySpace } from 'micromark-factory-space';
+import { markdownLineEnding } from 'micromark-util-character';
+/** @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)), "linePrefix")));
+  return initial;
+
+  /** @type {State} */
+  function atBlankEnding(code) {
+    if (code === null) {
+      effects.consume(code);
+      return;
+    }
+    effects.enter("lineEndingBlank");
+    effects.consume(code);
+    effects.exit("lineEndingBlank");
+    self.currentConstruct = undefined;
+    return initial;
+  }
+
+  /** @type {State} */
+  function afterConstruct(code) {
+    if (code === null) {
+      effects.consume(code);
+      return;
+    }
+    effects.enter("lineEnding");
+    effects.consume(code);
+    effects.exit("lineEnding");
+    self.currentConstruct = undefined;
+    return initial;
+  }
+}

package/node_modules/micromark/lib/initialize/text.d.ts

@@ -0,0 +1,8 @@
+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/node_modules/micromark/lib/initialize/text.d.ts.map

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

package/node_modules/micromark/lib/initialize/text.js

@@ -0,0 +1,216 @@
+/**
+ * @import {
+ *   Code,
+ *   InitialConstruct,
+ *   Initializer,
+ *   Resolver,
+ *   State,
+ *   TokenizeContext
+ * } from 'micromark-util-types'
+ */
+
+import { EditMap } from 'micromark-util-edit-map';
+export const resolver = {
+  resolveAll: createResolver()
+};
+export const string = initializeFactory('string');
+export const text = initializeFactory('text');
+
+/**
+ * @param {'string' | 'text'} field
+ *   Field.
+ * @returns {InitialConstruct}
+ *   Construct.
+ */
+function initializeFactory(field) {
+  return {
+    resolveAll: createResolver(field === 'text' ? resolveAllLineSuffixes : undefined),
+    tokenize: initializeText
+  };
+
+  /**
+   * @this {TokenizeContext}
+   *   Context.
+   * @type {Initializer}
+   */
+  function initializeText(effects) {
+    const self = this;
+    const constructs = this.parser.constructs[field];
+    const text = effects.attempt(constructs, start, notText);
+    return start;
+
+    /** @type {State} */
+    function start(code) {
+      return atBreak(code) ? text(code) : notText(code);
+    }
+
+    /** @type {State} */
+    function notText(code) {
+      if (code === null) {
+        effects.consume(code);
+        return;
+      }
+      effects.enter("data");
+      effects.consume(code);
+      return data;
+    }
+
+    /** @type {State} */
+    function data(code) {
+      if (atBreak(code)) {
+        effects.exit("data");
+        return text(code);
+      }
+
+      // Data.
+      effects.consume(code);
+      return data;
+    }
+
+    /**
+     * @param {Code} code
+     *   Code.
+     * @returns {boolean}
+     *   Whether the code is a break.
+     */
+    function atBreak(code) {
+      if (code === null) {
+        return true;
+      }
+      const list = constructs[code];
+      let index = -1;
+      if (list) {
+        // Always populated by defaults.
+
+        while (++index < list.length) {
+          const item = list[index];
+          if (!item.previous || item.previous.call(self, self.previous)) {
+            return true;
+          }
+        }
+      }
+      return false;
+    }
+  }
+}
+
+/**
+ * @param {Resolver | undefined} [extraResolver]
+ *   Resolver.
+ * @returns {Resolver}
+ *   Resolver.
+ */
+function createResolver(extraResolver) {
+  return resolveAllText;
+
+  /** @type {Resolver} */
+  function resolveAllText(events, context) {
+    let index = -1;
+    /** @type {number | undefined} */
+    let enter;
+
+    // A rather boring computation (to merge adjacent `data` events) which
+    // improves mm performance by 29%.
+    while (++index <= events.length) {
+      if (enter === undefined) {
+        if (events[index] && events[index][1].type === "data") {
+          enter = index;
+          index++;
+        }
+      } else if (!events[index] || events[index][1].type !== "data") {
+        // Don’t do anything if there is one data token.
+        if (index !== enter + 2) {
+          events[enter][1].end = events[index - 1][1].end;
+          events.splice(enter + 2, index - enter - 2);
+          index = enter + 2;
+        }
+        enter = undefined;
+      }
+    }
+    return extraResolver ? extraResolver(events, context) : events;
+  }
+}
+
+/**
+ * A rather ugly set of instructions which again looks at chunks in the input
+ * stream.
+ * The reason to do this here is that it is *much* faster to parse in reverse.
+ * And that we can’t hook into `null` to split the line suffix before an EOF.
+ * To do: figure out if we can make this into a clean utility, or even in core.
+ * As it will be useful for GFMs literal autolink extension (and maybe even
+ * tables?)
+ *
+ * @type {Resolver}
+ */
+function resolveAllLineSuffixes(events, context) {
+  const editMap = new EditMap();
+  let eventIndex = 0; // Skip first.
+
+  while (++eventIndex <= events.length) {
+    if ((eventIndex === events.length || events[eventIndex][1].type === "lineEnding") && events[eventIndex - 1][1].type === "data") {
+      const data = events[eventIndex - 1][1];
+      const chunks = context.sliceStream(data);
+      let index = chunks.length;
+      let bufferIndex = -1;
+      let size = 0;
+      /** @type {boolean | undefined} */
+      let tabs;
+      while (index--) {
+        const chunk = chunks[index];
+        if (typeof chunk === 'string') {
+          bufferIndex = chunk.length;
+          while (chunk.charCodeAt(bufferIndex - 1) === 32) {
+            size++;
+            bufferIndex--;
+          }
+          if (bufferIndex) {
+            break;
+          }
+          bufferIndex = -1;
+        }
+        // Number
+        else if (chunk === -2) {
+          tabs = true;
+          size++;
+        } else if (chunk === -1) {
+          // Empty
+        } else {
+          // Replacement character, exit.
+          index++;
+          break;
+        }
+      }
+
+      // Allow final trailing whitespace.
+      if (context._contentTypeTextTrailing && eventIndex === events.length) {
+        size = 0;
+      }
+      if (size) {
+        const token = {
+          type: eventIndex === events.length || tabs || size < 2 ? "lineSuffix" : "hardBreakTrailing",
+          start: {
+            _bufferIndex: index ? bufferIndex : data.start._bufferIndex + bufferIndex,
+            _index: data.start._index + index,
+            line: data.end.line,
+            column: data.end.column - size,
+            offset: data.end.offset - size
+          },
+          end: {
+            ...data.end
+          }
+        };
+        data.end = {
+          ...token.start
+        };
+        if (data.start.offset === data.end.offset) {
+          Object.assign(data, token);
+        } else {
+          editMap.add(eventIndex, 0, [['enter', token, context], ['exit', token, context]]);
+        }
+      }
+      eventIndex++;
+    }
+  }
+  editMap.consume(events);
+  return events;
+}

package/node_modules/micromark/lib/parse.d.ts

@@ -0,0 +1,10 @@
+/**
+ * @param {ParseOptions | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {ParseContext}
+ *   Parser.
+ */
+export function parse(options?: ParseOptions | null | undefined): ParseContext;
+import type { ParseOptions } from 'micromark-util-types';
+import type { ParseContext } from 'micromark-util-types';
+//# sourceMappingURL=parse.d.ts.map

package/node_modules/micromark/lib/parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse.d.ts","sourceRoot":"","sources":["parse.js"],"names":[],"mappings":"AAkBA;;;;;GAKG;AACH,gCALW,YAAY,GAAG,IAAI,GAAG,SAAS,GAE7B,YAAY,CAoCxB;kCAlDS,sBAAsB;kCAAtB,sBAAsB"}