@tiangong-lca/pcr 0.3.1 → 0.4.1

package/node_modules/markdown-table/readme.md

@@ -0,0 +1,344 @@
+# markdown-table
+
+[![Build][build-badge]][build]
+[![Coverage][coverage-badge]][coverage]
+[![Downloads][downloads-badge]][downloads]
+[![Size][size-badge]][size]
+
+Generate a markdown ([GFM][]) table.
+
+## Contents
+
+* [What is this?](#what-is-this)
+* [When should I use this?](#when-should-i-use-this)
+* [Install](#install)
+* [Use](#use)
+* [API](#api)
+  * [`markdownTable(table[, options])`](#markdowntabletable-options)
+* [Types](#types)
+* [Compatibility](#compatibility)
+* [Security](#security)
+* [Inspiration](#inspiration)
+* [Contribute](#contribute)
+* [License](#license)
+
+## What is this?
+
+This is a simple package that takes table data and generates a [GitHub flavored
+markdown (GFM)][gfm] table.
+
+## When should I use this?
+
+You can use this package when you want to generate the source code of a GFM
+table from some data.
+
+This is a simple solution in that it doesn’t handle escapes or HTML or any of
+that.
+For a complete but heavier solution, build an AST and serialize it with
+[`mdast-util-to-markdown`][mdast-util-to-markdown] (with
+[`mdast-util-gfm`][mdast-util-gfm]).
+
+## Install
+
+This package is [ESM only][esm].
+In Node.js (version 14.14+, 16.0+), install with [npm][]:
+
+```sh
+npm install markdown-table
+```
+
+In Deno with [`esm.sh`][esmsh]:
+
+```js
+import {markdownTable} from 'https://esm.sh/markdown-table@3'
+```
+
+In browsers with [`esm.sh`][esmsh]:
+
+```html
+<script type="module">
+  import {markdownTable} from 'https://esm.sh/markdown-table@3?bundle'
+</script>
+```
+
+## Use
+
+Typical usage (defaults to align left):
+
+```js
+import {markdownTable} from 'markdown-table'
+
+markdownTable([
+  ['Branch', 'Commit'],
+  ['main', '0123456789abcdef'],
+  ['staging', 'fedcba9876543210']
+])
+```
+
+Yields:
+
+```markdown
+| Branch  | Commit           |
+| ------- | ---------------- |
+| main    | 0123456789abcdef |
+| staging | fedcba9876543210 |
+```
+
+With align:
+
+```js
+markdownTable(
+  [
+    ['Beep', 'No.', 'Boop'],
+    ['beep', '1024', 'xyz'],
+    ['boop', '3388450', 'tuv'],
+    ['foo', '10106', 'qrstuv'],
+    ['bar', '45', 'lmno']
+  ],
+  {align: ['l', 'c', 'r']}
+)
+```
+
+Yields:
+
+```markdown
+| Beep |   No.   |   Boop |
+| :--- | :-----: | -----: |
+| beep |   1024  |    xyz |
+| boop | 3388450 |    tuv |
+| foo  |  10106  | qrstuv |
+| bar  |    45   |   lmno |
+```
+
+## API
+
+This package exports the identifier `markdownTable`.
+There is no default export.
+
+### `markdownTable(table[, options])`
+
+Generate a markdown table from table data (matrix of strings).
+
+##### `options`
+
+Configuration (optional).
+
+###### `options.align`
+
+One style for all columns, or styles for their respective columns (`string` or
+`Array<string>`).
+Each style is either `'l'` (left), `'r'` (right), or `'c'` (center).
+Other values are treated as `''`, which doesn’t place the colon in the alignment
+row but does align left.
+*Only the lowercased first character is used, so `Right` is fine.*
+
+###### `options.padding`
+
+Whether to add a space of padding between delimiters and cells (`boolean`,
+default: `true`).
+
+When `true`, there is padding:
+
+```markdown
+| Alpha | B     |
+| ----- | ----- |
+| C     | Delta |
+```
+
+When `false`, there is no padding:
+
+```markdown
+|Alpha|B    |
+|-----|-----|
+|C    |Delta|
+```
+
+###### `options.delimiterStart`
+
+Whether to begin each row with the delimiter (`boolean`, default: `true`).
+
+> 👉 **Note**: please don’t use this: it could create fragile structures that
+> aren’t understandable to some markdown parsers.
+
+When `true`, there are starting delimiters:
+
+```markdown
+| Alpha | B     |
+| ----- | ----- |
+| C     | Delta |
+```
+
+When `false`, there are no starting delimiters:
+
+```markdown
+Alpha | B     |
+----- | ----- |
+C     | Delta |
+```
+
+###### `options.delimiterEnd`
+
+Whether to end each row with the delimiter (`boolean`, default: `true`).
+
+> 👉 **Note**: please don’t use this: it could create fragile structures that
+> aren’t understandable to some markdown parsers.
+
+When `true`, there are ending delimiters:
+
+```markdown
+| Alpha | B     |
+| ----- | ----- |
+| C     | Delta |
+```
+
+When `false`, there are no ending delimiters:
+
+```markdown
+| Alpha | B
+| ----- | -----
+| C     | Delta
+```
+
+###### `options.alignDelimiters`
+
+Whether to align the delimiters (`boolean`, default: `true`).
+By default, they are aligned:
+
+```markdown
+| Alpha | B     |
+| ----- | ----- |
+| C     | Delta |
+```
+
+Pass `false` to make them staggered:
+
+```markdown
+| Alpha | B |
+| - | - |
+| C | Delta |
+```
+
+###### `options.stringLength`
+
+Function to detect the length of table cell content (`Function`, default:
+`s => s.length`).
+This is used when aligning the delimiters (`|`) between table cells.
+Full-width characters and emoji mess up delimiter alignment when viewing the
+markdown source.
+To fix this, you can pass this function, which receives the cell content and
+returns its “visible” size.
+Note that what is and isn’t visible depends on where the text is displayed.
+
+Without such a function, the following:
+
+```js
+markdownTable([
+  ['Alpha', 'Bravo'],
+  ['中文', 'Charlie'],
+  ['👩‍❤️‍👩', 'Delta']
+])
+```
+
+Yields:
+
+```markdown
+| Alpha | Bravo |
+| - | - |
+| 中文 | Charlie |
+| 👩‍❤️‍👩 | Delta |
+```
+
+With [`string-width`][string-width]:
+
+```js
+import stringWidth from 'string-width'
+
+markdownTable(
+  [
+    ['Alpha', 'Bravo'],
+    ['中文', 'Charlie'],
+    ['👩‍❤️‍👩', 'Delta']
+  ],
+  {stringLength: stringWidth}
+)
+```
+
+Yields:
+
+```markdown
+| Alpha | Bravo   |
+| ----- | ------- |
+| 中文  | Charlie |
+| 👩‍❤️‍👩    | Delta   |
+```
+
+## Types
+
+This package is fully typed with [TypeScript][].
+It exports the additional type `Options`.
+
+## Compatibility
+
+This package is at least compatible with all maintained versions of Node.js.
+As of now, that is Node.js 14.14+ and 16.0+.
+It also works in Deno and modern browsers.
+
+## Security
+
+This package is safe.
+
+## Inspiration
+
+The original idea and basic implementation was inspired by James Halliday’s
+[`text-table`][text-table] library.
+
+## Contribute
+
+Yes please!
+See [How to Contribute to Open Source][contribute].
+
+## License
+
+[MIT][license] © [Titus Wormer][author]
+
+<!-- Definitions -->
+
+[build-badge]: https://github.com/wooorm/markdown-table/workflows/main/badge.svg
+
+[build]: https://github.com/wooorm/markdown-table/actions
+
+[coverage-badge]: https://img.shields.io/codecov/c/github/wooorm/markdown-table.svg
+
+[coverage]: https://codecov.io/github/wooorm/markdown-table
+
+[downloads-badge]: https://img.shields.io/npm/dm/markdown-table.svg
+
+[downloads]: https://www.npmjs.com/package/markdown-table
+
+[size-badge]: https://img.shields.io/bundlephobia/minzip/markdown-table.svg
+
+[size]: https://bundlephobia.com/result?p=markdown-table
+
+[npm]: https://docs.npmjs.com/cli/install
+
+[esmsh]: https://esm.sh
+
+[license]: license
+
+[author]: https://wooorm.com
+
+[esm]: https://gist.github.com/sindresorhus/a39789f98801d908bbc7ff3ecc99d99c
+
+[typescript]: https://www.typescriptlang.org
+
+[contribute]: https://opensource.guide/how-to-contribute/
+
+[gfm]: https://docs.github.com/en/github/writing-on-github/working-with-advanced-formatting/organizing-information-with-tables
+
+[text-table]: https://github.com/substack/text-table
+
+[string-width]: https://github.com/sindresorhus/string-width
+
+[mdast-util-to-markdown]: https://github.com/syntax-tree/mdast-util-to-markdown
+
+[mdast-util-gfm]: https://github.com/syntax-tree/mdast-util-gfm

package/node_modules/mdast-util-find-and-replace/index.d.ts

@@ -0,0 +1,9 @@
+export { findAndReplace } from "./lib/index.js";
+export type FindAndReplaceList = import("./lib/index.js").FindAndReplaceList;
+export type FindAndReplaceTuple = import("./lib/index.js").FindAndReplaceTuple;
+export type Find = import("./lib/index.js").Find;
+export type Options = import("./lib/index.js").Options;
+export type RegExpMatchObject = import("./lib/index.js").RegExpMatchObject;
+export type ReplaceFunction = import("./lib/index.js").ReplaceFunction;
+export type Replace = import("./lib/index.js").Replace;
+//# sourceMappingURL=index.d.ts.map

package/node_modules/mdast-util-find-and-replace/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":";iCACa,OAAO,gBAAgB,EAAE,kBAAkB;kCAC3C,OAAO,gBAAgB,EAAE,mBAAmB;mBAC5C,OAAO,gBAAgB,EAAE,IAAI;sBAC7B,OAAO,gBAAgB,EAAE,OAAO;gCAChC,OAAO,gBAAgB,EAAE,iBAAiB;8BAC1C,OAAO,gBAAgB,EAAE,eAAe;sBACxC,OAAO,gBAAgB,EAAE,OAAO"}

package/node_modules/mdast-util-find-and-replace/index.js

@@ -0,0 +1,11 @@
+/**
+ * @typedef {import('./lib/index.js').FindAndReplaceList} FindAndReplaceList
+ * @typedef {import('./lib/index.js').FindAndReplaceTuple} FindAndReplaceTuple
+ * @typedef {import('./lib/index.js').Find} Find
+ * @typedef {import('./lib/index.js').Options} Options
+ * @typedef {import('./lib/index.js').RegExpMatchObject} RegExpMatchObject
+ * @typedef {import('./lib/index.js').ReplaceFunction} ReplaceFunction
+ * @typedef {import('./lib/index.js').Replace} Replace
+ */
+
+export {findAndReplace} from './lib/index.js'

package/node_modules/mdast-util-find-and-replace/lib/index.d.ts

@@ -0,0 +1,79 @@
+/**
+ * Find patterns in a tree and replace them.
+ *
+ * The algorithm searches the tree in *preorder* for complete values in `Text`
+ * nodes.
+ * Partial matches are not supported.
+ *
+ * @param {Nodes} tree
+ *   Tree to change.
+ * @param {FindAndReplaceList | FindAndReplaceTuple} list
+ *   Patterns to find.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (when `find` is not `Find`).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export function findAndReplace(tree: Nodes, list: FindAndReplaceList | FindAndReplaceTuple, options?: Options | null | undefined): undefined;
+/**
+ * Info on the match.
+ */
+export type RegExpMatchObject = {
+    /**
+     *   The index of the search at which the result was found.
+     */
+    index: number;
+    /**
+     *   A copy of the search string in the text node.
+     */
+    input: string;
+    /**
+     *   All ancestors of the text node, where the last node is the text itself.
+     */
+    stack: [...Array<Parents>, Text];
+};
+/**
+ * Pattern to find.
+ *
+ * Strings are escaped and then turned into global expressions.
+ */
+export type Find = RegExp | string;
+/**
+ * Several find and replaces, in array form.
+ */
+export type FindAndReplaceList = Array<FindAndReplaceTuple>;
+/**
+ * Find and replace in tuple form.
+ */
+export type FindAndReplaceTuple = [Find, Replace?];
+/**
+ * Thing to replace with.
+ */
+export type Replace = ReplaceFunction | string | null | undefined;
+/**
+ * Callback called when a search matches.
+ */
+export type ReplaceFunction = (...parameters: any[]) => Array<PhrasingContent> | PhrasingContent | string | false | null | undefined;
+/**
+ * Normalized find and replace.
+ */
+export type Pair = [RegExp, ReplaceFunction];
+/**
+ * All find and replaced.
+ */
+export type Pairs = Array<Pair>;
+/**
+ * Configuration.
+ */
+export type Options = {
+    /**
+     * Test for which nodes to ignore (optional).
+     */
+    ignore?: Test | null | undefined;
+};
+import type { Nodes } from 'mdast';
+import type { Parents } from 'mdast';
+import type { Text } from 'mdast';
+import type { PhrasingContent } from 'mdast';
+import type { Test } from 'unist-util-visit-parents';
+//# sourceMappingURL=index.d.ts.map

package/node_modules/mdast-util-find-and-replace/lib/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.js"],"names":[],"mappings":"AA6DA;;;;;;;;;;;;;;;GAeG;AACH,qCATW,KAAK,QAEL,kBAAkB,GAAG,mBAAmB,YAExC,OAAO,GAAG,IAAI,GAAG,SAAS,GAExB,SAAS,CA6HrB;;;;;;;;WA/La,MAAM;;;;WAEN,MAAM;;;;WAEN,CAAC,GAAG,KAAK,CAAC,OAAO,CAAC,EAAE,IAAI,CAAC;;;;;;;mBAG1B,MAAM,GAAG,MAAM;;;;iCAKf,KAAK,CAAC,mBAAmB,CAAC;;;;kCAG1B,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;;;;sBAGhB,eAAe,GAAG,MAAM,GAAG,IAAI,GAAG,SAAS;;;;8CAK1C,GAAG,EAAA,KAMJ,KAAK,CAAC,eAAe,CAAC,GAAG,eAAe,GAAG,MAAM,GAAG,KAAK,GAAG,IAAI,GAAG,SAAS;;;;mBAQ5E,CAAC,MAAM,EAAE,eAAe,CAAC;;;;oBAGzB,KAAK,CAAC,IAAI,CAAC;;;;;;;;aAKV,IAAI,GAAG,IAAI,GAAG,SAAS;;2BApDyB,OAAO;6BAAP,OAAO;0BAAP,OAAO;qCAAP,OAAO;0BACjB,0BAA0B"}

package/node_modules/mdast-util-find-and-replace/lib/index.js

@@ -0,0 +1,261 @@
+/**
+ * @import {Nodes, Parents, PhrasingContent, Root, Text} from 'mdast'
+ * @import {BuildVisitor, Test, VisitorResult} from 'unist-util-visit-parents'
+ */
+
+/**
+ * @typedef RegExpMatchObject
+ *   Info on the match.
+ * @property {number} index
+ *   The index of the search at which the result was found.
+ * @property {string} input
+ *   A copy of the search string in the text node.
+ * @property {[...Array<Parents>, Text]} stack
+ *   All ancestors of the text node, where the last node is the text itself.
+ *
+ * @typedef {RegExp | string} Find
+ *   Pattern to find.
+ *
+ *   Strings are escaped and then turned into global expressions.
+ *
+ * @typedef {Array<FindAndReplaceTuple>} FindAndReplaceList
+ *   Several find and replaces, in array form.
+ *
+ * @typedef {[Find, Replace?]} FindAndReplaceTuple
+ *   Find and replace in tuple form.
+ *
+ * @typedef {ReplaceFunction | string | null | undefined} Replace
+ *   Thing to replace with.
+ *
+ * @callback ReplaceFunction
+ *   Callback called when a search matches.
+ * @param {...any} parameters
+ *   The parameters are the result of corresponding search expression:
+ *
+ *   * `value` (`string`) — whole match
+ *   * `...capture` (`Array<string>`) — matches from regex capture groups
+ *   * `match` (`RegExpMatchObject`) — info on the match
+ * @returns {Array<PhrasingContent> | PhrasingContent | string | false | null | undefined}
+ *   Thing to replace with.
+ *
+ *   * when `null`, `undefined`, `''`, remove the match
+ *   * …or when `false`, do not replace at all
+ *   * …or when `string`, replace with a text node of that value
+ *   * …or when `Node` or `Array<Node>`, replace with those nodes
+ *
+ * @typedef {[RegExp, ReplaceFunction]} Pair
+ *   Normalized find and replace.
+ *
+ * @typedef {Array<Pair>} Pairs
+ *   All find and replaced.
+ *
+ * @typedef Options
+ *   Configuration.
+ * @property {Test | null | undefined} [ignore]
+ *   Test for which nodes to ignore (optional).
+ */
+
+import escape from 'escape-string-regexp'
+import {visitParents} from 'unist-util-visit-parents'
+import {convert} from 'unist-util-is'
+
+/**
+ * Find patterns in a tree and replace them.
+ *
+ * The algorithm searches the tree in *preorder* for complete values in `Text`
+ * nodes.
+ * Partial matches are not supported.
+ *
+ * @param {Nodes} tree
+ *   Tree to change.
+ * @param {FindAndReplaceList | FindAndReplaceTuple} list
+ *   Patterns to find.
+ * @param {Options | null | undefined} [options]
+ *   Configuration (when `find` is not `Find`).
+ * @returns {undefined}
+ *   Nothing.
+ */
+export function findAndReplace(tree, list, options) {
+  const settings = options || {}
+  const ignored = convert(settings.ignore || [])
+  const pairs = toPairs(list)
+  let pairIndex = -1
+
+  while (++pairIndex < pairs.length) {
+    visitParents(tree, 'text', visitor)
+  }
+
+  /** @type {BuildVisitor<Root, 'text'>} */
+  function visitor(node, parents) {
+    let index = -1
+    /** @type {Parents | undefined} */
+    let grandparent
+
+    while (++index < parents.length) {
+      const parent = parents[index]
+      /** @type {Array<Nodes> | undefined} */
+      const siblings = grandparent ? grandparent.children : undefined
+
+      if (
+        ignored(
+          parent,
+          siblings ? siblings.indexOf(parent) : undefined,
+          grandparent
+        )
+      ) {
+        return
+      }
+
+      grandparent = parent
+    }
+
+    if (grandparent) {
+      return handler(node, parents)
+    }
+  }
+
+  /**
+   * Handle a text node which is not in an ignored parent.
+   *
+   * @param {Text} node
+   *   Text node.
+   * @param {Array<Parents>} parents
+   *   Parents.
+   * @returns {VisitorResult}
+   *   Result.
+   */
+  function handler(node, parents) {
+    const parent = parents[parents.length - 1]
+    const find = pairs[pairIndex][0]
+    const replace = pairs[pairIndex][1]
+    let start = 0
+    /** @type {Array<Nodes>} */
+    const siblings = parent.children
+    const index = siblings.indexOf(node)
+    let change = false
+    /** @type {Array<PhrasingContent>} */
+    let nodes = []
+
+    find.lastIndex = 0
+
+    let match = find.exec(node.value)
+
+    while (match) {
+      const position = match.index
+      /** @type {RegExpMatchObject} */
+      const matchObject = {
+        index: match.index,
+        input: match.input,
+        stack: [...parents, node]
+      }
+      let value = replace(...match, matchObject)
+
+      if (typeof value === 'string') {
+        value = value.length > 0 ? {type: 'text', value} : undefined
+      }
+
+      // It wasn’t a match after all.
+      if (value === false) {
+        // False acts as if there was no match.
+        // So we need to reset `lastIndex`, which currently being at the end of
+        // the current match, to the beginning.
+        find.lastIndex = position + 1
+      } else {
+        if (start !== position) {
+          nodes.push({
+            type: 'text',
+            value: node.value.slice(start, position)
+          })
+        }
+
+        if (Array.isArray(value)) {
+          nodes.push(...value)
+        } else if (value) {
+          nodes.push(value)
+        }
+
+        start = position + match[0].length
+        change = true
+      }
+
+      if (!find.global) {
+        break
+      }
+
+      match = find.exec(node.value)
+    }
+
+    if (change) {
+      if (start < node.value.length) {
+        nodes.push({type: 'text', value: node.value.slice(start)})
+      }
+
+      parent.children.splice(index, 1, ...nodes)
+    } else {
+      nodes = [node]
+    }
+
+    return index + nodes.length
+  }
+}
+
+/**
+ * Turn a tuple or a list of tuples into pairs.
+ *
+ * @param {FindAndReplaceList | FindAndReplaceTuple} tupleOrList
+ *   Schema.
+ * @returns {Pairs}
+ *   Clean pairs.
+ */
+function toPairs(tupleOrList) {
+  /** @type {Pairs} */
+  const result = []
+
+  if (!Array.isArray(tupleOrList)) {
+    throw new TypeError('Expected find and replace tuple or list of tuples')
+  }
+
+  /** @type {FindAndReplaceList} */
+  // @ts-expect-error: correct.
+  const list =
+    !tupleOrList[0] || Array.isArray(tupleOrList[0])
+      ? tupleOrList
+      : [tupleOrList]
+
+  let index = -1
+
+  while (++index < list.length) {
+    const tuple = list[index]
+    result.push([toExpression(tuple[0]), toFunction(tuple[1])])
+  }
+
+  return result
+}
+
+/**
+ * Turn a find into an expression.
+ *
+ * @param {Find} find
+ *   Find.
+ * @returns {RegExp}
+ *   Expression.
+ */
+function toExpression(find) {
+  return typeof find === 'string' ? new RegExp(escape(find), 'g') : find
+}
+
+/**
+ * Turn a replace into a function.
+ *
+ * @param {Replace} replace
+ *   Replace.
+ * @returns {ReplaceFunction}
+ *   Function.
+ */
+function toFunction(replace) {
+  return typeof replace === 'function'
+    ? replace
+    : function () {
+        return replace
+      }
+}