@invarn/cibuild 1.3.16 → 1.3.18

package/dist/src/yaml/env-resolver.test.js

@@ -0,0 +1,502 @@
+/**
+ * Unit tests for environment variable resolution
+ */
+import { describe, test, expect, beforeEach, afterEach } from '@jest/globals';
+import { EnvResolver, MissingEnvironmentVariableError, createEnvResolver } from './env-resolver.js';
+import * as fs from 'fs';
+describe('EnvResolver', () => {
+    let originalEnv;
+    beforeEach(() => {
+        // Save original environment
+        originalEnv = { ...process.env };
+    });
+    afterEach(() => {
+        // Restore original environment
+        process.env = originalEnv;
+    });
+    describe('Built-in environment variables', () => {
+        test('should add common built-in variables', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('CIBUILD_SOURCE_DIR')).toBe(process.cwd());
+            expect(resolver.get('CIBUILD_BUILD_NUMBER')).toBe('1');
+            expect(resolver.get('CIBUILD_GIT_BRANCH')).toBeDefined();
+            expect(resolver.get('CIBUILD_GIT_COMMIT')).toBeDefined();
+            expect(resolver.get('CIBUILD_TRIGGERED_WORKFLOW_ID')).toBe('primary');
+        });
+        test('should add macOS platform-specific variables', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'macos', 'macos-ventura-xcode-15.1');
+            expect(resolver.get('CIBUILD_STACK')).toBe('macos-ventura-xcode-15.1');
+            expect(resolver.get('CIBUILD_XCODE_VERSION')).toBe('15.1');
+            expect(resolver.get('CIBUILD_SCHEME')).toBeDefined();
+        });
+        test('should add Linux platform-specific variables', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux', 'linux-docker-android-22.04');
+            expect(resolver.get('CIBUILD_STACK')).toBe('linux-docker-android-22.04');
+            expect(resolver.get('CIBUILD_GRADLE_VERSION')).toBeDefined();
+            expect(resolver.get('JAVA_HOME')).toBeDefined();
+        });
+        test('should extract Xcode version from stack', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'macos', 'macos-sonoma-xcode-15.0');
+            expect(resolver.get('CIBUILD_XCODE_VERSION')).toBe('15.0');
+        });
+        test('should use process.env values when available', () => {
+            process.env.BUILD_NUMBER = '42';
+            process.env.GIT_BRANCH = 'feature/test';
+            process.env.GIT_COMMIT = 'abc123';
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('CIBUILD_BUILD_NUMBER')).toBe('42');
+            expect(resolver.get('CIBUILD_GIT_BRANCH')).toBe('feature/test');
+            expect(resolver.get('CIBUILD_GIT_COMMIT')).toBe('abc123');
+        });
+    });
+    describe('Environment variable merging', () => {
+        test('should merge global environment variables', () => {
+            const pipeline = {
+                format_version: '4',
+                app: {
+                    envs: [
+                        { GLOBAL_VAR1: 'value1' },
+                        { GLOBAL_VAR2: 'value2' },
+                    ],
+                },
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('GLOBAL_VAR1')).toBe('value1');
+            expect(resolver.get('GLOBAL_VAR2')).toBe('value2');
+        });
+        test('should merge workflow-level environment variables', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        envs: [
+                            { WORKFLOW_VAR1: 'wf_value1' },
+                            { WORKFLOW_VAR2: 'wf_value2' },
+                        ],
+                        steps: [],
+                    },
+                },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('WORKFLOW_VAR1')).toBe('wf_value1');
+            expect(resolver.get('WORKFLOW_VAR2')).toBe('wf_value2');
+        });
+        test('should override global variables with workflow variables', () => {
+            const pipeline = {
+                format_version: '4',
+                app: {
+                    envs: [{ BUILD_TYPE: 'debug' }],
+                },
+                workflows: {
+                    primary: {
+                        envs: [{ BUILD_TYPE: 'release' }],
+                        steps: [],
+                    },
+                },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('BUILD_TYPE')).toBe('release');
+        });
+        test('should handle empty env arrays', () => {
+            const pipeline = {
+                format_version: '4',
+                app: { envs: [] },
+                workflows: {
+                    primary: {
+                        envs: [],
+                        steps: [],
+                    },
+                },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            // Should still have built-in variables
+            expect(resolver.get('CIBUILD_SOURCE_DIR')).toBeDefined();
+        });
+    });
+    describe('Variable interpolation', () => {
+        test('should interpolate $VAR format', () => {
+            const pipeline = {
+                format_version: '4',
+                app: {
+                    envs: [{ MY_VAR: 'hello' }],
+                },
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            const result = resolver.interpolate('Value is $MY_VAR world');
+            expect(result).toBe('Value is hello world');
+        });
+        test('should interpolate ${VAR} format', () => {
+            const pipeline = {
+                format_version: '4',
+                app: {
+                    envs: [{ MY_VAR: 'hello' }],
+                },
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            const result = resolver.interpolate('Value is ${MY_VAR} world');
+            expect(result).toBe('Value is hello world');
+        });
+        test('should interpolate {{getenv "VAR"}} format', () => {
+            const pipeline = {
+                format_version: '4',
+                app: {
+                    envs: [{ MY_VAR: 'hello' }],
+                },
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            const result = resolver.interpolate('Value is {{getenv "MY_VAR"}} world');
+            expect(result).toBe('Value is hello world');
+        });
+        test('should interpolate {{checksum "file"}} format', () => {
+            // Create a test file
+            const testFile = 'test-checksum-file.txt';
+            fs.writeFileSync(testFile, 'test content');
+            try {
+                const pipeline = {
+                    format_version: '4',
+                    workflows: { primary: { steps: [] } },
+                };
+                const workflow = pipeline.workflows.primary;
+                const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+                const result = resolver.interpolate(`checksum-{{checksum "${testFile}"}}`);
+                // MD5 hash of "test content" is 9473fdd0d880a43c21b7778d34872157
+                expect(result).toBe('checksum-9473fdd0d880a43c21b7778d34872157');
+            }
+            finally {
+                // Cleanup
+                if (fs.existsSync(testFile)) {
+                    fs.unlinkSync(testFile);
+                }
+            }
+        });
+        test('should throw error for non-existent file in checksum', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(() => {
+                resolver.interpolate('{{checksum "non-existent-file.txt"}}');
+            }).toThrow('File not found: non-existent-file.txt');
+        });
+        test('should interpolate multiple variables in one string', () => {
+            const pipeline = {
+                format_version: '4',
+                app: {
+                    envs: [
+                        { VAR1: 'hello' },
+                        { VAR2: 'world' },
+                    ],
+                },
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            const result = resolver.interpolate('$VAR1 ${VAR2} {{getenv "VAR1"}}');
+            expect(result).toBe('hello world hello');
+        });
+        test('should interpolate variables in nested objects', () => {
+            const pipeline = {
+                format_version: '4',
+                app: {
+                    envs: [{ PROJECT_PATH: './MyApp' }],
+                },
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            const obj = {
+                path: '$PROJECT_PATH',
+                nested: {
+                    value: '${PROJECT_PATH}/sub',
+                },
+            };
+            const result = resolver.interpolateObject(obj);
+            expect(result.path).toBe('./MyApp');
+            expect(result.nested.value).toBe('./MyApp/sub');
+        });
+        test('should interpolate variables in arrays', () => {
+            const pipeline = {
+                format_version: '4',
+                app: {
+                    envs: [{ DIR: '/path' }],
+                },
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            const arr = ['$DIR/file1', '${DIR}/file2'];
+            const result = resolver.interpolateObject(arr);
+            expect(result[0]).toBe('/path/file1');
+            expect(result[1]).toBe('/path/file2');
+        });
+        test('should support env vars referencing other env vars', () => {
+            const pipeline = {
+                format_version: '4',
+                app: {
+                    envs: [
+                        { BASE_DIR: '/home/user' },
+                        { PROJECT_DIR: '$BASE_DIR/project' },
+                    ],
+                },
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('PROJECT_DIR')).toContain('/home/user/project');
+        });
+    });
+    describe('Missing variable detection', () => {
+        test('should throw error for missing variable in interpolation', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(() => resolver.interpolate('Value is $MISSING_VAR')).toThrow(MissingEnvironmentVariableError);
+        });
+        test('should include variable name in error message', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(() => resolver.interpolate('${MISSING_VAR}')).toThrow(/MISSING_VAR/);
+        });
+        test('should include step name in error message when provided', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(() => resolver.interpolate('${MISSING_VAR}', 'my-step')).toThrow(/my-step/);
+        });
+        test('should detect missing variables in nested objects', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            const obj = {
+                nested: {
+                    value: '$MISSING_VAR',
+                },
+            };
+            expect(() => resolver.interpolateObject(obj)).toThrow(MissingEnvironmentVariableError);
+        });
+    });
+    describe('Helper methods', () => {
+        test('has() should check variable existence', () => {
+            const pipeline = {
+                format_version: '4',
+                app: {
+                    envs: [{ MY_VAR: 'value' }],
+                },
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.has('MY_VAR')).toBe(true);
+            expect(resolver.has('NONEXISTENT_VAR')).toBe(false);
+        });
+        test('getAll() should return all variables', () => {
+            const pipeline = {
+                format_version: '4',
+                app: {
+                    envs: [{ VAR1: 'value1' }, { VAR2: 'value2' }],
+                },
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            const allVars = resolver.getAll();
+            expect(allVars.VAR1).toBe('value1');
+            expect(allVars.VAR2).toBe('value2');
+            expect(allVars.CIBUILD_SOURCE_DIR).toBeDefined();
+        });
+    });
+    describe('createEnvResolver helper', () => {
+        test('should create resolver for valid workflow', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const resolver = createEnvResolver(pipeline, 'primary', 'linux');
+            expect(resolver).toBeInstanceOf(EnvResolver);
+        });
+        test('should throw error for non-existent workflow', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            expect(() => createEnvResolver(pipeline, 'nonexistent', 'linux')).toThrow(/not found/);
+        });
+        test('should pass stack to resolver', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const resolver = createEnvResolver(pipeline, 'primary', 'macos', 'macos-ventura-xcode-15.1');
+            expect(resolver.get('CIBUILD_STACK')).toBe('macos-ventura-xcode-15.1');
+        });
+    });
+    describe('Bitrise variable mapping (FR-9.2)', () => {
+        test('should add CIBUILD_BUILD_NUMBER built-in variable', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('CIBUILD_BUILD_NUMBER')).toBe('1');
+        });
+        test('should add CIBUILD_BUILD_URL built-in variable', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('CIBUILD_BUILD_URL')).toBe('https://cibuild.io/builds/1');
+        });
+        test('should add CIBUILD_APP_TITLE built-in variable', () => {
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('CIBUILD_APP_TITLE')).toBe('CI Build Build');
+        });
+        test('should use process.env.BUILD_NUMBER for CIBUILD_BUILD_NUMBER', () => {
+            process.env.BUILD_NUMBER = '123';
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('CIBUILD_BUILD_NUMBER')).toBe('123');
+        });
+        test('should use process.env.BUILD_URL for CIBUILD_BUILD_URL', () => {
+            process.env.BUILD_URL = 'https://my-ci.com/build/456';
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('CIBUILD_BUILD_URL')).toBe('https://my-ci.com/build/456');
+        });
+        test('should use process.env.APP_TITLE for CIBUILD_APP_TITLE', () => {
+            process.env.APP_TITLE = 'My Awesome App';
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('CIBUILD_APP_TITLE')).toBe('My Awesome App');
+        });
+        test('should interpolate CIBUILD_BUILD_NUMBER in strings', () => {
+            process.env.BUILD_NUMBER = '999';
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            const result = resolver.interpolate('Build number: $CIBUILD_BUILD_NUMBER');
+            expect(result).toBe('Build number: 999');
+        });
+        test('should support CIBUILD_GIT_REPOSITORY_URL built-in variable', () => {
+            process.env.GIT_REPOSITORY_URL = 'https://github.com/user/repo.git';
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('CIBUILD_GIT_REPOSITORY_URL')).toBe('https://github.com/user/repo.git');
+        });
+        test('should allow YAML to reference CIBUILD variables naturally', () => {
+            process.env.BUILD_NUMBER = '1001';
+            const pipeline = {
+                format_version: '4',
+                workflows: {
+                    primary: {
+                        envs: [
+                            { MESSAGE: 'Build $CIBUILD_BUILD_NUMBER completed at $CIBUILD_BUILD_URL' },
+                        ],
+                        steps: [],
+                    },
+                },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            expect(resolver.get('MESSAGE')).toContain('Build 1001 completed at');
+            expect(resolver.get('MESSAGE')).toContain('https://cibuild.io/builds/1');
+        });
+        test('should handle CIBUILD variables in complex objects', () => {
+            process.env.BUILD_NUMBER = '2020';
+            process.env.APP_TITLE = 'Test App';
+            const pipeline = {
+                format_version: '4',
+                workflows: { primary: { steps: [] } },
+            };
+            const workflow = pipeline.workflows.primary;
+            const resolver = new EnvResolver(pipeline, workflow, 'primary', 'linux');
+            const obj = {
+                cibuild: {
+                    build: '$CIBUILD_BUILD_NUMBER',
+                    app: '$CIBUILD_APP_TITLE',
+                },
+            };
+            const result = resolver.interpolateObject(obj);
+            expect(result.cibuild.build).toBe('2020');
+            expect(result.cibuild.app).toBe('Test App');
+        });
+    });
+});
+//# sourceMappingURL=env-resolver.test.js.map

package/dist/src/yaml/interactive-prompts.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Interactive prompts for missing environment variables
+ * Allows users to fill in missing values or cancel the build
+ */
+import { SecretsManager } from './secrets-manager.js';
+/**
+ * Result of prompting for a missing environment variable
+ */
+export interface PromptResult {
+    value: string;
+    cancelled: boolean;
+    copiedToAI?: boolean;
+}
+/**
+ * Interactive prompt manager for collecting missing environment variables
+ */
+export declare class InteractivePrompts {
+    private secretsManager;
+    private workflow?;
+    constructor(secretsManager: SecretsManager, workflow?: string);
+    /**
+     * Prompt user for a missing environment variable
+     * @param varName Variable name
+     * @param stepName Optional step name that requires this variable
+     * @param hint Optional hint describing what the variable is for and expected format
+     * @returns Promise with the entered value or cancellation
+     */
+    promptForVariable(varName: string, stepName?: string, hint?: string): Promise<PromptResult>;
+    /**
+     * Determine if a variable name suggests it's sensitive
+     * @param varName Variable name
+     * @returns True if variable appears to be sensitive
+     */
+    private isSensitiveVariable;
+    /**
+     * Prompt for yes/no confirmation
+     * @param message Prompt message
+     * @returns Promise with true for yes, false for no
+     */
+    private promptYesNo;
+    /**
+     * Process hint text to preserve formatting while wrapping plain text
+     * @param hint Hint text (may contain newlines and formatted sections)
+     * @param maxWidth Maximum width for wrapping plain text lines
+     * @returns Array of processed lines ready for display
+     */
+    private processHintText;
+    /**
+     * Wrap text to fit within a specified width
+     * @param text Text to wrap
+     * @param maxWidth Maximum width per line
+     * @returns Array of wrapped lines
+     */
+    private wrapText;
+    /**
+     * Generate AI prompt with hint for getting guidance
+     * @param hint Hint text from the step
+     * @returns Formatted AI prompt
+     */
+    private generateAIPrompt;
+    /**
+     * Copy text to system clipboard
+     * @param text Text to copy
+     */
+    private copyToClipboard;
+    /**
+     * Close the prompts interface (no-op with prompts library)
+     */
+    close(): void;
+}
+//# sourceMappingURL=interactive-prompts.d.ts.map

package/dist/src/yaml/interactive-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interactive-prompts.d.ts","sourceRoot":"","sources":["../../../src/yaml/interactive-prompts.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAEtD;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,KAAK,EAAE,MAAM,CAAC;IACd,SAAS,EAAE,OAAO,CAAC;IACnB,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED;;GAEG;AACH,qBAAa,kBAAkB;IAC7B,OAAO,CAAC,cAAc,CAAiB;IACvC,OAAO,CAAC,QAAQ,CAAC,CAAS;gBAEd,cAAc,EAAE,cAAc,EAAE,QAAQ,CAAC,EAAE,MAAM;IAK7D;;;;;;OAMG;IACG,iBAAiB,CACrB,OAAO,EAAE,MAAM,EACf,QAAQ,CAAC,EAAE,MAAM,EACjB,IAAI,CAAC,EAAE,MAAM,GACZ,OAAO,CAAC,YAAY,CAAC;IA4FxB;;;;OAIG;IACH,OAAO,CAAC,mBAAmB;IAe3B;;;;OAIG;YACW,WAAW;IAWzB;;;;;OAKG;IACH,OAAO,CAAC,eAAe;IA0BvB;;;;;OAKG;IACH,OAAO,CAAC,QAAQ;IAyBhB;;;;OAIG;IACH,OAAO,CAAC,gBAAgB;IAkBxB;;;OAGG;YACW,eAAe;IAuC7B;;OAEG;IACH,KAAK,IAAI,IAAI;CAGd"}