@pascal-app/ifc-converter 1.0.3 → 1.0.4

package/dist/export/step.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Minimal ISO-10303-21 (STEP physical file) writer for IFC4.
+ *
+ * Entities are serialized the moment they are added, so the file order is
+ * the insertion order and entity numbers are deterministic for a given
+ * input. Attribute values are plain TS values; the wrappers below cover the
+ * STEP-specific literals (enums, integers, typed selects, `$` and `*`).
+ */
+export declare class StepRef {
+    readonly id: number;
+    constructor(id: number);
+}
+declare class StepEnum {
+    readonly value: string;
+    constructor(value: string);
+}
+declare class StepInt {
+    readonly value: number;
+    constructor(value: number);
+}
+declare class StepTyped {
+    readonly type: string;
+    readonly value: StepValue;
+    constructor(type: string, value: StepValue);
+}
+declare class StepRaw {
+    readonly text: string;
+    constructor(text: string);
+}
+declare const DERIVED_TOKEN: unique symbol;
+export type StepValue = null | undefined | boolean | number | string | StepRef | StepEnum | StepInt | StepTyped | StepRaw | typeof DERIVED_TOKEN | readonly StepValue[];
+/** `*` — attribute re-declared as derived in a subtype. */
+export declare const DERIVED: typeof DERIVED_TOKEN;
+export declare const enumValue: (value: string) => StepEnum;
+export declare const int: (value: number) => StepInt;
+export declare const typed: (type: string, value: StepValue) => StepTyped;
+/** Pre-serialized attribute text, for large aggregates built in a tight loop. */
+export declare const raw: (text: string) => StepRaw;
+export declare function formatReal(value: number, decimals?: number): string;
+/** STEP string literal with ISO 10303-21 escapes for quotes, backslashes and non-ASCII. */
+export declare function formatString(value: string): string;
+export declare function formatValue(value: StepValue): string;
+export interface StepHeader {
+    description: string;
+    fileName: string;
+    timestamp: string;
+    author: string;
+    organization: string;
+    preprocessor: string;
+    originatingSystem: string;
+    schema: string;
+}
+export declare class StepWriter {
+    private readonly lines;
+    private readonly shared;
+    private nextId;
+    readonly counts: Map<string, number>;
+    add(type: string, ...args: StepValue[]): StepRef;
+    /** Reuse one entity for identical simple values (points, directions, styles). */
+    addShared(type: string, ...args: StepValue[]): StepRef;
+    serialize(header: StepHeader): string;
+}
+export {};
+//# sourceMappingURL=step.d.ts.map

package/dist/export/step.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step.d.ts","sourceRoot":"","sources":["../../src/export/step.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAEH,qBAAa,OAAO;IACN,QAAQ,CAAC,EAAE,EAAE,MAAM;gBAAV,EAAE,EAAE,MAAM;CAChC;AAED,cAAM,QAAQ;IACA,QAAQ,CAAC,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM;CACnC;AAED,cAAM,OAAO;IACC,QAAQ,CAAC,KAAK,EAAE,MAAM;gBAAb,KAAK,EAAE,MAAM;CACnC;AAED,cAAM,SAAS;IAEX,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,KAAK,EAAE,SAAS;gBADhB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,SAAS;CAE5B;AAED,cAAM,OAAO;IACC,QAAQ,CAAC,IAAI,EAAE,MAAM;gBAAZ,IAAI,EAAE,MAAM;CAClC;AAED,QAAA,MAAM,aAAa,eAAoB,CAAA;AAEvC,MAAM,MAAM,SAAS,GACjB,IAAI,GACJ,SAAS,GACT,OAAO,GACP,MAAM,GACN,MAAM,GACN,OAAO,GACP,QAAQ,GACR,OAAO,GACP,SAAS,GACT,OAAO,GACP,OAAO,aAAa,GACpB,SAAS,SAAS,EAAE,CAAA;AAExB,2DAA2D;AAC3D,eAAO,MAAM,OAAO,EAAE,OAAO,aAA6B,CAAA;AAC1D,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,aAAwB,CAAA;AAC/D,eAAO,MAAM,GAAG,GAAI,OAAO,MAAM,YAAmC,CAAA;AACpE,eAAO,MAAM,KAAK,GAAI,MAAM,MAAM,EAAE,OAAO,SAAS,cAA+B,CAAA;AACnF,iFAAiF;AACjF,eAAO,MAAM,GAAG,GAAI,MAAM,MAAM,YAAsB,CAAA;AAEtD,wBAAgB,UAAU,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,SAAI,GAAG,MAAM,CAc9D;AAED,2FAA2F;AAC3F,wBAAgB,YAAY,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAsBlD;AAED,wBAAgB,WAAW,CAAC,KAAK,EAAE,SAAS,GAAG,MAAM,CAYpD;AAED,MAAM,WAAW,UAAU;IACzB,WAAW,EAAE,MAAM,CAAA;IACnB,QAAQ,EAAE,MAAM,CAAA;IAChB,SAAS,EAAE,MAAM,CAAA;IACjB,MAAM,EAAE,MAAM,CAAA;IACd,YAAY,EAAE,MAAM,CAAA;IACpB,YAAY,EAAE,MAAM,CAAA;IACpB,iBAAiB,EAAE,MAAM,CAAA;IACzB,MAAM,EAAE,MAAM,CAAA;CACf;AAED,qBAAa,UAAU;IACrB,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAe;IACrC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAA6B;IACpD,OAAO,CAAC,MAAM,CAAI;IAClB,QAAQ,CAAC,MAAM,sBAA4B;IAE3C,GAAG,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,GAAG,OAAO;IAOhD,iFAAiF;IACjF,SAAS,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,IAAI,EAAE,SAAS,EAAE,GAAG,OAAO;IAStD,SAAS,CAAC,MAAM,EAAE,UAAU,GAAG,MAAM;CAoBtC"}

package/dist/export/step.js

@@ -0,0 +1,158 @@
+/**
+ * Minimal ISO-10303-21 (STEP physical file) writer for IFC4.
+ *
+ * Entities are serialized the moment they are added, so the file order is
+ * the insertion order and entity numbers are deterministic for a given
+ * input. Attribute values are plain TS values; the wrappers below cover the
+ * STEP-specific literals (enums, integers, typed selects, `$` and `*`).
+ */
+export class StepRef {
+    id;
+    constructor(id) {
+        this.id = id;
+    }
+}
+class StepEnum {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+class StepInt {
+    value;
+    constructor(value) {
+        this.value = value;
+    }
+}
+class StepTyped {
+    type;
+    value;
+    constructor(type, value) {
+        this.type = type;
+        this.value = value;
+    }
+}
+class StepRaw {
+    text;
+    constructor(text) {
+        this.text = text;
+    }
+}
+const DERIVED_TOKEN = Symbol('derived');
+/** `*` — attribute re-declared as derived in a subtype. */
+export const DERIVED = DERIVED_TOKEN;
+export const enumValue = (value) => new StepEnum(value);
+export const int = (value) => new StepInt(Math.round(value));
+export const typed = (type, value) => new StepTyped(type, value);
+/** Pre-serialized attribute text, for large aggregates built in a tight loop. */
+export const raw = (text) => new StepRaw(text);
+export function formatReal(value, decimals = 9) {
+    if (!Number.isFinite(value))
+        return '0.';
+    const scale = 10 ** decimals;
+    let rounded = Math.round(value * scale) / scale;
+    if (Object.is(rounded, -0))
+        rounded = 0;
+    let text = String(rounded);
+    const exponent = text.indexOf('e');
+    if (exponent >= 0) {
+        const mantissa = text.slice(0, exponent);
+        text = `${mantissa.includes('.') ? mantissa : `${mantissa}.`}E${text.slice(exponent + 1)}`;
+    }
+    else if (!text.includes('.')) {
+        text += '.';
+    }
+    return text;
+}
+/** STEP string literal with ISO 10303-21 escapes for quotes, backslashes and non-ASCII. */
+export function formatString(value) {
+    let out = "'";
+    let wide = '';
+    const flushWide = () => {
+        if (!wide)
+            return;
+        out += `\\X2\\${wide}\\X0\\`;
+        wide = '';
+    };
+    for (const char of value) {
+        const code = char.codePointAt(0);
+        if (code >= 0x20 && code <= 0x7e) {
+            flushWide();
+            out += char === "'" ? "''" : char === '\\' ? '\\\\' : char;
+        }
+        else if (code > 0xffff) {
+            flushWide();
+            out += `\\X4\\${code.toString(16).toUpperCase().padStart(8, '0')}\\X0\\`;
+        }
+        else {
+            wide += code.toString(16).toUpperCase().padStart(4, '0');
+        }
+    }
+    flushWide();
+    return `${out}'`;
+}
+export function formatValue(value) {
+    if (value === null || value === undefined)
+        return '$';
+    if (value === DERIVED_TOKEN)
+        return '*';
+    if (typeof value === 'boolean')
+        return value ? '.T.' : '.F.';
+    if (typeof value === 'number')
+        return formatReal(value);
+    if (typeof value === 'string')
+        return formatString(value);
+    if (value instanceof StepRef)
+        return `#${value.id}`;
+    if (value instanceof StepEnum)
+        return `.${value.value}.`;
+    if (value instanceof StepInt)
+        return String(value.value);
+    if (value instanceof StepRaw)
+        return value.text;
+    if (value instanceof StepTyped)
+        return `${value.type}(${formatValue(value.value)})`;
+    return `(${value.map(formatValue).join(',')})`;
+}
+export class StepWriter {
+    lines = [];
+    shared = new Map();
+    nextId = 1;
+    counts = new Map();
+    add(type, ...args) {
+        const ref = new StepRef(this.nextId++);
+        this.lines.push(`#${ref.id}=${type}(${args.map(formatValue).join(',')});`);
+        this.counts.set(type, (this.counts.get(type) ?? 0) + 1);
+        return ref;
+    }
+    /** Reuse one entity for identical simple values (points, directions, styles). */
+    addShared(type, ...args) {
+        const key = `${type}(${args.map(formatValue).join(',')})`;
+        const existing = this.shared.get(key);
+        if (existing)
+            return existing;
+        const ref = this.add(type, ...args);
+        this.shared.set(key, ref);
+        return ref;
+    }
+    serialize(header) {
+        const head = [
+            'ISO-10303-21;',
+            'HEADER;',
+            `FILE_DESCRIPTION((${formatString(header.description)}),'2;1');`,
+            `FILE_NAME(${[
+                formatString(header.fileName),
+                formatString(header.timestamp),
+                `(${formatString(header.author)})`,
+                `(${formatString(header.organization)})`,
+                formatString(header.preprocessor),
+                formatString(header.originatingSystem),
+                "''",
+            ].join(',')});`,
+            `FILE_SCHEMA((${formatString(header.schema)}));`,
+            'ENDSEC;',
+            'DATA;',
+        ];
+        return `${[...head, ...this.lines, 'ENDSEC;', 'END-ISO-10303-21;'].join('\n')}\n`;
+    }
+}

package/dist/export/wall-base.d.ts

@@ -0,0 +1,25 @@
+import { type WallNode, type wallSupportForNodes } from '@pascal-app/core';
+type WallSupport = ReturnType<typeof wallSupportForNodes>;
+/** A run of the wall (normalised arc length) on one side, with its bottom elevation. */
+export interface WallBaseCell {
+    t0: number;
+    t1: number;
+    /** Which half of the thickness: both, or the `a` / `b` face half. */
+    side: 'both' | 'a' | 'b';
+    bottom: number;
+}
+/**
+ * The wall renderer's stepped bottom (`generateExtrudedWall`), as additive
+ * cells: it extrudes from the lowest exposed support, then cuts away the
+ * volume below every higher-supported run — per face when the two faces sit
+ * on different floors. Returned cells cover the whole wall.
+ */
+export declare function wallBaseCells(wall: WallNode, support: WallSupport, top: number): WallBaseCell[];
+/**
+ * Plan band (Pascal x/z) covering a cell's run and side, generously past the
+ * faces and past the wall ends so mitred corners are included — the same
+ * band the renderer cuts with.
+ */
+export declare function wallCellBand(wall: WallNode, cell: WallBaseCell): [number, number][];
+export {};
+//# sourceMappingURL=wall-base.d.ts.map

package/dist/export/wall-base.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-base.d.ts","sourceRoot":"","sources":["../../src/export/wall-base.ts"],"names":[],"mappings":"AAAA,OAAO,EAML,KAAK,QAAQ,EACb,KAAK,mBAAmB,EACzB,MAAM,kBAAkB,CAAA;AAEzB,KAAK,WAAW,GAAG,UAAU,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAGzD,wFAAwF;AACxF,MAAM,WAAW,YAAY;IAC3B,EAAE,EAAE,MAAM,CAAA;IACV,EAAE,EAAE,MAAM,CAAA;IACV,qEAAqE;IACrE,IAAI,EAAE,MAAM,GAAG,GAAG,GAAG,GAAG,CAAA;IACxB,MAAM,EAAE,MAAM,CAAA;CACf;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,QAAQ,EAAE,OAAO,EAAE,WAAW,EAAE,GAAG,EAAE,MAAM,GAAG,YAAY,EAAE,CAwE/F;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAAC,IAAI,EAAE,QAAQ,EAAE,IAAI,EAAE,YAAY,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAmBnF"}

package/dist/export/wall-base.js

@@ -0,0 +1,91 @@
+import { DEFAULT_WALL_THICKNESS, getWallBodyCenterOffset, getWallCurveFrameAt, isCurvedWall, resolveWallFaceBottom, } from '@pascal-app/core';
+/**
+ * The wall renderer's stepped bottom (`generateExtrudedWall`), as additive
+ * cells: it extrudes from the lowest exposed support, then cuts away the
+ * volume below every higher-supported run — per face when the two faces sit
+ * on different floors. Returned cells cover the whole wall.
+ */
+export function wallBaseCells(wall, support, top) {
+    const slabElevation = support.elevation;
+    const baseElevation = support.baseElevation ?? slabElevation;
+    const baseSegments = support.baseSegments?.length
+        ? support.baseSegments
+        : [{ start: 0, end: 1, elevation: baseElevation }];
+    const faceBase = support.faceDatum
+        ? {
+            a: resolveWallFaceBottom(support.faceDatum.a, baseSegments, slabElevation),
+            b: resolveWallFaceBottom(support.faceDatum.b, baseSegments, slabElevation),
+        }
+        : undefined;
+    const useFaceBase = faceBase !== undefined &&
+        ![faceBase.a, faceBase.b].every((segments) => JSON.stringify(segments) === JSON.stringify(baseSegments));
+    const lowest = useFaceBase
+        ? Math.min(...[...faceBase.a, ...faceBase.b].flatMap((segment) => [
+            segment.elevation,
+            segment.endElevation ?? segment.elevation,
+        ]), slabElevation)
+        : Math.min(baseElevation, slabElevation);
+    const profiles = useFaceBase
+        ? [
+            ...faceBase.a.map((segment) => ({ segment, face: 'a' })),
+            ...faceBase.b.map((segment) => ({ segment, face: 'b' })),
+        ]
+        : baseSegments.map((segment) => ({ segment, face: undefined }));
+    const raised = profiles.flatMap(({ segment, face }) => {
+        const elevation = face
+            ? Math.min(Math.max(segment.elevation, segment.endElevation ?? segment.elevation), top)
+            : Math.min(segment.elevation, slabElevation);
+        const t0 = Math.max(0, Math.min(1, segment.start));
+        const t1 = Math.max(0, Math.min(1, segment.end));
+        return elevation - lowest > 1e-6 && t1 - t0 > 1e-7 ? [{ t0, t1, face, elevation }] : [];
+    });
+    if (raised.length === 0)
+        return [{ t0: 0, t1: 1, side: 'both', bottom: lowest }];
+    const cuts = [...new Set([0, 1, ...raised.flatMap((run) => [run.t0, run.t1])])].sort((a, b) => a - b);
+    const sides = useFaceBase ? ['a', 'b'] : ['both'];
+    const cells = [];
+    for (const side of sides) {
+        for (let i = 1; i < cuts.length; i++) {
+            const t0 = cuts[i - 1];
+            const t1 = cuts[i];
+            if (t1 - t0 <= 1e-9)
+                continue;
+            const mid = (t0 + t1) / 2;
+            const bottom = Math.max(lowest, ...raised
+                .filter((run) => run.t0 <= mid && run.t1 >= mid && (run.face === undefined || run.face === side))
+                .map((run) => run.elevation));
+            const previous = cells[cells.length - 1];
+            if (previous && previous.side === side && previous.t1 === t0 && previous.bottom === bottom) {
+                previous.t1 = t1;
+            }
+            else {
+                cells.push({ t0, t1, side, bottom });
+            }
+        }
+    }
+    return cells;
+}
+/**
+ * Plan band (Pascal x/z) covering a cell's run and side, generously past the
+ * faces and past the wall ends so mitred corners are included — the same
+ * band the renderer cuts with.
+ */
+export function wallCellBand(wall, cell) {
+    const reach = Math.max((wall.thickness ?? DEFAULT_WALL_THICKNESS) * 2, 0.2);
+    const center = getWallBodyCenterOffset(wall);
+    const left = cell.side === 'b' ? center : reach;
+    const right = cell.side === 'a' ? center : -reach;
+    const samples = isCurvedWall(wall) ? Math.max(2, Math.ceil((cell.t1 - cell.t0) * 24)) : 1;
+    const leftSide = [];
+    const rightSide = [];
+    for (let index = 0; index <= samples; index++) {
+        const t = cell.t0 + ((cell.t1 - cell.t0) * index) / samples;
+        const frame = getWallCurveFrameAt(wall, t);
+        const extension = index === 0 && cell.t0 <= 1e-7 ? -reach : index === samples && cell.t1 >= 1 - 1e-7 ? reach : 0;
+        const x = frame.point.x + frame.tangent.x * extension;
+        const z = frame.point.y + frame.tangent.y * extension;
+        leftSide.push([x + frame.normal.x * left, z + frame.normal.y * left]);
+        rightSide.push([x + frame.normal.x * right, z + frame.normal.y * right]);
+    }
+    return [...leftSide, ...rightSide.reverse()];
+}

package/dist/ids.d.ts

@@ -0,0 +1,3 @@
+export declare function seedIds(source: Uint8Array): void;
+export declare function nextId<T extends string>(prefix: T): `${T}_${string}`;
+//# sourceMappingURL=ids.d.ts.map

package/dist/ids.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ids.d.ts","sourceRoot":"","sources":["../src/ids.ts"],"names":[],"mappings":"AA0BA,wBAAgB,OAAO,CAAC,MAAM,EAAE,UAAU,GAAG,IAAI,CAIhD;AAED,wBAAgB,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,CAAC,GAAG,GAAG,CAAC,IAAI,MAAM,EAAE,CAMpE"}

package/dist/ids.js

@@ -0,0 +1,35 @@
+// Node ids are drawn from a sequence seeded by the IFC bytes, not from a random
+// source: room detection breaks near-ties by id order, so random ids made the
+// same file import differently from run to run.
+let seedA = 0;
+let seedB = 0;
+let counter = 0;
+function fnv1a(bytes, basis) {
+    let hash = basis;
+    for (let i = 0; i < bytes.length; i++) {
+        hash ^= bytes[i];
+        hash = Math.imul(hash, 0x01000193);
+    }
+    return hash >>> 0;
+}
+function mix(value) {
+    let x = value >>> 0;
+    x ^= x >>> 16;
+    x = Math.imul(x, 0x7feb352d);
+    x ^= x >>> 15;
+    x = Math.imul(x, 0x846ca68b);
+    x ^= x >>> 16;
+    return x >>> 0;
+}
+export function seedIds(source) {
+    seedA = fnv1a(source, 0x811c9dc5);
+    seedB = fnv1a(source, 0x9e3779b9);
+    counter = 0;
+}
+export function nextId(prefix) {
+    counter++;
+    const high = mix(seedA ^ Math.imul(counter, 0x9e3779b1));
+    const low = mix(seedB + Math.imul(counter, 0x85ebca6b));
+    const body = `${high.toString(36).padStart(7, '0')}${low.toString(36).padStart(7, '0')}`;
+    return `${prefix}_${body}`;
+}

package/dist/index.d.ts

@@ -1,11 +1,11 @@
-import { type AnyNode, type AnyNodeId } from '@pascal-app/core';
+import { type AnyNode, type AnyNodeId, type Collection } from '@pascal-app/core';
 import { type IfcConversionSimplificationOptions } from './cleanup';
 export type { IfcConversionSimplificationOptions, IfcConversionSimplificationStats, } from './cleanup';
 export type PascalNode = AnyNode;
 export interface PascalSceneGraph {
     nodes: Record<AnyNodeId, AnyNode>;
     rootNodeIds: AnyNodeId[];
-    collections?: Record<string, unknown>;
+    collections?: Record<string, Collection>;
 }
 export interface ConversionOptions {
     swapYZ?: boolean;

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAkBf,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,KAAK,kCAAkC,EAA+B,MAAM,WAAW,CAAA;AAIhG,YAAY,EACV,kCAAkC,EAClC,gCAAgC,GACjC,MAAM,WAAW,CAAA;AAElB,MAAM,MAAM,UAAU,GAAG,OAAO,CAAA;AAEhC,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CACtC;AAixBD,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,GAAG,kCAAkC,CAAA;IACvD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAa7D,CAAA;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,UAAU,EACnB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,EACvD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,gBAAgB,CAAC,CA8nD3B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAId,KAAK,UAAU,EAmBhB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,KAAK,kCAAkC,EAA+B,MAAM,WAAW,CAAA;AAQhG,YAAY,EACV,kCAAkC,EAClC,gCAAgC,GACjC,MAAM,WAAW,CAAA;AAElB,MAAM,MAAM,UAAU,GAAG,OAAO,CAAA;AAEhC,MAAM,WAAW,gBAAgB;IAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,UAAU,CAAC,CAAA;CACzC;AAiyBD,MAAM,WAAW,iBAAiB;IAChC,MAAM,CAAC,EAAE,OAAO,CAAA;IAChB,sBAAsB,CAAC,EAAE,OAAO,CAAA;IAChC,qBAAqB,CAAC,EAAE,OAAO,CAAA;IAC/B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,CAAC,EAAE,OAAO,GAAG,kCAAkC,CAAA;IACvD,KAAK,CAAC,EAAE,MAAM,CAAA;CACf;AAED,eAAO,MAAM,eAAe,EAAE,MAAM,CAAC,MAAM,EAAE,iBAAiB,CAa7D,CAAA;AAED,wBAAsB,kBAAkB,CACtC,OAAO,EAAE,UAAU,EACnB,UAAU,CAAC,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,KAAK,IAAI,EACvD,OAAO,CAAC,EAAE,iBAAiB,GAC1B,OAAO,CAAC,gBAAgB,CAAC,CA8/D3B"}