@salesforce/metadata-visualizer-web 1.0.1

package/LICENSE.txt

@@ -0,0 +1,27 @@
+Copyright (c) 2026, Salesforce.com, inc.
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without modification,
+are permitted provided that the following conditions are met:
+
+* Redistributions of source code must retain the above copyright notice, this
+list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright notice, this
+list of conditions and the following disclaimer in the documentation and/or
+other materials provided with the distribution.
+
+* Neither the name of Salesforce.com nor the names of its contributors may be
+used to endorse or promote products derived from this software without specific
+prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR
+ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

package/README.md

@@ -0,0 +1,269 @@
+# @salesforce/metadata-visualizer-web
+
+Web/HTTP SDK for the Salesforce Metadata Visualizer framework (`@salesforce/metadata-visualizer-core`). Lets any HTTP-based host (custom web services, browser applications, demo pages) plug a host-supplied filesystem into the framework and serve plugin visualizations to a browser.
+
+This package mirrors the role `visualizer-vscode-ext` plays for VS Code: it owns the host-specific plumbing (postMessage bootstrap, plugin asset bundling, `@dist/` URL rewriting) and exposes a small façade so consumers never see plugin internals.
+
+## Interfaces the host must implement
+
+The SDK is built around the principle of _interface inversion_: we define small contracts in `core-sdk`, and each host (browser application, VS Code, others) implements them. The SDK does not impose a transport, a router, or a filesystem layout — it just consumes what the host supplies and returns blobs the host can serve.
+
+There is **exactly one** interface the host must implement: `IFileSystem`. The engine also accepts an optional `telemetry` hook; everything else is handled internally by the SDK.
+
+### Required: `IFileSystem` (from `@salesforce/metadata-core-sdk`)
+
+This is the only interface the host _must_ implement. It is the host's bridge between the framework and the user-project files the host owns.
+
+#### Why this is required
+
+Plugin parsers (`SchemaParser`, `FlexipageParser`, future plugins) read the user's metadata files through this interface. The host implements it once against its existing I/O layer — delegating to your project service's file operations, which should enforce path traversal guards, restricted-path rules (`.git`, `.sf`, `node_modules`, dotfiles), path length limits, and per-project isolation.
+
+#### Methods to implement
+
+| Method                                                                                                               | What it does                                                    | Implementation notes                                                                                                                      |
+| -------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------- | ----------------------------------------------------------------------------------------------------------------------------------------- |
+| `readFile(path)`                                                                                                     | Read a file as a UTF-8 string. Returns `Result<string>`.        | Delegate to your file I/O layer. Wrap path validation errors into `{ success: false, error }`.                                            |
+| `writeFile(path, content)`                                                                                           | Write a file. Returns `Result<void>`.                           | Plugins do not write today; you can throw or stub.                                                                                        |
+| `exists(path)`                                                                                                       | Whether a file or directory exists. Returns `Promise<boolean>`. | Use your project service's path resolution + file system checks.                                                                          |
+| `getMetadata(path)`                                                                                                  | Returns `{ path, fileName, extension }`.                        | Pure path operations + stat for existence.                                                                                                |
+| `readDirectory(path)`                                                                                                | Lists directory entries with `{ name, isFile }`.                | Delegate to your directory listing implementation.                                                                                        |
+| `findFiles(pattern, maxResults?)`                                                                                    | Workspace-wide glob (e.g. `**/*.object-meta.xml`).              | Pattern language is minimatch with POSIX separators, anchored at the workspace root. Schema plugin uses this to discover related objects. |
+| `getWorkspaceRoot()`                                                                                                 | Absolute path of the project root.                              | One project per `IFileSystem` instance — construct one per request bound to that request's project.                                       |
+| `normalizePath`, `separator`, `basename`, `dirname`, `join`, `extname`, `parse`, `relative`, `resolve`, `isAbsolute` | Pure string operations.                                         | Delegate to Node's `path` module.                                                                                                         |
+
+The full type definition lives at `@salesforce/metadata-core-sdk` → `IFileSystem`.
+
+### Optional: `telemetry` (`ITelemetry` from `@salesforce/metadata-core-sdk`)
+
+A telemetry hook for tracking usage and errors, passed to `createWebVisualizationEngine` alongside `fileSystem`. If the host doesn't supply it, the SDK falls back to a no-op implementation.
+
+---
+
+## What the host gets back from the SDK
+
+After implementing `IFileSystem` and constructing the engine via `createWebVisualizationEngine`, the host calls these methods. The `WebVisualizationEngine` class provides five core methods:
+
+### Core API Methods
+
+| Method                                       | Returns                                                             | Use Case                                                                                  |
+| -------------------------------------------- | ------------------------------------------------------------------- | ----------------------------------------------------------------------------------------- |
+| `getPlugin(metadataFilePath)`                | `PluginInfo \| null`                                                | Resolve a metadata file path to its registered plugin (returns `id`, `displayName`, etc.) |
+| `visualizeMetadata(pluginId)`                | `{ bundle: HttpAsset<string> \| null, error: PluginError \| null }` | Generate a fully self-contained HTML shell for the plugin's UI (no parsing — UI only)     |
+| `getParsedMetadata(metadataFilePath)`        | `VisualizeOutcome` — `{ result, error }`                            | Parse metadata and return structured data without generating HTML                         |
+| `getUpdatedParsedMetadata(metadataFilePath)` | `{ error, pluginDataUpdateMessage }`                                | Generate update message for posting to existing plugin iframe (live updates)              |
+| `dispose()`                                  | `void`                                                              | Release all resources (call on shutdown)                                                  |
+
+### Method Details
+
+**Two-step flow.** UI generation and metadata parsing are separate calls. `visualizeMetadata` produces the static plugin UI shell (no file I/O, no parsing); the loaded iframe then requests parsed data via `postMessage`, which the host serves from `getParsedMetadata`. Use `getPlugin(filePath)` to resolve a metadata file to its plugin ID before calling `visualizeMetadata`.
+
+**`getPlugin(metadataFilePath)`** — Resolve plugin for a file:
+
+- Matches the file path against registered plugin file patterns
+- Returns `PluginInfo` (with `id`) on match, `null` otherwise
+- Synchronous and side-effect-free
+
+**`visualizeMetadata(pluginId)`** — Generate UI shell:
+
+- Returns fully self-contained HTML with all assets (JS, CSS, platform styles) inlined
+- **No metadata parsing occurs** — this generates the static plugin UI only
+- Zero additional HTTP requests needed
+- Perfect for iframe embedding: `<iframe srcdoc="..."></iframe>`
+- The loaded plugin iframe requests its data separately via postMessage
+- Error handling: Check `error` field first, then use `bundle`
+
+**`getParsedMetadata(metadataFilePath)`** — Parse metadata only:
+
+- Returns parsed metadata as structured data
+- Use for REST endpoints, data analysis, validation, and as the data source for plugin postMessage requests
+- No HTML generation overhead
+
+**`getUpdatedParsedMetadata(metadataFilePath)`** — Live updates:
+
+- Parses file and generates `PluginDataUpdateMessage` ready for iframe postMessage
+- Use with file watchers to push updates to already-loaded visualizations
+- Plugins listen via `onDataUpdate` from `HostCommunicationUtils`
+
+---
+
+## Integration walkthrough
+
+This section explains how a web host integrates the SDK end-to-end. The actual route plumbing depends on your framework conventions (Express, Fastify, etc.). The shape below shows the integration pattern at the seams.
+
+### Step 1 — Implement `IFileSystem`
+
+The host writes a single class that wraps its existing file I/O layer. Each method delegates to your existing file operations. The class is constructed per request, bound to that request's project root.
+
+```ts
+// Host implementation — sketch only
+class MyHostFileSystem implements IFileSystem {
+  constructor(private readonly projectDir: string) {}
+  // readFile, findFiles, exists, getMetadata, readDirectory →
+  //     delegate to your file service
+  // pure-string helpers (basename, join, etc.) → delegate to node:path
+  // getWorkspaceRoot() → return this.projectDir
+}
+```
+
+### Step 2 — Construct the engine per request
+
+For each incoming HTTP request that needs visualization:
+
+```ts
+const fileSystem = new MyHostFileSystem(projectDir);
+const engine = await createWebVisualizationEngine({ fileSystem });
+// Use the engine, then dispose when the request ends.
+```
+
+Per-request construction is acceptable for prototypes because plugin loading is cheap. Production hosts can cache engines per project if profiling shows it matters.
+
+### Step 3 — Wire HTTP routes
+
+The host adds visualizer routes to its service using the five core `WebVisualizationEngine` methods:
+
+#### Route 1: Generate HTML Bundle
+
+```ts
+app.post('/visualizer/bundle', async (req, res) => {
+  const { filePath } = req.body;
+
+  // Resolve file → plugin first; visualizeMetadata takes a pluginId, not a path.
+  const pluginInfo = engine.getPlugin(filePath);
+  if (!pluginInfo) {
+    return res.status(415).json({ error: 'No plugin found for this file type' });
+  }
+
+  const { bundle, error } = await engine.visualizeMetadata(pluginInfo.id);
+
+  if (error) {
+    const status = error.category === 'Configuration' ? 415 : 500;
+    return res.status(status).json({
+      error: error.message,
+      category: error.category,
+      context: error.context,
+    });
+  }
+
+  res.type(bundle.contentType).set('Cache-Control', bundle.cacheControl).send(bundle.body);
+});
+```
+
+**Use case:** Generate the plugin UI shell for iframe embedding. Returns fully self-contained HTML with all assets inlined. Note: this generates the UI only — the loaded iframe requests parsed metadata separately via postMessage, served by the parse route below.
+
+#### Route 2: Parse Metadata
+
+```ts
+app.post('/visualizer/parse', async (req, res) => {
+  const { filePath } = req.body;
+  const outcome = await engine.getParsedMetadata(filePath);
+
+  if (outcome.error) {
+    return res.status(500).json({
+      error: outcome.error.message,
+      category: outcome.error.category,
+    });
+  }
+
+  res.json({
+    data: outcome.result.data,
+    metadata: outcome.result.metadata,
+    filePath: outcome.result.filePath,
+  });
+});
+```
+
+**Use case:** Data-only endpoint. Plugins request this via postMessage; useful for validation, analysis, and structured data access.
+
+#### Route 3: Live Updates
+
+```ts
+app.post('/visualizer/update', async (req, res) => {
+  const { filePath } = req.body;
+  const { error, pluginDataUpdateMessage } = await engine.getUpdatedParsedMetadata(filePath);
+
+  if (error) {
+    return res.status(500).json({ error: error.message });
+  }
+
+  // Return message for host to post to iframe
+  res.json({ updateMessage: pluginDataUpdateMessage, success: true });
+});
+
+// File watcher integration (server-side)
+fileWatcher.on('change', async (filePath) => {
+  const { pluginDataUpdateMessage } = await engine.getUpdatedParsedMetadata(filePath);
+  if (pluginDataUpdateMessage) {
+    // Send to connected clients via WebSocket
+    wss.clients.forEach((client) => {
+      client.send(JSON.stringify(pluginDataUpdateMessage));
+    });
+  }
+});
+```
+
+**Use case:** Push updates to already-loaded iframe when file content changes. Plugins listen via `onDataUpdate`:
+
+```tsx
+import { onDataUpdate } from '@salesforce/metadata-core-sdk/utils/HostCommunicationUtils';
+
+useEffect(() => {
+  const unsubscribe = onDataUpdate((freshData) => {
+    setData(freshData); // Re-render with updated data
+  });
+  return unsubscribe;
+}, []);
+```
+
+### Step 4 — Wire the browser side
+
+The host's UI mounts an `<iframe>` whose `src` is the bundle URL above. Because the iframe is same-origin (everything served from your domain), the bootstrap script the SDK injected can `postMessage` cleanly to the parent window. The parent UI listens for those messages and proxies `REQUEST_PLUGIN_DATA` back to the parse endpoint, then posts `PLUGIN_DATA_RESPONSE` back into the iframe.
+
+This relay logic lives entirely on the host's side. The package gives the iframe a working `__ExtensionHostPostMessage` and an HTML document; the host decides what listens to those messages on the parent.
+
+---
+
+## Architecture rules enforced by tests
+
+The SDK has two strict architectural rules — both checked at test time:
+
+1. **No runtime dependency on `@salesforce/metadata-plugins`.** Plugin React builds are bundled into the SDK's own `dist/plugins/` at build time via `scripts/copy-plugin-assets.mjs` — same pattern the VS Code adapter uses with webpack `CopyPlugin`. The plugins package is referenced only at the workspace root's `devDependencies`. Consumers' `npm install` never pulls plugins in directly.
+2. **No `vscode` import.** This is a browser-host SDK; VS Code-flavored code stays in `visualizer-vscode-ext`.
+
+Both are enforced by `src/__tests__/architecture.test.ts`.
+
+---
+
+## Development
+
+```bash
+npm run build       # tsc + scripts/copy-plugin-assets.mjs (populates dist/plugins/, dist/design-system/)
+npm test            # jest with coverage
+npm run typecheck   # tsc --noEmit
+npm run lint
+```
+
+Build runs from the workspace root — `@salesforce/metadata-plugins` lives in the root's `devDependencies` and the build script resolves it from there. Building the package outside the workspace is not supported.
+
+## Public API summary
+
+### Core Class
+
+- `WebVisualizationEngine` — Main class with five methods:
+  - `getPlugin(metadataFilePath)` — Resolve a file path to its registered plugin
+  - `visualizeMetadata(pluginId)` — Generate the plugin UI shell (HTML bundle, no parsing)
+  - `getParsedMetadata(metadataFilePath)` — Parse metadata only
+  - `getUpdatedParsedMetadata(metadataFilePath)` — Generate update message for live updates
+  - `dispose()` — Release resources
+- `createWebVisualizationEngine(opts)` — Async factory function
+
+### Supporting Types
+
+- `HttpAsset<T>` — Response wrapper: `{ contentType, body, cacheControl }`
+- `PluginInfo` — Plugin metadata: `{ id, displayName, filePatterns, priority? }`
+- `VisualizeOutcome` — Parse result: `{ result, error }`. The `error` field is a `PluginError` from `@salesforce/metadata-core-sdk`.
+- `PluginDataUpdateMessage<T = unknown>` — Update message for postMessage: `{ type: 'PLUGIN_DATA_UPDATE', payload: PluginDataResponse<T> }`. Generic `T` lets plugin code with a known data shape opt into type-safety; consumers can narrow on `message.type` in a discriminated-union switch.
+- `WebAdapterOptions` — Engine constructor options: `{ fileSystem, telemetry? }`
+
+## License
+
+BSD-3-Clause.

package/dist/WebVisualizationEngine.d.ts

@@ -0,0 +1,165 @@
+/**
+ * Copyright (c) 2025, Salesforce, Inc.
+ * All rights reserved.
+ * Licensed under the BSD 3-Clause license.
+ * For full license text, see LICENSE.txt file in the repo root or https://opensource.org/licenses/BSD-3-Clause
+ **/
+import type { PluginError } from '@salesforce/metadata-core-sdk';
+import type { PluginManager, VisualizationEngine } from '@salesforce/metadata-visualizer-core';
+import { BundledPluginAssetReader } from './pluginAssets/BundledPluginAssetReader.js';
+import type { HttpAsset } from './types/HttpAsset.js';
+import type { PluginInfo } from './types/PluginInfo.js';
+import type { VisualizeOutcome } from './types/VisualizeOutcome.js';
+import type { PluginDataUpdateMessage } from './types/PluginDataUpdateMessage.js';
+/**
+ * Internal construction parameters used by the factory. Not part of the
+ * public API — consumers always go through `createWebVisualizationEngine`.
+ *
+ * @internal
+ */
+export interface WebVisualizationEngineDeps {
+    framework: VisualizationEngine;
+    pluginManager: PluginManager;
+    pluginAssetReader: BundledPluginAssetReader;
+}
+/**
+ * Browser/HTTP platform adapter for the visualization framework.
+ * Provides methods to generate self-contained HTML bundles and parse metadata
+ * for embedding in iframes. All methods are safe to call concurrently.
+ */
+export declare class WebVisualizationEngine {
+    private readonly framework;
+    private readonly pluginManager;
+    private readonly assetReader;
+    /** Tracks whether dispose() has been called to prevent use-after-dispose */
+    private disposed;
+    /** Per-file monotonic counter for fileId. Date.now() collides under sub-ms concurrent calls. */
+    private readonly fileIdCounters;
+    /**
+     * Construct an engine.
+     *
+     * **Use `createWebVisualizationEngine()` instead.** This constructor is exposed
+     * only for the factory and internal tests, and it asserts an ownership contract
+     * that is easy to misuse:
+     *
+     * - The injected `framework` (and its `ErrorManager`) is **owned** by the
+     *   resulting engine. Calling `dispose()` tears it down — including any error
+     *   listeners registered by other code on the same instance.
+     * - Therefore the framework must be dedicated to this engine. Sharing one
+     *   `VisualizationEngine` between a `WebVisualizationEngine` and another
+     *   adapter (e.g. the VS Code adapter) will break the other adapter when this
+     *   engine is disposed.
+     *
+     * @internal
+     */
+    constructor(deps: WebVisualizationEngineDeps);
+    /**
+     * Generate a complete HTML bundle for a plugin's visualization UI.
+     * Returns a self-contained HTML file with all assets (JS, CSS, platform styles) inlined,
+     * ready to be embedded in an iframe. No metadata parsing occurs — this generates the static UI shell.
+     *
+     * @param pluginId - ID of the registered plugin to generate bundle for
+     * @returns Object containing the bundle (null if failed) and error (null if successful)
+     *
+     * @example
+     * ```typescript
+     * const { bundle, error } = await engine.visualizeMetadata('flexipage-visualizer');
+     * if (error) {
+     *   console.error('Bundle generation failed:', error.message);
+     *   res.status(error.category === 'Configuration' ? 404 : 500).json({ error: error.message });
+     * } else if (bundle) {
+     *   res.type(bundle.contentType).send(bundle.body);
+     * }
+     * ```
+     */
+    visualizeMetadata(pluginId: string): Promise<{
+        bundle: HttpAsset<string> | null;
+        error: PluginError | null;
+    }>;
+    /**
+     * Parse a metadata file and return the visualization outcome.
+     * Finds the appropriate plugin by file pattern, parses the file, and returns structured data.
+     * Handles error capturing for concurrent-safe execution (multiple calls won't interfere).
+     *
+     * @param metadataFilePath - Path to the metadata file to parse
+     * @returns VisualizeOutcome containing either parsed result or error
+     *
+     * @example
+     * ```typescript
+     * const outcome = await engine.getParsedMetadata('force-app/main/default/flexipages/Home.flexipage');
+     * if (outcome.error) {
+     *   console.error('Parse failed:', outcome.error.message);
+     * } else {
+     *   console.log('Parsed data:', outcome.result.data);
+     * }
+     * ```
+     */
+    getParsedMetadata(metadataFilePath: string): Promise<VisualizeOutcome>;
+    /**
+     * Parse metadata and generate an update message for posting to an existing plugin iframe.
+     * Use this when file content changes and you need to push updates to a loaded iframe
+     * without regenerating the entire bundle. Plugins receive updates via onDataUpdate().
+     *
+     * @param metadataFilePath - Path to the metadata file to parse
+     * @returns Object containing error (if any) and pluginDataUpdateMessage (null if parsing failed)
+     *
+     * @example
+     * ```typescript
+     * // File watcher integration
+     * watcher.on('change', async (filePath) => {
+     *   const { error, pluginDataUpdateMessage } = await engine.getUpdatedParsedMetadata(filePath);
+     *   if (pluginDataUpdateMessage) {
+     *     iframeWindow.postMessage(pluginDataUpdateMessage, '*');
+     *   }
+     * });
+     * ```
+     */
+    getUpdatedParsedMetadata(metadataFilePath: string): Promise<{
+        error: PluginError | null;
+        pluginDataUpdateMessage: PluginDataUpdateMessage | null;
+    }>;
+    /**
+     * Release all resources held by the engine.
+     * After calling this method, the engine instance should not be used.
+     * Safe to call multiple times (idempotent).
+     *
+     * **Disposes the underlying framework.** The engine takes ownership of the
+     * `VisualizationEngine` passed to its constructor (or built by the factory),
+     * including its `ErrorManager`. Do not share that framework with another
+     * adapter — it will be torn down here.
+     *
+     * @example
+     * ```typescript
+     * process.on('SIGTERM', () => {
+     *   engine.dispose();
+     *   process.exit(0);
+     * });
+     * ```
+     */
+    dispose(): void;
+    /**
+     * Create a PLUGIN_DATA_UPDATE message for posting to a loaded plugin iframe.
+     * Per-file monotonic counter guarantees a unique, ordered fileId per update,
+     * even under sub-millisecond concurrent calls (Date.now() can collide).
+     *
+     * @param outcome - Visualization outcome with parsed data
+     * @returns Message ready to be posted via iframe.contentWindow.postMessage(), or null if parsing failed
+     */
+    private createDataUpdateMessage;
+    /**
+     * Find the registered plugin that handles a given file.
+     * Matches file against plugin patterns (e.g., *.flexipage, *.object, *-meta.xml).
+     *
+     * @param metadataFile - Filename (e.g., 'Home.flexipage') or full path to match
+     * @returns PluginInfo if a matching plugin is found, null otherwise
+     */
+    getPlugin(metadataFile: string): PluginInfo | null;
+    /**
+     * Verify a plugin is registered before attempting to use it.
+     * Prevents asset read failures for non-existent plugins.
+     */
+    private requireKnownPlugin;
+    /** Guards against use-after-dispose by throwing an error */
+    private assertNotDisposed;
+}
+//# sourceMappingURL=WebVisualizationEngine.d.ts.map

package/dist/WebVisualizationEngine.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"WebVisualizationEngine.d.ts","sourceRoot":"","sources":["../src/WebVisualizationEngine.ts"],"names":[],"mappings":"AAAA;;;;;IAKI;AAEJ,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,+BAA+B,CAAC;AAEjE,OAAO,KAAK,EAAE,aAAa,EAAE,mBAAmB,EAAE,MAAM,sCAAsC,CAAC;AAI/F,OAAO,EAAE,wBAAwB,EAAE,MAAM,4CAA4C,CAAC;AACtF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,sBAAsB,CAAC;AACtD,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,uBAAuB,CAAC;AACxD,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,oCAAoC,CAAC;AAElF;;;;;GAKG;AACH,MAAM,WAAW,0BAA0B;IACzC,SAAS,EAAE,mBAAmB,CAAC;IAC/B,aAAa,EAAE,aAAa,CAAC;IAC7B,iBAAiB,EAAE,wBAAwB,CAAC;CAC7C;AAED;;;;GAIG;AACH,qBAAa,sBAAsB;IACjC,OAAO,CAAC,QAAQ,CAAC,SAAS,CAAsB;IAChD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA2B;IACvD,4EAA4E;IAC5E,OAAO,CAAC,QAAQ,CAAS;IACzB,gGAAgG;IAChG,OAAO,CAAC,QAAQ,CAAC,cAAc,CAA6B;IAE5D;;;;;;;;;;;;;;;;OAgBG;gBACS,IAAI,EAAE,0BAA0B;IAM5C;;;;;;;;;;;;;;;;;;OAkBG;IACG,iBAAiB,CAAC,QAAQ,EAAE,MAAM,GAAG,OAAO,CAAC;QACjD,MAAM,EAAE,SAAS,CAAC,MAAM,CAAC,GAAG,IAAI,CAAC;QACjC,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;KAC3B,CAAC;IA0DF;;;;;;;;;;;;;;;;;OAiBG;IACG,iBAAiB,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAyC5E;;;;;;;;;;;;;;;;;;OAkBG;IACG,wBAAwB,CAAC,gBAAgB,EAAE,MAAM,GAAG,OAAO,CAAC;QAChE,KAAK,EAAE,WAAW,GAAG,IAAI,CAAC;QAC1B,uBAAuB,EAAE,uBAAuB,GAAG,IAAI,CAAC;KACzD,CAAC;IASF;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,IAAI,IAAI;IAUf;;;;;;;OAOG;IACH,OAAO,CAAC,uBAAuB;IAsB/B;;;;;;OAMG;IACH,SAAS,CAAC,YAAY,EAAE,MAAM,GAAG,UAAU,GAAG,IAAI;IAKlD;;;OAGG;IACH,OAAO,CAAC,kBAAkB;IAI1B,4DAA4D;IAC5D,OAAO,CAAC,iBAAiB;CAK1B"}