@ifc-lite/export 2.9.3 → 3.0.0

package/dist/step-pass-builder.js

@@ -0,0 +1,249 @@
+/* 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 { getEffectiveEntityIndex } from './effective-index.js';
+import { createModificationLedger } from './delta-modification-ledger.js';
+import { createSourceRefReader } from './source-ref-bounds.js';
+import { buildStepHeader } from './step-header.js';
+export function buildExportPass(input) {
+    const { dataStore, mutationView, isGeometryEntity, options, schema, sourceSchema, converting, applyMutations, excludeGeometry, sourceHeader, schemaToken, } = input;
+    const pass = {
+        entities: [],
+        newEntityCount: 0,
+        schema,
+        sourceSchema,
+        converting,
+        sourceHeader,
+        schemaToken,
+        overlayActive: !!mutationView && applyMutations,
+        // Built once entity counts are known, so the provenance item can report the
+        // actual modification count. See the two call sites (empty delta + final).
+        // Body lives in `step-header.ts` (#2475 header/assembly tail): the
+        // closure still has to be built here, because it closes over this
+        // call's own `options`/`sourceHeader`/`schemaToken`, and both call
+        // sites still read it as `pass.buildHeader`.
+        buildHeader: (modifications) => buildStepHeader(options, sourceHeader, schemaToken, modifications),
+        // The one authority for exists / class / deleted, overlay first and source
+        // buffer second. Every pass below asks this instead of `dataStore`,
+        // which answers only for the file as parsed (#2012).
+        effective: getEffectiveEntityIndex(dataStore, mutationView, applyMutations),
+        // Does this id belong to an entity the OVERLAY created (`createEntity` /
+        // `store.addEntity`) rather than to a record in the source buffer? Such an
+        // entity has no source bytes, so the source-iteration pass below never sees
+        // it and the new-entities pass at the end owns its line entirely (#2006).
+        isOverlayCreated: (entityId) => pass.effective.isOverlayCreated(entityId),
+        // Does this record describe a line this export can actually READ out of the
+        // source? One predicate for every byte-range gate below, so they cannot
+        // disagree — see `source-ref-bounds.ts` for the corrupt file the weaker
+        // "is there a source / does the ref claim bytes" pair let through (#2491).
+        isReadableSourceRef: createSourceRefReader(dataStore.source),
+        // Build visible-only closure if requested. Classification, the closure walk
+        // and the style pass all run over the EFFECTIVE index: an overlay-created
+        // product becomes a root by the same type rules as a parsed one, the walk
+        // follows its authored references into the geometry it alone owns, and a
+        // tombstoned entity is simply not there. Run over the source buffer, a
+        // created wall could never be a root and nothing referenced it, so
+        // `visibleOnly` wrote a file without it and said nothing (#2012).
+        //
+        // Computed here, ahead of the modification-count passes below, because
+        // `hasEmittableHostBytes` needs it: a source-backed host EXCLUDED by
+        // `visibleOnly` never gets its line written by the source-iteration pass
+        // either, so counting it as "modified" would make the header claim a
+        // change the DATA section does not contain (CodeRabbit finding on #2414).
+        allowedEntityIds: null,
+        // Populated alongside `allowedEntityIds` below. `getVisibleEntityIds`
+        // excludes a hidden PRODUCT's own line from the closure, but `IFCREL*` is
+        // an unconditional root a few lines down and its bytes are copied verbatim
+        // by the source-iteration pass — nothing there filters a `#N` the closure
+        // just excluded out of the relationship's own attribute list. Kept because
+        // the closure walk's `isRefExcludedDuringClosureWalk` needs a notion of
+        // "hidden" that does not read `allowedEntityIds` — the set that walk is
+        // producing (#2398). The two OUTPUT passes no longer read this directly:
+        // they filter on `isOmittedFromOutput`, which subsumes it via
+        // `allowedEntityIds`.
+        hiddenProductIds: null,
+        // A relationship can name an excluded entity two ways that have nothing
+        // to do with each other: a `visibleOnly` hidden PRODUCT (`hiddenProductIds`,
+        // below), and a TOMBSTONED one — `editor.removeEntity` on a related object
+        // named by a relationship the deletion sweep below does not reach (that
+        // sweep only withholds an `IfcRelDefinesByProperties` when EVERY related
+        // object is gone, and only for that one relationship class). Left alone, a
+        // relationship still naming a deleted entity ships the identical `#N` with
+        // no `#N=` line, on a path with no `visibleOnly` involved at all (#2398).
+        // `effective.isDeleted` answers for every id, not just a precomputed set,
+        // so this predicate covers both sources without a second exclusion set.
+        //
+        // Declared here, ahead of the closure walk below, and passed into
+        // `collectReferencedEntityIds` as its `isRefExcluded` — rather than the
+        // walk inventing its own `!entityIndex.has` proxy for "deleted" that could
+        // disagree on an id that never existed in the file at all
+        // (maintainer-found regression on #2637: such an id blocked the bridge but
+        // did not stop the relationship's own line from shipping, dropping a
+        // VISIBLE sibling's pset while adding a fresh dangling ref). A closure over
+        // `pass.hiddenProductIds`, not a value snapshot — correct because nothing
+        // reads it before the closure walk assigns it just below.
+        //
+        // ## Why this is NOT the predicate the OUTPUT-line filter uses
+        //
+        // The name says walk, and only walk. The two passes that write a
+        // relationship's line ask `isOmittedFromOutput` (further below, derived
+        // from `pass.willBeEmitted`), which is strictly stronger — it also answers
+        // for the closure, for an unreadable source ref and for a geometry
+        // exclusion.
+        //
+        // This one CANNOT be `willBeEmitted`, and the difference is structural
+        // rather than stylistic: `willBeEmitted`'s first act is to consult
+        // `allowedEntityIds`, and `allowedEntityIds` is precisely what the call
+        // below is computing. Wiring it in here is circular: it would answer "not
+        // in the closure" as `false` while the closure is still being built and
+        // `true` for the same id afterwards.
+        //
+        // That is a genuine departure from the contract #2637 was closed on —
+        // `reference-collector.ts` still documents the bridge as taking the
+        // caller's OWN output predicate, "not two expressions that happened to
+        // agree". It has an OBSERVABLE consequence, not just a naming one: for an
+        // unreadable source ref this admits, the walk bridges through a
+        // relationship the output then withholds, leaving the relationship's other
+        // target in the closure with nothing naming it — an orphan, pinned by
+        // `unreadable-ref-dangling.test.ts` ("walk and output predicates diverge").
+        // The reverse direction is closed: every id this excludes,
+        // `isOmittedFromOutput` excludes too, so the #2548 leak cannot return.
+        isRefExcludedDuringClosureWalk: (id) => (pass.hiddenProductIds !== null && pass.hiddenProductIds.has(id))
+            || pass.effective.isDeleted(id),
+        // Will THIS entity's own line ever land in the file? The same byte-range
+        // test `willBeEmitted` uses (defined further below) and the source-
+        // iteration pass's own skip at `entityRef.byteLength === 0` — a source
+        // entity with no bytes (a point-cloud / GLB "entity" from
+        // `createSyntheticDataStore`, not an overlay-created one) never gets a
+        // defining line written, source-iteration or otherwise, so a pset/attribute
+        // edit against it must not count as a modification either: the header
+        // would describe a change the file does not contain (out-of-scope finding
+        // in #2398). Also excludes a source-backed host the visible-only closure
+        // above drops — same reasoning, different reason the line never lands.
+        //
+        // And, like `willBeEmitted` below, excludes a geometry-classified SOURCE
+        // host under `includeGeometry: false`: the source-iteration pass's own
+        // `isGeometryEntity` skip (further below) drops that line too, so this
+        // predicate must agree or a geometry entity's attribute edit inflates the
+        // count over an omitted line (CodeRabbit finding on #2414). Guarded by
+        // `!deltaOnly` for the same reason `willBeEmitted` is: under `deltaOnly`
+        // the source-iteration pass — and its geometry skip — never runs at all,
+        // so a source entity's line is assumed to already exist in the file being
+        // patched, geometry or not.
+        isGeometryExcluded: (entityId, recordType) => excludeGeometry
+            && isGeometryEntity(pass.effective.effectiveType(entityId, recordType)),
+        hasEmittableHostBytes: (entityId) => {
+            if (pass.allowedEntityIds !== null && !pass.allowedEntityIds.has(entityId))
+                return false;
+            const ref = pass.effective.get(entityId);
+            // The ref must be READABLE, not merely non-empty: a range this source
+            // cannot address decodes to the empty string, which used to be pushed
+            // into the file as a blank line while everything generated FOR the host
+            // still named it (#2491).
+            if (!ref || !pass.isReadableSourceRef(ref))
+                return false;
+            if (options.deltaOnly !== true && pass.isGeometryExcluded(entityId, ref.type))
+                return false;
+            return true;
+        },
+        /**
+         * Will this id have a defining STEP line in the output at all?
+         *
+         * The predicate is #2030's, and it is the right one: the pset, quantity and
+         * type-owned passes below are built from unfiltered mutation history, and
+         * what each of them needs to know before emitting an
+         * `IFCRELDEFINESBYPROPERTIES` is not "was this deleted" or "is this hidden"
+         * but the general question those are two answers to. A relation naming an
+         * expressId that never gets written is a dangling reference and an invalid
+         * file, whichever route dropped the line.
+         *
+         * #2030 had to reach for four things to answer it — a tombstone probe, a
+         * visibility set, a byte-range test on `completeIndex`, and a `getNewEntity`
+         * fallback whose stated purpose was that `deleteEntity` FORGOT an
+         * overlay-created entity instead of tombstoning it, so `isDeleted` could not
+         * answer for one. That fallback was documented on main as a workaround for
+         * exactly the model-level defect this branch fixes: `deleteEntity` now
+         * tombstones as well as forgets, so the effective index answers existence
+         * for source and overlay ids alike and the workaround collapses into it.
+         *
+         * The overlay branch does NOT disappear with it, and the distinction matters:
+         * `isOverlayCreated` is still load-bearing here, because a live
+         * overlay-created entity has no source bytes and would fail the byte-range
+         * test that a source record passes. What the tombstone fix removed is the
+         * need for that branch to double as a deletion detector.
+         *
+         * Deliberately unchanged from #2030 for source records under `deltaOnly` /
+         * `exportPropertiesOnly`: the source-iteration pass is skipped wholesale in
+         * those modes, yet a source entity still answers true here. A delta is a
+         * patch against a file that already has the line, not a standalone model.
+         */
+        willBeEmitted: (entityId) => {
+            if (pass.allowedEntityIds !== null && !pass.allowedEntityIds.has(entityId))
+                return false;
+            // Undefined for a tombstoned id and for one neither the file nor the
+            // session ever had — a stale mutation must not conjure a relation either.
+            const ref = pass.effective.get(entityId);
+            if (!ref)
+                return false;
+            // An overlay-created record carries the placeholder byte range and is
+            // written by the new-entities pass; a source record needs real bytes.
+            if (pass.effective.isOverlayCreated(entityId)) {
+                // The overlay new-entities pass applies its OWN `isGeometryEntity`
+                // filter unconditionally — deltaOnly or not (see the comment at that
+                // loop, further below) — so this branch mirrors it without the
+                // deltaOnly carve-out the source branch gets.
+                return !pass.isGeometryExcluded(entityId, ref.type);
+            }
+            // Same readability test as `hasEmittableHostBytes`, and for the reason
+            // that predicate names: a ref this source cannot address is not a line
+            // this export can write, so nothing may be generated naming it (#2491).
+            if (!pass.isReadableSourceRef(ref))
+                return false;
+            // Mirrors `hasEmittableHostBytes`: under `deltaOnly` the source-
+            // iteration pass — and its geometry skip — never runs, so a source
+            // entity's line is assumed to already exist in the file being patched.
+            if (options.deltaOnly === true)
+                return true;
+            return !pass.isGeometryExcluded(entityId, ref.type);
+        },
+        // Under `deltaOnly` a nomination only becomes a count once some pass has
+        // actually written content that delivers THAT KIND of edit for the host —
+        // see `delta-modification-ledger.ts` for why the two are not the same event
+        // in that mode, and why the pair is (entity, kind) rather than the entity
+        // (#2462).
+        modifications: createModificationLedger(options.deltaOnly === true),
+        /**
+         * Hosts whose in-place named-attribute edits a FULL export may count, per
+         * kind. Filled by the collection passes below and read by the two passes
+         * that write a rewritten source line — see `in-place-nomination.ts` for why
+         * the nomination waits for the rewrite in this mode and not under
+         * `deltaOnly` (#2483).
+         */
+        inPlaceNominees: {
+            attribute: new Set(),
+            georeferencing: new Set(),
+        },
+        // Collect entities that need to be modified or created
+        modifiedEntities: new Set(),
+        modifiedAttributes: new Map(),
+        newPropertySets: [],
+        newQuantitySets: [],
+        typeOwnedPsetNamesByEntity: new Map(),
+        typeOwnedPsetIdsByEntity: new Map(),
+        rewrittenEntityIds: new Set(),
+        rewrittenEntityLines: new Map(),
+        /** HasPropertySets slot value for an OVERLAY-CREATED type object, applied
+         *  by the new-entities pass (there is no source line to rewrite). */
+        overlayTypeOwnedPsets: new Map(),
+        // Track property set IDs and relationship IDs to skip
+        skipPropertySetIds: new Set(),
+        skipRelationshipIds: new Set(),
+        // Written by the georeferencing pass and read again by the final
+        // assembly, which is why they are pass state and not phase locals.
+        newGeorefLines: [],
+        warnings: [],
+    };
+    // The same object, deliberately. See the file header.
+    return pass;
+}
+//# sourceMappingURL=step-pass-builder.js.map

package/dist/step-pass-builder.js.map

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

package/dist/step-property-sets.d.ts

@@ -0,0 +1,198 @@
+/**
+ * The property-set and quantity-set phases of `StepExporter.export()` (#2475
+ * steps 2b and 2c), and the type-object `HasPropertySets` rewrite that sits
+ * between them.
+ *
+ * ## Why one module, and why the rewrite is not its own function
+ *
+ *  - `generatedTypeOwnedPsetIds` is written by the property-set generation loop
+ *    and read by the rewrite loop. `ExportPass` documents it as the binding
+ *    that "is read in one phase only", and it stays that way here precisely
+ *    because both loops live inside
+ *    {@link generatePropertyAndQuantitySetEntities}: it is a plain local, not a
+ *    field on the pass and not an argument threaded between two functions.
+ *  - {@link getTypeOwnedHasPropertySetIds} is the rewrite's own helper, but its
+ *    only call site is the property-set COLLECTION loop, which fills
+ *    `pass.typeOwnedPsetIdsByEntity` from its result.
+ *  - `getPropertySetName` is called from the collection loop twice and from the
+ *    rewrite once.
+ *  - The three generation loops run pset → rewrite → qset, and `export()`
+ *    flushes `pass.rewrittenEntityLines` (the rewrite's output) only after the
+ *    qset loop. That order is load-bearing and is kept exactly as it was.
+ *
+ * ## What stayed behind, and why these two exports exist
+ *
+ * `retainSharedAtoms` belongs to neither phase and runs between them, so it
+ * stays on the exporter — which is why {@link getPropertyIdsInSet} is exported
+ * rather than module-private, the same shape step 2a used for
+ * `findLengthUnitReference`. {@link buildRelDefinesByPropertiesIndex} is
+ * exported for the mirror-image reason: the collection loops consume its
+ * `byEntity` half, but `export()` reads `relatedByRel` for the deleted-host
+ * relationship sweep, which is neither phase's work.
+ * `step-attribute-mutations.ts`'s `applySourceLineMutations` (moved off
+ * `StepExporter` by #2475's "remaining private helpers" step) is shared with
+ * the source-iteration pass, so it is injected on the context rather than
+ * imported directly.
+ *
+ * ## The state these phases cannot read off the pass
+ *
+ * {@link PropertySetContext}, following `step-georeferencing.ts:GeorefContext`.
+ * `allocateExpressId` is the exporter's own `nextExpressId++`: all six
+ * allocation sites in an export live in the two generators below, and the
+ * counter is shared with the georeferencing phase, so it is injected as a
+ * callback rather than hoisted onto the pass. The owner-history memos are
+ * injected BY REFERENCE and stay owned by the exporter, because their reset is
+ * an `export()`-level statement whose comment explains why they are per-export;
+ * storing them here would move that reset out of the method that documents it.
+ *
+ * Every helper below takes `ctx` FIRST; the two phase entry points take it
+ * LAST, as `applyGeoreferencingMutations` does. The split is not aesthetic —
+ * the two generators end in optional parameters, which a trailing `ctx` cannot
+ * follow.
+ */
+import type { IfcDataStore } from '@ifc-lite/parser';
+import { EntityExtractor } from '@ifc-lite/parser';
+import type { MutablePropertyView } from '@ifc-lite/mutations';
+import { createSourceRefReader } from './source-ref-bounds.js';
+import type { IfcSchemaVersion } from './schema-converter.js';
+import type { ExportPass, SourceLineMutations, StepExportOptions } from './step-exporter.js';
+/**
+ * The two owner-history memos the generators share, in one object so the
+ * exporter can hand them over by reference. Both are per-EXPORT rather than
+ * per-exporter; `StepExporter.export()` owns the reset and explains why.
+ */
+export interface OwnerHistoryCache {
+    /** Lazily-resolved fallback `#id` of an IfcOwnerHistory that survives the
+     *  current export closure (or `$` when the file has none). */
+    fallbackRef: string | undefined;
+    /** Per-host cache of an element's own OwnerHistory ref (`#id` or null). */
+    readonly byEntity: Map<number, string | null>;
+}
+/**
+ * The exporter state these phases cannot read off the {@link ExportPass}.
+ *
+ * `isReadableSourceRef` is the exporter's OWN reader rather than the pass's:
+ * the byte readers below are also reached from
+ * {@link buildRelDefinesByPropertiesIndex} and from `retainSharedAtoms`,
+ * neither of which has a pass in hand. Both readers are built by
+ * `createSourceRefReader` over the same `dataStore.source`.
+ */
+export interface PropertySetContext {
+    readonly dataStore: IfcDataStore;
+    readonly entityExtractor: EntityExtractor | null;
+    readonly mutationView: MutablePropertyView | null;
+    readonly isReadableSourceRef: ReturnType<typeof createSourceRefReader>;
+    /** `() => this.nextExpressId++` on the exporter. */
+    readonly allocateExpressId: () => number;
+    readonly ownerHistory: OwnerHistoryCache;
+    /** `step-attribute-mutations.ts`'s `applySourceLineMutations`: the ONE
+     *  pipeline the source-iteration pass and the type-object rewrite share, so
+     *  it belongs to neither phase and is injected. */
+    readonly applySourceLineMutations: (expressId: number, entityText: string, recordType: string, attributeMutations: Map<string, string> | undefined, sourceSchema: IfcSchemaVersion, overlayActive: boolean, onRejected?: (attrName: string, value: string) => void) => SourceLineMutations;
+}
+/** The mutation groupings `export()` builds before the collection phase runs. */
+export interface PropertyMutationGroups {
+    readonly entityPropMutations: Map<number, Set<string>>;
+    readonly entityQuantMutations: Map<number, Set<string>>;
+    readonly relDefinesByEntity: Map<number, Array<{
+        relId: number;
+        psetId: number;
+    }>>;
+}
+/**
+ * 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.
+ *
+ * `relatedByRel` is the same walk read the other way round, so the deleted-host
+ * sweep costs nothing extra.
+ */
+export declare function buildRelDefinesByPropertiesIndex(ctx: PropertySetContext): {
+    byEntity: Map<number, Array<{
+        relId: number;
+        psetId: number;
+    }>>;
+    relatedByRel: Map<number, number[]>;
+};
+/**
+ * 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 `!ctx.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`
+ *
+ * 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.
+ */
+export declare function entityLineText(ctx: PropertySetContext, entityId: number): string | null;
+/**
+ * Get the name of a property set by parsing the entity
+ */
+export declare function getPropertySetName(ctx: PropertySetContext, psetId: number): string | null;
+/**
+ * Get IDs of properties in a property set
+ */
+export declare function getPropertyIdsInSet(ctx: PropertySetContext, psetId: number): number[];
+/**
+ * Collect what the overlay's property-set and quantity-set edits mean for this
+ * export: which sets to regenerate (`pass.newPropertySets` /
+ * `pass.newQuantitySets`), which source records to withhold
+ * (`pass.skipPropertySetIds` / `pass.skipRelationshipIds`), and which type
+ * objects need their `HasPropertySets` resolved later
+ * (`pass.typeOwnedPsetNamesByEntity`, `…IdsByEntity`, `pass.rewrittenEntityIds`).
+ *
+ * The caller owns the `mutationView && options.applyMutations !== false` gate;
+ * reaching here means overlay edits were both present and enabled.
+ */
+export declare function collectPropertyAndQuantitySetMutations(pass: ExportPass, options: StepExportOptions, groups: PropertyMutationGroups, ctx: PropertySetContext): void;
+/**
+ * Write the generated property-set and quantity-set records into
+ * `pass.entities`, and point every affected type object's `HasPropertySets` at
+ * the property sets this export just generated.
+ *
+ * Three loops, in the order `export()` ran them, and the order is load-bearing:
+ * the rewrite reads `generatedTypeOwnedPsetIds` from the property-set loop, and
+ * the caller flushes `pass.rewrittenEntityLines` — this function's output —
+ * only after the quantity-set loop has run.
+ */
+export declare function generatePropertyAndQuantitySetEntities(pass: ExportPass, options: StepExportOptions, ctx: PropertySetContext): void;
+//# sourceMappingURL=step-property-sets.d.ts.map

package/dist/step-property-sets.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"step-property-sets.d.ts","sourceRoot":"","sources":["../src/step-property-sets.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmDG;AAEH,OAAO,KAAK,EAAE,YAAY,EAAqB,MAAM,kBAAkB,CAAC;AACxE,OAAO,EAAE,eAAe,EAAkD,MAAM,kBAAkB,CAAC;AACnG,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,qBAAqB,CAAC;AAK/D,OAAO,EAAE,qBAAqB,EAAe,MAAM,wBAAwB,CAAC;AAY5E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAC9D,OAAO,KAAK,EAAE,UAAU,EAAE,mBAAmB,EAAE,iBAAiB,EAAE,MAAM,oBAAoB,CAAC;AAqB7F;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAChC;kEAC8D;IAC9D,WAAW,EAAE,MAAM,GAAG,SAAS,CAAC;IAChC,2EAA2E;IAC3E,QAAQ,CAAC,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC,CAAC;CAC/C;AAED;;;;;;;;GAQG;AACH,MAAM,WAAW,kBAAkB;IACjC,QAAQ,CAAC,SAAS,EAAE,YAAY,CAAC;IACjC,QAAQ,CAAC,eAAe,EAAE,eAAe,GAAG,IAAI,CAAC;IACjD,QAAQ,CAAC,YAAY,EAAE,mBAAmB,GAAG,IAAI,CAAC;IAClD,QAAQ,CAAC,mBAAmB,EAAE,UAAU,CAAC,OAAO,qBAAqB,CAAC,CAAC;IACvE,oDAAoD;IACpD,QAAQ,CAAC,iBAAiB,EAAE,MAAM,MAAM,CAAC;IACzC,QAAQ,CAAC,YAAY,EAAE,iBAAiB,CAAC;IACzC;;uDAEmD;IACnD,QAAQ,CAAC,wBAAwB,EAAE,CACjC,SAAS,EAAE,MAAM,EACjB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,EAClB,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,EACnD,YAAY,EAAE,gBAAgB,EAC9B,aAAa,EAAE,OAAO,EACtB,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,KAAK,IAAI,KACnD,mBAAmB,CAAC;CAC1B;AAED,iFAAiF;AACjF,MAAM,WAAW,sBAAsB;IACrC,QAAQ,CAAC,mBAAmB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACvD,QAAQ,CAAC,oBAAoB,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC;IACxD,QAAQ,CAAC,kBAAkB,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;CACpF;AAED;;;;;;;;GAQG;AACH,wBAAgB,gCAAgC,CAAC,GAAG,EAAE,kBAAkB,GAAG;IACzE,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC;QAAE,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAE,CAAC,CAAC,CAAC;IAChE,YAAY,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAC;CACrC,CAmBA;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+CG;AAQH,wBAAgB,cAAc,CAAC,GAAG,EAAE,kBAAkB,EAAE,QAAQ,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQvF;AAoCD;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,GAAG,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,GAAG,IAAI,CAQzF;AAeD;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,GAAG,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,EAAE,CAerF;AA0QD;;;;;;;;;;GAUG;AACH,wBAAgB,sCAAsC,CACpD,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,iBAAiB,EAC1B,MAAM,EAAE,sBAAsB,EAC9B,GAAG,EAAE,kBAAkB,GACtB,IAAI,CAqQN;AAED;;;;;;;;;GASG;AACH,wBAAgB,sCAAsC,CACpD,IAAI,EAAE,UAAU,EAChB,OAAO,EAAE,iBAAiB,EAC1B,GAAG,EAAE,kBAAkB,GACtB,IAAI,CAgLN"}