@bquery/bquery 1.5.0 → 1.7.0

package/dist/security/trusted-html.d.ts

@@ -0,0 +1,53 @@
+declare const sanitizedHtmlBrand: unique symbol;
+declare const trustedHtmlBrand: unique symbol;
+/**
+ * Branded HTML string produced by bQuery's sanitization or escaping template helpers.
+ *
+ * Values returned from {@link sanitizeHtml} carry sanitized markup. Values returned from
+ * {@link safeHtml} preserve the template's static markup while escaping normal interpolations
+ * and splicing {@link trusted} fragments verbatim. This brand is not intended for arbitrary
+ * strings or manual concatenation outside those helpers.
+ */
+export type SanitizedHtml = string & {
+    readonly [sanitizedHtmlBrand]: true;
+};
+/**
+ * Marker object that safeHtml can splice into templates without escaping again.
+ */
+export type TrustedHtml = {
+    readonly [trustedHtmlBrand]: true;
+    toString(): string;
+};
+/**
+ * Apply the internal {@link SanitizedHtml} brand to helper output.
+ *
+ * @internal
+ */
+export declare const toSanitizedHtml: (html: string) => SanitizedHtml;
+/**
+ * Mark a sanitized HTML string for verbatim splicing into safeHtml templates.
+ *
+ * @param html - HTML previously produced by sanitizeHtml, safeHtml, or another trusted bQuery helper
+ * @returns Trusted HTML marker object for safeHtml interpolations
+ *
+ * @example
+ * ```ts
+ * const badge = trusted(sanitizeHtml('<strong onclick="alert(1)">New</strong>'));
+ * const markup = safeHtml`<span>${badge}</span>`;
+ * ```
+ */
+export declare const trusted: (html: SanitizedHtml) => TrustedHtml;
+/**
+ * Check whether a value is a trusted HTML marker created by trusted().
+ *
+ * @internal
+ */
+export declare const isTrustedHtml: (value: unknown) => value is TrustedHtml;
+/**
+ * Unwrap the raw HTML string stored inside a trusted HTML marker.
+ *
+ * @internal
+ */
+export declare const unwrapTrustedHtml: (value: TrustedHtml) => string;
+export {};
+//# sourceMappingURL=trusted-html.d.ts.map

package/dist/security/trusted-html.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"trusted-html.d.ts","sourceRoot":"","sources":["../../src/security/trusted-html.ts"],"names":[],"mappings":"AAAA,OAAO,CAAC,MAAM,kBAAkB,EAAE,OAAO,MAAM,CAAC;AAChD,QAAA,MAAM,gBAAgB,EAAE,OAAO,MAA4C,CAAC;AAG5E;;;;;;;GAOG;AACH,MAAM,MAAM,aAAa,GAAG,MAAM,GAAG;IAAE,QAAQ,CAAC,CAAC,kBAAkB,CAAC,EAAE,IAAI,CAAA;CAAE,CAAC;AAE7E;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG;IAAE,QAAQ,CAAC,CAAC,gBAAgB,CAAC,EAAE,IAAI,CAAC;IAAC,QAAQ,IAAI,MAAM,CAAA;CAAE,CAAC;AAIpF;;;;GAIG;AACH,eAAO,MAAM,eAAe,GAAI,MAAM,MAAM,KAAG,aAAsC,CAAC;AAEtF;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,aAAa,KAAG,WAO7C,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,aAAa,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAOvD,CAAC;AAEF;;;;GAIG;AACH,eAAO,MAAM,iBAAiB,GAAI,OAAO,WAAW,KAAG,MAEtD,CAAC"}

package/dist/security.es.mjs

@@ -1,12 +1,13 @@
-import { a as e, c as a, i as t, n as r, o as i, r as p, s as o, t as c } from "./sanitize-jyJ2ryE2.js";
+import { a as e, c as t, d as a, i as r, n as i, o as p, r as o, s as c, t as d } from "./sanitize-B1V4JswB.js";
 export {
-  t as createTrustedHtml,
-  c as escapeHtml,
-  o as generateNonce,
+  r as createTrustedHtml,
+  d as escapeHtml,
+  c as generateNonce,
   e as getTrustedTypesPolicy,
-  a as hasCSPDirective,
-  i as isTrustedTypesSupported,
-  r as sanitize,
-  r as sanitizeHtml,
-  p as stripTags
+  t as hasCSPDirective,
+  p as isTrustedTypesSupported,
+  i as sanitize,
+  i as sanitizeHtml,
+  o as stripTags,
+  a as trusted
 };

package/dist/ssr/hydrate.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Hydration support for server-rendered DOM.
+ *
+ * Enables the client-side view system to reuse existing server-rendered DOM
+ * elements instead of re-rendering them, by attaching reactive bindings
+ * to the pre-existing DOM structure.
+ *
+ * @module bquery/ssr
+ */
+import type { BindingContext, MountOptions, View } from '../view/types';
+/**
+ * Extended mount options that include hydration mode.
+ */
+export type HydrateMountOptions = MountOptions & {
+    /**
+     * When present, must be `true` so the mount operation reuses existing DOM elements
+     * instead of re-rendering them. Reactive bindings (effects) are
+     * still attached so the DOM updates reactively from that point on.
+     *
+     * @default true
+     */
+    hydrate?: true;
+};
+/**
+ * Mounts a reactive view with optional hydration support.
+ *
+ * When `hydrate: true` is set, the existing server-rendered DOM is preserved
+ * and reactive bindings are attached on top. The DOM is NOT re-rendered;
+ * instead, effects begin tracking signals so future changes update the DOM.
+ *
+ * This is the client-side counterpart to `renderToString()`. The typical flow:
+ * 1. Server: `renderToString(template, data)` → send HTML to client
+ * 2. Client: `hydrateMount('#app', reactiveContext, { hydrate: true })`
+ *
+ * Under the hood, `hydrateMount` simply delegates to the standard `mount()`
+ * function. The `mount()` function already processes existing DOM elements
+ * and attaches reactive effects to them — it does not clear/replace content.
+ * The `hydrate` flag is a semantic marker indicating developer intent and
+ * ensures the existing DOM structure is preserved.
+ *
+ * @param selector - CSS selector or Element to hydrate
+ * @param context - Binding context with signals, computed values, and functions
+ * @param options - Mount options with `hydrate: true`
+ * @returns The mounted View instance
+ *
+ * @example
+ * ```ts
+ * import { hydrateMount } from '@bquery/bquery/ssr';
+ * import { signal, computed } from '@bquery/bquery/reactive';
+ *
+ * // Server rendered:
+ * // <div id="app"><h1>Welcome</h1><p>Hello, World!</p></div>
+ *
+ * // Client hydration — attaches reactivity to existing DOM:
+ * const name = signal('World');
+ * const greeting = computed(() => `Hello, ${name.value}!`);
+ *
+ * const view = hydrateMount('#app', { name, greeting }, { hydrate: true });
+ *
+ * // Now updating `name.value` will reactively update the DOM
+ * name.value = 'Alice'; // <p> updates to "Hello, Alice!"
+ * ```
+ */
+export declare const hydrateMount: (selector: string | Element, context: BindingContext, options?: HydrateMountOptions) => View;
+//# sourceMappingURL=hydrate.d.ts.map

package/dist/ssr/hydrate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"hydrate.d.ts","sourceRoot":"","sources":["../../src/ssr/hydrate.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,YAAY,EAAE,IAAI,EAAE,MAAM,eAAe,CAAC;AAGxE;;GAEG;AACH,MAAM,MAAM,mBAAmB,GAAG,YAAY,GAAG;IAC/C;;;;;;OAMG;IACH,OAAO,CAAC,EAAE,IAAI,CAAC;CAChB,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAuCG;AACH,eAAO,MAAM,YAAY,GACvB,UAAU,MAAM,GAAG,OAAO,EAC1B,SAAS,cAAc,EACvB,UAAS,mBAAwB,KAChC,IAUF,CAAC"}

package/dist/ssr/index.d.ts

@@ -0,0 +1,59 @@
+/**
+ * SSR / Pre-rendering module for bQuery.js.
+ *
+ * Provides server-side rendering, hydration, and store state serialization
+ * utilities for bQuery applications. Enables rendering bQuery templates
+ * to HTML strings on the server, serializing store state for client pickup,
+ * and hydrating the pre-rendered DOM on the client.
+ *
+ * ## Features
+ *
+ * - **`renderToString(template, data)`** — Server-side render a bQuery
+ *   template to an `SSRResult` containing an `html` string with directive evaluation.
+ * - **`hydrateMount(selector, context, { hydrate: true })`** — Reuse
+ *   existing server-rendered DOM and attach reactive bindings.
+ * - **`serializeStoreState(options?)`** — Serialize store state into a
+ *   `<script>` tag for client-side pickup.
+ * - **`deserializeStoreState()`** — Read serialized state on the client.
+ * - **`hydrateStore(id, state)` / `hydrateStores(stateMap)`** — Apply
+ *   server state to client stores.
+ *
+ * ## Usage
+ *
+ * ### Server
+ * ```ts
+ * import { renderToString, serializeStoreState } from '@bquery/bquery/ssr';
+ *
+ * const { html } = renderToString(
+ *   '<div id="app"><h1 bq-text="title"></h1></div>',
+ *   { title: 'Welcome' }
+ * );
+ *
+ * const { scriptTag } = serializeStoreState();
+ *
+ * // Send to client: html + scriptTag
+ * ```
+ *
+ * ### Client
+ * ```ts
+ * import { hydrateMount, deserializeStoreState, hydrateStores } from '@bquery/bquery/ssr';
+ * import { signal } from '@bquery/bquery/reactive';
+ *
+ * // Restore store state from SSR
+ * const ssrState = deserializeStoreState();
+ * hydrateStores(ssrState);
+ *
+ * // Hydrate the DOM with reactive bindings
+ * const title = signal('Welcome');
+ * hydrateMount('#app', { title }, { hydrate: true });
+ * ```
+ *
+ * @module bquery/ssr
+ */
+export { hydrateMount } from './hydrate';
+export type { HydrateMountOptions } from './hydrate';
+export { renderToString } from './render';
+export { deserializeStoreState, hydrateStore, hydrateStores, serializeStoreState, } from './serialize';
+export type { SerializeResult } from './serialize';
+export type { DeserializedStoreState, HydrationOptions, RenderOptions, SSRResult, SerializeOptions, } from './types';
+//# sourceMappingURL=index.d.ts.map

package/dist/ssr/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/ssr/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,EAAE,YAAY,EAAE,MAAM,WAAW,CAAC;AACzC,YAAY,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAC;AAC1C,OAAO,EACL,qBAAqB,EACrB,YAAY,EACZ,aAAa,EACb,mBAAmB,GACpB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,eAAe,EAAE,MAAM,aAAa,CAAC;AACnD,YAAY,EACV,sBAAsB,EACtB,gBAAgB,EAChB,aAAa,EACb,SAAS,EACT,gBAAgB,GACjB,MAAM,SAAS,CAAC"}

package/dist/ssr/render.d.ts

@@ -0,0 +1,62 @@
+/**
+ * SSR rendering utilities.
+ *
+ * Server-side renders bQuery templates to HTML strings by evaluating
+ * directive attributes against a plain data context. Uses a lightweight
+ * DOM implementation to process templates without a browser.
+ *
+ * @module bquery/ssr
+ */
+import type { BindingContext } from '../view/types';
+import type { RenderOptions, SSRResult } from './types';
+/**
+ * Server-side renders a bQuery template to an HTML string.
+ *
+ * Takes an HTML template with bQuery directives (bq-text, bq-if, bq-for, etc.)
+ * and a data context, then evaluates the directives to produce a static HTML string.
+ * This HTML can be sent to the client and later hydrated with `mount()` using
+ * `{ hydrate: true }`.
+ *
+ * Supported directives:
+ * - `bq-text` — Sets text content
+ * - `bq-html` — Sets innerHTML
+ * - `bq-if` — Conditional rendering (removes element if falsy)
+ * - `bq-show` — Toggle visibility via `display: none`
+ * - `bq-class` — Dynamic class binding (object or expression syntax)
+ * - `bq-style` — Dynamic inline styles
+ * - `bq-for` — List rendering
+ * - `bq-bind:attr` — Dynamic attribute binding
+ *
+ * @param template - HTML template string with bq-* directives
+ * @param data - Plain data object (signals will be unwrapped automatically)
+ * @param options - Rendering options
+ * @returns SSR result with HTML string and optional store state
+ *
+ * @example
+ * ```ts
+ * import { renderToString } from '@bquery/bquery/ssr';
+ * import { signal } from '@bquery/bquery/reactive';
+ *
+ * const result = renderToString(
+ *   '<div><h1 bq-text="title"></h1><p bq-if="showBody">Hello!</p></div>',
+ *   { title: 'Welcome', showBody: true }
+ * );
+ *
+ * console.log(result.html);
+ * // '<div><h1>Welcome</h1><p>Hello!</p></div>'
+ * ```
+ *
+ * @example
+ * ```ts
+ * // With bq-for list rendering
+ * const result = renderToString(
+ *   '<ul><li bq-for="item in items" bq-text="item.name"></li></ul>',
+ *   { items: [{ name: 'Alice' }, { name: 'Bob' }] }
+ * );
+ *
+ * console.log(result.html);
+ * // '<ul><li>Alice</li><li>Bob</li></ul>'
+ * ```
+ */
+export declare const renderToString: (template: string, data: BindingContext, options?: RenderOptions) => SSRResult;
+//# sourceMappingURL=render.d.ts.map

package/dist/ssr/render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"render.d.ts","sourceRoot":"","sources":["../../src/ssr/render.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAKH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,eAAe,CAAC;AACpD,OAAO,KAAK,EAAE,aAAa,EAAE,SAAS,EAAE,MAAM,SAAS,CAAC;AA2YxD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH,eAAO,MAAM,cAAc,GACzB,UAAU,MAAM,EAChB,MAAM,cAAc,EACpB,UAAS,aAAkB,KAC1B,SA6CF,CAAC"}

package/dist/ssr/serialize.d.ts

@@ -0,0 +1,118 @@
+/**
+ * Store state serialization for SSR.
+ *
+ * Provides utilities to serialize store state into a `<script>` tag
+ * for client-side hydration, and to deserialize state on the client.
+ *
+ * @module bquery/ssr
+ */
+import type { DeserializedStoreState, SerializeOptions } from './types';
+/**
+ * Result of store state serialization.
+ */
+export type SerializeResult = {
+    /** JSON string of the state map */
+    stateJson: string;
+    /** Complete `<script>` tag ready to embed in HTML */
+    scriptTag: string;
+};
+/**
+ * Serializes the state of registered stores into a JSON string and
+ * a `<script>` tag suitable for embedding in server-rendered HTML.
+ *
+ * The serialized state can be picked up on the client using
+ * `deserializeStoreState()` to restore stores to their server-side values.
+ *
+ * @param options - Serialization options
+ * @returns Object with JSON string and ready-to-use script tag
+ *
+ * @example
+ * ```ts
+ * import { serializeStoreState } from '@bquery/bquery/ssr';
+ * import { createStore } from '@bquery/bquery/store';
+ *
+ * const store = createStore({
+ *   id: 'counter',
+ *   state: () => ({ count: 42 }),
+ * });
+ *
+ * const { scriptTag } = serializeStoreState();
+ * // '<script id="__BQUERY_STORE_STATE__">window.__BQUERY_INITIAL_STATE__={"counter":{"count":42}}</script>'
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Serialize only specific stores
+ * const { scriptTag } = serializeStoreState({ storeIds: ['counter'] });
+ * ```
+ */
+export declare const serializeStoreState: (options?: SerializeOptions) => SerializeResult;
+/**
+ * Deserializes store state from the global variable set by the SSR script tag.
+ *
+ * Call this on the client before creating stores to pre-populate them with
+ * server-rendered state. After deserialization, the script tag and global
+ * variable are cleaned up automatically.
+ *
+ * @param globalKey - The global variable name where state was serialized
+ * @param scriptId - The ID of the SSR script tag to remove after hydration
+ * @returns The deserialized state map, or an empty object if not found
+ *
+ * @example
+ * ```ts
+ * import { deserializeStoreState } from '@bquery/bquery/ssr';
+ *
+ * // Call before creating stores
+ * const state = deserializeStoreState();
+ * // state = { counter: { count: 42 } }
+ * ```
+ */
+export declare const deserializeStoreState: (globalKey?: string, scriptId?: string) => DeserializedStoreState;
+/**
+ * Hydrates a store with pre-serialized state from SSR.
+ *
+ * If the store exists and has a `$patch` method, this applies the
+ * deserialized state as a patch. Otherwise, the state is ignored.
+ *
+ * @param storeId - The store ID to hydrate
+ * @param state - The plain state object to apply
+ *
+ * @example
+ * ```ts
+ * import { hydrateStore, deserializeStoreState } from '@bquery/bquery/ssr';
+ * import { createStore } from '@bquery/bquery/store';
+ *
+ * // 1. Deserialize state from SSR script tag
+ * const ssrState = deserializeStoreState();
+ *
+ * // 2. Create store (gets initial values from factory)
+ * const store = createStore({
+ *   id: 'counter',
+ *   state: () => ({ count: 0 }),
+ * });
+ *
+ * // 3. Apply SSR state
+ * if (ssrState.counter) {
+ *   hydrateStore('counter', ssrState.counter);
+ * }
+ * // store.count is now 42 (from SSR)
+ * ```
+ */
+export declare const hydrateStore: (storeId: string, state: Record<string, unknown>) => void;
+/**
+ * Hydrates all stores at once from a deserialized state map.
+ *
+ * Convenience wrapper that calls `hydrateStore` for each entry in the state map.
+ *
+ * @param stateMap - Map of store IDs to their state objects
+ *
+ * @example
+ * ```ts
+ * import { hydrateStores, deserializeStoreState } from '@bquery/bquery/ssr';
+ *
+ * const ssrState = deserializeStoreState();
+ * hydrateStores(ssrState);
+ * ```
+ */
+export declare const hydrateStores: (stateMap: DeserializedStoreState) => void;
+//# sourceMappingURL=serialize.d.ts.map

package/dist/ssr/serialize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serialize.d.ts","sourceRoot":"","sources":["../../src/ssr/serialize.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAIH,OAAO,KAAK,EAAE,sBAAsB,EAAE,gBAAgB,EAAE,MAAM,SAAS,CAAC;AAcxE;;GAEG;AACH,MAAM,MAAM,eAAe,GAAG;IAC5B,mCAAmC;IACnC,SAAS,EAAE,MAAM,CAAC;IAClB,qDAAqD;IACrD,SAAS,EAAE,MAAM,CAAC;CACnB,CAAC;AA6BF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,mBAAmB,GAAI,UAAS,gBAAqB,KAAG,eA4DpE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB,GAChC,kBAAsC,EACtC,iBAAmC,KAClC,sBA2DF,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,eAAO,MAAM,YAAY,GAAI,SAAS,MAAM,EAAE,OAAO,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,KAAG,IAM9E,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,aAAa,GAAI,UAAU,sBAAsB,KAAG,IAIhE,CAAC"}

package/dist/ssr/types.d.ts

@@ -0,0 +1,70 @@
+import type { HydrateMountOptions } from './hydrate';
+/**
+ * Public types for the SSR / Pre-rendering module.
+ */
+/**
+ * Options for server-side rendering a template to an HTML string.
+ */
+export type RenderOptions = {
+    /**
+     * Prefix for directive attributes.
+     * @default 'bq'
+     */
+    prefix?: string;
+    /**
+     * Whether to strip directive attributes from the output HTML.
+     * When `true`, attributes like `bq-text`, `bq-if`, etc. are removed
+     * from the rendered output for cleaner HTML.
+     * @default false
+     */
+    stripDirectives?: boolean;
+    /**
+     * Whether to include a serialized store state `<script>` tag in the output.
+     * When `true`, all registered store states are serialized and appended.
+     * You can also pass an array of store IDs to serialize only specific stores.
+     * @default false
+     */
+    includeStoreState?: boolean | string[];
+};
+/**
+ * Result of a `renderToString` call.
+ */
+export type SSRResult = {
+    /** The rendered HTML string */
+    html: string;
+    /**
+     * Serialized store state string, typically the `<script>` tag payload
+     * produced when `includeStoreState` is enabled.
+     */
+    storeState?: string;
+};
+/** @deprecated Use `HydrateMountOptions` instead. */
+export type HydrationOptions = HydrateMountOptions;
+/**
+ * Options for serializing store state.
+ */
+export type SerializeOptions = {
+    /**
+     * The ID attribute for the generated `<script>` tag.
+     * @default '__BQUERY_STORE_STATE__'
+     */
+    scriptId?: string;
+    /**
+     * The global variable name where state will be assigned.
+     * @default '__BQUERY_INITIAL_STATE__'
+     */
+    globalKey?: string;
+    /**
+     * Store IDs to serialize. If omitted, all registered stores are serialized.
+     */
+    storeIds?: string[];
+    /**
+     * Custom serializer function. Defaults to `JSON.stringify`.
+     */
+    serialize?: (data: unknown) => string;
+};
+/**
+ * Deserialized store state map: store ID → plain state object.
+ */
+export type DeserializedStoreState = Record<string, Record<string, unknown>>;
+//# sourceMappingURL=types.d.ts.map

package/dist/ssr/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/ssr/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,WAAW,CAAC;AAErD;;GAEG;AAEH;;GAEG;AACH,MAAM,MAAM,aAAa,GAAG;IAC1B;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;IAEhB;;;;;OAKG;IACH,eAAe,CAAC,EAAE,OAAO,CAAC;IAE1B;;;;;OAKG;IACH,iBAAiB,CAAC,EAAE,OAAO,GAAG,MAAM,EAAE,CAAC;CACxC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG;IACtB,+BAA+B;IAC/B,IAAI,EAAE,MAAM,CAAC;IAEb;;;OAGG;IACH,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB,CAAC;AAEF,qDAAqD;AACrD,MAAM,MAAM,gBAAgB,GAAG,mBAAmB,CAAC;AAEnD;;GAEG;AACH,MAAM,MAAM,gBAAgB,GAAG;IAC7B;;;OAGG;IACH,QAAQ,CAAC,EAAE,MAAM,CAAC;IAElB;;;OAGG;IACH,SAAS,CAAC,EAAE,MAAM,CAAC;IAEnB;;OAEG;IACH,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IAEpB;;OAEG;IACH,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,OAAO,KAAK,MAAM,CAAC;CACvC,CAAC;AAEF;;GAEG;AACH,MAAM,MAAM,sBAAsB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC"}