npm - vite-ember-ssr - Versions diffs - 0.1.0-alpha.0 - Mend

vite-ember-ssr 0.1.0-alpha.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (18) hide show

package/LICENSE.md ADDED Viewed

@@ -0,0 +1,7 @@
+Copyright © 2026 Liam Potter
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md ADDED Viewed

@@ -0,0 +1,203 @@
+# vite-ember-ssr
+> [!WARNING]
+> **EXPERIMENTAL** — This project is in early development and targets **compatless** Ember apps only (no `@embroider/compat`, no `ember-cli-build.js`, no `classicEmberSupport()`). APIs will change. Do not use in production.
+Vite plugin and SSR runtime for Ember.js applications. Uses [HappyDOM](https://github.com/capricorn86/happy-dom) for server-side rendering — no FastBoot, no VM sandbox.
+See the Installation and Setup sections below for installation and copy‑paste integration snippets.
+## Architecture
+- **HappyDOM Window** provides a full per-request browser-like environment. Ember runs directly in the Node.js process with globals swapped per request.
+- **`Application.visit(url)`** drives the entire render cycle server-side.
+- **No hydration yet** — the client boots normally and replaces SSR content. SSR provides the initial visual while JS loads.
+- **Shoebox** — fetch responses captured during SSR are serialized into the HTML and replayed on the client to avoid duplicate API requests.
+## Requirements
+- Ember app built with Embroider in "compatless" mode (no `@embroider/compat`, no `ember-cli-build.js`, and no `classicEmberSupport()`).
+- Your app's `config/environment` must be a direct ES module import (i.e. `import config from './config/environment.ts'`). Do not rely on `<meta>` config injection or `@embroider/config-meta-loader`.
+- Vite 6+
+- Node 22+
+## Installation
+```sh
+pnpm add -D vite-ember-ssr
+```
+## Setup
+### 1. Vite config
+```js
+// vite.config.mjs
+import { defineConfig } from 'vite';
+import { extensions, ember } from '@embroider/vite';
+import { babel } from '@rollup/plugin-babel';
+import { emberSsr } from 'vite-ember-ssr/vite-plugin';
+export default defineConfig({
+  plugins: [
+    ember(),
+    babel({ babelHelpers: 'runtime', extensions }),
+    emberSsr()
+  ],
+});
+```
+### 2. HTML template
+Add SSR markers to `index.html`:
+```html
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8" />
+    <!-- VITE_EMBER_SSR_HEAD -->
+  </head>
+  <body>
+    <!-- VITE_EMBER_SSR_BODY -->
+    <script type="module" src="/app/entry.ts"></script>
+  </body>
+</html>
+```
+### 3. SSR entry (`app/app-ssr.ts`)
+Export a factory that creates the Ember app with `autoboot: false`:
+```ts
+import EmberApp from 'ember-strict-application-resolver';
+import config from './config/environment.ts';
+import Router from './router.ts';
+class App extends EmberApp {
+  modulePrefix = config.modulePrefix;
+  modules = {
+    './router': Router,
+    ...import.meta.glob('./{routes,templates}/**/*.{ts,gts}', { eager: true }),
+    ...import.meta.glob('./services/*.ts', { eager: true }),
+  };
+}
+export function createSsrApp() {
+  return App.create({ ...config.APP, autoboot: false });
+}
+Notes:
+- Place this file in your application package at `app/app-ssr.ts` (the SSR build references that path in examples).
+- `autoboot: false` prevents the Ember application from attempting to boot itself in the server environment; instead we call `Application.visit(url)` to drive rendering.
+- The `modules` map uses `import.meta.glob(..., { eager: true })` to provide the resolver with preloaded route/template/service modules — this mirrors how Embroider/Ember apps load modules at runtime in a static environment.
+- Keep the glob patterns broad enough to include your `routes`, `templates`, and `services` so the resolver can find everything the app needs during SSR.
+```
+### 4. Client entry (`app/entry.ts`)
+```ts
+import Application from './app.ts';
+import config from './config/environment.ts';
+import { installShoebox, cleanupSSRContent } from 'vite-ember-ssr/client';
+installShoebox();
+cleanupSSRContent();
+Application.create(config.APP);
+```
+### 5. Build
+```sh
+vite build                      # client → dist/client
+vite build --ssr app/app-ssr.ts # server → dist/server
+```
+### 6. Server
+Wire up `render()` in your server's catch-all route. See [examples/fastify.md](https://github.com/evoactivity/vite-ember-ssr/blob/main/examples/fastify.md) for a complete Fastify example with dev and production modes.
+Shoebox (fetch replay):
+- Pass `shoebox: true` to `render()` to capture `fetch` responses during SSR and serialize them into the rendered HTML. On the client call `installShoebox()` before boot to replay those responses and avoid duplicate requests.
+- Default: shoebox is opt-in. Use it when your app makes server-side fetch calls that the client would otherwise repeat on first load.
+- Caveats: embedding large API responses increases HTML size; do not serialize sensitive data into the shoebox.
+## API
+### `vite-ember-ssr/vite-plugin`
+```js
+import { emberSsr } from 'vite-ember-ssr/vite-plugin';
+```
+Single Vite plugin. Handles all SSR-related configuration:
+- `ssr.noExternal` for Ember ecosystem packages
+- Build output directories (`dist/client` and `dist/server`)
+- SSR build defaults (`target: 'node22'`, `sourcemap: true`, `minify: false`)
+- Writes `{"type": "module"}` to SSR output directory
+Options:
+```js
+emberSsr({
+  clientOutDir: 'dist/client', // default
+  serverOutDir: 'dist/server', // default
+  additionalNoExternal: ['my-addon'], // extend built-in patterns
+});
+```
+### `vite-ember-ssr/server`
+```js
+import { render } from 'vite-ember-ssr/server';
+```
+- **`render({ url, template, createApp, shoebox? })`** — render an Ember app and assemble the final HTML. Returns `{ html, statusCode, error }`.
+Lower-level functions are also exported for advanced use:
+- **`renderEmberApp({ url, createApp, shoebox? })`** — render only, returns `{ head, body, statusCode, error }`.
+- **`assembleHTML(template, renderResult)`** — replace SSR markers in the HTML template.
+### `vite-ember-ssr/client`
+```js
+import { installShoebox, cleanupSSRContent, cleanupShoebox, isSSRRendered } from 'vite-ember-ssr/client';
+```
+- **`installShoebox()`** — replay server-captured fetch responses, auto-restores `fetch` when all entries consumed.
+- **`cleanupSSRContent()`** — remove SSR-rendered DOM nodes before client Ember boots.
+- **`cleanupShoebox()`** — manually restore original `fetch`.
+- **`isSSRRendered()`** — returns `true` if SSR boundary markers are present in the DOM. Useful for conditionally running client-side setup that should only happen on SSR-rendered pages.
+## Monorepo development
+This repo contains three packages:
+| Package                   | Description                      |
+| ------------------------- | -------------------------------- |
+| `packages/vite-ember-ssr` | Core library                     |
+| `packages/test-app`       | Ember test app                   |
+| `packages/test-server`    | Fastify SSR server + test suites |
+```sh
+pnpm install
+pnpm dev          # dev server (Fastify + Vite middleware)
+pnpm build        # build library + test app
+pnpm demo         # build everything, start production server
+pnpm test         # vitest SSR tests
+pnpm test:browser # playwright browser tests
+pnpm test:all     # both
+```
+## Performance
+- Server startup: ~1s (no ember-cli build step)
+- First SSR render: ~3s (cold module loading)
+- Warm SSR render: ~24ms
+## License
+MIT

package/dist/client.d.ts ADDED Viewed

@@ -0,0 +1,53 @@
+/**
+ * Client-side utilities for vite-ember-ssr.
+ *
+ * Currently the client Ember app boots normally and replaces the
+ * SSR-rendered content. True DOM hydration is planned for a future
+ * phase.
+ *
+ * For now, the SSR content provides the initial visual while client
+ * JavaScript loads, parses, and Ember boots.
+ */
+/**
+ * Installs the shoebox fetch interceptor on the client.
+ *
+ * Reads the shoebox data from the server-injected <script> tag,
+ * removes the tag from the DOM, and monkey-patches globalThis.fetch
+ * to serve cached responses for URLs that match shoebox entries.
+ *
+ * Each entry is reference-counted: concurrent fetch calls to the same
+ * URL all receive the shoebox response. The entry is removed only when
+ * the last concurrent consumer has been served.
+ *
+ * Call this BEFORE creating the Ember application, typically as the
+ * first thing in your client entry point.
+ *
+ * @returns true if shoebox data was found and installed, false otherwise
+ */
+export declare function installShoebox(): boolean;
+/**
+ * Restores the original fetch function and cleans up shoebox state.
+ *
+ * Called automatically when all shoebox entries have been consumed,
+ * or can be called manually to force cleanup.
+ */
+export declare function cleanupShoebox(): void;
+/**
+ * Removes the SSR-rendered content from the DOM before the client
+ * Ember app boots. This prevents the "double render" where both the
+ * server-rendered HTML and the client-rendered HTML are visible.
+ *
+ * Removes everything between (and including) the SSR boundary markers:
+ *   <script type="x/boundary" id="ssr-body-start">
+ *   ...server rendered content...
+ *   <script type="x/boundary" id="ssr-body-end">
+ *
+ * Call this in your client entry point BEFORE creating the Ember app.
+ */
+export declare function cleanupSSRContent(): void;
+/**
+ * Checks if the current page was server-side rendered by looking
+ * for SSR boundary markers in the DOM.
+ */
+export declare function isSSRRendered(): boolean;
+//# sourceMappingURL=client.d.ts.map

package/dist/client.d.ts.map ADDED Viewed

	@@ -0,0 +1 @@
1	+ {"version":3,"file":"client.d.ts","sourceRoot":"","sources":["../src/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AA0BH;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,cAAc,IAAI,OAAO,CAsFxC;AAED;;;;;GAKG;AACH,wBAAgB,cAAc,IAAI,IAAI,CAMrC;AAID;;;;;;;;;;;GAWG;AACH,wBAAgB,iBAAiB,IAAI,IAAI,CAmBxC;AAED;;;GAGG;AACH,wBAAgB,aAAa,IAAI,OAAO,CAEvC"}

package/dist/client.js ADDED Viewed

@@ -0,0 +1,161 @@
+/**
+ * Client-side utilities for vite-ember-ssr.
+ *
+ * Currently the client Ember app boots normally and replaces the
+ * SSR-rendered content. True DOM hydration is planned for a future
+ * phase.
+ *
+ * For now, the SSR content provides the initial visual while client
+ * JavaScript loads, parses, and Ember boots.
+ */
+const SHOEBOX_SCRIPT_ID = 'vite-ember-ssr-shoebox';
+// ─── Shoebox: Client-Side Fetch Replay ───────────────────────────────
+/** Original fetch function, saved before monkey-patching */
+let _originalFetch = null;
+/** Map of URL → { entry, refCount } for reference-counted consumption */
+let _shoeboxMap = null;
+/**
+ * Installs the shoebox fetch interceptor on the client.
+ *
+ * Reads the shoebox data from the server-injected <script> tag,
+ * removes the tag from the DOM, and monkey-patches globalThis.fetch
+ * to serve cached responses for URLs that match shoebox entries.
+ *
+ * Each entry is reference-counted: concurrent fetch calls to the same
+ * URL all receive the shoebox response. The entry is removed only when
+ * the last concurrent consumer has been served.
+ *
+ * Call this BEFORE creating the Ember application, typically as the
+ * first thing in your client entry point.
+ *
+ * @returns true if shoebox data was found and installed, false otherwise
+ */
+export function installShoebox() {
+    const scriptEl = document.getElementById(SHOEBOX_SCRIPT_ID);
+    if (!scriptEl) {
+        return false;
+    }
+    // Parse the shoebox data
+    let entries;
+    try {
+        entries = JSON.parse(scriptEl.textContent ?? '[]');
+    }
+    catch {
+        // Malformed shoebox data — skip
+        scriptEl.remove();
+        return false;
+    }
+    // Remove the script tag from the DOM
+    scriptEl.remove();
+    if (entries.length === 0) {
+        return false;
+    }
+    // Build the lookup map with ref counts
+    _shoeboxMap = new Map();
+    for (const entry of entries) {
+        _shoeboxMap.set(entry.url, { entry, refCount: 1 });
+    }
+    // Save the original fetch and install our interceptor
+    _originalFetch = globalThis.fetch;
+    globalThis.fetch = function shoeboxFetch(input, init) {
+        // Only intercept GET requests (or requests with no method, which default to GET)
+        const method = init?.method?.toUpperCase() ?? 'GET';
+        if (method !== 'GET' || !_shoeboxMap || _shoeboxMap.size === 0) {
+            return _originalFetch(input, init);
+        }
+        // Resolve the URL string for matching
+        let url;
+        try {
+            if (typeof input === 'string') {
+                url = new URL(input, globalThis.location?.href).href;
+            }
+            else if (input instanceof URL) {
+                url = input.href;
+            }
+            else if (input instanceof Request) {
+                url = input.url;
+            }
+            else {
+                return _originalFetch(input, init);
+            }
+        }
+        catch {
+            return _originalFetch(input, init);
+        }
+        const cached = _shoeboxMap.get(url);
+        if (!cached) {
+            return _originalFetch(input, init);
+        }
+        // Decrement ref count and remove if exhausted
+        cached.refCount--;
+        if (cached.refCount <= 0) {
+            _shoeboxMap.delete(url);
+        }
+        // Construct a Response from the cached data
+        const { entry } = cached;
+        const response = new Response(entry.body, {
+            status: entry.status,
+            statusText: entry.statusText,
+            headers: new Headers(entry.headers),
+        });
+        // Auto-cleanup when the map is empty
+        if (_shoeboxMap.size === 0) {
+            cleanupShoebox();
+        }
+        return Promise.resolve(response);
+    };
+    return true;
+}
+/**
+ * Restores the original fetch function and cleans up shoebox state.
+ *
+ * Called automatically when all shoebox entries have been consumed,
+ * or can be called manually to force cleanup.
+ */
+export function cleanupShoebox() {
+    if (_originalFetch) {
+        globalThis.fetch = _originalFetch;
+        _originalFetch = null;
+    }
+    _shoeboxMap = null;
+}
+// ─── SSR Content Cleanup ─────────────────────────────────────────────
+/**
+ * Removes the SSR-rendered content from the DOM before the client
+ * Ember app boots. This prevents the "double render" where both the
+ * server-rendered HTML and the client-rendered HTML are visible.
+ *
+ * Removes everything between (and including) the SSR boundary markers:
+ *   <script type="x/boundary" id="ssr-body-start">
+ *   ...server rendered content...
+ *   <script type="x/boundary" id="ssr-body-end">
+ *
+ * Call this in your client entry point BEFORE creating the Ember app.
+ */
+export function cleanupSSRContent() {
+    const start = document.getElementById('ssr-body-start');
+    const end = document.getElementById('ssr-body-end');
+    if (!start || !end) {
+        return; // Not an SSR-rendered page
+    }
+    // Remove all nodes between start and end markers (inclusive)
+    const parent = start.parentNode;
+    if (!parent)
+        return;
+    let node = start;
+    while (node) {
+        const next = node.nextSibling;
+        parent.removeChild(node);
+        if (node === end)
+            break;
+        node = next;
+    }
+}
+/**
+ * Checks if the current page was server-side rendered by looking
+ * for SSR boundary markers in the DOM.
+ */
+export function isSSRRendered() {
+    return document.getElementById('ssr-body-start') !== null;
+}
+//# sourceMappingURL=client.js.map

package/dist/client.js.map ADDED Viewed

@@ -0,0 +1 @@

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

package/dist/server.d.ts ADDED Viewed

@@ -0,0 +1,128 @@
+/**
+ * Minimal interface for an Ember Application that supports SSR.
+ *
+ * The app must be created with `autoboot: false` so the server can
+ * control boot timing via `app.visit(url, options)`.
+ *
+ * `visit()` handles the full boot sequence internally:
+ *   app.boot() → app.buildInstance() → instance.boot(options) → instance.visit(url)
+ * and returns a Promise<ApplicationInstance>.
+ */
+export interface EmberApplication {
+    visit(url: string, options?: BootOptions): Promise<EmberApplicationInstance>;
+    destroy(): void;
+}
+export interface EmberApplicationInstance {
+    destroy(): void;
+    getURL?(): string;
+    _booted?: boolean;
+}
+export interface BootOptions {
+    /** When false, disables browser-specific features like event delegation. */
+    isBrowser: boolean;
+    /** The document to render into. For SSR, this is the HappyDOM document. */
+    document: Document;
+    /** The root DOM element for the Ember app. Typically document.body. */
+    rootElement: Element;
+    /** Whether Ember should render templates. Set to true for SSR. */
+    shouldRender: boolean;
+    /** Override the router's location type. */
+    location?: string;
+}
+export interface RenderOptions {
+    /** The URL path to render, e.g., '/' or '/about' */
+    url: string;
+    /**
+     * Factory function that creates a fresh Ember Application instance.
+     * This should be the `createSsrApp` export from the Ember app.
+     */
+    createApp: () => EmberApplication;
+    /**
+     * When true, intercepts all fetch() calls during SSR rendering and
+     * serializes the responses into a <script> tag in the HTML output.
+     * The client can then replay these responses to avoid double-fetching.
+     */
+    shoebox?: boolean;
+}
+export interface RenderResult {
+    /** Rendered HTML from the document's <head> */
+    head: string;
+    /** Rendered HTML from the document's <body>, wrapped in boundary markers */
+    body: string;
+    /** HTTP status code (200 by default) */
+    statusCode: number;
+    /** Any error that occurred during rendering */
+    error?: Error;
+}
+/**
+ * A captured fetch response for transfer from server to client.
+ */
+export interface ShoeboxEntry {
+    /** The request URL */
+    url: string;
+    /** HTTP status code */
+    status: number;
+    /** HTTP status text */
+    statusText: string;
+    /** Response headers (serializable subset) */
+    headers: Record<string, string>;
+    /** Response body as text */
+    body: string;
+}
+/**
+ * Renders an Ember application at the given URL using HappyDOM.
+ *
+ * This is the main SSR entry point. It:
+ * 1. Creates an isolated HappyDOM Window
+ * 2. Temporarily installs browser globals from HappyDOM
+ * 3. Creates the Ember app and calls visit()
+ * 4. Extracts the rendered HTML
+ * 5. Cleans up all resources
+ *
+ * Each call creates a completely fresh environment — there is no
+ * shared state between requests.
+ */
+export declare function renderEmberApp(options: RenderOptions): Promise<RenderResult>;
+/**
+ * Assembles the final HTML response by inserting rendered content
+ * into the index.html template.
+ *
+ * Replaces:
+ * - `<!-- VITE_EMBER_SSR_HEAD -->` with the rendered head content
+ * - `<!-- VITE_EMBER_SSR_BODY -->` with the rendered body content
+ */
+export declare function assembleHTML(template: string, rendered: Pick<RenderResult, 'head' | 'body'>): string;
+/**
+ * Checks whether an HTML template contains the required SSR markers.
+ */
+export declare function hasSSRMarkers(html: string): {
+    head: boolean;
+    body: boolean;
+};
+export interface SSRResult {
+    /** Final HTML string with SSR content injected */
+    html: string;
+    /** HTTP status code (200 by default) */
+    statusCode: number;
+    /** Any error that occurred during rendering */
+    error?: Error;
+}
+/**
+ * Renders an Ember app at the given URL and assembles the final HTML
+ * in a single call. Combines `renderEmberApp` and `assembleHTML`.
+ *
+ * @example
+ * ```js
+ * const { html, statusCode, error } = await render({
+ *   url: '/about',
+ *   template,
+ *   createApp: createSsrApp,
+ *   shoebox: true,
+ * });
+ * reply.code(statusCode).type('text/html').send(html);
+ * ```
+ */
+export declare function render(options: RenderOptions & {
+    template: string;
+}): Promise<SSRResult>;
+//# sourceMappingURL=server.d.ts.map

package/dist/server.d.ts.map ADDED Viewed

@@ -0,0 +1 @@

+ {"version":3,"file":"server.d.ts","sourceRoot":"","sources":["../src/server.ts"],"names":[],"mappings":"AAQA;;;;;;;;;GASG;AACH,MAAM,WAAW,gBAAgB;IAC/B,KAAK,CAAC,GAAG,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,wBAAwB,CAAC,CAAC;IAC7E,OAAO,IAAI,IAAI,CAAC;CACjB;AAED,MAAM,WAAW,wBAAwB;IACvC,OAAO,IAAI,IAAI,CAAC;IAChB,MAAM,CAAC,IAAI,MAAM,CAAC;IAClB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,WAAW;IAC1B,4EAA4E;IAC5E,SAAS,EAAE,OAAO,CAAC;IACnB,2EAA2E;IAC3E,QAAQ,EAAE,QAAQ,CAAC;IACnB,uEAAuE;IACvE,WAAW,EAAE,OAAO,CAAC;IACrB,kEAAkE;IAClE,YAAY,EAAE,OAAO,CAAC;IACtB,2CAA2C;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAC;CACnB;AAED,MAAM,WAAW,aAAa;IAC5B,oDAAoD;IACpD,GAAG,EAAE,MAAM,CAAC;IAEZ;;;OAGG;IACH,SAAS,EAAE,MAAM,gBAAgB,CAAC;IAElC;;;;OAIG;IACH,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,YAAY;IAC3B,+CAA+C;IAC/C,IAAI,EAAE,MAAM,CAAC;IACb,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAID;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,sBAAsB;IACtB,GAAG,EAAE,MAAM,CAAC;IACZ,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,uBAAuB;IACvB,UAAU,EAAE,MAAM,CAAC;IACnB,6CAA6C;IAC7C,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IAChC,4BAA4B;IAC5B,IAAI,EAAE,MAAM,CAAC;CACd;AA2LD;;;;;;;;;;;;GAYG;AACH,wBAAsB,cAAc,CAAC,OAAO,EAAE,aAAa,GAAG,OAAO,CAAC,YAAY,CAAC,CAuFlF;AAID;;;;;;;GAOG;AACH,wBAAgB,YAAY,CAC1B,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,IAAI,CAAC,YAAY,EAAE,MAAM,GAAG,MAAM,CAAC,GAC5C,MAAM,CAeR;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAK5E;AAID,MAAM,WAAW,SAAS;IACxB,kDAAkD;IAClD,IAAI,EAAE,MAAM,CAAC;IACb,wCAAwC;IACxC,UAAU,EAAE,MAAM,CAAC;IACnB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,KAAK,CAAC;CACf;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAsB,MAAM,CAC1B,OAAO,EAAE,aAAa,GAAG;IAAE,QAAQ,EAAE,MAAM,CAAA;CAAE,GAC5C,OAAO,CAAC,SAAS,CAAC,CAUpB"}