@mikeyt23/node-cli-utils 1.4.1 → 2.0.0-beta.1

package/dist/esm/generalUtils.js

@@ -0,0 +1,591 @@
+import { exec, spawnSync } from 'node:child_process';
+import fs from 'node:fs';
+import fsp from 'node:fs/promises';
+import { platform } from 'node:os';
+import path, { resolve } from 'node:path';
+import * as readline from 'readline';
+import { config } from './NodeCliUtilsConfig.js';
+import { copyEnv, dictionaryToEnvFileString, getEnvAsDictionary, spawnAsyncInternal } from './generalUtilsInternal.js';
+const dockerComposeCommandsThatSupportDetached = ['exec', 'logs', 'ps', 'restart', 'run', 'start', 'stop', 'up'];
+/**
+ * Just a wrapper for console.log() to type less.
+ * @param data The data to log
+ * @param moreData More data to log
+ */
+export function log(data, ...moreData) {
+    console.log(data, ...moreData);
+}
+/**
+ * Wrapper for console.log() that is suppressed if NodeCliUtilsConfig.logEnabled is false.
+ * @param data The data to log
+ * @param moreData More data to log
+ */
+export function trace(data, ...moreData) {
+    if (config.traceEnabled) {
+        const prefix = `[TRACE]`;
+        console.log(prefix, data, ...moreData);
+    }
+}
+/**
+ * Error throw by {@link spawnAsync} when the spawned process exits with a non-zero exit code and options.throwOnNonZero is true.
+ *
+ * Contains a {@link SpawnResult} with the exit code, stdout, stderr, and error (if any).
+ */
+export class SpawnError extends Error {
+    result;
+    constructor(message, result) {
+        super(message);
+        this.result = result;
+    }
+}
+/**
+ * Error throw by {@link simpleSpawnSync} and {@link simpleCmdSync} when the spawned process exits with a non-zero exit code and throwOnNonZero param is true (the default).
+ *
+ * Contains a {@link SimpleSpawnResult} with the exit code, stdout, stderr, and error (if any) in addition to stdoutLines, which is stdout split into lines from stdout that weren't empty.
+ */
+export class SimpleSpawnError extends Error {
+    result;
+    constructor(message, result) {
+        super(message);
+        this.result = result;
+    }
+}
+/**
+ * Sleeps for the specified number of milliseconds.
+ * @param ms The number of milliseconds to sleep
+ * @returns A Promise that resolves after the specified number of milliseconds
+ */
+export async function sleep(ms) {
+    return new Promise((resolve) => {
+        setTimeout(resolve, ms);
+    });
+}
+/**
+ * This is a wrapper function for NodeJS. Defaults stdio to inherit so that output is visible in the console,
+ * but note that this means stdout and stderr will not be available in the returned SpawnResult.
+ *
+ * When spawning long-running processes, use {@link spawnAsyncLongRunning} instead so that unexpected
+ * termination of the parent process will not orphan the child process tree on windows.
+ * @param command The command to spawn
+ * @param args The arguments to pass to the command
+ * @param options The options to pass to the command
+ * @returns A Promise that resolves to a {@link SpawnResult}
+ */
+export async function spawnAsync(command, args, options) {
+    return spawnAsyncInternal(command, args, options);
+}
+/**
+ * Use this alternate spawn wrapper instead of {@link spawnAsync} when spawning long-running processes to
+ * avoid orphaned child process trees on Windows.
+ * @param command The command to spawn
+ * @param args The arguments to pass to the command
+ * @param cwd The current working directory to run the command from - defaults to process.cwd()
+ * @returns A Promise that resolves to a {@link SpawnResult}
+ */
+export async function spawnAsyncLongRunning(command, args, cwd) {
+    return spawnAsyncInternal(command, args, { cwd: cwd, isLongRunning: true });
+}
+/**
+ * Ensure the directory exists. Similar to `mkdir -p` (creates parent directories if they don't exist).
+ * @param dir The directory to ensure exists. If it does not exist, it will be created.
+ */
+export async function ensureDirectory(dir) {
+    requireString('dir', dir);
+    if (!fs.existsSync(dir)) {
+        await mkdirp(dir);
+    }
+}
+/**
+ * Create a directory. Will create parent directory structure if it don't exist. Similar to `mkdir -p`.
+ * @param dir The directory to create.
+ */
+export async function mkdirp(dir) {
+    await fsp.mkdir(dir, { recursive: true });
+}
+/**
+ * Empties a directory of all files and subdirectories.
+ *
+ * Optionally skips files and directories at the top level.
+ * @param directoryToEmpty The directory to empty.
+ * @param fileAndDirectoryNamesToSkip An optional array of file and directory names to skip, but only at the top level of the directoryToEmpty.
+ */
+export async function emptyDirectory(directoryToEmpty, fileAndDirectoryNamesToSkip) {
+    requireString('directoryToEmpty', directoryToEmpty);
+    if (!fs.existsSync(directoryToEmpty)) {
+        trace(`directoryToEmpty does not exist - creating directory ${directoryToEmpty}`);
+        await mkdirp(directoryToEmpty);
+        return;
+    }
+    if (!fs.lstatSync(directoryToEmpty).isDirectory()) {
+        throw new Error(`directoryToEmpty is not a directory: ${directoryToEmpty}`);
+    }
+    // Add some guardrails to prevent accidentally emptying the wrong directory
+    const absolutePath = path.resolve(directoryToEmpty);
+    log(`emptying directory: ${absolutePath}`);
+    if (!absolutePath.startsWith(process.cwd())) {
+        throw new Error(`directoryToEmpty must be a child of the current working directory: ${directoryToEmpty}`);
+    }
+    if (absolutePath === process.cwd()) {
+        throw new Error(`directoryToEmpty cannot be the current working directory: ${directoryToEmpty}`);
+    }
+    const dir = await fsp.opendir(directoryToEmpty, { encoding: 'utf-8' });
+    if (fileAndDirectoryNamesToSkip && !Array.isArray(fileAndDirectoryNamesToSkip)) {
+        throw new Error('fileAndDirectoryNamesToSkip must be an array');
+    }
+    let dirEntry = await dir.read();
+    while (dirEntry) {
+        if (fileAndDirectoryNamesToSkip && fileAndDirectoryNamesToSkip.includes(dirEntry.name)) {
+            dirEntry = await dir.read();
+            continue;
+        }
+        const direntPath = path.join(directoryToEmpty, dirEntry.name);
+        if (dirEntry.isDirectory()) {
+            await fsp.rm(direntPath, { recursive: true });
+        }
+        else {
+            await fsp.unlink(direntPath);
+        }
+        dirEntry = await dir.read();
+    }
+    await dir.close();
+}
+/**
+ * Copies the contents of a directory to another directory (not including the top-level directory itself).
+ *
+ * If the destination directory does not exist, it will be created.
+ * @param sourceDirectory Directory to copy from
+ * @param destinationDirectory Directory to copy to
+ */
+export async function copyDirectoryContents(sourceDirectory, destinationDirectory) {
+    requireString('sourceDirectory', sourceDirectory);
+    requireString('destinationDirectory', destinationDirectory);
+    if (!fs.existsSync(sourceDirectory)) {
+        throw new Error(`sourceDirectory directory does not exist: ${sourceDirectory}`);
+    }
+    if (!fs.lstatSync(sourceDirectory).isDirectory()) {
+        throw new Error(`sourceDirectory is not a directory: ${sourceDirectory}`);
+    }
+    if (!fs.existsSync(destinationDirectory)) {
+        await mkdirp(destinationDirectory);
+    }
+    if (!fs.lstatSync(destinationDirectory).isDirectory()) {
+        throw new Error(`destinationDirectory is not a directory: ${destinationDirectory}`);
+    }
+    const dir = await fsp.opendir(sourceDirectory, { encoding: 'utf-8' });
+    let dirEntry = await dir.read();
+    while (dirEntry) {
+        const sourcePath = path.join(sourceDirectory, dirEntry.name);
+        const destPath = path.join(destinationDirectory, dirEntry.name);
+        if (dirEntry.isDirectory()) {
+            await copyDirectoryContents(sourcePath, destPath);
+        }
+        else {
+            await fsp.copyFile(sourcePath, destPath);
+        }
+        dirEntry = await dir.read();
+    }
+}
+/**
+ * Helper method to validate that a non-falsy value is provided for a parameter that should be a string.
+ *
+ * **Warning:** this does not validate the type of the parameter, just whether something non-empty was provided.
+ * @param paramName The name of the parameter, for logging purposes
+ * @param paramValue The value of the parameter
+ */
+export function requireString(paramName, paramValue) {
+    if (paramValue === undefined || paramValue === null || paramValue === '') {
+        throw new Error(`Required param '${paramName}' is missing`);
+    }
+    if (typeof paramValue !== 'string') {
+        throw new Error(`Required param '${paramName}' is not a string`);
+    }
+}
+/**
+ * Helper method to validate that the path actually exists for the provided value.
+ * @param paramName The name of the parameter, for logging purposes
+ * @param paramValue The value of the parameter
+ */
+export function requireValidPath(paramName, paramValue) {
+    requireString(paramName, paramValue);
+    if (!fs.existsSync(paramValue)) {
+        throw new Error(`Invalid or nonexistent path provided for param '${paramName}': ${paramValue}`);
+    }
+}
+/**
+ * For docker compose commands, see https://docs.docker.com/compose/reference/.
+ * @param dockerComposePath Path to docker-compose.yml
+ * @param dockerComposeCommand The docker-compose command to run
+ * @param options {@link DockerComposeOptions} to use, including additional arguments to pass to the docker compose command and the project name
+ */
+export async function spawnDockerCompose(dockerComposePath, dockerComposeCommand, options) {
+    requireValidPath('dockerComposePath', dockerComposePath);
+    requireString('dockerComposeCommand', dockerComposeCommand);
+    const useDockerComposeFileDirectoryAsCwd = options && options.useDockerComposeFileDirectoryAsCwd;
+    if (await isDockerRunning() === false) {
+        throw new Error('Docker is not running');
+    }
+    const defaultOptions = { attached: false };
+    const mergedOptions = { ...defaultOptions, ...options };
+    const dockerComposeDir = path.dirname(dockerComposePath);
+    const dockerComposeFilename = path.basename(dockerComposePath);
+    const spawnCommand = 'docker';
+    let spawnArgs = ['compose', '-f', useDockerComposeFileDirectoryAsCwd ? dockerComposeFilename : dockerComposePath];
+    if (mergedOptions.projectName) {
+        spawnArgs.push('--project-name', mergedOptions.projectName);
+    }
+    spawnArgs.push(dockerComposeCommand);
+    if (!mergedOptions.attached && dockerComposeCommandsThatSupportDetached.includes(dockerComposeCommand)) {
+        spawnArgs.push('-d');
+    }
+    if (mergedOptions.args) {
+        spawnArgs = spawnArgs.concat(mergedOptions.args);
+    }
+    const dockerCommandString = `docker ${spawnArgs.join(' ')}`;
+    const traceMessage = useDockerComposeFileDirectoryAsCwd ?
+        `running command in ${dockerComposeDir}: ${dockerCommandString}` :
+        `running command: ${dockerCommandString}`;
+    trace(traceMessage);
+    const longRunning = dockerComposeCommandsThatSupportDetached.includes(dockerComposeCommand) && options && options.attached;
+    const spawnOptions = {
+        cwd: useDockerComposeFileDirectoryAsCwd ? dockerComposeDir : process.cwd(),
+        shell: true,
+        isLongRunning: longRunning
+    };
+    const spawnResult = await spawnAsyncInternal(spawnCommand, spawnArgs, spawnOptions);
+    if (spawnResult.code !== 0) {
+        throw new Error(`docker compose command failed with code ${spawnResult.code}`);
+    }
+}
+/**
+ * Splits a string into lines, removing empty lines and carriage return characters.
+ * @param str String to split into lines
+ * @returns An array of lines from the string, with empty lines removed
+ */
+export function stringToNonEmptyLines(str) {
+    if (!str) {
+        return [];
+    }
+    return str.split('\n').filter(line => line && line.trim()).map(line => line.replace('\r', ''));
+}
+/**
+ * Runs the requested command using NodeJS spawnSync wrapped in an outer Windows CMD.exe command and returns the result with stdout split into lines.
+ *
+ * Use this for simple quick commands that don't require a lot of control.
+ *
+ * For commands that aren't Windows and CMD specific, use {@link simpleSpawnSync}.
+ * @param command Command to run
+ * @param args Arguments to pass to the command
+ * @returns An object with the status code, stdout, stderr, and error (if any)
+ * @throws {@link SimpleSpawnError} if the command fails and throwOnNonZero is true
+ */
+export function simpleCmdSync(command, args, throwOnNonZero = true) {
+    if (!isPlatformWindows()) {
+        throw new Error('getCmdResult is only supported on Windows');
+    }
+    return simpleSpawnSync('cmd', ['/D', '/S', '/C', command, ...(args ?? [])], throwOnNonZero);
+}
+/**
+ * Runs the requested command using NodeJS spawnSync and returns the result with stdout split into lines.
+ *
+ * Use this for simple quick commands that don't require a lot of control.
+ *
+ * For commands that are Windows and CMD specific, use {@link simpleCmdSync}.
+ * @param command Command to run
+ * @param args Arguments to pass to the command
+ * @returns An object with the status code, stdout, stderr, and error (if any)
+ * @throws {@link SimpleSpawnError} if the command fails and throwOnNonZero is true
+ */
+export function simpleSpawnSync(command, args, throwOnNonZero = true) {
+    requireString('command', command);
+    const result = spawnSync(command, args ?? [], { encoding: 'utf-8' });
+    const spawnResult = {
+        code: result.status ?? 1,
+        stdout: result.stdout.toString(),
+        stderr: result.stdout.toString(),
+        stdoutLines: stringToNonEmptyLines(result.stdout.toString()),
+        error: result.error,
+        cwd: process.cwd()
+    };
+    if (spawnResult.code !== 0 && throwOnNonZero) {
+        throw new SimpleSpawnError(`spawned process failed with code ${spawnResult.code}`, spawnResult);
+    }
+    return spawnResult;
+}
+/**
+ * @returns `true` if platform() is 'win32', `false` otherwise
+ */
+export function isPlatformWindows() {
+    return platform() === 'win32';
+}
+/**
+ *
+ * @returns `true` if platform() is 'darwin', `false` otherwise
+ */
+export function isPlatformMac() {
+    return platform() === 'darwin';
+}
+/**
+ *
+ * @returns `true` if {@link isPlatformWindows} and {@link isPlatformMac} are both `false, otherwise returns `false`
+ */
+export function isPlatformLinux() {
+    return !isPlatformWindows() && !isPlatformMac();
+}
+/**
+ * This is a cross-platform method to get the location of a system command. Useful for checking if software
+ * is installed, where it's installed and whether there are multiple locations for a command.
+ * @param commandName The name of the command to find
+ * @returns The location of the command, any additional locations, and an error if one occurred
+ */
+export function whichSync(commandName) {
+    if (isPlatformWindows()) {
+        const result = simpleCmdSync('where', [commandName]);
+        return {
+            location: result.stdoutLines[0],
+            additionalLocations: result.stdoutLines.slice(1),
+            error: result.error
+        };
+    }
+    else {
+        const result = simpleSpawnSync('which', ['-a', commandName]);
+        return {
+            location: result.stdoutLines[0],
+            additionalLocations: result.stdoutLines.slice(1),
+            error: result.error
+        };
+    }
+}
+/**
+ * First checks if docker is installed and if not immediately returns false.
+ *
+ * Then runs the `docker info` command and looks for "error during connect" in the output to determine if docker is running.
+ * @returns `true` if docker is installed and running, `false` otherwise
+ */
+export async function isDockerRunning() {
+    if (!whichSync('docker').location) {
+        trace('whichSync will not check if docker is running because docker does not appear to be installed - returning false');
+        return false;
+    }
+    return new Promise((resolve) => {
+        exec('docker info', (error, stdout) => {
+            if (error) {
+                resolve(false);
+            }
+            else {
+                if (!stdout || stdout.includes('error during connect')) {
+                    resolve(false);
+                }
+                else {
+                    resolve(true);
+                }
+            }
+        });
+    });
+}
+/**
+ * Uses built-in NodeJS readline to ask a question and return the user's answer.
+ * @param query The question to ask
+ * @returns A Promise that resolves to the user's answer
+ */
+export function askQuestion(query) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise(resolve => rl.question(`\n${query}\n`, ans => {
+        rl.close();
+        resolve(ans);
+    }));
+}
+/**
+ * A simple CLI prompt using the built-in NodeJS readline functionality to ask for confirmation.
+ * @param question The question to ask
+ * @returns A Promise that resolves to true if the user answers 'y' or 'yes', false otherwise
+ */
+export function getConfirmation(question) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`\n  ❓ ${question}\n  ➡️ Proceed? (yes/no): `, (answer) => {
+            rl.close();
+            const confirmed = answer.toLowerCase() === 'y' || answer.toLowerCase() === 'yes';
+            log(confirmed ? '  ✅ Proceeding\n' : '  ❌ Aborting\n');
+            resolve(confirmed);
+        });
+    });
+}
+/**
+ * Example of using {@link getConfirmation}.
+ */
+export async function getConfirmationExample() {
+    if (await getConfirmation('Do you even?')) {
+        log('you do even');
+    }
+    else {
+        log('you do not even');
+    }
+}
+/**
+ * Copy entries from a source .env file to a destination .env file for which the destination .env file does not already have entries.
+ * If the destination .env file does not exist, it will be created and populated with the source .env file's values.
+ *
+ * This is useful for copying values from a .env.template file to a root .env file.
+ *
+ * For copying root .env files to other locations, use {@link overwriteEnvFile}.
+ * @param sourcePath The path to the source .env file such as a `.env.template` file (use {@link overwriteEnvFile} for copying root .env files to other locations)
+ * @param destinationPath The path to the destination .env file, such as the root .env file
+ */
+export async function copyNewEnvValues(sourcePath, destinationPath) {
+    await copyEnv(sourcePath, destinationPath, false);
+}
+/**
+ * Copy entries from a source .env file to a destination .env file, overwriting any existing entries in the destination .env file.
+ * If the destination .env file does not exist, it will be created and populated with the source .env file's values.
+ *
+ * This is useful for copying values from a root .env file to additional locations (server, client, docker-compose directory, etc.)
+ * throughout your solution so you only have to manage one .env file.
+ *
+ * Note that this does not delete any existing entries in the destination .env file, which is useful if you have additional entries in
+ * the destination .env file that you don't want to overwrite.
+ *
+ * For copying .env.template files to root .env files, use {@link copyNewEnvValues}.
+ * @param sourcePath The path to the source .env file such as a root .env file (use {@link copyNewEnvValues} for .env.template files)
+ * @param destinationPath The path to the destination .env file
+ * @param suppressAddKeysMessages If true, messages about adding missing keys will not be logged (useful if you're always calling {@link copyModifiedEnv} after this call)
+ */
+export async function overwriteEnvFile(sourcePath, destinationPath, suppressAddKeysMessages = false) {
+    await copyEnv(sourcePath, destinationPath, true, suppressAddKeysMessages);
+}
+/**
+ * Copy entries from a source .env file to a destination .env file, but only for the keys specified in keepKeys.
+ * Will also modify entries in the destination .env file as specified in modifyEntries.
+ * @param sourcePath The path to the source .env file
+ * @param destinationPath The path to the destination .env file
+ * @param keepKeys The keys to keep from the source .env file
+ * @param modifyEntries The entries to modify in the destination .env file
+ */
+export async function copyModifiedEnv(sourcePath, destinationPath, keepKeys, modifyEntries) {
+    requireValidPath('sourcePath', sourcePath);
+    const destPathDir = path.dirname(destinationPath);
+    if (!fs.existsSync(destPathDir)) {
+        await ensureDirectory(destPathDir);
+    }
+    const sourceDict = getEnvAsDictionary(sourcePath);
+    const newDict = filterDictionary(sourceDict, key => keepKeys.includes(key));
+    if (modifyEntries && Object.keys(modifyEntries).length > 0) {
+        for (const [key, value] of Object.entries(modifyEntries)) {
+            newDict[key] = value;
+        }
+    }
+    const newSortedDict = sortDictionaryByKeyAsc(newDict);
+    const newEnvFileContent = dictionaryToEnvFileString(newSortedDict);
+    await fsp.writeFile(destinationPath, newEnvFileContent);
+}
+/**
+ * Filters a dictionary by key.
+ * @param dict The dictionary to filter
+ * @param predicate A function that returns true if the key should be included in the filtered dictionary
+ * @returns A new dictionary with only the keys that passed the predicate
+ */
+export function filterDictionary(dict, predicate) {
+    // Notes to self:
+    // - The second param of reduce is the initial value of the accumulator
+    // - Reduce processes each element of the array and returns the accumulator for the next iteration
+    // - In our case, the accumulator is a new dictionary that we're building up
+    return Object.keys(dict)
+        .filter(predicate)
+        .reduce((accumulator, key) => {
+        accumulator[key] = dict[key];
+        return accumulator;
+    }, {});
+}
+/**
+ * Sorts a dictionary by key in ascending order.
+ * @param dict The dictionary to sort
+ * @returns A new dictionary sorted by key in ascending order
+ */
+export function sortDictionaryByKeyAsc(dict) {
+    const newSortedDict = Object.entries(dict).sort((a, b) => {
+        if (a < b) {
+            return -1;
+        }
+        if (a > b) {
+            return 1;
+        }
+        return 0;
+    });
+    return Object.fromEntries(newSortedDict);
+}
+/**
+ * Helper method to delete a .env file if it exists.
+ * @param envPath The path to the .env file to delete
+ */
+export async function deleteEnvIfExists(envPath) {
+    // Just protecting ourselves from accidentally deleting something we didn't mean to
+    if (envPath.endsWith('.env') === false) {
+        throw new Error(`envPath must end with '.env': ${envPath}`);
+    }
+    // Using fsp.unlink will throw an error if it's a directory
+    if (fs.existsSync(envPath)) {
+        await fsp.unlink(envPath);
+    }
+}
+/**
+ * Searches a directory recursively for files that match the specified pattern.
+ * The filenamePattern is a simple text string with asterisks (*) for wildcards.
+ * @param dir The directory to find files in
+ * @param filenamePattern The pattern to match files against
+ * @param options Specify a max depth to search, defaults to 5
+ * @returns A Promise that resolves to an array of file paths that match the pattern
+ */
+export async function findFilesRecursively(dir, filenamePattern, options) {
+    requireValidPath('dir', dir);
+    requireString('pattern', filenamePattern);
+    if (filenamePattern.length > 50) {
+        throw new Error(`filenamePattern param must have fewer than 50 characters`);
+    }
+    const numWildcards = filenamePattern.replace(/\*+/g, '*').split('*').length - 1;
+    if (numWildcards > 5) {
+        throw new Error(`filenamePattern param must contain 5 or fewer wildcards`);
+    }
+    if (filenamePattern.includes('/') || filenamePattern.includes('\\')) {
+        throw new Error('filenamePattern param must not contain slashes');
+    }
+    const defaultOptions = { maxDepth: 5 };
+    const mergedOptions = { ...defaultOptions, ...options };
+    // Convert the pattern to a regex
+    const regex = new RegExp('^' + filenamePattern.split(/\*+/).map(escapeStringForRegex).join('.*') + '$');
+    const matches = [];
+    // Recursive function to search within directories
+    async function searchDirectory(directory, depth) {
+        if (depth > mergedOptions.maxDepth)
+            return;
+        const entries = await fsp.readdir(directory, { withFileTypes: true });
+        for (const entry of entries) {
+            const fullPath = resolve(directory, entry.name);
+            if (entry.isDirectory()) {
+                // Check if directory is in the exclude list
+                if (!mergedOptions.excludeDirectoryNames || !mergedOptions.excludeDirectoryNames.includes(entry.name)) {
+                    await searchDirectory(fullPath, depth + 1);
+                }
+            }
+            else if (entry.isFile() && regex.test(entry.name)) {
+                if (mergedOptions.returnForwardSlashRelativePaths) {
+                    matches.push(path.relative(dir, fullPath).replace(/\\/g, '/'));
+                }
+                else {
+                    matches.push(fullPath);
+                }
+            }
+        }
+    }
+    await searchDirectory(dir, 1); // Start search from the first depth
+    return matches;
+}
+/** Utility function to escape a string for use within regex */
+export function escapeStringForRegex(str) {
+    return str.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"generalUtils.js","sourceRoot":"","sources":["../../src/generalUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAgB,IAAI,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAA;AAClE,OAAO,EAAE,MAAM,SAAS,CAAA;AACxB,OAAO,GAAG,MAAM,kBAAkB,CAAA;AAClC,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAA;AAClC,OAAO,IAAI,EAAE,EAAE,OAAO,EAAE,MAAM,WAAW,CAAA;AACzC,OAAO,KAAK,QAAQ,MAAM,UAAU,CAAA;AACpC,OAAO,EAAE,MAAM,EAAE,MAAM,yBAAyB,CAAA;AAChD,OAAO,EAAwB,OAAO,EAAE,yBAAyB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAA;AAE5I,MAAM,wCAAwC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,SAAS,EAAE,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,CAAA;AAEhH;;;;GAIG;AACH,MAAM,UAAU,GAAG,CAAC,IAAa,EAAE,GAAG,QAAmB;IACvD,OAAO,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,QAAQ,CAAC,CAAA;AAChC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,KAAK,CAAC,IAAc,EAAE,GAAG,QAAmB;IAC1D,IAAI,MAAM,CAAC,YAAY,EAAE;QACvB,MAAM,MAAM,GAAG,SAAS,CAAA;QACxB,OAAO,CAAC,GAAG,CAAC,MAAM,EAAE,IAAI,EAAE,GAAG,QAAQ,CAAC,CAAA;KACvC;AACH,CAAC;AAiCD;;;;GAIG;AACH,MAAM,OAAO,UAAW,SAAQ,KAAK;IACnC,MAAM,CAAa;IAEnB,YAAY,OAAe,EAAE,MAAmB;QAC9C,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACtB,CAAC;CACF;AAWD;;;;GAIG;AACH,MAAM,OAAO,gBAAiB,SAAQ,KAAK;IACzC,MAAM,CAAmB;IAEzB,YAAY,OAAe,EAAE,MAAyB;QACpD,KAAK,CAAC,OAAO,CAAC,CAAA;QACd,IAAI,CAAC,MAAM,GAAG,MAAM,CAAA;IACtB,CAAC;CACF;AAgBD;;;;GAIG;AACH,MAAM,CAAC,KAAK,UAAU,KAAK,CAAC,EAAU;IACpC,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,UAAU,CAAC,OAAO,EAAE,EAAE,CAAC,CAAA;IACzB,CAAC,CAAC,CAAA;AACJ,CAAC;AAUD;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,UAAU,CAAC,OAAe,EAAE,IAAe,EAAE,OAA+B;IAChG,OAAO,kBAAkB,CAAC,OAAO,EAAE,IAAI,EAAE,OAAO,CAAC,CAAA;AACnD,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAC,OAAe,EAAE,IAAe,EAAE,GAAY;IACxF,OAAO,kBAAkB,CAAC,OAAO,EAAE,IAAI,EAAE,EAAE,GAAG,EAAE,GAAG,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAA;AAC7E,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,GAAW;IAC/C,aAAa,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;IACzB,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;QACvB,MAAM,MAAM,CAAC,GAAG,CAAC,CAAA;KAClB;AACH,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,MAAM,CAAC,GAAW;IACtC,MAAM,GAAG,CAAC,KAAK,CAAC,GAAG,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;AAC3C,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,cAAc,CAAC,gBAAwB,EAAE,2BAAsC;IACnG,aAAa,CAAC,kBAAkB,EAAE,gBAAgB,CAAC,CAAA;IAEnD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,gBAAgB,CAAC,EAAE;QACpC,KAAK,CAAC,wDAAwD,gBAAgB,EAAE,CAAC,CAAA;QACjF,MAAM,MAAM,CAAC,gBAAgB,CAAC,CAAA;QAC9B,OAAM;KACP;IAED,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,gBAAgB,CAAC,CAAC,WAAW,EAAE,EAAE;QACjD,MAAM,IAAI,KAAK,CAAC,wCAAwC,gBAAgB,EAAE,CAAC,CAAA;KAC5E;IAED,2EAA2E;IAC3E,MAAM,YAAY,GAAG,IAAI,CAAC,OAAO,CAAC,gBAAgB,CAAC,CAAA;IACnD,GAAG,CAAC,uBAAuB,YAAY,EAAE,CAAC,CAAA;IAC1C,IAAI,CAAC,YAAY,CAAC,UAAU,CAAC,OAAO,CAAC,GAAG,EAAE,CAAC,EAAE;QAC3C,MAAM,IAAI,KAAK,CAAC,sEAAsE,gBAAgB,EAAE,CAAC,CAAA;KAC1G;IAED,IAAI,YAAY,KAAK,OAAO,CAAC,GAAG,EAAE,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,6DAA6D,gBAAgB,EAAE,CAAC,CAAA;KACjG;IAED,MAAM,GAAG,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,gBAAgB,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAA;IAEtE,IAAI,2BAA2B,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,2BAA2B,CAAC,EAAE;QAC9E,MAAM,IAAI,KAAK,CAAC,8CAA8C,CAAC,CAAA;KAChE;IAED,IAAI,QAAQ,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAA;IAE/B,OAAO,QAAQ,EAAE;QACf,IAAI,2BAA2B,IAAI,2BAA2B,CAAC,QAAQ,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;YACtF,QAAQ,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAA;YAC3B,SAAQ;SACT;QAED,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,gBAAgB,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;QAE7D,IAAI,QAAQ,CAAC,WAAW,EAAE,EAAE;YAC1B,MAAM,GAAG,CAAC,EAAE,CAAC,UAAU,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAA;SAC9C;aAAM;YACL,MAAM,GAAG,CAAC,MAAM,CAAC,UAAU,CAAC,CAAA;SAC7B;QAED,QAAQ,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAA;KAC5B;IAED,MAAM,GAAG,CAAC,KAAK,EAAE,CAAA;AACnB,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,KAAK,UAAU,qBAAqB,CAAC,eAAuB,EAAE,oBAA4B;IAC/F,aAAa,CAAC,iBAAiB,EAAE,eAAe,CAAC,CAAA;IACjD,aAAa,CAAC,sBAAsB,EAAE,oBAAoB,CAAC,CAAA;IAE3D,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE;QACnC,MAAM,IAAI,KAAK,CAAC,6CAA6C,eAAe,EAAE,CAAC,CAAA;KAChF;IAED,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,eAAe,CAAC,CAAC,WAAW,EAAE,EAAE;QAChD,MAAM,IAAI,KAAK,CAAC,uCAAuC,eAAe,EAAE,CAAC,CAAA;KAC1E;IAED,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,oBAAoB,CAAC,EAAE;QACxC,MAAM,MAAM,CAAC,oBAAoB,CAAC,CAAA;KACnC;IAED,IAAI,CAAC,EAAE,CAAC,SAAS,CAAC,oBAAoB,CAAC,CAAC,WAAW,EAAE,EAAE;QACrD,MAAM,IAAI,KAAK,CAAC,4CAA4C,oBAAoB,EAAE,CAAC,CAAA;KACpF;IAED,MAAM,GAAG,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,eAAe,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAA;IAErE,IAAI,QAAQ,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAA;IAE/B,OAAO,QAAQ,EAAE;QACf,MAAM,UAAU,GAAG,IAAI,CAAC,IAAI,CAAC,eAAe,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;QAC5D,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,CAAC,oBAAoB,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;QAE/D,IAAI,QAAQ,CAAC,WAAW,EAAE,EAAE;YAC1B,MAAM,qBAAqB,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;SAClD;aAAM;YACL,MAAM,GAAG,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAA;SACzC;QAED,QAAQ,GAAG,MAAM,GAAG,CAAC,IAAI,EAAE,CAAA;KAC5B;AACH,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,aAAa,CAAC,SAAiB,EAAE,UAAkB;IACjE,IAAI,UAAU,KAAK,SAAS,IAAI,UAAU,KAAK,IAAI,IAAI,UAAU,KAAK,EAAE,EAAE;QACxE,MAAM,IAAI,KAAK,CAAC,mBAAmB,SAAS,cAAc,CAAC,CAAA;KAC5D;IACD,IAAI,OAAO,UAAU,KAAK,QAAQ,EAAE;QAClC,MAAM,IAAI,KAAK,CAAC,mBAAmB,SAAS,mBAAmB,CAAC,CAAA;KACjE;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,gBAAgB,CAAC,SAAiB,EAAE,UAAkB;IACpE,aAAa,CAAC,SAAS,EAAE,UAAU,CAAC,CAAA;IAEpC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE;QAC9B,MAAM,IAAI,KAAK,CAAC,mDAAmD,SAAS,MAAM,UAAU,EAAE,CAAC,CAAA;KAChG;AACH,CAAC;AAiBD;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,kBAAkB,CAAC,iBAAyB,EAAE,oBAA0C,EAAE,OAA8B;IAC5I,gBAAgB,CAAC,mBAAmB,EAAE,iBAAiB,CAAC,CAAA;IACxD,aAAa,CAAC,sBAAsB,EAAE,oBAAoB,CAAC,CAAA;IAE3D,MAAM,kCAAkC,GAAG,OAAO,IAAI,OAAO,CAAC,kCAAkC,CAAA;IAEhG,IAAI,MAAM,eAAe,EAAE,KAAK,KAAK,EAAE;QACrC,MAAM,IAAI,KAAK,CAAC,uBAAuB,CAAC,CAAA;KACzC;IAED,MAAM,cAAc,GAAyB,EAAE,QAAQ,EAAE,KAAK,EAAE,CAAA;IAChE,MAAM,aAAa,GAAG,EAAE,GAAG,cAAc,EAAE,GAAG,OAAO,EAAE,CAAA;IAEvD,MAAM,gBAAgB,GAAG,IAAI,CAAC,OAAO,CAAC,iBAAiB,CAAC,CAAA;IACxD,MAAM,qBAAqB,GAAG,IAAI,CAAC,QAAQ,CAAC,iBAAiB,CAAC,CAAA;IAE9D,MAAM,YAAY,GAAG,QAAQ,CAAA;IAC7B,IAAI,SAAS,GAAG,CAAC,SAAS,EAAE,IAAI,EAAE,kCAAkC,CAAC,CAAC,CAAC,qBAAqB,CAAC,CAAC,CAAC,iBAAiB,CAAC,CAAA;IAEjH,IAAI,aAAa,CAAC,WAAW,EAAE;QAC7B,SAAS,CAAC,IAAI,CAAC,gBAAgB,EAAE,aAAa,CAAC,WAAW,CAAC,CAAA;KAC5D;IAED,SAAS,CAAC,IAAI,CAAC,oBAAoB,CAAC,CAAA;IAEpC,IAAI,CAAC,aAAa,CAAC,QAAQ,IAAI,wCAAwC,CAAC,QAAQ,CAAC,oBAAoB,CAAC,EAAE;QACtG,SAAS,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;KACrB;IAED,IAAI,aAAa,CAAC,IAAI,EAAE;QACtB,SAAS,GAAG,SAAS,CAAC,MAAM,CAAC,aAAa,CAAC,IAAI,CAAC,CAAA;KACjD;IAED,MAAM,mBAAmB,GAAG,UAAU,SAAS,CAAC,IAAI,CAAC,GAAG,CAAC,EAAE,CAAA;IAC3D,MAAM,YAAY,GAAG,kCAAkC,CAAC,CAAC;QACvD,sBAAsB,gBAAgB,KAAK,mBAAmB,EAAE,CAAC,CAAC;QAClE,oBAAoB,mBAAmB,EAAE,CAAA;IAE3C,KAAK,CAAC,YAAY,CAAC,CAAA;IAEnB,MAAM,WAAW,GAAG,wCAAwC,CAAC,QAAQ,CAAC,oBAAoB,CAAC,IAAI,OAAO,IAAI,OAAO,CAAC,QAAQ,CAAA;IAE1H,MAAM,YAAY,GAAyB;QACzC,GAAG,EAAE,kCAAkC,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAC,CAAC,OAAO,CAAC,GAAG,EAAE;QAC1E,KAAK,EAAE,IAAI;QACX,aAAa,EAAE,WAAW;KAC3B,CAAA;IAED,MAAM,WAAW,GAAG,MAAM,kBAAkB,CAAC,YAAY,EAAE,SAAS,EAAE,YAAY,CAAC,CAAA;IAEnF,IAAI,WAAW,CAAC,IAAI,KAAK,CAAC,EAAE;QAC1B,MAAM,IAAI,KAAK,CAAC,2CAA2C,WAAW,CAAC,IAAI,EAAE,CAAC,CAAA;KAC/E;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,qBAAqB,CAAC,GAAW;IAC/C,IAAI,CAAC,GAAG,EAAE;QAAE,OAAO,EAAE,CAAA;KAAE;IACvB,OAAO,GAAG,CAAC,KAAK,CAAC,IAAI,CAAC,CAAC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,IAAI,IAAI,CAAC,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,CAAA;AAChG,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,aAAa,CAAC,OAAe,EAAE,IAAe,EAAE,iBAA0B,IAAI;IAC5F,IAAI,CAAC,iBAAiB,EAAE,EAAE;QACxB,MAAM,IAAI,KAAK,CAAC,2CAA2C,CAAC,CAAA;KAC7D;IACD,OAAO,eAAe,CAAC,KAAK,EAAE,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,GAAG,CAAC,IAAI,IAAI,EAAE,CAAC,CAAC,EAAE,cAAc,CAAC,CAAA;AAC7F,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,UAAU,eAAe,CAAC,OAAe,EAAE,IAAe,EAAE,iBAA0B,IAAI;IAC9F,aAAa,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,MAAM,MAAM,GAAG,SAAS,CAAC,OAAO,EAAE,IAAI,IAAI,EAAE,EAAE,EAAE,QAAQ,EAAE,OAAO,EAAE,CAAC,CAAA;IAEpE,MAAM,WAAW,GAAsB;QACrC,IAAI,EAAE,MAAM,CAAC,MAAM,IAAI,CAAC;QACxB,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE;QAChC,MAAM,EAAE,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE;QAChC,WAAW,EAAE,qBAAqB,CAAC,MAAM,CAAC,MAAM,CAAC,QAAQ,EAAE,CAAC;QAC5D,KAAK,EAAE,MAAM,CAAC,KAAK;QACnB,GAAG,EAAE,OAAO,CAAC,GAAG,EAAE;KACnB,CAAA;IAED,IAAI,WAAW,CAAC,IAAI,KAAK,CAAC,IAAI,cAAc,EAAE;QAC5C,MAAM,IAAI,gBAAgB,CAAC,oCAAoC,WAAW,CAAC,IAAI,EAAE,EAAE,WAAW,CAAC,CAAA;KAChG;IAED,OAAO,WAAW,CAAA;AACpB,CAAC;AAED;;GAEG;AACH,MAAM,UAAU,iBAAiB;IAC/B,OAAO,QAAQ,EAAE,KAAK,OAAO,CAAA;AAC/B,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,aAAa;IAC3B,OAAO,QAAQ,EAAE,KAAK,QAAQ,CAAA;AAChC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,eAAe;IAC7B,OAAO,CAAC,iBAAiB,EAAE,IAAI,CAAC,aAAa,EAAE,CAAA;AACjD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,SAAS,CAAC,WAAmB;IAC3C,IAAI,iBAAiB,EAAE,EAAE;QACvB,MAAM,MAAM,GAAG,aAAa,CAAC,OAAO,EAAE,CAAC,WAAW,CAAC,CAAC,CAAA;QACpD,OAAO;YACL,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;YAC/B,mBAAmB,EAAE,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;YAChD,KAAK,EAAE,MAAM,CAAC,KAAK;SACpB,CAAA;KACF;SAAM;QACL,MAAM,MAAM,GAAG,eAAe,CAAC,OAAO,EAAE,CAAC,IAAI,EAAE,WAAW,CAAC,CAAC,CAAA;QAC5D,OAAO;YACL,QAAQ,EAAE,MAAM,CAAC,WAAW,CAAC,CAAC,CAAC;YAC/B,mBAAmB,EAAE,MAAM,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC,CAAC;YAChD,KAAK,EAAE,MAAM,CAAC,KAAK;SACpB,CAAA;KACF;AACH,CAAC;AAED;;;;;GAKG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe;IACnC,IAAI,CAAC,SAAS,CAAC,QAAQ,CAAC,CAAC,QAAQ,EAAE;QACjC,KAAK,CAAC,gHAAgH,CAAC,CAAA;QACvH,OAAO,KAAK,CAAA;KACb;IACD,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,IAAI,CAAC,aAAa,EAAE,CAAC,KAAK,EAAE,MAAM,EAAE,EAAE;YACpC,IAAI,KAAK,EAAE;gBACT,OAAO,CAAC,KAAK,CAAC,CAAA;aACf;iBAAM;gBACL,IAAI,CAAC,MAAM,IAAI,MAAM,CAAC,QAAQ,CAAC,sBAAsB,CAAC,EAAE;oBACtD,OAAO,CAAC,KAAK,CAAC,CAAA;iBACf;qBAAM;oBACL,OAAO,CAAC,IAAI,CAAC,CAAA;iBACd;aACF;QACH,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,WAAW,CAAC,KAAa;IACvC,MAAM,EAAE,GAAG,QAAQ,CAAC,eAAe,CAAC;QAClC,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,MAAM,EAAE,OAAO,CAAC,MAAM;KACvB,CAAC,CAAA;IAEF,OAAO,IAAI,OAAO,CAAC,OAAO,CAAC,EAAE,CAC3B,EAAE,CAAC,QAAQ,CAAC,KAAK,KAAK,IAAI,EAAE,GAAG,CAAC,EAAE;QAChC,EAAE,CAAC,KAAK,EAAE,CAAA;QACV,OAAO,CAAC,GAAG,CAAC,CAAA;IACd,CAAC,CAAC,CACH,CAAA;AACH,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,QAAgB;IAC9C,MAAM,EAAE,GAAG,QAAQ,CAAC,eAAe,CAAC;QAClC,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,MAAM,EAAE,OAAO,CAAC,MAAM;KACvB,CAAC,CAAA;IAEF,OAAO,IAAI,OAAO,CAAC,CAAC,OAAO,EAAE,EAAE;QAC7B,EAAE,CAAC,QAAQ,CAAC,SAAS,QAAQ,4BAA4B,EAAE,CAAC,MAAM,EAAE,EAAE;YACpE,EAAE,CAAC,KAAK,EAAE,CAAA;YACV,MAAM,SAAS,GAAG,MAAM,CAAC,WAAW,EAAE,KAAK,GAAG,IAAI,MAAM,CAAC,WAAW,EAAE,KAAK,KAAK,CAAA;YAChF,GAAG,CAAC,SAAS,CAAC,CAAC,CAAC,kBAAkB,CAAC,CAAC,CAAC,gBAAgB,CAAC,CAAA;YACtD,OAAO,CAAC,SAAS,CAAC,CAAA;QACpB,CAAC,CAAC,CAAA;IACJ,CAAC,CAAC,CAAA;AACJ,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB;IAC1C,IAAI,MAAM,eAAe,CAAC,cAAc,CAAC,EAAE;QACzC,GAAG,CAAC,aAAa,CAAC,CAAA;KACnB;SAAM;QACL,GAAG,CAAC,iBAAiB,CAAC,CAAA;KACvB;AACH,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,UAAkB,EAAE,eAAuB;IAChF,MAAM,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,KAAK,CAAC,CAAA;AACnD,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,CAAC,KAAK,UAAU,gBAAgB,CAAC,UAAkB,EAAE,eAAuB,EAAE,uBAAuB,GAAG,KAAK;IACjH,MAAM,OAAO,CAAC,UAAU,EAAE,eAAe,EAAE,IAAI,EAAE,uBAAuB,CAAC,CAAA;AAC3E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,eAAe,CAAC,UAAkB,EAAE,eAAuB,EAAE,QAAkB,EAAE,aAAqC;IAC1I,gBAAgB,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;IAC1C,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAA;IACjD,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,WAAW,CAAC,EAAE;QAC/B,MAAM,eAAe,CAAC,WAAW,CAAC,CAAA;KACnC;IAED,MAAM,UAAU,GAAG,kBAAkB,CAAC,UAAU,CAAC,CAAA;IACjD,MAAM,OAAO,GAA0B,gBAAgB,CAAC,UAAU,EAAE,GAAG,CAAC,EAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,GAAG,CAAC,CAAC,CAAA;IAElG,IAAI,aAAa,IAAI,MAAM,CAAC,IAAI,CAAC,aAAa,CAAC,CAAC,MAAM,GAAG,CAAC,EAAE;QAC1D,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,aAAa,CAAC,EAAE;YACxD,OAAO,CAAC,GAAG,CAAC,GAAG,KAAK,CAAA;SACrB;KACF;IAED,MAAM,aAAa,GAAG,sBAAsB,CAAC,OAAO,CAAC,CAAA;IACrD,MAAM,iBAAiB,GAAG,yBAAyB,CAAC,aAAa,CAAC,CAAA;IAClE,MAAM,GAAG,CAAC,SAAS,CAAC,eAAe,EAAE,iBAAiB,CAAC,CAAA;AACzD,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,gBAAgB,CAAC,IAA2B,EAAE,SAAmC;IAC/F,iBAAiB;IACjB,uEAAuE;IACvE,kGAAkG;IAClG,4EAA4E;IAC5E,OAAO,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC;SACrB,MAAM,CAAC,SAAS,CAAC;SACjB,MAAM,CAAC,CAAC,WAAW,EAAE,GAAG,EAAE,EAAE;QAC3B,WAAW,CAAC,GAAG,CAAC,GAAG,IAAI,CAAC,GAAG,CAAC,CAAA;QAC5B,OAAO,WAAW,CAAA;IACpB,CAAC,EAAE,EAA2B,CAAC,CAAA;AACnC,CAAC;AAED;;;;GAIG;AACH,MAAM,UAAU,sBAAsB,CAAC,IAA2B;IAChE,MAAM,aAAa,GAAG,MAAM,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE;QACvD,IAAI,CAAC,GAAG,CAAC,EAAE;YACT,OAAO,CAAC,CAAC,CAAA;SACV;QACD,IAAI,CAAC,GAAG,CAAC,EAAE;YACT,OAAO,CAAC,CAAA;SACT;QACD,OAAO,CAAC,CAAA;IACV,CAAC,CAAC,CAAA;IAEF,OAAO,MAAM,CAAC,WAAW,CAAC,aAAa,CAAC,CAAA;AAC1C,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CAAC,OAAe;IACrD,mFAAmF;IACnF,IAAI,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC,KAAK,KAAK,EAAE;QACtC,MAAM,IAAI,KAAK,CAAC,iCAAiC,OAAO,EAAE,CAAC,CAAA;KAC5D;IACD,2DAA2D;IAC3D,IAAI,EAAE,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE;QAC1B,MAAM,GAAG,CAAC,MAAM,CAAC,OAAO,CAAC,CAAA;KAC1B;AACH,CAAC;AASD;;;;;;;GAOG;AACH,MAAM,CAAC,KAAK,UAAU,oBAAoB,CAAC,GAAW,EAAE,eAAuB,EAAE,OAA0B;IACzG,gBAAgB,CAAC,KAAK,EAAE,GAAG,CAAC,CAAA;IAC5B,aAAa,CAAC,SAAS,EAAE,eAAe,CAAC,CAAA;IAEzC,IAAI,eAAe,CAAC,MAAM,GAAG,EAAE,EAAE;QAC/B,MAAM,IAAI,KAAK,CAAC,0DAA0D,CAAC,CAAA;KAC5E;IAED,MAAM,YAAY,GAAG,eAAe,CAAC,OAAO,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAA;IAC/E,IAAI,YAAY,GAAG,CAAC,EAAE;QACpB,MAAM,IAAI,KAAK,CAAC,yDAAyD,CAAC,CAAA;KAC3E;IAED,IAAI,eAAe,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,eAAe,CAAC,QAAQ,CAAC,IAAI,CAAC,EAAE;QACnE,MAAM,IAAI,KAAK,CAAC,gDAAgD,CAAC,CAAA;KAClE;IAED,MAAM,cAAc,GAAqB,EAAE,QAAQ,EAAE,CAAC,EAAE,CAAA;IACxD,MAAM,aAAa,GAAG,EAAE,GAAG,cAAc,EAAE,GAAG,OAAO,EAAE,CAAA;IAEvD,iCAAiC;IACjC,MAAM,KAAK,GAAG,IAAI,MAAM,CAAC,GAAG,GAAG,eAAe,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC,GAAG,CAAC,oBAAoB,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,GAAG,GAAG,CAAC,CAAA;IAEvG,MAAM,OAAO,GAAa,EAAE,CAAA;IAE5B,kDAAkD;IAClD,KAAK,UAAU,eAAe,CAAC,SAAiB,EAAE,KAAa;QAC7D,IAAI,KAAK,GAAG,aAAa,CAAC,QAAS;YAAE,OAAM;QAE3C,MAAM,OAAO,GAAG,MAAM,GAAG,CAAC,OAAO,CAAC,SAAS,EAAE,EAAE,aAAa,EAAE,IAAI,EAAE,CAAC,CAAA;QAErE,KAAK,MAAM,KAAK,IAAI,OAAO,EAAE;YAC3B,MAAM,QAAQ,GAAG,OAAO,CAAC,SAAS,EAAE,KAAK,CAAC,IAAI,CAAC,CAAA;YAE/C,IAAI,KAAK,CAAC,WAAW,EAAE,EAAE;gBACvB,4CAA4C;gBAC5C,IAAI,CAAC,aAAa,CAAC,qBAAqB,IAAI,CAAC,aAAa,CAAC,qBAAqB,CAAC,QAAQ,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;oBACrG,MAAM,eAAe,CAAC,QAAQ,EAAE,KAAK,GAAG,CAAC,CAAC,CAAA;iBAC3C;aACF;iBAAM,IAAI,KAAK,CAAC,MAAM,EAAE,IAAI,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;gBACnD,IAAI,aAAa,CAAC,+BAA+B,EAAE;oBACjD,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,QAAQ,CAAC,GAAG,EAAE,QAAQ,CAAC,CAAC,OAAO,CAAC,KAAK,EAAE,GAAG,CAAC,CAAC,CAAA;iBAC/D;qBAAM;oBACL,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;iBACvB;aACF;SACF;IACH,CAAC;IAED,MAAM,eAAe,CAAC,GAAG,EAAE,CAAC,CAAC,CAAA,CAAE,oCAAoC;IAEnE,OAAO,OAAO,CAAA;AAChB,CAAC;AAED,+DAA+D;AAC/D,MAAM,UAAU,oBAAoB,CAAC,GAAW;IAC9C,OAAO,GAAG,CAAC,OAAO,CAAC,qBAAqB,EAAE,MAAM,CAAC,CAAA;AACnD,CAAC"}

package/dist/esm/generalUtilsInternal.d.ts

@@ -0,0 +1,9 @@
+import { SpawnOptionsWithThrow, SpawnResult, StringKeyedDictionary } from './generalUtils.js';
+export declare function copyEnv(sourcePath: string, destinationPath: string, overrideExistingDestinationValues?: boolean, suppressAddKeysMessages?: boolean): Promise<void>;
+export declare function getEnvAsDictionary(envPath: string): StringKeyedDictionary;
+export declare function dictionaryToEnvFileString(dict: StringKeyedDictionary): string;
+export interface SpawnOptionsInternal extends SpawnOptionsWithThrow {
+    isLongRunning?: boolean;
+}
+export declare function spawnAsyncInternal(command: string, args?: string[], options?: SpawnOptionsInternal): Promise<SpawnResult>;
+//# sourceMappingURL=generalUtilsInternal.d.ts.map

package/dist/esm/generalUtilsInternal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generalUtilsInternal.d.ts","sourceRoot":"","sources":["../../src/generalUtilsInternal.ts"],"names":[],"mappings":"AAKA,OAAO,EAAc,qBAAqB,EAAE,WAAW,EAAE,qBAAqB,EAA8G,MAAM,mBAAmB,CAAA;AAOrN,wBAAsB,OAAO,CAAC,UAAU,EAAE,MAAM,EAAE,eAAe,EAAE,MAAM,EAAE,iCAAiC,UAAO,EAAE,uBAAuB,UAAQ,iBAuCnJ;AAED,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,MAAM,GAAG,qBAAqB,CAUzE;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,qBAAqB,GAAG,MAAM,CAE7E;AAED,MAAM,WAAW,oBAAqB,SAAQ,qBAAqB;IACjE,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,wBAAsB,kBAAkB,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM,EAAE,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,OAAO,CAAC,WAAW,CAAC,CAmG/H"}