@mondaydotcomorg/atp-compiler 0.18.2 → 0.18.4-rc.1

package/__tests__/unit/default-compiler.test.ts

@@ -0,0 +1,259 @@
+/**
+ * Tests to verify createDefaultCompiler() provides identical functionality to ATPCompiler
+ */
+
+import { ATPCompiler } from '../../src/transformer/index.js';
+import { createDefaultCompiler } from '../../src/plugin-system/create-default-compiler.js';
+import type { TransformationPlugin } from '../../src/plugin-system/plugin-api.js';
+
+describe('Default Compiler - Functional Equivalence', () => {
+	describe('Detection', () => {
+		it('should detect for-of-await patterns like ATPCompiler', async () => {
+			const code = `
+				for (const item of items) {
+					await processItem(item);
+				}
+			`;
+
+			const atpCompiler = new ATPCompiler();
+			const pluggableCompiler = createDefaultCompiler();
+
+			const atpResult = atpCompiler.detect(code);
+			const pluggableResult = await pluggableCompiler.detect(code);
+
+			expect(pluggableResult.needsTransform).toBe(atpResult.needsTransform);
+			expect(pluggableResult.patterns).toEqual(expect.arrayContaining(atpResult.patterns));
+		});
+
+		it('should detect map-async patterns like ATPCompiler', async () => {
+			const code = `
+				const results = items.map(async (item) => {
+					return await processItem(item);
+				});
+			`;
+
+			const atpCompiler = new ATPCompiler();
+			const pluggableCompiler = createDefaultCompiler();
+
+			const atpResult = atpCompiler.detect(code);
+			const pluggableResult = await pluggableCompiler.detect(code);
+
+			expect(pluggableResult.needsTransform).toBe(atpResult.needsTransform);
+			expect(pluggableResult.patterns).toEqual(expect.arrayContaining(atpResult.patterns));
+		});
+
+		it('should detect Promise.all patterns like ATPCompiler', async () => {
+			const code = `
+				const results = await Promise.all(promises);
+			`;
+
+			const atpCompiler = new ATPCompiler();
+			const pluggableCompiler = createDefaultCompiler();
+
+			const atpResult = atpCompiler.detect(code);
+			const pluggableResult = await pluggableCompiler.detect(code);
+
+			expect(pluggableResult.needsTransform).toBe(atpResult.needsTransform);
+		});
+	});
+
+	describe('Transformation', () => {
+		it('should transform for-of loops like ATPCompiler', async () => {
+			const code = `
+				for (const item of items) {
+					await processItem(item);
+				}
+			`;
+
+			const atpCompiler = new ATPCompiler();
+			const pluggableCompiler = createDefaultCompiler();
+
+			const atpResult = atpCompiler.transform(code);
+			const pluggableResult = await pluggableCompiler.transform(code);
+
+			// Both should transform
+			expect(pluggableResult.transformed).toBe(true);
+			expect(atpResult.transformed).toBe(true);
+
+			// Both should produce transformed code (not exact match due to formatting)
+			expect(pluggableResult.code).toContain('__runtime.resumableForOf');
+			expect(atpResult.code).toContain('__runtime.resumableForOf');
+
+			// Metadata should be similar
+			expect(pluggableResult.metadata.loopCount).toBeGreaterThan(0);
+			expect(atpResult.metadata.loopCount).toBeGreaterThan(0);
+		});
+
+		it('should transform array methods like ATPCompiler', async () => {
+			const code = `
+				const results = items.map(async (item) => {
+					return await processItem(item);
+				});
+			`;
+
+			const atpCompiler = new ATPCompiler();
+			const pluggableCompiler = createDefaultCompiler();
+
+			const atpResult = atpCompiler.transform(code);
+			const pluggableResult = await pluggableCompiler.transform(code);
+
+			expect(pluggableResult.transformed).toBe(true);
+			expect(atpResult.transformed).toBe(true);
+
+			// Code should contain transformation
+			expect(pluggableResult.code).toContain('map');
+			expect(atpResult.code).toContain('map');
+			
+			// Metadata counts should match
+			expect(pluggableResult.metadata).toMatchObject({
+				loopCount: atpResult.metadata.loopCount,
+				arrayMethodCount: atpResult.metadata.arrayMethodCount,
+				parallelCallCount: atpResult.metadata.parallelCallCount,
+			});
+		});
+
+		it('should handle code that needs no transformation', async () => {
+			const code = `
+				const x = 1 + 1;
+				console.log(x);
+			`;
+
+			const atpCompiler = new ATPCompiler();
+			const pluggableCompiler = createDefaultCompiler();
+
+			const atpResult = atpCompiler.transform(code);
+			const pluggableResult = await pluggableCompiler.transform(code);
+
+			expect(pluggableResult.transformed).toBe(false);
+			expect(atpResult.transformed).toBe(false);
+
+			// Code should be unchanged
+			expect(pluggableResult.code).toBe(code);
+			expect(atpResult.code).toBe(code);
+		});
+	});
+
+	describe('Configuration', () => {
+		it('should respect enableBatchParallel config', async () => {
+			const code = `
+				const results = await Promise.all([
+					fetch('/api/1'),
+					fetch('/api/2'),
+				]);
+			`;
+
+			const compilerWithBatch = createDefaultCompiler({ enableBatchParallel: true });
+			const compilerWithoutBatch = createDefaultCompiler({ enableBatchParallel: false });
+
+			const resultWith = await compilerWithBatch.transform(code);
+			const resultWithout = await compilerWithoutBatch.transform(code);
+
+			// Both should transform
+			expect(resultWith.transformed).toBe(true);
+			expect(resultWithout.transformed).toBe(true);
+
+			// The code output might differ based on batch config
+			// (exact differences depend on implementation)
+		});
+
+		it('should respect batchSizeThreshold config', async () => {
+			const code = `
+				for (const item of items) {
+					await processItem(item);
+				}
+			`;
+
+			const compilerSmall = createDefaultCompiler({ batchSizeThreshold: 5 });
+			const compilerLarge = createDefaultCompiler({ batchSizeThreshold: 100 });
+
+			const resultSmall = await compilerSmall.transform(code);
+			const resultLarge = await compilerLarge.transform(code);
+
+			// Both should transform
+			expect(resultSmall.transformed).toBe(true);
+			expect(resultLarge.transformed).toBe(true);
+		});
+	});
+
+	describe('Extensibility', () => {
+		it('should allow adding custom plugins on top of defaults', async () => {
+			const compiler = createDefaultCompiler();
+
+			let customPluginExecuted = false;
+
+			// Add custom transformation plugin that counts identifiers
+			const customPlugin: TransformationPlugin = {
+				name: 'custom-plugin',
+				version: '1.0.0',
+				priority: 50, // Lower priority to run after defaults
+				getVisitor: () => ({
+					Identifier: (path: any) => {
+						if (path.node.name === 'item') {
+							customPluginExecuted = true;
+						}
+					},
+				}),
+				getMetadata: () => ({}),
+				reset: () => {
+					customPluginExecuted = false;
+				},
+			};
+			
+			compiler.use(customPlugin);
+
+			// Use code that will trigger transformation
+			const code = `
+				for (const item of items) {
+					await processItem(item);
+				}
+			`;
+			const result = await compiler.transform(code);
+
+			// Verify plugin was registered and executed
+			expect(customPluginExecuted).toBe(true);
+			expect(result).toHaveProperty('code');
+			expect(result.transformed).toBe(true);
+		});
+
+		it('should work with AST caching', async () => {
+			const compiler = createDefaultCompiler();
+
+			const code = `const x = 42;`;
+
+			// First call - parses and caches
+			await compiler.detect(code);
+			expect(compiler.getCacheStats().size).toBe(1);
+
+			// Second call - uses cache
+			await compiler.transform(code);
+			expect(compiler.getCacheStats().size).toBe(1);
+		});
+	});
+
+	describe('Drop-in Replacement', () => {
+		it('should be usable as ATPCompilerLike type', async () => {
+			// This test verifies the type compatibility
+			const compiler = createDefaultCompiler({
+				enableBatchParallel: true,
+				batchSizeThreshold: 10,
+			});
+
+			const code = `
+				for (const item of items) {
+					await processItem(item);
+				}
+			`;
+
+			// Should work with same API
+			const detection = await compiler.detect(code);
+			expect(detection).toHaveProperty('needsTransform');
+			expect(detection).toHaveProperty('patterns');
+
+			const result = await compiler.transform(code);
+			expect(result).toHaveProperty('code');
+			expect(result).toHaveProperty('transformed');
+			expect(result).toHaveProperty('metadata');
+		});
+	});
+});
+

package/__tests__/unit/plugin-system.test.ts

@@ -0,0 +1,401 @@
+/**
+ * Unit tests for the Plugin System
+ */
+
+import { PluginRegistry } from '../../src/plugin-system/plugin-api.js';
+import { PluggableCompiler } from '../../src/plugin-system/pluggable-compiler.js';
+import type {
+	DetectionPlugin,
+	TransformationPlugin,
+	OptimizerPlugin,
+	ValidatorPlugin,
+	BabelVisitor,
+} from '../../src/plugin-system/plugin-api.js';
+import type { CompilerConfig, TransformMetadata, DetectionResult } from '../../src/types.js';
+import * as t from '@babel/types';
+
+describe('PluginRegistry', () => {
+	let registry: PluginRegistry;
+
+	beforeEach(() => {
+		registry = new PluginRegistry();
+	});
+
+	describe('Plugin Registration', () => {
+		it('should register a detection plugin', () => {
+			const plugin: DetectionPlugin = {
+				name: 'test-detector',
+				version: '1.0.0',
+				priority: 100,
+				patterns: ['for-of-await'],
+				detect: async (code: string, ast: t.File): Promise<DetectionResult> => ({
+					needsTransform: true,
+					patterns: ['for-of-await'],
+					batchableParallel: false,
+				}),
+			};
+
+			registry.register(plugin);
+			const plugins = registry.getDetectors();
+			expect(plugins).toHaveLength(1);
+			expect(plugins[0]!.name).toBe('test-detector');
+		});
+
+		it('should register a transformation plugin', () => {
+			const plugin: TransformationPlugin = {
+				name: 'test-transformer',
+				version: '1.0.0',
+				priority: 100,
+				getVisitor: (config: CompilerConfig): BabelVisitor => ({}),
+				getMetadata: () => ({ loopCount: 0 }),
+				reset: () => {},
+			};
+
+			registry.register(plugin);
+			const plugins = registry.getTransformers();
+			expect(plugins).toHaveLength(1);
+			expect(plugins[0]!.name).toBe('test-transformer');
+		});
+
+		it('should throw error when registering duplicate plugin names', () => {
+			const plugin1: DetectionPlugin = {
+				name: 'duplicate',
+				version: '1.0.0',
+				priority: 100,
+				patterns: ['for-of-await'],
+				detect: async () => ({ needsTransform: false, patterns: [], batchableParallel: false }),
+			};
+
+			const plugin2: DetectionPlugin = {
+				name: 'duplicate',
+				version: '2.0.0',
+				priority: 50,
+				patterns: ['map-async'],
+				detect: async () => ({ needsTransform: false, patterns: [], batchableParallel: false }),
+			};
+
+			registry.register(plugin1);
+			expect(() => registry.register(plugin2)).toThrow('Plugin "duplicate" is already registered');
+		});
+
+		it('should sort plugins by priority (higher first)', () => {
+			const plugin1: DetectionPlugin = {
+				name: 'low-priority',
+				version: '1.0.0',
+				priority: 10,
+				patterns: [],
+				detect: async () => ({ needsTransform: false, patterns: [], batchableParallel: false }),
+			};
+
+			const plugin2: DetectionPlugin = {
+				name: 'high-priority',
+				version: '1.0.0',
+				priority: 100,
+				patterns: [],
+				detect: async () => ({ needsTransform: false, patterns: [], batchableParallel: false }),
+			};
+
+			registry.register(plugin1);
+			registry.register(plugin2);
+
+			const plugins = registry.getDetectors();
+			expect(plugins[0]!.name).toBe('high-priority');
+			expect(plugins[1]!.name).toBe('low-priority');
+		});
+	});
+
+	describe('Plugin Unregistration', () => {
+		it('should unregister a plugin by name', () => {
+			const plugin: DetectionPlugin = {
+				name: 'to-remove',
+				version: '1.0.0',
+				priority: 100,
+				patterns: [],
+				detect: async () => ({ needsTransform: false, patterns: [], batchableParallel: false }),
+			};
+
+			registry.register(plugin);
+			expect(registry.getDetectors()).toHaveLength(1);
+
+			const removed = registry.unregister('to-remove');
+			expect(removed).toBe(true);
+			expect(registry.getDetectors()).toHaveLength(0);
+		});
+
+		it('should return false when unregistering non-existent plugin', () => {
+			const removed = registry.unregister('non-existent');
+			expect(removed).toBe(false);
+		});
+	});
+
+	describe('Plugin Retrieval', () => {
+		it('should find plugin by name', () => {
+			const plugin: DetectionPlugin = {
+				name: 'findable',
+				version: '1.0.0',
+				priority: 100,
+				patterns: [],
+				detect: async () => ({ needsTransform: false, patterns: [], batchableParallel: false }),
+			};
+
+			registry.register(plugin);
+			const found = registry.findPlugin('findable');
+			expect(found).toBeDefined();
+			expect(found?.name).toBe('findable');
+		});
+
+		it('should return undefined for non-existent plugin', () => {
+			const found = registry.findPlugin('non-existent');
+			expect(found).toBeUndefined();
+		});
+	});
+});
+
+describe('PluggableCompiler', () => {
+	let compiler: PluggableCompiler;
+
+	beforeEach(() => {
+		compiler = new PluggableCompiler();
+	});
+
+	describe('Plugin Management', () => {
+		it('should register plugin via use() method (chainable)', () => {
+			const plugin: DetectionPlugin = {
+				name: 'test-plugin',
+				version: '1.0.0',
+				patterns: [],
+				detect: async () => ({ needsTransform: false, patterns: [], batchableParallel: false }),
+			};
+
+			const result = compiler.use(plugin);
+			expect(result).toBe(compiler); // Chainable
+		});
+
+		it('should unregister plugin via remove() method', () => {
+			const plugin: DetectionPlugin = {
+				name: 'removable',
+				version: '1.0.0',
+				patterns: [],
+				detect: async () => ({ needsTransform: false, patterns: [], batchableParallel: false }),
+			};
+
+			compiler.use(plugin);
+			const removed = compiler.remove('removable');
+			expect(removed).toBe(true);
+		});
+	});
+
+	describe('Detection', () => {
+		it('should detect patterns using registered plugins', async () => {
+			const plugin: DetectionPlugin = {
+				name: 'for-of-detector',
+				version: '1.0.0',
+				priority: 100,
+				patterns: ['for-of-await'],
+				detect: async (code: string): Promise<DetectionResult> => {
+					return code.includes('for')
+						? { needsTransform: true, patterns: ['for-of-await'], batchableParallel: false }
+						: { needsTransform: false, patterns: [], batchableParallel: false };
+				},
+			};
+
+			compiler.use(plugin);
+
+			const code = `
+				for (const item of items) {
+					console.log(item);
+				}
+			`;
+
+			const result = await compiler.detect(code);
+			expect(result.needsTransform).toBe(true);
+			expect(result.patterns).toContain('for-of-await');
+		});
+
+		it('should handle detection errors gracefully', async () => {
+			const plugin: DetectionPlugin = {
+				name: 'failing-detector',
+				version: '1.0.0',
+				priority: 100,
+				patterns: [],
+				detect: async () => {
+					throw new Error('Detection failed');
+				},
+			};
+
+			compiler.use(plugin);
+
+			const result = await compiler.detect('some code');
+			expect(result.needsTransform).toBe(false);
+			expect(result.patterns).toEqual([]);
+		});
+	});
+
+	describe('Transformation', () => {
+		it('should execute transform with registered transformation plugins', async () => {
+			const plugin: TransformationPlugin = {
+				name: 'simple-transformer',
+				version: '1.0.0',
+				priority: 100,
+				getVisitor: (): BabelVisitor => ({}),
+				getMetadata: () => ({ loopCount: 1 }),
+				reset: () => {},
+			};
+
+			compiler.use(plugin);
+
+			const code = `const foo = 42;`;
+			const result = await compiler.transform(code);
+			expect(result.code).toBeTruthy(); // Code was processed
+			expect(result.metadata).toBeDefined(); // Metadata is present
+		});
+	});
+
+	describe('Lifecycle Management', () => {
+		it('should initialize plugins automatically on first use', async () => {
+			let initialized = false;
+
+			const plugin: DetectionPlugin = {
+				name: 'lifecycle-plugin',
+				version: '1.0.0',
+				priority: 100,
+				patterns: [],
+				detect: async () => ({ needsTransform: false, patterns: [], batchableParallel: false }),
+				initialize: async () => {
+					initialized = true;
+				},
+			};
+
+			compiler.use(plugin);
+			await compiler.detect('test code');
+
+			expect(initialized).toBe(true);
+		});
+
+		it('should dispose plugins on compiler disposal', async () => {
+			let disposed = false;
+
+			const plugin: DetectionPlugin = {
+				name: 'disposable-plugin',
+				version: '1.0.0',
+				patterns: [],
+				detect: async () => ({ needsTransform: false, patterns: [], batchableParallel: false }),
+				dispose: async () => {
+					disposed = true;
+				},
+			};
+
+			compiler.use(plugin);
+			await compiler.dispose();
+
+			expect(disposed).toBe(true);
+		});
+	});
+});
+
+describe('AST Caching', () => {
+	it('should cache AST between detect() and transform()', async () => {
+		const compiler = new PluggableCompiler();
+
+		const code = `const x = 42;`;
+
+		// First call - should parse and cache
+		await compiler.detect(code);
+		expect(compiler.getCacheStats().size).toBe(1);
+
+		// Second call - should use cache
+		await compiler.transform(code);
+		expect(compiler.getCacheStats().size).toBe(1); // Still 1, not 2
+	});
+
+	it('should cache different code snippets separately', async () => {
+		const compiler = new PluggableCompiler();
+
+		const code1 = `const x = 1;`;
+		const code2 = `const y = 2;`;
+
+		await compiler.detect(code1);
+		await compiler.detect(code2);
+
+		expect(compiler.getCacheStats().size).toBe(2);
+	});
+
+	it('should clear cache on clearCache() call', async () => {
+		const compiler = new PluggableCompiler();
+
+		await compiler.detect(`const x = 1;`);
+		expect(compiler.getCacheStats().size).toBe(1);
+
+		compiler.clearCache();
+		expect(compiler.getCacheStats().size).toBe(0);
+	});
+
+	it('should clear cache on dispose()', async () => {
+		const compiler = new PluggableCompiler();
+
+		await compiler.detect(`const x = 1;`);
+		expect(compiler.getCacheStats().size).toBe(1);
+
+		await compiler.dispose();
+		expect(compiler.getCacheStats().size).toBe(0);
+	});
+
+	it('should return cache statistics', () => {
+		const compiler = new PluggableCompiler();
+
+		const stats = compiler.getCacheStats();
+		expect(stats).toEqual({
+			size: 0,
+			enabled: true,
+		});
+	});
+});
+
+describe('Plugin Integration', () => {
+	it('should work with detection + transformation plugins', async () => {
+		const compiler = new PluggableCompiler();
+
+		// Detection plugin
+		compiler.use({
+			name: 'detector',
+			version: '1.0.0',
+			priority: 100,
+			patterns: ['for-of-await'],
+			detect: async (code: string) =>
+				code.includes('for')
+					? { needsTransform: true, patterns: ['for-of-await'], batchableParallel: false }
+					: { needsTransform: false, patterns: [], batchableParallel: false },
+		} as DetectionPlugin);
+
+		// Transformation plugin
+		let loopCount = 0;
+		compiler.use({
+			name: 'transformer',
+			version: '1.0.0',
+			priority: 100,
+			getVisitor: () => ({
+				ForOfStatement: (path: any) => {
+					loopCount++;
+				},
+			}),
+			getMetadata: () => ({ loopCount }),
+			reset: () => {
+				loopCount = 0;
+			},
+		} as TransformationPlugin);
+
+		const code = `
+			for (const item of items) {
+				console.log(item);
+			}
+		`;
+
+		const detection = await compiler.detect(code);
+		expect(detection.needsTransform).toBe(true);
+
+		const result = await compiler.transform(code);
+		expect(result.transformed).toBe(true);
+		expect(result.metadata.loopCount).toBeGreaterThan(0);
+	});
+});
+

package/dist/atp-compiler/src/index.d.ts

@@ -1,6 +1,14 @@
 export * from './types.js';
 export * from './transformer/index.js';
 export * from './runtime/index.js';
+export * from './types/compiler-interface.js';
+export * from './plugin-system/index.js';
 export { ATPCompiler } from './transformer/index.js';
 export { initializeRuntime, cleanupRuntime } from './runtime/index.js';
+export { PluggableCompiler } from './plugin-system/pluggable-compiler.js';
+export { PluginRegistry } from './plugin-system/plugin-api.js';
+export { createDefaultCompiler } from './plugin-system/create-default-compiler.js';
+export type { CompilerPlugin, DetectionPlugin, TransformationPlugin, OptimizerPlugin, ValidatorPlugin, PluginContext, BabelVisitor, } from './plugin-system/plugin-api.js';
+export type { ATPCompilerLike } from './plugin-system/create-default-compiler.js';
+export type { ICompiler, CacheStats } from './types/compiler-interface.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/atp-compiler/src/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AAEnC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AACA,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AAGnC,cAAc,+BAA+B,CAAC;AAG9C,cAAc,0BAA0B,CAAC;AAGzC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC;AAGnF,YAAY,EACX,cAAc,EACd,eAAe,EACf,oBAAoB,EACpB,eAAe,EACf,eAAe,EACf,aAAa,EACb,YAAY,GACZ,MAAM,+BAA+B,CAAC;AACvC,YAAY,EAAE,eAAe,EAAE,MAAM,4CAA4C,CAAC;AAGlF,YAAY,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC"}

package/dist/atp-compiler/src/index.js

@@ -1,6 +1,15 @@
+// Core exports
 export * from './types.js';
 export * from './transformer/index.js';
 export * from './runtime/index.js';
+// Compiler interface exports
+export * from './types/compiler-interface.js';
+// Plugin system exports
+export * from './plugin-system/index.js';
+// Main exports
 export { ATPCompiler } from './transformer/index.js';
 export { initializeRuntime, cleanupRuntime } from './runtime/index.js';
+export { PluggableCompiler } from './plugin-system/pluggable-compiler.js';
+export { PluginRegistry } from './plugin-system/plugin-api.js';
+export { createDefaultCompiler } from './plugin-system/create-default-compiler.js';
 //# sourceMappingURL=index.js.map

package/dist/atp-compiler/src/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AAEnC,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/index.ts"],"names":[],"mappings":"AAAA,eAAe;AACf,cAAc,YAAY,CAAC;AAC3B,cAAc,wBAAwB,CAAC;AACvC,cAAc,oBAAoB,CAAC;AAEnC,6BAA6B;AAC7B,cAAc,+BAA+B,CAAC;AAE9C,wBAAwB;AACxB,cAAc,0BAA0B,CAAC;AAEzC,eAAe;AACf,OAAO,EAAE,WAAW,EAAE,MAAM,wBAAwB,CAAC;AACrD,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACvE,OAAO,EAAE,iBAAiB,EAAE,MAAM,uCAAuC,CAAC;AAC1E,OAAO,EAAE,cAAc,EAAE,MAAM,+BAA+B,CAAC;AAC/D,OAAO,EAAE,qBAAqB,EAAE,MAAM,4CAA4C,CAAC"}