ttsc 0.30.3 → 0.31.0

package/lib/launcher/internal/watch/ProjectInputWatchRules.js.map

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

package/lib/launcher/internal/watch/WatchInputChange.d.ts

@@ -0,0 +1,29 @@
+/**
+ * One classified filesystem event from the watch topology, before it is
+ * coalesced into a cycle by {@link PendingResidentCheckWatchChanges}.
+ *
+ * @evidence contracts/common.md#principled-implementation The discriminant distinguishes compiler data, project-rule data and execution-selection inputs; invalidation separately requests a cold Program without replacing the process.
+ * @evidence contracts/common.md#clear-and-simple-design One tagged event carries optional localization and an independent resident-invalidation qualification.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts The event does not invent a changed path for an unnamed native notification.
+ * @evidence contracts/common.md#meaningful-documentation Member paragraphs explain reload categories, invalidation and absent localization following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Optional path preserves the backend's inability to name a changed input instead of assuming every native notification carries a filename.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources A type declaration acquires and holds no runtime resource.
+ * @evidenceExclude contracts/performance.md#efficient-algorithms A type declaration chooses no processing strategy.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work A type declaration computes nothing, so there is no work to share.
+ */
+export type WatchInputChange = {
+    /** Keep the resident process but cold-load its compiler Program. */
+    invalidate?: boolean;
+    /**
+     * Which population the path belongs to. `config` and `plugin` changes force a
+     * full reload; `compiler` belongs to the compiler input topology, including
+     * non-TypeScript files the compiler reports; `project` is a file a project
+     * rule declared as its own input.
+     */
+    kind: "compiler" | "config" | "plugin" | "project";
+    /**
+     * The changed path, when the backend named it. An unnamed `compiler` event
+     * cannot be localized and is treated as a reload.
+     */
+    path?: string;
+};

package/lib/launcher/internal/watch/WatchInputChange.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=WatchInputChange.js.map

package/lib/launcher/internal/watch/WatchInputChange.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WatchInputChange.js","sourceRoot":"","sources":["../../../../src/launcher/internal/watch/WatchInputChange.ts"],"names":[],"mappings":""}

package/lib/launcher/internal/watch/WatchPaths.d.ts

@@ -0,0 +1,101 @@
+import type { ProjectInputPathIdentityContext } from "../../../internal/pathIdentity/ProjectInputPathIdentityContext";
+/**
+ * Path helpers the watch topology calls per event.
+ *
+ * Containment and membership preserve lexical declarations rather than merge
+ * symlink aliases. Their supplied transaction shares native parent-directory
+ * case observations; map equality needs no filesystem query. Directory probes
+ * use one `stat` per candidate and follow native links.
+ *
+ * @evidence contracts/common.md#principled-implementation Lexical containment and membership stay distinct from physical-identity operations; directory predicates ask the native filesystem rather than infer kind from spelling.
+ * @evidence contracts/common.md#clear-and-simple-design One namespace groups event-time lexical calculations and the two directory probes, separate from transaction identity resolution.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts These helpers do not reread content to fabricate a compiler input state or mutate native filesystem methods.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lexical-versus-physical scope and directory probing following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path APIs handle separator/volume arithmetic; parent-directory case observations qualify lexical key folding without collapsing physical aliases or assuming an OS-wide case policy.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms Namespace membership itself performs no computation; individual helpers own their algorithms.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The namespace defines no shared computation coordinator.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Helpers retain no namespace-level cache or native handles.
+ */
+export declare namespace WatchPaths {
+    /**
+     * Whether `location` exists and is a directory, following links.
+     *
+     * @evidence contracts/common.md#principled-implementation A successful native stat determines directory kind; an unavailable stat remains false rather than inventing an accessible directory.
+     * @evidence contracts/common.md#clear-and-simple-design One stat and failure boundary provide the admission predicate.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Filesystem state replaces extension/name heuristics and no native stat method is patched.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states existence, kind and followed-link semantics following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Node stat owns native link following and directory semantics without an OS-name-derived file-kind rule.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms One synchronous native stat plus kind inspection performs no collection traversal here. Work includes supplied path processing and native metadata/target lookup; a single boolean result does not cap those costs.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work A fresh stat serves the event's current native state rather than a historical result.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The stat result is local with no retained handle or history.
+     */
+    function isDirectory(location: string): boolean;
+    /**
+     * The nearest lexical ancestor at or above `location` successfully observed
+     * as a directory, or undefined when none is admitted, including the volume
+     * root. Native query failure is not proof that an ancestor does not exist.
+     *
+     * @evidence contracts/common.md#principled-implementation Walking native parents finds the deepest directory admitted by stat; root equality ends an unsuccessful search without equating query failure with proven absence.
+     * @evidence contracts/common.md#clear-and-simple-design One ancestor loop reuses the directory predicate without a second search policy.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The answer derives from actual ancestor state instead of assumed temporary or project layouts.
+     * @evidence contracts/common.md#meaningful-documentation Native prose explains the missing-input anchor and undefined result following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Node resolve/dirname preserve native volume roots and stat provides actual accessibility/kind.
+     * @evidence contracts/performance.md#efficient-algorithms At most D lexical ancestors each require a native stat, while repeated resolve/dirname and native lookup process their spelling lengths. Current-path storage is local; ancestor depth/path text are not capped here and descendant contents are not enumerated.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Event-time ancestor state may change; this helper owns no cross-request cache.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources One current path remains local and no watcher or resident index is acquired.
+     */
+    function nearestExistingDirectory(location: string): string | undefined;
+    /**
+     * Whether two key-to-path maps hold exactly the same entries.
+     *
+     * @evidence contracts/common.md#principled-implementation Equal cardinality plus equal values at every left key establishes equality of the complete keyed population.
+     * @evidence contracts/common.md#clear-and-simple-design One size guard precedes a direct iterator comparison.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Equality uses supplied entries rather than assuming insertion order or accepting equal key counts alone.
+     * @evidence contracts/common.md#meaningful-documentation Native prose specifies exact key-to-path equality following the documentation skill.
+     *
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation This comparison borrows already keyed maps and performs no native path operation.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms A size mismatch returns immediately; otherwise at most N borrowed entries require indexed key lookup and string-value equality. Work includes key/value spelling comparisons as well as map indexing; auxiliary iteration state is constant without an intermediate population array, and N/text lengths are not capped here.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Map comparison owns no completed/in-flight computation sharing.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Both maps are borrowed and no entries survive the call in helper-owned state.
+     */
+    function mapsEqual(left: ReadonlyMap<string, string>, right: ReadonlyMap<string, string>): boolean;
+    /**
+     * Whether `candidate` is `root` or lies beneath it, compared lexically.
+     *
+     * @evidence contracts/common.md#principled-implementation Equal lexical keys include the root; separator-delimited descendants preserve proved component case semantics and reject siblings or distinct volumes.
+     * @evidence contracts/common.md#clear-and-simple-design Shared key construction precedes the existing canonical-key containment predicate.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts A sibling whose name begins with the root is not accepted by a prefix shortcut.
+     * @evidence contracts/common.md#meaningful-documentation Native prose limits this predicate to lexical containment following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Native lexical keys fold only proved insensitive components, preserve unknown spelling and retain drive/UNC/POSIX grammar without Windows relative-path case folding.
+     * @evidence contracts/performance.md#efficient-algorithms Two delegated component-key constructions precede one separator-prefix comparison. Work includes spelling/ancestor/entry observations and possible synchronous case-query processes, plus key text comparison; no descendant corpus is enumerated and those populations are not capped here.
+     * @evidence contracts/performance.md#reuse-equivalent-work The supplied transaction shares parent-directory capability observations with sibling key and containment requests; standalone calls create fresh observations.
+     *
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the transaction or creates invocation-local caches and acquires no watcher or persistent history.
+     */
+    function isPathWithin(root: string, candidate: string, identities?: import("../../../internal/projectInputPathIdentity").FilesystemPathIdentityContext): boolean;
+    /**
+     * The lexical watch key for `location`, preserving declaration aliases. Under
+     * proved insensitive parents, ASCII letters in each component are folded;
+     * non-ASCII component characters remain unchanged. Sensitive or unknown
+     * parents preserve component spelling. Native volume-root formatting remains
+     * the shared resolver's separate rule.
+     *
+     * @evidence contracts/common.md#principled-implementation The shared component key folds only native evidence of insensitive parents, so sensitive and unknown names remain distinct while lexical symlink ownership is preserved.
+     * @evidence contracts/common.md#clear-and-simple-design One delegation uses the transaction's lexical policy without duplicating physical resolution or native probing.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts An OS name never supplies case evidence, and physical realpath keys do not replace declarations merely to normalize aliases.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes lexical ownership, proved folding and unknown spelling following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation The shared resolver applies native root grammar and actual parent-directory capability; Windows sensitive directories and POSIX insensitive volumes follow their measured policy.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms The delegated lexical resolver walks path components and observes parent identities/case authority, potentially including native ancestor/entry work and synchronous Windows queries. Path/name/output text and visited populations are uncapped here; returning one key does not make delegation constant-cost.
+     *
+     * @evidence contracts/performance.md#reuse-equivalent-work Callers share one transaction across reconciliation keys; omitted contexts start fresh capability observations rather than reuse historical generations.
+     *
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Borrowed transaction ownership stays with the caller; a standalone context becomes unreachable on return and no watcher is acquired.
+     */
+    function pathKey(location: string, identities?: ProjectInputPathIdentityContext): string;
+}

package/lib/launcher/internal/watch/WatchPaths.js

@@ -0,0 +1,150 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.WatchPaths = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const createProjectInputPathIdentityContext_1 = require("../../../internal/pathIdentity/createProjectInputPathIdentityContext");
+const isFilesystemPathIdentityWithin_1 = require("../../../internal/pathIdentity/isFilesystemPathIdentityWithin");
+/**
+ * Path helpers the watch topology calls per event.
+ *
+ * Containment and membership preserve lexical declarations rather than merge
+ * symlink aliases. Their supplied transaction shares native parent-directory
+ * case observations; map equality needs no filesystem query. Directory probes
+ * use one `stat` per candidate and follow native links.
+ *
+ * @evidence contracts/common.md#principled-implementation Lexical containment and membership stay distinct from physical-identity operations; directory predicates ask the native filesystem rather than infer kind from spelling.
+ * @evidence contracts/common.md#clear-and-simple-design One namespace groups event-time lexical calculations and the two directory probes, separate from transaction identity resolution.
+ * @evidence contracts/common.md#prohibited-implementation-shortcuts These helpers do not reread content to fabricate a compiler input state or mutate native filesystem methods.
+ * @evidence contracts/common.md#meaningful-documentation Native paragraphs explain lexical-versus-physical scope and directory probing following the documentation skill.
+ * @evidence contracts/portability.md#os-neutral-implementation Native path APIs handle separator/volume arithmetic; parent-directory case observations qualify lexical key folding without collapsing physical aliases or assuming an OS-wide case policy.
+ *
+ * @evidenceExclude contracts/performance.md#efficient-algorithms Namespace membership itself performs no computation; individual helpers own their algorithms.
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work The namespace defines no shared computation coordinator.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Helpers retain no namespace-level cache or native handles.
+ */
+var WatchPaths;
+(function (WatchPaths) {
+    /**
+     * Whether `location` exists and is a directory, following links.
+     *
+     * @evidence contracts/common.md#principled-implementation A successful native stat determines directory kind; an unavailable stat remains false rather than inventing an accessible directory.
+     * @evidence contracts/common.md#clear-and-simple-design One stat and failure boundary provide the admission predicate.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Filesystem state replaces extension/name heuristics and no native stat method is patched.
+     * @evidence contracts/common.md#meaningful-documentation Native prose states existence, kind and followed-link semantics following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Node stat owns native link following and directory semantics without an OS-name-derived file-kind rule.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms One synchronous native stat plus kind inspection performs no collection traversal here. Work includes supplied path processing and native metadata/target lookup; a single boolean result does not cap those costs.
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work A fresh stat serves the event's current native state rather than a historical result.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The stat result is local with no retained handle or history.
+     */
+    function isDirectory(location) {
+        try {
+            return node_fs_1.default.statSync(location).isDirectory();
+        }
+        catch {
+            return false;
+        }
+    }
+    WatchPaths.isDirectory = isDirectory;
+    /**
+     * The nearest lexical ancestor at or above `location` successfully observed
+     * as a directory, or undefined when none is admitted, including the volume
+     * root. Native query failure is not proof that an ancestor does not exist.
+     *
+     * @evidence contracts/common.md#principled-implementation Walking native parents finds the deepest directory admitted by stat; root equality ends an unsuccessful search without equating query failure with proven absence.
+     * @evidence contracts/common.md#clear-and-simple-design One ancestor loop reuses the directory predicate without a second search policy.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts The answer derives from actual ancestor state instead of assumed temporary or project layouts.
+     * @evidence contracts/common.md#meaningful-documentation Native prose explains the missing-input anchor and undefined result following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Node resolve/dirname preserve native volume roots and stat provides actual accessibility/kind.
+     * @evidence contracts/performance.md#efficient-algorithms At most D lexical ancestors each require a native stat, while repeated resolve/dirname and native lookup process their spelling lengths. Current-path storage is local; ancestor depth/path text are not capped here and descendant contents are not enumerated.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Event-time ancestor state may change; this helper owns no cross-request cache.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources One current path remains local and no watcher or resident index is acquired.
+     */
+    function nearestExistingDirectory(location) {
+        let current = node_path_1.default.resolve(location);
+        while (true) {
+            if (isDirectory(current))
+                return current;
+            const parent = node_path_1.default.dirname(current);
+            if (parent === current)
+                return undefined;
+            current = parent;
+        }
+    }
+    WatchPaths.nearestExistingDirectory = nearestExistingDirectory;
+    /**
+     * Whether two key-to-path maps hold exactly the same entries.
+     *
+     * @evidence contracts/common.md#principled-implementation Equal cardinality plus equal values at every left key establishes equality of the complete keyed population.
+     * @evidence contracts/common.md#clear-and-simple-design One size guard precedes a direct iterator comparison.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts Equality uses supplied entries rather than assuming insertion order or accepting equal key counts alone.
+     * @evidence contracts/common.md#meaningful-documentation Native prose specifies exact key-to-path equality following the documentation skill.
+     *
+     * @evidenceExclude contracts/portability.md#os-neutral-implementation This comparison borrows already keyed maps and performs no native path operation.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms A size mismatch returns immediately; otherwise at most N borrowed entries require indexed key lookup and string-value equality. Work includes key/value spelling comparisons as well as map indexing; auxiliary iteration state is constant without an intermediate population array, and N/text lengths are not capped here.
+     *
+     * @evidenceExclude contracts/performance.md#reuse-equivalent-work Map comparison owns no completed/in-flight computation sharing.
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Both maps are borrowed and no entries survive the call in helper-owned state.
+     */
+    function mapsEqual(left, right) {
+        if (left.size !== right.size)
+            return false;
+        for (const [key, value] of left) {
+            if (right.get(key) !== value)
+                return false;
+        }
+        return true;
+    }
+    WatchPaths.mapsEqual = mapsEqual;
+    /**
+     * Whether `candidate` is `root` or lies beneath it, compared lexically.
+     *
+     * @evidence contracts/common.md#principled-implementation Equal lexical keys include the root; separator-delimited descendants preserve proved component case semantics and reject siblings or distinct volumes.
+     * @evidence contracts/common.md#clear-and-simple-design Shared key construction precedes the existing canonical-key containment predicate.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts A sibling whose name begins with the root is not accepted by a prefix shortcut.
+     * @evidence contracts/common.md#meaningful-documentation Native prose limits this predicate to lexical containment following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation Native lexical keys fold only proved insensitive components, preserve unknown spelling and retain drive/UNC/POSIX grammar without Windows relative-path case folding.
+     * @evidence contracts/performance.md#efficient-algorithms Two delegated component-key constructions precede one separator-prefix comparison. Work includes spelling/ancestor/entry observations and possible synchronous case-query processes, plus key text comparison; no descendant corpus is enumerated and those populations are not capped here.
+     * @evidence contracts/performance.md#reuse-equivalent-work The supplied transaction shares parent-directory capability observations with sibling key and containment requests; standalone calls create fresh observations.
+     *
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate borrows the transaction or creates invocation-local caches and acquires no watcher or persistent history.
+     */
+    function isPathWithin(root, candidate, identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)({
+        throwOnRealpathError: false,
+    })) {
+        return (0, isFilesystemPathIdentityWithin_1.isFilesystemPathIdentityWithin)(identities.lexicalKey(root), identities.lexicalKey(candidate));
+    }
+    WatchPaths.isPathWithin = isPathWithin;
+    /**
+     * The lexical watch key for `location`, preserving declaration aliases. Under
+     * proved insensitive parents, ASCII letters in each component are folded;
+     * non-ASCII component characters remain unchanged. Sensitive or unknown
+     * parents preserve component spelling. Native volume-root formatting remains
+     * the shared resolver's separate rule.
+     *
+     * @evidence contracts/common.md#principled-implementation The shared component key folds only native evidence of insensitive parents, so sensitive and unknown names remain distinct while lexical symlink ownership is preserved.
+     * @evidence contracts/common.md#clear-and-simple-design One delegation uses the transaction's lexical policy without duplicating physical resolution or native probing.
+     * @evidence contracts/common.md#prohibited-implementation-shortcuts An OS name never supplies case evidence, and physical realpath keys do not replace declarations merely to normalize aliases.
+     * @evidence contracts/common.md#meaningful-documentation Native prose distinguishes lexical ownership, proved folding and unknown spelling following the documentation skill.
+     * @evidence contracts/portability.md#os-neutral-implementation The shared resolver applies native root grammar and actual parent-directory capability; Windows sensitive directories and POSIX insensitive volumes follow their measured policy.
+     *
+     * @evidence contracts/performance.md#efficient-algorithms The delegated lexical resolver walks path components and observes parent identities/case authority, potentially including native ancestor/entry work and synchronous Windows queries. Path/name/output text and visited populations are uncapped here; returning one key does not make delegation constant-cost.
+     *
+     * @evidence contracts/performance.md#reuse-equivalent-work Callers share one transaction across reconciliation keys; omitted contexts start fresh capability observations rather than reuse historical generations.
+     *
+     * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources Borrowed transaction ownership stays with the caller; a standalone context becomes unreachable on return and no watcher is acquired.
+     */
+    function pathKey(location, identities = (0, createProjectInputPathIdentityContext_1.createProjectInputPathIdentityContext)({
+        throwOnRealpathError: false,
+    })) {
+        return identities.lexicalKey(location);
+    }
+    WatchPaths.pathKey = pathKey;
+})(WatchPaths || (exports.WatchPaths = WatchPaths = {}));
+//# sourceMappingURL=WatchPaths.js.map

package/lib/launcher/internal/watch/WatchPaths.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"WatchPaths.js","sourceRoot":"","sources":["../../../../src/launcher/internal/watch/WatchPaths.ts"],"names":[],"mappings":";;;;;;AAAA,sDAAyB;AACzB,0DAA6B;AAG7B,gIAA6H;AAC7H,kHAA+G;AAE/G;;;;;;;;;;;;;;;;;GAiBG;AACH,IAAiB,UAAU,CAkI1B;AAlID,WAAiB,UAAU;IACzB;;;;;;;;;;;;OAYG;IACH,SAAgB,WAAW,CAAC,QAAgB;QAC1C,IAAI,CAAC;YACH,OAAO,iBAAE,CAAC,QAAQ,CAAC,QAAQ,CAAC,CAAC,WAAW,EAAE,CAAC;QAC7C,CAAC;QAAC,MAAM,CAAC;YACP,OAAO,KAAK,CAAC;QACf,CAAC;IACH,CAAC;IANe,WAAA,WAAW,cAM1B,CAAA;IAED;;;;;;;;;;;;;;OAcG;IACH,SAAgB,wBAAwB,CACtC,QAAgB;QAEhB,IAAI,OAAO,GAAG,mBAAI,CAAC,OAAO,CAAC,QAAQ,CAAC,CAAC;QACrC,OAAO,IAAI,EAAE,CAAC;YACZ,IAAI,WAAW,CAAC,OAAO,CAAC;gBAAE,OAAO,OAAO,CAAC;YACzC,MAAM,MAAM,GAAG,mBAAI,CAAC,OAAO,CAAC,OAAO,CAAC,CAAC;YACrC,IAAI,MAAM,KAAK,OAAO;gBAAE,OAAO,SAAS,CAAC;YACzC,OAAO,GAAG,MAAM,CAAC;QACnB,CAAC;IACH,CAAC;IAVe,WAAA,wBAAwB,2BAUvC,CAAA;IAED;;;;;;;;;;;;;;OAcG;IACH,SAAgB,SAAS,CACvB,IAAiC,EACjC,KAAkC;QAElC,IAAI,IAAI,CAAC,IAAI,KAAK,KAAK,CAAC,IAAI;YAAE,OAAO,KAAK,CAAC;QAC3C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,IAAI,EAAE,CAAC;YAChC,IAAI,KAAK,CAAC,GAAG,CAAC,GAAG,CAAC,KAAK,KAAK;gBAAE,OAAO,KAAK,CAAC;QAC7C,CAAC;QACD,OAAO,IAAI,CAAC;IACd,CAAC;IATe,WAAA,SAAS,YASxB,CAAA;IAED;;;;;;;;;;;;OAYG;IACH,SAAgB,YAAY,CAC1B,IAAY,EACZ,SAAiB,EACjB,UAAU,GAAG,IAAA,6EAAqC,EAAC;QACjD,oBAAoB,EAAE,KAAK;KAC5B,CAAC;QAEF,OAAO,IAAA,+DAA8B,EACnC,UAAU,CAAC,UAAU,CAAC,IAAI,CAAC,EAC3B,UAAU,CAAC,UAAU,CAAC,SAAS,CAAC,CACjC,CAAC;IACJ,CAAC;IAXe,WAAA,YAAY,eAW3B,CAAA;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,SAAgB,OAAO,CACrB,QAAgB,EAChB,UAAU,GAAoC,IAAA,6EAAqC,EACjF;QACE,oBAAoB,EAAE,KAAK;KAC5B,CACF;QAED,OAAO,UAAU,CAAC,UAAU,CAAC,QAAQ,CAAC,CAAC;IACzC,CAAC;IATe,WAAA,OAAO,UAStB,CAAA;AACH,CAAC,EAlIgB,UAAU,aAAV,UAAU,GAAV,UAAU,QAkI1B"}