@push.rocks/smartconfig 6.0.0

package/dist_ts/00_commitinfo_data.d.ts

@@ -0,0 +1,8 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export declare const commitinfo: {
+    name: string;
+    version: string;
+    description: string;
+};

package/dist_ts/00_commitinfo_data.js

@@ -0,0 +1,9 @@
+/**
+ * autocreated commitinfo by @push.rocks/commitinfo
+ */
+export const commitinfo = {
+    name: '@push.rocks/smartconfig',
+    version: '6.0.0',
+    description: 'A comprehensive configuration management library providing key-value storage, environment variable mapping, and tool configuration.'
+};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiMDBfY29tbWl0aW5mb19kYXRhLmpzIiwic291cmNlUm9vdCI6IiIsInNvdXJjZXMiOlsiLi4vdHMvMDBfY29tbWl0aW5mb19kYXRhLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBOztHQUVHO0FBQ0gsTUFBTSxDQUFDLE1BQU0sVUFBVSxHQUFHO0lBQ3hCLElBQUksRUFBRSx5QkFBeUI7SUFDL0IsT0FBTyxFQUFFLE9BQU87SUFDaEIsV0FBVyxFQUFFLHFJQUFxSTtDQUNuSixDQUFBIn0=

package/dist_ts/classes.appdata.d.ts

@@ -0,0 +1,72 @@
+import * as plugins from './plugins.js';
+import { KeyValueStore } from './classes.keyvaluestore.js';
+export interface IAppDataOptions<T = any> {
+    dirPath?: string;
+    requiredKeys?: Array<keyof T>;
+    /**
+     * Whether keys should be persisted on disk or not
+     */
+    ephemeral?: boolean;
+    /**
+     * @deprecated Use 'ephemeral' instead
+     */
+    ephermal?: boolean;
+    /**
+     * kvStoreKey: 'MY_ENV_VAR'
+     */
+    envMapping?: plugins.tsclass.typeFest.PartialDeep<T>;
+    overwriteObject?: plugins.tsclass.typeFest.PartialDeep<T>;
+}
+export declare class AppData<T = any> {
+    /**
+     * creates appdata. If no pathArg is given, data will be stored here:
+     * ${PWD}/.nogit/appdata
+     * @param pathArg
+     * @returns
+     */
+    static createAndInit<T = any>(optionsArg?: IAppDataOptions<T>): Promise<AppData<T>>;
+    /**
+     * Static helper to get an environment variable as a boolean
+     * @param envVarName The name of the environment variable
+     * @returns boolean value (true if env var is "true", false otherwise)
+     */
+    static valueAsBoolean(envVarName: string): Promise<boolean>;
+    /**
+     * Static helper to get an environment variable as parsed JSON
+     * @param envVarName The name of the environment variable
+     * @returns Parsed JSON object/array
+     */
+    static valueAsJson<R = any>(envVarName: string): Promise<R | undefined>;
+    /**
+     * Static helper to get an environment variable as base64 decoded string
+     * @param envVarName The name of the environment variable
+     * @returns Decoded string
+     */
+    static valueAsBase64(envVarName: string): Promise<string | undefined>;
+    /**
+     * Static helper to get an environment variable as a string
+     * @param envVarName The name of the environment variable
+     * @returns String value
+     */
+    static valueAsString(envVarName: string): Promise<string | undefined>;
+    /**
+     * Static helper to get an environment variable as a number
+     * @param envVarName The name of the environment variable
+     * @returns Number value
+     */
+    static valueAsNumber(envVarName: string): Promise<number | undefined>;
+    readyDeferred: plugins.smartpromise.Deferred<void>;
+    options: IAppDataOptions<T>;
+    private kvStore;
+    constructor(optionsArg?: IAppDataOptions<T>);
+    /**
+     * inits app data
+     */
+    private init;
+    /**
+     * returns a kvstore that resides in appdata
+     */
+    getKvStore(): Promise<KeyValueStore<T>>;
+    logMissingKeys(): Promise<Array<keyof T>>;
+    waitForAndGetKey<K extends keyof T>(keyArg: K): Promise<T[K] | undefined>;
+}

package/dist_ts/classes.appdata.js

@@ -0,0 +1,454 @@
+import * as plugins from './plugins.js';
+import { KeyValueStore } from './classes.keyvaluestore.js';
+// ============================================================================
+// Singleton Qenv Provider
+// ============================================================================
+let sharedQenv;
+function getQenv() {
+    if (!sharedQenv) {
+        sharedQenv = new plugins.qenv.Qenv(process.cwd(), plugins.path.join(process.cwd(), '.nogit'));
+    }
+    return sharedQenv;
+}
+// ============================================================================
+// Security - Redaction for sensitive data
+// ============================================================================
+/**
+ * Redacts sensitive values in logs to prevent exposure of secrets
+ */
+function redactSensitiveValue(key, value) {
+    // List of patterns that indicate sensitive data
+    const sensitivePatterns = [
+        /secret/i, /token/i, /key/i, /password/i, /pass/i,
+        /api/i, /credential/i, /auth/i, /private/i, /jwt/i,
+        /cert/i, /signature/i, /bearer/i
+    ];
+    // Check if key contains sensitive pattern
+    const isSensitive = sensitivePatterns.some(pattern => pattern.test(key));
+    if (isSensitive) {
+        if (typeof value === 'string') {
+            // Show first 3 chars and length for debugging
+            return value.length > 3
+                ? `${value.substring(0, 3)}...[${value.length} chars]`
+                : '[redacted]';
+        }
+        return '[redacted]';
+    }
+    // Check if value looks like a JWT token or base64 secret
+    if (typeof value === 'string') {
+        // JWT tokens start with eyJ
+        if (value.startsWith('eyJ')) {
+            return `eyJ...[${value.length} chars]`;
+        }
+        // Very long strings might be encoded secrets
+        if (value.length > 100) {
+            return `${value.substring(0, 50)}...[${value.length} chars total]`;
+        }
+    }
+    return JSON.stringify(value);
+}
+// ============================================================================
+// Type Converters - Centralized conversion logic
+// ============================================================================
+function toBoolean(value) {
+    // If already boolean, return as-is
+    if (typeof value === 'boolean') {
+        console.log(`    🔹 toBoolean: value is already boolean: ${value}`);
+        return value;
+    }
+    // Handle null/undefined
+    if (value == null) {
+        console.log(`    🔹 toBoolean: value is null/undefined, returning false`);
+        return false;
+    }
+    // Handle string representations
+    const s = String(value).toLowerCase().trim();
+    // True values: "true", "1", "yes", "y", "on"
+    if (['true', '1', 'yes', 'y', 'on'].includes(s)) {
+        console.log(`    🔹 toBoolean: converting "${value}" to true`);
+        return true;
+    }
+    // False values: "false", "0", "no", "n", "off"
+    if (['false', '0', 'no', 'n', 'off'].includes(s)) {
+        console.log(`    🔹 toBoolean: converting "${value}" to false`);
+        return false;
+    }
+    // Default: non-empty string = true, empty = false
+    const result = s.length > 0;
+    console.log(`    🔹 toBoolean: defaulting "${value}" to ${result}`);
+    return result;
+}
+function toJson(value) {
+    if (value == null)
+        return undefined;
+    if (typeof value === 'string') {
+        try {
+            return JSON.parse(value);
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return value;
+}
+function fromBase64(value) {
+    if (value == null)
+        return undefined;
+    try {
+        return Buffer.from(String(value), 'base64').toString('utf8');
+    }
+    catch {
+        return String(value);
+    }
+}
+function toNumber(value) {
+    if (value == null)
+        return undefined;
+    const num = Number(value);
+    return Number.isNaN(num) ? undefined : num;
+}
+function toString(value) {
+    if (value == null)
+        return undefined;
+    return String(value);
+}
+// Transform registry for extensibility
+const transformRegistry = {
+    boolean: toBoolean,
+    json: toJson,
+    base64: fromBase64,
+    number: toNumber,
+};
+/**
+ * Parse a mapping string into a declarative spec
+ */
+function parseMappingSpec(input) {
+    const transforms = [];
+    let remaining = input;
+    // Check for hardcoded prefixes with type conversion
+    if (remaining.startsWith('hard_boolean:')) {
+        return {
+            source: { type: 'hard', value: remaining.slice(13) },
+            transforms: ['boolean']
+        };
+    }
+    if (remaining.startsWith('hard_json:')) {
+        return {
+            source: { type: 'hard', value: remaining.slice(10) },
+            transforms: ['json']
+        };
+    }
+    if (remaining.startsWith('hard_base64:')) {
+        return {
+            source: { type: 'hard', value: remaining.slice(12) },
+            transforms: ['base64']
+        };
+    }
+    // Check for generic hard: prefix
+    if (remaining.startsWith('hard:')) {
+        remaining = remaining.slice(5);
+        // Check for legacy suffixes on hardcoded values
+        if (remaining.endsWith('_JSON')) {
+            transforms.push('json');
+            remaining = remaining.slice(0, -5);
+        }
+        else if (remaining.endsWith('_BASE64')) {
+            transforms.push('base64');
+            remaining = remaining.slice(0, -7);
+        }
+        return {
+            source: { type: 'hard', value: remaining },
+            transforms
+        };
+    }
+    // Check for env var prefixes
+    if (remaining.startsWith('boolean:')) {
+        transforms.push('boolean');
+        remaining = remaining.slice(8);
+    }
+    else if (remaining.startsWith('json:')) {
+        transforms.push('json');
+        remaining = remaining.slice(5);
+    }
+    else if (remaining.startsWith('base64:')) {
+        transforms.push('base64');
+        remaining = remaining.slice(7);
+    }
+    // Check for legacy suffixes on env vars
+    if (remaining.endsWith('_JSON')) {
+        transforms.push('json');
+        remaining = remaining.slice(0, -5);
+    }
+    else if (remaining.endsWith('_BASE64')) {
+        transforms.push('base64');
+        remaining = remaining.slice(0, -7);
+    }
+    return {
+        source: { type: 'env', key: remaining },
+        transforms
+    };
+}
+/**
+ * Resolve the source value (env var or hardcoded)
+ */
+async function resolveSource(source) {
+    if (source.type === 'hard') {
+        return source.value;
+    }
+    // source.type === 'env'
+    // Workaround for Qenv bug where empty strings are treated as undefined
+    // Check process.env directly first to preserve empty strings
+    if (Object.prototype.hasOwnProperty.call(process.env, source.key)) {
+        return process.env[source.key];
+    }
+    // Fall back to Qenv for other sources (env.json, docker secrets, etc.)
+    return await getQenv().getEnvVarOnDemand(source.key);
+}
+/**
+ * Apply transformations in sequence
+ */
+function applyTransforms(value, transforms) {
+    return transforms.reduce((acc, transform) => {
+        const fn = transformRegistry[transform];
+        return fn ? fn(acc) : acc;
+    }, value);
+}
+/**
+ * Process a mapping value through the complete pipeline
+ */
+async function processMappingValue(mappingString) {
+    const spec = parseMappingSpec(mappingString);
+    const keyName = spec.source.type === 'env' ? spec.source.key : 'hardcoded';
+    console.log(`    🔍 Processing mapping: "${mappingString}"`);
+    console.log(`       Source: ${spec.source.type === 'env' ? `env:${spec.source.key}` : `hard:${spec.source.value}`}`);
+    console.log(`       Transforms: ${spec.transforms.length > 0 ? spec.transforms.join(', ') : 'none'}`);
+    const rawValue = await resolveSource(spec.source);
+    console.log(`       Raw value: ${redactSensitiveValue(keyName, rawValue)} (type: ${typeof rawValue})`);
+    if (rawValue === undefined || rawValue === null) {
+        console.log(`       ⚠️ Raw value is undefined/null, returning undefined`);
+        return undefined;
+    }
+    const result = applyTransforms(rawValue, spec.transforms);
+    console.log(`       Final value: ${redactSensitiveValue(keyName, result)} (type: ${typeof result})`);
+    return result;
+}
+/**
+ * Recursively evaluate mapping values (strings or nested objects)
+ */
+async function evaluateMappingValue(mappingValue) {
+    // Handle null explicitly - it should return null, not be treated as object
+    if (mappingValue === null) {
+        console.log(`    📌 Value is null, returning null`);
+        return null;
+    }
+    // Handle strings (mapping specs)
+    if (typeof mappingValue === 'string') {
+        return processMappingValue(mappingValue);
+    }
+    // Handle objects (but not arrays or null)
+    if (mappingValue && typeof mappingValue === 'object' && !Array.isArray(mappingValue)) {
+        console.log(`    📂 Processing nested object with ${Object.keys(mappingValue).length} keys`);
+        const result = {};
+        for (const [key, value] of Object.entries(mappingValue)) {
+            console.log(`      → Processing nested key "${key}"`);
+            const evaluated = await evaluateMappingValue(value);
+            // Important: Don't filter out false or other falsy values!
+            // Only skip if explicitly undefined
+            if (evaluated !== undefined) {
+                result[key] = evaluated;
+                console.log(`      ✓ Nested key "${key}" = ${redactSensitiveValue(key, evaluated)} (type: ${typeof evaluated})`);
+            }
+            else {
+                console.log(`      ⚠️ Nested key "${key}" evaluated to undefined, skipping`);
+            }
+        }
+        return result;
+    }
+    // For any other type (numbers, booleans, etc.), return as-is
+    // Note: We don't have key context here, so we'll just indicate the type
+    console.log(`    📎 Returning value as-is: [value] (type: ${typeof mappingValue})`);
+    return mappingValue;
+}
+export class AppData {
+    /**
+     * creates appdata. If no pathArg is given, data will be stored here:
+     * ${PWD}/.nogit/appdata
+     * @param pathArg
+     * @returns
+     */
+    static async createAndInit(optionsArg = {}) {
+        const appData = new AppData(optionsArg);
+        await appData.readyDeferred.promise;
+        return appData;
+    }
+    /**
+     * Static helper to get an environment variable as a boolean
+     * @param envVarName The name of the environment variable
+     * @returns boolean value (true if env var is "true", false otherwise)
+     */
+    static async valueAsBoolean(envVarName) {
+        const value = await getQenv().getEnvVarOnDemand(envVarName);
+        return toBoolean(value);
+    }
+    /**
+     * Static helper to get an environment variable as parsed JSON
+     * @param envVarName The name of the environment variable
+     * @returns Parsed JSON object/array
+     */
+    static async valueAsJson(envVarName) {
+        const value = await getQenv().getEnvVarOnDemand(envVarName);
+        return toJson(value);
+    }
+    /**
+     * Static helper to get an environment variable as base64 decoded string
+     * @param envVarName The name of the environment variable
+     * @returns Decoded string
+     */
+    static async valueAsBase64(envVarName) {
+        const value = await getQenv().getEnvVarOnDemand(envVarName);
+        return fromBase64(value);
+    }
+    /**
+     * Static helper to get an environment variable as a string
+     * @param envVarName The name of the environment variable
+     * @returns String value
+     */
+    static async valueAsString(envVarName) {
+        const value = await getQenv().getEnvVarOnDemand(envVarName);
+        return toString(value);
+    }
+    /**
+     * Static helper to get an environment variable as a number
+     * @param envVarName The name of the environment variable
+     * @returns Number value
+     */
+    static async valueAsNumber(envVarName) {
+        const value = await getQenv().getEnvVarOnDemand(envVarName);
+        return toNumber(value);
+    }
+    constructor(optionsArg = {}) {
+        // instance
+        this.readyDeferred = plugins.smartpromise.defer();
+        this.options = optionsArg;
+        this.init();
+    }
+    /**
+     * inits app data
+     */
+    async init() {
+        console.log('🚀 Initializing AppData...');
+        // Handle backward compatibility for typo
+        const isEphemeral = this.options.ephemeral ?? this.options.ephermal ?? false;
+        if (this.options.ephermal && !this.options.ephemeral) {
+            console.warn('⚠️ Option "ephermal" is deprecated, use "ephemeral" instead.');
+        }
+        if (this.options.dirPath) {
+            console.log(`  📁 Using custom directory: ${this.options.dirPath}`);
+        }
+        else if (isEphemeral) {
+            console.log(`  💨 Using ephemeral storage (in-memory only)`);
+        }
+        else {
+            const appDataDir = '/app/data';
+            const dataDir = '/data';
+            const nogitAppData = '.nogit/appdata';
+            const appDataExists = plugins.smartfile.fs.isDirectory(appDataDir);
+            const dataExists = plugins.smartfile.fs.isDirectory(dataDir);
+            if (appDataExists) {
+                this.options.dirPath = appDataDir;
+                console.log(`  📁 Auto-selected container directory: ${appDataDir}`);
+            }
+            else if (dataExists) {
+                this.options.dirPath = dataDir;
+                console.log(`  📁 Auto-selected data directory: ${dataDir}`);
+            }
+            else {
+                await plugins.smartfile.fs.ensureDir(nogitAppData);
+                this.options.dirPath = nogitAppData;
+                console.log(`  📁 Auto-selected local directory: ${nogitAppData}`);
+            }
+        }
+        this.kvStore = new KeyValueStore({
+            typeArg: isEphemeral ? 'ephemeral' : 'custom',
+            identityArg: 'appkv',
+            customPath: this.options.dirPath,
+            mandatoryKeys: this.options.requiredKeys,
+        });
+        if (this.options.envMapping) {
+            console.log(`📦 Processing envMapping for AppData...`);
+            const totalKeys = Object.keys(this.options.envMapping).length;
+            let processedCount = 0;
+            // Process each top-level key in envMapping
+            for (const key in this.options.envMapping) {
+                try {
+                    const mappingSpec = this.options.envMapping[key];
+                    const specType = mappingSpec === null ? 'null' :
+                        typeof mappingSpec === 'string' ? mappingSpec :
+                            typeof mappingSpec === 'object' ? 'nested object' :
+                                typeof mappingSpec;
+                    console.log(`  → Processing key "${key}" with spec: ${specType}`);
+                    const evaluated = await evaluateMappingValue(mappingSpec);
+                    // Important: Don't skip false, 0, empty string, or null values!
+                    // Only skip if explicitly undefined
+                    if (evaluated !== undefined) {
+                        await this.kvStore.writeKey(key, evaluated);
+                        processedCount++;
+                        const valueType = evaluated === null ? 'null' :
+                            Array.isArray(evaluated) ? 'array' :
+                                typeof evaluated;
+                        const valuePreview = evaluated === null ? 'null' :
+                            typeof evaluated === 'object' ?
+                                (Array.isArray(evaluated) ? `[${evaluated.length} items]` : `{${Object.keys(evaluated).length} keys}`) :
+                                redactSensitiveValue(key, evaluated);
+                        console.log(`  ✅ Successfully processed key "${key}" = ${valuePreview} (type: ${valueType})`);
+                    }
+                    else {
+                        console.log(`  ⚠️ Key "${key}" evaluated to undefined, skipping`);
+                    }
+                }
+                catch (err) {
+                    console.error(`  ❌ Failed to evaluate envMapping for key "${key}":`, err);
+                }
+            }
+            console.log(`📊 EnvMapping complete: ${processedCount}/${totalKeys} keys successfully processed`);
+        }
+        // Apply overwrite object after env mapping
+        if (this.options.overwriteObject) {
+            const overwriteKeys = Object.keys(this.options.overwriteObject);
+            console.log(`🔄 Applying overwriteObject with ${overwriteKeys.length} key(s)...`);
+            for (const key of overwriteKeys) {
+                const value = this.options.overwriteObject[key];
+                const valueType = Array.isArray(value) ? 'array' : typeof value;
+                console.log(`  🔧 Overwriting key "${key}" with ${valueType} value`);
+                await this.kvStore.writeKey(key, value);
+            }
+            console.log(`✅ OverwriteObject complete: ${overwriteKeys.length} key(s) overwritten`);
+        }
+        this.readyDeferred.resolve();
+        console.log('✨ AppData initialization complete!');
+    }
+    /**
+     * returns a kvstore that resides in appdata
+     */
+    async getKvStore() {
+        await this.readyDeferred.promise;
+        return this.kvStore;
+    }
+    async logMissingKeys() {
+        const kvStore = await this.getKvStore();
+        const missingMandatoryKeys = await kvStore.getMissingMandatoryKeys();
+        if (missingMandatoryKeys.length > 0) {
+            console.log(`The following mandatory keys are missing in the appdata:\n   -> ${missingMandatoryKeys.join(',\n   -> ')}`);
+        }
+        else {
+            console.log('All mandatory keys are present in the appdata');
+        }
+        return missingMandatoryKeys;
+    }
+    async waitForAndGetKey(keyArg) {
+        await this.readyDeferred.promise;
+        await this.kvStore.waitForKeysPresent([keyArg]);
+        return this.kvStore.readKey(keyArg);
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"classes.appdata.js","sourceRoot":"","sources":["../ts/classes.appdata.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,OAAO,MAAM,cAAc,CAAC;AACxC,OAAO,EAAE,aAAa,EAAE,MAAM,4BAA4B,CAAC;AAE3D,+EAA+E;AAC/E,0BAA0B;AAC1B,+EAA+E;AAC/E,IAAI,UAAyC,CAAC;AAE9C,SAAS,OAAO;IACd,IAAI,CAAC,UAAU,EAAE,CAAC;QAChB,UAAU,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC,IAAI,CAChC,OAAO,CAAC,GAAG,EAAE,EACb,OAAO,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,EAAE,QAAQ,CAAC,CAC3C,CAAC;IACJ,CAAC;IACD,OAAO,UAAU,CAAC;AACpB,CAAC;AAED,+EAA+E;AAC/E,0CAA0C;AAC1C,+EAA+E;AAC/E;;GAEG;AACH,SAAS,oBAAoB,CAAC,GAAW,EAAE,KAAc;IACvD,gDAAgD;IAChD,MAAM,iBAAiB,GAAG;QACxB,SAAS,EAAE,QAAQ,EAAE,MAAM,EAAE,WAAW,EAAE,OAAO;QACjD,MAAM,EAAE,aAAa,EAAE,OAAO,EAAE,UAAU,EAAE,MAAM;QAClD,OAAO,EAAE,YAAY,EAAE,SAAS;KACjC,CAAC;IAEF,0CAA0C;IAC1C,MAAM,WAAW,GAAG,iBAAiB,CAAC,IAAI,CAAC,OAAO,CAAC,EAAE,CAAC,OAAO,CAAC,IAAI,CAAC,GAAG,CAAC,CAAC,CAAC;IAEzE,IAAI,WAAW,EAAE,CAAC;QAChB,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;YAC9B,8CAA8C;YAC9C,OAAO,KAAK,CAAC,MAAM,GAAG,CAAC;gBACrB,CAAC,CAAC,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,CAAC,CAAC,OAAO,KAAK,CAAC,MAAM,SAAS;gBACtD,CAAC,CAAC,YAAY,CAAC;QACnB,CAAC;QACD,OAAO,YAAY,CAAC;IACtB,CAAC;IAED,yDAAyD;IACzD,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,4BAA4B;QAC5B,IAAI,KAAK,CAAC,UAAU,CAAC,KAAK,CAAC,EAAE,CAAC;YAC5B,OAAO,UAAU,KAAK,CAAC,MAAM,SAAS,CAAC;QACzC,CAAC;QACD,6CAA6C;QAC7C,IAAI,KAAK,CAAC,MAAM,GAAG,GAAG,EAAE,CAAC;YACvB,OAAO,GAAG,KAAK,CAAC,SAAS,CAAC,CAAC,EAAE,EAAE,CAAC,OAAO,KAAK,CAAC,MAAM,eAAe,CAAC;QACrE,CAAC;IACH,CAAC;IAED,OAAO,IAAI,CAAC,SAAS,CAAC,KAAK,CAAC,CAAC;AAC/B,CAAC;AAED,+EAA+E;AAC/E,iDAAiD;AACjD,+EAA+E;AAC/E,SAAS,SAAS,CAAC,KAAc;IAC/B,mCAAmC;IACnC,IAAI,OAAO,KAAK,KAAK,SAAS,EAAE,CAAC;QAC/B,OAAO,CAAC,GAAG,CAAC,+CAA+C,KAAK,EAAE,CAAC,CAAC;QACpE,OAAO,KAAK,CAAC;IACf,CAAC;IAED,wBAAwB;IACxB,IAAI,KAAK,IAAI,IAAI,EAAE,CAAC;QAClB,OAAO,CAAC,GAAG,CAAC,4DAA4D,CAAC,CAAC;QAC1E,OAAO,KAAK,CAAC;IACf,CAAC;IAED,gCAAgC;IAChC,MAAM,CAAC,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC,WAAW,EAAE,CAAC,IAAI,EAAE,CAAC;IAE7C,6CAA6C;IAC7C,IAAI,CAAC,MAAM,EAAE,GAAG,EAAE,KAAK,EAAE,GAAG,EAAE,IAAI,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QAChD,OAAO,CAAC,GAAG,CAAC,iCAAiC,KAAK,WAAW,CAAC,CAAC;QAC/D,OAAO,IAAI,CAAC;IACd,CAAC;IAED,+CAA+C;IAC/C,IAAI,CAAC,OAAO,EAAE,GAAG,EAAE,IAAI,EAAE,GAAG,EAAE,KAAK,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,EAAE,CAAC;QACjD,OAAO,CAAC,GAAG,CAAC,iCAAiC,KAAK,YAAY,CAAC,CAAC;QAChE,OAAO,KAAK,CAAC;IACf,CAAC;IAED,kDAAkD;IAClD,MAAM,MAAM,GAAG,CAAC,CAAC,MAAM,GAAG,CAAC,CAAC;IAC5B,OAAO,CAAC,GAAG,CAAC,iCAAiC,KAAK,QAAQ,MAAM,EAAE,CAAC,CAAC;IACpE,OAAO,MAAM,CAAC;AAChB,CAAC;AAED,SAAS,MAAM,CAAU,KAAc;IACrC,IAAI,KAAK,IAAI,IAAI;QAAE,OAAO,SAAS,CAAC;IACpC,IAAI,OAAO,KAAK,KAAK,QAAQ,EAAE,CAAC;QAC9B,IAAI,CAAC;YACH,OAAO,IAAI,CAAC,KAAK,CAAC,KAAK,CAAC,CAAC;QAC3B,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,SAAS,CAAC;QACnB,CAAC;IACH,CAAC;IACD,OAAO,KAAU,CAAC;AACpB,CAAC;AAED,SAAS,UAAU,CAAC,KAAc;IAChC,IAAI,KAAK,IAAI,IAAI;QAAE,OAAO,SAAS,CAAC;IACpC,IAAI,CAAC;QACH,OAAO,MAAM,CAAC,IAAI,CAAC,MAAM,CAAC,KAAK,CAAC,EAAE,QAAQ,CAAC,CAAC,QAAQ,CAAC,MAAM,CAAC,CAAC;IAC/D,CAAC;IAAC,MAAM,CAAC;QACP,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;IACvB,CAAC;AACH,CAAC;AAED,SAAS,QAAQ,CAAC,KAAc;IAC9B,IAAI,KAAK,IAAI,IAAI;QAAE,OAAO,SAAS,CAAC;IACpC,MAAM,GAAG,GAAG,MAAM,CAAC,KAAK,CAAC,CAAC;IAC1B,OAAO,MAAM,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,GAAG,CAAC;AAC7C,CAAC;AAED,SAAS,QAAQ,CAAC,KAAc;IAC9B,IAAI,KAAK,IAAI,IAAI;QAAE,OAAO,SAAS,CAAC;IACpC,OAAO,MAAM,CAAC,KAAK,CAAC,CAAC;AACvB,CAAC;AAcD,uCAAuC;AACvC,MAAM,iBAAiB,GAA4C;IACjE,OAAO,EAAE,SAAS;IAClB,IAAI,EAAE,MAAM;IACZ,MAAM,EAAE,UAAU;IAClB,MAAM,EAAE,QAAQ;CACjB,CAAC;AAEF;;GAEG;AACH,SAAS,gBAAgB,CAAC,KAAa;IACrC,MAAM,UAAU,GAAgB,EAAE,CAAC;IACnC,IAAI,SAAS,GAAG,KAAK,CAAC;IAEtB,oDAAoD;IACpD,IAAI,SAAS,CAAC,UAAU,CAAC,eAAe,CAAC,EAAE,CAAC;QAC1C,OAAO;YACL,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE;YACpD,UAAU,EAAE,CAAC,SAAS,CAAC;SACxB,CAAC;IACJ,CAAC;IAED,IAAI,SAAS,CAAC,UAAU,CAAC,YAAY,CAAC,EAAE,CAAC;QACvC,OAAO;YACL,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE;YACpD,UAAU,EAAE,CAAC,MAAM,CAAC;SACrB,CAAC;IACJ,CAAC;IAED,IAAI,SAAS,CAAC,UAAU,CAAC,cAAc,CAAC,EAAE,CAAC;QACzC,OAAO;YACL,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE;YACpD,UAAU,EAAE,CAAC,QAAQ,CAAC;SACvB,CAAC;IACJ,CAAC;IAED,iCAAiC;IACjC,IAAI,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QAClC,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC/B,gDAAgD;QAChD,IAAI,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;YAChC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;YACxB,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC;aAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;YACzC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;YAC1B,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;QACrC,CAAC;QACD,OAAO;YACL,MAAM,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,SAAS,EAAE;YAC1C,UAAU;SACX,CAAC;IACJ,CAAC;IAED,6BAA6B;IAC7B,IAAI,SAAS,CAAC,UAAU,CAAC,UAAU,CAAC,EAAE,CAAC;QACrC,UAAU,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC;QAC3B,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACjC,CAAC;SAAM,IAAI,SAAS,CAAC,UAAU,CAAC,OAAO,CAAC,EAAE,CAAC;QACzC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACxB,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACjC,CAAC;SAAM,IAAI,SAAS,CAAC,UAAU,CAAC,SAAS,CAAC,EAAE,CAAC;QAC3C,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC1B,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACjC,CAAC;IAED,wCAAwC;IACxC,IAAI,SAAS,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QAChC,UAAU,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;QACxB,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACrC,CAAC;SAAM,IAAI,SAAS,CAAC,QAAQ,CAAC,SAAS,CAAC,EAAE,CAAC;QACzC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;QAC1B,SAAS,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACrC,CAAC;IAED,OAAO;QACL,MAAM,EAAE,EAAE,IAAI,EAAE,KAAK,EAAE,GAAG,EAAE,SAAS,EAAE;QACvC,UAAU;KACX,CAAC;AACJ,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,aAAa,CAAC,MAA6B;IACxD,IAAI,MAAM,CAAC,IAAI,KAAK,MAAM,EAAE,CAAC;QAC3B,OAAO,MAAM,CAAC,KAAK,CAAC;IACtB,CAAC;IACD,wBAAwB;IACxB,uEAAuE;IACvE,6DAA6D;IAC7D,IAAI,MAAM,CAAC,SAAS,CAAC,cAAc,CAAC,IAAI,CAAC,OAAO,CAAC,GAAG,EAAE,MAAM,CAAC,GAAG,CAAC,EAAE,CAAC;QAClE,OAAO,OAAO,CAAC,GAAG,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;IACjC,CAAC;IACD,uEAAuE;IACvE,OAAO,MAAM,OAAO,EAAE,CAAC,iBAAiB,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC;AACvD,CAAC;AAED;;GAEG;AACH,SAAS,eAAe,CAAC,KAAc,EAAE,UAAuB;IAC9D,OAAO,UAAU,CAAC,MAAM,CAAC,CAAC,GAAG,EAAE,SAAS,EAAE,EAAE;QAC1C,MAAM,EAAE,GAAG,iBAAiB,CAAC,SAAS,CAAC,CAAC;QACxC,OAAO,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,CAAC;IAC5B,CAAC,EAAE,KAAK,CAAC,CAAC;AACZ,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,mBAAmB,CAAC,aAAqB;IACtD,MAAM,IAAI,GAAG,gBAAgB,CAAC,aAAa,CAAC,CAAC;IAC7C,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,CAAC,CAAC,WAAW,CAAC;IAE3E,OAAO,CAAC,GAAG,CAAC,+BAA+B,aAAa,GAAG,CAAC,CAAC;IAC7D,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,CAAC,MAAM,CAAC,IAAI,KAAK,KAAK,CAAC,CAAC,CAAC,OAAO,IAAI,CAAC,MAAM,CAAC,GAAG,EAAE,CAAC,CAAC,CAAC,QAAQ,IAAI,CAAC,MAAM,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;IACrH,OAAO,CAAC,GAAG,CAAC,sBAAsB,IAAI,CAAC,UAAU,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,IAAI,CAAC,UAAU,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC,MAAM,EAAE,CAAC,CAAC;IAEtG,MAAM,QAAQ,GAAG,MAAM,aAAa,CAAC,IAAI,CAAC,MAAM,CAAC,CAAC;IAClD,OAAO,CAAC,GAAG,CAAC,qBAAqB,oBAAoB,CAAC,OAAO,EAAE,QAAQ,CAAC,WAAW,OAAO,QAAQ,GAAG,CAAC,CAAC;IAEvG,IAAI,QAAQ,KAAK,SAAS,IAAI,QAAQ,KAAK,IAAI,EAAE,CAAC;QAChD,OAAO,CAAC,GAAG,CAAC,4DAA4D,CAAC,CAAC;QAC1E,OAAO,SAAS,CAAC;IACnB,CAAC;IAED,MAAM,MAAM,GAAG,eAAe,CAAC,QAAQ,EAAE,IAAI,CAAC,UAAU,CAAC,CAAC;IAC1D,OAAO,CAAC,GAAG,CAAC,uBAAuB,oBAAoB,CAAC,OAAO,EAAE,MAAM,CAAC,WAAW,OAAO,MAAM,GAAG,CAAC,CAAC;IACrG,OAAO,MAAM,CAAC;AAChB,CAAC;AAED;;GAEG;AACH,KAAK,UAAU,oBAAoB,CAAC,YAAiB;IACnD,2EAA2E;IAC3E,IAAI,YAAY,KAAK,IAAI,EAAE,CAAC;QAC1B,OAAO,CAAC,GAAG,CAAC,sCAAsC,CAAC,CAAC;QACpD,OAAO,IAAI,CAAC;IACd,CAAC;IAED,iCAAiC;IACjC,IAAI,OAAO,YAAY,KAAK,QAAQ,EAAE,CAAC;QACrC,OAAO,mBAAmB,CAAC,YAAY,CAAC,CAAC;IAC3C,CAAC;IAED,0CAA0C;IAC1C,IAAI,YAAY,IAAI,OAAO,YAAY,KAAK,QAAQ,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;QACrF,OAAO,CAAC,GAAG,CAAC,wCAAwC,MAAM,CAAC,IAAI,CAAC,YAAY,CAAC,CAAC,MAAM,OAAO,CAAC,CAAC;QAC7F,MAAM,MAAM,GAAQ,EAAE,CAAC;QACvB,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,YAAY,CAAC,EAAE,CAAC;YACxD,OAAO,CAAC,GAAG,CAAC,kCAAkC,GAAG,GAAG,CAAC,CAAC;YACtD,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAAC,KAAK,CAAC,CAAC;YACpD,2DAA2D;YAC3D,oCAAoC;YACpC,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;gBAC5B,MAAM,CAAC,GAAG,CAAC,GAAG,SAAS,CAAC;gBACxB,OAAO,CAAC,GAAG,CAAC,uBAAuB,GAAG,OAAO,oBAAoB,CAAC,GAAG,EAAE,SAAS,CAAC,WAAW,OAAO,SAAS,GAAG,CAAC,CAAC;YACnH,CAAC;iBAAM,CAAC;gBACN,OAAO,CAAC,GAAG,CAAC,wBAAwB,GAAG,oCAAoC,CAAC,CAAC;YAC/E,CAAC;QACH,CAAC;QACD,OAAO,MAAM,CAAC;IAChB,CAAC;IAED,6DAA6D;IAC7D,wEAAwE;IACxE,OAAO,CAAC,GAAG,CAAC,gDAAgD,OAAO,YAAY,GAAG,CAAC,CAAC;IACpF,OAAO,YAAY,CAAC;AACtB,CAAC;AA0BD,MAAM,OAAO,OAAO;IAClB;;;;;OAKG;IACI,MAAM,CAAC,KAAK,CAAC,aAAa,CAC/B,aAAiC,EAAE;QAEnC,MAAM,OAAO,GAAG,IAAI,OAAO,CAAI,UAAU,CAAC,CAAC;QAC3C,MAAM,OAAO,CAAC,aAAa,CAAC,OAAO,CAAC;QACpC,OAAO,OAAO,CAAC;IACjB,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,KAAK,CAAC,cAAc,CAAC,UAAkB;QACnD,MAAM,KAAK,GAAG,MAAM,OAAO,EAAE,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC5D,OAAO,SAAS,CAAC,KAAK,CAAC,CAAC;IAC1B,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,KAAK,CAAC,WAAW,CAAU,UAAkB;QACzD,MAAM,KAAK,GAAG,MAAM,OAAO,EAAE,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC5D,OAAO,MAAM,CAAI,KAAK,CAAC,CAAC;IAC1B,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,UAAkB;QAClD,MAAM,KAAK,GAAG,MAAM,OAAO,EAAE,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC5D,OAAO,UAAU,CAAC,KAAK,CAAC,CAAC;IAC3B,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,UAAkB;QAClD,MAAM,KAAK,GAAG,MAAM,OAAO,EAAE,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC5D,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAED;;;;OAIG;IACI,MAAM,CAAC,KAAK,CAAC,aAAa,CAAC,UAAkB;QAClD,MAAM,KAAK,GAAG,MAAM,OAAO,EAAE,CAAC,iBAAiB,CAAC,UAAU,CAAC,CAAC;QAC5D,OAAO,QAAQ,CAAC,KAAK,CAAC,CAAC;IACzB,CAAC;IAOD,YAAY,aAAiC,EAAE;QAL/C,WAAW;QACJ,kBAAa,GAAG,OAAO,CAAC,YAAY,CAAC,KAAK,EAAQ,CAAC;QAKxD,IAAI,CAAC,OAAO,GAAG,UAAU,CAAC;QAC1B,IAAI,CAAC,IAAI,EAAE,CAAC;IACd,CAAC;IAED;;OAEG;IACK,KAAK,CAAC,IAAI;QAChB,OAAO,CAAC,GAAG,CAAC,4BAA4B,CAAC,CAAC;QAE1C,yCAAyC;QACzC,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,SAAS,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,KAAK,CAAC;QAC7E,IAAI,IAAI,CAAC,OAAO,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,SAAS,EAAE,CAAC;YACrD,OAAO,CAAC,IAAI,CAAC,8DAA8D,CAAC,CAAC;QAC/E,CAAC;QAED,IAAI,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC;YACzB,OAAO,CAAC,GAAG,CAAC,gCAAgC,IAAI,CAAC,OAAO,CAAC,OAAO,EAAE,CAAC,CAAC;QACtE,CAAC;aAAM,IAAI,WAAW,EAAE,CAAC;YACvB,OAAO,CAAC,GAAG,CAAC,+CAA+C,CAAC,CAAC;QAC/D,CAAC;aAAM,CAAC;YACN,MAAM,UAAU,GAAG,WAAW,CAAC;YAC/B,MAAM,OAAO,GAAG,OAAO,CAAC;YACxB,MAAM,YAAY,GAAG,gBAAgB,CAAC;YACtC,MAAM,aAAa,GAAG,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,WAAW,CAAC,UAAU,CAAC,CAAC;YACnE,MAAM,UAAU,GAAG,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;YAC7D,IAAI,aAAa,EAAE,CAAC;gBAClB,IAAI,CAAC,OAAO,CAAC,OAAO,GAAG,UAAU,CAAC;gBAClC,OAAO,CAAC,GAAG,CAAC,2CAA2C,UAAU,EAAE,CAAC,CAAC;YACvE,CAAC;iBAAM,IAAI,UAAU,EAAE,CAAC;gBACtB,IAAI,CAAC,OAAO,CAAC,OAAO,GAAG,OAAO,CAAC;gBAC/B,OAAO,CAAC,GAAG,CAAC,sCAAsC,OAAO,EAAE,CAAC,CAAC;YAC/D,CAAC;iBAAM,CAAC;gBACN,MAAM,OAAO,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,YAAY,CAAC,CAAC;gBACnD,IAAI,CAAC,OAAO,CAAC,OAAO,GAAG,YAAY,CAAC;gBACpC,OAAO,CAAC,GAAG,CAAC,uCAAuC,YAAY,EAAE,CAAC,CAAC;YACrE,CAAC;QACH,CAAC;QAED,IAAI,CAAC,OAAO,GAAG,IAAI,aAAa,CAAI;YAClC,OAAO,EAAE,WAAW,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC,CAAC,QAAQ;YAC7C,WAAW,EAAE,OAAO;YACpB,UAAU,EAAE,IAAI,CAAC,OAAO,CAAC,OAAO;YAChC,aAAa,EAAE,IAAI,CAAC,OAAO,CAAC,YAA8B;SAC3D,CAAC,CAAC;QAEH,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;YAC5B,OAAO,CAAC,GAAG,CAAC,yCAAyC,CAAC,CAAC;YACvD,MAAM,SAAS,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC;YAC9D,IAAI,cAAc,GAAG,CAAC,CAAC;YAEvB,2CAA2C;YAC3C,KAAK,MAAM,GAAG,IAAI,IAAI,CAAC,OAAO,CAAC,UAAU,EAAE,CAAC;gBAC1C,IAAI,CAAC;oBACH,MAAM,WAAW,GAAG,IAAI,CAAC,OAAO,CAAC,UAAU,CAAC,GAAG,CAAC,CAAC;oBACjD,MAAM,QAAQ,GAAG,WAAW,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;wBAChC,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,WAAW,CAAC,CAAC;4BAC/C,OAAO,WAAW,KAAK,QAAQ,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC;gCACnD,OAAO,WAAW,CAAC;oBACnC,OAAO,CAAC,GAAG,CAAC,uBAAuB,GAAG,gBAAgB,QAAQ,EAAE,CAAC,CAAC;oBAElE,MAAM,SAAS,GAAG,MAAM,oBAAoB,CAAC,WAAW,CAAC,CAAC;oBAC1D,gEAAgE;oBAChE,oCAAoC;oBACpC,IAAI,SAAS,KAAK,SAAS,EAAE,CAAC;wBAC5B,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,GAAc,EAAE,SAAS,CAAC,CAAC;wBACvD,cAAc,EAAE,CAAC;wBACjB,MAAM,SAAS,GAAG,SAAS,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;4BAC/B,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC;gCACpC,OAAO,SAAS,CAAC;wBACjC,MAAM,YAAY,GAAG,SAAS,KAAK,IAAI,CAAC,CAAC,CAAC,MAAM,CAAC,CAAC;4BAC/B,OAAO,SAAS,KAAK,QAAQ,CAAC,CAAC;gCAC7B,CAAC,KAAK,CAAC,OAAO,CAAC,SAAS,CAAC,CAAC,CAAC,CAAC,IAAI,SAAS,CAAC,MAAM,SAAS,CAAC,CAAC,CAAC,IAAI,MAAM,CAAC,IAAI,CAAC,SAAS,CAAC,CAAC,MAAM,QAAQ,CAAC,CAAC,CAAC;gCACxG,oBAAoB,CAAC,GAAG,EAAE,SAAS,CAAC,CAAC;wBAC1D,OAAO,CAAC,GAAG,CAAC,mCAAmC,GAAG,OAAO,YAAY,WAAW,SAAS,GAAG,CAAC,CAAC;oBAChG,CAAC;yBAAM,CAAC;wBACN,OAAO,CAAC,GAAG,CAAC,aAAa,GAAG,oCAAoC,CAAC,CAAC;oBACpE,CAAC;gBACH,CAAC;gBAAC,OAAO,GAAG,EAAE,CAAC;oBACb,OAAO,CAAC,KAAK,CAAC,8CAA8C,GAAG,IAAI,EAAE,GAAG,CAAC,CAAC;gBAC5E,CAAC;YACH,CAAC;YAED,OAAO,CAAC,GAAG,CAAC,2BAA2B,cAAc,IAAI,SAAS,8BAA8B,CAAC,CAAC;QACpG,CAAC;QAED,2CAA2C;QAC3C,IAAI,IAAI,CAAC,OAAO,CAAC,eAAe,EAAE,CAAC;YACjC,MAAM,aAAa,GAAG,MAAM,CAAC,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;YAChE,OAAO,CAAC,GAAG,CAAC,oCAAoC,aAAa,CAAC,MAAM,YAAY,CAAC,CAAC;YAElF,KAAK,MAAM,GAAG,IAAI,aAAa,EAAE,CAAC;gBAChC,MAAM,KAAK,GAAG,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,GAAG,CAAC,CAAC;gBAChD,MAAM,SAAS,GAAG,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,OAAO,CAAC,CAAC,CAAC,OAAO,KAAK,CAAC;gBAChE,OAAO,CAAC,GAAG,CAAC,yBAAyB,GAAG,UAAU,SAAS,QAAQ,CAAC,CAAC;gBAErE,MAAM,IAAI,CAAC,OAAO,CAAC,QAAQ,CACzB,GAAc,EACd,KAAK,CACN,CAAC;YACJ,CAAC;YAED,OAAO,CAAC,GAAG,CAAC,+BAA+B,aAAa,CAAC,MAAM,qBAAqB,CAAC,CAAC;QACxF,CAAC;QAED,IAAI,CAAC,aAAa,CAAC,OAAO,EAAE,CAAC;QAC7B,OAAO,CAAC,GAAG,CAAC,oCAAoC,CAAC,CAAC;IACpD,CAAC;IAED;;OAEG;IACI,KAAK,CAAC,UAAU;QACrB,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;QACjC,OAAO,IAAI,CAAC,OAAO,CAAC;IACtB,CAAC;IAEM,KAAK,CAAC,cAAc;QACzB,MAAM,OAAO,GAAG,MAAM,IAAI,CAAC,UAAU,EAAE,CAAC;QACxC,MAAM,oBAAoB,GAAG,MAAM,OAAO,CAAC,uBAAuB,EAAE,CAAC;QACrE,IAAI,oBAAoB,CAAC,MAAM,GAAG,CAAC,EAAE,CAAC;YACpC,OAAO,CAAC,GAAG,CACT,mEAAmE,oBAAoB,CAAC,IAAI,CAC1F,WAAW,CACZ,EAAE,CACJ,CAAC;QACJ,CAAC;aAAM,CAAC;YACN,OAAO,CAAC,GAAG,CAAC,+CAA+C,CAAC,CAAC;QAC/D,CAAC;QACD,OAAO,oBAAoB,CAAC;IAC9B,CAAC;IAEM,KAAK,CAAC,gBAAgB,CAC3B,MAAS;QAET,MAAM,IAAI,CAAC,aAAa,CAAC,OAAO,CAAC;QACjC,MAAM,IAAI,CAAC,OAAO,CAAC,kBAAkB,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC;QAChD,OAAO,IAAI,CAAC,OAAO,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC;IACtC,CAAC;CACF"}

package/dist_ts/classes.keyvaluestore.d.ts

@@ -0,0 +1,63 @@
+import * as plugins from './plugins.js';
+export type TKeyValueStore = 'custom' | 'userHomeDir' | 'ephemeral';
+export interface IKvStoreConstructorOptions<T> {
+    typeArg: TKeyValueStore;
+    identityArg: string;
+    customPath?: string;
+    mandatoryKeys?: Array<keyof T>;
+}
+/**
+ * kvStore is a simple key value store to store data about projects between runs
+ */
+export declare class KeyValueStore<T = any> {
+    private dataObject;
+    private deletedObject;
+    private mandatoryKeys;
+    changeSubject: plugins.smartrx.rxjs.Subject<Partial<T>>;
+    private storedStateString;
+    syncTask: plugins.taskbuffer.Task<undefined>;
+    /**
+     * computes the identity and filePath
+     */
+    private initFilePath;
+    type: TKeyValueStore;
+    identity: string;
+    filePath?: string;
+    private customPath?;
+    /**
+     * the constructor of keyvalue store
+     * @param typeArg
+     * @param identityArg
+     * @param customPath Optional custom path for the keyValue store
+     */
+    constructor(optionsArg: IKvStoreConstructorOptions<T>);
+    /**
+     * reads all keyValue pairs at once and returns them
+     */
+    readAll(): Promise<Partial<T>>;
+    /**
+     * reads a keyValueFile from disk
+     */
+    readKey<K extends keyof T>(keyArg: K): Promise<T[K]>;
+    /**
+     * writes a specific key to the keyValueStore
+     */
+    writeKey<K extends keyof T>(keyArg: K, valueArg: T[K]): Promise<void>;
+    deleteKey<K extends keyof T>(keyArg: K): Promise<void>;
+    /**
+     * writes all keyValue pairs in the object argument
+     */
+    writeAll(keyValueObject: Partial<T>): Promise<void>;
+    /**
+     * wipes a key value store from disk
+     */
+    wipe(): Promise<void>;
+    /**
+     * resets the KeyValueStore to the initial state by syncing first, deleting all keys, and then triggering a sync again
+     */
+    reset(): Promise<void>;
+    private setMandatoryKeys;
+    getMissingMandatoryKeys(): Promise<Array<keyof T>>;
+    waitForKeysPresent<K extends keyof T>(keysArg: K[]): Promise<void>;
+    waitForAndGetKey<K extends keyof T>(keyArg: K): Promise<T[K] | undefined>;
+}