@tiangong-lca/pcr 0.3.1 → 0.4.0

package/node_modules/mdast-util-to-markdown/lib/handle/paragraph.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Paragraph, Parents} from 'mdast'
+ */
+/**
+ * Serialize a paragraph node.
+ *
+ * @param {Paragraph} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function paragraph(node: Paragraph, _: Parents | undefined, state: State, info: Info): string;
+import type { Paragraph } from 'mdast';
+import type { Parents } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+import type { Info } from 'mdast-util-to-markdown';
+//# sourceMappingURL=paragraph.d.ts.map

package/node_modules/mdast-util-to-markdown/lib/handle/paragraph.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"paragraph.d.ts","sourceRoot":"","sources":["paragraph.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AACH,gCAXW,SAAS,KAET,OAAO,GAAG,SAAS,SAEnB,KAAK,QAEL,IAAI,GAEF,MAAM,CAUlB;+BAxBoC,OAAO;6BAAP,OAAO;2BADd,wBAAwB;0BAAxB,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/handle/paragraph.js

@@ -0,0 +1,27 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Paragraph, Parents} from 'mdast'
+ */
+
+/**
+ * Serialize a paragraph node.
+ *
+ * @param {Paragraph} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function paragraph(node, _, state, info) {
+  const exit = state.enter('paragraph')
+  const subexit = state.enter('phrasing')
+  const value = state.containerPhrasing(node, info)
+  subexit()
+  exit()
+  return value
+}

package/node_modules/mdast-util-to-markdown/lib/handle/root.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Serialize a root node.
+ *
+ * @param {Root} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function root(node: Root, _: Parents | undefined, state: State, info: Info): string;
+import type { Root } from 'mdast';
+import type { Parents } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+import type { Info } from 'mdast-util-to-markdown';
+//# sourceMappingURL=root.d.ts.map

package/node_modules/mdast-util-to-markdown/lib/handle/root.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"root.d.ts","sourceRoot":"","sources":["root.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;GAaG;AACH,2BAXW,IAAI,KAEJ,OAAO,GAAG,SAAS,SAEnB,KAAK,QAEL,IAAI,GAEF,MAAM,CAelB;0BA/B+B,OAAO;6BAAP,OAAO;2BADT,wBAAwB;0BAAxB,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/handle/root.js

@@ -0,0 +1,34 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Parents, Root} from 'mdast'
+ */
+
+import {phrasing} from 'mdast-util-phrasing'
+
+/**
+ * Serialize a root node.
+ *
+ * @param {Root} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function root(node, _, state, info) {
+  // Note: `html` nodes are ambiguous.
+  const hasPhrasing = node.children.some(function (d) {
+    return phrasing(d)
+  })
+
+  if (!hasPhrasing) return state.containerFlow(node, info)
+
+  const exit = state.enter('phrasing')
+  const value = state.containerPhrasing(node, info)
+  exit()
+  return value
+}

package/node_modules/mdast-util-to-markdown/lib/handle/strong.d.ts

@@ -0,0 +1,52 @@
+/**
+ * Serialize a strong node.
+ *
+ * Attention is properly handled by `containerPhrasing`.
+ *
+ * @param {Strong} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function strong(node: Strong, _: Parents | undefined, state: State, info: Info): string;
+export namespace strong {
+    export { attention };
+    export { peek };
+}
+import type { Strong } from 'mdast';
+import type { Parents } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+import type { Info } from 'mdast-util-to-markdown';
+/**
+ * Serialize a strong node as attention.
+ *
+ * @param {Strong} _
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {AttentionInfo}
+ *   Info on how to serialize the node.
+ */
+declare function attention(_: Strong, state: State): AttentionInfo;
+/**
+ * Peek at this node.
+ *
+ * @param {Strong} _
+ *   Node to serialize.
+ * @param {Parents | undefined} _1
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {string}
+ *   Start of the serialized markdown.
+ */
+declare function peek(_: Strong, _1: Parents | undefined, state: State): string;
+import type { AttentionInfo } from 'mdast-util-to-markdown';
+export {};
+//# sourceMappingURL=strong.d.ts.map

package/node_modules/mdast-util-to-markdown/lib/handle/strong.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"strong.d.ts","sourceRoot":"","sources":["strong.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;GAeG;AACH,6BAXW,MAAM,KAEN,OAAO,GAAG,SAAS,SAEnB,KAAK,QAEL,IAAI,GAEF,MAAM,CAQlB;;;;;4BA7BiC,OAAO;6BAAP,OAAO;2BADI,wBAAwB;0BAAxB,wBAAwB;AAgCrE;;;;;;;;;GASG;AACH,8BAPW,MAAM,SAEN,KAAK,GAEH,aAAa,CAUzB;AAED;;;;;;;;;;;GAWG;AACH,yBATW,MAAM,MAEN,OAAO,GAAG,SAAS,SAEnB,KAAK,GAEH,MAAM,CAKlB;mCAjE4C,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/handle/strong.js

@@ -0,0 +1,67 @@
+/**
+ * @import {AttentionInfo, Info, State} from 'mdast-util-to-markdown'
+ * @import {Parents, Strong} from 'mdast'
+ */
+
+import {checkStrong} from '../util/check-strong.js'
+
+strong.attention = attention
+strong.peek = peek
+
+/**
+ * Serialize a strong node.
+ *
+ * Attention is properly handled by `containerPhrasing`.
+ *
+ * @param {Strong} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function strong(node, _, state, info) {
+  const exit = state.enter('phrasing')
+  const value = state.containerPhrasing({type: 'root', children: [node]}, info)
+  exit()
+  return value
+}
+
+/**
+ * Serialize a strong node as attention.
+ *
+ * @param {Strong} _
+ *   Node to serialize.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {AttentionInfo}
+ *   Info on how to serialize the node.
+ */
+function attention(_, state) {
+  const marker = checkStrong(state)
+  return {
+    construct: 'strong',
+    markers: marker === '*' ? ['*', '_'] : ['_', '*'],
+    sizes: [2]
+  }
+}
+
+/**
+ * Peek at this node.
+ *
+ * @param {Strong} _
+ *   Node to serialize.
+ * @param {Parents | undefined} _1
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {string}
+ *   Start of the serialized markdown.
+ */
+function peek(_, _1, state) {
+  return state.options.strong || '*'
+}

package/node_modules/mdast-util-to-markdown/lib/handle/text.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Parents, Text} from 'mdast'
+ */
+/**
+ * Serialize a text node.
+ *
+ * @param {Text} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function text(node: Text, _: Parents | undefined, state: State, info: Info): string;
+import type { Text } from 'mdast';
+import type { Parents } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+import type { Info } from 'mdast-util-to-markdown';
+//# sourceMappingURL=text.d.ts.map

package/node_modules/mdast-util-to-markdown/lib/handle/text.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"text.d.ts","sourceRoot":"","sources":["text.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;;;;;;;;;GAaG;AACH,2BAXW,IAAI,KAEJ,OAAO,GAAG,SAAS,SAEnB,KAAK,QAEL,IAAI,GAEF,MAAM,CAKlB;0BAnB+B,OAAO;6BAAP,OAAO;2BADT,wBAAwB;0BAAxB,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/handle/text.js

@@ -0,0 +1,22 @@
+/**
+ * @import {Info, State} from 'mdast-util-to-markdown'
+ * @import {Parents, Text} from 'mdast'
+ */
+
+/**
+ * Serialize a text node.
+ *
+ * @param {Text} node
+ *   Node to serialize.
+ * @param {Parents | undefined} _
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @param {Info} info
+ *   Info on surrounding context.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function text(node, _, state, info) {
+  return state.safe(node.value, info)
+}

package/node_modules/mdast-util-to-markdown/lib/handle/thematic-break.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Serialize a thematic break node.
+ *
+ * @param {ThematicBreak} _
+ *   Node to serialize.
+ * @param {Parents | undefined} _1
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function thematicBreak(_: ThematicBreak, _1: Parents | undefined, state: State): string;
+import type { ThematicBreak } from 'mdast';
+import type { Parents } from 'mdast';
+import type { State } from 'mdast-util-to-markdown';
+//# sourceMappingURL=thematic-break.d.ts.map

package/node_modules/mdast-util-to-markdown/lib/handle/thematic-break.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"thematic-break.d.ts","sourceRoot":"","sources":["thematic-break.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;GAWG;AACH,iCATW,aAAa,MAEb,OAAO,GAAG,SAAS,SAEnB,KAAK,GAEH,MAAM,CASlB;mCAxBwC,OAAO;6BAAP,OAAO;2BADxB,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/handle/thematic-break.js

@@ -0,0 +1,27 @@
+/**
+ * @import {State} from 'mdast-util-to-markdown'
+ * @import {Parents, ThematicBreak} from 'mdast'
+ */
+
+import {checkRuleRepetition} from '../util/check-rule-repetition.js'
+import {checkRule} from '../util/check-rule.js'
+
+/**
+ * Serialize a thematic break node.
+ *
+ * @param {ThematicBreak} _
+ *   Node to serialize.
+ * @param {Parents | undefined} _1
+ *   Parent node.
+ * @param {State} state
+ *   Info passed around.
+ * @returns {string}
+ *   Serialized markdown.
+ */
+export function thematicBreak(_, _1, state) {
+  const value = (
+    checkRule(state) + (state.options.ruleSpaces ? ' ' : '')
+  ).repeat(checkRuleRepetition(state))
+
+  return state.options.ruleSpaces ? value.slice(0, -1) : value
+}

package/node_modules/mdast-util-to-markdown/lib/index.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Turn an mdast syntax tree into markdown.
+ *
+ * @param {Nodes} tree
+ *   Tree to serialize.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {string}
+ *   Serialized markdown representing `tree`.
+ */
+export function toMarkdown(tree: Nodes, options?: Options | null | undefined): string;
+import type { Nodes } from 'mdast';
+import type { Options } from 'mdast-util-to-markdown';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/mdast-util-to-markdown/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AAoBA;;;;;;;;;GASG;AACH,iCAPW,KAAK,YAEL,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,MAAM,CA6ElB;2BAtGuB,OAAO;6BAD0B,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/index.js

@@ -0,0 +1,213 @@
+/**
+ * @import {Info, Join, Options, SafeConfig, State} from 'mdast-util-to-markdown'
+ * @import {Nodes} from 'mdast'
+ * @import {Enter, FlowParents, PhrasingParents, TrackFields} from './types.js'
+ */
+
+import {phrasing} from 'mdast-util-phrasing'
+import {zwitch} from 'zwitch'
+import {configure} from './configure.js'
+import {handle as handlers} from './handle/index.js'
+import {join} from './join.js'
+import {unsafe} from './unsafe.js'
+import {association} from './util/association.js'
+import {compilePattern} from './util/compile-pattern.js'
+import {containerPhrasing} from './util/container-phrasing.js'
+import {containerFlow} from './util/container-flow.js'
+import {indentLines} from './util/indent-lines.js'
+import {safe} from './util/safe.js'
+import {track} from './util/track.js'
+
+/**
+ * Turn an mdast syntax tree into markdown.
+ *
+ * @param {Nodes} tree
+ *   Tree to serialize.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (optional).
+ * @returns {string}
+ *   Serialized markdown representing `tree`.
+ */
+export function toMarkdown(tree, options) {
+  const settings = options || {}
+  /** @type {State} */
+  const state = {
+    associationId: association,
+    bulletCurrent: undefined,
+    bulletLastUsed: undefined,
+    containerPhrasing: containerPhrasingBound,
+    containerFlow: containerFlowBound,
+    createTracker: track,
+    compilePattern,
+    enter,
+    // @ts-expect-error: GFM / frontmatter are typed in `mdast` but not defined
+    // here.
+    handlers: {...handlers},
+    // @ts-expect-error: add `handle` in a second.
+    handle: undefined,
+    indentLines,
+    indexStack: [],
+    join: [...join],
+    options: {},
+    safe: safeBound,
+    stack: [],
+    unsafe: [...unsafe]
+  }
+
+  configure(state, settings)
+
+  if (state.options.tightDefinitions) {
+    state.join.push(joinDefinition)
+  }
+
+  state.handle = zwitch('type', {
+    invalid,
+    unknown,
+    handlers: state.handlers
+  })
+
+  let result = state.handle(
+    phrasing(tree) ? {type: 'root', children: [tree]} : tree,
+    undefined,
+    state,
+    {before: '\n', after: '\n', now: {line: 1, column: 1}, lineShift: 0}
+  )
+
+  if (
+    result &&
+    result.charCodeAt(result.length - 1) !== 10 &&
+    result.charCodeAt(result.length - 1) !== 13
+  ) {
+    result += '\n'
+  }
+
+  return result
+
+  /**
+   * Enter a construct.
+   *
+   * @type {Enter}
+   */
+  function enter(name) {
+    state.stack.push(name)
+    return exit
+
+    /**
+     * Exit a construct.
+     *
+     * @returns {undefined}
+     *   Nothing.
+     */
+    function exit() {
+      state.stack.pop()
+    }
+  }
+}
+
+/**
+ * Handle an invalid value that cannot be processed.
+ *
+ * @param {unknown} value
+ *   Value.
+ * @returns {never}
+ *   Never.
+ * @throws {Error}
+ *   Always.
+ */
+function invalid(value) {
+  throw new Error('Cannot handle value `' + value + '`, expected node')
+}
+
+/**
+ * Handle an unknown node.
+ *
+ * @param {unknown} value
+ *   Value.
+ * @returns {never}
+ *   Never.
+ * @throws {Error}
+ *   Always.
+ */
+function unknown(value) {
+  // Always a node.
+  const node = /** @type {Nodes} */ (value)
+  throw new Error('Cannot handle unknown node `' + node.type + '`')
+}
+
+/**
+ * Join function for `tightDefinitions` option.
+ *
+ * @type {Join}
+ */
+function joinDefinition(left, right) {
+  // No blank line between adjacent definitions.
+  if (left.type === 'definition' && left.type === right.type) {
+    return 0
+  }
+}
+
+/**
+ * Serialize the children of a parent that contains phrasing children.
+ *
+ * These children will be joined flush together.
+ *
+ * @this {State}
+ *   Info passed around about the current state.
+ * @param {PhrasingParents} parent
+ *   Parent of flow nodes.
+ * @param {Info} info
+ *   Info on where we are in the document we are generating.
+ * @returns {string}
+ *   Serialized children, joined together.
+ */
+function containerPhrasingBound(parent, info) {
+  return containerPhrasing(parent, this, info)
+}
+
+/**
+ * Serialize the children of a parent that contains flow children.
+ *
+ * These children will typically be joined by blank lines.
+ * What they are joined by exactly is defined by `Join` functions.
+ *
+ * @this {State}
+ *   Info passed around about the current state.
+ * @param {FlowParents} parent
+ *   Parent of flow nodes.
+ * @param {TrackFields} info
+ *   Info on where we are in the document we are generating.
+ * @returns {string}
+ *   Serialized children, joined by (blank) lines.
+ */
+function containerFlowBound(parent, info) {
+  return containerFlow(parent, this, info)
+}
+
+/**
+ * Make a string safe for embedding in markdown constructs.
+ *
+ * In markdown, almost all punctuation characters can, in certain cases,
+ * result in something.
+ * Whether they do is highly subjective to where they happen and in what
+ * they happen.
+ *
+ * To solve this, `mdast-util-to-markdown` tracks:
+ *
+ * * Characters before and after something;
+ * * What “constructs” we are in.
+ *
+ * This information is then used by this function to escape or encode
+ * special characters.
+ *
+ * @this {State}
+ *   Info passed around about the current state.
+ * @param {string | null | undefined} value
+ *   Raw value to make safe.
+ * @param {SafeConfig} config
+ *   Configuration.
+ * @returns {string}
+ *   Serialized markdown safe for embedding.
+ */
+function safeBound(value, config) {
+  return safe(this, value, config)
+}

package/node_modules/mdast-util-to-markdown/lib/join.d.ts

@@ -0,0 +1,4 @@
+/** @type {Array<Join>} */
+export const join: Array<Join>;
+import type { Join } from 'mdast-util-to-markdown';
+//# sourceMappingURL=join.d.ts.map

package/node_modules/mdast-util-to-markdown/lib/join.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"join.d.ts","sourceRoot":"","sources":["join.js"],"names":[],"mappings":"AAQA,0BAA0B;AAC1B,mBADW,KAAK,CAAC,IAAI,CAAC,CACY;0BARX,wBAAwB"}

package/node_modules/mdast-util-to-markdown/lib/join.js

@@ -0,0 +1,56 @@
+/**
+ * @import {Join} from 'mdast-util-to-markdown'
+ */
+
+import {formatCodeAsIndented} from './util/format-code-as-indented.js'
+import {formatHeadingAsSetext} from './util/format-heading-as-setext.js'
+import {htmlKind} from './util/html-kind.js'
+
+/** @type {Array<Join>} */
+export const join = [joinDefaults]
+
+/**
+ * Default join function.
+ *
+ * @type {Join}
+ */
+function joinDefaults(left, right, parent, state) {
+  // Indented code after list or another indented code.
+  if (
+    right.type === 'code' &&
+    formatCodeAsIndented(right, state) &&
+    (left.type === 'list' ||
+      (left.type === right.type && formatCodeAsIndented(left, state)))
+  ) {
+    return false
+  }
+
+  // Join children of a list or an item.
+  // In which case, `parent` has a `spread` field.
+  if ('spread' in parent && typeof parent.spread === 'boolean') {
+    if (
+      left.type === 'paragraph' &&
+      // Two paragraphs.
+      (left.type === right.type ||
+        right.type === 'definition' ||
+        // Paragraph followed by a setext heading.
+        (right.type === 'heading' && formatHeadingAsSetext(right, state)))
+    ) {
+      return
+    }
+
+    // HTML that only ends at a blank line followed by something.
+    if (left.type === 'html') {
+      const kind = htmlKind(left.value)
+      if (kind === undefined || kind === 6 || kind === 7) return 1
+    }
+
+    // HTML that cannot interrupt a paragraph (kind 7) after one.
+    if (left.type === 'paragraph' && right.type === 'html') {
+      const kind = htmlKind(right.value)
+      if (kind === undefined || kind === 7) return 1
+    }
+
+    return parent.spread ? 1 : 0
+  }
+}