@tiangong-lca/pcr 0.3.1 → 0.4.1

package/node_modules/yaml/dist/nodes/Alias.js

@@ -0,0 +1,120 @@
+'use strict';
+
+var anchors = require('../doc/anchors.js');
+var visit = require('../visit.js');
+var identity = require('./identity.js');
+var Node = require('./Node.js');
+var toJS = require('./toJS.js');
+
+class Alias extends Node.NodeBase {
+    constructor(source) {
+        super(identity.ALIAS);
+        this.source = source;
+        Object.defineProperty(this, 'tag', {
+            set() {
+                throw new Error('Alias nodes cannot have tags');
+            }
+        });
+    }
+    /**
+     * Resolve the value of this alias within `doc`, finding the last
+     * instance of the `source` anchor before this node.
+     */
+    resolve(doc, ctx) {
+        if (ctx?.maxAliasCount === 0)
+            throw new ReferenceError('Alias resolution is disabled');
+        let nodes;
+        if (ctx?.aliasResolveCache) {
+            nodes = ctx.aliasResolveCache;
+        }
+        else {
+            nodes = [];
+            visit.visit(doc, {
+                Node: (_key, node) => {
+                    if (identity.isAlias(node) || identity.hasAnchor(node))
+                        nodes.push(node);
+                }
+            });
+            if (ctx)
+                ctx.aliasResolveCache = nodes;
+        }
+        let found = undefined;
+        for (const node of nodes) {
+            if (node === this)
+                break;
+            if (node.anchor === this.source)
+                found = node;
+        }
+        if (found && ctx) {
+            const { anchors, doc, maxAliasCount } = ctx;
+            let data = anchors.get(found);
+            if (!data) {
+                // Resolve anchors for Node.prototype.toJS()
+                toJS.toJS(found, null, ctx);
+                data = anchors.get(found);
+            }
+            /* istanbul ignore if */
+            if (data?.res === undefined) {
+                const msg = 'This should not happen: Alias anchor was not resolved?';
+                throw new ReferenceError(msg);
+            }
+            if (maxAliasCount >= 0) {
+                data.count += 1;
+                if (data.aliasCount === 0)
+                    data.aliasCount = getAliasCount(doc, found, anchors);
+                if (data.count * data.aliasCount > maxAliasCount) {
+                    const msg = 'Excessive alias count indicates a resource exhaustion attack';
+                    throw new ReferenceError(msg);
+                }
+            }
+        }
+        return found;
+    }
+    toJSON(_arg, ctx) {
+        if (!ctx)
+            return { source: this.source };
+        const source = this.resolve(ctx.doc, ctx);
+        if (!source) {
+            const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+            throw new ReferenceError(msg);
+        }
+        return ctx.anchors.get(source).res;
+    }
+    toString(ctx, _onComment, _onChompKeep) {
+        const src = `*${this.source}`;
+        if (ctx) {
+            anchors.anchorIsValid(this.source);
+            if (ctx.options.verifyAliasOrder && !ctx.anchors.has(this.source)) {
+                const msg = `Unresolved alias (the anchor must be set before the alias): ${this.source}`;
+                throw new Error(msg);
+            }
+            if (ctx.implicitKey)
+                return `${src} `;
+        }
+        return src;
+    }
+}
+function getAliasCount(doc, node, anchors) {
+    if (identity.isAlias(node)) {
+        const source = node.resolve(doc);
+        const anchor = anchors && source && anchors.get(source);
+        return anchor ? anchor.count * anchor.aliasCount : 0;
+    }
+    else if (identity.isCollection(node)) {
+        let count = 0;
+        for (const item of node.items) {
+            const c = getAliasCount(doc, item, anchors);
+            if (c > count)
+                count = c;
+        }
+        return count;
+    }
+    else if (identity.isPair(node)) {
+        const kc = getAliasCount(doc, node.key, anchors);
+        const vc = getAliasCount(doc, node.value, anchors);
+        return Math.max(kc, vc);
+    }
+    return 1;
+}
+
+exports.Alias = Alias;

package/node_modules/yaml/dist/nodes/Collection.d.ts

@@ -0,0 +1,73 @@
+import type { Schema } from '../schema/Schema';
+import { NODE_TYPE } from './identity';
+import { NodeBase } from './Node';
+export declare function collectionFromPath(schema: Schema, path: unknown[], value: unknown): import('./Node').Node;
+export declare const isEmptyPath: (path: Iterable<unknown> | null | undefined) => path is null | undefined;
+export declare abstract class Collection extends NodeBase {
+    schema: Schema | undefined;
+    [NODE_TYPE]: symbol;
+    items: unknown[];
+    /** An optional anchor on this node. Used by alias nodes. */
+    anchor?: string;
+    /**
+     * If true, stringify this and all child nodes using flow rather than
+     * block styles.
+     */
+    flow?: boolean;
+    constructor(type: symbol, schema?: Schema);
+    /**
+     * Create a copy of this collection.
+     *
+     * @param schema - If defined, overwrites the original's schema
+     */
+    clone(schema?: Schema): Collection;
+    /** Adds a value to the collection. */
+    abstract add(value: unknown): void;
+    /**
+     * Removes a value from the collection.
+     * @returns `true` if the item was found and removed.
+     */
+    abstract delete(key: unknown): boolean;
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    abstract get(key: unknown, keepScalar?: boolean): unknown;
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     */
+    abstract has(key: unknown): boolean;
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    abstract set(key: unknown, value: unknown): void;
+    /**
+     * Adds a value to the collection. For `!!map` and `!!omap` the value must
+     * be a Pair instance or a `{ key, value }` object, which may not have a key
+     * that already exists in the map.
+     */
+    addIn(path: Iterable<unknown>, value: unknown): void;
+    /**
+     * Removes a value from the collection.
+     * @returns `true` if the item was found and removed.
+     */
+    deleteIn(path: Iterable<unknown>): boolean;
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    getIn(path: Iterable<unknown>, keepScalar?: boolean): unknown;
+    hasAllNullValues(allowScalar?: boolean): boolean;
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     */
+    hasIn(path: Iterable<unknown>): boolean;
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    setIn(path: Iterable<unknown>, value: unknown): void;
+}

package/node_modules/yaml/dist/nodes/Collection.js

@@ -0,0 +1,151 @@
+'use strict';
+
+var createNode = require('../doc/createNode.js');
+var identity = require('./identity.js');
+var Node = require('./Node.js');
+
+function collectionFromPath(schema, path, value) {
+    let v = value;
+    for (let i = path.length - 1; i >= 0; --i) {
+        const k = path[i];
+        if (typeof k === 'number' && Number.isInteger(k) && k >= 0) {
+            const a = [];
+            a[k] = v;
+            v = a;
+        }
+        else {
+            v = new Map([[k, v]]);
+        }
+    }
+    return createNode.createNode(v, undefined, {
+        aliasDuplicateObjects: false,
+        keepUndefined: false,
+        onAnchor: () => {
+            throw new Error('This should not happen, please report a bug.');
+        },
+        schema,
+        sourceObjects: new Map()
+    });
+}
+// Type guard is intentionally a little wrong so as to be more useful,
+// as it does not cover untypable empty non-string iterables (e.g. []).
+const isEmptyPath = (path) => path == null ||
+    (typeof path === 'object' && !!path[Symbol.iterator]().next().done);
+class Collection extends Node.NodeBase {
+    constructor(type, schema) {
+        super(type);
+        Object.defineProperty(this, 'schema', {
+            value: schema,
+            configurable: true,
+            enumerable: false,
+            writable: true
+        });
+    }
+    /**
+     * Create a copy of this collection.
+     *
+     * @param schema - If defined, overwrites the original's schema
+     */
+    clone(schema) {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (schema)
+            copy.schema = schema;
+        copy.items = copy.items.map(it => identity.isNode(it) || identity.isPair(it) ? it.clone(schema) : it);
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
+    /**
+     * Adds a value to the collection. For `!!map` and `!!omap` the value must
+     * be a Pair instance or a `{ key, value }` object, which may not have a key
+     * that already exists in the map.
+     */
+    addIn(path, value) {
+        if (isEmptyPath(path))
+            this.add(value);
+        else {
+            const [key, ...rest] = path;
+            const node = this.get(key, true);
+            if (identity.isCollection(node))
+                node.addIn(rest, value);
+            else if (node === undefined && this.schema)
+                this.set(key, collectionFromPath(this.schema, rest, value));
+            else
+                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        }
+    }
+    /**
+     * Removes a value from the collection.
+     * @returns `true` if the item was found and removed.
+     */
+    deleteIn(path) {
+        const [key, ...rest] = path;
+        if (rest.length === 0)
+            return this.delete(key);
+        const node = this.get(key, true);
+        if (identity.isCollection(node))
+            return node.deleteIn(rest);
+        else
+            throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+    }
+    /**
+     * Returns item at `key`, or `undefined` if not found. By default unwraps
+     * scalar values from their surrounding node; to disable set `keepScalar` to
+     * `true` (collections are always returned intact).
+     */
+    getIn(path, keepScalar) {
+        const [key, ...rest] = path;
+        const node = this.get(key, true);
+        if (rest.length === 0)
+            return !keepScalar && identity.isScalar(node) ? node.value : node;
+        else
+            return identity.isCollection(node) ? node.getIn(rest, keepScalar) : undefined;
+    }
+    hasAllNullValues(allowScalar) {
+        return this.items.every(node => {
+            if (!identity.isPair(node))
+                return false;
+            const n = node.value;
+            return (n == null ||
+                (allowScalar &&
+                    identity.isScalar(n) &&
+                    n.value == null &&
+                    !n.commentBefore &&
+                    !n.comment &&
+                    !n.tag));
+        });
+    }
+    /**
+     * Checks if the collection includes a value with the key `key`.
+     */
+    hasIn(path) {
+        const [key, ...rest] = path;
+        if (rest.length === 0)
+            return this.has(key);
+        const node = this.get(key, true);
+        return identity.isCollection(node) ? node.hasIn(rest) : false;
+    }
+    /**
+     * Sets a value in this collection. For `!!set`, `value` needs to be a
+     * boolean to add/remove the item from the set.
+     */
+    setIn(path, value) {
+        const [key, ...rest] = path;
+        if (rest.length === 0) {
+            this.set(key, value);
+        }
+        else {
+            const node = this.get(key, true);
+            if (identity.isCollection(node))
+                node.setIn(rest, value);
+            else if (node === undefined && this.schema)
+                this.set(key, collectionFromPath(this.schema, rest, value));
+            else
+                throw new Error(`Expected YAML collection at ${key}. Remaining path: ${rest}`);
+        }
+    }
+}
+
+exports.Collection = Collection;
+exports.collectionFromPath = collectionFromPath;
+exports.isEmptyPath = isEmptyPath;

package/node_modules/yaml/dist/nodes/Node.d.ts

@@ -0,0 +1,53 @@
+import type { Document } from '../doc/Document';
+import type { ToJSOptions } from '../options';
+import type { Token } from '../parse/cst';
+import type { StringifyContext } from '../stringify/stringify';
+import type { Alias } from './Alias';
+import { NODE_TYPE } from './identity';
+import type { Scalar } from './Scalar';
+import type { ToJSContext } from './toJS';
+import type { MapLike, YAMLMap } from './YAMLMap';
+import type { YAMLSeq } from './YAMLSeq';
+export type Node<T = unknown> = Alias | Scalar<T> | YAMLMap<unknown, T> | YAMLSeq<T>;
+/** Utility type mapper */
+export type NodeType<T> = T extends string | number | bigint | boolean | null | undefined ? Scalar<T> : T extends Date ? Scalar<string | Date> : T extends Array<any> ? YAMLSeq<NodeType<T[number]>> : T extends {
+    [key: string]: any;
+} ? YAMLMap<NodeType<keyof T>, NodeType<T[keyof T]>> : T extends {
+    [key: number]: any;
+} ? YAMLMap<NodeType<keyof T>, NodeType<T[keyof T]>> : Node;
+export type ParsedNode = Alias.Parsed | Scalar.Parsed | YAMLMap.Parsed | YAMLSeq.Parsed;
+/** `[start, value-end, node-end]` */
+export type Range = [number, number, number];
+export declare abstract class NodeBase {
+    readonly [NODE_TYPE]: symbol;
+    /** A comment on or immediately after this */
+    comment?: string | null;
+    /** A comment before this */
+    commentBefore?: string | null;
+    /**
+     * The `[start, value-end, node-end]` character offsets for the part of the
+     * source parsed into this node (undefined if not parsed). The `value-end`
+     * and `node-end` positions are themselves not included in their respective
+     * ranges.
+     */
+    range?: Range | null;
+    /** A blank line before this node and its commentBefore */
+    spaceBefore?: boolean;
+    /** The CST token that was composed into this node.  */
+    srcToken?: Token;
+    /** A fully qualified tag, if required */
+    tag?: string;
+    /**
+     * Customize the way that a key-value pair is resolved.
+     * Used for YAML 1.1 !!merge << handling.
+     */
+    addToJSMap?: (ctx: ToJSContext | undefined, map: MapLike, value: unknown) => void;
+    /** A plain JS representation of this node */
+    abstract toJSON(): any;
+    abstract toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+    constructor(type: symbol);
+    /** Create a copy of this node.  */
+    clone(): NodeBase;
+    /** A plain JavaScript representation of this node. */
+    toJS(doc: Document<Node, boolean>, { mapAsMap, maxAliasCount, onAnchor, reviver }?: ToJSOptions): any;
+}

package/node_modules/yaml/dist/nodes/Node.js

@@ -0,0 +1,40 @@
+'use strict';
+
+var applyReviver = require('../doc/applyReviver.js');
+var identity = require('./identity.js');
+var toJS = require('./toJS.js');
+
+class NodeBase {
+    constructor(type) {
+        Object.defineProperty(this, identity.NODE_TYPE, { value: type });
+    }
+    /** Create a copy of this node.  */
+    clone() {
+        const copy = Object.create(Object.getPrototypeOf(this), Object.getOwnPropertyDescriptors(this));
+        if (this.range)
+            copy.range = this.range.slice();
+        return copy;
+    }
+    /** A plain JavaScript representation of this node. */
+    toJS(doc, { mapAsMap, maxAliasCount, onAnchor, reviver } = {}) {
+        if (!identity.isDocument(doc))
+            throw new TypeError('A document argument is required');
+        const ctx = {
+            anchors: new Map(),
+            doc,
+            keep: true,
+            mapAsMap: mapAsMap === true,
+            mapKeyWarned: false,
+            maxAliasCount: typeof maxAliasCount === 'number' ? maxAliasCount : 100
+        };
+        const res = toJS.toJS(this, '', ctx);
+        if (typeof onAnchor === 'function')
+            for (const { count, res } of ctx.anchors.values())
+                onAnchor(res, count);
+        return typeof reviver === 'function'
+            ? applyReviver.applyReviver(reviver, { '': res }, '', res)
+            : res;
+    }
+}
+
+exports.NodeBase = NodeBase;

package/node_modules/yaml/dist/nodes/Pair.d.ts

@@ -0,0 +1,22 @@
+import type { CreateNodeContext } from '../doc/createNode';
+import type { CollectionItem } from '../parse/cst';
+import type { Schema } from '../schema/Schema';
+import type { StringifyContext } from '../stringify/stringify';
+import { addPairToJSMap } from './addPairToJSMap';
+import { NODE_TYPE } from './identity';
+import type { Node } from './Node';
+import type { ToJSContext } from './toJS';
+export declare function createPair(key: unknown, value: unknown, ctx: CreateNodeContext): Pair<Node, Node>;
+export declare class Pair<K = unknown, V = unknown> {
+    readonly [NODE_TYPE]: symbol;
+    /** Always Node or null when parsed, but can be set to anything. */
+    key: K;
+    /** Always Node or null when parsed, but can be set to anything. */
+    value: V | null;
+    /** The CST token that was composed into this pair.  */
+    srcToken?: CollectionItem;
+    constructor(key: K, value?: V | null);
+    clone(schema?: Schema): Pair<K, V>;
+    toJSON(_?: unknown, ctx?: ToJSContext): ReturnType<typeof addPairToJSMap>;
+    toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+}

package/node_modules/yaml/dist/nodes/Pair.js

@@ -0,0 +1,39 @@
+'use strict';
+
+var createNode = require('../doc/createNode.js');
+var stringifyPair = require('../stringify/stringifyPair.js');
+var addPairToJSMap = require('./addPairToJSMap.js');
+var identity = require('./identity.js');
+
+function createPair(key, value, ctx) {
+    const k = createNode.createNode(key, undefined, ctx);
+    const v = createNode.createNode(value, undefined, ctx);
+    return new Pair(k, v);
+}
+class Pair {
+    constructor(key, value = null) {
+        Object.defineProperty(this, identity.NODE_TYPE, { value: identity.PAIR });
+        this.key = key;
+        this.value = value;
+    }
+    clone(schema) {
+        let { key, value } = this;
+        if (identity.isNode(key))
+            key = key.clone(schema);
+        if (identity.isNode(value))
+            value = value.clone(schema);
+        return new Pair(key, value);
+    }
+    toJSON(_, ctx) {
+        const pair = ctx?.mapAsMap ? new Map() : {};
+        return addPairToJSMap.addPairToJSMap(ctx, pair, this);
+    }
+    toString(ctx, onComment, onChompKeep) {
+        return ctx?.doc
+            ? stringifyPair.stringifyPair(this, ctx, onComment, onChompKeep)
+            : JSON.stringify(this);
+    }
+}
+
+exports.Pair = Pair;
+exports.createPair = createPair;

package/node_modules/yaml/dist/nodes/Scalar.d.ts

@@ -0,0 +1,47 @@
+import type { BlockScalar, FlowScalar } from '../parse/cst';
+import type { Range } from './Node';
+import { NodeBase } from './Node';
+import type { ToJSContext } from './toJS';
+export declare const isScalarValue: (value: unknown) => boolean;
+export declare namespace Scalar {
+    interface Parsed extends Scalar {
+        range: Range;
+        source: string;
+        srcToken?: FlowScalar | BlockScalar;
+    }
+    type BLOCK_FOLDED = 'BLOCK_FOLDED';
+    type BLOCK_LITERAL = 'BLOCK_LITERAL';
+    type PLAIN = 'PLAIN';
+    type QUOTE_DOUBLE = 'QUOTE_DOUBLE';
+    type QUOTE_SINGLE = 'QUOTE_SINGLE';
+    type Type = BLOCK_FOLDED | BLOCK_LITERAL | PLAIN | QUOTE_DOUBLE | QUOTE_SINGLE;
+}
+export declare class Scalar<T = unknown> extends NodeBase {
+    static readonly BLOCK_FOLDED = "BLOCK_FOLDED";
+    static readonly BLOCK_LITERAL = "BLOCK_LITERAL";
+    static readonly PLAIN = "PLAIN";
+    static readonly QUOTE_DOUBLE = "QUOTE_DOUBLE";
+    static readonly QUOTE_SINGLE = "QUOTE_SINGLE";
+    value: T;
+    /** An optional anchor on this node. Used by alias nodes. */
+    anchor?: string;
+    /**
+     * By default (undefined), numbers use decimal notation.
+     * The YAML 1.2 core schema only supports 'HEX' and 'OCT'.
+     * The YAML 1.1 schema also supports 'BIN' and 'TIME'
+     */
+    format?: string;
+    /**
+     * If `value` is a number that is serialized as a decimal string
+     * (i.e. not using exponential notation),
+     * use this value when stringifying this node.
+     */
+    minFractionDigits?: number;
+    /** Set during parsing to the source string value */
+    source?: string;
+    /** The scalar style used for the node's string representation */
+    type?: Scalar.Type;
+    constructor(value: T);
+    toJSON(arg?: any, ctx?: ToJSContext): any;
+    toString(): string;
+}

package/node_modules/yaml/dist/nodes/Scalar.js

@@ -0,0 +1,27 @@
+'use strict';
+
+var identity = require('./identity.js');
+var Node = require('./Node.js');
+var toJS = require('./toJS.js');
+
+const isScalarValue = (value) => !value || (typeof value !== 'function' && typeof value !== 'object');
+class Scalar extends Node.NodeBase {
+    constructor(value) {
+        super(identity.SCALAR);
+        this.value = value;
+    }
+    toJSON(arg, ctx) {
+        return ctx?.keep ? this.value : toJS.toJS(this.value, arg, ctx);
+    }
+    toString() {
+        return String(this.value);
+    }
+}
+Scalar.BLOCK_FOLDED = 'BLOCK_FOLDED';
+Scalar.BLOCK_LITERAL = 'BLOCK_LITERAL';
+Scalar.PLAIN = 'PLAIN';
+Scalar.QUOTE_DOUBLE = 'QUOTE_DOUBLE';
+Scalar.QUOTE_SINGLE = 'QUOTE_SINGLE';
+
+exports.Scalar = Scalar;
+exports.isScalarValue = isScalarValue;

package/node_modules/yaml/dist/nodes/YAMLMap.d.ts

@@ -0,0 +1,53 @@
+import type { BlockMap, FlowCollection } from '../parse/cst';
+import type { Schema } from '../schema/Schema';
+import type { StringifyContext } from '../stringify/stringify';
+import type { CreateNodeContext } from '../util';
+import { Collection } from './Collection';
+import type { ParsedNode, Range } from './Node';
+import { Pair } from './Pair';
+import type { Scalar } from './Scalar';
+import type { ToJSContext } from './toJS';
+export type MapLike = Map<unknown, unknown> | Set<unknown> | Record<string | number | symbol, unknown>;
+export declare function findPair<K = unknown, V = unknown>(items: Iterable<Pair<K, V>>, key: unknown): Pair<K, V> | undefined;
+export declare namespace YAMLMap {
+    interface Parsed<K extends ParsedNode = ParsedNode, V extends ParsedNode | null = ParsedNode | null> extends YAMLMap<K, V> {
+        items: Pair<K, V>[];
+        range: Range;
+        srcToken?: BlockMap | FlowCollection;
+    }
+}
+export declare class YAMLMap<K = unknown, V = unknown> extends Collection {
+    static get tagName(): 'tag:yaml.org,2002:map';
+    items: Pair<K, V>[];
+    constructor(schema?: Schema);
+    /**
+     * A generic collection parsing method that can be extended
+     * to other node classes that inherit from YAMLMap
+     */
+    static from(schema: Schema, obj: unknown, ctx: CreateNodeContext): YAMLMap;
+    /**
+     * Adds a value to the collection.
+     *
+     * @param overwrite - If not set `true`, using a key that is already in the
+     *   collection will throw. Otherwise, overwrites the previous value.
+     */
+    add(pair: Pair<K, V> | {
+        key: K;
+        value: V;
+    }, overwrite?: boolean): void;
+    delete(key: unknown): boolean;
+    get(key: unknown, keepScalar: true): Scalar<V> | undefined;
+    get(key: unknown, keepScalar?: false): V | undefined;
+    get(key: unknown, keepScalar?: boolean): V | Scalar<V> | undefined;
+    has(key: unknown): boolean;
+    set(key: K, value: V): void;
+    /**
+     * @param ctx - Conversion context, originally set in Document#toJS()
+     * @param {Class} Type - If set, forces the returned collection type
+     * @returns Instance of Type, Map, or Object
+     */
+    toJSON<T extends MapLike = Map<unknown, unknown>>(_?: unknown, ctx?: ToJSContext, Type?: {
+        new (): T;
+    }): any;
+    toString(ctx?: StringifyContext, onComment?: () => void, onChompKeep?: () => void): string;
+}