blockprint 0.2.0 → 0.2.1

package/README.md

@@ -4,6 +4,8 @@
 
 **Live demo: [blockprint.terzidest.com](https://blockprint.terzidest.com)** — three completely different pages (commerce, SaaS, editorial) from one renderer and one registry, plus a deliberately broken config showing graceful fallback. · [GitHub](https://github.com/terzidest/blockprint)
 
+In production at [ethereal_nature](https://github.com/terzidest/ethereal_nature): storefront pages from DB-stored configs, an admin page editor, and server-side validation via `blockprint/config`.
+
 ## The problem
 
 Content teams compose pages from a fixed set of block types; your app receives JSON like `[{ "type": "hero", "props": { … } }, …]`. Consuming that in React usually collapses into a `switch` on `block.type` — every block imported into every page, props typed `any`, unknown types crashing the page.
@@ -58,6 +60,26 @@ The default fallback renders a warning box in development and `null` in producti
 
 The optional `wrapBlock={(node, entry, index) => …}` prop wraps every rendered entry — blocks and fallbacks alike — with access to the config entry and its index. This is the hook point for visual-editing overlays, analytics boundaries, or per-block chrome.
 
+A common recipe — shared section chrome, deep-link anchors, and analytics attributes in one place instead of repeated in every block:
+
+```tsx
+<Renderer
+  config={config}
+  registry={registry}
+  wrapBlock={(node, entry) => (
+    <section
+      id={entry.id != null ? String(entry.id) : undefined} // anchor: /page#hero-1
+      data-block={entry.type}                        // analytics / e2e hooks
+      className="mx-auto max-w-5xl px-6 py-10"
+    >
+      {node}
+    </section>
+  )}
+/>
+```
+
+Rendering and schema validation are memoised per `(config, registry)` identity — keep the config referentially stable across renders (state, loader data, `useMemo`) to benefit. Duplicate `id`s warn in development and render under collision-safe keys.
+
 ### `parseConfig(input)`
 
 The boundary validator, exported for consumers who want to fail at fetch time rather than render time. Throws `ConfigError` with the entry index and reason.

package/dist/Renderer.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentType, ReactNode } from "react";
-import type { BlockConfig, BlocksShape, FallbackProps, Registry } from "./types.ts";
+import type { BlockConfig, BlocksShape, FallbackProps, Registry } from "./types.js";
 export interface RendererProps<T extends BlocksShape> {
     /** Untrusted input; the outer shape is validated internally. */
     config: unknown;

package/dist/Renderer.js

@@ -1,7 +1,11 @@
 import { jsx as _jsx } from "react/jsx-runtime";
-import { Fragment } from "react";
+import { Fragment, useMemo } from "react";
 import { parseConfig } from "./parseConfig.js";
 import { DefaultFallback } from "./fallback.js";
+import { isDev } from "./env.js";
+// StrictMode double-invokes render (and therefore the memo) in development;
+// remember what we've already warned about so each duplicate id logs once.
+const warnedDuplicateIds = new Set();
 // `memo`/`forwardRef` components are exotic objects, not functions, so the
 // bare-vs-definition split must discriminate on the `component` key.
 function resolveDef(def) {
@@ -10,37 +14,92 @@ function resolveDef(def) {
     }
     return { component: def };
 }
-export function Renderer({ config, registry, fallback, wrapBlock, }) {
-    const Fallback = fallback ?? DefaultFallback;
+function prepare(config, registry) {
     const entries = parseConfig(config);
+    const seenKeys = new Set();
     return entries.map((entry, index) => {
-        const key = entry.id ?? `${entry.type}-${index}`;
-        const node = renderEntry(entry, registry, Fallback);
-        // The key lives on a Fragment so it survives whatever wrapBlock returns.
-        return (_jsx(Fragment, { children: wrapBlock ? wrapBlock(node, entry, index) : node }, key));
-    });
-}
-function renderEntry(entry, registry, Fallback) {
-    if (!Object.hasOwn(registry.blocks, entry.type)) {
-        return (_jsx(Fallback, { reason: "unknown-type", type: entry.type, props: entry.props }));
-    }
-    const { component: Component, schema } = resolveDef(registry.blocks[entry.type]);
-    let props = entry.props;
-    if (schema) {
+        let key = entry.id ?? `${entry.type}-${index}`;
+        if (seenKeys.has(key)) {
+            if (isDev() && !warnedDuplicateIds.has(key)) {
+                warnedDuplicateIds.add(key);
+                console.warn(`blockprint: duplicate block id "${key}" at config[${index}]; ids should be unique per config`);
+            }
+            key = `${key}__dup${index}`;
+        }
+        seenKeys.add(key);
+        if (!Object.hasOwn(registry.blocks, entry.type)) {
+            return {
+                key,
+                entry,
+                kind: "fallback",
+                fallbackProps: {
+                    reason: "unknown-type",
+                    type: entry.type,
+                    props: entry.props,
+                },
+            };
+        }
+        const { component, schema } = resolveDef(registry.blocks[entry.type]);
+        if (!schema) {
+            return {
+                key,
+                entry,
+                kind: "block",
+                component,
+                props: entry.props,
+            };
+        }
         const result = schema["~standard"].validate(entry.props);
         // React render is synchronous; async schemas are a config mistake and
         // are contained like any other invalid block.
         if (result instanceof Promise) {
-            return (_jsx(Fallback, { reason: "invalid-props", type: entry.type, props: entry.props, issues: [
-                    {
-                        message: "schema validated asynchronously; blockprint only supports synchronous schemas",
-                    },
-                ] }));
+            return {
+                key,
+                entry,
+                kind: "fallback",
+                fallbackProps: {
+                    reason: "invalid-props",
+                    type: entry.type,
+                    props: entry.props,
+                    issues: [
+                        {
+                            message: "schema validated asynchronously; blockprint only supports synchronous schemas",
+                        },
+                    ],
+                },
+            };
         }
         if (result.issues) {
-            return (_jsx(Fallback, { reason: "invalid-props", type: entry.type, props: entry.props, issues: result.issues }));
+            return {
+                key,
+                entry,
+                kind: "fallback",
+                fallbackProps: {
+                    reason: "invalid-props",
+                    type: entry.type,
+                    props: entry.props,
+                    issues: result.issues,
+                },
+            };
         }
-        props = result.value;
-    }
-    return _jsx(Component, { ...props });
+        return {
+            key,
+            entry,
+            kind: "block",
+            component,
+            props: result.value,
+        };
+    });
+}
+export function Renderer({ config, registry, fallback, wrapBlock, }) {
+    const Fallback = fallback ?? DefaultFallback;
+    // Parsing and schema validation run once per (config, registry) identity,
+    // not on every render; a consumer recreating the config array each render
+    // opts out of the caching, not the correctness.
+    const prepared = useMemo(() => prepare(config, registry), [config, registry]);
+    return prepared.map((item, index) => {
+        const node = item.kind === "block" ? (_jsx(item.component, { ...item.props })) : (_jsx(Fallback, { ...item.fallbackProps }));
+        // The key lives on a Fragment so it survives whatever wrapBlock returns.
+        return (_jsx(Fragment, { children: wrapBlock ? wrapBlock(node, item.entry, index) : node }, item.key));
+    });
 }

package/dist/config.d.ts

@@ -4,6 +4,6 @@
  * this module (and its imports) free of React — servers validating stored
  * configs want exactly this and nothing more.
  */
-export { parseConfig, ConfigError } from "./parseConfig.ts";
-export type { BlockConfig } from "./types.ts";
-export type { StandardSchemaV1 } from "./standard-schema.ts";
+export { parseConfig, ConfigError } from "./parseConfig.js";
+export type { BlockConfig } from "./types.js";
+export type { StandardSchemaV1 } from "./standard-schema.js";

package/dist/createRegistry.d.ts

@@ -1,6 +1,6 @@
 import type { ComponentType } from "react";
-import type { StandardSchemaV1 } from "./standard-schema.ts";
-import type { BlocksShape, Registry } from "./types.ts";
+import type { StandardSchemaV1 } from "./standard-schema.js";
+import type { BlocksShape, Registry } from "./types.js";
 /**
  * Maps every compatible entry to `unknown` (an identity when intersected) and
  * every entry whose schema output is not assignable to its component's props

package/dist/env.d.ts

@@ -0,0 +1,5 @@
+/**
+ * True outside production builds. Guarded so a browser without a bundler
+ * defining `process` gets `false` instead of a ReferenceError.
+ */
+export declare function isDev(): boolean;

package/dist/env.js

@@ -0,0 +1,7 @@
+/**
+ * True outside production builds. Guarded so a browser without a bundler
+ * defining `process` gets `false` instead of a ReferenceError.
+ */
+export function isDev() {
+    return typeof process !== "undefined" && process.env.NODE_ENV !== "production";
+}

package/dist/fallback.d.ts

@@ -1,2 +1,2 @@
-import type { FallbackProps } from "./types.ts";
+import type { FallbackProps } from "./types.js";
 export declare function DefaultFallback(props: FallbackProps): import("react").JSX.Element | null;

package/dist/fallback.js

@@ -1,6 +1,7 @@
 import { jsxs as _jsxs } from "react/jsx-runtime";
+import { isDev } from "./env.js";
 export function DefaultFallback(props) {
-    if (process.env.NODE_ENV === "production") {
+    if (!isDev()) {
         return null;
     }
     const detail = props.reason === "invalid-props"

package/dist/index.d.ts

@@ -1,6 +1,6 @@
-export { createRegistry } from "./createRegistry.ts";
-export { Renderer } from "./Renderer.tsx";
-export type { RendererProps } from "./Renderer.tsx";
-export { parseConfig, ConfigError } from "./parseConfig.ts";
-export type { BlockConfig, BlockDef, BlocksShape, ConfigFor, FallbackProps, InputFor, PropsFor, Registry, } from "./types.ts";
-export type { StandardSchemaV1 } from "./standard-schema.ts";
+export { createRegistry } from "./createRegistry.js";
+export { Renderer } from "./Renderer.js";
+export type { RendererProps } from "./Renderer.js";
+export { parseConfig, ConfigError } from "./parseConfig.js";
+export type { BlockConfig, BlockDef, BlocksShape, ConfigFor, FallbackProps, InputFor, PropsFor, Registry, } from "./types.js";
+export type { StandardSchemaV1 } from "./standard-schema.js";

package/dist/parseConfig.d.ts

@@ -1,4 +1,4 @@
-import type { BlockConfig } from "./types.ts";
+import type { BlockConfig } from "./types.js";
 export declare class ConfigError extends Error {
     constructor(message: string);
 }

package/dist/types.d.ts

@@ -1,5 +1,5 @@
 import type { ComponentType } from "react";
-import type { StandardSchemaV1 } from "./standard-schema.ts";
+import type { StandardSchemaV1 } from "./standard-schema.js";
 export type AnyComponent = ComponentType<any>;
 export type BlockDef = AnyComponent | {
     component: AnyComponent;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockprint",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "Typed, config-driven block renderer for React. Render arbitrary UI trees from untrusted JSON with compile-time registry safety and runtime schema validation.",
   "license": "MIT",
   "homepage": "https://blockprint.terzidest.com",
@@ -43,6 +43,7 @@
   "devDependencies": {
     "@types/react": "^19.2.18",
     "@types/react-dom": "^19.2.4",
+    "jsdom": "^30.1.3",
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "typescript": "^7.0.2",
@@ -55,7 +56,7 @@
     }
   },
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "node -e \"fs.rmSync('dist',{recursive:true,force:true})\" && tsc -p tsconfig.build.json && node scripts/fix-dts.mjs",
     "typecheck": "tsc",
     "test": "vitest run"
   }

package/dist/chunk-4JB5QQUK.js

@@ -1,37 +0,0 @@
-// src/parseConfig.ts
-var ConfigError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "ConfigError";
-  }
-};
-function parseConfig(input) {
-  if (!Array.isArray(input)) {
-    throw new ConfigError(
-      `config must be an array, received ${input === null ? "null" : typeof input}`
-    );
-  }
-  return input.map((entry, index) => {
-    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
-      throw new ConfigError(`config[${index}] must be an object`);
-    }
-    const { type, props, id } = entry;
-    if (typeof type !== "string" || type.length === 0) {
-      throw new ConfigError(
-        `config[${index}].type must be a non-empty string`
-      );
-    }
-    if (id !== void 0 && typeof id !== "string" && typeof id !== "number") {
-      throw new ConfigError(
-        `config[${index}].id must be a string or number when present`
-      );
-    }
-    return id === void 0 ? { type, props } : { type, props, id };
-  });
-}
-
-export {
-  ConfigError,
-  parseConfig
-};
-//# sourceMappingURL=chunk-4JB5QQUK.js.map

package/dist/chunk-4JB5QQUK.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/parseConfig.ts"],"sourcesContent":["import type { BlockConfig } from \"./types\";\n\nexport class ConfigError extends Error {\n  constructor(message: string) {\n    super(message);\n    this.name = \"ConfigError\";\n  }\n}\n\n/**\n * The single boundary where untrusted input becomes a typed config. Validates\n * the outer shape only; per-block props are validated against their registered\n * schema at render time.\n */\nexport function parseConfig(input: unknown): BlockConfig[] {\n  if (!Array.isArray(input)) {\n    throw new ConfigError(\n      `config must be an array, received ${input === null ? \"null\" : typeof input}`,\n    );\n  }\n\n  return input.map((entry, index) => {\n    if (typeof entry !== \"object\" || entry === null || Array.isArray(entry)) {\n      throw new ConfigError(`config[${index}] must be an object`);\n    }\n    const { type, props, id } = entry as Record<string, unknown>;\n    if (typeof type !== \"string\" || type.length === 0) {\n      throw new ConfigError(\n        `config[${index}].type must be a non-empty string`,\n      );\n    }\n    if (id !== undefined && typeof id !== \"string\" && typeof id !== \"number\") {\n      throw new ConfigError(\n        `config[${index}].id must be a string or number when present`,\n      );\n    }\n    return id === undefined ? { type, props } : { type, props, id };\n  });\n}\n"],"mappings":";AAEO,IAAM,cAAN,cAA0B,MAAM;AAAA,EACrC,YAAY,SAAiB;AAC3B,UAAM,OAAO;AACb,SAAK,OAAO;AAAA,EACd;AACF;AAOO,SAAS,YAAY,OAA+B;AACzD,MAAI,CAAC,MAAM,QAAQ,KAAK,GAAG;AACzB,UAAM,IAAI;AAAA,MACR,qCAAqC,UAAU,OAAO,SAAS,OAAO,KAAK;AAAA,IAC7E;AAAA,EACF;AAEA,SAAO,MAAM,IAAI,CAAC,OAAO,UAAU;AACjC,QAAI,OAAO,UAAU,YAAY,UAAU,QAAQ,MAAM,QAAQ,KAAK,GAAG;AACvE,YAAM,IAAI,YAAY,UAAU,KAAK,qBAAqB;AAAA,IAC5D;AACA,UAAM,EAAE,MAAM,OAAO,GAAG,IAAI;AAC5B,QAAI,OAAO,SAAS,YAAY,KAAK,WAAW,GAAG;AACjD,YAAM,IAAI;AAAA,QACR,UAAU,KAAK;AAAA,MACjB;AAAA,IACF;AACA,QAAI,OAAO,UAAa,OAAO,OAAO,YAAY,OAAO,OAAO,UAAU;AACxE,YAAM,IAAI;AAAA,QACR,UAAU,KAAK;AAAA,MACjB;AAAA,IACF;AACA,WAAO,OAAO,SAAY,EAAE,MAAM,MAAM,IAAI,EAAE,MAAM,OAAO,GAAG;AAAA,EAChE,CAAC;AACH;","names":[]}

package/dist/config.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":[],"sourcesContent":[],"mappings":"","names":[]}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/createRegistry.ts","../src/Renderer.tsx","../src/fallback.tsx"],"sourcesContent":["import type { ComponentType } from \"react\";\nimport type { StandardSchemaV1 } from \"./standard-schema\";\nimport type { BlocksShape, Registry } from \"./types\";\n\n/**\n * Maps every compatible entry to `unknown` (an identity when intersected) and\n * every entry whose schema output is not assignable to its component's props\n * to an impossible shape — so the type error lands on the offending key with\n * a message naming it.\n */\nexport type ValidateBlocks<T extends BlocksShape> = {\n  [K in keyof T]: T[K] extends {\n    component: ComponentType<infer P>;\n    schema: StandardSchemaV1<unknown, infer S>;\n  }\n    ? [S] extends [P]\n      ? unknown\n      : {\n          schema: `schema output is not assignable to props of '${K & string}'`;\n        }\n    : unknown;\n};\n\nexport function createRegistry<T extends BlocksShape>(\n  blocks: T & ValidateBlocks<T>,\n): Registry<T> {\n  return { blocks: blocks as T };\n}\n","import { Fragment } from \"react\";\nimport type { ComponentType, ReactNode } from \"react\";\nimport type { StandardSchemaV1 } from \"./standard-schema\";\nimport type {\n  AnyComponent,\n  BlockConfig,\n  BlocksShape,\n  FallbackProps,\n  Registry,\n} from \"./types\";\nimport { parseConfig } from \"./parseConfig\";\nimport { DefaultFallback } from \"./fallback\";\n\nexport interface RendererProps<T extends BlocksShape> {\n  /** Untrusted input; the outer shape is validated internally. */\n  config: unknown;\n  registry: Registry<T>;\n  fallback?: ComponentType<FallbackProps>;\n  /**\n   * Wraps every rendered entry — blocks and fallbacks alike — with access to\n   * the config entry and its index. The hook point for visual-editing\n   * overlays, analytics boundaries, or per-block chrome.\n   */\n  wrapBlock?: (node: ReactNode, entry: BlockConfig, index: number) => ReactNode;\n}\n\ninterface ResolvedDef {\n  component: AnyComponent;\n  schema?: StandardSchemaV1<unknown, any>;\n}\n\n// `memo`/`forwardRef` components are exotic objects, not functions, so the\n// bare-vs-definition split must discriminate on the `component` key.\nfunction resolveDef(def: BlocksShape[string]): ResolvedDef {\n  if (typeof def === \"object\" && def !== null && \"component\" in def) {\n    return def;\n  }\n  return { component: def };\n}\n\nexport function Renderer<T extends BlocksShape>({\n  config,\n  registry,\n  fallback,\n  wrapBlock,\n}: RendererProps<T>): ReactNode {\n  const Fallback = fallback ?? DefaultFallback;\n  const entries = parseConfig(config);\n\n  return entries.map((entry, index) => {\n    const key = entry.id ?? `${entry.type}-${index}`;\n    const node = renderEntry(entry, registry, Fallback);\n    // The key lives on a Fragment so it survives whatever wrapBlock returns.\n    return (\n      <Fragment key={key}>\n        {wrapBlock ? wrapBlock(node, entry, index) : node}\n      </Fragment>\n    );\n  });\n}\n\nfunction renderEntry(\n  entry: BlockConfig,\n  registry: Registry<BlocksShape>,\n  Fallback: ComponentType<FallbackProps>,\n): ReactNode {\n  if (!Object.hasOwn(registry.blocks, entry.type)) {\n    return (\n      <Fallback reason=\"unknown-type\" type={entry.type} props={entry.props} />\n    );\n  }\n\n  const { component: Component, schema } = resolveDef(\n    registry.blocks[entry.type] as BlocksShape[string],\n  );\n\n  let props = entry.props;\n  if (schema) {\n    const result = schema[\"~standard\"].validate(entry.props);\n    // React render is synchronous; async schemas are a config mistake and\n    // are contained like any other invalid block.\n    if (result instanceof Promise) {\n      return (\n        <Fallback\n          reason=\"invalid-props\"\n          type={entry.type}\n          props={entry.props}\n          issues={[\n            {\n              message:\n                \"schema validated asynchronously; blockprint only supports synchronous schemas\",\n            },\n          ]}\n        />\n      );\n    }\n    if (result.issues) {\n      return (\n        <Fallback\n          reason=\"invalid-props\"\n          type={entry.type}\n          props={entry.props}\n          issues={result.issues}\n        />\n      );\n    }\n    props = result.value;\n  }\n\n  return <Component {...(props as object | undefined)} />;\n}\n","import type { FallbackProps } from \"./types\";\n\n// Ambient declaration instead of @types/node: bundlers replace\n// process.env.NODE_ENV statically, and the library has no other Node surface.\ndeclare const process: { env: { NODE_ENV?: string } };\n\nexport function DefaultFallback(props: FallbackProps) {\n  if (process.env.NODE_ENV === \"production\") {\n    return null;\n  }\n\n  const detail =\n    props.reason === \"invalid-props\"\n      ? props.issues.map((issue) => issue.message).join(\"; \")\n      : \"no component registered for this type\";\n\n  return (\n    <div\n      role=\"note\"\n      style={{\n        border: \"1px dashed #c00\",\n        borderRadius: 4,\n        padding: \"8px 12px\",\n        fontFamily: \"monospace\",\n        fontSize: 13,\n        color: \"#c00\",\n      }}\n    >\n      blockprint: block &quot;{props.type}&quot; not rendered ({props.reason}):{\" \"}\n      {detail}\n    </div>\n  );\n}\n"],"mappings":";;;;;;AAuBO,SAAS,eACd,QACa;AACb,SAAO,EAAE,OAAoB;AAC/B;;;AC3BA,SAAS,gBAAgB;;;ACiBrB;AAXG,SAAS,gBAAgB,OAAsB;AACpD,MAAI,QAAQ,IAAI,aAAa,cAAc;AACzC,WAAO;AAAA,EACT;AAEA,QAAM,SACJ,MAAM,WAAW,kBACb,MAAM,OAAO,IAAI,CAAC,UAAU,MAAM,OAAO,EAAE,KAAK,IAAI,IACpD;AAEN,SACE;AAAA,IAAC;AAAA;AAAA,MACC,MAAK;AAAA,MACL,OAAO;AAAA,QACL,QAAQ;AAAA,QACR,cAAc;AAAA,QACd,SAAS;AAAA,QACT,YAAY;AAAA,QACZ,UAAU;AAAA,QACV,OAAO;AAAA,MACT;AAAA,MACD;AAAA;AAAA,QAC0B,MAAM;AAAA,QAAK;AAAA,QAAsB,MAAM;AAAA,QAAO;AAAA,QAAG;AAAA,QACzE;AAAA;AAAA;AAAA,EACH;AAEJ;;;ADsBM;AArBN,SAAS,WAAW,KAAuC;AACzD,MAAI,OAAO,QAAQ,YAAY,QAAQ,QAAQ,eAAe,KAAK;AACjE,WAAO;AAAA,EACT;AACA,SAAO,EAAE,WAAW,IAAI;AAC1B;AAEO,SAAS,SAAgC;AAAA,EAC9C;AAAA,EACA;AAAA,EACA;AAAA,EACA;AACF,GAAgC;AAC9B,QAAM,WAAW,YAAY;AAC7B,QAAM,UAAU,YAAY,MAAM;AAElC,SAAO,QAAQ,IAAI,CAAC,OAAO,UAAU;AACnC,UAAM,MAAM,MAAM,MAAM,GAAG,MAAM,IAAI,IAAI,KAAK;AAC9C,UAAM,OAAO,YAAY,OAAO,UAAU,QAAQ;AAElD,WACE,oBAAC,YACE,sBAAY,UAAU,MAAM,OAAO,KAAK,IAAI,QADhC,GAEf;AAAA,EAEJ,CAAC;AACH;AAEA,SAAS,YACP,OACA,UACA,UACW;AACX,MAAI,CAAC,OAAO,OAAO,SAAS,QAAQ,MAAM,IAAI,GAAG;AAC/C,WACE,oBAAC,YAAS,QAAO,gBAAe,MAAM,MAAM,MAAM,OAAO,MAAM,OAAO;AAAA,EAE1E;AAEA,QAAM,EAAE,WAAW,WAAW,OAAO,IAAI;AAAA,IACvC,SAAS,OAAO,MAAM,IAAI;AAAA,EAC5B;AAEA,MAAI,QAAQ,MAAM;AAClB,MAAI,QAAQ;AACV,UAAM,SAAS,OAAO,WAAW,EAAE,SAAS,MAAM,KAAK;AAGvD,QAAI,kBAAkB,SAAS;AAC7B,aACE;AAAA,QAAC;AAAA;AAAA,UACC,QAAO;AAAA,UACP,MAAM,MAAM;AAAA,UACZ,OAAO,MAAM;AAAA,UACb,QAAQ;AAAA,YACN;AAAA,cACE,SACE;AAAA,YACJ;AAAA,UACF;AAAA;AAAA,MACF;AAAA,IAEJ;AACA,QAAI,OAAO,QAAQ;AACjB,aACE;AAAA,QAAC;AAAA;AAAA,UACC,QAAO;AAAA,UACP,MAAM,MAAM;AAAA,UACZ,OAAO,MAAM;AAAA,UACb,QAAQ,OAAO;AAAA;AAAA,MACjB;AAAA,IAEJ;AACA,YAAQ,OAAO;AAAA,EACjB;AAEA,SAAO,oBAAC,aAAW,GAAI,OAA8B;AACvD;","names":[]}