@pascal-app/core 1.0.0 → 1.0.3

package/dist/procedural-items/materials.js

@@ -0,0 +1,47 @@
+import { getMaterialPresetByRef, parseMaterialRef, toSceneMaterialRef } from '../material-library.js';
+import { generateSceneMaterialId, } from '../schema/scene-material.js';
+import { runAsSingleSceneHistoryStep } from '../store/history-control.js';
+import useScene from '../store/use-scene.js';
+import { proceduralFinishLibraryColor } from './library-colors.js';
+import { isProceduralItem } from './query.js';
+export function proceduralSlotColor(ref, fallback, materials) {
+    if (ref?.startsWith('#'))
+        return ref;
+    const parsed = parseMaterialRef(ref);
+    if (parsed?.kind === 'scene')
+        return materials[parsed.id]?.material.properties?.color ?? fallback;
+    return ref
+        ? (proceduralFinishLibraryColor(ref) ??
+            getMaterialPresetByRef(ref)?.mapProperties?.color ??
+            fallback)
+        : fallback;
+}
+export function setProceduralMaterial(nodeId, slotId, ref, material) {
+    const state = useScene.getState(), node = state.nodes[nodeId];
+    if (state.readOnly || !isProceduralItem(node))
+        return;
+    if (!node.recipe.slots.some((s) => s.id === slotId))
+        throw new Error('Unknown material slot');
+    let created;
+    if (material && !ref) {
+        const match = Object.values(state.materials).find((m) => JSON.stringify(m.material) === JSON.stringify(material));
+        created = match
+            ? undefined
+            : {
+                id: generateSceneMaterialId(),
+                name: node.recipe.slots.find((s) => s.id === slotId).label,
+                material,
+            };
+        ref = toSceneMaterialRef((match ?? created).id);
+    }
+    const slots = { ...node.slots };
+    if (ref)
+        slots[slotId] = ref;
+    else
+        delete slots[slotId];
+    runAsSingleSceneHistoryStep(useScene, () => {
+        state.updateNode(nodeId, { slots });
+        if (created)
+            useScene.getState().addSceneMaterial(created);
+    });
+}

package/dist/procedural-items/node.d.ts

@@ -0,0 +1,280 @@
+import { z } from 'zod';
+import { type Recipe } from './recipe.js';
+export declare const ProceduralItemNode: z.ZodObject<{
+    object: z.ZodDefault<z.ZodLiteral<"node">>;
+    name: z.ZodOptional<z.ZodString>;
+    parentId: z.ZodDefault<z.ZodNullable<z.ZodString>>;
+    visible: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+    camera: z.ZodOptional<z.ZodObject<{
+        position: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        target: z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>;
+        mode: z.ZodDefault<z.ZodEnum<{
+            perspective: "perspective";
+            orthographic: "orthographic";
+        }>>;
+        fov: z.ZodOptional<z.ZodNumber>;
+        zoom: z.ZodOptional<z.ZodNumber>;
+    }, z.core.$strip>>;
+    metadata: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>>;
+    id: z.ZodDefault<z.ZodTemplateLiteral<`procedural-item_${string}`>>;
+    type: z.ZodDefault<z.ZodLiteral<"procedural-item">>;
+    recipe: z.ZodPipe<z.ZodCustom<{
+        version: 1;
+        name: string;
+        description: string;
+        parameters: {
+            id: string;
+            label: string;
+            default: number;
+            min: number;
+            max: number;
+            step: number;
+            unit: "count" | "m" | "rad";
+            part?: string | undefined;
+            axis?: "x" | "y" | "z" | undefined;
+        }[];
+        slots: {
+            id: string;
+            label: string;
+            color: string;
+            finish?: "wood" | "glass" | "metal" | undefined;
+        }[];
+        parts: {
+            id: string;
+            label: string;
+            count: import("./recipe.js").Expr;
+            shapes: {
+                id: string;
+                primitive: "box" | "roundedBox" | "cylinder";
+                slot: string;
+                size: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+                radius?: import("./recipe.js").Expr | undefined;
+                support?: boolean | undefined;
+            }[];
+        }[];
+        constraints: {
+            left: import("./recipe.js").Expr;
+            relation: "lte" | "gte";
+            right: import("./recipe.js").Expr;
+            message: string;
+        }[];
+        classification?: {
+            category: string;
+            functionTags: string[];
+            tags: string[];
+        } | undefined;
+        mounting?: {
+            attachTo: "ceiling" | "wall-side";
+            reference: string;
+        } | undefined;
+        surfaces?: {
+            id: string;
+            label: string;
+            position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+            size: [import("./recipe.js").Expr, import("./recipe.js").Expr];
+            part?: string | undefined;
+            rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+        }[] | undefined;
+    }, {
+        version: 1;
+        name: string;
+        description: string;
+        parameters: {
+            id: string;
+            label: string;
+            default: number;
+            min: number;
+            max: number;
+            step: number;
+            unit: "count" | "m" | "rad";
+            part?: string | undefined;
+            axis?: "x" | "y" | "z" | undefined;
+        }[];
+        slots: {
+            id: string;
+            label: string;
+            color: string;
+            finish?: "wood" | "glass" | "metal" | undefined;
+        }[];
+        parts: {
+            id: string;
+            label: string;
+            count: import("./recipe.js").Expr;
+            shapes: {
+                id: string;
+                primitive: "box" | "roundedBox" | "cylinder";
+                slot: string;
+                size: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+                radius?: import("./recipe.js").Expr | undefined;
+                support?: boolean | undefined;
+            }[];
+        }[];
+        constraints: {
+            left: import("./recipe.js").Expr;
+            relation: "lte" | "gte";
+            right: import("./recipe.js").Expr;
+            message: string;
+        }[];
+        classification?: {
+            category: string;
+            functionTags: string[];
+            tags: string[];
+        } | undefined;
+        mounting?: {
+            attachTo: "ceiling" | "wall-side";
+            reference: string;
+        } | undefined;
+        surfaces?: {
+            id: string;
+            label: string;
+            position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+            size: [import("./recipe.js").Expr, import("./recipe.js").Expr];
+            part?: string | undefined;
+            rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+        }[] | undefined;
+    }>, z.ZodTransform<{
+        version: 1;
+        name: string;
+        description: string;
+        parameters: {
+            id: string;
+            label: string;
+            default: number;
+            min: number;
+            max: number;
+            step: number;
+            unit: "count" | "m" | "rad";
+            part?: string | undefined;
+            axis?: "x" | "y" | "z" | undefined;
+        }[];
+        slots: {
+            id: string;
+            label: string;
+            color: string;
+            finish?: "wood" | "glass" | "metal" | undefined;
+        }[];
+        parts: {
+            id: string;
+            label: string;
+            count: import("./recipe.js").Expr;
+            shapes: {
+                id: string;
+                primitive: "box" | "roundedBox" | "cylinder";
+                slot: string;
+                size: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+                radius?: import("./recipe.js").Expr | undefined;
+                support?: boolean | undefined;
+            }[];
+        }[];
+        constraints: {
+            left: import("./recipe.js").Expr;
+            relation: "lte" | "gte";
+            right: import("./recipe.js").Expr;
+            message: string;
+        }[];
+        classification?: {
+            category: string;
+            functionTags: string[];
+            tags: string[];
+        } | undefined;
+        mounting?: {
+            attachTo: "ceiling" | "wall-side";
+            reference: string;
+        } | undefined;
+        surfaces?: {
+            id: string;
+            label: string;
+            position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+            size: [import("./recipe.js").Expr, import("./recipe.js").Expr];
+            part?: string | undefined;
+            rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+        }[] | undefined;
+    }, {
+        version: 1;
+        name: string;
+        description: string;
+        parameters: {
+            id: string;
+            label: string;
+            default: number;
+            min: number;
+            max: number;
+            step: number;
+            unit: "count" | "m" | "rad";
+            part?: string | undefined;
+            axis?: "x" | "y" | "z" | undefined;
+        }[];
+        slots: {
+            id: string;
+            label: string;
+            color: string;
+            finish?: "wood" | "glass" | "metal" | undefined;
+        }[];
+        parts: {
+            id: string;
+            label: string;
+            count: import("./recipe.js").Expr;
+            shapes: {
+                id: string;
+                primitive: "box" | "roundedBox" | "cylinder";
+                slot: string;
+                size: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+                rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+                radius?: import("./recipe.js").Expr | undefined;
+                support?: boolean | undefined;
+            }[];
+        }[];
+        constraints: {
+            left: import("./recipe.js").Expr;
+            relation: "lte" | "gte";
+            right: import("./recipe.js").Expr;
+            message: string;
+        }[];
+        classification?: {
+            category: string;
+            functionTags: string[];
+            tags: string[];
+        } | undefined;
+        mounting?: {
+            attachTo: "ceiling" | "wall-side";
+            reference: string;
+        } | undefined;
+        surfaces?: {
+            id: string;
+            label: string;
+            position: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr];
+            size: [import("./recipe.js").Expr, import("./recipe.js").Expr];
+            part?: string | undefined;
+            rotation?: [import("./recipe.js").Expr, import("./recipe.js").Expr, import("./recipe.js").Expr] | undefined;
+        }[] | undefined;
+    }>>;
+    parameters: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodNumber>>;
+    slots: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    position: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    rotation: z.ZodDefault<z.ZodTuple<[z.ZodNumber, z.ZodNumber, z.ZodNumber], null>>;
+    wallId: z.ZodOptional<z.ZodString>;
+    side: z.ZodOptional<z.ZodEnum<{
+        front: "front";
+        back: "back";
+    }>>;
+    supportSlabId: z.ZodOptional<z.ZodString>;
+    children: z.ZodDefault<z.ZodArray<z.ZodString>>;
+    attachments: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+export type ProceduralItemNode = z.infer<typeof ProceduralItemNode>;
+export declare function parameterPatch(node: ProceduralItemNode, id: string, value: number): {
+    parameters: {
+        [x: string]: number;
+    };
+} | null;
+export declare function snapParameters(recipe: Recipe, values: Record<string, number>): {
+    [x: string]: number;
+};
+//# sourceMappingURL=node.d.ts.map

package/dist/procedural-items/node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/procedural-items/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EAA+B,KAAK,MAAM,EAAE,MAAM,UAAU,CAAA;AAanE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCmD,CAAA;AAClF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACnE,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;SAIjF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;EAS5E"}

package/dist/procedural-items/node.js

@@ -0,0 +1,71 @@
+import { z } from 'zod';
+import { BaseNode, nodeType, objectId } from '../schema/base.js';
+import { validateProceduralRelations } from './query.js';
+import { evaluateRecipe, parseRecipe } from './recipe.js';
+const recipe = z.custom().transform((value, ctx) => {
+    try {
+        return parseRecipe(value);
+    }
+    catch (error) {
+        ctx.addIssue({
+            code: 'custom',
+            message: error instanceof Error ? error.message : 'Invalid recipe',
+        });
+        return z.NEVER;
+    }
+});
+export const ProceduralItemNode = BaseNode.extend({
+    id: objectId('procedural-item'),
+    type: nodeType('procedural-item'),
+    recipe,
+    parameters: z.record(z.string(), z.number().finite()).default({}),
+    slots: z
+        .record(z.string(), z.string().regex(/^(#[0-9a-fA-F]{6}|(?:scene|library):[^\s]+)$/))
+        .default({}),
+    position: z
+        .tuple([z.number().finite(), z.number().finite(), z.number().finite()])
+        .default([0, 0, 0]),
+    rotation: z
+        .tuple([z.number().finite(), z.number().finite(), z.number().finite()])
+        .default([0, 0, 0]),
+    wallId: z.string().optional(),
+    side: z.enum(['front', 'back']).optional(),
+    supportSlabId: z.string().optional(),
+    children: z.array(z.string()).default([]),
+    attachments: z.record(z.string(), z.string()).default({}),
+})
+    .superRefine((node, ctx) => {
+    try {
+        const result = evaluateRecipe(node.recipe, node.parameters);
+        for (const slot of Object.keys(node.slots))
+            if (!node.recipe.slots.some((s) => s.id === slot))
+                throw new Error(`Unknown slot ${slot}`);
+        for (const [childId, surfaceId] of Object.entries(node.attachments)) {
+            if (node.children.includes(childId) && !result.surfaces.some((s) => s.id === surfaceId))
+                throw new Error('Remove the hosted item before removing its support surface');
+        }
+    }
+    catch (error) {
+        ctx.addIssue({
+            code: 'custom',
+            message: error instanceof Error ? error.message : 'Invalid parameters',
+        });
+    }
+})
+    .meta({ strictMutations: true, validateRelations: validateProceduralRelations });
+export function parameterPatch(node, id, value) {
+    const parameters = { ...node.parameters, [id]: value };
+    const parsed = ProceduralItemNode.safeParse({ ...node, parameters });
+    return parsed.success ? { parameters } : null;
+}
+export function snapParameters(recipe, values) {
+    const result = { ...values };
+    for (const p of recipe.parameters) {
+        const value = values[p.id];
+        if (value === undefined)
+            continue;
+        const snapped = p.min + Math.round((value - p.min) / p.step) * p.step;
+        result[p.id] = Number(Math.max(p.min, Math.min(p.max, snapped)).toFixed(10));
+    }
+    return result;
+}

package/dist/procedural-items/placement.d.ts

@@ -0,0 +1,7 @@
+import type { CeilingNode } from '../schema/nodes/ceiling.js';
+import type { WallNode } from '../schema/nodes/wall.js';
+import type { ProceduralItemNode } from './node.js';
+import { type QueryNodes } from './query.js';
+export declare function resolveProceduralWallPlacement(node: ProceduralItemNode, wall: WallNode, x: number, y: number, side: 'front' | 'back', nodes: QueryNodes): ProceduralItemNode | null;
+export declare function resolveProceduralCeilingPlacement(node: ProceduralItemNode, ceiling: CeilingNode, x: number, z: number, yaw?: number): ProceduralItemNode;
+//# sourceMappingURL=placement.d.ts.map

package/dist/procedural-items/placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"placement.d.ts","sourceRoot":"","sources":["../../src/procedural-items/placement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,yBAAyB,CAAA;AAC1D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAA;AAChD,OAAO,EAAuB,KAAK,UAAU,EAA+B,MAAM,SAAS,CAAA;AAI3F,wBAAgB,8BAA8B,CAC5C,IAAI,EAAE,kBAAkB,EACxB,IAAI,EAAE,QAAQ,EACd,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,IAAI,EAAE,OAAO,GAAG,MAAM,EACtB,KAAK,EAAE,UAAU,GAChB,kBAAkB,GAAG,IAAI,CA+B3B;AAED,wBAAgB,iCAAiC,CAC/C,IAAI,EAAE,kBAAkB,EACxB,OAAO,EAAE,WAAW,EACpB,CAAC,EAAE,MAAM,EACT,CAAC,EAAE,MAAM,EACT,GAAG,SAAmB,GACrB,kBAAkB,CAWpB"}

package/dist/procedural-items/placement.js

@@ -0,0 +1,48 @@
+import { proceduralLocalPose, validateProceduralRelations } from './query.js';
+import { evaluateRecipe } from './recipe.js';
+import { boundsOf, boxCorners, frame, transformPoint } from './spatial.js';
+export function resolveProceduralWallPlacement(node, wall, x, y, side, nodes) {
+    if (node.recipe.mounting?.attachTo !== 'wall-side' || wall.curveOffset)
+        return null;
+    const candidate = {
+        ...node,
+        parentId: wall.id,
+        wallId: wall.id,
+        side,
+        position: [0, 0, 0],
+        rotation: [0, 0, 0],
+        visible: true,
+    };
+    const e = evaluateRecipe(node.recipe, node.parameters);
+    const pose = proceduralLocalPose(candidate, nodes);
+    const b = boundsOf(boxCorners(e.min, e.max).map((p) => transformPoint(frame(pose.position, pose.rotation), p)));
+    const level = wall.parentId ? nodes[wall.parentId] : undefined;
+    const height = wall.height ?? (level?.type === 'level' ? level.height : 2.5) ?? 2.5;
+    const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    if (b.dimensions[0] > length || b.dimensions[1] > height)
+        return null;
+    candidate.position = [
+        Math.min(length - b.max[0], Math.max(-b.min[0], x)),
+        Math.min(height - b.max[1], Math.max(-b.min[1], y)),
+        0,
+    ];
+    try {
+        validateProceduralRelations(candidate, nodes);
+        return candidate;
+    }
+    catch {
+        return null;
+    }
+}
+export function resolveProceduralCeilingPlacement(node, ceiling, x, z, yaw = node.rotation[1]) {
+    return {
+        ...node,
+        parentId: ceiling.id,
+        wallId: undefined,
+        side: undefined,
+        supportSlabId: undefined,
+        position: [x, 0, z],
+        rotation: [0, yaw, 0],
+        visible: true,
+    };
+}

package/dist/procedural-items/query.d.ts

@@ -0,0 +1,51 @@
+import type { ItemNode } from '../schema/nodes/item.js';
+import type { AnyNode } from '../schema/types.js';
+import type { ProceduralItemNode } from './node.js';
+import { type Vec3 } from './recipe.js';
+import { type Frame } from './spatial.js';
+export type QueryNodes = Readonly<Record<string, AnyNode | ProceduralItemNode>>;
+export declare function isProceduralItem(node: unknown): node is ProceduralItemNode;
+export declare function proceduralLocalPose(node: ProceduralItemNode, nodes: QueryNodes): {
+    position: Vec3;
+    rotation: Vec3;
+};
+export declare function proceduralFootprint(node: ProceduralItemNode): {
+    position: Vec3;
+    rotation: [number, number, number];
+    dimensions: Vec3;
+};
+export declare function nodeLevelFrame(id: string, nodes: QueryNodes, seen?: Set<string>): Frame;
+export declare function attachmentBounds(child: ProceduralItemNode | ItemNode): import("./spatial.js").Bounds;
+export declare function attachmentRegionsOverlap(a: ReturnType<typeof attachmentBounds>, b: ReturnType<typeof attachmentBounds>): boolean;
+export declare function validateProceduralRelations(raw: AnyNode | ProceduralItemNode, nodes: QueryNodes): void;
+export declare function queryProceduralItem(node: ProceduralItemNode, nodes: QueryNodes): {
+    id: `procedural-item_${string}`;
+    kind: "procedural-item";
+    classification: {
+        category: string;
+        functionTags: string[];
+        tags: string[];
+    } | null;
+    hostId: string | null;
+    wallId: string | null;
+    parameters: Record<string, number>;
+    localBounds: {
+        min: Vec3;
+        max: Vec3;
+        dimensions: Vec3;
+    };
+    levelBounds: import("./spatial.js").Bounds;
+    frame: Frame;
+    footprint: number[][];
+    surfaces: {
+        frame: Frame;
+        id: string;
+        label: string;
+        position: Vec3;
+        rotation: Vec3;
+        normal: Vec3;
+        size: [number, number];
+    }[];
+    children: string[];
+};
+//# sourceMappingURL=query.d.ts.map

package/dist/procedural-items/query.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/procedural-items/query.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAIpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAM9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAA;AAChD,OAAO,EAAgC,KAAK,IAAI,EAAE,MAAM,UAAU,CAAA;AAClE,OAAO,EAIL,KAAK,KAAK,EAIX,MAAM,WAAW,CAAA;AAElB,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,kBAAkB,CAAC,CAAC,CAAA;AAC/E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,kBAAkB,CAI1E;AAQD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,UAAU;;;EA6B9E;AACD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB;;;;EAK3D;AAyFD,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,cAAoB,GAAG,KAAK,CA0F7F;AAMD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,QAAQ,8BAKpE;AACD,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EACtC,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,WAQvC;AA0BD,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,EAAE,KAAK,EAAE,UAAU,QAkG/F;AACD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B9E"}