@generaltranslation/compiler 0.0.0-alpha.0

package/LICENSE.md

@@ -0,0 +1,105 @@
+# Functional Source License, Version 1.1, ALv2 Future License
+
+## Abbreviation
+
+FSL-1.1-ALv2
+
+## Notice
+
+Copyright 2025 General Translation, Inc.
+
+## Terms and Conditions
+
+### Licensor ("We")
+
+The party offering the Software under these Terms and Conditions.
+
+### The Software
+
+The "Software" is each version of the software that we make available under
+these Terms and Conditions, as indicated by our inclusion of these Terms and
+Conditions with the Software.
+
+### License Grant
+
+Subject to your compliance with this License Grant and the Patents,
+Redistribution and Trademark clauses below, we hereby grant you the right to
+use, copy, modify, create derivative works, publicly perform, publicly display
+and redistribute the Software for any Permitted Purpose identified below.
+
+### Permitted Purpose
+
+A Permitted Purpose is any purpose other than a Competing Use. A Competing Use
+means making the Software available to others in a commercial product or
+service that:
+
+1. substitutes for the Software;
+
+2. substitutes for any other product or service we offer using the Software
+   that exists as of the date we make the Software available; or
+
+3. offers the same or substantially similar functionality as the Software.
+
+Permitted Purposes specifically include using the Software:
+
+1. for your internal use and access;
+
+2. for non-commercial education;
+
+3. for non-commercial research; and
+
+4. in connection with professional services that you provide to a licensee
+   using the Software in accordance with these Terms and Conditions.
+
+### Patents
+
+To the extent your use for a Permitted Purpose would necessarily infringe our
+patents, the license grant above includes a license under our patents. If you
+make a claim against any party that the Software infringes or contributes to
+the infringement of any patent, then your patent license to the Software ends
+immediately.
+
+### Redistribution
+
+The Terms and Conditions apply to all copies, modifications and derivatives of
+the Software.
+
+If you redistribute any copies, modifications or derivatives of the Software,
+you must include a copy of or a link to these Terms and Conditions and not
+remove any copyright notices provided in or with the Software.
+
+### Disclaimer
+
+THE SOFTWARE IS PROVIDED "AS IS" AND WITHOUT WARRANTIES OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING WITHOUT LIMITATION WARRANTIES OF FITNESS FOR A PARTICULAR
+PURPOSE, MERCHANTABILITY, TITLE OR NON-INFRINGEMENT.
+
+IN NO EVENT WILL WE HAVE ANY LIABILITY TO YOU ARISING OUT OF OR RELATED TO THE
+SOFTWARE, INCLUDING INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES,
+EVEN IF WE HAVE BEEN INFORMED OF THEIR POSSIBILITY IN ADVANCE.
+
+### Trademarks
+
+Except for displaying the License Details and identifying us as the origin of
+the Software, you have no right under these Terms and Conditions to use our
+trademarks, trade names, service marks or product names.
+
+## Grant of Future License
+
+We hereby irrevocably grant you an additional license to use the Software under
+the Apache License, Version 2.0 that is effective on the second anniversary of
+the date we make the Software available. On or after that date, you may use the
+Software under the Apache License, Version 2.0, in which case the following
+will apply:
+
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License.
+
+You may obtain a copy of the License at
+
+http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed
+under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR
+CONDITIONS OF ANY KIND, either express or implied. See the License for the
+specific language governing permissions and limitations under the License.

package/README.md

@@ -0,0 +1,274 @@
+# GT Compiler
+
+A universal plugin for compile-time optimization of GT translation components that works across webpack, Vite, Rollup, and other bundlers.
+
+## What It Does
+
+This plugin performs two main functions during the build process:
+
+### 1. Dynamic Content Detection
+
+Detects and prevents invalid usage patterns in GT translation components:
+
+#### JSX Component Violations:
+
+```jsx
+// ❌ Unwrapped expressions
+<T>Hello {userName}!</T>
+<T>You have {count} {count === 1 ? 'item' : 'items'}</T>
+<T>{greeting} world</T>
+
+// ❌ Mixed content
+<T>Price: <span>{price}</span></T>
+
+// ✅ Correct usage
+<T>Hello <Var>{userName}</Var>!</T>
+<T>You have <Num>{count}</Num> <Plural n={count} one="item" other="items" />!</T>
+<T><Var>{greeting}</Var> world</T>
+```
+
+#### Function Call Violations:
+
+```js
+// ❌ Template literals
+const msg = t(`Hello ${name}!`);
+const error = t(`Error: ${code} - ${message}`);
+
+// ❌ String concatenation
+const welcome = t('Welcome ' + username);
+const path = t('Go to ' + destination + ' page');
+
+// ❌ Dynamic expressions
+const dynamic = t(isError ? errorMsg : successMsg);
+
+// ✅ Correct usage
+const msg = t('Hello world!');
+const welcome = t('Welcome to our app');
+const error = t('Something went wrong', { context: 'error' });
+```
+
+### 2. Compile-Time Hash Generation
+
+Pre-computes translation keys at build time for better performance:
+
+- Generates stable hashes for `<T>` components and `t()` function calls
+- Injects hash attributes (`_hash`) into components
+- Creates content arrays for translation functions
+
+## Installation
+
+```bash
+npm install @generaltranslation/compiler
+```
+
+## Usage
+
+### With Next.js (Automatic)
+
+If you're using `gt-next`, the plugin is automatically configured for you. No additional setup required!
+
+### With Webpack (Manual)
+
+```js
+// webpack.config.js
+const gtCompiler = require('@generaltranslation/compiler/webpack');
+
+module.exports = {
+  plugins: [
+    gtCompiler({
+      compileTimeHash: true,
+      logLevel: 'warn',
+    }),
+  ],
+};
+```
+
+### With Vite
+
+```js
+// vite.config.js
+import { defineConfig } from 'vite';
+import gtCompiler from '@generaltranslation/compiler/vite';
+
+export default defineConfig({
+  plugins: [
+    gtCompiler({
+      compileTimeHash: true,
+      logLevel: 'warn',
+    }),
+  ],
+});
+```
+
+### With Rollup
+
+```js
+// rollup.config.js
+import gtCompiler from '@generaltranslation/compiler/rollup';
+
+export default {
+  plugins: [
+    gtCompiler({
+      compileTimeHash: true,
+      logLevel: 'warn',
+    }),
+  ],
+};
+```
+
+### With esbuild
+
+```js
+// esbuild.config.js
+const { build } = require('esbuild');
+const gtCompiler = require('@generaltranslation/compiler/esbuild');
+
+build({
+  plugins: [
+    gtCompiler({
+      compileTimeHash: true,
+      logLevel: 'warn',
+    }),
+  ],
+};
+```
+
+## Configuration Options
+
+```typescript
+interface GTCompilerOptions {
+  /** Control warning output */
+  logLevel?: 'silent' | 'error' | 'warn' | 'info' | 'debug';
+
+  /** Enable hash generation at compile time */
+  compileTimeHash?: boolean;
+
+  /** Skip dynamic content validation */
+  disableBuildChecks?: boolean;
+}
+```
+
+## How It Works
+
+The plugin uses the [unplugin](https://unplugin.unjs.io/) framework to provide universal bundler support. It analyzes your code using Babel's parser and transformer to:
+
+### String Collector
+
+Manages translation content across the two-pass transformation:
+
+- **Pass 1**: Collects translation strings, JSX content, and hash data
+- **Pass 2**: Injects collected data back into `useGT()`/`getGT()` calls
+- Associates content with function calls using deterministic counter IDs
+- Supports multiple `t()` calls per translation function
+
+### Scope Tracker
+
+Handles variable scoping and import tracking:
+
+- Tracks `useGT`/`getGT` variable assignments across nested scopes
+- Manages variable shadowing (`const t = useGT()` in different scopes)
+- Maps component names to their original GT imports (`T`, `Var`, etc.)
+- Handles both named imports and namespace imports (`GT.T`)
+
+### AST Traversal
+
+Converts JSX components into sanitized hash-able objects:
+
+- Recursively processes JSX elements and their children
+- Identifies GT components vs regular HTML elements
+- Extracts content from `Branch`/`Plural` component attributes
+- Generates stable hash representations for consistent builds
+
+## Two-Pass Traversal System
+
+The plugin uses a two-pass approach to handle the circular dependency between translation functions and their usage:
+
+### Pass 1: Collection
+
+- **Discover translation functions**: Find `useGT()` and `getGT()` calls, assign unique counter IDs
+- **Track variable assignments**: Follow `const t = useGT()` patterns using scope tracker
+- **Collect content**: Gather `t()` calls and `<T>` components, associate with counter IDs
+- **Generate hashes**: Calculate stable hashes for JSX content using AST traversal
+- **Validate usage**: Check for dynamic content violations and report errors
+
+### Pass 2: Transformation
+
+- **Inject content arrays**: Add collected `t()` strings to `useGT()`/`getGT()` calls
+- **Add hash attributes**: Insert `_hash` props into `<T>` components
+- **Preserve order**: Use the same counter sequence to match content with functions
+
+This approach solves the "chicken-and-egg" problem: we need to know what `t()` calls exist before we can inject content into the `useGT()` function that creates `t()`.
+
+## Supported Bundlers
+
+This plugin works with:
+
+- ✅ **Webpack** 4, 5
+- ✅ **Vite** 2, 3, 4, 5
+- ✅ **Rollup** 2, 3, 4
+- ✅ **esbuild** 0.15+
+- ✅ **Next.js** (via gt-next)
+- ✅ **Nuxt** (via unplugin auto-detection)
+
+## Components Tracked
+
+- **Translation**: `T`
+- **Variables**: `Var`, `Num`, `Currency`, `DateTime`
+- **Branching**: `Branch`, `Plural`
+- **Functions**: `useGT()`, `getGT()`, and their callbacks
+
+## Development Status
+
+Files ported from Rust SWC plugin with their implementation status:
+
+### ✅ Core Framework
+
+- **`src/index.ts`** - Universal plugin entry point with unplugin integration
+
+### ✅ Completed (with tests)
+
+- **`src/visitor/analysis.ts`** - Component identification functions
+- **`src/visitor/string-collector.ts`** - Two-pass transformation system
+- **`src/logging.ts`** - Logger implementation
+- **`src/visitor/errors.ts`** - Error message creation
+
+### 🚧 Implemented (needs integration)
+
+- **`src/visitor/scope-tracker.ts`** - Scope tracking and variable management
+- **`src/visitor/import-tracker.ts`** - Import tracking and component resolution
+
+### ❌ Not Yet Implemented
+
+- **`src/ast/traversal.ts`** - JSX to sanitized objects conversion
+- **`src/ast/utilities.ts`** - AST utility functions
+- **`src/hash.ts`** - Hash generation utilities
+- **`src/whitespace.ts`** - Whitespace handling utilities
+- **`src/visitor/transform.ts`** - Main transformation logic
+- **`src/visitor/jsx-utils.ts`** - JSX processing utilities
+- **`src/visitor/expr-utils.ts`** - Expression analysis utilities
+
+## Contributing
+
+This plugin is part of the General Translation ecosystem. The transformation logic is gradually being ported from the existing Rust SWC plugin to provide broader bundler support.
+
+### Test Files Structure
+
+```
+src/
+├── __tests__/
+│   ├── index.test.ts (unplugin integration tests)
+├── visitor/
+│   └── __tests__/
+│       ├── string-collector.test.ts ✅
+│       ├── analysis.test.ts (pending)
+│       ├── scope-tracker.test.ts (pending)
+│       └── import-tracker.test.ts (pending)
+├── logging.test.ts (pending)
+└── ast/
+    └── __tests__/
+        └── traversal.test.ts (pending)
+```
+
+## License
+
+MIT - General Translation, Inc.

package/dist/config.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Configuration types for the GT Babel plugin
+ */
+export type LogLevel = 'silent' | 'error' | 'warn' | 'info' | 'debug';
+/**
+ * Plugin configuration options (from babel config)
+ */
+export interface PluginConfig {
+    /** Log level for the plugin */
+    logLevel?: LogLevel;
+    /** Enable compile-time hash generation */
+    compileTimeHash?: boolean;
+    /** Disable dynamic content validation checks */
+    disableBuildChecks?: boolean;
+}
+/**
+ * Internal plugin settings (processed config)
+ */
+export interface PluginSettings {
+    logLevel: LogLevel;
+    compileTimeHash: boolean;
+    disableBuildChecks: boolean;
+    filename?: string;
+}
+//# sourceMappingURL=config.d.ts.map

package/dist/config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.d.ts","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":"AAAA;;GAEG;AAEH,MAAM,MAAM,QAAQ,GAAG,QAAQ,GAAG,OAAO,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;AAEtE;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,+BAA+B;IAC/B,QAAQ,CAAC,EAAE,QAAQ,CAAC;IACpB,0CAA0C;IAC1C,eAAe,CAAC,EAAE,OAAO,CAAC;IAC1B,gDAAgD;IAChD,kBAAkB,CAAC,EAAE,OAAO,CAAC;CAC9B;AAED;;GAEG;AACH,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,QAAQ,CAAC;IACnB,eAAe,EAAE,OAAO,CAAC;IACzB,kBAAkB,EAAE,OAAO,CAAC;IAC5B,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB"}

package/dist/config.js

@@ -0,0 +1,6 @@
+"use strict";
+/**
+ * Configuration types for the GT Babel plugin
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=config.js.map

package/dist/config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"config.js","sourceRoot":"","sources":["../src/config.ts"],"names":[],"mappings":";AAAA;;GAEG"}

package/dist/index.d.ts

@@ -0,0 +1,68 @@
+import { PluginConfig } from './config';
+/**
+ *
+ * First Pass:
+ * - Collect + calculate all data
+ * - Check for violations
+ * - "Register" - collect data to inject
+ * - "Track" - track a function call/variable assignment
+ *
+ * Second Pass:
+ * - Inject all data
+ *
+ * Architecture:
+ *
+ * Babel functions:
+ * - 1-to-1 relationship with processing functions
+ * - Handle (1) enter/exit scope (2) invoking processing function
+ * - ex) JSXElement()
+ *
+ * Processing functions:
+ * - Are dependent on the pass, so they have three categories: (1) first pass, (2) second pass, (3) shared/general
+ * - Invoke transformation functions and utility functions
+ * - ex) processJSXElement()
+ * - Has the following file structure:
+ * + processing
+ * | sharedProcessingFunction.ts
+ * | + first-pass
+ * | | firstPassProcessingFunction.ts
+ * | + second-pass
+ * | | secondPassProcessingFunction.ts
+ *
+ * Transformation functions:
+ * - Are AGNOSTIC to pass number
+ * - MUST be stateful in some way
+ * - ex) trackImportDeclaration()
+ *
+ * Utility functions:
+ * - Are AGNOSTIC to pass number
+ * - Are stateless
+ * - ex) extractIdentifiersFromLVal()
+ *
+ * State:
+ * - Includes classes for tracking state
+ *
+ * Currently no support for:
+ * - namespaces and and modules
+ */
+/**
+ * GT Universal Plugin Options
+ */
+export interface GTUnpluginOptions extends PluginConfig {
+}
+/**
+ * GT Universal Plugin - Main entry point
+ *
+ * Universal plugin for compile-time optimization of GT translation components
+ * that works across webpack, Vite, Rollup, and other bundlers.
+ *
+ * First pass: construct all information. no replacements, lest we lose our the monkey patching
+ * Second pass: inject all information (hashes, messages, etc.)
+ */
+declare const gtUnplugin: import("unplugin").UnpluginInstance<GTUnpluginOptions | undefined, boolean>;
+export default gtUnplugin;
+export declare const webpack: (options?: GTUnpluginOptions | undefined) => import("unplugin").WebpackPluginInstance;
+export declare const vite: (options?: GTUnpluginOptions | undefined) => import("vite").Plugin<any> | import("vite").Plugin<any>[];
+export declare const rollup: (options?: GTUnpluginOptions | undefined) => import("rollup").Plugin<any> | import("rollup").Plugin<any>[];
+export declare const esbuild: (options?: GTUnpluginOptions | undefined) => import("unplugin").EsbuildPlugin;
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAMA,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAC;AAcxC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AAEH;;GAEG;AACH,MAAM,WAAW,iBAAkB,SAAQ,YAAY;CAEtD;AAED;;;;;;;;GAQG;AACH,QAAA,MAAM,UAAU,6EAgFf,CAAC;AAGF,eAAe,UAAU,CAAC;AAC1B,eAAO,MAAM,OAAO,uFAAqB,CAAC;AAC1C,eAAO,MAAM,IAAI,wGAAkB,CAAC;AACpC,eAAO,MAAM,MAAM,4GAAoB,CAAC;AACxC,eAAO,MAAM,OAAO,+EAAqB,CAAC"}

package/dist/index.js

@@ -0,0 +1,132 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.esbuild = exports.rollup = exports.vite = exports.webpack = void 0;
+const unplugin_1 = require("unplugin");
+const parser = __importStar(require("@babel/parser"));
+const generator_1 = __importDefault(require("@babel/generator"));
+const traverse_1 = __importDefault(require("@babel/traverse"));
+// Import transformation functions
+const processCallExpression_1 = require("./processing/first-pass/processCallExpression");
+const processCallExpression_2 = require("./processing/second-pass/processCallExpression");
+const basePass_1 = require("./passes/basePass");
+const handleErrors_1 = require("./passes/handleErrors");
+const processVariableDeclarator_1 = require("./processing/first-pass/processVariableDeclarator");
+const processVariableDeclarator_2 = require("./processing/second-pass/processVariableDeclarator");
+const handleErrors_2 = require("./passes/handleErrors");
+const initializeState_1 = require("./state/utils/initializeState");
+/**
+ * GT Universal Plugin - Main entry point
+ *
+ * Universal plugin for compile-time optimization of GT translation components
+ * that works across webpack, Vite, Rollup, and other bundlers.
+ *
+ * First pass: construct all information. no replacements, lest we lose our the monkey patching
+ * Second pass: inject all information (hashes, messages, etc.)
+ */
+const gtUnplugin = (0, unplugin_1.createUnplugin)((options = {}) => {
+    return {
+        name: '@generaltranslation/GT_PLUGIN',
+        transformInclude(id) {
+            // Only transform TSX and JSX files
+            return (id.endsWith('.tsx') ||
+                id.endsWith('.jsx') ||
+                id.endsWith('.ts') ||
+                id.endsWith('.js'));
+        },
+        transform(code, id) {
+            // Initialize processing state
+            const state = (0, initializeState_1.initializeState)(options, id);
+            try {
+                // Skip transformation if not needed
+                if (state.settings.disableBuildChecks &&
+                    !state.settings.compileTimeHash) {
+                    return null;
+                }
+                // Parse the code into AST
+                const ast = parser.parse(code, {
+                    sourceType: 'module',
+                    plugins: ['jsx', 'typescript', 'decorators-legacy'],
+                    allowImportExportEverywhere: true,
+                    allowReturnOutsideFunction: true,
+                });
+                // PASS 1: Collection phase - collect translation data without transforming
+                (0, traverse_1.default)(ast, Object.assign(Object.assign({}, (0, basePass_1.basePass)(state)), { 
+                    // const gt = useGT();
+                    CallExpression: (0, processCallExpression_1.processCallExpression)(state), 
+                    // let T = ...
+                    VariableDeclarator: (0, processVariableDeclarator_1.processVariableDeclarator)(state) }));
+                // Handle errors
+                if ((0, handleErrors_1.handleErrors)(state)) {
+                    return null;
+                }
+                // PASS 2: Transformation phase - apply collected data to generate hashes and content arrays
+                if (!state.stringCollector.hasContent()) {
+                    return null;
+                }
+                // Complete second-pass traversal matching Rust Fold trait
+                (0, traverse_1.default)(ast, Object.assign(Object.assign({}, (0, basePass_1.basePass)(state)), { 
+                    // const gt = useGT();
+                    CallExpression: (0, processCallExpression_2.processCallExpression)(state), 
+                    // let T = ...
+                    VariableDeclarator: (0, processVariableDeclarator_2.processVariableDeclarator)(state) }));
+                // Generate code
+                return (0, generator_1.default)(ast, {
+                    retainLines: true,
+                    compact: false,
+                });
+            }
+            catch (error) {
+                // If the error is an instance of InvalidLibraryUsageError, throw it
+                if (error instanceof handleErrors_2.InvalidLibraryUsageError) {
+                    throw error;
+                }
+                // Otherwise, log the error
+                state.logger.logError(`Error processing ${id}: ${error}`);
+                return null;
+            }
+        },
+    };
+});
+// Export the unplugin with different bundler integrations
+exports.default = gtUnplugin;
+exports.webpack = gtUnplugin.webpack;
+exports.vite = gtUnplugin.vite;
+exports.rollup = gtUnplugin.rollup;
+exports.esbuild = gtUnplugin.esbuild;
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}

package/dist/passes/basePass.d.ts

@@ -0,0 +1,4 @@
+import { TransformState } from '../state/types';
+import { TraverseOptions } from '@babel/traverse';
+export declare function basePass(state: TransformState): TraverseOptions;
+//# sourceMappingURL=basePass.d.ts.map

package/dist/passes/basePass.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"basePass.d.ts","sourceRoot":"","sources":["../../src/passes/basePass.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAChD,OAAO,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAC;AAGlD,wBAAgB,QAAQ,CAAC,KAAK,EAAE,cAAc,GAAG,eAAe,CAoD/D"}