@memoarchitect/tools 0.6.7 → 0.8.7

package/packages/tools/lib/model/activity-notation.js

@@ -0,0 +1,208 @@
+// ─── Activity notation roles ─────────────────────────────────────────────────
+//
+// Which activity symbol an element draws as. Same standard as
+// `relationship-legality.ts`: pure, dependency-free, and derived from declared
+// data rather than from a table of names in TypeScript.
+//
+// What this replaces. Architect's `actionflow-view.ts` classified nodes by
+// comparing a normalised `kind` string against a ladder of spellings —
+// `'decisionnode' || 'decisionnodeusage'`, `'acceptactionusage' ||
+// 'acceptaction'`, and so on. Three problems with that, in increasing order of
+// seriousness: it lived in the view rather than in the toolchain (§1.2.2); the
+// spellings were a hardcoded kind list, which is exactly what the engine is not
+// supposed to contain; and it could not answer a question the metamodel answers
+// for free — that a `ForkNode` *is* a `ControlNode` *is* an `ActionUsage`.
+//
+// How it works instead. Three declared sources decide, and none of them is a
+// list of names maintained here:
+//
+//   1. **The normative metamodel.** `SYSML_METACLASSES` is generated from
+//      `SysML.ecore` (Track B B2), so the generalization graph — `ForkNode` →
+//      `ControlNode` → `ActionUsage` — is data. A role is anchored on one
+//      metaclass and matched with `conformsTo`, so every present and future
+//      subtype of that anchor classifies correctly without being named.
+//   2. **The metamodel again, for precedence.** Roles are tried most-specific
+//      first, and "most specific" is computed from each anchor's supertype
+//      depth rather than written down in an order someone has to maintain.
+//   3. **The ontology.** An element whose `kind` is a MEMO ontology kind is
+//      resolved by walking that kind's declared `superType` chain, so binding a
+//      new kind to a notation role is an ontology edit and not a code change.
+//
+// What remains hardcoded, stated plainly rather than hidden. Two things, both
+// irreducible today:
+//
+//   - **The role → anchor binding.** Notation is a mapping from semantics to
+//      symbols; something has to state it. The normative graphical grammar
+//      (`bnf/SysML-graphical-bnf.kgbnf`, vendored) names the productions —
+//      `fork-node`, `decision-node`, `accept-action-node` — but binds them to
+//      SVG images, not to metaclasses, so it cannot supply the anchor. Each
+//      binding cites its production, and Session 5's notation work is where the
+//      kgbnf becomes the source rather than the citation.
+//   - **The two final-node roles.** SysML v2 has no `ActivityFinalNode` or
+//      `FlowFinalNode` metaclass; they are UML and SysML v1 names that
+//      importers still emit. They cannot come from the v2 metamodel because the
+//      v2 metamodel does not have them, so they are declared as what they are —
+//      legacy input spellings — instead of sitting in the same ladder as
+//      metaclasses that do exist.
+// ─────────────────────────────────────────────────────────────────────────────
+import { SYSML_METACLASSES, allSuperTypes, conformsTo } from '../sysml-ir/index.js';
+/**
+ * Role bindings, unordered.
+ *
+ * Deliberately not written in precedence order — `activityRolesBySpecificity()`
+ * derives that from the metamodel, so adding a binding cannot put it in the
+ * wrong place.
+ */
+export const ACTIVITY_NOTATION_ROLES = [
+    { role: 'fork', metaclass: 'ForkNode', bnfProduction: 'fork-node' },
+    { role: 'join', metaclass: 'JoinNode', bnfProduction: 'join-node' },
+    { role: 'decision', metaclass: 'DecisionNode', bnfProduction: 'decision-node' },
+    { role: 'merge', metaclass: 'MergeNode', bnfProduction: 'merge-node' },
+    { role: 'send', metaclass: 'SendActionUsage', bnfProduction: 'send-action-node' },
+    { role: 'accept', metaclass: 'AcceptActionUsage', bnfProduction: 'accept-action-node' },
+    { role: 'activityFinal', metaclass: 'TerminateActionUsage' },
+    { role: 'action', metaclass: 'ActionUsage', bnfProduction: 'action-node' },
+    // Definitions draw as actions too, and `ActionDefinition` is not a subtype
+    // of `ActionUsage` — the metamodel puts it under `OccurrenceDefinition` and
+    // `Behavior` — so it needs its own anchor rather than being reached through
+    // the usage one. A role with two anchors is exactly what the list shape is
+    // for.
+    { role: 'action', metaclass: 'ActionDefinition', bnfProduction: 'action-node' },
+];
+/**
+ * Input spellings SysML v2 has no metaclass for.
+ *
+ * UML and SysML v1 final nodes. Kept because importers emit them and a diagram
+ * that silently drops a final node is worse than one drawn from a legacy name;
+ * kept *here*, apart from the metamodel-driven path, because pretending they
+ * are metaclasses is how the old ladder became unreadable.
+ */
+const LEGACY_NODE_SPELLINGS = {
+    activityfinalnode: 'activityFinal',
+    activityfinalnodeusage: 'activityFinal',
+    flowfinalnode: 'flowFinal',
+    flowfinalnodeusage: 'flowFinal',
+};
+/**
+ * MEMO grammar literals for `ControlNodeUsage.controlKind`, bound to the
+ * metaclasses they name.
+ *
+ * The four values come from MEMO's own Langium grammar, so they are not
+ * derivable from `SysML.ecore` — but their targets are, and
+ * `controlKindMetaclassesAreControlNodes()` asserts that these four are exactly
+ * the metamodel's `ControlNode` subtypes. A fifth control node upstream fails
+ * that check rather than silently going unclassified.
+ */
+export const CONTROL_KIND_METACLASS = {
+    fork: 'ForkNode',
+    join: 'JoinNode',
+    decide: 'DecisionNode',
+    merge: 'MergeNode',
+};
+/** True when the bindings above still match the metamodel's control nodes. */
+export function controlKindMetaclassesAreControlNodes() {
+    const declared = new Set(Object.values(CONTROL_KIND_METACLASS));
+    const actual = Object.keys(SYSML_METACLASSES)
+        .filter(name => name !== 'ControlNode' && conformsTo(name, 'ControlNode'));
+    return actual.length === declared.size && actual.every(name => declared.has(name));
+}
+/**
+ * Roles most-specific first, by supertype depth.
+ *
+ * `ForkNode` sits three levels below `ActionUsage`, so it is tried first and an
+ * `ActionUsage` anchor never swallows a control node. Computed rather than
+ * declared, because the metamodel already knows the answer.
+ */
+export function activityRolesBySpecificity() {
+    return [...ACTIVITY_NOTATION_ROLES].sort((a, b) => allSuperTypes(b.metaclass).length - allSuperTypes(a.metaclass).length);
+}
+/**
+ * Spellings of `token` to try against the metamodel.
+ *
+ * The suffix rules exist because the same concept is written several ways
+ * across importers and MEMO's own construct keywords — `DecisionNodeUsage`,
+ * `decision`, `AcceptAction`. What makes this different from the ladder it
+ * replaces is that *the metamodel decides* which candidate is real: a spelling
+ * that does not name a metaclass simply does not match, and no spelling has to
+ * be enumerated here.
+ */
+function metaclassCandidates(token) {
+    if (!token)
+        return [];
+    const base = token.replace(/[ _-]/g, '');
+    const capitalized = base.charAt(0).toUpperCase() + base.slice(1);
+    return [
+        capitalized,
+        `${capitalized}Usage`,
+        `${capitalized}Node`,
+        `${capitalized}ActionUsage`,
+        capitalized.replace(/Usage$/, ''),
+        capitalized.replace(/Definition$/, ''),
+    ];
+}
+/** The metaclass a token names, if the metamodel has one. */
+function resolveMetaclass(token) {
+    for (const candidate of metaclassCandidates(token ?? '')) {
+        if (candidate in SYSML_METACLASSES)
+            return candidate;
+    }
+    return undefined;
+}
+/** An ontology kind and everything it specializes, nearest first. */
+function ontologyChain(kind, kinds) {
+    const byName = new Map((kinds ?? []).map(definition => [definition.name, definition]));
+    const chain = [];
+    let current = kind;
+    while (current && !chain.includes(current)) {
+        chain.push(current);
+        current = byName.get(current)?.superType;
+    }
+    return chain;
+}
+/**
+ * The activity symbol this element draws as, or `undefined` if it is not an
+ * activity node at all.
+ *
+ * `registries` is optional: without it, classification uses the metamodel
+ * alone, which is what a caller holding a bare element can do. With it, an
+ * ontology kind reaches its role through its declared specialization chain —
+ * which is the path a project extends.
+ */
+export function activityNodeType(element, registries) {
+    // The metamodel's own discriminator first: a control node says what it is.
+    const controlKind = element.attributes?.controlKind?.toLowerCase();
+    const fromControlKind = controlKind ? CONTROL_KIND_METACLASS[controlKind] : undefined;
+    const tokens = [
+        ...(fromControlKind ? [fromControlKind] : []),
+        ...ontologyChain(element.kind, registries?.kinds),
+        // Native SysML nodes (AcceptActionUsage, DecisionNodeUsage, etc.) are
+        // already represented by their metaclass name in `kind`; do not rely
+        // on the generic `construct: action`, which would erase their symbol.
+        element.kind,
+        element.construct,
+    ];
+    const roles = activityRolesBySpecificity();
+    for (const token of tokens) {
+        const legacy = LEGACY_NODE_SPELLINGS[(token ?? '').replace(/[ _-]/g, '').toLowerCase()];
+        if (legacy)
+            return legacy;
+        const metaclass = resolveMetaclass(token);
+        if (!metaclass)
+            continue;
+        const match = roles.find(role => conformsTo(metaclass, role.metaclass));
+        if (match)
+            return match.role;
+    }
+    return undefined;
+}
+/** Control nodes flow through the graph but own no responsibility lane. */
+export function isControlNode(element, registries) {
+    const role = activityNodeType(element, registries);
+    if (role === 'activityFinal' || role === 'flowFinal')
+        return true;
+    const binding = ACTIVITY_NOTATION_ROLES.find(candidate => candidate.role === role);
+    // "Is it a control node" is the metamodel's question, not a list of four
+    // role names: `ControlNode` is a metaclass, and the anchors sit under it.
+    return binding !== undefined && conformsTo(binding.metaclass, 'ControlNode');
+}
+//# sourceMappingURL=activity-notation.js.map

package/packages/tools/lib/model/activity-notation.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"activity-notation.js","sourceRoot":"","sources":["../../src/model/activity-notation.ts"],"names":[],"mappings":"AAAA,gFAAgF;AAChF,EAAE;AACF,8DAA8D;AAC9D,+EAA+E;AAC/E,wDAAwD;AACxD,EAAE;AACF,2EAA2E;AAC3E,uEAAuE;AACvE,mEAAmE;AACnE,+EAA+E;AAC/E,+EAA+E;AAC/E,gFAAgF;AAChF,gFAAgF;AAChF,2EAA2E;AAC3E,EAAE;AACF,6EAA6E;AAC7E,iCAAiC;AACjC,EAAE;AACF,0EAA0E;AAC1E,8EAA8E;AAC9E,0EAA0E;AAC1E,4EAA4E;AAC5E,wEAAwE;AACxE,8EAA8E;AAC9E,2EAA2E;AAC3E,2EAA2E;AAC3E,4EAA4E;AAC5E,gFAAgF;AAChF,8EAA8E;AAC9E,EAAE;AACF,8EAA8E;AAC9E,qBAAqB;AACrB,EAAE;AACF,6EAA6E;AAC7E,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAC9E,4EAA4E;AAC5E,gFAAgF;AAChF,0DAA0D;AAC1D,2EAA2E;AAC3E,uEAAuE;AACvE,gFAAgF;AAChF,gFAAgF;AAChF,yEAAyE;AACzE,kCAAkC;AAClC,gFAAgF;AAEhF,OAAO,EAAE,iBAAiB,EAAE,aAAa,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAkBpF;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,uBAAuB,GAAoC;IACpE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE;IACnE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,UAAU,EAAE,aAAa,EAAE,WAAW,EAAE;IACnE,EAAE,IAAI,EAAE,UAAU,EAAE,SAAS,EAAE,cAAc,EAAE,aAAa,EAAE,eAAe,EAAE;IAC/E,EAAE,IAAI,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,aAAa,EAAE,YAAY,EAAE;IACtE,EAAE,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,iBAAiB,EAAE,aAAa,EAAE,kBAAkB,EAAE;IACjF,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,mBAAmB,EAAE,aAAa,EAAE,oBAAoB,EAAE;IACvF,EAAE,IAAI,EAAE,eAAe,EAAE,SAAS,EAAE,sBAAsB,EAAE;IAC5D,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,aAAa,EAAE,aAAa,EAAE,aAAa,EAAE;IAC1E,2EAA2E;IAC3E,4EAA4E;IAC5E,4EAA4E;IAC5E,2EAA2E;IAC3E,OAAO;IACP,EAAE,IAAI,EAAE,QAAQ,EAAE,SAAS,EAAE,kBAAkB,EAAE,aAAa,EAAE,aAAa,EAAE;CAClF,CAAC;AAEF;;;;;;;GAOG;AACH,MAAM,qBAAqB,GAA+C;IACtE,iBAAiB,EAAE,eAAe;IAClC,sBAAsB,EAAE,eAAe;IACvC,aAAa,EAAE,WAAW;IAC1B,kBAAkB,EAAE,WAAW;CAClC,CAAC;AAEF;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAqC;IACpE,IAAI,EAAE,UAAU;IAChB,IAAI,EAAE,UAAU;IAChB,MAAM,EAAE,cAAc;IACtB,KAAK,EAAE,WAAW;CACrB,CAAC;AAEF,8EAA8E;AAC9E,MAAM,UAAU,qCAAqC;IACjD,MAAM,QAAQ,GAAG,IAAI,GAAG,CAAC,MAAM,CAAC,MAAM,CAAC,sBAAsB,CAAC,CAAC,CAAC;IAChE,MAAM,MAAM,GAAG,MAAM,CAAC,IAAI,CAAC,iBAAiB,CAAC;SACxC,MAAM,CAAC,IAAI,CAAC,EAAE,CAAC,IAAI,KAAK,aAAa,IAAI,UAAU,CAAC,IAAI,EAAE,aAAa,CAAC,CAAC,CAAC;IAC/E,OAAO,MAAM,CAAC,MAAM,KAAK,QAAQ,CAAC,IAAI,IAAI,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE,CAAC,QAAQ,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC,CAAC;AACvF,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,0BAA0B;IACtC,OAAO,CAAC,GAAG,uBAAuB,CAAC,CAAC,IAAI,CACpC,CAAC,CAAC,EAAE,CAAC,EAAE,EAAE,CAAC,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,GAAG,aAAa,CAAC,CAAC,CAAC,SAAS,CAAC,CAAC,MAAM,CAAC,CAAC;AACzF,CAAC;AAED;;;;;;;;;GASG;AACH,SAAS,mBAAmB,CAAC,KAAa;IACtC,IAAI,CAAC,KAAK;QAAE,OAAO,EAAE,CAAC;IACtB,MAAM,IAAI,GAAG,KAAK,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC;IACzC,MAAM,WAAW,GAAG,IAAI,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,WAAW,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;IACjE,OAAO;QACH,WAAW;QACX,GAAG,WAAW,OAAO;QACrB,GAAG,WAAW,MAAM;QACpB,GAAG,WAAW,aAAa;QAC3B,WAAW,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC;QACjC,WAAW,CAAC,OAAO,CAAC,aAAa,EAAE,EAAE,CAAC;KACzC,CAAC;AACN,CAAC;AAED,6DAA6D;AAC7D,SAAS,gBAAgB,CAAC,KAAyB;IAC/C,KAAK,MAAM,SAAS,IAAI,mBAAmB,CAAC,KAAK,IAAI,EAAE,CAAC,EAAE,CAAC;QACvD,IAAI,SAAS,IAAI,iBAAiB;YAAE,OAAO,SAAS,CAAC;IACzD,CAAC;IACD,OAAO,SAAS,CAAC;AACrB,CAAC;AAED,qEAAqE;AACrE,SAAS,aAAa,CAAC,IAAY,EAAE,KAA+C;IAChF,MAAM,MAAM,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,GAAG,CAAC,UAAU,CAAC,EAAE,CAAC,CAAC,UAAU,CAAC,IAAI,EAAE,UAAU,CAAC,CAAC,CAAC,CAAC;IACvF,MAAM,KAAK,GAAa,EAAE,CAAC;IAC3B,IAAI,OAAO,GAAuB,IAAI,CAAC;IACvC,OAAO,OAAO,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC;QACzC,KAAK,CAAC,IAAI,CAAC,OAAO,CAAC,CAAC;QACpB,OAAO,GAAG,MAAM,CAAC,GAAG,CAAC,OAAO,CAAC,EAAE,SAAS,CAAC;IAC7C,CAAC;IACD,OAAO,KAAK,CAAC;AACjB,CAAC;AAED;;;;;;;;GAQG;AACH,MAAM,UAAU,gBAAgB,CAC5B,OAAoB,EACpB,UAAkC;IAElC,2EAA2E;IAC3E,MAAM,WAAW,GAAG,OAAO,CAAC,UAAU,EAAE,WAAW,EAAE,WAAW,EAAE,CAAC;IACnE,MAAM,eAAe,GAAG,WAAW,CAAC,CAAC,CAAC,sBAAsB,CAAC,WAAW,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC;IAEtF,MAAM,MAAM,GAAG;QACX,GAAG,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,eAAe,CAAC,CAAC,CAAC,CAAC,EAAE,CAAC;QAC7C,GAAG,aAAa,CAAC,OAAO,CAAC,IAAI,EAAE,UAAU,EAAE,KAAK,CAAC;QACjD,sEAAsE;QACtE,qEAAqE;QACrE,sEAAsE;QACtE,OAAO,CAAC,IAAI;QACZ,OAAO,CAAC,SAAS;KACpB,CAAC;IAEF,MAAM,KAAK,GAAG,0BAA0B,EAAE,CAAC;IAC3C,KAAK,MAAM,KAAK,IAAI,MAAM,EAAE,CAAC;QACzB,MAAM,MAAM,GAAG,qBAAqB,CAAC,CAAC,KAAK,IAAI,EAAE,CAAC,CAAC,OAAO,CAAC,QAAQ,EAAE,EAAE,CAAC,CAAC,WAAW,EAAE,CAAC,CAAC;QACxF,IAAI,MAAM;YAAE,OAAO,MAAM,CAAC;QAC1B,MAAM,SAAS,GAAG,gBAAgB,CAAC,KAAK,CAAC,CAAC;QAC1C,IAAI,CAAC,SAAS;YAAE,SAAS;QACzB,MAAM,KAAK,GAAG,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAAC,UAAU,CAAC,SAAS,EAAE,IAAI,CAAC,SAAS,CAAC,CAAC,CAAC;QACxE,IAAI,KAAK;YAAE,OAAO,KAAK,CAAC,IAAI,CAAC;IACjC,CAAC;IACD,OAAO,SAAS,CAAC;AACrB,CAAC;AAED,2EAA2E;AAC3E,MAAM,UAAU,aAAa,CAAC,OAAoB,EAAE,UAAkC;IAClF,MAAM,IAAI,GAAG,gBAAgB,CAAC,OAAO,EAAE,UAAU,CAAC,CAAC;IACnD,IAAI,IAAI,KAAK,eAAe,IAAI,IAAI,KAAK,WAAW;QAAE,OAAO,IAAI,CAAC;IAClE,MAAM,OAAO,GAAG,uBAAuB,CAAC,IAAI,CAAC,SAAS,CAAC,EAAE,CAAC,SAAS,CAAC,IAAI,KAAK,IAAI,CAAC,CAAC;IACnF,yEAAyE;IACzE,0EAA0E;IAC1E,OAAO,OAAO,KAAK,SAAS,IAAI,UAAU,CAAC,OAAO,CAAC,SAAS,EAAE,aAAa,CAAC,CAAC;AACjF,CAAC"}

package/packages/tools/lib/model/builder.d.ts

@@ -3,6 +3,7 @@ import type { MemoModel, ParseError } from './semantic.js';
 import type { ParsedDocument } from './parser-utils.js';
 import type { KindRegistry } from './kind-registry.js';
 import type { RelationshipRegistry } from './relationship-registry.js';
+import type { ProvenanceTable } from './source-provenance.js';
 /**
  * Optional registries for dual-mode resolution.
  * When provided, registries take precedence over config lookups.
@@ -13,6 +14,8 @@ export interface BuilderRegistries {
     kindRegistry?: KindRegistry;
     /** RelationshipRegistry populated from ontology SysML files */
     relationshipRegistry?: RelationshipRegistry;
+    /** Resolved source ownership; never infer this from a client-side path. */
+    provenance?: ProvenanceTable;
 }
 /**
  * Build a MemoModel from parsed documents and config.

package/packages/tools/lib/model/builder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/model/builder.ts"],"names":[],"mappings":"AA4DA,OAAO,KAAK,EAAE,UAAU,EAAkB,MAAM,aAAa,CAAC;AAC9D,OAAO,KAAK,EAGR,SAAS,EACT,UAAU,EAGb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAGvE;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAC9B,uDAAuD;IACvD,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,+DAA+D;IAC/D,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;CAC/C;AAmFD;;;GAGG;AACH,wBAAgB,cAAc,CAC1B,SAAS,EAAE,cAAc,EAAE,EAC3B,MAAM,EAAE,UAAU,EAClB,WAAW,GAAE,UAAU,EAAO,EAC9B,UAAU,CAAC,EAAE,iBAAiB,GAC/B,SAAS,CAiIX"}
+{"version":3,"file":"builder.d.ts","sourceRoot":"","sources":["../../src/model/builder.ts"],"names":[],"mappings":"AAgGA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAC;AAE9C,OAAO,KAAK,EAGR,SAAS,EAET,UAAU,EAGb,MAAM,eAAe,CAAC;AACvB,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,mBAAmB,CAAC;AAGxD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AACvD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC;AAIvE,OAAO,KAAK,EAAE,eAAe,EAA6B,MAAM,wBAAwB,CAAC;AAGzF;;;;GAIG;AACH,MAAM,WAAW,iBAAiB;IAC9B,uDAAuD;IACvD,YAAY,CAAC,EAAE,YAAY,CAAC;IAC5B,+DAA+D;IAC/D,oBAAoB,CAAC,EAAE,oBAAoB,CAAC;IAC5C,2EAA2E;IAC3E,UAAU,CAAC,EAAE,eAAe,CAAC;CAChC;AAsGD;;;GAGG;AACH,wBAAgB,cAAc,CAC1B,SAAS,EAAE,cAAc,EAAE,EAC3B,MAAM,EAAE,UAAU,EAClB,WAAW,GAAE,UAAU,EAAO,EAC9B,UAAU,CAAC,EAAE,iBAAiB,GAC/B,SAAS,CA8MX"}