@wo658/redpact 0.3.0 → 0.5.0

package/node_modules/@rushstack/node-core-library/lib/Sort.js

@@ -0,0 +1,266 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Sort = void 0;
+/**
+ * Operations for sorting collections.
+ *
+ * @public
+ */
+class Sort {
+    /**
+     * Compares `x` and `y` using the JavaScript `>` and `<` operators.  This function is suitable for usage as
+     * the callback for `array.sort()`.
+     *
+     * @remarks
+     *
+     * The JavaScript ordering is generalized so that `undefined` \< `null` \< all other values.
+     *
+     * @returns -1 if `x` is smaller than `y`, 1 if `x` is greater than `y`, or 0 if the values are equal.
+     *
+     * @example
+     *
+     * ```ts
+     * let array: number[] = [3, 6, 2];
+     * array.sort(Sort.compareByValue);  // [2, 3, 6]
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static compareByValue(x, y) {
+        if (x === y) {
+            return 0;
+        }
+        // Undefined is smaller than anything else
+        if (x === undefined) {
+            return -1;
+        }
+        if (y === undefined) {
+            return 1;
+        }
+        // Null is smaller than anything except undefined
+        if (x === null) {
+            return -1;
+        }
+        if (y === null) {
+            return 1;
+        }
+        // These comparisons always return false if either of the arguments is "undefined".
+        // These comparisons return nonsense for "null" (true for "null > -1", but false for "null < 0" and "null > 0")
+        if (x < y) {
+            return -1;
+        }
+        if (x > y) {
+            return 1;
+        }
+        return 0;
+    }
+    /**
+     * Sorts the array according to a key which is obtained from the array elements.
+     * The result is guaranteed to be a stable sort.
+     *
+     * @example
+     *
+     * ```ts
+     * let array: string[] = [ 'aaa', 'bb', 'c' ];
+     * Sort.sortBy(array, x => x.length);  // [ 'c', 'bb', 'aaa' ]
+     * ```
+     */
+    static sortBy(array, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    keySelector, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    comparer = Sort.compareByValue) {
+        array.sort((x, y) => comparer(keySelector(x), keySelector(y)));
+    }
+    /**
+     * Returns true if the collection is already sorted.
+     */
+    static isSorted(collection, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    comparer = Sort.compareByValue) {
+        let isFirst = true;
+        let previous = undefined;
+        for (const element of collection) {
+            if (isFirst) {
+                // Don't start by comparing against undefined.
+                isFirst = false;
+            }
+            else if (comparer(previous, element) > 0) {
+                return false;
+            }
+            previous = element;
+        }
+        return true;
+    }
+    /**
+     * Returns true if the collection is already sorted by the specified key.
+     *
+     * @example
+     *
+     * ```ts
+     * let array: string[] = [ 'a', 'bb', 'ccc' ];
+     * Sort.isSortedBy(array, x => x.length); // true
+     * ```
+     */
+    static isSortedBy(collection, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    keySelector, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    comparer = Sort.compareByValue) {
+        let isFirst = true;
+        let previousKey = undefined;
+        for (const element of collection) {
+            const key = keySelector(element);
+            if (isFirst) {
+                // Don't start by comparing against undefined.
+                isFirst = false;
+            }
+            else if (comparer(previousKey, key) > 0) {
+                return false;
+            }
+            previousKey = key;
+        }
+        return true;
+    }
+    /**
+     * Sorts the entries in a Map object according to the map keys.
+     * The result is guaranteed to be a stable sort.
+     *
+     * @example
+     *
+     * ```ts
+     * let map: Map<string, number> = new Map<string, number>();
+     * map.set('zebra', 1);
+     * map.set('goose', 2);
+     * map.set('aardvark', 3);
+     * Sort.sortMapKeys(map);
+     * console.log(JSON.stringify(Array.from(map.keys()))); // ["aardvark","goose","zebra"]
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static sortMapKeys(map, keyComparer = Sort.compareByValue) {
+        // Sorting a map is expensive, so first check whether it's already sorted.
+        if (Sort.isSorted(map.keys(), keyComparer)) {
+            return;
+        }
+        const pairs = Array.from(map.entries());
+        Sort.sortBy(pairs, (x) => x[0], keyComparer);
+        map.clear();
+        for (const pair of pairs) {
+            map.set(pair[0], pair[1]);
+        }
+    }
+    /**
+     * Sorts the entries in a Set object according to the specified keys.
+     * The result is guaranteed to be a stable sort.
+     *
+     * @example
+     *
+     * ```ts
+     * let set: Set<string> = new Set<string>();
+     * set.add('aaa');
+     * set.add('bb');
+     * set.add('c');
+     * Sort.sortSetBy(set, x => x.length);
+     * console.log(Array.from(set)); // ['c', 'bb', 'aaa']
+     * ```
+     */
+    static sortSetBy(set, 
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    keySelector, keyComparer = Sort.compareByValue) {
+        // Sorting a set is expensive, so first check whether it's already sorted.
+        if (Sort.isSortedBy(set, keySelector, keyComparer)) {
+            return;
+        }
+        const array = Array.from(set);
+        array.sort((x, y) => keyComparer(keySelector(x), keySelector(y)));
+        set.clear();
+        for (const item of array) {
+            set.add(item);
+        }
+    }
+    /**
+     * Sorts the entries in a Set object.  The result is guaranteed to be a stable sort.
+     *
+     * @example
+     *
+     * ```ts
+     * let set: Set<string> = new Set<string>();
+     * set.add('zebra');
+     * set.add('goose');
+     * set.add('aardvark');
+     * Sort.sortSet(set);
+     * console.log(Array.from(set)); // ['aardvark', 'goose', 'zebra']
+     * ```
+     */
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    static sortSet(set, comparer = Sort.compareByValue) {
+        // Sorting a set is expensive, so first check whether it's already sorted.
+        if (Sort.isSorted(set, comparer)) {
+            return;
+        }
+        const array = Array.from(set);
+        array.sort((x, y) => comparer(x, y));
+        set.clear();
+        for (const item of array) {
+            set.add(item);
+        }
+    }
+    /**
+     * Sort the keys deeply given an object or an array.
+     *
+     * Doesn't handle cyclic reference.
+     *
+     * @param object - The object to be sorted
+     *
+     * @example
+     *
+     * ```ts
+     * console.log(Sort.sortKeys({ c: 3, b: 2, a: 1 })); // { a: 1, b: 2, c: 3}
+     * ```
+     */
+    static sortKeys(object) {
+        if (!isPlainObject(object) && !Array.isArray(object)) {
+            throw new TypeError(`Expected object or array`);
+        }
+        return Array.isArray(object) ? innerSortArray(object) : innerSortKeys(object);
+    }
+}
+exports.Sort = Sort;
+function isPlainObject(obj) {
+    return obj !== null && typeof obj === 'object';
+}
+function innerSortArray(arr) {
+    const result = [];
+    for (const entry of arr) {
+        if (Array.isArray(entry)) {
+            result.push(innerSortArray(entry));
+        }
+        else if (isPlainObject(entry)) {
+            result.push(innerSortKeys(entry));
+        }
+        else {
+            result.push(entry);
+        }
+    }
+    return result;
+}
+function innerSortKeys(obj) {
+    const result = {};
+    const keys = Object.keys(obj).sort();
+    for (const key of keys) {
+        const value = obj[key];
+        if (Array.isArray(value)) {
+            result[key] = innerSortArray(value);
+        }
+        else if (isPlainObject(value)) {
+            result[key] = innerSortKeys(value);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+//# sourceMappingURL=Sort.js.map

package/node_modules/@rushstack/node-core-library/lib/Sort.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"Sort.js","sourceRoot":"","sources":["../src/Sort.ts"],"names":[],"mappings":"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","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/**\n * Operations for sorting collections.\n *\n * @public\n */\nexport class Sort {\n  /**\n   * Compares `x` and `y` using the JavaScript `>` and `<` operators.  This function is suitable for usage as\n   * the callback for `array.sort()`.\n   *\n   * @remarks\n   *\n   * The JavaScript ordering is generalized so that `undefined` \\< `null` \\< all other values.\n   *\n   * @returns -1 if `x` is smaller than `y`, 1 if `x` is greater than `y`, or 0 if the values are equal.\n   *\n   * @example\n   *\n   * ```ts\n   * let array: number[] = [3, 6, 2];\n   * array.sort(Sort.compareByValue);  // [2, 3, 6]\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public static compareByValue(x: any, y: any): number {\n    if (x === y) {\n      return 0;\n    }\n\n    // Undefined is smaller than anything else\n    if (x === undefined) {\n      return -1;\n    }\n    if (y === undefined) {\n      return 1;\n    }\n\n    // Null is smaller than anything except undefined\n    if (x === null) {\n      return -1;\n    }\n    if (y === null) {\n      return 1;\n    }\n\n    // These comparisons always return false if either of the arguments is \"undefined\".\n    // These comparisons return nonsense for \"null\" (true for \"null > -1\", but false for \"null < 0\" and \"null > 0\")\n    if (x < y) {\n      return -1;\n    }\n    if (x > y) {\n      return 1;\n    }\n\n    return 0;\n  }\n\n  /**\n   * Sorts the array according to a key which is obtained from the array elements.\n   * The result is guaranteed to be a stable sort.\n   *\n   * @example\n   *\n   * ```ts\n   * let array: string[] = [ 'aaa', 'bb', 'c' ];\n   * Sort.sortBy(array, x => x.length);  // [ 'c', 'bb', 'aaa' ]\n   * ```\n   */\n  public static sortBy<T>(\n    array: T[],\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    keySelector: (element: T) => any,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    comparer: (x: any, y: any) => number = Sort.compareByValue\n  ): void {\n    array.sort((x, y) => comparer(keySelector(x), keySelector(y)));\n  }\n\n  /**\n   * Returns true if the collection is already sorted.\n   */\n  public static isSorted<T>(\n    collection: Iterable<T>,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    comparer: (x: any, y: any) => number = Sort.compareByValue\n  ): boolean {\n    let isFirst: boolean = true;\n    let previous: T | undefined = undefined;\n    for (const element of collection) {\n      if (isFirst) {\n        // Don't start by comparing against undefined.\n        isFirst = false;\n      } else if (comparer(previous, element) > 0) {\n        return false;\n      }\n      previous = element;\n    }\n    return true;\n  }\n\n  /**\n   * Returns true if the collection is already sorted by the specified key.\n   *\n   * @example\n   *\n   * ```ts\n   * let array: string[] = [ 'a', 'bb', 'ccc' ];\n   * Sort.isSortedBy(array, x => x.length); // true\n   * ```\n   */\n  public static isSortedBy<T>(\n    collection: Iterable<T>,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    keySelector: (element: T) => any,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    comparer: (x: any, y: any) => number = Sort.compareByValue\n  ): boolean {\n    let isFirst: boolean = true;\n    let previousKey: T | undefined = undefined;\n    for (const element of collection) {\n      const key: T = keySelector(element);\n      if (isFirst) {\n        // Don't start by comparing against undefined.\n        isFirst = false;\n      } else if (comparer(previousKey, key) > 0) {\n        return false;\n      }\n      previousKey = key;\n    }\n    return true;\n  }\n\n  /**\n   * Sorts the entries in a Map object according to the map keys.\n   * The result is guaranteed to be a stable sort.\n   *\n   * @example\n   *\n   * ```ts\n   * let map: Map<string, number> = new Map<string, number>();\n   * map.set('zebra', 1);\n   * map.set('goose', 2);\n   * map.set('aardvark', 3);\n   * Sort.sortMapKeys(map);\n   * console.log(JSON.stringify(Array.from(map.keys()))); // [\"aardvark\",\"goose\",\"zebra\"]\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public static sortMapKeys<K, V>(\n    map: Map<K, V>,\n    keyComparer: (x: K, y: K) => number = Sort.compareByValue\n  ): void {\n    // Sorting a map is expensive, so first check whether it's already sorted.\n    if (Sort.isSorted(map.keys(), keyComparer)) {\n      return;\n    }\n\n    const pairs: [K, V][] = Array.from(map.entries());\n\n    Sort.sortBy(pairs, (x) => x[0], keyComparer);\n    map.clear();\n    for (const pair of pairs) {\n      map.set(pair[0], pair[1]);\n    }\n  }\n\n  /**\n   * Sorts the entries in a Set object according to the specified keys.\n   * The result is guaranteed to be a stable sort.\n   *\n   * @example\n   *\n   * ```ts\n   * let set: Set<string> = new Set<string>();\n   * set.add('aaa');\n   * set.add('bb');\n   * set.add('c');\n   * Sort.sortSetBy(set, x => x.length);\n   * console.log(Array.from(set)); // ['c', 'bb', 'aaa']\n   * ```\n   */\n  public static sortSetBy<T>(\n    set: Set<T>,\n    // eslint-disable-next-line @typescript-eslint/no-explicit-any\n    keySelector: (element: T) => any,\n    keyComparer: (x: T, y: T) => number = Sort.compareByValue\n  ): void {\n    // Sorting a set is expensive, so first check whether it's already sorted.\n    if (Sort.isSortedBy(set, keySelector, keyComparer)) {\n      return;\n    }\n\n    const array: T[] = Array.from(set);\n    array.sort((x, y) => keyComparer(keySelector(x), keySelector(y)));\n\n    set.clear();\n    for (const item of array) {\n      set.add(item);\n    }\n  }\n\n  /**\n   * Sorts the entries in a Set object.  The result is guaranteed to be a stable sort.\n   *\n   * @example\n   *\n   * ```ts\n   * let set: Set<string> = new Set<string>();\n   * set.add('zebra');\n   * set.add('goose');\n   * set.add('aardvark');\n   * Sort.sortSet(set);\n   * console.log(Array.from(set)); // ['aardvark', 'goose', 'zebra']\n   * ```\n   */\n  // eslint-disable-next-line @typescript-eslint/no-explicit-any\n  public static sortSet<T>(set: Set<T>, comparer: (x: T, y: T) => number = Sort.compareByValue): void {\n    // Sorting a set is expensive, so first check whether it's already sorted.\n    if (Sort.isSorted(set, comparer)) {\n      return;\n    }\n\n    const array: T[] = Array.from(set);\n    array.sort((x, y) => comparer(x, y));\n\n    set.clear();\n    for (const item of array) {\n      set.add(item);\n    }\n  }\n\n  /**\n   * Sort the keys deeply given an object or an array.\n   *\n   * Doesn't handle cyclic reference.\n   *\n   * @param object - The object to be sorted\n   *\n   * @example\n   *\n   * ```ts\n   * console.log(Sort.sortKeys({ c: 3, b: 2, a: 1 })); // { a: 1, b: 2, c: 3}\n   * ```\n   */\n  public static sortKeys<T extends Partial<Record<string, unknown>> | unknown[]>(object: T): T {\n    if (!isPlainObject(object) && !Array.isArray(object)) {\n      throw new TypeError(`Expected object or array`);\n    }\n\n    return Array.isArray(object) ? (innerSortArray(object) as T) : (innerSortKeys(object) as T);\n  }\n}\n\nfunction isPlainObject(obj: unknown): obj is object {\n  return obj !== null && typeof obj === 'object';\n}\n\nfunction innerSortArray(arr: unknown[]): unknown[] {\n  const result: unknown[] = [];\n  for (const entry of arr) {\n    if (Array.isArray(entry)) {\n      result.push(innerSortArray(entry));\n    } else if (isPlainObject(entry)) {\n      result.push(innerSortKeys(entry));\n    } else {\n      result.push(entry);\n    }\n  }\n  return result;\n}\n\nfunction innerSortKeys(obj: Partial<Record<string, unknown>>): Partial<Record<string, unknown>> {\n  const result: Partial<Record<string, unknown>> = {};\n  const keys: string[] = Object.keys(obj).sort();\n  for (const key of keys) {\n    const value: unknown = obj[key];\n    if (Array.isArray(value)) {\n      result[key] = innerSortArray(value);\n    } else if (isPlainObject(value)) {\n      result[key] = innerSortKeys(value);\n    } else {\n      result[key] = value;\n    }\n  }\n\n  return result;\n}\n"]}

package/node_modules/@rushstack/node-core-library/lib/StringBuilder.d.ts

@@ -0,0 +1,46 @@
+/**
+ * An interface for a builder object that allows a large text string to be constructed incrementally by appending
+ * small chunks.
+ *
+ * @remarks
+ *
+ * {@link StringBuilder} is the default implementation of this contract.
+ *
+ * @public
+ */
+export interface IStringBuilder {
+    /**
+     * Append the specified text to the buffer.
+     */
+    append(text: string): void;
+    /**
+     * Returns a single string containing all the text that was appended to the buffer so far.
+     *
+     * @remarks
+     *
+     * This is a potentially expensive operation.
+     */
+    toString(): string;
+}
+/**
+ * This class allows a large text string to be constructed incrementally by appending small chunks.  The final
+ * string can be obtained by calling StringBuilder.toString().
+ *
+ * @remarks
+ * A naive approach might use the `+=` operator to append strings:  This would have the downside of copying
+ * the entire string each time a chunk is appended, resulting in `O(n^2)` bytes of memory being allocated
+ * (and later freed by the garbage  collector), and many of the allocations could be very large objects.
+ * StringBuilder avoids this overhead by accumulating the chunks in an array, and efficiently joining them
+ * when `getText()` is finally called.
+ *
+ * @public
+ */
+export declare class StringBuilder implements IStringBuilder {
+    private _chunks;
+    constructor();
+    /** {@inheritDoc IStringBuilder.append} */
+    append(text: string): void;
+    /** {@inheritDoc IStringBuilder.toString} */
+    toString(): string;
+}
+//# sourceMappingURL=StringBuilder.d.ts.map

package/node_modules/@rushstack/node-core-library/lib/StringBuilder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringBuilder.d.ts","sourceRoot":"","sources":["../src/StringBuilder.ts"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,MAAM,WAAW,cAAc;IAC7B;;OAEG;IACH,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAAC;IAE3B;;;;;;OAMG;IACH,QAAQ,IAAI,MAAM,CAAC;CACpB;AAED;;;;;;;;;;;;GAYG;AACH,qBAAa,aAAc,YAAW,cAAc;IAClD,OAAO,CAAC,OAAO,CAAW;;IAM1B,0CAA0C;IACnC,MAAM,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;IAIjC,4CAA4C;IACrC,QAAQ,IAAI,MAAM;CAa1B"}

package/node_modules/@rushstack/node-core-library/lib/StringBuilder.js

@@ -0,0 +1,41 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StringBuilder = void 0;
+/**
+ * This class allows a large text string to be constructed incrementally by appending small chunks.  The final
+ * string can be obtained by calling StringBuilder.toString().
+ *
+ * @remarks
+ * A naive approach might use the `+=` operator to append strings:  This would have the downside of copying
+ * the entire string each time a chunk is appended, resulting in `O(n^2)` bytes of memory being allocated
+ * (and later freed by the garbage  collector), and many of the allocations could be very large objects.
+ * StringBuilder avoids this overhead by accumulating the chunks in an array, and efficiently joining them
+ * when `getText()` is finally called.
+ *
+ * @public
+ */
+class StringBuilder {
+    constructor() {
+        this._chunks = [];
+    }
+    /** {@inheritDoc IStringBuilder.append} */
+    append(text) {
+        this._chunks.push(text);
+    }
+    /** {@inheritDoc IStringBuilder.toString} */
+    toString() {
+        if (this._chunks.length === 0) {
+            return '';
+        }
+        if (this._chunks.length > 1) {
+            const joined = this._chunks.join('');
+            this._chunks.length = 1;
+            this._chunks[0] = joined;
+        }
+        return this._chunks[0];
+    }
+}
+exports.StringBuilder = StringBuilder;
+//# sourceMappingURL=StringBuilder.js.map

package/node_modules/@rushstack/node-core-library/lib/StringBuilder.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"StringBuilder.js","sourceRoot":"","sources":["../src/StringBuilder.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AA4B3D;;;;;;;;;;;;GAYG;AACH,MAAa,aAAa;IAGxB;QACE,IAAI,CAAC,OAAO,GAAG,EAAE,CAAC;IACpB,CAAC;IAED,0CAA0C;IACnC,MAAM,CAAC,IAAY;QACxB,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;IAC1B,CAAC;IAED,4CAA4C;IACrC,QAAQ;QACb,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,KAAK,CAAC,EAAE,CAAC;YAC9B,OAAO,EAAE,CAAC;QACZ,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YAC5B,MAAM,MAAM,GAAW,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,EAAE,CAAC,CAAC;YAC7C,IAAI,CAAC,OAAO,CAAC,MAAM,GAAG,CAAC,CAAC;YACxB,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC;QAC3B,CAAC;QAED,OAAO,IAAI,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC;IACzB,CAAC;CACF;AA1BD,sCA0BC","sourcesContent":["// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.\n// See LICENSE in the project root for license information.\n\n/**\n * An interface for a builder object that allows a large text string to be constructed incrementally by appending\n * small chunks.\n *\n * @remarks\n *\n * {@link StringBuilder} is the default implementation of this contract.\n *\n * @public\n */\nexport interface IStringBuilder {\n  /**\n   * Append the specified text to the buffer.\n   */\n  append(text: string): void;\n\n  /**\n   * Returns a single string containing all the text that was appended to the buffer so far.\n   *\n   * @remarks\n   *\n   * This is a potentially expensive operation.\n   */\n  toString(): string;\n}\n\n/**\n * This class allows a large text string to be constructed incrementally by appending small chunks.  The final\n * string can be obtained by calling StringBuilder.toString().\n *\n * @remarks\n * A naive approach might use the `+=` operator to append strings:  This would have the downside of copying\n * the entire string each time a chunk is appended, resulting in `O(n^2)` bytes of memory being allocated\n * (and later freed by the garbage  collector), and many of the allocations could be very large objects.\n * StringBuilder avoids this overhead by accumulating the chunks in an array, and efficiently joining them\n * when `getText()` is finally called.\n *\n * @public\n */\nexport class StringBuilder implements IStringBuilder {\n  private _chunks: string[];\n\n  public constructor() {\n    this._chunks = [];\n  }\n\n  /** {@inheritDoc IStringBuilder.append} */\n  public append(text: string): void {\n    this._chunks.push(text);\n  }\n\n  /** {@inheritDoc IStringBuilder.toString} */\n  public toString(): string {\n    if (this._chunks.length === 0) {\n      return '';\n    }\n\n    if (this._chunks.length > 1) {\n      const joined: string = this._chunks.join('');\n      this._chunks.length = 1;\n      this._chunks[0] = joined;\n    }\n\n    return this._chunks[0];\n  }\n}\n"]}

package/node_modules/@rushstack/node-core-library/lib/SubprocessTerminator.d.ts

@@ -0,0 +1,64 @@
+import type * as child_process from 'child_process';
+/**
+ * Details about how the `child_process.ChildProcess` was created.
+ *
+ * @beta
+ */
+export interface ISubprocessOptions {
+    /**
+     * Whether or not the child process was started in detached mode.
+     *
+     * @remarks
+     * On POSIX systems, detached=true is required for killing the subtree. Attempting to kill the
+     * subtree on POSIX systems with detached=false will throw an error. On Windows, detached=true
+     * creates a separate console window and is not required for killing the subtree. In general,
+     * it is recommended to use SubprocessTerminator.RECOMMENDED_OPTIONS when forking or spawning
+     * a child process.
+     */
+    detached: boolean;
+}
+/**
+ * When a child process is created, registering it with the SubprocessTerminator will ensure
+ * that the child gets terminated when the current process terminates.
+ *
+ * @remarks
+ * This works by hooking the current process's events for SIGTERM/SIGINT/exit, and ensuring the
+ * child process gets terminated in those cases.
+ *
+ * SubprocessTerminator doesn't do anything on Windows, since by default Windows automatically
+ * terminates child processes when their parent is terminated.
+ *
+ * @beta
+ */
+export declare class SubprocessTerminator {
+    /**
+     * Whether the hooks are installed
+     */
+    private static _initialized;
+    /**
+     * The list of registered child processes.  Processes are removed from this set if they
+     * terminate on their own.
+     */
+    private static _subprocessesByPid;
+    private static readonly _isWindows;
+    /**
+     * The recommended options when creating a child process.
+     */
+    static readonly RECOMMENDED_OPTIONS: ISubprocessOptions;
+    /**
+     * Registers a child process so that it will be terminated automatically if the current process
+     * is terminated.
+     */
+    static killProcessTreeOnExit(subprocess: child_process.ChildProcess, subprocessOptions: ISubprocessOptions): void;
+    /**
+     * Terminate the child process and all of its children.
+     */
+    static killProcessTree(subprocess: child_process.ChildProcess, subprocessOptions: ISubprocessOptions): void;
+    private static _ensureInitialized;
+    private static _cleanupChildProcesses;
+    private static _validateSubprocessOptions;
+    private static _onExit;
+    private static _onTerminateSignal;
+    private static _logDebug;
+}
+//# sourceMappingURL=SubprocessTerminator.d.ts.map

package/node_modules/@rushstack/node-core-library/lib/SubprocessTerminator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubprocessTerminator.d.ts","sourceRoot":"","sources":["../src/SubprocessTerminator.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,KAAK,aAAa,MAAM,eAAe,CAAC;AAKpD;;;;GAIG;AACH,MAAM,WAAW,kBAAkB;IACjC;;;;;;;;;OASG;IACH,QAAQ,EAAE,OAAO,CAAC;CACnB;AAOD;;;;;;;;;;;;GAYG;AACH,qBAAa,oBAAoB;IAC/B;;OAEG;IACH,OAAO,CAAC,MAAM,CAAC,YAAY,CAAkB;IAE7C;;;OAGG;IACH,OAAO,CAAC,MAAM,CAAC,kBAAkB,CAA8C;IAE/E,OAAO,CAAC,MAAM,CAAC,QAAQ,CAAC,UAAU,CAAyC;IAE3E;;OAEG;IACH,gBAAuB,mBAAmB,EAAE,kBAAkB,CAE5D;IAEF;;;OAGG;WACW,qBAAqB,CACjC,UAAU,EAAE,aAAa,CAAC,YAAY,EACtC,iBAAiB,EAAE,kBAAkB,GACpC,IAAI;IA8BP;;OAEG;WACW,eAAe,CAC3B,UAAU,EAAE,aAAa,CAAC,YAAY,EACtC,iBAAiB,EAAE,kBAAkB,GACpC,IAAI;IAmDP,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAcjC,OAAO,CAAC,MAAM,CAAC,sBAAsB;IAuCrC,OAAO,CAAC,MAAM,CAAC,0BAA0B;IASzC,OAAO,CAAC,MAAM,CAAC,OAAO;IAQtB,OAAO,CAAC,MAAM,CAAC,kBAAkB;IAajC,OAAO,CAAC,MAAM,CAAC,SAAS;CAKzB"}

package/node_modules/@rushstack/node-core-library/lib/SubprocessTerminator.js

@@ -0,0 +1,190 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SubprocessTerminator = void 0;
+const process_1 = __importDefault(require("process"));
+const Executable_1 = require("./Executable");
+/**
+ * When a child process is created, registering it with the SubprocessTerminator will ensure
+ * that the child gets terminated when the current process terminates.
+ *
+ * @remarks
+ * This works by hooking the current process's events for SIGTERM/SIGINT/exit, and ensuring the
+ * child process gets terminated in those cases.
+ *
+ * SubprocessTerminator doesn't do anything on Windows, since by default Windows automatically
+ * terminates child processes when their parent is terminated.
+ *
+ * @beta
+ */
+class SubprocessTerminator {
+    /**
+     * Registers a child process so that it will be terminated automatically if the current process
+     * is terminated.
+     */
+    static killProcessTreeOnExit(subprocess, subprocessOptions) {
+        if (typeof subprocess.exitCode === 'number') {
+            // Process has already been killed
+            return;
+        }
+        SubprocessTerminator._validateSubprocessOptions(subprocessOptions);
+        SubprocessTerminator._ensureInitialized();
+        // Closure variable
+        const pid = subprocess.pid;
+        if (pid === undefined) {
+            // The process failed to spawn.
+            return;
+        }
+        subprocess.on('close', (exitCode, signal) => {
+            if (SubprocessTerminator._subprocessesByPid.delete(pid)) {
+                SubprocessTerminator._logDebug(`untracking #${pid}`);
+            }
+        });
+        SubprocessTerminator._subprocessesByPid.set(pid, {
+            subprocess,
+            subprocessOptions
+        });
+        SubprocessTerminator._logDebug(`tracking #${pid}`);
+    }
+    /**
+     * Terminate the child process and all of its children.
+     */
+    static killProcessTree(subprocess, subprocessOptions) {
+        const pid = subprocess.pid;
+        if (pid === undefined) {
+            // The process failed to spawn.
+            return;
+        }
+        // Don't attempt to kill the same process twice
+        if (SubprocessTerminator._subprocessesByPid.delete(pid)) {
+            SubprocessTerminator._logDebug(`untracking #${pid} via killProcessTree()`);
+        }
+        SubprocessTerminator._validateSubprocessOptions(subprocessOptions);
+        if (typeof subprocess.exitCode === 'number') {
+            // Process has already been killed
+            return;
+        }
+        SubprocessTerminator._logDebug(`terminating #${pid}`);
+        if (SubprocessTerminator._isWindows) {
+            // On Windows we have a problem that CMD.exe launches child processes, but when CMD.exe is killed
+            // the child processes may continue running.  Also if we send signals to CMD.exe the child processes
+            // will not receive them.  The safest solution is not to attempt a graceful shutdown, but simply
+            // kill the entire process tree.
+            const result = Executable_1.Executable.spawnSync('TaskKill.exe', [
+                '/T', // "Terminates the specified process and any child processes which were started by it."
+                '/F', // Without this, TaskKill will try to use WM_CLOSE which doesn't work with CLI tools
+                '/PID',
+                pid.toString()
+            ]);
+            if (result.status) {
+                const output = result.output.join('\n');
+                // Nonzero exit code
+                if (output.indexOf('not found') >= 0) {
+                    // The PID does not exist
+                }
+                else {
+                    // Another error occurred, for example TaskKill.exe does not support
+                    // the expected CLI syntax
+                    throw new Error(`TaskKill.exe returned exit code ${result.status}:\n` + output + '\n');
+                }
+            }
+        }
+        else {
+            // Passing a negative PID terminates the entire group instead of just the one process
+            process_1.default.kill(-pid, 'SIGKILL');
+        }
+    }
+    // Install the hooks
+    static _ensureInitialized() {
+        if (!SubprocessTerminator._initialized) {
+            SubprocessTerminator._initialized = true;
+            SubprocessTerminator._logDebug('initialize');
+            process_1.default.prependListener('SIGTERM', SubprocessTerminator._onTerminateSignal);
+            process_1.default.prependListener('SIGINT', SubprocessTerminator._onTerminateSignal);
+            process_1.default.prependListener('exit', SubprocessTerminator._onExit);
+        }
+    }
+    // Uninstall the hooks and perform cleanup
+    static _cleanupChildProcesses() {
+        if (SubprocessTerminator._initialized) {
+            SubprocessTerminator._initialized = false;
+            process_1.default.removeListener('SIGTERM', SubprocessTerminator._onTerminateSignal);
+            process_1.default.removeListener('SIGINT', SubprocessTerminator._onTerminateSignal);
+            const trackedSubprocesses = Array.from(SubprocessTerminator._subprocessesByPid.values());
+            let firstError = undefined;
+            for (const trackedSubprocess of trackedSubprocesses) {
+                try {
+                    SubprocessTerminator.killProcessTree(trackedSubprocess.subprocess, { detached: true });
+                }
+                catch (error) {
+                    if (firstError === undefined) {
+                        firstError = error;
+                    }
+                }
+            }
+            if (firstError !== undefined) {
+                // This is generally an unexpected error such as the TaskKill.exe command not being found,
+                // not a trivial issue such as a nonexistent PID.   Since this occurs during process shutdown,
+                // we should not interfere with control flow by throwing an exception  or calling process.exit().
+                // So simply write to STDERR and ensure our exit code indicates the problem.
+                // eslint-disable-next-line no-console
+                console.error('\nAn unexpected error was encountered while attempting to clean up child processes:');
+                // eslint-disable-next-line no-console
+                console.error(firstError.toString());
+                if (!process_1.default.exitCode) {
+                    process_1.default.exitCode = 1;
+                }
+            }
+        }
+    }
+    static _validateSubprocessOptions(subprocessOptions) {
+        if (!SubprocessTerminator._isWindows) {
+            if (!subprocessOptions.detached) {
+                // Setting detached=true is what creates the process group that we use to kill the children
+                throw new Error('killProcessTree() requires detached=true on this operating system');
+            }
+        }
+    }
+    static _onExit(exitCode) {
+        SubprocessTerminator._logDebug(`received exit(${exitCode})`);
+        SubprocessTerminator._cleanupChildProcesses();
+        SubprocessTerminator._logDebug(`finished exit()`);
+    }
+    static _onTerminateSignal(signal) {
+        SubprocessTerminator._logDebug(`received signal ${signal}`);
+        SubprocessTerminator._cleanupChildProcesses();
+        // When a listener is added to SIGTERM, Node.js strangely provides no way to reference
+        // the original handler.  But we can invoke it by removing our listener and then resending
+        // the signal to our own process.
+        SubprocessTerminator._logDebug(`relaying ${signal}`);
+        process_1.default.kill(process_1.default.pid, signal);
+    }
+    // For debugging
+    static _logDebug(message) {
+        //const logLine: string = `SubprocessTerminator: [${process.pid}] ${message}`;
+        // fs.writeFileSync('trace.log', logLine + '\n', { flag: 'a' });
+        //console.log(logLine);
+    }
+}
+exports.SubprocessTerminator = SubprocessTerminator;
+/**
+ * Whether the hooks are installed
+ */
+SubprocessTerminator._initialized = false;
+/**
+ * The list of registered child processes.  Processes are removed from this set if they
+ * terminate on their own.
+ */
+SubprocessTerminator._subprocessesByPid = new Map();
+SubprocessTerminator._isWindows = process_1.default.platform === 'win32';
+/**
+ * The recommended options when creating a child process.
+ */
+SubprocessTerminator.RECOMMENDED_OPTIONS = {
+    detached: process_1.default.platform !== 'win32'
+};
+//# sourceMappingURL=SubprocessTerminator.js.map