@fluixi/start 0.1.0-alpha.43

package/dist/handler.js

@@ -0,0 +1,152 @@
+import { createServer as createHttpServer } from 'node:http';
+import { stat } from 'node:fs/promises';
+import { createReadStream } from 'node:fs';
+import { Readable } from 'node:stream';
+import { join, extname } from 'node:path';
+/**
+ * Compose a streamed HTML Response: flush `head` immediately (browser starts fetching
+ * assets while the server awaits data), then pipe the app `body` stream into the mount
+ * point, then `tail` (client script + closing tags). A render error after the head is
+ * flushed can only error the stream (status is already 200) — truncated HTML; callers
+ * should guard the pre-flush path for a real 500.
+ */
+export function streamDocument(head, body, tail) {
+    const enc = new TextEncoder();
+    const stream = new ReadableStream({
+        async start(controller) {
+            try {
+                controller.enqueue(enc.encode(head));
+                const reader = body.getReader();
+                for (;;) {
+                    const { done, value } = await reader.read();
+                    if (done)
+                        break;
+                    controller.enqueue(value);
+                }
+                controller.enqueue(enc.encode(tail));
+                controller.close();
+            }
+            catch (err) {
+                controller.error(err);
+            }
+        },
+    });
+    return new Response(stream, {
+        status: 200,
+        headers: { 'content-type': 'text/html; charset=utf-8' },
+    });
+}
+/** Wrap a render function as a fetch handler (Node/Bun/Deno/edge-portable). */
+export function createRequestHandler(render) {
+    return async (request) => {
+        const url = new URL(request.url);
+        try {
+            const html = await render(url.pathname + url.search, request);
+            return new Response(html, {
+                status: 200,
+                headers: { 'content-type': 'text/html; charset=utf-8' },
+            });
+        }
+        catch (e) {
+            return new Response(String(e?.stack || e), {
+                status: 500,
+                headers: { 'content-type': 'text/plain; charset=utf-8' },
+            });
+        }
+    };
+}
+// ─── Node bridge (the built-in "node adapter") ──────────────────────────────
+/** Build a Web `Request` from a Node `IncomingMessage`. */
+export function nodeToRequest(req) {
+    const host = req.headers.host ?? 'localhost';
+    const url = `http://${host}${req.url ?? '/'}`;
+    const headers = new Headers();
+    for (const [k, v] of Object.entries(req.headers)) {
+        if (Array.isArray(v))
+            v.forEach((x) => headers.append(k, x));
+        else if (v != null)
+            headers.set(k, v);
+    }
+    const method = req.method ?? 'GET';
+    const init = { method, headers };
+    if (method !== 'GET' && method !== 'HEAD') {
+        init.body = req; // Node readable — fine for undici/Node fetch
+        init.duplex = 'half';
+    }
+    return new Request(url, init);
+}
+/** Write a Web `Response` (string or streamed body) to a Node `ServerResponse`. */
+export async function sendResponse(res, response) {
+    res.statusCode = response.status;
+    response.headers.forEach((value, key) => res.setHeader(key, value));
+    const body = response.body;
+    if (!body) {
+        res.end(await response.text().catch(() => ''));
+        return;
+    }
+    const reader = body.getReader();
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            res.write(value);
+        }
+    }
+    finally {
+        res.end();
+    }
+}
+/** Adapt a `FetchHandler` to a Node `(req, res)` handler. */
+export function toNodeHandler(handler) {
+    return async (req, res) => {
+        const response = await handler(nodeToRequest(req));
+        await sendResponse(res, response);
+    };
+}
+/** The reference **Node adapter**: serve a `FetchHandler` over `node:http`. */
+export function serveNode(handler, opts = {}) {
+    const port = opts.port ?? 3000;
+    const node = toNodeHandler(handler);
+    const server = createHttpServer((req, res) => {
+        node(req, res).catch((e) => {
+            res.statusCode = 500;
+            res.end(String(e?.stack || e));
+        });
+    });
+    server.listen(port, () => opts.onListen ? opts.onListen(port) : console.log(`  fluixi → http://localhost:${port}`));
+    return server;
+}
+const MIME = {
+    '.js': 'text/javascript', '.mjs': 'text/javascript', '.css': 'text/css',
+    '.html': 'text/html', '.json': 'application/json', '.svg': 'image/svg+xml',
+    '.png': 'image/png', '.jpg': 'image/jpeg', '.jpeg': 'image/jpeg', '.webp': 'image/webp',
+    '.ico': 'image/x-icon', '.woff': 'font/woff', '.woff2': 'font/woff2', '.map': 'application/json',
+};
+/**
+ * Wrap a handler to serve static files from `dir` first (for filesystem runtimes —
+ * Node/Bun/Deno). Edge runtimes serve assets via the platform, so they use the bare
+ * handler instead.
+ */
+export function withStaticFiles(handler, dir) {
+    return async (request) => {
+        const { pathname } = new URL(request.url);
+        if (pathname !== '/' && extname(pathname)) {
+            const file = join(dir, decodeURIComponent(pathname));
+            try {
+                const s = await stat(file);
+                if (s.isFile()) {
+                    const body = Readable.toWeb(createReadStream(file));
+                    return new Response(body, {
+                        headers: {
+                            'content-type': MIME[extname(file).toLowerCase()] ?? 'application/octet-stream',
+                            'content-length': String(s.size),
+                        },
+                    });
+                }
+            }
+            catch { /* not a static file → fall through to SSR */ }
+        }
+        return handler(request);
+    };
+}

package/dist/head.d.ts

@@ -0,0 +1,14 @@
+/**
+ * `@fluixi/start/head` — the app-facing SEO & document-head surface, re-exported from the
+ * framework-agnostic `@fluixi/head` engine. Importing from the meta-framework gives apps a single,
+ * stable dependency (like `@fluixi/start/router`) instead of reaching into the engine directly:
+ *
+ *   import { seo, jsonld, Title, Meta, Link, JsonLD } from '@fluixi/start/head';
+ *
+ *   seo({ title: 'Home', description: '…', canonical: 'https://site.com/' });
+ *
+ * SSR injection, route `seo` exports + nested-layout inheritance, and build-time
+ * robots.txt/sitemap.xml emission are wired through @fluixi/start (see server + build).
+ */
+export * from '@fluixi/head';
+//# sourceMappingURL=head.d.ts.map

package/dist/head.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"head.d.ts","sourceRoot":"","sources":["../src/head.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AACH,cAAc,cAAc,CAAC"}

package/dist/head.js

@@ -0,0 +1,13 @@
+/**
+ * `@fluixi/start/head` — the app-facing SEO & document-head surface, re-exported from the
+ * framework-agnostic `@fluixi/head` engine. Importing from the meta-framework gives apps a single,
+ * stable dependency (like `@fluixi/start/router`) instead of reaching into the engine directly:
+ *
+ *   import { seo, jsonld, Title, Meta, Link, JsonLD } from '@fluixi/start/head';
+ *
+ *   seo({ title: 'Home', description: '…', canonical: 'https://site.com/' });
+ *
+ * SSR injection, route `seo` exports + nested-layout inheritance, and build-time
+ * robots.txt/sitemap.xml emission are wired through @fluixi/start (see server + build).
+ */
+export * from '@fluixi/head';

package/dist/index.d.ts

@@ -0,0 +1,24 @@
+/**
+ * @fluixi/start — the Fluixi meta-framework.
+ *
+ * Packages the dev server, build, and production SSR server over @fluixi/server +
+ * Vite, so apps stop hand-rolling server.mjs. Use the `fluixi` CLI (dev/build/start)
+ * or call the commands programmatically.
+ */
+export { defineConfig, resolveConfig, loadConfig } from './config.js';
+export type { FluixiConfig, ResolvedConfig } from './config.js';
+export { dev } from './commands/dev.js';
+export { build } from './commands/build.js';
+export { start } from './commands/start.js';
+export { prerender } from './commands/prerender.js';
+export { injectApp, injectAppAndHead, splitTemplate } from './internal.js';
+export { createRequestHandler, toNodeHandler, nodeToRequest, sendResponse, serveNode, streamDocument, withStaticFiles, } from './handler.js';
+export type { FetchHandler, RenderFn, StreamRenderFn, ServeNodeOptions } from './handler.js';
+export { createProdHandler, nodeAdapter, webAdapter } from './adapter.js';
+export type { Adapter, AdapterContext } from './adapter.js';
+export { defineMiddleware, composeMiddleware, normalizeMiddleware } from './middleware.js';
+export type { Middleware, MiddlewareNext } from './middleware.js';
+export { addInterceptor, clearInterceptors, fetchWithInterceptors } from './interceptors.js';
+export type { Interceptor } from './interceptors.js';
+export { getRequestLocals, getLocals, type RequestLocals } from '@fluixi/server';
+//# 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":"AAAA;;;;;;GAMG;AACH,OAAO,EAAE,YAAY,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AACtE,YAAY,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAChE,OAAO,EAAE,GAAG,EAAE,MAAM,mBAAmB,CAAC;AACxC,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,KAAK,EAAE,MAAM,qBAAqB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,MAAM,yBAAyB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,aAAa,EAAE,MAAM,eAAe,CAAC;AAE3E,OAAO,EACL,oBAAoB,EACpB,aAAa,EACb,aAAa,EACb,YAAY,EACZ,SAAS,EACT,cAAc,EACd,eAAe,GAChB,MAAM,cAAc,CAAC;AACtB,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAC;AAE7F,OAAO,EAAE,iBAAiB,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC1E,YAAY,EAAE,OAAO,EAAE,cAAc,EAAE,MAAM,cAAc,CAAC;AAE5D,OAAO,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,mBAAmB,EAAE,MAAM,iBAAiB,CAAC;AAC3F,YAAY,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAElE,OAAO,EAAE,cAAc,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,mBAAmB,CAAC;AAC7F,YAAY,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAIrD,OAAO,EAAE,gBAAgB,EAAE,SAAS,EAAE,KAAK,aAAa,EAAE,MAAM,gBAAgB,CAAC"}

package/dist/index.js

@@ -0,0 +1,25 @@
+/**
+ * @fluixi/start — the Fluixi meta-framework.
+ *
+ * Packages the dev server, build, and production SSR server over @fluixi/server +
+ * Vite, so apps stop hand-rolling server.mjs. Use the `fluixi` CLI (dev/build/start)
+ * or call the commands programmatically.
+ */
+export { defineConfig, resolveConfig, loadConfig } from './config.js';
+export { dev } from './commands/dev.js';
+export { build } from './commands/build.js';
+export { start } from './commands/start.js';
+export { prerender } from './commands/prerender.js';
+export { injectApp, injectAppAndHead, splitTemplate } from './internal.js';
+// The runtime-neutral request layer — the seam adapters (edge/worker/Bun/Deno) build on.
+export { createRequestHandler, toNodeHandler, nodeToRequest, sendResponse, serveNode, streamDocument, withStaticFiles, } from './handler.js';
+// Deploy adapters: the portable prod handler + the node/web reference adapters.
+export { createProdHandler, nodeAdapter, webAdapter } from './adapter.js';
+// Request middleware — a `(request, next) => Response` chain run before render.
+export { defineMiddleware, composeMiddleware, normalizeMiddleware } from './middleware.js';
+// HTTP interceptors — request/response/error pipeline around fetch (server-fn RPC + app fetch).
+export { addInterceptor, clearInterceptors, fetchWithInterceptors } from './interceptors.js';
+// Middleware→render locals bridge: write `getRequestLocals(request).x = …` in middleware;
+// read it back in loaders/server-fns/render via getLocals() (the app entry forwards
+// `request` on the render event — `renderRequestAsync(App, { url, request })`).
+export { getRequestLocals, getLocals } from '@fluixi/server';

package/dist/interceptors.d.ts

@@ -0,0 +1,15 @@
+export interface Interceptor {
+    /** Transform the outgoing request (e.g. add an Authorization header). */
+    request?: (request: Request) => Request | Promise<Request>;
+    /** Transform the incoming response (e.g. unwrap, refresh-on-401). */
+    response?: (response: Response, request: Request) => Response | Promise<Response>;
+    /** Handle a network error; return a Response to recover, or nothing to rethrow. */
+    error?: (error: unknown, request: Request) => Response | void | Promise<Response | void>;
+}
+/** Register an interceptor. Returns a remover. The first call wires server-fn RPC through it. */
+export declare function addInterceptor(interceptor: Interceptor): () => void;
+/** Remove all interceptors (and restore the plain fetch for server-fn RPC). */
+export declare function clearInterceptors(): void;
+/** fetch() run through the interceptor chain: request → fetch → response, with error recovery. */
+export declare function fetchWithInterceptors(input: RequestInfo | URL, init?: RequestInit): Promise<Response>;
+//# sourceMappingURL=interceptors.d.ts.map

package/dist/interceptors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"interceptors.d.ts","sourceRoot":"","sources":["../src/interceptors.ts"],"names":[],"mappings":"AAMA,MAAM,WAAW,WAAW;IAC1B,yEAAyE;IACzE,OAAO,CAAC,EAAE,CAAC,OAAO,EAAE,OAAO,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;IAC3D,qEAAqE;IACrE,QAAQ,CAAC,EAAE,CAAC,QAAQ,EAAE,QAAQ,EAAE,OAAO,EAAE,OAAO,KAAK,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,CAAC;IAClF,mFAAmF;IACnF,KAAK,CAAC,EAAE,CAAC,KAAK,EAAE,OAAO,EAAE,OAAO,EAAE,OAAO,KAAK,QAAQ,GAAG,IAAI,GAAG,OAAO,CAAC,QAAQ,GAAG,IAAI,CAAC,CAAC;CAC1F;AAID,iGAAiG;AACjG,wBAAgB,cAAc,CAAC,WAAW,EAAE,WAAW,GAAG,MAAM,IAAI,CAOnE;AAED,+EAA+E;AAC/E,wBAAgB,iBAAiB,IAAI,IAAI,CAGxC;AAED,kGAAkG;AAClG,wBAAsB,qBAAqB,CAAC,KAAK,EAAE,WAAW,GAAG,GAAG,EAAE,IAAI,CAAC,EAAE,WAAW,GAAG,OAAO,CAAC,QAAQ,CAAC,CAkB3G"}

package/dist/interceptors.js

@@ -0,0 +1,47 @@
+// HTTP interceptors — a request/response/error pipeline around fetch (Angular-style).
+// Register interceptors to attach auth headers, handle 401s, log, or retry. Server-function
+// RPC calls route through this automatically once any interceptor is added; use
+// `fetchWithInterceptors` for your own data fetching too.
+import { setServerFnFetch } from './server-fn.js';
+const interceptors = [];
+/** Register an interceptor. Returns a remover. The first call wires server-fn RPC through it. */
+export function addInterceptor(interceptor) {
+    if (interceptors.length === 0)
+        setServerFnFetch(fetchWithInterceptors);
+    interceptors.push(interceptor);
+    return () => {
+        const i = interceptors.indexOf(interceptor);
+        if (i >= 0)
+            interceptors.splice(i, 1);
+    };
+}
+/** Remove all interceptors (and restore the plain fetch for server-fn RPC). */
+export function clearInterceptors() {
+    interceptors.length = 0;
+    setServerFnFetch(((...a) => fetch(...a)));
+}
+/** fetch() run through the interceptor chain: request → fetch → response, with error recovery. */
+export async function fetchWithInterceptors(input, init) {
+    let request = input instanceof Request && !init ? input : new Request(input, init);
+    for (const i of interceptors)
+        if (i.request)
+            request = await i.request(request);
+    let response;
+    try {
+        response = await fetch(request);
+    }
+    catch (error) {
+        for (const i of interceptors) {
+            if (!i.error)
+                continue;
+            const recovered = await i.error(error, request);
+            if (recovered)
+                return recovered;
+        }
+        throw error;
+    }
+    for (const i of interceptors)
+        if (i.response)
+            response = await i.response(response, request);
+    return response;
+}

package/dist/internal.d.ts

@@ -0,0 +1,87 @@
+import type { ResolvedConfig } from './config.js';
+import type { FetchHandler } from './handler.js';
+/** The virtual module that registers every `"use server"` fn + re-exports the dispatcher. */
+export declare const SERVER_FNS_VMOD = "virtual:fluixi-server-fns";
+/** The virtual module exposing auto-discovered translations: `{ messages, locales, defaultLocale }`. */
+export declare const I18N_VMOD = "virtual:fluixi-i18n";
+/**
+ * Auto-discover translations. Scans `<dir>/<locale>.json` (e.g. `src/i18n/en.json`, `fr.json`)
+ * and provides `virtual:fluixi-i18n` exporting `{ messages, locales, defaultLocale }` — wire it
+ * into the built-in i18n in one line:
+ *
+ *   import { createI18n } from '@fluixi/core/i18n';
+ *   import { messages, locales, defaultLocale } from 'virtual:fluixi-i18n';
+ *   export const { t, locale, setLocale } = createI18n({ locale: defaultLocale, locales, messages });
+ *
+ * Configured via `fluixi.config`'s `i18n` (folder / locales / defaultLocale); `i18n: false` disables it.
+ */
+export declare function i18nVitePlugin(opts: {
+    dir: string;
+    defaultLocale?: string;
+    locales?: string[];
+}): any;
+/**
+ * Load env files into `process.env` for SERVER code — the framework's environment manager.
+ *
+ * SECURITY MODEL (Vite-aligned): only `VITE_`-prefixed vars are exposed to the client (via
+ * `import.meta.env`, inlined into the browser bundle). Everything else is server-only. This
+ * loads ALL vars (`.env`, `.env.local`, `.env.[mode]`, `.env.[mode].local`) into `process.env`
+ * so loaders + `"use server"` functions can read secrets — WITHOUT ever exposing non-`VITE_`
+ * vars to the browser. A real (OS) env var always wins, so deploys/secret managers override files.
+ *
+ * Result: `process.env.STRIPE_SECRET` works on the server and never ships to the web; only
+ * `VITE_*` reaches the client. Apps stop hand-rolling dotenv loaders + risking secret leaks.
+ */
+export declare function loadServerEnv(root: string, mode: string): Promise<void>;
+/**
+ * Auto-generate ambient TypeScript declarations for @fluixi/start's virtual modules
+ * (`virtual:fluixi-server-fns`, `virtual:fluixi-i18n`) into `src/fluixi-start-env.d.ts`, the
+ * way the routes plugin writes `fluixi-env.d.ts`. So apps NEVER hand-write these `declare
+ * module` blocks — the modules AND their types are both generated. Idempotent (only writes on
+ * change), runs in dev + build.
+ */
+export declare function startTypesPlugin(cfg: ResolvedConfig): any;
+/**
+ * The fluixi build plugins @fluixi/start provides by default: file-based routing
+ * (fluixiRoutesPlugin → virtual:fluixi-routes) + the JSX/SSR transform
+ * (createVitePlugin). This is what makes start "sit on top of fluixi" — apps get
+ * zero-config routing + SSR. Apps using `fluixi dev|build` should therefore NOT add
+ * these to their own vite.config (start owns them); keep vite.config for app-specific
+ * bits only (optimizeDeps, ssr.noExternal via config, etc.).
+ */
+export declare function fluixiPlugins(cfg: ResolvedConfig): Promise<any[]>;
+/**
+ * Inject server-rendered app HTML into the template's mount element
+ * (`<div id="root"></div>`). Falls back to a `<!--ssr-outlet-->` marker, then to
+ * just before `</body>`.
+ */
+export declare function injectApp(template: string, appHtml: string, mountId?: string): string;
+/**
+ * Split the template at the mount point for streaming: `head` is everything up to and
+ * including the open mount tag (flushed first so the browser fetches assets while the
+ * server awaits data); `tail` is the close tag onward (client script + `</body>`).
+ * Mirrors injectApp's three cases (mount div, `<!--ssr-outlet-->`, before `</body>`).
+ */
+export declare function splitTemplate(template: string, mountId?: string): {
+    head: string;
+    tail: string;
+};
+/**
+ * Inject the rendered app into the mount point AND lift any @fluixi/head metadata (carried back as
+ * a marker by renderRequestAsync) into <head> + <html>. If the page set a title, the template's own
+ * <title> is dropped so there's only one. No marker → identical to injectApp.
+ */
+export declare function injectAppAndHead(template: string, rendered: string, mountId?: string): string;
+/**
+ * Wrap a fetch handler so a thrown/rejected error becomes a 500 instead of an
+ * unhandled rejection. `createRequestHandler` already guards the renderer; this
+ * covers the middleware chain that wraps it. `onError` lets dev map the stack first.
+ */
+export declare function guardHandler(handler: FetchHandler, onError?: (e: unknown) => void): FetchHandler;
+/**
+ * A render fires the route's data fetches eagerly; if the backend is down those
+ * promises can reject AFTER we've already responded, with nothing awaiting them —
+ * a floating rejection would kill the dev server. Swallow + log instead.
+ */
+export declare function installCrashGuards(): void;
+//# sourceMappingURL=internal.d.ts.map

package/dist/internal.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"internal.d.ts","sourceRoot":"","sources":["../src/internal.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,aAAa,CAAC;AAClD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,cAAc,CAAC;AAEjD,6FAA6F;AAC7F,eAAO,MAAM,eAAe,8BAA8B,CAAC;AAE3D,wGAAwG;AACxG,eAAO,MAAM,SAAS,wBAAwB,CAAC;AAE/C;;;;;;;;;;GAUG;AACH,wBAAgB,cAAc,CAAC,IAAI,EAAE;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,aAAa,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,CAAC,EAAE,MAAM,EAAE,CAAA;CAAE,GAAG,GAAG,CAoCrG;AAED;;;;;;;;;;;GAWG;AACH,wBAAsB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC,CAM7E;AA6DD;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,cAAc,GAAG,GAAG,CA4BzD;AAED;;;;;;;GAOG;AACH,wBAAsB,aAAa,CAAC,GAAG,EAAE,cAAc,GAAG,OAAO,CAAC,GAAG,EAAE,CAAC,CAoBvE;AAED;;;;GAIG;AACH,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,OAAO,SAAS,GAAG,MAAM,CASrF;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,SAAS,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAwBhG;AASD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,OAAO,SAAS,GAAG,MAAM,CAW7F;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,OAAO,EAAE,YAAY,EACrB,OAAO,CAAC,EAAE,CAAC,CAAC,EAAE,OAAO,KAAK,IAAI,GAC7B,YAAY,CAYd;AAID;;;;GAIG;AACH,wBAAgB,kBAAkB,IAAI,IAAI,CASzC"}