@ifc-lite/mutations 1.26.1 → 2.0.0

package/dist/mutation-guard.js

@@ -0,0 +1,40 @@
+/* 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/. */
+/**
+ * Optional local-edit guard for the "always-local" write engines
+ * (`BulkQueryEngine`, `CsvConnector`).
+ *
+ * These two classes are constructed directly by viewer components
+ * (`BulkPropertyEditor.tsx`, `DataConnector.tsx`) and write straight to a
+ * `MutablePropertyView`, bypassing the Zustand store's `setProperty` /
+ * `setEntityType` actions — and, with them, `canCollabEdit()`. Unlike
+ * `MutablePropertyView` and `StoreEditor` themselves (see the module doc on
+ * `MutablePropertyView`), neither engine is ever reached by inbound CRDT
+ * replay, `useZoneWriteBack`, or any `mirror*` helper: both are always
+ * constructed fresh, per dialog-open, from a local user action, and never
+ * shared with — or passed into — the collab plumbing. That makes them safe
+ * to gate at construction: there is no legitimate caller this guard could
+ * wrongly block.
+ *
+ * A caller passes a `canEdit` predicate at construction; the engine consults
+ * it once before mutating and throws `MutationGuardError` (rather than
+ * silently dropping the write) if it returns false. Passing no predicate
+ * preserves today's behaviour exactly — this is opt-in, not a new default,
+ * so it does not change any other consumer of these classes (CLI, SDK,
+ * sandbox bridge, existing tests).
+ */
+/** Thrown by a guarded engine when `canEdit()` returns false. */
+export class MutationGuardError extends Error {
+    constructor(message = 'Mutation blocked: editing is disabled for the current role') {
+        super(message);
+        this.name = 'MutationGuardError';
+    }
+}
+/** Throws `MutationGuardError` if `guard` is present and returns false. */
+export function checkMutationGuard(guard) {
+    if (guard && !guard()) {
+        throw new MutationGuardError();
+    }
+}
+//# sourceMappingURL=mutation-guard.js.map

package/dist/mutation-guard.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"mutation-guard.js","sourceRoot":"","sources":["../src/mutation-guard.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,iEAAiE;AACjE,MAAM,OAAO,kBAAmB,SAAQ,KAAK;IAC3C,YAAY,OAAO,GAAG,4DAA4D;QAChF,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,oBAAoB,CAAC;IACnC,CAAC;CACF;AAKD,2EAA2E;AAC3E,MAAM,UAAU,kBAAkB,CAAC,KAAuC;IACxE,IAAI,KAAK,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC;QACtB,MAAM,IAAI,kBAAkB,EAAE,CAAC;IACjC,CAAC;AACH,CAAC"}

package/dist/nonfinite-json.d.ts

@@ -0,0 +1,8 @@
+/** `JSON.stringify` replacer for `MutablePropertyView.exportMutations()`. */
+export declare function encodeNonFiniteNumbers(key: string, value: unknown): unknown;
+/**
+ * `JSON.parse` reviver for `MutablePropertyView.importMutations()`; inverse
+ * of {@link encodeNonFiniteNumbers}.
+ */
+export declare function decodeNonFiniteNumbers(key: string, value: unknown): unknown;
+//# sourceMappingURL=nonfinite-json.d.ts.map

package/dist/nonfinite-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"nonfinite-json.d.ts","sourceRoot":"","sources":["../src/nonfinite-json.ts"],"names":[],"mappings":"AAoCA,6EAA6E;AAC7E,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAU3E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,GAAG,OAAO,CAY3E"}

package/dist/nonfinite-json.js

@@ -0,0 +1,57 @@
+/* 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/. */
+/**
+ * `JSON.stringify`/`JSON.parse` replacer+reviver pair that preserves a
+ * non-finite number (`NaN`/`Infinity`/`-Infinity`) inside a `Mutation`'s
+ * `newValue`/`oldValue`, or a `value` inside a whole-set `newValue` array
+ * (`createPropertySet`/`createQuantitySet`'s per-member payload).
+ *
+ * JSON has no non-finite numeric literal (RFC 8259); `JSON.stringify` silently
+ * maps `NaN`/`Infinity`/`-Infinity` to `null`, indistinguishable from the value
+ * being absent. `MutablePropertyView.applyMutations`' quantity replay then
+ * does `Number(mutation.newValue)`, and `Number(null)` is `0` — so an
+ * out-of-range quantity (e.g. a computed volume that overflowed, or a CSV
+ * cell parsed to `NaN`) silently became `0` across `exportMutations()` →
+ * `importMutations()`, even though direct application (no serialization in
+ * between) preserves it exactly. Mirrors the sibling fix for the JSON/JSON-LD
+ * export path (`finite_json_number` in `rust/export/src/json.rs`, #3596) and
+ * the query aggregation guard (#3611) — this repo's recurring non-finite-value
+ * shape.
+ */
+const NON_FINITE_NUMBER_KEYS = new Set(['newValue', 'oldValue', 'value']);
+function isNonFiniteNumberMarker(value) {
+    return (typeof value === 'object' &&
+        value !== null &&
+        typeof value.__nonFiniteNumber === 'string');
+}
+/** `JSON.stringify` replacer for `MutablePropertyView.exportMutations()`. */
+export function encodeNonFiniteNumbers(key, value) {
+    if (NON_FINITE_NUMBER_KEYS.has(key) && typeof value === 'number' && !Number.isFinite(value)) {
+        const token = Number.isNaN(value)
+            ? 'NaN'
+            : value > 0
+                ? 'Infinity'
+                : '-Infinity';
+        return { __nonFiniteNumber: token };
+    }
+    return value;
+}
+/**
+ * `JSON.parse` reviver for `MutablePropertyView.importMutations()`; inverse
+ * of {@link encodeNonFiniteNumbers}.
+ */
+export function decodeNonFiniteNumbers(key, value) {
+    if (NON_FINITE_NUMBER_KEYS.has(key) && isNonFiniteNumberMarker(value)) {
+        switch (value.__nonFiniteNumber) {
+            case 'NaN':
+                return NaN;
+            case 'Infinity':
+                return Infinity;
+            case '-Infinity':
+                return -Infinity;
+        }
+    }
+    return value;
+}
+//# sourceMappingURL=nonfinite-json.js.map

package/dist/nonfinite-json.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"nonfinite-json.js","sourceRoot":"","sources":["../src/nonfinite-json.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AAE/D;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,sBAAsB,GAAG,IAAI,GAAG,CAAC,CAAC,UAAU,EAAE,UAAU,EAAE,OAAO,CAAC,CAAC,CAAC;AAM1E,SAAS,uBAAuB,CAAC,KAAc;IAC7C,OAAO,CACL,OAAO,KAAK,KAAK,QAAQ;QACzB,KAAK,KAAK,IAAI;QACd,OAAQ,KAAyC,CAAC,iBAAiB,KAAK,QAAQ,CACjF,CAAC;AACJ,CAAC;AAED,6EAA6E;AAC7E,MAAM,UAAU,sBAAsB,CAAC,GAAW,EAAE,KAAc;IAChE,IAAI,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,KAAK,KAAK,QAAQ,IAAI,CAAC,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC;QAC5F,MAAM,KAAK,GAA+C,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC;YAC3E,CAAC,CAAC,KAAK;YACP,CAAC,CAAC,KAAK,GAAG,CAAC;gBACT,CAAC,CAAC,UAAU;gBACZ,CAAC,CAAC,WAAW,CAAC;QAClB,OAAO,EAAE,iBAAiB,EAAE,KAAK,EAAkC,CAAC;IACtE,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,sBAAsB,CAAC,GAAW,EAAE,KAAc;IAChE,IAAI,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,uBAAuB,CAAC,KAAK,CAAC,EAAE,CAAC;QACtE,QAAQ,KAAK,CAAC,iBAAiB,EAAE,CAAC;YAChC,KAAK,KAAK;gBACR,OAAO,GAAG,CAAC;YACb,KAAK,UAAU;gBACb,OAAO,QAAQ,CAAC;YAClB,KAAK,WAAW;gBACd,OAAO,CAAC,QAAQ,CAAC;QACrB,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC;AACf,CAAC"}

package/dist/same-name-set-claims.d.ts

@@ -0,0 +1,54 @@
+/**
+ * `getForEntity`/`getQuantitiesForEntity`'s shared helper for entities that
+ * carry two (or more) base property/quantity sets sharing a name (a type
+ * pset and an occurrence pset, say). A mutation key
+ * (`${entityId}:${setName}:${memberName}`) has no identity past the set
+ * NAME, so it can't tell apart which instance a SET/DELETE on an existing
+ * member, or a brand-new member, was meant for. Both must still land on
+ * exactly ONE instance: the FIRST one (in base-set order) whose own base
+ * members already carry that name -- matching the "first match across the
+ * sequence wins" read semantics `findPropertyInSets`/
+ * `PropertyTable.getProperty` already use for same-named reads (#3468). A
+ * member that exists on NO instance yet (a genuinely new property/quantity)
+ * is claimed by the first instance of that set name, same as a brand-new
+ * set would be.
+ *
+ * One implementation, parameterised over the set/member shapes, backs both
+ * the property and quantity paths -- they are one mechanism (a name-only
+ * mutation key over possibly-repeated set names) and must agree; a
+ * property-only or quantity-only copy would drift the same way the pset and
+ * qset paths themselves drifted before this file existed.
+ */
+export interface SetClaims<S> {
+    /** `${setName}:${memberName}` -> the base set instance that owns edits to it. */
+    readonly claimingInstanceForMember: Map<string, S>;
+    /** `setName` -> the first base set instance carrying that name. */
+    readonly firstInstanceOfSetName: Map<string, S>;
+}
+export declare function computeSetClaims<S extends {
+    name: string;
+}>(sets: readonly S[], membersOf: (set: S) => readonly {
+    name: string;
+}[]): SetClaims<S>;
+/**
+ * The mutated member list for ONE base set instance: its own members with
+ * SET/DELETE applied only where this instance is the claiming one for that
+ * name, plus any genuinely-new member this instance claims as the first
+ * instance of its set name.
+ *
+ * @param memberKey builds the mutation-map key, e.g. `propertyKey`/`quantityKey`.
+ * @param applySet builds the output row for an own member a SET mutation targets.
+ * @param passthrough builds the output row for an own member with no mutation
+ *   applied here (either unmutated, or mutated on a sibling instance instead).
+ * @param buildNew builds the output row for a brand-new member this instance claims.
+ */
+export declare function mutatedMembersForInstance<S extends {
+    name: string;
+}, M extends {
+    name: string;
+}, Mut extends {
+    operation: 'SET' | 'DELETE';
+}, Out extends {
+    name: string;
+}>(entityId: number, set: S, members: readonly M[], claims: SetClaims<S>, mutations: ReadonlyMap<string, Mut>, entityMemberKeys: ReadonlySet<string> | undefined, memberKey: (entityId: number, setName: string, memberName: string) => string, applySet: (member: M, mutation: Mut) => Out, passthrough: (member: M) => Out, buildNew: (name: string, mutation: Mut) => Out): Out[];
+//# sourceMappingURL=same-name-set-claims.d.ts.map

package/dist/same-name-set-claims.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"same-name-set-claims.d.ts","sourceRoot":"","sources":["../src/same-name-set-claims.ts"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH,MAAM,WAAW,SAAS,CAAC,CAAC;IAC1B,iFAAiF;IACjF,QAAQ,CAAC,yBAAyB,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;IACnD,mEAAmE;IACnE,QAAQ,CAAC,sBAAsB,EAAE,GAAG,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;CACjD;AAED,wBAAgB,gBAAgB,CAAC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EACzD,IAAI,EAAE,SAAS,CAAC,EAAE,EAClB,SAAS,EAAE,CAAC,GAAG,EAAE,CAAC,KAAK,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAAE,GACjD,SAAS,CAAC,CAAC,CAAC,CAed;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAC1B,CAAC,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAC1B,GAAG,SAAS;IAAE,SAAS,EAAE,KAAK,GAAG,QAAQ,CAAA;CAAE,EAC3C,GAAG,SAAS;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,EAE5B,QAAQ,EAAE,MAAM,EAChB,GAAG,EAAE,CAAC,EACN,OAAO,EAAE,SAAS,CAAC,EAAE,EACrB,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC,EACpB,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,GAAG,CAAC,EACnC,gBAAgB,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,SAAS,EACjD,SAAS,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,KAAK,MAAM,EAC5E,QAAQ,EAAE,CAAC,MAAM,EAAE,CAAC,EAAE,QAAQ,EAAE,GAAG,KAAK,GAAG,EAC3C,WAAW,EAAE,CAAC,MAAM,EAAE,CAAC,KAAK,GAAG,EAC/B,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,KAAK,GAAG,GAC7C,GAAG,EAAE,CAwCP"}

package/dist/same-name-set-claims.js

@@ -0,0 +1,74 @@
+/* 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/. */
+export function computeSetClaims(sets, membersOf) {
+    const claimingInstanceForMember = new Map();
+    const firstInstanceOfSetName = new Map();
+    for (const set of sets) {
+        if (!firstInstanceOfSetName.has(set.name)) {
+            firstInstanceOfSetName.set(set.name, set);
+        }
+        for (const member of membersOf(set)) {
+            const claimKey = `${set.name}:${member.name}`;
+            if (!claimingInstanceForMember.has(claimKey)) {
+                claimingInstanceForMember.set(claimKey, set);
+            }
+        }
+    }
+    return { claimingInstanceForMember, firstInstanceOfSetName };
+}
+/**
+ * The mutated member list for ONE base set instance: its own members with
+ * SET/DELETE applied only where this instance is the claiming one for that
+ * name, plus any genuinely-new member this instance claims as the first
+ * instance of its set name.
+ *
+ * @param memberKey builds the mutation-map key, e.g. `propertyKey`/`quantityKey`.
+ * @param applySet builds the output row for an own member a SET mutation targets.
+ * @param passthrough builds the output row for an own member with no mutation
+ *   applied here (either unmutated, or mutated on a sibling instance instead).
+ * @param buildNew builds the output row for a brand-new member this instance claims.
+ */
+export function mutatedMembersForInstance(entityId, set, members, claims, mutations, entityMemberKeys, memberKey, applySet, passthrough, buildNew) {
+    const { claimingInstanceForMember, firstInstanceOfSetName } = claims;
+    const mutatedMembers = [];
+    for (const member of members) {
+        const isClaimingInstance = claimingInstanceForMember.get(`${set.name}:${member.name}`) === set;
+        if (!isClaimingInstance) {
+            mutatedMembers.push(passthrough(member));
+            continue;
+        }
+        const key = memberKey(entityId, set.name, member.name);
+        const mutation = mutations.get(key);
+        if (mutation) {
+            if (mutation.operation === 'DELETE')
+                continue;
+            mutatedMembers.push(applySet(member, mutation));
+        }
+        else {
+            mutatedMembers.push(passthrough(member));
+        }
+    }
+    // New members (never present on any same-named base instance) land on
+    // the first instance of this set name only, and only when no OTHER
+    // same-named instance already owns that name in its own base members
+    // (that member isn't new at all, just claimed by the sibling above).
+    if (firstInstanceOfSetName.get(set.name) === set && entityMemberKeys) {
+        const setPrefix = `${entityId}:${set.name}:`;
+        for (const key of entityMemberKeys) {
+            if (!key.startsWith(setPrefix))
+                continue;
+            const mutation = mutations.get(key);
+            if (!mutation || mutation.operation !== 'SET')
+                continue;
+            const memberName = key.slice(setPrefix.length);
+            if (claimingInstanceForMember.has(`${set.name}:${memberName}`))
+                continue; // owned by a sibling instance's own member
+            if (!mutatedMembers.some(m => m.name === memberName)) {
+                mutatedMembers.push(buildNew(memberName, mutation));
+            }
+        }
+    }
+    return mutatedMembers;
+}
+//# sourceMappingURL=same-name-set-claims.js.map

package/dist/same-name-set-claims.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"same-name-set-claims.js","sourceRoot":"","sources":["../src/same-name-set-claims.ts"],"names":[],"mappings":"AAAA;;+DAE+D;AA+B/D,MAAM,UAAU,gBAAgB,CAC9B,IAAkB,EAClB,SAAkD;IAElD,MAAM,yBAAyB,GAAG,IAAI,GAAG,EAAa,CAAC;IACvD,MAAM,sBAAsB,GAAG,IAAI,GAAG,EAAa,CAAC;IACpD,KAAK,MAAM,GAAG,IAAI,IAAI,EAAE,CAAC;QACvB,IAAI,CAAC,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,EAAE,CAAC;YAC1C,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,EAAE,GAAG,CAAC,CAAC;QAC5C,CAAC;QACD,KAAK,MAAM,MAAM,IAAI,SAAS,CAAC,GAAG,CAAC,EAAE,CAAC;YACpC,MAAM,QAAQ,GAAG,GAAG,GAAG,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC;YAC9C,IAAI,CAAC,yBAAyB,CAAC,GAAG,CAAC,QAAQ,CAAC,EAAE,CAAC;gBAC7C,yBAAyB,CAAC,GAAG,CAAC,QAAQ,EAAE,GAAG,CAAC,CAAC;YAC/C,CAAC;QACH,CAAC;IACH,CAAC;IACD,OAAO,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,CAAC;AAC/D,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,yBAAyB,CAMvC,QAAgB,EAChB,GAAM,EACN,OAAqB,EACrB,MAAoB,EACpB,SAAmC,EACnC,gBAAiD,EACjD,SAA4E,EAC5E,QAA2C,EAC3C,WAA+B,EAC/B,QAA8C;IAE9C,MAAM,EAAE,yBAAyB,EAAE,sBAAsB,EAAE,GAAG,MAAM,CAAC;IAErE,MAAM,cAAc,GAAU,EAAE,CAAC;IACjC,KAAK,MAAM,MAAM,IAAI,OAAO,EAAE,CAAC;QAC7B,MAAM,kBAAkB,GAAG,yBAAyB,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,IAAI,IAAI,MAAM,CAAC,IAAI,EAAE,CAAC,KAAK,GAAG,CAAC;QAC/F,IAAI,CAAC,kBAAkB,EAAE,CAAC;YACxB,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;YACzC,SAAS;QACX,CAAC;QAED,MAAM,GAAG,GAAG,SAAS,CAAC,QAAQ,EAAE,GAAG,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,CAAC,CAAC;QACvD,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACpC,IAAI,QAAQ,EAAE,CAAC;YACb,IAAI,QAAQ,CAAC,SAAS,KAAK,QAAQ;gBAAE,SAAS;YAC9C,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;QAClD,CAAC;aAAM,CAAC;YACN,cAAc,CAAC,IAAI,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC,CAAC;QAC3C,CAAC;IACH,CAAC;IAED,sEAAsE;IACtE,mEAAmE;IACnE,qEAAqE;IACrE,qEAAqE;IACrE,IAAI,sBAAsB,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,CAAC,KAAK,GAAG,IAAI,gBAAgB,EAAE,CAAC;QACrE,MAAM,SAAS,GAAG,GAAG,QAAQ,IAAI,GAAG,CAAC,IAAI,GAAG,CAAC;QAC7C,KAAK,MAAM,GAAG,IAAI,gBAAgB,EAAE,CAAC;YACnC,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,SAAS,CAAC;gBAAE,SAAS;YACzC,MAAM,QAAQ,GAAG,SAAS,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;YACpC,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,SAAS,KAAK,KAAK;gBAAE,SAAS;YACxD,MAAM,UAAU,GAAG,GAAG,CAAC,KAAK,CAAC,SAAS,CAAC,MAAM,CAAC,CAAC;YAC/C,IAAI,yBAAyB,CAAC,GAAG,CAAC,GAAG,GAAG,CAAC,IAAI,IAAI,UAAU,EAAE,CAAC;gBAAE,SAAS,CAAC,2CAA2C;YACrH,IAAI,CAAC,cAAc,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,UAAU,CAAC,EAAE,CAAC;gBACrD,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,UAAU,EAAE,QAAQ,CAAC,CAAC,CAAC;YACtD,CAAC;QACH,CAAC;IACH,CAAC;IAED,OAAO,cAAc,CAAC;AACxB,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ifc-lite/mutations",
-  "version": "1.26.1",
+  "version": "2.0.0",
   "description": "Mutation tracking and property editing for IFC-Lite",
   "type": "module",
   "main": "./dist/index.js",
@@ -13,12 +13,12 @@
     }
   },
   "dependencies": {
-    "@noble/hashes": "^2.3.0",
-    "@ifc-lite/data": "^3.4.0"
+    "@noble/hashes": "^2.4.0",
+    "@ifc-lite/data": "^4.0.0"
   },
   "devDependencies": {
     "typescript": "^6.0.3",
-    "vitest": "^4.1.10"
+    "vitest": "^4.1.11"
   },
   "license": "MPL-2.0",
   "author": "Louis True",