@wo658/redpact 0.3.0 → 0.5.0

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

@@ -0,0 +1,462 @@
+"use strict";
+// Copyright (c) Microsoft Corporation. All rights reserved. Licensed under the MIT license.
+// See LICENSE in the project root for license information.
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LockFile = void 0;
+exports.getProcessStartTimeFromProcStat = getProcessStartTimeFromProcStat;
+exports.getProcessStartTime = getProcessStartTime;
+const path = __importStar(require("path"));
+const child_process = __importStar(require("child_process"));
+const FileSystem_1 = require("./FileSystem");
+const FileWriter_1 = require("./FileWriter");
+const Async_1 = require("./Async");
+/**
+ * http://man7.org/linux/man-pages/man5/proc.5.html
+ * (22) starttime  %llu
+ * The time the process started after system boot. In kernels before Linux 2.6, this value was
+ * expressed in jiffies. Since Linux 2.6, the value is expressed in clock ticks (divide by
+ * sysconf(_SC_CLK_TCK)).
+ * The format for this field was %lu before Linux 2.6.
+ */
+const procStatStartTimePos = 22;
+/**
+ * Parses the process start time from the contents of a linux /proc/[pid]/stat file.
+ * @param stat - The contents of a linux /proc/[pid]/stat file.
+ * @returns The process start time in jiffies, or undefined if stat has an unexpected format.
+ */
+function getProcessStartTimeFromProcStat(stat) {
+    // Parse the value at position procStatStartTimePos.
+    // We cannot just split stat on spaces, because value 2 may contain spaces.
+    // For example, when running the following Shell commands:
+    // > cp "$(which bash)" ./'bash 2)('
+    // > ./'bash 2)(' -c 'OWNPID=$BASHPID;cat /proc/$OWNPID/stat'
+    // 59389 (bash 2)() S 59358 59389 59358 34818 59389 4202496 329 0 0 0 0 0 0 0 20 0 1 0
+    // > rm -rf ./'bash 2)('
+    // The output shows a stat file such that value 2 contains spaces.
+    // To still umambiguously parse such output we assume no values after the second ends with a right parenthesis...
+    // trimRight to remove the trailing line terminator.
+    let values = stat.trimRight().split(' ');
+    let i = values.length - 1;
+    while (i >= 0 &&
+        // charAt returns an empty string if the index is out of bounds.
+        values[i].charAt(values[i].length - 1) !== ')') {
+        i -= 1;
+    }
+    // i is the index of the last part of the second value (but i need not be 1).
+    if (i < 1) {
+        // Format of stat has changed.
+        return undefined;
+    }
+    const value2 = values.slice(1, i + 1).join(' ');
+    values = [values[0], value2].concat(values.slice(i + 1));
+    if (values.length < procStatStartTimePos) {
+        // Older version of linux, or non-standard configuration of linux.
+        return undefined;
+    }
+    const startTimeJiffies = values[procStatStartTimePos - 1];
+    // In theory, the representations of start time returned by `cat /proc/[pid]/stat` and `ps -o lstart` can change
+    // while the system is running, but we assume this does not happen.
+    // So the caller can safely use this value as part of a unique process id (on the machine, without comparing
+    // across reboots).
+    return startTimeJiffies;
+}
+/**
+ * Helper function that is exported for unit tests only.
+ * Returns undefined if the process doesn't exist with that pid.
+ */
+function getProcessStartTime(pid) {
+    const pidString = pid.toString();
+    if (pid < 0 || pidString.indexOf('e') >= 0 || pidString.indexOf('E') >= 0) {
+        throw new Error(`"pid" is negative or too large`);
+    }
+    let args;
+    if (process.platform === 'darwin') {
+        args = [`-p ${pidString}`, '-o lstart'];
+    }
+    else if (process.platform === 'linux') {
+        args = ['-p', pidString, '-o', 'lstart'];
+    }
+    else {
+        throw new Error(`Unsupported system: ${process.platform}`);
+    }
+    const psResult = child_process.spawnSync('ps', args, {
+        encoding: 'utf8'
+    });
+    const psStdout = psResult.stdout;
+    // If no process with PID pid exists then the exit code is non-zero on linux but stdout is not empty.
+    // But if no process exists we do not want to fall back on /proc/*/stat to determine the process
+    // start time, so we we additionally test for !psStdout. NOTE: !psStdout evaluates to true if
+    // zero bytes are written to stdout.
+    if (psResult.status !== 0 && !psStdout && process.platform === 'linux') {
+        // Try to read /proc/[pid]/stat and get the value at position procStatStartTimePos.
+        let stat;
+        try {
+            stat = FileSystem_1.FileSystem.readFile(`/proc/${pidString}/stat`);
+        }
+        catch (error) {
+            if (error.code !== 'ENOENT') {
+                throw error;
+            }
+            // Either no process with PID pid exists, or this version/configuration of linux is non-standard.
+            // We assume the former.
+            return undefined;
+        }
+        if (stat !== undefined) {
+            const startTimeJiffies = getProcessStartTimeFromProcStat(stat);
+            if (startTimeJiffies === undefined) {
+                throw new Error(`Could not retrieve the start time of process ${pidString} from the OS because the ` +
+                    `contents of /proc/${pidString}/stat have an unexpected format`);
+            }
+            return startTimeJiffies;
+        }
+    }
+    // there was an error executing ps (zero bytes were written to stdout).
+    if (!psStdout) {
+        throw new Error(`Unexpected output from "ps" command`);
+    }
+    const psSplit = psStdout.split('\n');
+    // successfully able to run "ps", but no process was found
+    if (psSplit[1] === '') {
+        return undefined;
+    }
+    if (psSplit[1]) {
+        const trimmed = psSplit[1].trim();
+        if (trimmed.length > 10) {
+            return trimmed;
+        }
+    }
+    throw new Error(`Unexpected output from the "ps" command`);
+}
+// A set of locks that currently exist in the current process, to be used when
+// multiple locks are acquired in the same process.
+const IN_PROC_LOCKS = new Set();
+/**
+ * The `LockFile` implements a file-based mutex for synchronizing access to a shared resource
+ * between multiple Node.js processes.  It is not recommended for synchronization solely within
+ * a single Node.js process.
+ * @remarks
+ * The implementation works on Windows, Mac, and Linux without requiring any native helpers.
+ * On non-Windows systems, the algorithm requires access to the `ps` shell command.  On Linux,
+ * it requires access the `/proc/${pidString}/stat` filesystem.
+ * @public
+ */
+class LockFile {
+    constructor(fileWriter, filePath, dirtyWhenAcquired) {
+        this._fileWriter = fileWriter;
+        this._filePath = filePath;
+        this._dirtyWhenAcquired = dirtyWhenAcquired;
+        IN_PROC_LOCKS.add(filePath);
+    }
+    /**
+     * Returns the path of the lockfile that will be created when a lock is successfully acquired.
+     * @param resourceFolder - The folder where the lock file will be created
+     * @param resourceName - An alphanumeric name that describes the resource being locked.  This will become
+     *   the filename of the temporary file created to manage the lock.
+     * @param pid - The PID for the current Node.js process (`process.pid`), which is used by the locking algorithm.
+     */
+    static getLockFilePath(resourceFolder, resourceName, pid = process.pid) {
+        if (!resourceName.match(/^[a-zA-Z0-9][a-zA-Z0-9-.]+[a-zA-Z0-9]$/)) {
+            throw new Error(`The resource name "${resourceName}" is invalid.` +
+                ` It must be an alphanumeric string with only "-" or "." It must start and end with an alphanumeric character.`);
+        }
+        switch (process.platform) {
+            case 'win32': {
+                return path.resolve(resourceFolder, `${resourceName}.lock`);
+            }
+            case 'linux':
+            case 'darwin': {
+                return path.resolve(resourceFolder, `${resourceName}#${pid}.lock`);
+            }
+            default: {
+                throw new Error(`File locking not implemented for platform: "${process.platform}"`);
+            }
+        }
+    }
+    /**
+     * Attempts to create a lockfile with the given filePath.
+     * @param resourceFolder - The folder where the lock file will be created
+     * @param resourceName - An alphanumeric name that describes the resource being locked.  This will become
+     *   the filename of the temporary file created to manage the lock.
+     * @returns If successful, returns a `LockFile` instance.  If unable to get a lock, returns `undefined`.
+     */
+    static tryAcquire(resourceFolder, resourceName) {
+        FileSystem_1.FileSystem.ensureFolder(resourceFolder);
+        const lockFilePath = LockFile.getLockFilePath(resourceFolder, resourceName);
+        return LockFile._tryAcquireInner(resourceFolder, resourceName, lockFilePath);
+    }
+    /**
+     * @deprecated Use {@link LockFile.acquireAsync} instead.
+     */
+    static acquire(resourceFolder, resourceName, maxWaitMs) {
+        return LockFile.acquireAsync(resourceFolder, resourceName, maxWaitMs);
+    }
+    /**
+     * Attempts to create the lockfile.  Will continue to loop at every 100ms until the lock becomes available
+     * or the maxWaitMs is surpassed.
+     *
+     * @remarks
+     * This function is subject to starvation, whereby it does not ensure that the process that has been
+     * waiting the longest to acquire the lock will get it first. This means that a process could theoretically
+     * wait for the lock forever, while other processes skipped it in line and acquired the lock first.
+     *
+     * @param resourceFolder - The folder where the lock file will be created
+     * @param resourceName - An alphanumeric name that describes the resource being locked.  This will become
+     *   the filename of the temporary file created to manage the lock.
+     * @param maxWaitMs - The maximum number of milliseconds to wait for the lock before reporting an error
+     */
+    static async acquireAsync(resourceFolder, resourceName, maxWaitMs) {
+        const interval = 100;
+        const startTime = Date.now();
+        const timeoutTime = maxWaitMs ? startTime + maxWaitMs : undefined;
+        await FileSystem_1.FileSystem.ensureFolderAsync(resourceFolder);
+        const lockFilePath = LockFile.getLockFilePath(resourceFolder, resourceName);
+        // eslint-disable-next-line no-unmodified-loop-condition
+        while (!timeoutTime || Date.now() <= timeoutTime) {
+            const lock = LockFile._tryAcquireInner(resourceFolder, resourceName, lockFilePath);
+            if (lock) {
+                return lock;
+            }
+            await Async_1.Async.sleepAsync(interval);
+        }
+        throw new Error(`Exceeded maximum wait time to acquire lock for resource "${resourceName}"`);
+    }
+    static _tryAcquireInner(resourceFolder, resourceName, lockFilePath) {
+        if (!IN_PROC_LOCKS.has(lockFilePath)) {
+            switch (process.platform) {
+                case 'win32': {
+                    return LockFile._tryAcquireWindows(lockFilePath);
+                }
+                case 'linux':
+                case 'darwin': {
+                    return LockFile._tryAcquireMacOrLinux(resourceFolder, resourceName, lockFilePath);
+                }
+                default: {
+                    throw new Error(`File locking not implemented for platform: "${process.platform}"`);
+                }
+            }
+        }
+    }
+    /**
+     * Attempts to acquire the lock on a Linux or OSX machine
+     */
+    static _tryAcquireMacOrLinux(resourceFolder, resourceName, pidLockFilePath) {
+        let dirtyWhenAcquired = false;
+        // get the current process' pid
+        const pid = process.pid;
+        const startTime = LockFile._getStartTime(pid);
+        if (!startTime) {
+            throw new Error(`Unable to calculate start time for current process.`);
+        }
+        let lockFileHandle;
+        let lockFile;
+        try {
+            // open in write mode since if this file exists, it cannot be from the current process
+            // TODO: This will malfunction if the same process tries to acquire two locks on the same file.
+            // We should ideally maintain a dictionary of normalized acquired filenames
+            lockFileHandle = FileWriter_1.FileWriter.open(pidLockFilePath);
+            lockFileHandle.write(startTime);
+            const currentBirthTimeMs = lockFileHandle.getStatistics().birthtime.getTime();
+            let smallestBirthTimeMs = currentBirthTimeMs;
+            let smallestBirthTimePid = pid.toString();
+            // now, scan the directory for all lockfiles
+            const files = FileSystem_1.FileSystem.readFolderItemNames(resourceFolder);
+            // look for anything ending with # then numbers and ".lock"
+            const lockFileRegExp = /^(.+)#([0-9]+)\.lock$/;
+            let match;
+            let otherPid;
+            for (const fileInFolder of files) {
+                if ((match = fileInFolder.match(lockFileRegExp)) &&
+                    match[1] === resourceName &&
+                    (otherPid = match[2]) !== pid.toString()) {
+                    // we found at least one lockfile hanging around that isn't ours
+                    const fileInFolderPath = `${resourceFolder}/${fileInFolder}`;
+                    dirtyWhenAcquired = true;
+                    // console.log(`FOUND OTHER LOCKFILE: ${otherPid}`);
+                    const otherPidCurrentStartTime = LockFile._getStartTime(parseInt(otherPid, 10));
+                    let otherPidOldStartTime;
+                    let otherBirthtimeMs;
+                    try {
+                        otherPidOldStartTime = FileSystem_1.FileSystem.readFile(fileInFolderPath);
+                        // check the timestamp of the file
+                        otherBirthtimeMs = FileSystem_1.FileSystem.getStatistics(fileInFolderPath).birthtime.getTime();
+                    }
+                    catch (error) {
+                        if (FileSystem_1.FileSystem.isNotExistError(error)) {
+                            // the file is already deleted by other process, skip it
+                            continue;
+                        }
+                    }
+                    // if the otherPidOldStartTime is invalid, then we should look at the timestamp,
+                    // if this file was created after us, ignore it
+                    // if it was created within 1 second before us, then it could be good, so we
+                    //  will conservatively fail
+                    // otherwise it is an old lock file and will be deleted
+                    if (otherPidOldStartTime === '' && otherBirthtimeMs !== undefined) {
+                        if (otherBirthtimeMs > currentBirthTimeMs) {
+                            // ignore this file, he will be unable to get the lock since this process
+                            // will hold it
+                            // console.log(`Ignoring lock for pid ${otherPid} because its lockfile is newer than ours.`);
+                            continue;
+                        }
+                        else if (otherBirthtimeMs - currentBirthTimeMs < 0 && // it was created before us AND
+                            otherBirthtimeMs - currentBirthTimeMs > -1000) {
+                            // it was created less than a second before
+                            // conservatively be unable to keep the lock
+                            return undefined;
+                        }
+                    }
+                    // console.log(`Other pid ${otherPid} lockfile has start time: "${otherPidOldStartTime}"`);
+                    // console.log(`Other pid ${otherPid} actually has start time: "${otherPidCurrentStartTime}"`);
+                    // this means the process is no longer executing, delete the file
+                    if (!otherPidCurrentStartTime || otherPidOldStartTime !== otherPidCurrentStartTime) {
+                        // console.log(`Other pid ${otherPid} is no longer executing!`);
+                        FileSystem_1.FileSystem.deleteFile(fileInFolderPath);
+                        continue;
+                    }
+                    // console.log(`Pid ${otherPid} lockfile has birth time: ${otherBirthtimeMs}`);
+                    // console.log(`Pid ${pid} lockfile has birth time: ${currentBirthTimeMs}`);
+                    // this is a lockfile pointing at something valid
+                    if (otherBirthtimeMs !== undefined) {
+                        // the other lock file was created before the current earliest lock file
+                        // or the other lock file was created at the same exact time, but has earlier pid
+                        // note that it is acceptable to do a direct comparison of the PIDs in this case
+                        // since we are establishing a consistent order to apply to the lock files in all
+                        // execution instances.
+                        // it doesn't matter that the PIDs roll over, we've already
+                        // established that these processes all started at the same time, so we just
+                        // need to get all instances of the lock test to agree which one won.
+                        if (otherBirthtimeMs < smallestBirthTimeMs ||
+                            (otherBirthtimeMs === smallestBirthTimeMs && otherPid < smallestBirthTimePid)) {
+                            smallestBirthTimeMs = otherBirthtimeMs;
+                            smallestBirthTimePid = otherPid;
+                        }
+                    }
+                }
+            }
+            if (smallestBirthTimePid !== pid.toString()) {
+                // we do not have the lock
+                return undefined;
+            }
+            // we have the lock!
+            lockFile = new LockFile(lockFileHandle, pidLockFilePath, dirtyWhenAcquired);
+            lockFileHandle = undefined; // we have handed the descriptor off to the instance
+        }
+        finally {
+            if (lockFileHandle) {
+                // ensure our lock is closed
+                lockFileHandle.close();
+                FileSystem_1.FileSystem.deleteFile(pidLockFilePath);
+            }
+        }
+        return lockFile;
+    }
+    /**
+     * Attempts to acquire the lock using Windows
+     * This algorithm is much simpler since we can rely on the operating system
+     */
+    static _tryAcquireWindows(lockFilePath) {
+        let dirtyWhenAcquired = false;
+        let fileHandle;
+        let lockFile;
+        try {
+            if (FileSystem_1.FileSystem.exists(lockFilePath)) {
+                dirtyWhenAcquired = true;
+                // If the lockfile is held by an process with an exclusive lock, then removing it will
+                // silently fail. OpenSync() below will then fail and we will be unable to create a lock.
+                // Otherwise, the lockfile is sitting on disk, but nothing is holding it, implying that
+                // the last process to hold it died.
+                FileSystem_1.FileSystem.deleteFile(lockFilePath);
+            }
+            try {
+                // Attempt to open an exclusive lockfile
+                fileHandle = FileWriter_1.FileWriter.open(lockFilePath, { exclusive: true });
+            }
+            catch (error) {
+                // we tried to delete the lock, but something else is holding it,
+                // (probably an active process), therefore we are unable to create a lock
+                return undefined;
+            }
+            // Ensure we can hand off the file descriptor to the lockfile
+            lockFile = new LockFile(fileHandle, lockFilePath, dirtyWhenAcquired);
+            fileHandle = undefined;
+        }
+        finally {
+            if (fileHandle) {
+                fileHandle.close();
+            }
+        }
+        return lockFile;
+    }
+    /**
+     * Unlocks a file and optionally removes it from disk.
+     * This can only be called once.
+     *
+     * @param deleteFile - Whether to delete the lockfile from disk. Defaults to true.
+     */
+    release(deleteFile = true) {
+        if (this.isReleased) {
+            throw new Error(`The lock for file "${path.basename(this._filePath)}" has already been released.`);
+        }
+        IN_PROC_LOCKS.delete(this._filePath);
+        this._fileWriter.close();
+        if (deleteFile) {
+            FileSystem_1.FileSystem.deleteFile(this._filePath);
+        }
+        this._fileWriter = undefined;
+    }
+    /**
+     * Returns the initial state of the lock.
+     * This can be used to detect if the previous process was terminated before releasing the resource.
+     */
+    get dirtyWhenAcquired() {
+        return this._dirtyWhenAcquired;
+    }
+    /**
+     * Returns the absolute path to the lockfile
+     */
+    get filePath() {
+        return this._filePath;
+    }
+    /**
+     * Returns true if this lock is currently being held.
+     */
+    get isReleased() {
+        return this._fileWriter === undefined;
+    }
+}
+exports.LockFile = LockFile;
+LockFile._getStartTime = getProcessStartTime;
+//# sourceMappingURL=LockFile.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LockFile.js","sourceRoot":"","sources":["../src/LockFile.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\nimport * as path from 'path';\nimport * as child_process from 'child_process';\nimport { FileSystem } from './FileSystem';\nimport { FileWriter } from './FileWriter';\nimport { Async } from './Async';\n\n/**\n * http://man7.org/linux/man-pages/man5/proc.5.html\n * (22) starttime  %llu\n * The time the process started after system boot. In kernels before Linux 2.6, this value was\n * expressed in jiffies. Since Linux 2.6, the value is expressed in clock ticks (divide by\n * sysconf(_SC_CLK_TCK)).\n * The format for this field was %lu before Linux 2.6.\n */\nconst procStatStartTimePos: number = 22;\n\n/**\n * Parses the process start time from the contents of a linux /proc/[pid]/stat file.\n * @param stat - The contents of a linux /proc/[pid]/stat file.\n * @returns The process start time in jiffies, or undefined if stat has an unexpected format.\n */\nexport function getProcessStartTimeFromProcStat(stat: string): string | undefined {\n  // Parse the value at position procStatStartTimePos.\n  // We cannot just split stat on spaces, because value 2 may contain spaces.\n  // For example, when running the following Shell commands:\n  // > cp \"$(which bash)\" ./'bash 2)('\n  // > ./'bash 2)(' -c 'OWNPID=$BASHPID;cat /proc/$OWNPID/stat'\n  // 59389 (bash 2)() S 59358 59389 59358 34818 59389 4202496 329 0 0 0 0 0 0 0 20 0 1 0\n  // > rm -rf ./'bash 2)('\n  // The output shows a stat file such that value 2 contains spaces.\n  // To still umambiguously parse such output we assume no values after the second ends with a right parenthesis...\n\n  // trimRight to remove the trailing line terminator.\n  let values: string[] = stat.trimRight().split(' ');\n  let i: number = values.length - 1;\n  while (\n    i >= 0 &&\n    // charAt returns an empty string if the index is out of bounds.\n    values[i].charAt(values[i].length - 1) !== ')'\n  ) {\n    i -= 1;\n  }\n  // i is the index of the last part of the second value (but i need not be 1).\n  if (i < 1) {\n    // Format of stat has changed.\n    return undefined;\n  }\n  const value2: string = values.slice(1, i + 1).join(' ');\n  values = [values[0], value2].concat(values.slice(i + 1));\n  if (values.length < procStatStartTimePos) {\n    // Older version of linux, or non-standard configuration of linux.\n    return undefined;\n  }\n  const startTimeJiffies: string = values[procStatStartTimePos - 1];\n  // In theory, the representations of start time returned by `cat /proc/[pid]/stat` and `ps -o lstart` can change\n  // while the system is running, but we assume this does not happen.\n  // So the caller can safely use this value as part of a unique process id (on the machine, without comparing\n  // across reboots).\n  return startTimeJiffies;\n}\n\n/**\n * Helper function that is exported for unit tests only.\n * Returns undefined if the process doesn't exist with that pid.\n */\nexport function getProcessStartTime(pid: number): string | undefined {\n  const pidString: string = pid.toString();\n  if (pid < 0 || pidString.indexOf('e') >= 0 || pidString.indexOf('E') >= 0) {\n    throw new Error(`\"pid\" is negative or too large`);\n  }\n  let args: string[];\n  if (process.platform === 'darwin') {\n    args = [`-p ${pidString}`, '-o lstart'];\n  } else if (process.platform === 'linux') {\n    args = ['-p', pidString, '-o', 'lstart'];\n  } else {\n    throw new Error(`Unsupported system: ${process.platform}`);\n  }\n\n  const psResult: child_process.SpawnSyncReturns<string> = child_process.spawnSync('ps', args, {\n    encoding: 'utf8'\n  });\n  const psStdout: string = psResult.stdout;\n\n  // If no process with PID pid exists then the exit code is non-zero on linux but stdout is not empty.\n  // But if no process exists we do not want to fall back on /proc/*/stat to determine the process\n  // start time, so we we additionally test for !psStdout. NOTE: !psStdout evaluates to true if\n  // zero bytes are written to stdout.\n  if (psResult.status !== 0 && !psStdout && process.platform === 'linux') {\n    // Try to read /proc/[pid]/stat and get the value at position procStatStartTimePos.\n    let stat: undefined | string;\n    try {\n      stat = FileSystem.readFile(`/proc/${pidString}/stat`);\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') {\n        throw error;\n      }\n      // Either no process with PID pid exists, or this version/configuration of linux is non-standard.\n      // We assume the former.\n      return undefined;\n    }\n    if (stat !== undefined) {\n      const startTimeJiffies: string | undefined = getProcessStartTimeFromProcStat(stat);\n      if (startTimeJiffies === undefined) {\n        throw new Error(\n          `Could not retrieve the start time of process ${pidString} from the OS because the ` +\n            `contents of /proc/${pidString}/stat have an unexpected format`\n        );\n      }\n      return startTimeJiffies;\n    }\n  }\n\n  // there was an error executing ps (zero bytes were written to stdout).\n  if (!psStdout) {\n    throw new Error(`Unexpected output from \"ps\" command`);\n  }\n\n  const psSplit: string[] = psStdout.split('\\n');\n\n  // successfully able to run \"ps\", but no process was found\n  if (psSplit[1] === '') {\n    return undefined;\n  }\n\n  if (psSplit[1]) {\n    const trimmed: string = psSplit[1].trim();\n    if (trimmed.length > 10) {\n      return trimmed;\n    }\n  }\n\n  throw new Error(`Unexpected output from the \"ps\" command`);\n}\n\n// A set of locks that currently exist in the current process, to be used when\n// multiple locks are acquired in the same process.\nconst IN_PROC_LOCKS: Set<string> = new Set<string>();\n\n/**\n * The `LockFile` implements a file-based mutex for synchronizing access to a shared resource\n * between multiple Node.js processes.  It is not recommended for synchronization solely within\n * a single Node.js process.\n * @remarks\n * The implementation works on Windows, Mac, and Linux without requiring any native helpers.\n * On non-Windows systems, the algorithm requires access to the `ps` shell command.  On Linux,\n * it requires access the `/proc/${pidString}/stat` filesystem.\n * @public\n */\nexport class LockFile {\n  private static _getStartTime: (pid: number) => string | undefined = getProcessStartTime;\n\n  private _fileWriter: FileWriter | undefined;\n  private _filePath: string;\n  private _dirtyWhenAcquired: boolean;\n\n  private constructor(fileWriter: FileWriter | undefined, filePath: string, dirtyWhenAcquired: boolean) {\n    this._fileWriter = fileWriter;\n    this._filePath = filePath;\n    this._dirtyWhenAcquired = dirtyWhenAcquired;\n\n    IN_PROC_LOCKS.add(filePath);\n  }\n\n  /**\n   * Returns the path of the lockfile that will be created when a lock is successfully acquired.\n   * @param resourceFolder - The folder where the lock file will be created\n   * @param resourceName - An alphanumeric name that describes the resource being locked.  This will become\n   *   the filename of the temporary file created to manage the lock.\n   * @param pid - The PID for the current Node.js process (`process.pid`), which is used by the locking algorithm.\n   */\n  public static getLockFilePath(\n    resourceFolder: string,\n    resourceName: string,\n    pid: number = process.pid\n  ): string {\n    if (!resourceName.match(/^[a-zA-Z0-9][a-zA-Z0-9-.]+[a-zA-Z0-9]$/)) {\n      throw new Error(\n        `The resource name \"${resourceName}\" is invalid.` +\n          ` It must be an alphanumeric string with only \"-\" or \".\" It must start and end with an alphanumeric character.`\n      );\n    }\n\n    switch (process.platform) {\n      case 'win32': {\n        return path.resolve(resourceFolder, `${resourceName}.lock`);\n      }\n\n      case 'linux':\n      case 'darwin': {\n        return path.resolve(resourceFolder, `${resourceName}#${pid}.lock`);\n      }\n\n      default: {\n        throw new Error(`File locking not implemented for platform: \"${process.platform}\"`);\n      }\n    }\n  }\n\n  /**\n   * Attempts to create a lockfile with the given filePath.\n   * @param resourceFolder - The folder where the lock file will be created\n   * @param resourceName - An alphanumeric name that describes the resource being locked.  This will become\n   *   the filename of the temporary file created to manage the lock.\n   * @returns If successful, returns a `LockFile` instance.  If unable to get a lock, returns `undefined`.\n   */\n  public static tryAcquire(resourceFolder: string, resourceName: string): LockFile | undefined {\n    FileSystem.ensureFolder(resourceFolder);\n    const lockFilePath: string = LockFile.getLockFilePath(resourceFolder, resourceName);\n    return LockFile._tryAcquireInner(resourceFolder, resourceName, lockFilePath);\n  }\n\n  /**\n   * @deprecated Use {@link LockFile.acquireAsync} instead.\n   */\n  public static acquire(resourceFolder: string, resourceName: string, maxWaitMs?: number): Promise<LockFile> {\n    return LockFile.acquireAsync(resourceFolder, resourceName, maxWaitMs);\n  }\n\n  /**\n   * Attempts to create the lockfile.  Will continue to loop at every 100ms until the lock becomes available\n   * or the maxWaitMs is surpassed.\n   *\n   * @remarks\n   * This function is subject to starvation, whereby it does not ensure that the process that has been\n   * waiting the longest to acquire the lock will get it first. This means that a process could theoretically\n   * wait for the lock forever, while other processes skipped it in line and acquired the lock first.\n   *\n   * @param resourceFolder - The folder where the lock file will be created\n   * @param resourceName - An alphanumeric name that describes the resource being locked.  This will become\n   *   the filename of the temporary file created to manage the lock.\n   * @param maxWaitMs - The maximum number of milliseconds to wait for the lock before reporting an error\n   */\n  public static async acquireAsync(\n    resourceFolder: string,\n    resourceName: string,\n    maxWaitMs?: number\n  ): Promise<LockFile> {\n    const interval: number = 100;\n    const startTime: number = Date.now();\n    const timeoutTime: number | undefined = maxWaitMs ? startTime + maxWaitMs : undefined;\n\n    await FileSystem.ensureFolderAsync(resourceFolder);\n\n    const lockFilePath: string = LockFile.getLockFilePath(resourceFolder, resourceName);\n\n    // eslint-disable-next-line no-unmodified-loop-condition\n    while (!timeoutTime || Date.now() <= timeoutTime) {\n      const lock: LockFile | undefined = LockFile._tryAcquireInner(\n        resourceFolder,\n        resourceName,\n        lockFilePath\n      );\n      if (lock) {\n        return lock;\n      }\n\n      await Async.sleepAsync(interval);\n    }\n\n    throw new Error(`Exceeded maximum wait time to acquire lock for resource \"${resourceName}\"`);\n  }\n\n  private static _tryAcquireInner(\n    resourceFolder: string,\n    resourceName: string,\n    lockFilePath: string\n  ): LockFile | undefined {\n    if (!IN_PROC_LOCKS.has(lockFilePath)) {\n      switch (process.platform) {\n        case 'win32': {\n          return LockFile._tryAcquireWindows(lockFilePath);\n        }\n\n        case 'linux':\n        case 'darwin': {\n          return LockFile._tryAcquireMacOrLinux(resourceFolder, resourceName, lockFilePath);\n        }\n\n        default: {\n          throw new Error(`File locking not implemented for platform: \"${process.platform}\"`);\n        }\n      }\n    }\n  }\n\n  /**\n   * Attempts to acquire the lock on a Linux or OSX machine\n   */\n  private static _tryAcquireMacOrLinux(\n    resourceFolder: string,\n    resourceName: string,\n    pidLockFilePath: string\n  ): LockFile | undefined {\n    let dirtyWhenAcquired: boolean = false;\n\n    // get the current process' pid\n    const pid: number = process.pid;\n    const startTime: string | undefined = LockFile._getStartTime(pid);\n\n    if (!startTime) {\n      throw new Error(`Unable to calculate start time for current process.`);\n    }\n\n    let lockFileHandle: FileWriter | undefined;\n\n    let lockFile: LockFile;\n\n    try {\n      // open in write mode since if this file exists, it cannot be from the current process\n      // TODO: This will malfunction if the same process tries to acquire two locks on the same file.\n      // We should ideally maintain a dictionary of normalized acquired filenames\n      lockFileHandle = FileWriter.open(pidLockFilePath);\n      lockFileHandle.write(startTime);\n      const currentBirthTimeMs: number = lockFileHandle.getStatistics().birthtime.getTime();\n\n      let smallestBirthTimeMs: number = currentBirthTimeMs;\n      let smallestBirthTimePid: string = pid.toString();\n\n      // now, scan the directory for all lockfiles\n      const files: string[] = FileSystem.readFolderItemNames(resourceFolder);\n\n      // look for anything ending with # then numbers and \".lock\"\n      const lockFileRegExp: RegExp = /^(.+)#([0-9]+)\\.lock$/;\n\n      let match: RegExpMatchArray | null;\n      let otherPid: string;\n      for (const fileInFolder of files) {\n        if (\n          (match = fileInFolder.match(lockFileRegExp)) &&\n          match[1] === resourceName &&\n          (otherPid = match[2]) !== pid.toString()\n        ) {\n          // we found at least one lockfile hanging around that isn't ours\n          const fileInFolderPath: string = `${resourceFolder}/${fileInFolder}`;\n          dirtyWhenAcquired = true;\n\n          // console.log(`FOUND OTHER LOCKFILE: ${otherPid}`);\n\n          const otherPidCurrentStartTime: string | undefined = LockFile._getStartTime(parseInt(otherPid, 10));\n\n          let otherPidOldStartTime: string | undefined;\n          let otherBirthtimeMs: number | undefined;\n          try {\n            otherPidOldStartTime = FileSystem.readFile(fileInFolderPath);\n            // check the timestamp of the file\n            otherBirthtimeMs = FileSystem.getStatistics(fileInFolderPath).birthtime.getTime();\n          } catch (error) {\n            if (FileSystem.isNotExistError(error)) {\n              // the file is already deleted by other process, skip it\n              continue;\n            }\n          }\n\n          // if the otherPidOldStartTime is invalid, then we should look at the timestamp,\n          // if this file was created after us, ignore it\n          // if it was created within 1 second before us, then it could be good, so we\n          //  will conservatively fail\n          // otherwise it is an old lock file and will be deleted\n          if (otherPidOldStartTime === '' && otherBirthtimeMs !== undefined) {\n            if (otherBirthtimeMs > currentBirthTimeMs) {\n              // ignore this file, he will be unable to get the lock since this process\n              // will hold it\n              // console.log(`Ignoring lock for pid ${otherPid} because its lockfile is newer than ours.`);\n              continue;\n            } else if (\n              otherBirthtimeMs - currentBirthTimeMs < 0 && // it was created before us AND\n              otherBirthtimeMs - currentBirthTimeMs > -1000\n            ) {\n              // it was created less than a second before\n\n              // conservatively be unable to keep the lock\n              return undefined;\n            }\n          }\n\n          // console.log(`Other pid ${otherPid} lockfile has start time: \"${otherPidOldStartTime}\"`);\n          // console.log(`Other pid ${otherPid} actually has start time: \"${otherPidCurrentStartTime}\"`);\n\n          // this means the process is no longer executing, delete the file\n          if (!otherPidCurrentStartTime || otherPidOldStartTime !== otherPidCurrentStartTime) {\n            // console.log(`Other pid ${otherPid} is no longer executing!`);\n            FileSystem.deleteFile(fileInFolderPath);\n            continue;\n          }\n\n          // console.log(`Pid ${otherPid} lockfile has birth time: ${otherBirthtimeMs}`);\n          // console.log(`Pid ${pid} lockfile has birth time: ${currentBirthTimeMs}`);\n          // this is a lockfile pointing at something valid\n          if (otherBirthtimeMs !== undefined) {\n            // the other lock file was created before the current earliest lock file\n            // or the other lock file was created at the same exact time, but has earlier pid\n\n            // note that it is acceptable to do a direct comparison of the PIDs in this case\n            // since we are establishing a consistent order to apply to the lock files in all\n            // execution instances.\n\n            // it doesn't matter that the PIDs roll over, we've already\n            // established that these processes all started at the same time, so we just\n            // need to get all instances of the lock test to agree which one won.\n            if (\n              otherBirthtimeMs < smallestBirthTimeMs ||\n              (otherBirthtimeMs === smallestBirthTimeMs && otherPid < smallestBirthTimePid)\n            ) {\n              smallestBirthTimeMs = otherBirthtimeMs;\n              smallestBirthTimePid = otherPid;\n            }\n          }\n        }\n      }\n\n      if (smallestBirthTimePid !== pid.toString()) {\n        // we do not have the lock\n        return undefined;\n      }\n\n      // we have the lock!\n      lockFile = new LockFile(lockFileHandle, pidLockFilePath, dirtyWhenAcquired);\n      lockFileHandle = undefined; // we have handed the descriptor off to the instance\n    } finally {\n      if (lockFileHandle) {\n        // ensure our lock is closed\n        lockFileHandle.close();\n        FileSystem.deleteFile(pidLockFilePath);\n      }\n    }\n    return lockFile;\n  }\n\n  /**\n   * Attempts to acquire the lock using Windows\n   * This algorithm is much simpler since we can rely on the operating system\n   */\n  private static _tryAcquireWindows(lockFilePath: string): LockFile | undefined {\n    let dirtyWhenAcquired: boolean = false;\n\n    let fileHandle: FileWriter | undefined;\n    let lockFile: LockFile;\n\n    try {\n      if (FileSystem.exists(lockFilePath)) {\n        dirtyWhenAcquired = true;\n\n        // If the lockfile is held by an process with an exclusive lock, then removing it will\n        // silently fail. OpenSync() below will then fail and we will be unable to create a lock.\n\n        // Otherwise, the lockfile is sitting on disk, but nothing is holding it, implying that\n        // the last process to hold it died.\n        FileSystem.deleteFile(lockFilePath);\n      }\n\n      try {\n        // Attempt to open an exclusive lockfile\n        fileHandle = FileWriter.open(lockFilePath, { exclusive: true });\n      } catch (error) {\n        // we tried to delete the lock, but something else is holding it,\n        // (probably an active process), therefore we are unable to create a lock\n        return undefined;\n      }\n\n      // Ensure we can hand off the file descriptor to the lockfile\n      lockFile = new LockFile(fileHandle, lockFilePath, dirtyWhenAcquired);\n      fileHandle = undefined;\n    } finally {\n      if (fileHandle) {\n        fileHandle.close();\n      }\n    }\n\n    return lockFile;\n  }\n\n  /**\n   * Unlocks a file and optionally removes it from disk.\n   * This can only be called once.\n   *\n   * @param deleteFile - Whether to delete the lockfile from disk. Defaults to true.\n   */\n  public release(deleteFile: boolean = true): void {\n    if (this.isReleased) {\n      throw new Error(`The lock for file \"${path.basename(this._filePath)}\" has already been released.`);\n    }\n\n    IN_PROC_LOCKS.delete(this._filePath);\n\n    this._fileWriter!.close();\n    if (deleteFile) {\n      FileSystem.deleteFile(this._filePath);\n    }\n\n    this._fileWriter = undefined;\n  }\n\n  /**\n   * Returns the initial state of the lock.\n   * This can be used to detect if the previous process was terminated before releasing the resource.\n   */\n  public get dirtyWhenAcquired(): boolean {\n    return this._dirtyWhenAcquired;\n  }\n\n  /**\n   * Returns the absolute path to the lockfile\n   */\n  public get filePath(): string {\n    return this._filePath;\n  }\n\n  /**\n   * Returns true if this lock is currently being held.\n   */\n  public get isReleased(): boolean {\n    return this._fileWriter === undefined;\n  }\n}\n"]}

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

@@ -0,0 +1,26 @@
+/**
+ * Helper functions for working with the `Map<K, V>` data type.
+ *
+ * @public
+ */
+export declare class MapExtensions {
+    /**
+     * Adds all the (key, value) pairs from the source map into the target map.
+     * @remarks
+     * This function modifies targetMap.  Any existing keys will be overwritten.
+     * @param targetMap - The map that entries will be added to
+     * @param sourceMap - The map containing the entries to be added
+     */
+    static mergeFromMap<K, V>(targetMap: Map<K, V>, sourceMap: ReadonlyMap<K, V>): void;
+    /**
+     * Converts a string-keyed map to an object.
+     * @remarks
+     * This function has the same effect as Object.fromEntries(map.entries())
+     * in supported versions of Node (\>= 12.0.0).
+     * @param map - The map that the object properties will be sourced from
+     */
+    static toObject<TValue>(map: Map<string, TValue>): {
+        [key: string]: TValue;
+    };
+}
+//# sourceMappingURL=MapExtensions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MapExtensions.d.ts","sourceRoot":"","sources":["../src/MapExtensions.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,qBAAa,aAAa;IACxB;;;;;;OAMG;WACW,YAAY,CAAC,CAAC,EAAE,CAAC,EAAE,SAAS,EAAE,GAAG,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,SAAS,EAAE,WAAW,CAAC,CAAC,EAAE,CAAC,CAAC,GAAG,IAAI;IAM1F;;;;;;OAMG;WACW,QAAQ,CAAC,MAAM,EAAE,GAAG,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG;QAAE,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM,CAAA;KAAE;CAOpF"}

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

@@ -0,0 +1,40 @@
+"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.MapExtensions = void 0;
+/**
+ * Helper functions for working with the `Map<K, V>` data type.
+ *
+ * @public
+ */
+class MapExtensions {
+    /**
+     * Adds all the (key, value) pairs from the source map into the target map.
+     * @remarks
+     * This function modifies targetMap.  Any existing keys will be overwritten.
+     * @param targetMap - The map that entries will be added to
+     * @param sourceMap - The map containing the entries to be added
+     */
+    static mergeFromMap(targetMap, sourceMap) {
+        for (const pair of sourceMap.entries()) {
+            targetMap.set(pair[0], pair[1]);
+        }
+    }
+    /**
+     * Converts a string-keyed map to an object.
+     * @remarks
+     * This function has the same effect as Object.fromEntries(map.entries())
+     * in supported versions of Node (\>= 12.0.0).
+     * @param map - The map that the object properties will be sourced from
+     */
+    static toObject(map) {
+        const object = {};
+        for (const [key, value] of map.entries()) {
+            object[key] = value;
+        }
+        return object;
+    }
+}
+exports.MapExtensions = MapExtensions;
+//# sourceMappingURL=MapExtensions.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MapExtensions.js","sourceRoot":"","sources":["../src/MapExtensions.ts"],"names":[],"mappings":";AAAA,4FAA4F;AAC5F,2DAA2D;;;AAE3D;;;;GAIG;AACH,MAAa,aAAa;IACxB;;;;;;OAMG;IACI,MAAM,CAAC,YAAY,CAAO,SAAoB,EAAE,SAA4B;QACjF,KAAK,MAAM,IAAI,IAAI,SAAS,CAAC,OAAO,EAAE,EAAE,CAAC;YACvC,SAAS,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAC,CAAC,CAAC,CAAC;QAClC,CAAC;IACH,CAAC;IAED;;;;;;OAMG;IACI,MAAM,CAAC,QAAQ,CAAS,GAAwB;QACrD,MAAM,MAAM,GAA8B,EAAE,CAAC;QAC7C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,GAAG,CAAC,OAAO,EAAE,EAAE,CAAC;YACzC,MAAM,CAAC,GAAG,CAAC,GAAG,KAAK,CAAC;QACtB,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;CACF;AA5BD,sCA4BC","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 * Helper functions for working with the `Map<K, V>` data type.\n *\n * @public\n */\nexport class MapExtensions {\n  /**\n   * Adds all the (key, value) pairs from the source map into the target map.\n   * @remarks\n   * This function modifies targetMap.  Any existing keys will be overwritten.\n   * @param targetMap - The map that entries will be added to\n   * @param sourceMap - The map containing the entries to be added\n   */\n  public static mergeFromMap<K, V>(targetMap: Map<K, V>, sourceMap: ReadonlyMap<K, V>): void {\n    for (const pair of sourceMap.entries()) {\n      targetMap.set(pair[0], pair[1]);\n    }\n  }\n\n  /**\n   * Converts a string-keyed map to an object.\n   * @remarks\n   * This function has the same effect as Object.fromEntries(map.entries())\n   * in supported versions of Node (\\>= 12.0.0).\n   * @param map - The map that the object properties will be sourced from\n   */\n  public static toObject<TValue>(map: Map<string, TValue>): { [key: string]: TValue } {\n    const object: { [key: string]: TValue } = {};\n    for (const [key, value] of map.entries()) {\n      object[key] = value;\n    }\n    return object;\n  }\n}\n"]}

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

@@ -0,0 +1,39 @@
+/**
+ * Implements a standard heap data structure for items of type T and a custom comparator.
+ * The root will always be the minimum value as determined by the comparator.
+ *
+ * @public
+ */
+export declare class MinimumHeap<T> {
+    private readonly _items;
+    private readonly _comparator;
+    /**
+     * Constructs a new MinimumHeap instance.
+     * @param comparator - a comparator function that determines the order of the items in the heap.
+     *   If the comparator returns a value less than zero, then `a` will be considered less than `b`.
+     *   If the comparator returns zero, then `a` and `b` are considered equal.
+     *   Otherwise, `a` will be considered greater than `b`.
+     */
+    constructor(comparator: (a: T, b: T) => number);
+    /**
+     * Returns the number of items in the heap.
+     * @returns the number of items in the heap.
+     */
+    get size(): number;
+    /**
+     * Retrieves the root item from the heap without removing it.
+     * @returns the root item, or `undefined` if the heap is empty
+     */
+    peek(): T | undefined;
+    /**
+     * Retrieves and removes the root item from the heap. The next smallest item will become the new root.
+     * @returns the root item, or `undefined` if the heap is empty
+     */
+    poll(): T | undefined;
+    /**
+     * Pushes an item into the heap.
+     * @param item - the item to push
+     */
+    push(item: T): void;
+}
+//# sourceMappingURL=MinimumHeap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"MinimumHeap.d.ts","sourceRoot":"","sources":["../src/MinimumHeap.ts"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,qBAAa,WAAW,CAAC,CAAC;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAW;IAClC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAyB;IAErD;;;;;;OAMG;gBACgB,UAAU,EAAE,CAAC,CAAC,EAAE,CAAC,EAAE,CAAC,EAAE,CAAC,KAAK,MAAM;IAIrD;;;OAGG;IACH,IAAW,IAAI,IAAI,MAAM,CAExB;IAED;;;OAGG;IACI,IAAI,IAAI,CAAC,GAAG,SAAS;IAI5B;;;OAGG;IACI,IAAI,IAAI,CAAC,GAAG,SAAS;IA4C5B;;;OAGG;IACI,IAAI,CAAC,IAAI,EAAE,CAAC,GAAG,IAAI;CAe3B"}