@tiangong-lca/pcr 0.3.0 → 0.4.0

package/node_modules/micromark-core-commonmark/dev/lib/definition.js

@@ -0,0 +1,295 @@
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {factoryDestination} from 'micromark-factory-destination'
+import {factoryLabel} from 'micromark-factory-label'
+import {factorySpace} from 'micromark-factory-space'
+import {factoryTitle} from 'micromark-factory-title'
+import {factoryWhitespace} from 'micromark-factory-whitespace'
+import {
+  markdownLineEndingOrSpace,
+  markdownLineEnding,
+  markdownSpace
+} from 'micromark-util-character'
+import {normalizeIdentifier} from 'micromark-util-normalize-identifier'
+import {codes, types} from 'micromark-util-symbol'
+
+/** @type {Construct} */
+export const definition = {name: 'definition', tokenize: tokenizeDefinition}
+
+/** @type {Construct} */
+const titleBefore = {partial: true, tokenize: tokenizeTitleBefore}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeDefinition(effects, ok, nok) {
+  const self = this
+  /** @type {string} */
+  let identifier
+
+  return start
+
+  /**
+   * At start of a definition.
+   *
+   * ```markdown
+   * > | [a]: b "c"
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    // Do not interrupt paragraphs (but do follow definitions).
+    // To do: do `interrupt` the way `markdown-rs` does.
+    // To do: parse whitespace the way `markdown-rs` does.
+    effects.enter(types.definition)
+    return before(code)
+  }
+
+  /**
+   * After optional whitespace, at `[`.
+   *
+   * ```markdown
+   * > | [a]: b "c"
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function before(code) {
+    // To do: parse whitespace the way `markdown-rs` does.
+    assert(code === codes.leftSquareBracket, 'expected `[`')
+    return factoryLabel.call(
+      self,
+      effects,
+      labelAfter,
+      // Note: we don’t need to reset the way `markdown-rs` does.
+      nok,
+      types.definitionLabel,
+      types.definitionLabelMarker,
+      types.definitionLabelString
+    )(code)
+  }
+
+  /**
+   * After label.
+   *
+   * ```markdown
+   * > | [a]: b "c"
+   *        ^
+   * ```
+   *
+   * @type {State}
+   */
+  function labelAfter(code) {
+    identifier = normalizeIdentifier(
+      self.sliceSerialize(self.events[self.events.length - 1][1]).slice(1, -1)
+    )
+
+    if (code === codes.colon) {
+      effects.enter(types.definitionMarker)
+      effects.consume(code)
+      effects.exit(types.definitionMarker)
+      return markerAfter
+    }
+
+    return nok(code)
+  }
+
+  /**
+   * After marker.
+   *
+   * ```markdown
+   * > | [a]: b "c"
+   *         ^
+   * ```
+   *
+   * @type {State}
+   */
+  function markerAfter(code) {
+    // Note: whitespace is optional.
+    return markdownLineEndingOrSpace(code)
+      ? factoryWhitespace(effects, destinationBefore)(code)
+      : destinationBefore(code)
+  }
+
+  /**
+   * Before destination.
+   *
+   * ```markdown
+   * > | [a]: b "c"
+   *          ^
+   * ```
+   *
+   * @type {State}
+   */
+  function destinationBefore(code) {
+    return factoryDestination(
+      effects,
+      destinationAfter,
+      // Note: we don’t need to reset the way `markdown-rs` does.
+      nok,
+      types.definitionDestination,
+      types.definitionDestinationLiteral,
+      types.definitionDestinationLiteralMarker,
+      types.definitionDestinationRaw,
+      types.definitionDestinationString
+    )(code)
+  }
+
+  /**
+   * After destination.
+   *
+   * ```markdown
+   * > | [a]: b "c"
+   *           ^
+   * ```
+   *
+   * @type {State}
+   */
+  function destinationAfter(code) {
+    return effects.attempt(titleBefore, after, after)(code)
+  }
+
+  /**
+   * After definition.
+   *
+   * ```markdown
+   * > | [a]: b
+   *           ^
+   * > | [a]: b "c"
+   *               ^
+   * ```
+   *
+   * @type {State}
+   */
+  function after(code) {
+    return markdownSpace(code)
+      ? factorySpace(effects, afterWhitespace, types.whitespace)(code)
+      : afterWhitespace(code)
+  }
+
+  /**
+   * After definition, after optional whitespace.
+   *
+   * ```markdown
+   * > | [a]: b
+   *           ^
+   * > | [a]: b "c"
+   *               ^
+   * ```
+   *
+   * @type {State}
+   */
+  function afterWhitespace(code) {
+    if (code === codes.eof || markdownLineEnding(code)) {
+      effects.exit(types.definition)
+
+      // Note: we don’t care about uniqueness.
+      // It’s likely that that doesn’t happen very frequently.
+      // It is more likely that it wastes precious time.
+      self.parser.defined.push(identifier)
+
+      // To do: `markdown-rs` interrupt.
+      // // You’d be interrupting.
+      // tokenizer.interrupt = true
+      return ok(code)
+    }
+
+    return nok(code)
+  }
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeTitleBefore(effects, ok, nok) {
+  return titleBefore
+
+  /**
+   * After destination, at whitespace.
+   *
+   * ```markdown
+   * > | [a]: b
+   *           ^
+   * > | [a]: b "c"
+   *           ^
+   * ```
+   *
+   * @type {State}
+   */
+  function titleBefore(code) {
+    return markdownLineEndingOrSpace(code)
+      ? factoryWhitespace(effects, beforeMarker)(code)
+      : nok(code)
+  }
+
+  /**
+   * At title.
+   *
+   * ```markdown
+   *   | [a]: b
+   * > | "c"
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function beforeMarker(code) {
+    return factoryTitle(
+      effects,
+      titleAfter,
+      nok,
+      types.definitionTitle,
+      types.definitionTitleMarker,
+      types.definitionTitleString
+    )(code)
+  }
+
+  /**
+   * After title.
+   *
+   * ```markdown
+   * > | [a]: b "c"
+   *               ^
+   * ```
+   *
+   * @type {State}
+   */
+  function titleAfter(code) {
+    return markdownSpace(code)
+      ? factorySpace(
+          effects,
+          titleAfterOptionalWhitespace,
+          types.whitespace
+        )(code)
+      : titleAfterOptionalWhitespace(code)
+  }
+
+  /**
+   * After title, after optional whitespace.
+   *
+   * ```markdown
+   * > | [a]: b "c"
+   *               ^
+   * ```
+   *
+   * @type {State}
+   */
+  function titleAfterOptionalWhitespace(code) {
+    return code === codes.eof || markdownLineEnding(code) ? ok(code) : nok(code)
+  }
+}

package/node_modules/micromark-core-commonmark/dev/lib/hard-break-escape.d.ts

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

package/node_modules/micromark-core-commonmark/dev/lib/hard-break-escape.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hard-break-escape.d.ts","sourceRoot":"","sources":["hard-break-escape.js"],"names":[],"mappings":"AAaA,wBAAwB;AACxB,8BADW,SAAS,CAInB;+BAXS,sBAAsB"}

package/node_modules/micromark-core-commonmark/dev/lib/hard-break-escape.js

@@ -0,0 +1,65 @@
+/**
+ * @import {
+ *   Construct,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer
+ * } 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 hardBreakEscape = {
+  name: 'hardBreakEscape',
+  tokenize: tokenizeHardBreakEscape
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeHardBreakEscape(effects, ok, nok) {
+  return start
+
+  /**
+   * Start of a hard break (escape).
+   *
+   * ```markdown
+   * > | a\
+   *      ^
+   *   | b
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    assert(code === codes.backslash, 'expected `\\`')
+    effects.enter(types.hardBreakEscape)
+    effects.consume(code)
+    return after
+  }
+
+  /**
+   * After `\`, at eol.
+   *
+   * ```markdown
+   * > | a\
+   *       ^
+   *   | b
+   * ```
+   *
+   *  @type {State}
+   */
+  function after(code) {
+    if (markdownLineEnding(code)) {
+      effects.exit(types.hardBreakEscape)
+      return ok(code)
+    }
+
+    return nok(code)
+  }
+}

package/node_modules/micromark-core-commonmark/dev/lib/heading-atx.d.ts

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

package/node_modules/micromark-core-commonmark/dev/lib/heading-atx.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"heading-atx.d.ts","sourceRoot":"","sources":["heading-atx.js"],"names":[],"mappings":"AAqBA,wBAAwB;AACxB,yBADW,SAAS,CAKnB;+BAlBS,sBAAsB"}

package/node_modules/micromark-core-commonmark/dev/lib/heading-atx.js

@@ -0,0 +1,229 @@
+/**
+ * @import {
+ *   Construct,
+ *   Resolver,
+ *   State,
+ *   TokenizeContext,
+ *   Tokenizer,
+ *   Token
+ * } from 'micromark-util-types'
+ */
+
+import {ok as assert} from 'devlop'
+import {factorySpace} from 'micromark-factory-space'
+import {
+  markdownLineEndingOrSpace,
+  markdownLineEnding,
+  markdownSpace
+} from 'micromark-util-character'
+import {splice} from 'micromark-util-chunked'
+import {codes, constants, types} from 'micromark-util-symbol'
+
+/** @type {Construct} */
+export const headingAtx = {
+  name: 'headingAtx',
+  resolve: resolveHeadingAtx,
+  tokenize: tokenizeHeadingAtx
+}
+
+/** @type {Resolver} */
+function resolveHeadingAtx(events, context) {
+  let contentEnd = events.length - 2
+  let contentStart = 3
+
+  // Prefix whitespace, part of the opening.
+  if (events[contentStart][1].type === types.whitespace) {
+    contentStart += 2
+  }
+
+  // Suffix whitespace, part of the closing.
+  if (
+    contentEnd - 2 > contentStart &&
+    events[contentEnd][1].type === types.whitespace
+  ) {
+    contentEnd -= 2
+  }
+
+  if (
+    events[contentEnd][1].type === types.atxHeadingSequence &&
+    (contentStart === contentEnd - 1 ||
+      (contentEnd - 4 > contentStart &&
+        events[contentEnd - 2][1].type === types.whitespace))
+  ) {
+    contentEnd -= contentStart + 1 === contentEnd ? 2 : 4
+  }
+
+  if (contentEnd > contentStart) {
+    const content = {
+      type: types.atxHeadingText,
+      start: events[contentStart][1].start,
+      end: events[contentEnd][1].end
+    }
+    const text = {
+      type: types.chunkText,
+      start: events[contentStart][1].start,
+      end: events[contentEnd][1].end,
+      contentType: constants.contentTypeText
+    }
+
+    splice(events, contentStart, contentEnd - contentStart + 1, [
+      ['enter', content, context],
+      ['enter', text, context],
+      ['exit', text, context],
+      ['exit', content, context]
+    ])
+  }
+
+  return events
+}
+
+/**
+ * @this {TokenizeContext}
+ *   Context.
+ * @type {Tokenizer}
+ */
+function tokenizeHeadingAtx(effects, ok, nok) {
+  let size = 0
+
+  return start
+
+  /**
+   * Start of a heading (atx).
+   *
+   * ```markdown
+   * > | ## aa
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function start(code) {
+    // To do: parse indent like `markdown-rs`.
+    effects.enter(types.atxHeading)
+    return before(code)
+  }
+
+  /**
+   * After optional whitespace, at `#`.
+   *
+   * ```markdown
+   * > | ## aa
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function before(code) {
+    assert(code === codes.numberSign, 'expected `#`')
+    effects.enter(types.atxHeadingSequence)
+    return sequenceOpen(code)
+  }
+
+  /**
+   * In opening sequence.
+   *
+   * ```markdown
+   * > | ## aa
+   *     ^
+   * ```
+   *
+   * @type {State}
+   */
+  function sequenceOpen(code) {
+    if (
+      code === codes.numberSign &&
+      size++ < constants.atxHeadingOpeningFenceSizeMax
+    ) {
+      effects.consume(code)
+      return sequenceOpen
+    }
+
+    // Always at least one `#`.
+    if (code === codes.eof || markdownLineEndingOrSpace(code)) {
+      effects.exit(types.atxHeadingSequence)
+      return atBreak(code)
+    }
+
+    return nok(code)
+  }
+
+  /**
+   * After something, before something else.
+   *
+   * ```markdown
+   * > | ## aa
+   *       ^
+   * ```
+   *
+   * @type {State}
+   */
+  function atBreak(code) {
+    if (code === codes.numberSign) {
+      effects.enter(types.atxHeadingSequence)
+      return sequenceFurther(code)
+    }
+
+    if (code === codes.eof || markdownLineEnding(code)) {
+      effects.exit(types.atxHeading)
+      // To do: interrupt like `markdown-rs`.
+      // // Feel free to interrupt.
+      // tokenizer.interrupt = false
+      return ok(code)
+    }
+
+    if (markdownSpace(code)) {
+      return factorySpace(effects, atBreak, types.whitespace)(code)
+    }
+
+    // To do: generate `data` tokens, add the `text` token later.
+    // Needs edit map, see: `markdown.rs`.
+    effects.enter(types.atxHeadingText)
+    return data(code)
+  }
+
+  /**
+   * In further sequence (after whitespace).
+   *
+   * Could be normal “visible” hashes in the heading or a final sequence.
+   *
+   * ```markdown
+   * > | ## aa ##
+   *           ^
+   * ```
+   *
+   * @type {State}
+   */
+  function sequenceFurther(code) {
+    if (code === codes.numberSign) {
+      effects.consume(code)
+      return sequenceFurther
+    }
+
+    effects.exit(types.atxHeadingSequence)
+    return atBreak(code)
+  }
+
+  /**
+   * In text.
+   *
+   * ```markdown
+   * > | ## aa
+   *        ^
+   * ```
+   *
+   * @type {State}
+   */
+  function data(code) {
+    if (
+      code === codes.eof ||
+      code === codes.numberSign ||
+      markdownLineEndingOrSpace(code)
+    ) {
+      effects.exit(types.atxHeadingText)
+      return atBreak(code)
+    }
+
+    effects.consume(code)
+    return data
+  }
+}

package/node_modules/micromark-core-commonmark/dev/lib/html-flow.d.ts

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

package/node_modules/micromark-core-commonmark/dev/lib/html-flow.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"html-flow.d.ts","sourceRoot":"","sources":["html-flow.js"],"names":[],"mappings":"AAwBA,wBAAwB;AACxB,uBADW,SAAS,CAMnB;+BAtBS,sBAAsB"}