@ifc-lite/export 2.9.3 → 3.0.0

package/dist/step-exporter.d.ts

@@ -5,116 +5,15 @@
  * Supports applying property and root attribute mutations before export.
  */
 import type { IfcDataStore } from '@ifc-lite/parser';
-import { type MapConversion, type ProjectedCRS } from '@ifc-lite/parser';
 import type { MutablePropertyView } from '@ifc-lite/mutations';
-import { type RandomSource } from '@ifc-lite/encoding';
 /**
- * Options for STEP export
+ * The export vocabulary lives in `step-export-types.ts` (#2475). Re-exported
+ * here, unchanged, so that the package entry point and the seven sibling
+ * modules that import `ExportPass` / `SourceLineMutations` from this file
+ * carry on doing exactly that -- the split moved declarations, not call sites.
  */
-export interface StepExportOptions {
-    /** IFC schema version for the output file (any version, will convert if needed) */
-    schema: 'IFC2X3' | 'IFC4' | 'IFC4X3' | 'IFC5';
-    /** File description */
-    description?: string;
-    /** Author name */
-    author?: string;
-    /** Organization name */
-    organization?: string;
-    /** Application name (defaults to 'ifc-lite') */
-    application?: string;
-    /** Output filename */
-    filename?: string;
-    /** Include original geometry entities (default: true) */
-    includeGeometry?: boolean;
-    /** Include property sets (default: true) */
-    includeProperties?: boolean;
-    /** Include quantity sets (default: true) */
-    includeQuantities?: boolean;
-    /** Include relationships (default: true) */
-    includeRelationships?: boolean;
-    /** Apply mutations from MutablePropertyView (default: true if provided) */
-    applyMutations?: boolean;
-    /** Only export entities with mutations (delta export) */
-    deltaOnly?: boolean;
-    /** Only export entities currently visible in the viewer */
-    visibleOnly?: boolean;
-    /** Hidden entity IDs (local expressIds) — required when visibleOnly is true */
-    hiddenEntityIds?: Set<number>;
-    /** Isolated entity IDs (local expressIds, null = no isolation active) */
-    isolatedEntityIds?: Set<number> | null;
-    /** Georeferencing mutations to apply (IfcProjectedCRS / IfcMapConversion edits) */
-    georefMutations?: {
-        projectedCRS?: Partial<ProjectedCRS>;
-        mapConversion?: Partial<MapConversion>;
-    };
-    /**
-     * Seeded randomness for the GlobalIds this exporter SYNTHESIZES:
-     * the `IfcPropertySet` / `IfcElementQuantity` roots regenerated for
-     * mutated (or overlay-created) property and quantity sets, their
-     * `IfcRelDefinesByProperties` links, and any `IFCPROXY` placeholder minted
-     * by schema conversion. Without it those come from the platform CSPRNG, so
-     * two exports of the same model differ in exactly those bytes - which
-     * breaks byte-reproducibility for in-store builds that call
-     * `addPropertySet` / `addQuantitySet` (the sets themselves live in the
-     * mutation overlay and only become IFC roots here). Pass the same seeded
-     * source used for `SpatialAnchor.guidRandom` to close that gap. Default
-     * (omitted) behaviour is unchanged: random.
-     */
-    guidRandom?: RandomSource;
-    /**
-     * Pin the STEP header `FILE_NAME` timestamp (STEP format, e.g.
-     * `20240101T000000`). Omitted = the wall clock, as before. Required for
-     * genuinely byte-identical exports, since the header otherwise carries the
-     * export instant.
-     */
-    timeStamp?: string;
-    /** Progress callback for async export */
-    onProgress?: (progress: StepExportProgress) => void;
-}
-/**
- * Progress information during STEP export
- */
-export interface StepExportProgress {
-    /** Current phase of export */
-    phase: 'preparing' | 'entities' | 'assembling';
-    /** Progress 0-1 */
-    percent: number;
-    /** Number of entities processed so far */
-    entitiesProcessed: number;
-    /** Total entities to process */
-    entitiesTotal: number;
-}
-/**
- * Result of STEP export
- */
-export interface StepExportResult {
-    /** STEP file content as bytes (avoids V8 string length limit for large files) */
-    content: Uint8Array;
-    /** Statistics about the export */
-    stats: {
-        /** Total entities exported */
-        entityCount: number;
-        /** New entities created for mutations */
-        newEntityCount: number;
-        /** Entities modified by mutations */
-        modifiedEntityCount: number;
-        /** File size in bytes */
-        fileSize: number;
-        /**
-         * Non-fatal refusals: things the caller asked for that this export could
-         * not write. Empty when the export did everything it was asked to do.
-         *
-         * A requested `georefMutations.mapConversion` is the one case today: with
-         * no `IfcGeometricRepresentationContext` to reference as `SourceCRS`, the
-         * `IfcMapConversion` is skipped (writing it would produce a dangling
-         * reference) while the `IfcProjectedCRS` is still written — so the output
-         * is indistinguishable from "no map conversion was requested" unless the
-         * caller reads this (#2067). Same `string[]` shape as
-         * `MergeExportResult.stats.warnings`.
-         */
-        warnings: string[];
-    };
-}
+export type { StepExportOptions, StepExportProgress, StepExportResult, SourceLineMutations, ExportPass, } from './step-export-types.js';
+import type { StepExportOptions, StepExportResult } from './step-export-types.js';
 /**
  * IFC STEP file exporter
  */
@@ -123,11 +22,16 @@ export declare class StepExporter {
     private mutationView;
     private nextExpressId;
     private entityExtractor;
-    /** Lazily-resolved fallback `#id` of an IfcOwnerHistory that survives the
-     *  current export closure (or `$` when the file has none). */
-    private ownerHistoryFallbackRef;
-    /** Per-host cache of an element's own OwnerHistory ref (`#id` or null). */
-    private ownerHistoryByEntity;
+    /**
+     * The owner-history memos the property-set and quantity-set generators read.
+     *
+     * Owned here and handed to `step-property-sets.ts` BY REFERENCE rather than
+     * stored on its context: the reset below is an `export()`-level statement,
+     * and the comment there is where "per export, not per exporter" is argued.
+     * Moving the storage into a per-export context would make that reset
+     * implicit — the same invariant, in a place nothing says it (#2475 step 2b).
+     */
+    private ownerHistory;
     /**
      * "Can this record's line actually be read out of this store's source?"
      * (`source-ref-bounds.ts`, #2491). Built once — `dataStore` is assigned in
@@ -149,305 +53,48 @@ export declare class StepExporter {
      * Export only property/quantity changes (lightweight export)
      */
     exportPropertiesOnly(options: Omit<StepExportOptions, 'includeGeometry'>): StepExportResult;
-    /**
-     * Resolve a STEP reference to an existing IfcOwnerHistory for the
-     * IfcPropertySet / IfcRelDefinesByProperties / IfcElementQuantity entities we
-     * generate for `hostEntityId`'s mutations. OwnerHistory is optional in IFC4 but
-     * MANDATORY in IFC2X3 (IfcRoot.OwnerHistory), so emitting `$` yields an invalid
-     * IFC2X3 file that strict readers (e.g. BIM Vision) reject.
-     *
-     * Prefer the host element's OWN owner history, then any owner history that
-     * survives this export, then `$` only when none does.
-     *
-     * "Survives" is `willBeEmitted`, the same predicate that decides whether the
-     * host itself may have psets generated for it. A reference is a reference: it
-     * is no more acceptable to point an emitted `IfcPropertySet` at an owner
-     * history the session deleted than at a host it deleted. This used to consult
-     * only the `visibleOnly` closure, so an overlay-created OwnerHistory that was
-     * later deleted still got referenced — a dangling `#N`, reached through the
-     * one attribute the generators fill in for themselves.
-     */
-    private resolveOwnerHistoryRef;
-    /**
-     * The overlay's answer for one positional slot of an overlay-created entity,
-     * falling back to the creation payload only when the overlay has NOTHING to
-     * say about that slot.
-     *
-     * **Ask `Map.has`, never `??`.** `setPositionalAttribute(id, slot, null)` is
-     * an explicit "clear this slot", and its value is `null`, so `??` reads the
-     * overlay's answer as an absence and reinstates the authored one. That is the
-     * same overlay-versus-buffer confusion this whole change is about, one
-     * attribute wide: an explicit null IS the overlay's answer, and the overlay is
-     * the authority. Cleared OwnerHistory came back as the authored reference, and
-     * a cleared `HasPropertySets` resurrected the list the user had removed.
-     */
-    private overlaySlotValue;
-    /**
-     * Read an element's own OwnerHistory reference (`#id`), or null when the
-     * element omits one (`$`) or cannot be parsed. OwnerHistory is the second
-     * attribute of every IfcRoot subtype, immediately after the GlobalId string.
-     */
-    private getOwnerHistoryRefOfEntity;
-    /**
-     * Generate STEP entities for property sets
-     */
-    private generatePropertySetEntities;
-    /**
-     * Generate STEP entities for quantity sets (IfcElementQuantity)
-     */
-    private generateQuantitySetEntities;
-    /**
-     * THE mutation pipeline for a line read out of the source buffer: retype,
-     * then named attribute edits, then positional edits.
-     *
-     * **One implementation, two call sites**, and that is the whole point. Two
-     * passes can write the defining line of a source entity — the
-     * source-iteration pass, and the type-object `HasPropertySets` rewrite that
-     * REPLACES it (`rewrittenEntityIds` makes the source pass skip those ids).
-     * The rewrite used to do its own thing (replace slot 5, nothing else), so
-     * every other edit to a type object with a type-owned pset edit was dropped
-     * in silence: first the renames (#2462 follow-up), and after those were
-     * special-cased here, still the retypes and the positional edits. Whatever
-     * the source pass applies, the rewrite has to apply too, or the next edit
-     * kind added to one site goes missing at the other.
-     *
-     * The order is load-bearing:
-     *
-     *   - the retype runs FIRST so named attribute edits resolve against the
-     *     TARGET class's attribute names, and so positional slots are indexed
-     *     into the retyped argument list;
-     *   - the `HasPropertySets` replacement (rewrite path only) runs LAST, on
-     *     the text this returns. Run it first and a positional edit to slot 5 —
-     *     or a retype's argument-list rebuild — overwrites the resolved pset
-     *     list with the stale one, which is the same silent drop one slot over.
-     *
-     * The expressId is unchanged by all of this, so geometry / placement /
-     * representation and every IfcRel* reference (keyed by #id) carry over.
-     *
-     * All three flags report EFFECT, not intent — each is the answer to "did this
-     * operation change the line", measured across that operation alone. The count
-     * and the ledger are claims about the FILE, so an edit that resolves to the
-     * text already there has delivered nothing and must not be reported: retyping
-     * an entity to the class it already is, or writing a positional slot the token
-     * it already holds, used to count as a modification and reach the ledger as a
-     * landed edit, over a byte-identical line. Discarded edits read the same way:
-     * `applyAttributeMutations` drops a name its class has no slot for and
-     * `retypeStepLine` returns an unparseable line untouched, and neither is a
-     * modification of anything.
-     *
-     * `retyped` / `positional` matter most in a FULL export, which is where the
-     * two are nominated (their edits have no earlier nomination site); named
-     * attribute edits are nominated by the collection pass and `attributed` only
-     * settles their delivery.
-     */
-    private applySourceLineMutations;
-    /**
-     * Rewrite root IFC attributes directly on the original STEP entity line.
-     */
-    private applyAttributeMutations;
-    /**
-     * Serialize one NAMED attribute override into its slot — the single point
-     * both the source-buffer rewrite and the overlay-created rewrite go through.
-     *
-     * `serializeAttributeValue` decides the STEP form by reading the token being
-     * replaced, which is sound only while that token carries type information. A
-     * `$` slot carries none, and both paths have plenty: a source record's
-     * optional attributes are `$`, and overlay-created records pad missing slots
-     * with `$`. So the declared type decides first, and inference is the fallback
-     * for slots the schema does not classify (references, SELECTs, numerics),
-     * where reading the old token is exactly the right heuristic.
-     */
-    private serializeNamedAttribute;
-    /**
-     * Apply overlay attribute + positional overrides to an OVERLAY-CREATED
-     * entity's argument list (#2006).
-     *
-     * Distinct from {@link applyAttributeMutations} / {@link applyPositionalMutations},
-     * which rewrite a line read out of the source buffer. Here the whole line is
-     * ours: it was serialized moments ago from the creation payload, so the
-     * argument list is the authoring payload's, not the file's. That difference
-     * is why this PADS — `entity_create` takes whatever positional list the
-     * caller passes, so a wall authored with three arguments still has a real
-     * `Tag` slot at index 7, and dropping the edit because the payload was short
-     * would be the very data loss this fixes. The source-buffer path must not
-     * pad: there a short line means a different schema, and growing a record we
-     * did not author would corrupt it.
-     *
-     * Named and positional overrides resolve to a slot index up front and share
-     * ONE padding rule. Two padding rules on one record is how the next bug
-     * starts, and the argument for padding — the class is fixed at creation time,
-     * so a short payload is partial authoring — never depended on which of the
-     * two APIs queued the edit.
-     */
-    private applyOverlayEntityOverrides;
-    /**
-     * Apply positional STEP argument overrides to an entity line.
-     * Used for non-IfcRoot edits (e.g. profile dimensions) where attributes
-     * have no symbolic names. Indexes that fall outside the existing arg list
-     * are silently ignored.
-     */
-    private applyPositionalMutations;
-    /**
-     * Serialize one positional override, composing the schema-aware passes:
-     * explicit `{ real }`/`{ typed }` marker → SELECT auto-qualification
-     * (`IFCBOOLEAN(.T.)`) → REAL forcing. For REAL forcing the current source
-     * token is a secondary signal: replacing a value that was already a REAL
-     * (`0.4`, `1.5E-7`) keeps it REAL even for entities the XSD index doesn't
-     * cover, so a whole-number edit can't silently downgrade the slot.
-     */
-    private serializePositionalOverride;
-    private resolveMapUnitReference;
-    private normalizeMapUnitName;
-    /**
-     * `effective` filters the candidates the same way the georef reads above do:
-     * returning a tombstoned unit id hands the caller a `#id` for a line the
-     * export never writes. Returning null instead makes `resolveMapUnitReference`
-     * synthesise a fresh unit, which is the outcome a deleted unit deserves.
-     */
-    private findLengthUnitReference;
-    /**
-     * Record that a requested IfcMapConversion could not be written. Emitting it
-     * anyway would leave `SourceCRS` pointing at nothing, so the refusal is the
-     * correct output — but the file alone cannot express it, which is why it goes
-     * back to the caller in `stats.warnings` as well as to the console (#2067).
-     */
-    private reportMapConversionRefused;
-    /**
-     * Record that a requested IfcMapConversion could not be written because
-     * there is no IfcProjectedCRS to attach it to — a different refusal from
-     * {@link reportMapConversionRefused}: "no CRS to attach it to" rather than
-     * "no context to reference" (#2105).
-     */
-    private reportMapConversionRefusedNoCrs;
-    /**
-     * `effective` again: the id returned here becomes the new IfcMapConversion's
-     * SourceCRS, so a tombstoned context would leave the created line pointing at
-     * a record the export skips — a dangling reference and an invalid file.
-     */
-    private findPreferredGeometricRepresentationContextId;
-    /**
-     * Generate a new IFC GlobalId (22 character base64). `random` is the
-     * export's optional seeded source (`StepExportOptions.guidRandom`);
-     * undefined keeps the default random path.
-     */
-    private generateGlobalId;
     /**
      * Find the maximum EXPRESS ID in the data store
      */
     private findMaxExpressId;
     /**
-     * Find a unit entity ID by name (simplified - returns null for now)
-     */
-    private findUnitId;
-    /**
-     * Check if an entity type is a geometry-related type
-     */
-    private isGeometryEntity;
-    /**
-     * Build a one-shot reverse index of every IfcRelDefinesByProperties in
-     * the source: for each related entity, list the rels and property/quantity
-     * sets that reference it. Used by the export pre-pass so the per-entity
-     * "find owning rels" step is O(K) rather than O(N) per modified entity.
+     * The exporter state `step-georeferencing.ts` cannot read off the pass.
      *
-     * `relatedByRel` is the same walk read the other way round, so the deleted-host
-     * sweep costs nothing extra.
+     * `allocateExpressId` hands out ids from THIS exporter's `nextExpressId`,
+     * which the property-set and quantity-set generators in
+     * `step-property-sets.ts` increment at six further sites through the same
+     * callback — hoisting the counter onto the pass would change what it
+     * computes, not merely where it is named, so both phases get a callback
+     * instead (#2475 step 2a).
      */
-    private buildRelDefinesByPropertiesIndex;
+    private georefContext;
     /**
-     * The source STEP text of an entity's line, or `null` when there are no bytes
-     * to read.
-     *
-     * The byte check is on the RANGE, not on `dataStore.source`. `source` is a
-     * MANDATORY accessor — `EMPTY_SOURCE_BYTES` is how "this model kept no bytes"
-     * is spelled (server-parsed, synthetic, GLB and point-cloud stores all have
-     * one) — so the `!this.dataStore.source` guard the five readers below used to
-     * carry never fired. It was also redundant: a zero-length range decodes to
-     * `''`, which fails every regex those readers run, so they already answered
-     * "nothing" for a sourceless store. Scoping the check to the range is what
-     * makes the guard live without changing a single answer, the same shape and
-     * for the same reason as `reference-collector.ts` (#2339).
-     *
-     * An OVERLAY-created entity never reaches here: every caller resolves its id
-     * through `dataStore.entityIndex.byId`, which holds source records only
-     * (`effective-index.ts` synthesises the overlay refs on its own side and
-     * writes nothing back), so an overlay id is already `undefined` at the
-     * lookup and is served by the callers' documented "not a source record"
-     * path. That is why an early return is safe HERE and is NOT safe at the
-     * visible-only closure in `export` — see the comment there.
-     *
-     * ## Why `isReadableSourceRef` and not `byteLength === 0`
+     * The state `step-property-sets.ts` cannot read off the pass (#2475 2b/2c).
      *
-     * An out-of-range ref does NOT degrade to "no match" here. `decodeUtf8`
-     * clamps the range it cannot address, and the clamped window is still a
-     * window over real file bytes — so these readers answer from somebody
-     * ELSE's record. `source-ref-bounds.ts` (#2491) carries the measured
-     * account of both shapes and of why "a clamped, empty decode already yields
-     * no match" is false; it is not restated here, because an argument kept in
-     * two files is an argument that has to stay true in two files.
-     *
-     * The consequence specific to THIS site is that the wrong answer is acted
-     * on. `retainSharedAtoms` un-skips every id `getPropertyIdsInSet` returns,
-     * so a member list read out of the wrong record un-skips the wrong atoms;
-     * and the source-iteration pass already refuses to emit a record whose ref
-     * fails `isReadableSourceRef` (see the `continue` in `export`), so before
-     * this gate these readers were making decisions on behalf of a container
-     * that the same export had decided not to write. Gating them on the same
-     * predicate is what makes the two passes agree.
-     *
-     * The degradation is the one the exporter already handles: a record with no
-     * emittable bytes, generating nothing and named by nothing. It costs one
-     * answer that used to be right by luck — an overrunning ref on the file's
-     * LAST record clamps back to exactly that record's text — but that record
-     * is one the emission pass drops anyway, so keeping the answer only kept
-     * the disagreement.
-     */
-    private entityLineText;
-    /**
-     * Get entity IDs related by IfcRelDefinesByProperties (the related objects)
-     */
-    private getRelatedEntities;
-    /**
-     * Get the property set ID from IfcRelDefinesByProperties
-     */
-    private getRelatedPropertySet;
-    /**
-     * Get the name of a property set by parsing the entity
-     */
-    private getPropertySetName;
-    /**
-     * Get the name of an element quantity set by parsing the entity
-     */
-    private getElementQuantityName;
-    /**
-     * Get IDs of properties in a property set
-     */
-    /**
-     * Un-skip property/quantity atoms that a surviving (non-skipped, and — under
-     * visible-only export — still-included) IfcPropertySet / IfcElementQuantity
-     * still references.
+     * `allocateExpressId` is the same callback `georefContext` hands out, over
+     * the same counter, so the ids the two phases allocate stay in one sequence.
+     * `ownerHistory` is passed by reference — the object is this exporter's, and
+     * `export()` resets it. `isReadableSourceRef` is the instance predicate, not
+     * `pass.isReadableSourceRef`, because two consumers of that module
+     * (`buildRelDefinesByPropertiesIndex`, and `retainSharedAtoms` in
+     * `step-source-iteration.ts`) run with no pass in hand; both readers are
+     * built over the same source.
      *
-     * When a property is edited, the modified pset is replaced and its member atoms
-     * are added to `skipIds` wholesale. Because exporters deduplicate shared
-     * Pset_*Common atoms (e.g. a single IsExternal / IsLoadBearing value referenced
-     * by many psets), that wholesale skip can drop an atom another pset still needs.
-     * This pass restores any such atom: the edited pset still emits its replacement
-     * with the new value, while the shared atom stays for the psets that keep their
-     * original value.
+     * Rebuilt per call, as `georefContext` is: every call site runs once per
+     * export bar `retainSharedAtoms`, which hoists it out of its loop — hence
+     * `buildSourceIterationContext` (`step-export-contexts.ts`) takes this as a
+     * thunk rather than a value.
      */
-    private retainSharedAtoms;
-    private getPropertyIdsInSet;
+    private propertySetContext;
     /**
-     * The full HasPropertySets id list of a type object, from whichever authority
-     * owns the record.
-     *
-     * Slot 5 is `HasPropertySets` on every `IfcTypeObject` subtype. For a source
-     * record the list is parsed out of the file; for an overlay-created type it is
-     * read off the authored payload, where a reference is the documented `'#42'`
-     * string form. Reading only the source made every pset on a created
-     * `IfcWallType` look unowned, which is how it ended up on an occurrence
-     * relation instead (#2012).
+     * The state `step-collection.ts` cannot read off the pass (#2475, the
+     * collection block). `propertySetContext` and `georefContext` are handed
+     * over as the SAME thunks {@link propertySetContext} and
+     * {@link georefContext} already are — this phase calls the first twice per
+     * export and the second once, and nothing here should change how often
+     * either is rebuilt.
      */
-    private getTypeOwnedHasPropertySetIds;
+    private collectionContext;
 }
 /**
  * Quick export function for simple use cases.

package/dist/step-exporter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"step-exporter.d.ts","sourceRoot":"","sources":["../src/step-exporter.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"step-exporter.d.ts","sourceRoot":"","sources":["../src/step-exporter.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAmB,MAAM,kBAAkB,CAAC;AAEtE,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAgB/D;;;;;GAKG;AACH,YAAY,EACV,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EAChB,mBAAmB,EACnB,UAAU,GACX,MAAM,wBAAwB,CAAC;AAIhC,OAAO,KAAK,EAAE,iBAAiB,EAAE,gBAAgB,EAAc,MAAM,wBAAwB,CAAC;AAU9F;;GAEG;AACH,qBAAa,YAAY;IACvB,OAAO,CAAC,SAAS,CAAe;IAChC,OAAO,CAAC,YAAY,CAA6B;IACjD,OAAO,CAAC,aAAa,CAAS;IAC9B,OAAO,CAAC,eAAe,CAAyB;IAChD;;;;;;;;OAQG;IACH,OAAO,CAAC,YAAY,CAAsE;IAC1F;;;;;OAKG;IACH,OAAO,CAAC,mBAAmB,CAA2C;gBAE1D,SAAS,EAAE,YAAY,EAAE,YAAY,CAAC,EAAE,mBAAmB;IAYvE;;OAEG;IACH,MAAM,CAAC,OAAO,EAAE,iBAAiB,GAAG,gBAAgB;IA4IpD;;;OAGG;IACG,WAAW,CAAC,OAAO,EAAE,iBAAiB,GAAG,OAAO,CAAC,gBAAgB,CAAC;IAqBxE;;OAEG;IACH,oBAAoB,CAAC,OAAO,EAAE,IAAI,CAAC,iBAAiB,EAAE,iBAAiB,CAAC,GAAG,gBAAgB;IAQ3F;;OAEG;IACH,OAAO,CAAC,gBAAgB;IAMxB;;;;;;;;;OASG;IACH,OAAO,CAAC,aAAa;IASrB;;;;;;;;;;;;;;;;OAgBG;IACH,OAAO,CAAC,kBAAkB;IAa1B;;;;;;;OAOG;IACH,OAAO,CAAC,iBAAiB;CAW1B;AAED;;;;GAIG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,YAAY,EACvB,OAAO,CAAC,EAAE,OAAO,CAAC,iBAAiB,CAAC,GACnC,MAAM,CAOR"}