@hydranium/core 1.0.0-next.10

package/lib/langium/scope/scoped-ast-node-description.d.ts

@@ -0,0 +1,160 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import type { AstNodeDescription } from '@hydranium/langium';
+/**
+ * Visibility tier of a {@link TieredAstNodeDescription} — the static
+ * metadata declaring intended visibility class for each description.
+ *
+ * Tier is orthogonal to "scope" (the source-conditioned, tier-aware
+ * projection of the global index at a query site, built by the scope
+ * providers via filter rules over tiers). Tier is a per-description
+ * label; scope is a per-query result.
+ *
+ * Four values:
+ * - `'local'` — document-only (not in the global index; lives in
+ *   Langium's precomputed per-document scope).
+ * - `'project'` — visible inside the owning project only (equality
+ *   check against the source's project id).
+ * - `'public'` — visible from dependent projects only (own-project
+ *   canonical filter + dependency-closure membership). The
+ *   project-qualified public-tier sibling of a multi-tier emission.
+ * - `'universal'` — visible everywhere unconditionally. Synthetic /
+ *   library / stdlib content with no project ownership.
+ */
+export type DescriptionTier = 'local' | 'project' | 'public' | 'universal';
+/**
+ * A description that carries its visibility tier (and optional owning
+ * project id) as typed fields. The framework's filter rules read these
+ * fields directly to build per-query scopes without rediscovering
+ * visibility via URI lookup on the hot path.
+ *
+ * The framework's `HydraniumScopeProvider.bucketFor`
+ * reads `tier` directly when present and falls back to the URI-based
+ * lookup for untagged descriptions, so adoption is incremental.
+ */
+export interface TieredAstNodeDescription extends AstNodeDescription {
+    readonly tier: DescriptionTier;
+    /**
+     * Owning project id. Semantics vary by tier:
+     *
+     * - **`tier: 'project'`** — REQUIRED. Identifies the project that
+     *   owns this description; visible iff `description.projectId ===
+     *   sourceProjectId` (equality, not closure membership). Cross-
+     *   project access via the `'public'`-tier sibling.
+     *
+     * - **`tier: 'public'`** — REQUIRED. Identifies the owning project of
+     *   a multi-tier emission's public-tier sibling. The filter hides
+     *   this description from queries originating inside its home
+     *   project (the `'project'` sibling under a shorter name is the
+     *   canonical entry there); visible from other projects iff
+     *   `description.projectId` is in the source's dependency closure.
+     *
+     * - **`tier: 'universal'`** — FORBIDDEN. Universal descriptions have
+     *   no owning project; visible everywhere unconditionally.
+     *
+     * - **`tier: 'local'`** — always absent. Local symbols don't pass
+     *   through the project filter, so the field would be unused.
+     *
+     * Set this via the matching `HydraniumAstNodeDescriptionProvider`
+     * factory method rather than constructing descriptions by hand — each
+     * method enforces the correct shape at the type level.
+     */
+    readonly projectId?: string;
+}
+/**
+ * Structural typeguard — true iff `description.tier` is set to a string.
+ *
+ * **Runtime value vs compile-time narrowing.** After the framework's
+ * `HydraniumAstNodeDescriptionProvider.createDescription` override always
+ * emits a `tier` field (defaulting to `'local'`), every description
+ * produced inside the framework is already a `TieredAstNodeDescription`
+ * at runtime — the predicate returns true for them unconditionally. The
+ * load-bearing value of this function today is **TypeScript narrowing**:
+ * it lifts an `AstNodeDescription` to `TieredAstNodeDescription` so call
+ * sites that need to read `.tier` / `.projectId` don't have to cast.
+ *
+ * The runtime check is still required for descriptions that originate
+ * outside the framework — third-party Langium services, fixtures, raw
+ * `IndexManager.allElements` consumers — where the field may be absent.
+ */
+export declare function isTieredDescription(description: AstNodeDescription): description is TieredAstNodeDescription;
+/**
+ * True iff `description` is a {@link TieredAstNodeDescription} with
+ * `tier === 'local'`. Use to filter / narrow at call sites that switch
+ * on tier; equivalent to `isTieredDescription(d) && d.tier === 'local'`
+ * with the type narrowing baked in.
+ */
+export declare function isLocalTier(description: AstNodeDescription): description is TieredAstNodeDescription & {
+    readonly tier: 'local';
+};
+/**
+ * True iff `description` is a {@link TieredAstNodeDescription} with
+ * `tier === 'project'`. Narrows `projectId` to non-nullable `string` —
+ * matches the design contract that project-tier descriptions always
+ * carry an owning project id.
+ */
+export declare function isProjectTier(description: AstNodeDescription): description is TieredAstNodeDescription & {
+    readonly tier: 'project';
+    readonly projectId: string;
+};
+/**
+ * True iff `description` is the public-tier sibling of a multi-tier
+ * emission — a {@link TieredAstNodeDescription} with `tier === 'public'`.
+ *
+ * `'public'` descriptions ALWAYS carry a `projectId` by construction
+ * (the typed factory `createPublic` requires it). The framework's
+ * `HydraniumScopeProvider.bucketFor` suppresses
+ * a `'public'` description inside its owning project (so the shorter-
+ * name `'project'`-tier sibling is the canonical entry there) and
+ * shows it to dependent projects in the source's visibility closure.
+ *
+ * Use this typeguard at sites that iterate `IndexManager.allElements()`
+ * and want to count each AST node exactly once — skip the public half
+ * because the project-tier sibling already represents the node.
+ */
+export declare function isPublicTier(description: AstNodeDescription): description is TieredAstNodeDescription & {
+    readonly tier: 'public';
+    readonly projectId: string;
+};
+/**
+ * True iff `description` is `tier === 'universal'` — synthetic /
+ * library / stdlib content with no project ownership, visible
+ * everywhere unconditionally.
+ *
+ * Universal descriptions never carry `projectId` (forbidden by the
+ * factory `createUniversal`); the narrowed type omits the field.
+ */
+export declare function isUniversalTier(description: AstNodeDescription): description is TieredAstNodeDescription & {
+    readonly tier: 'universal';
+};
+/**
+ * Relational variant of {@link isPublicTier} — true iff the description
+ * is a `'public'`-tier entry whose owning project is the given `projectId`.
+ * Distinct from {@link isPublicTier} (which matches any public-tier
+ * description, regardless of home).
+ *
+ * Used at adopter sites that pick the canonical entry for a given
+ * source project: when iterating descriptions reachable from a source
+ * URI's project, the public-tier sibling belonging to that
+ * same project is redundant (the project-tier sibling under a shorter
+ * name is already in scope) and should be hidden from completion /
+ * linking. The framework's
+ * `HydraniumScopeProvider.bucketFor` uses this
+ * predicate to enforce the own-project canonical filter on the typed scope path.
+ *
+ * `projectId` accepts `string | undefined` for adopter-call-site
+ * ergonomics: when the source has no resolvable project (standalone
+ * document, no ProjectManager binding), the predicate returns `false`
+ * for every description without forcing every caller to guard.
+ */
+export declare function isPublicFor(description: AstNodeDescription, projectId: string | undefined): description is TieredAstNodeDescription & {
+    readonly tier: 'public';
+    readonly projectId: string;
+};
+//# sourceMappingURL=scoped-ast-node-description.d.ts.map

package/lib/langium/scope/scoped-ast-node-description.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-ast-node-description.d.ts","sourceRoot":"","sources":["../../../src/langium/scope/scoped-ast-node-description.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,oBAAoB,CAAC;AAE7D;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,MAAM,eAAe,GAAG,OAAO,GAAG,SAAS,GAAG,QAAQ,GAAG,WAAW,CAAC;AAE3E;;;;;;;;;GASG;AACH,MAAM,WAAW,wBAAyB,SAAQ,kBAAkB;IACjE,QAAQ,CAAC,IAAI,EAAE,eAAe,CAAC;IAC/B;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC9B;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,WAAW,EAAE,kBAAkB,GAAG,WAAW,IAAI,wBAAwB,CAE5G;AAED;;;;;GAKG;AACH,wBAAgB,WAAW,CAAC,WAAW,EAAE,kBAAkB,GAAG,WAAW,IAAI,wBAAwB,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,OAAO,CAAA;CAAE,CAEjI;AAED;;;;;GAKG;AACH,wBAAgB,aAAa,CAC1B,WAAW,EAAE,kBAAkB,GAC/B,WAAW,IAAI,wBAAwB,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAEpG;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,YAAY,CACzB,WAAW,EAAE,kBAAkB,GAC/B,WAAW,IAAI,wBAAwB,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAEnG;AAED;;;;;;;GAOG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,kBAAkB,GAAG,WAAW,IAAI,wBAAwB,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,WAAW,CAAA;CAAE,CAEzI;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,WAAW,CACxB,WAAW,EAAE,kBAAkB,EAC/B,SAAS,EAAE,MAAM,GAAG,SAAS,GAC7B,WAAW,IAAI,wBAAwB,GAAG;IAAE,QAAQ,CAAC,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAEnG"}

package/lib/langium/scope/scoped-ast-node-description.js

@@ -0,0 +1,98 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+/**
+ * Structural typeguard — true iff `description.tier` is set to a string.
+ *
+ * **Runtime value vs compile-time narrowing.** After the framework's
+ * `HydraniumAstNodeDescriptionProvider.createDescription` override always
+ * emits a `tier` field (defaulting to `'local'`), every description
+ * produced inside the framework is already a `TieredAstNodeDescription`
+ * at runtime — the predicate returns true for them unconditionally. The
+ * load-bearing value of this function today is **TypeScript narrowing**:
+ * it lifts an `AstNodeDescription` to `TieredAstNodeDescription` so call
+ * sites that need to read `.tier` / `.projectId` don't have to cast.
+ *
+ * The runtime check is still required for descriptions that originate
+ * outside the framework — third-party Langium services, fixtures, raw
+ * `IndexManager.allElements` consumers — where the field may be absent.
+ */
+export function isTieredDescription(description) {
+    return typeof description.tier === 'string';
+}
+/**
+ * True iff `description` is a {@link TieredAstNodeDescription} with
+ * `tier === 'local'`. Use to filter / narrow at call sites that switch
+ * on tier; equivalent to `isTieredDescription(d) && d.tier === 'local'`
+ * with the type narrowing baked in.
+ */
+export function isLocalTier(description) {
+    return isTieredDescription(description) && description.tier === 'local';
+}
+/**
+ * True iff `description` is a {@link TieredAstNodeDescription} with
+ * `tier === 'project'`. Narrows `projectId` to non-nullable `string` —
+ * matches the design contract that project-tier descriptions always
+ * carry an owning project id.
+ */
+export function isProjectTier(description) {
+    return isTieredDescription(description) && description.tier === 'project';
+}
+/**
+ * True iff `description` is the public-tier sibling of a multi-tier
+ * emission — a {@link TieredAstNodeDescription} with `tier === 'public'`.
+ *
+ * `'public'` descriptions ALWAYS carry a `projectId` by construction
+ * (the typed factory `createPublic` requires it). The framework's
+ * `HydraniumScopeProvider.bucketFor` suppresses
+ * a `'public'` description inside its owning project (so the shorter-
+ * name `'project'`-tier sibling is the canonical entry there) and
+ * shows it to dependent projects in the source's visibility closure.
+ *
+ * Use this typeguard at sites that iterate `IndexManager.allElements()`
+ * and want to count each AST node exactly once — skip the public half
+ * because the project-tier sibling already represents the node.
+ */
+export function isPublicTier(description) {
+    return isTieredDescription(description) && description.tier === 'public';
+}
+/**
+ * True iff `description` is `tier === 'universal'` — synthetic /
+ * library / stdlib content with no project ownership, visible
+ * everywhere unconditionally.
+ *
+ * Universal descriptions never carry `projectId` (forbidden by the
+ * factory `createUniversal`); the narrowed type omits the field.
+ */
+export function isUniversalTier(description) {
+    return isTieredDescription(description) && description.tier === 'universal';
+}
+/**
+ * Relational variant of {@link isPublicTier} — true iff the description
+ * is a `'public'`-tier entry whose owning project is the given `projectId`.
+ * Distinct from {@link isPublicTier} (which matches any public-tier
+ * description, regardless of home).
+ *
+ * Used at adopter sites that pick the canonical entry for a given
+ * source project: when iterating descriptions reachable from a source
+ * URI's project, the public-tier sibling belonging to that
+ * same project is redundant (the project-tier sibling under a shorter
+ * name is already in scope) and should be hidden from completion /
+ * linking. The framework's
+ * `HydraniumScopeProvider.bucketFor` uses this
+ * predicate to enforce the own-project canonical filter on the typed scope path.
+ *
+ * `projectId` accepts `string | undefined` for adopter-call-site
+ * ergonomics: when the source has no resolvable project (standalone
+ * document, no ProjectManager binding), the predicate returns `false`
+ * for every description without forcing every caller to guard.
+ */
+export function isPublicFor(description, projectId) {
+    return projectId !== undefined && isPublicTier(description) && description.projectId === projectId;
+}
+//# sourceMappingURL=scoped-ast-node-description.js.map

package/lib/langium/scope/scoped-ast-node-description.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scoped-ast-node-description.js","sourceRoot":"","sources":["../../../src/langium/scope/scoped-ast-node-description.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAkElF;;;;;;;;;;;;;;;GAeG;AACH,MAAM,UAAU,mBAAmB,CAAC,WAA+B;IAChE,OAAO,OAAQ,WAAwC,CAAC,IAAI,KAAK,QAAQ,CAAC;AAC7E,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,WAAW,CAAC,WAA+B;IACxD,OAAO,mBAAmB,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,IAAI,KAAK,OAAO,CAAC;AAC3E,CAAC;AAED;;;;;GAKG;AACH,MAAM,UAAU,aAAa,CAC1B,WAA+B;IAE/B,OAAO,mBAAmB,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,IAAI,KAAK,SAAS,CAAC;AAC7E,CAAC;AAED;;;;;;;;;;;;;;GAcG;AACH,MAAM,UAAU,YAAY,CACzB,WAA+B;IAE/B,OAAO,mBAAmB,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,IAAI,KAAK,QAAQ,CAAC;AAC5E,CAAC;AAED;;;;;;;GAOG;AACH,MAAM,UAAU,eAAe,CAAC,WAA+B;IAC5D,OAAO,mBAAmB,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,IAAI,KAAK,WAAW,CAAC;AAC/E,CAAC;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,UAAU,WAAW,CACxB,WAA+B,EAC/B,SAA6B;IAE7B,OAAO,SAAS,KAAK,SAAS,IAAI,YAAY,CAAC,WAAW,CAAC,IAAI,WAAW,CAAC,SAAS,KAAK,SAAS,CAAC;AACtG,CAAC"}

package/lib/langium/scope/tier-specificity.d.ts

@@ -0,0 +1,47 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { type AstNodeDescription, type Stream } from '@hydranium/langium';
+/**
+ * Tier-sibling primitives — the building blocks for the "canonical
+ * filter" that collapses the multiple descriptions a single AST node
+ * emits across visibility tiers (multi-tier emission) down to the one
+ * most-specific tier-sibling per node.
+ *
+ * Multi-tier emission means one node is exported under several
+ * {@link AstNodeDescription}s — e.g. a `'project'`-tier short name and a
+ * `'public'`-tier project-qualified name for the same node. Those
+ * descriptions are *tier siblings*: same node, different tier. In a
+ * resolution scope both may legitimately appear (so a reference resolves
+ * by either form); in a completion dropdown only the canonical
+ * (most-specific) sibling should be shown so the user sees one entry per
+ * node.
+ */
+/**
+ * True if two descriptions refer to the same AST node, regardless of
+ * tier. Prefers node identity when both carry a live `node`; otherwise
+ * falls back to the stable document-URI + path key.
+ */
+export declare function areTierSiblings(left: AstNodeDescription, right: AstNodeDescription): boolean;
+/**
+ * Compare two descriptions by tier specificity. Returns a negative
+ * number if `left` is more specific (should win), positive if `right`
+ * is, `0` if equally specific. More specific = narrower visibility:
+ * `local` < `project` < `public` < `universal`. Untiered descriptions
+ * rank least specific so a tiered sibling always wins.
+ */
+export declare function compareTierSpecificity(left: AstNodeDescription, right: AstNodeDescription): number;
+/**
+ * Canonical filter: group descriptions by AST node and keep the
+ * most tier-specific sibling per group (see
+ * {@link compareTierSpecificity}). Input order is otherwise preserved —
+ * the first-seen sibling holds each group's slot and is only replaced by
+ * a strictly more specific one, so a stable upstream order stays stable.
+ */
+export declare function dedupeTierSiblingsStream<T extends AstNodeDescription>(descriptions: Stream<T>): Stream<T>;
+//# sourceMappingURL=tier-specificity.d.ts.map

package/lib/langium/scope/tier-specificity.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-specificity.d.ts","sourceRoot":"","sources":["../../../src/langium/scope/tier-specificity.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAE,KAAK,kBAAkB,EAAE,KAAK,MAAM,EAAU,MAAM,oBAAoB,CAAC;AAGlF;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,kBAAkB,GAAG,OAAO,CAK5F;AAED;;;;;;GAMG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,kBAAkB,GAAG,MAAM,CAElG;AAsBD;;;;;;GAMG;AACH,wBAAgB,wBAAwB,CAAC,CAAC,SAAS,kBAAkB,EAAE,YAAY,EAAE,MAAM,CAAC,CAAC,CAAC,GAAG,MAAM,CAAC,CAAC,CAAC,CAUzG"}

package/lib/langium/scope/tier-specificity.js

@@ -0,0 +1,83 @@
+/********************************************************************************
+ * Copyright (c) 2026 CrossBreeze, EclipseSource and others.
+ *
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License which is available in the project root.
+ *
+ * SPDX-License-Identifier: MIT
+ ********************************************************************************/
+import { stream } from '@hydranium/langium';
+import { isTieredDescription } from './scoped-ast-node-description.js';
+/**
+ * Tier-sibling primitives — the building blocks for the "canonical
+ * filter" that collapses the multiple descriptions a single AST node
+ * emits across visibility tiers (multi-tier emission) down to the one
+ * most-specific tier-sibling per node.
+ *
+ * Multi-tier emission means one node is exported under several
+ * {@link AstNodeDescription}s — e.g. a `'project'`-tier short name and a
+ * `'public'`-tier project-qualified name for the same node. Those
+ * descriptions are *tier siblings*: same node, different tier. In a
+ * resolution scope both may legitimately appear (so a reference resolves
+ * by either form); in a completion dropdown only the canonical
+ * (most-specific) sibling should be shown so the user sees one entry per
+ * node.
+ */
+/**
+ * True if two descriptions refer to the same AST node, regardless of
+ * tier. Prefers node identity when both carry a live `node`; otherwise
+ * falls back to the stable document-URI + path key.
+ */
+export function areTierSiblings(left, right) {
+    if (left.node !== undefined && left.node === right.node) {
+        return true;
+    }
+    return left.documentUri.toString() === right.documentUri.toString() && left.path === right.path;
+}
+/**
+ * Compare two descriptions by tier specificity. Returns a negative
+ * number if `left` is more specific (should win), positive if `right`
+ * is, `0` if equally specific. More specific = narrower visibility:
+ * `local` < `project` < `public` < `universal`. Untiered descriptions
+ * rank least specific so a tiered sibling always wins.
+ */
+export function compareTierSpecificity(left, right) {
+    return tierRank(left) - tierRank(right);
+}
+function tierRank(description) {
+    if (!isTieredDescription(description)) {
+        return Number.POSITIVE_INFINITY;
+    }
+    switch (description.tier) {
+        case 'local':
+            return 0;
+        case 'project':
+            return 1;
+        case 'public':
+            return 2;
+        case 'universal':
+            return 3;
+    }
+}
+function nodeKey(description) {
+    return `${description.documentUri.toString()}#${description.path}`;
+}
+/**
+ * Canonical filter: group descriptions by AST node and keep the
+ * most tier-specific sibling per group (see
+ * {@link compareTierSpecificity}). Input order is otherwise preserved —
+ * the first-seen sibling holds each group's slot and is only replaced by
+ * a strictly more specific one, so a stable upstream order stays stable.
+ */
+export function dedupeTierSiblingsStream(descriptions) {
+    const byNode = new Map();
+    for (const description of descriptions) {
+        const key = nodeKey(description);
+        const existing = byNode.get(key);
+        if (existing === undefined || compareTierSpecificity(description, existing) < 0) {
+            byNode.set(key, description);
+        }
+    }
+    return stream(byNode.values());
+}
+//# sourceMappingURL=tier-specificity.js.map

package/lib/langium/scope/tier-specificity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tier-specificity.js","sourceRoot":"","sources":["../../../src/langium/scope/tier-specificity.ts"],"names":[],"mappings":"AAAA;;;;;;;kFAOkF;AAElF,OAAO,EAAwC,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAClF,OAAO,EAAE,mBAAmB,EAAE,MAAM,kCAAkC,CAAC;AAEvE;;;;;;;;;;;;;;GAcG;AAEH;;;;GAIG;AACH,MAAM,UAAU,eAAe,CAAC,IAAwB,EAAE,KAAyB;IAChF,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,EAAE,CAAC;QACvD,OAAO,IAAI,CAAC;IACf,CAAC;IACD,OAAO,IAAI,CAAC,WAAW,CAAC,QAAQ,EAAE,KAAK,KAAK,CAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI,CAAC;AACnG,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,sBAAsB,CAAC,IAAwB,EAAE,KAAyB;IACvF,OAAO,QAAQ,CAAC,IAAI,CAAC,GAAG,QAAQ,CAAC,KAAK,CAAC,CAAC;AAC3C,CAAC;AAED,SAAS,QAAQ,CAAC,WAA+B;IAC9C,IAAI,CAAC,mBAAmB,CAAC,WAAW,CAAC,EAAE,CAAC;QACrC,OAAO,MAAM,CAAC,iBAAiB,CAAC;IACnC,CAAC;IACD,QAAQ,WAAW,CAAC,IAAI,EAAE,CAAC;QACxB,KAAK,OAAO;YACT,OAAO,CAAC,CAAC;QACZ,KAAK,SAAS;YACX,OAAO,CAAC,CAAC;QACZ,KAAK,QAAQ;YACV,OAAO,CAAC,CAAC;QACZ,KAAK,WAAW;YACb,OAAO,CAAC,CAAC;IACf,CAAC;AACJ,CAAC;AAED,SAAS,OAAO,CAAC,WAA+B;IAC7C,OAAO,GAAG,WAAW,CAAC,WAAW,CAAC,QAAQ,EAAE,IAAI,WAAW,CAAC,IAAI,EAAE,CAAC;AACtE,CAAC;AAED;;;;;;GAMG;AACH,MAAM,UAAU,wBAAwB,CAA+B,YAAuB;IAC3F,MAAM,MAAM,GAAG,IAAI,GAAG,EAAa,CAAC;IACpC,KAAK,MAAM,WAAW,IAAI,YAAY,EAAE,CAAC;QACtC,MAAM,GAAG,GAAG,OAAO,CAAC,WAAW,CAAC,CAAC;QACjC,MAAM,QAAQ,GAAG,MAAM,CAAC,GAAG,CAAC,GAAG,CAAC,CAAC;QACjC,IAAI,QAAQ,KAAK,SAAS,IAAI,sBAAsB,CAAC,WAAW,EAAE,QAAQ,CAAC,GAAG,CAAC,EAAE,CAAC;YAC/E,MAAM,CAAC,GAAG,CAAC,GAAG,EAAE,WAAW,CAAC,CAAC;QAChC,CAAC;IACJ,CAAC;IACD,OAAO,MAAM,CAAC,MAAM,CAAC,MAAM,EAAE,CAAC,CAAC;AAClC,CAAC"}