@ifc-lite/export 3.0.1 → 4.0.0

package/README.md

@@ -61,6 +61,39 @@ const blob = new Blob([stepText], { type: 'application/x-step' });
 
 `exportToStep` is the round-trip path for property edits. Edit via `@ifc-lite/mutations`, export with `applyMutations: true`, ship the resulting `.ifc` to whatever consumes IFC.
 
+## Anonymized isolated export — for bug reports
+
+`collectRelatedEntities` + `exportAnonymizedSubset` pick a seed selection,
+expand it by relationship context (host, openings/fillers, type, materials,
+spatial containment), and export exactly that subset with every
+project-identifying signal removed — while local placement rotations and
+non-orthogonal cuts survive, so a parsing/geometry bug reproduction still
+reproduces:
+
+```typescript
+import { collectRelatedEntities, exportAnonymizedSubset } from '@ifc-lite/export';
+
+const related = collectRelatedEntities(store, new Set([312])); // seed expressId(s)
+const result = exportAnonymizedSubset(store, related.all);
+await saveFile('anonymized.ifc', result.content);
+```
+
+Every `AnonymizeOptions` field defaults to the maximally-scrubbed direction
+(names pseudonymized, `GlobalId`s regenerated, property sets dropped, owner
+history and georeferencing scrubbed) — `ObjectType` and material/style names
+are pseudonymized right along with everything else under the default
+`pseudonymizeAllNames`, and the STEP header's `originating_system` is
+blanked under the default `scrubOwnerHistory`. What stays in the file by
+decision: geometry and local placement rotations/non-orthogonal cuts (only
+the root placement's translation is zeroed), structural entity types,
+material *assignments* (which material, just not its original name), and
+the header's `preprocessor_version` (from `IfcApplication`, defaults to
+`'ifc-lite'`) — that is what makes the file useful for a bug repro. See the
+[Exporting
+Guide](https://ifclite.dev/docs/guide/exporting/#anonymized-isolated-export)
+for the full option list, including how to opt back into authored names via
+`--keep-other-names`.
+
 ## Apache Parquet — for analytics
 
 ```typescript
@@ -84,6 +117,8 @@ argument to drop overlay-deleted entities (and every row that references one) fr
 `Entities`, `Properties`, `Quantities` and `Relationships`:
 
 ```typescript
+import { ParquetExporter } from '@ifc-lite/export';
+
 const exporter = new ParquetExporter(store, geometryResult, mutationView);
 ```
 
@@ -125,7 +160,7 @@ const bytes = new Uint8Array(await file.arrayBuffer());
 const lod0 = await generateLod0(bytes);
 
 // LOD1 — meshes simplified to bounding boxes / convex hulls, returned as GLB
-const lod1 = await generateLod1(bytes, { quality: 'medium' });
+const lod1 = await generateLod1(bytes);
 //   { glb: Uint8Array, meta: { failedElements, mapping, ... } }
 
 // Falls back gracefully to box geometry if a complex element fails to mesh
@@ -134,6 +169,7 @@ const lod1 = await generateLod1(bytes, { quality: 'medium' });
 ## Also exported
 
 - `MergedExporter` - merge several parsed models into one STEP export
+- `collectRelatedEntities` / `exportAnonymizedSubset` - anonymized isolated export (see above)
 - `convertEntityType` / `convertStepLine` / `needsConversion` - IFC2X3 / IFC4 / IFC4X3 schema conversion helpers
 - `parseGLB` / `parseGLBToMeshData` / `extractGlbMapping` - GLB round-trip readers
 

package/dist/anonymize-export.d.ts

@@ -0,0 +1,60 @@
+/**
+ * `exportAnonymizedSubset` (#2934, the "anonymized isolated export" feature,
+ * plan A2 "Orchestrator" row): given a caller-picked `includedIds` selection
+ * (typically `RelatedEntities.all` from `related-entities.ts`), produces a
+ * STEP file that contains ONLY that subset, with every project-identifying
+ * signal removed while the geometry-relevant local transformations
+ * (rotations, non-orthogonal cuts) survive — so a parsing bug reproduction
+ * keeps reproducing.
+ *
+ * Per the plan's "Key mechanism choice": anonymization is expressed as
+ * mutations on a PRIVATE `MutablePropertyView` + `StoreEditor` — never a text
+ * post-pass — fed to the same `StepExporter` every other export mode uses.
+ * The overlay is scoped to one call: nothing here writes into `store`, and
+ * the view is discarded once `export()` returns, so two calls against the
+ * same `store` never interact.
+ *
+ * Call order matters and is fixed:
+ *  1. `pruneUnresolvableRelationships` — ahead of everything else, so a
+ *     relationship this export cannot legally emit (its own mandatory,
+ *     single-valued reference — or every member of a SET/LIST reference —
+ *     names an entity outside `includedIds`) is removed from the ROOT set
+ *     BEFORE `StepExporter` ever sees it, rather than discovered mid-closure
+ *     and withheld with the generic `relationshipWithheldWarning`
+ *     (`step-export-types.ts`). Reported distinctly, as
+ *     `stats.prunedRelationshipIds`, for exactly this reason: a caller
+ *     should be able to tell "this association is gone because the anonymizer
+ *     pruned it" from "this association is gone for some other export-time
+ *     reason" without grepping warning text.
+ *  2. `applyPlacementAnonymization` (`anonymize-placement.ts`) — root
+ *     placement zeroing and georeferencing/address blanking.
+ *  3. `applyScrub` (`anonymize-scrub.ts`) — pseudonyms, GlobalId
+ *     regeneration, owner-history scrub, `HasPropertySets` clearing.
+ *  4. `StepExporter.export` with `subsetEntityIds` set to the PRUNED id set
+ *     and the header scrubbed (`author`/`organization`/`authorization`
+ *     blanked, per the decision doc — `originating_system` and
+ *     `preprocessor_version` are deliberately left alone).
+ *
+ * 2 and 3 both read `store`/`index` and queue their edits onto the SAME
+ * `view`/`editor` pair, so `StepExporter`'s closure walk (which reads the
+ * overlay through `effective-index.ts`) sees every edit from both passes at
+ * once — never two overlays that could disagree about the same entity.
+ */
+import type { IfcDataStore } from '@ifc-lite/parser';
+import type { AnonymizeOptions, AnonymizeResult } from './anonymize-types.js';
+/**
+ * Export `includedIds` (plus infrastructure and their forward closure — see
+ * `subset-roots.ts`) as an anonymized STEP file. Every `AnonymizeOptions`
+ * field defaults to the maximally-scrubbed direction (see that interface's
+ * own doc), so calling this with no options at all is the intended common
+ * case, not a partial anonymization a caller must opt further into.
+ *
+ * Throws when `store` has no source bytes to read entity records from — a
+ * server-parsed or synthetic store with `source.byteLength === 0` has
+ * nothing for `readEntityArgs`/`StepExporter`'s source-iteration pass to
+ * read, and every module this orchestrator calls assumes source-backed
+ * records exist for at least the infrastructure/relationship entities it
+ * touches.
+ */
+export declare function exportAnonymizedSubset(store: IfcDataStore, includedIds: ReadonlySet<number>, options?: AnonymizeOptions): AnonymizeResult;
+//# sourceMappingURL=anonymize-export.d.ts.map

package/dist/anonymize-export.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anonymize-export.d.ts","sourceRoot":"","sources":["../src/anonymize-export.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAkB,MAAM,kBAAkB,CAAC;AAcrE,OAAO,KAAK,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAiJ9E;;;;;;;;;;;;;GAaG;AACH,wBAAgB,sBAAsB,CACpC,KAAK,EAAE,YAAY,EACnB,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,OAAO,GAAE,gBAAqB,GAC7B,eAAe,CAmGjB"}

package/dist/anonymize-export.js

@@ -0,0 +1,217 @@
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at https://mozilla.org/MPL/2.0/. */
+import { MutablePropertyView, StoreEditor } from '@ifc-lite/mutations';
+import { getEffectiveEntityIndex } from './effective-index.js';
+import { getSubsetEntityIds, IFC_ROOT_TYPES, identifyingTypesFor } from './subset-roots.js';
+import { attrIndex, readEntityArgs, stepSourceSchema } from './subset-entity-reader.js';
+import { collectReferencedEntityIds, refGroupFromArg, relationshipRefsSurviveExclusion, } from './reference-collector.js';
+import { applyPlacementAnonymization } from './anonymize-placement.js';
+import { applyScrub } from './anonymize-scrub.js';
+import { StepExporter } from './step-exporter.js';
+import { isPropertySetDefinitionClass } from './type-owned-psets.js';
+/**
+ * Drop every `IfcPropertySet`/`IfcElementQuantity` id out of `includedIds`
+ * unless `keepPropertySets` is on (#3351 item 2, the SDK-path half `#3361`
+ * left open): `applyScrub`'s `keepPropertySets` handling only ever clears an
+ * `IfcTypeObject`'s `HasPropertySets` SLOT, so a pset that reached
+ * `includedIds` some other way — a caller's own
+ * `collectRelatedEntities(..., { IfcRelDefinesByProperties: true })` walk, or
+ * a hand-built id set — survived complete, values included, with
+ * `keepPropertySets` at its documented `false` default.
+ *
+ * DROP means EXCLUDE, not "emit scrubbed": this pass never queues a mutation
+ * on a pset entity, it removes the id from the set the exporter's closure
+ * ever sees, the same way the CLI's `--keep-psets` already behaves (it
+ * drives both this exclusion, via `RelatedEntityOptions.IfcRelDefinesByProperties`,
+ * and `keepPropertySets` from one flag) and the same way the viewer's two
+ * toggles are now coupled (`AnonymizationOptionsPanel.tsx`). Scrubbing in
+ * place was considered and rejected: a property/quantity VALUE is left
+ * unscrubbed by design everywhere else in this module (only NAMES are
+ * pseudonymized), so a scrubbed-but-kept pset would still carry
+ * `IFCPROPERTYSINGLEVALUE('Owner',$,IFCTEXT('jane.doe@acme-corp.example'),$)`
+ * verbatim — exactly the leak this exists to close. Exclusion is the only
+ * one of the two that actually removes it.
+ *
+ * Must run BEFORE `pruneUnresolvableRelationships`: dropping a pset id here
+ * feeds straight into that pass's `getSubsetEntityIds` exclusion set, so an
+ * `IfcRelDefinesByProperties` whose `RelatingPropertyDefinition` named only a
+ * now-dropped pset is pruned the same way any other relationship with an
+ * excluded mandatory single-valued reference is — never left dangling.
+ *
+ * Returns the surviving set plus every id this pass dropped, reported
+ * distinctly (the same shape `prunedRelationshipIds` already uses on
+ * `AnonymizeResult.stats`) so a caller can tell "excluded because it is a
+ * property set" from any other reason an id might be missing, without
+ * grepping `warnings` text.
+ */
+function excludePropertySetsUnlessKept(index, includedIds, keepPropertySets) {
+    if (keepPropertySets)
+        return { includedIds: new Set(includedIds), droppedPropertySetIds: [] };
+    const kept = new Set();
+    const droppedPropertySetIds = [];
+    for (const id of includedIds) {
+        if (isPropertySetDefinitionClass(index.typeOf(id))) {
+            droppedPropertySetIds.push(id);
+        }
+        else {
+            kept.add(id);
+        }
+    }
+    droppedPropertySetIds.sort((a, b) => a - b);
+    return { includedIds: kept, droppedPropertySetIds };
+}
+/**
+ * Null `PropertyReference` when an emitted `IfcPropertyReferenceValue` names
+ * an entity the subset excludes. The value can be reached by the forward
+ * closure rather than appearing in the caller's seed set, hence `closureIds`.
+ */
+function dropExcludedPropertyReferences(store, index, closureIds, excludedIds, view, schema) {
+    const droppedIds = [];
+    for (const id of closureIds) {
+        if ((index.typeOf(id) ?? '') !== 'IFCPROPERTYREFERENCEVALUE')
+            continue;
+        const record = readEntityArgs(store, index, id);
+        if (!record)
+            continue;
+        const idx = attrIndex('IFCPROPERTYREFERENCEVALUE', 'PropertyReference', schema);
+        if (idx === -1 || idx >= record.args.length)
+            continue;
+        const ref = refGroupFromArg(record.args[idx]);
+        if (typeof ref !== 'number' || !excludedIds.has(ref))
+            continue;
+        view.setPositionalAttribute(id, idx, null);
+        droppedIds.push(id);
+    }
+    return droppedIds;
+}
+/**
+ * Every id in `includedIds` whose EXPRESS type is an `IfcRel*` (an
+ * `IFC_ROOT_TYPES` member starting `IFCREL`), and whose own STEP record
+ * `relationshipRefsSurviveExclusion` would refuse to bridge or emit — i.e.
+ * one that names, in a single-valued attribute, an id NOT in `includedIds`
+ * (and not infrastructure), or whose every member of a SET/LIST attribute is
+ * likewise excluded. Everything ELSE in `includedIds` is left exactly as the
+ * caller passed it: this only ever REMOVES relationship ids, never adds or
+ * removes anything else.
+ *
+ * "Excluded" here is computed the same way the export's own closure would
+ * (`getSubsetEntityIds`'s `excludedIds` — every `IFC_ROOT_TYPES` /
+ * `IDENTIFYING_TYPES` id not in `includedIds`), so a relationship this
+ * function prunes is exactly one `StepExporter` would otherwise have had to
+ * withhold on its own.
+ */
+function pruneUnresolvableRelationships(store, index, includedIds) {
+    // Deliberately the DEFAULT identifying set, not the caller's narrowed one:
+    // this pass only decides which relationship members to trim, and a kept
+    // georeference entity is rooted by `getSubsetEntityIds` before it gets here.
+    // Threading the narrowed set in was measured dead -- mutating it failed zero
+    // tests -- so it is not carried.
+    const { excludedIds } = getSubsetEntityIds(index, includedIds);
+    const isExcluded = (id) => excludedIds.has(id);
+    const relationshipIds = [...includedIds]
+        .filter((id) => (index.typeOf(id) ?? '').startsWith('IFCREL'))
+        .sort((a, b) => a - b);
+    const prunedRelationshipIds = [];
+    const finalIncludedIds = new Set(includedIds);
+    for (const id of relationshipIds) {
+        const record = readEntityArgs(store, index, id);
+        // Unreadable (no source bytes, or an unparseable line): leave it for
+        // `StepExporter`'s own gates to decide, rather than guessing here.
+        if (!record)
+            continue;
+        const groups = record.args
+            .map(refGroupFromArg)
+            .filter((g) => g !== undefined);
+        if (!relationshipRefsSurviveExclusion(groups, isExcluded)) {
+            prunedRelationshipIds.push(id);
+            finalIncludedIds.delete(id);
+        }
+    }
+    return { prunedRelationshipIds, finalIncludedIds };
+}
+/**
+ * Export `includedIds` (plus infrastructure and their forward closure — see
+ * `subset-roots.ts`) as an anonymized STEP file. Every `AnonymizeOptions`
+ * field defaults to the maximally-scrubbed direction (see that interface's
+ * own doc), so calling this with no options at all is the intended common
+ * case, not a partial anonymization a caller must opt further into.
+ *
+ * Throws when `store` has no source bytes to read entity records from — a
+ * server-parsed or synthetic store with `source.byteLength === 0` has
+ * nothing for `readEntityArgs`/`StepExporter`'s source-iteration pass to
+ * read, and every module this orchestrator calls assumes source-backed
+ * records exist for at least the infrastructure/relationship entities it
+ * touches.
+ */
+export function exportAnonymizedSubset(store, includedIds, options = {}) {
+    if (!store.source || store.source.byteLength <= 0) {
+        throw new Error('exportAnonymizedSubset: the store has no source bytes to export from '
+            + '(a server-parsed or synthetic store with source.byteLength === 0 '
+            + 'cannot be anonymized — this feature reads and rewrites the original '
+            + 'STEP records).');
+    }
+    // One private overlay for this call only — never the caller's own
+    // mutation view, and never written into `store`. See the module doc.
+    const view = new MutablePropertyView(null, 'anonymize');
+    const editor = new StoreEditor(store, view);
+    const index = getEffectiveEntityIndex(store, view, true);
+    // Runs BEFORE relationship pruning — see that function's own doc for why
+    // the order matters (a dropped pset must be visible to the exclusion set
+    // relationship pruning reads).
+    const { includedIds: psetFilteredIds, droppedPropertySetIds } = excludePropertySetsUnlessKept(index, includedIds, options.keepPropertySets ?? false);
+    const { prunedRelationshipIds, finalIncludedIds } = pruneUnresolvableRelationships(store, index, psetFilteredIds);
+    const subsetIdentifyingTypes = identifyingTypesFor(options?.removeGeoreferencing !== false);
+    const subset = getSubsetEntityIds(index, finalIncludedIds, subsetIdentifyingTypes);
+    const exportClosure = collectReferencedEntityIds(subset.roots, store.source, index, subset.excludedIds);
+    const droppedPropertyReferenceIds = dropExcludedPropertyReferences(store, index, exportClosure, subset.excludedIds, view, stepSourceSchema(store.schemaVersion));
+    const placementResult = applyPlacementAnonymization(store, index, finalIncludedIds, editor, view, options);
+    const scrubResult = applyScrub(store, index, finalIncludedIds, view, options);
+    const exportResult = new StepExporter(store, view).export({
+        schema: store.schemaVersion,
+        subsetEntityIds: finalIncludedIds,
+        subsetIdentifyingTypes,
+        filename: options.filename ?? 'anonymized.ifc',
+        // Header scrub per the decision doc: author/organization/authorization
+        // blanked outright (never inherited from the source header — an empty
+        // string is a deliberate override, not "no override", per
+        // `step-header.ts`'s `??` wiring). `description` gets the same
+        // unconditional override: `buildStepHeader` falls through to the SOURCE
+        // FILE_DESCRIPTION items verbatim whenever this orchestrator leaves
+        // `description` undefined — an authoring tool's free-text
+        // "Comment [...]" item there is exactly as identifying as the
+        // author/organization fields beside it, so it is blanked the same way,
+        // not merely left to whatever the source happened to carry.
+        // `originating_system` is blanked under `scrubOwnerHistory` (a
+        // vendor build string such as `26.0.0 NOR FULL` encodes the licence
+        // region); `preprocessor_version` comes from `application`, left unset
+        // here (defaults to 'ifc-lite').
+        author: '',
+        organization: '',
+        authorization: '',
+        description: '',
+        ...((options.scrubOwnerHistory ?? true) ? { originatingSystem: '' } : {}),
+        timeStamp: options.timeStamp,
+        guidRandom: options.guidRandom,
+    });
+    const includedRootEntityCount = [...finalIncludedIds]
+        .filter((id) => IFC_ROOT_TYPES.has(index.typeOf(id) ?? '')).length;
+    return {
+        content: exportResult.content,
+        guidMap: scrubResult.guidMap,
+        stats: {
+            entityCount: exportResult.stats.entityCount,
+            includedRootEntityCount,
+            prunedRelationshipIds,
+            droppedPropertySetIds,
+            droppedPropertyReferenceIds,
+            zeroedPlacements: placementResult.zeroedPlacements,
+            warnings: [
+                ...placementResult.warnings,
+                ...scrubResult.warnings,
+                ...exportResult.stats.warnings,
+            ],
+        },
+    };
+}
+//# sourceMappingURL=anonymize-export.js.map

package/dist/anonymize-export.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"anonymize-export.js","sourceRoot":"","sources":["../src/anonymize-export.ts"],"names":[],"mappings":"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"}

package/dist/anonymize-placement.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Root-placement zeroing and georeferencing/address blanking for the
+ * "anonymized isolated export" feature (#2934, plan section A4).
+ *
+ * Coordinates are the strongest identifying signal a reproduction carries —
+ * an absolute site position pins the model to a real address — but the
+ * ROTATION in the placement chain and any non-orthogonal cuts are exactly
+ * what a parsing bug reproduction needs to keep. So this module zeroes only
+ * the TRANSLATION of each root `IfcLocalPlacement` (`PlacementRelTo = $`),
+ * leaving `Axis`/`RefDirection` and every child placement untouched.
+ *
+ * **Clone, never rewrite.** `IfcCartesianPoint` and `IfcAxis2Placement3D` /
+ * `2D` records are routinely SHARED — two storeys placed at the same origin,
+ * or a template point reused across a model — so rewriting one in place would
+ * silently move every other placement that happens to reference the same
+ * point. Each zeroed root gets its own freshly-cloned point and axis via
+ * `StoreEditor.addEntity`, and only the root's `RelativePlacement` slot is
+ * repointed (`setPositionalAttribute`) to the clone. Nothing else in the
+ * model ever sees the edit.
+ *
+ * The same clone-and-repoint mechanism handles
+ * `IfcGeometricRepresentationContext.WorldCoordinateSystem` (a second, less
+ * obvious place a survey offset can live — #2934's plan A4 step 4) and is
+ * shared between both call sites as {@link zeroAxisPlacementSlot}.
+ *
+ * `IfcGridPlacement` / `IfcLinearPlacement` roots have no `RelativePlacement`
+ * → `IfcCartesianPoint` chain to clone against, so they are left untouched
+ * and reported as a warning rather than silently ignored or corrupted.
+ *
+ * Reads go through {@link readEntityArgs} / {@link attrIndex}
+ * (`subset-entity-reader.ts`) so a positional slot is always resolved BY
+ * EXPRESS NAME against the schema registry, never a hand-counted index that
+ * would silently drift the day an entity's attribute layout changes.
+ */
+import type { IfcSourceBytes } from '@ifc-lite/parser';
+import type { MutablePropertyView, StoreEditor } from '@ifc-lite/mutations';
+import type { EffectiveEntityIndex } from './effective-index.js';
+import type { AnonymizeOptions } from './anonymize-types.js';
+/** The slice of {@link AnonymizeOptions} this module reads. */
+export type PlacementAnonymizationOptions = Pick<AnonymizeOptions, 'zeroRootPlacement' | 'removeGeoreferencing'>;
+/** What {@link applyPlacementAnonymization} did — folded into
+ *  `AnonymizeResult.stats` by the orchestrator (`anonymize-export.ts`). */
+export interface PlacementAnonymizationResult {
+    /** Each root `IfcLocalPlacement` this call zeroed, and the ORIGINAL
+     *  (pre-zero) translation it removed. */
+    zeroedPlacements: {
+        expressId: number;
+        translation: number[];
+    }[];
+    /** Non-fatal notices: an unsupported root placement kind, an unreadable
+     *  chain, multiple roots collapsing onto one origin, or a chain this walk
+     *  bounded before it reached one (256-hop cap, see "Bounding walks over
+     *  file-supplied references", AGENTS.md). */
+    warnings: string[];
+}
+/**
+ * Zero every root `IfcLocalPlacement` translation reachable from
+ * `includedIds`, zero `WorldCoordinateSystem` on every
+ * `IfcGeometricRepresentationContext` (always exported — it is an
+ * `INFRASTRUCTURE_TYPES` member, `reference-collector.ts`), and blank
+ * `IfcSite` / `IfcBuilding` georeferencing and address attributes.
+ *
+ * `store`/`index` are read from (never mutated directly) — every change goes
+ * through `editor` (new entities, positional overrides) or `view` (named
+ * attribute overrides), so the private `MutablePropertyView` overlay the
+ * orchestrator built stays the ONE place this export's edits live.
+ */
+export declare function applyPlacementAnonymization(store: {
+    readonly source: IfcSourceBytes;
+}, index: EffectiveEntityIndex, includedIds: ReadonlySet<number>, editor: StoreEditor, view: MutablePropertyView, opts?: PlacementAnonymizationOptions): PlacementAnonymizationResult;
+//# sourceMappingURL=anonymize-placement.d.ts.map

package/dist/anonymize-placement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"anonymize-placement.d.ts","sourceRoot":"","sources":["../src/anonymize-placement.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAC;AACvD,OAAO,KAAK,EAAE,mBAAmB,EAAE,WAAW,EAAE,MAAM,qBAAqB,CAAC;AAE5E,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,sBAAsB,CAAC;AACjE,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,sBAAsB,CAAC;AAK7D,+DAA+D;AAC/D,MAAM,MAAM,6BAA6B,GAAG,IAAI,CAC9C,gBAAgB,EAChB,mBAAmB,GAAG,sBAAsB,CAC7C,CAAC;AAEF;2EAC2E;AAC3E,MAAM,WAAW,4BAA4B;IAC3C;6CACyC;IACzC,gBAAgB,EAAE;QAAE,SAAS,EAAE,MAAM,CAAC;QAAC,WAAW,EAAE,MAAM,EAAE,CAAA;KAAE,EAAE,CAAC;IACjE;;;iDAG6C;IAC7C,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAUD;;;;;;;;;;;GAWG;AACH,wBAAgB,2BAA2B,CACzC,KAAK,EAAE;IAAE,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAA;CAAE,EAC1C,KAAK,EAAE,oBAAoB,EAC3B,WAAW,EAAE,WAAW,CAAC,MAAM,CAAC,EAChC,MAAM,EAAE,WAAW,EACnB,IAAI,EAAE,mBAAmB,EACzB,IAAI,CAAC,EAAE,6BAA6B,GACnC,4BAA4B,CAc9B"}