code-auditor-mcp 4.1.1 → 5.0.2

package/dist/phase/receiverActivity.js

@@ -0,0 +1,66 @@
+/**
+ * Spec 70 Item 4 (step 3) — the per-file `receiver-activity` producer.
+ *
+ * The extract half of the corpus-side `dbProvenanced` re-derivation. The four
+ * receiver consumers (`schema-usage`, `query-sites`, `data-access-calls`,
+ * `loop-queries`) will move from file producers (which read `file.receiverProvenance`
+ * seeded by the second parse) to corpus producers (which read the `receiver-provenance`
+ * fixed point). To re-derive each file's `buildProvenanceContext` `dbProvenanced`
+ * corpus-side — with no AST — the corpus producer needs the three provenance inputs
+ * that only the AST walk can supply, projected here while the tree still lives:
+ *
+ *   • `bindings`  — the TS binding environment (`buildBindingEnv`), which
+ *                   `identifyHandle` reads for declaration resolution (R4).
+ *   • `r3Sites`   — the R3 sites (`extractR3Sites`), the member calls whose static
+ *                   SQL argument proves their receiver a handle (criterion 8),
+ *                   re-folded corpus-side by `applyR3FromSites`.
+ *   • `dbActivity` — the DB-shaped activity set (`collectDbActivity`), the
+ *                   provenance-free file-gate signal `passesFileGate` reads.
+ *
+ * Go files carry none of these (`collectDbActivity` / `extractR3Sites` return empty,
+ * and the Go binding/import env already lives in `within-file-provenance` +
+ * `go-package-bindings`), so the producer is registered for the three TS-family
+ * formats alone. It emits exactly one fragment per file (null-or-value — a file with
+ * no bindings/activity still yields a fragment so the corpus producer sees the file).
+ */
+import { buildBindingScopeIndex } from '../analyzers/receiverRoot.js';
+import { collectDbActivity, extractR3Sites } from '../analyzers/provenance.js';
+import { bindingToFact } from './withinFileProvenance.js';
+/**
+ * One file's receiver-resolution inputs, as a single `ReceiverActivityFact`.
+ *
+ * @param file - The parsed code file whose bindings + R3 sites + DB activity are
+ *   projected.
+ * @returns A one-element array carrying the file's TS receiver-resolution inputs.
+ */
+export function extractReceiverActivity(file) {
+    const bindingScopeIndex = buildBindingScopeIndex(file.ast, file.adapter, file.source);
+    const r3Sites = extractR3Sites(file.ast, file.adapter, file.source);
+    const dbActivity = collectDbActivity(file.ast, file.adapter, file.source);
+    // Serialize *every* binding (no name collapse) so the corpus-side rehydrator
+    // can rebuild both the flat first-wins map and the scope-keyed index — a name
+    // bound in two functions yields two facts, disambiguated by `scope`.
+    const bindingFacts = [];
+    for (const [name, byScope] of bindingScopeIndex) {
+        for (const binding of byScope.values()) {
+            bindingFacts.push(bindingToFact(name, binding));
+        }
+    }
+    return [
+        {
+            file: file.file,
+            format: file.format,
+            bindings: bindingFacts,
+            r3Sites: r3Sites.map((s) => ({
+                root: s.root,
+                receiver: s.receiver,
+                method: s.method,
+                sqlArgument: s.sqlArgument,
+                thisField: s.thisField,
+                thisHeritage: s.thisHeritage,
+            })),
+            dbActivity: [...dbActivity],
+        },
+    ];
+}
+//# sourceMappingURL=receiverActivity.js.map

package/dist/phase/receiverActivity.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"receiverActivity.js","sourceRoot":"","sources":["../../src/phase/receiverActivity.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAGH,OAAO,EAAE,sBAAsB,EAAE,MAAM,8BAA8B,CAAC;AACtE,OAAO,EAAE,iBAAiB,EAAE,cAAc,EAAE,MAAM,4BAA4B,CAAC;AAC/E,OAAO,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAE1D;;;;;;GAMG;AACH,MAAM,UAAU,uBAAuB,CAAC,IAAa;IACnD,MAAM,iBAAiB,GAAG,sBAAsB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACtF,MAAM,OAAO,GAAG,cAAc,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IACpE,MAAM,UAAU,GAAG,iBAAiB,CAAC,IAAI,CAAC,GAAG,EAAE,IAAI,CAAC,OAAO,EAAE,IAAI,CAAC,MAAM,CAAC,CAAC;IAE1E,6EAA6E;IAC7E,8EAA8E;IAC9E,qEAAqE;IACrE,MAAM,YAAY,GAAoB,EAAE,CAAC;IACzC,KAAK,MAAM,CAAC,IAAI,EAAE,OAAO,CAAC,IAAI,iBAAiB,EAAE,CAAC;QAChD,KAAK,MAAM,OAAO,IAAI,OAAO,CAAC,MAAM,EAAE,EAAE,CAAC;YACvC,YAAY,CAAC,IAAI,CAAC,aAAa,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC,CAAC;QAClD,CAAC;IACH,CAAC;IAED,OAAO;QACL;YACE,IAAI,EAAE,IAAI,CAAC,IAAI;YACf,MAAM,EAAE,IAAI,CAAC,MAA6C;YAC1D,QAAQ,EAAE,YAAY;YACtB,OAAO,EAAE,OAAO,CAAC,GAAG,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC;gBAC3B,IAAI,EAAE,CAAC,CAAC,IAAI;gBACZ,QAAQ,EAAE,CAAC,CAAC,QAAQ;gBACpB,MAAM,EAAE,CAAC,CAAC,MAAM;gBAChB,WAAW,EAAE,CAAC,CAAC,WAAW;gBAC1B,SAAS,EAAE,CAAC,CAAC,SAAS;gBACtB,YAAY,EAAE,CAAC,CAAC,YAAY;aAC7B,CAAC,CAAC;YACH,UAAU,EAAE,CAAC,GAAG,UAAU,CAAC;SAC5B;KACF,CAAC;AACJ,CAAC"}

package/dist/phase/receiverConsumers.d.ts

@@ -0,0 +1,207 @@
+/**
+ * Spec 70 Item 4 (step 3) — the corpus-side reductions for the four receiver
+ * consumers, over the `receiver-activity` file fact + the `receiver-provenance`
+ * fixed point.
+ *
+ * The collapse makes each receiver consumer a corpus producer: it reads (a) a raw
+ * file fact extracted while the AST lived, and (b) the provenance fixed point, and
+ * re-derives the file's `buildProvenanceContext().dbProvenanced` with no AST via
+ * `classifyBuildProvenance`. This module holds the shared rehydration + the gate
+ * mirror those reductions need, so each consumer's `process` is a thin projection
+ * over pre-rehydrated provenance. The rehydrators are the inverse of the file
+ * producers' serialization: `evidenceFromFact`/`tsExtractFromFact` rebuild the
+ * `ProvenanceEvidence`/`TsWithinFileProvenanceExtract` the classify seam reads, and
+ * `rehydrateReceiverActivity` rebuilds the `Binding`/`R3Site` inputs
+ * `classifyBuildProvenance` folds R3 over.
+ */
+import type { DataAccessCallCandidate, LoopQueryFact, LoopQueryRawCandidate, QuerySiteCandidatesFact, QuerySiteFact, ReceiverActivityFact, ReceiverProvenanceFact, ResolvedQuery, SchemaUsageCandidatesFact, SchemaUsageFact, UnresolvedQuerySite, WithinFileProvenanceFact } from './types.js';
+import type { ProvenanceEvidence, R3Site } from '../analyzers/provenance.js';
+import { type Binding } from '../analyzers/receiverRoot.js';
+import type { TsWithinFileProvenanceExtract } from '../analyzers/tsExpressionDescriptor.js';
+import type { Dialect } from '../mcp-tools/discoveryQueries.js';
+import { type HandleVerdict, type GoWithinFileProvenanceExtract } from '../analyzers/handleIdentification.js';
+import { type UnparseableSql } from '../analyzers/universal/schema/codeAnalysis.js';
+import { type TsconfigPathMap, type UnprovenQueryReceiver } from '../analyzers/receiverResolution.js';
+/**
+ * The per-corpus resolution inputs the five receiver consumers share: the raw
+ * facts that rehydrate to the per-file environment each consumer folds, plus the
+ * dialect and project tail that build the specifier/heritage resolvers. Bundling
+ * them here (rather than threading eight positional parameters) keeps each
+ * consumer's signature about its own fact kind, not the shared plumbing — the
+ * `parameter-count` smell is the resolution environment spread into positional
+ * params, and the remedy is one context object, not a suppression.
+ */
+interface ReceiverResolution {
+    withinFacts: readonly WithinFileProvenanceFact[];
+    provenance: ReceiverProvenanceFact;
+    activityFacts: readonly ReceiverActivityFact[];
+    sqlDialect: Dialect | null;
+    /** Spec 70 R2 — the corpus's dialect-detection reason (non-null only when
+     *  `sqlDialect` is null), threaded so an unparseable SQL argument in a
+     *  dialect-undetermined corpus reports the *why* (`dialect undetermined …
+     *  or ambiguous`) rather than the generic fallback string. Mirrors the legacy
+     *  `schema-code` visitor's `config.sqlDialectReason` → `parseSqlTables`. */
+    sqlDialectReason?: string | null;
+    declaredTypePackages?: ReadonlySet<string>;
+    /** Spec 70 criterion 9 (Item 4) — the corpus-wide ambient interface-field map:
+     *  global-script `interface` declarations (e.g. `worker-configuration.d.ts`
+     *  generated by `wrangler types`) gathered once and merged under each file's
+     *  local `interfaceFields`. Without it, a handler typed `env: Env` where `Env`
+     *  is declared in a sibling global script can never resolve its `env.DB` member
+     *  to `handle`, because `interfaceFields` is per-file only. */
+    ambientInterfaceFields?: ReadonlyMap<string, ReadonlyMap<string, string>>;
+    projectRoot?: string;
+    tsconfig?: TsconfigPathMap;
+    verdictCache?: Map<string, HandleVerdict | null>;
+}
+/** Rehydrate one file's `receiver-activity` fact back to the three provenance
+ *  inputs `classifyBuildProvenance` reads: the `Binding` map (`identifyHandle`'s
+ *  declaration resolution), the `R3Site[]` (`applyR3FromSites`), and the DB-shaped
+ *  activity set (`passesFileGate`'s `dbActivity` signal).
+ * @param fact - The serialized `receiver-activity` fact (may be absent).
+ * @returns The rehydrated bindings, R3 sites, and DB-activity set. */
+export declare function rehydrateReceiverActivity(fact: ReceiverActivityFact | undefined): {
+    bindings: Map<string, Binding>;
+    bindingsByScope: Map<string, Map<number, Binding>>;
+    r3Sites: R3Site[];
+    dbActivity: Set<string>;
+};
+/** Rehydrate the `receiver-provenance` fact's `files` back to a per-file seed
+ *  map — the exact `FileProvenance[file]` the legacy `file.receiverProvenance`
+ *  carried, keyed by file path so a consumer can look up its seed.
+ * @param fact - The serialized `receiver-provenance` fixed point.
+ * @returns A per-file map of provenanced-name → evidence. */
+export declare function rehydrateReceiverProvenance(fact: ReceiverProvenanceFact): Map<string, Map<string, ProvenanceEvidence>>;
+/** Rehydrate the TS-family `within-file-provenance` facts back to a per-file
+ *  `TsWithinFileProvenanceExtract` map (Go facts are skipped — the receiver
+ *  consumers are TS-family-only).
+ * @param withinFacts - The `within-file-provenance` facts (TS-family + Go).
+ * @returns A per-file map of rehydrated `TsWithinFileProvenanceExtract` (Go skipped). */
+export declare function rehydrateWithinTsExtracts(withinFacts: readonly WithinFileProvenanceFact[]): Map<string, TsWithinFileProvenanceExtract>;
+/** Rehydrate the Go `within-file-provenance` facts back to a per-file
+ *  `GoWithinFileProvenanceExtract` map (TS facts are skipped). The Go extract is
+ *  the binding + import env the Go arm of `identifyHandle` reads — `data-access-calls`
+ *  is the one receiver consumer that runs for the `go` format, so its corpus
+ *  producer needs the Go extracts in addition to the TS ones.
+ * @param withinFacts - The `within-file-provenance` facts (TS-family + Go).
+ * @returns A per-file map of rehydrated `GoWithinFileProvenanceExtract` (TS skipped). */
+export declare function rehydrateWithinGoExtracts(withinFacts: readonly WithinFileProvenanceFact[]): Map<string, GoWithinFileProvenanceExtract>;
+/**
+ * The corpus `query-sites` producer: re-derive each file's gate (glob ||
+ * dbProvenanced || dbActivity || hasSqlTag) from the raw `query-site-candidates`
+ * fact + the provenance fixed point, and emit the sites of the files that pass.
+ *
+ * A file's `dbProvenanced` is re-derived by `classifyBuildProvenance` from its
+ * within-file extract, its cross-file seed (`receiver-provenance`), and its
+ * `receiver-activity` inputs. Files are iterated in the raw fact's (file-sorted)
+ * order, so the emitted site array — and every finding derived from it — is
+ * byte-identical to the legacy gated extraction.
+ *
+ * @param candidates the raw `query-site-candidates` facts (one per TS-family file)
+ * @param withinFacts the `within-file-provenance` facts (TS-family)
+ * @param provenance the `receiver-provenance` fixed point
+ * @param activityFacts the `receiver-activity` facts
+ * @param sqlDialect the corpus's named dialect, or null to skip R3
+ * @returns the classified query-site facts (one per admitted TS-family site)
+ */
+export declare function classifyQuerySites(candidates: readonly QuerySiteCandidatesFact[], withinFacts: readonly WithinFileProvenanceFact[], provenance: ReceiverProvenanceFact, activityFacts: readonly ReceiverActivityFact[], sqlDialect: Dialect | null): QuerySiteFact[];
+/**
+ * The corpus `schema-usage` producer: re-derive each file's gate and its
+ * `dbProvenanced` from the raw `schema-usage-candidates` fact + the provenance
+ * fixed point, then re-admit and re-home the provenance-dependent references
+ * (tagged-template + DB-call) and append the provenance-free references the raw
+ * producer already re-homed (ORM / query-builder / collection-adapter).
+ *
+ * The emitted array is the legacy `extractSchemaUsage` output, byte-identical:
+ * strategy (1) tagged, (2) DB-call, (4) ORM, (5) query-builder, (6)
+ * collection-adapter — in that order, gated the same way, re-homed the same way.
+ *
+ * @param candidates the raw `schema-usage-candidates` facts (one per TS-family file)
+ * @param resolution the per-corpus resolution inputs (facts + dialect/project tail)
+ * @returns the classified schema-usage facts (strategies 1/2/4/5/6, in order)
+ */
+export declare function classifySchemaUsage(candidates: readonly SchemaUsageCandidatesFact[], resolution: ReceiverResolution): SchemaUsageFact[];
+/**
+ * Spec 70 1b — the corpus `unresolved-query` reduction. The legacy `schema-code`
+ * visitor emitted `checkUnresolvedQueries` for DB-calls `findTableReferences`
+ * admitted via `dbCallVerdict` (i.e. `identifyHandle` said "DB handle") but whose
+ * SQL argument was held in an unresolvable identifier. The collapse re-derives
+ * that surface with no AST: for each raw `schema-usage-candidates` fact, re-derive
+ * `dbProvenanced` (as `classifySchemaUsage` does), re-apply the file gate, then
+ * re-admit every `unresolved` candidate via `identifyHandle` — dropping any that
+ * are not DB handles — and emit the `unresolved-query` site record.
+ *
+ * @param candidates the raw `schema-usage-candidates` facts (one per TS-family file)
+ * @param resolution the per-corpus resolution inputs (facts + dialect/project tail)
+ * @returns the unresolved-query site records re-admitted via `identifyHandle`
+ */
+export declare function classifyUnresolvedQuerySites(candidates: readonly SchemaUsageCandidatesFact[], resolution: ReceiverResolution): UnresolvedQuerySite[];
+/**
+ * Spec 70 R2 — the corpus `unparseable` reduction. The legacy `schema-code`
+ * visitor emitted `checkUnparseableSql` for every DB-call / tagged-template SQL
+ * argument `findTableReferences` admitted but whose static text the named
+ * dialect could not parse (e.g. SQLite `PRAGMA`/`VACUUM`/`ANALYZE`). The collapse
+ * re-derives that surface with no AST: for each raw `schema-usage-candidates`
+ * fact, re-derive `dbProvenanced` (as `classifySchemaUsage` does), re-apply the
+ * file gate, then re-admit and re-parse every tagged template and DB-call
+ * candidate — collecting `parseSqlTables().unparseable` (which
+ * `classifySchemaUsage` discards) instead of its references. This is the
+ * `unparseable` sibling of {@link classifyUnresolvedQuerySites} (the
+ * `unresolved` half): the same re-derivation shape, a distinct output record.
+ *
+ * @param candidates the raw `schema-usage-candidates` facts (one per TS-family file)
+ * @param resolution the per-corpus resolution inputs (facts + dialect/project tail)
+ * @returns the unparseable-SQL records re-admitted via `identifyHandle`, each
+ *   stamped with its `file` (the legacy visitor emitted `checkUnparseableSql`
+ *   per-file, so the caller must be able to re-group by file)
+ */
+export declare function classifyUnparseableSql(candidates: readonly SchemaUsageCandidatesFact[], resolution: ReceiverResolution): Array<UnparseableSql & {
+    file: string;
+}>;
+/**
+ * The corpus `data-access-calls` producer: re-derive each file's `dbProvenanced`
+ * (TS via `classifyBuildProvenance`; Go via the fixed-point seed) from the raw
+ * `data-access-calls-candidates` fact + the provenance fixed point, then re-fold
+ * the legacy `extractDatabaseCalls` pipeline — discovery filter (`isDbCallCandidate`)
+ * → line dedup (template preferred, else first in pre-order) → `buildDatabaseCall`
+ * — with no AST. The dedup runs on the *discovered* set, not the built set, so a
+ * discovered-but-rejected node still shadows an admitted node on the same line
+ * exactly as the legacy pass did.
+ *
+ * @param candidates the raw `data-access-calls-candidates` facts (one per file)
+ * @param resolution the per-corpus resolution inputs (facts + dialect/project tail)
+ * @returns the resolved DB calls, deduped and rebuilt with no AST
+ */
+export declare function classifyDataAccessCalls(candidates: readonly DataAccessCallCandidate[], resolution: ReceiverResolution): ResolvedQuery[];
+/**
+ * The corpus `loop-queries` producer: re-derive each file's `dbProvenanced` (TS
+ * via `classifyBuildProvenance`), re-fold the strict-handle filter
+ * (`isDbCallNode`'s `identifyHandle`), dedup by loop byte-offset (one finding per
+ * loop, first wins), and assign the stable symbol. The provenance-free
+ * discriminators already ran in the raw producer; only the three
+ * provenance-dependent steps remain.
+ *
+ * @param candidates the raw `loop-query-candidates` facts (one per file)
+ * @param resolution the per-corpus resolution inputs (facts + dialect/project tail)
+ * @returns the resolved loop-query facts (deduped, stable symbols assigned)
+ */
+export declare function classifyLoopQueries(candidates: readonly LoopQueryRawCandidate[], resolution: ReceiverResolution): LoopQueryFact[];
+/**
+ * The corpus `unproven-query-receivers` reduction (Spec 70 2c) — the fifth
+ * receiver consumer, re-derived from the raw `data-access-calls-candidates` fact
+ * + the provenance fixed point with no AST. It re-folds `identifyHandle` per
+ * member candidate and emits an `UnprovenQueryReceiver` when the verdict is
+ * `unproven` and the call is query-shaped — mirroring the pre-pass's candidacy
+ * filter (language-independent string-arg, the SQL literal as admission proof)
+ * and its `root === null` skip (re-folded
+ * via `reFoldHandleVerdict`'s null on a missing root). This is the source for the
+ * `cannot-fire` coverage diagnostic, re-homed from `collectCannotFireDiagnostics`
+ * (which read the pre-pass's `unprovenQueryReceivers`).
+ *
+ * @param candidates the raw `data-access-calls-candidates` facts (one per file)
+ * @param resolution the per-corpus resolution inputs (facts + dialect/project tail)
+ * @returns the unproven query-receiver records, deduped and rebuilt
+ */
+export declare function classifyUnprovenQueryReceivers(candidates: readonly DataAccessCallCandidate[], resolution: ReceiverResolution): UnprovenQueryReceiver[];
+export {};
+//# sourceMappingURL=receiverConsumers.d.ts.map

package/dist/phase/receiverConsumers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"receiverConsumers.d.ts","sourceRoot":"","sources":["../../src/phase/receiverConsumers.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAGH,OAAO,KAAK,EACV,uBAAuB,EAGvB,aAAa,EACb,qBAAqB,EACrB,uBAAuB,EACvB,aAAa,EACb,oBAAoB,EACpB,sBAAsB,EACtB,aAAa,EACb,yBAAyB,EACzB,eAAe,EAEf,mBAAmB,EACnB,wBAAwB,EACzB,MAAM,YAAY,CAAC;AACpB,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,EAAE,MAAM,4BAA4B,CAAC;AAC7E,OAAO,EAAmB,KAAK,OAAO,EAAgF,MAAM,8BAA8B,CAAC;AAC3J,OAAO,KAAK,EAAE,6BAA6B,EAAE,MAAM,wCAAwC,CAAC;AAG5F,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,kCAAkC,CAAC;AAChE,OAAO,EAAkB,KAAK,aAAa,EAAE,KAAK,6BAA6B,EAAE,MAAM,sCAAsC,CAAC;AAE9H,OAAO,EAAkB,KAAK,cAAc,EAAE,MAAM,+CAA+C,CAAC;AAgBpG,OAAO,EAAoE,KAAK,eAAe,EAAE,KAAK,qBAAqB,EAAE,MAAM,oCAAoC,CAAC;AAOxK;;;;;;;;GAQG;AACH,UAAU,kBAAkB;IAC1B,WAAW,EAAE,SAAS,wBAAwB,EAAE,CAAC;IACjD,UAAU,EAAE,sBAAsB,CAAC;IACnC,aAAa,EAAE,SAAS,oBAAoB,EAAE,CAAC;IAC/C,UAAU,EAAE,OAAO,GAAG,IAAI,CAAC;IAC3B;;;;gFAI4E;IAC5E,gBAAgB,CAAC,EAAE,MAAM,GAAG,IAAI,CAAC;IACjC,oBAAoB,CAAC,EAAE,WAAW,CAAC,MAAM,CAAC,CAAC;IAC3C;;;;;mEAK+D;IAC/D,sBAAsB,CAAC,EAAE,WAAW,CAAC,MAAM,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAC1E,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,EAAE,eAAe,CAAC;IAC3B,YAAY,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,aAAa,GAAG,IAAI,CAAC,CAAC;CAClD;AA2GD;;;;;sEAKsE;AACtE,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,oBAAoB,GAAG,SAAS,GAAG;IACjF,QAAQ,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC;IAC/B,eAAe,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,CAAC;IACnD,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,UAAU,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC;CACzB,CA8BA;AAED;;;;6DAI6D;AAC7D,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,sBAAsB,GAAG,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,EAAE,kBAAkB,CAAC,CAAC,CAStH;AAED;;;;yFAIyF;AACzF,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,SAAS,wBAAwB,EAAE,GAC/C,GAAG,CAAC,MAAM,EAAE,6BAA6B,CAAC,CAQ5C;AAED;;;;;;yFAMyF;AACzF,wBAAgB,yBAAyB,CACvC,WAAW,EAAE,SAAS,wBAAwB,EAAE,GAC/C,GAAG,CAAC,MAAM,EAAE,6BAA6B,CAAC,CAQ5C;AA4ED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,kBAAkB,CAChC,UAAU,EAAE,SAAS,uBAAuB,EAAE,EAC9C,WAAW,EAAE,SAAS,wBAAwB,EAAE,EAChD,UAAU,EAAE,sBAAsB,EAClC,aAAa,EAAE,SAAS,oBAAoB,EAAE,EAC9C,UAAU,EAAE,OAAO,GAAG,IAAI,GACzB,aAAa,EAAE,CAqBjB;AAiLD;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,SAAS,yBAAyB,EAAE,EAChD,UAAU,EAAE,kBAAkB,GAC7B,eAAe,EAAE,CAqDnB;AAED;;;;;;;;;;;;;GAaG;AACH,wBAAgB,4BAA4B,CAC1C,UAAU,EAAE,SAAS,yBAAyB,EAAE,EAChD,UAAU,EAAE,kBAAkB,GAC7B,mBAAmB,EAAE,CAkCvB;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,wBAAgB,sBAAsB,CACpC,UAAU,EAAE,SAAS,yBAAyB,EAAE,EAChD,UAAU,EAAE,kBAAkB,GAC7B,KAAK,CAAC,cAAc,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CAAE,CAAC,CA8C1C;AA6TD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,uBAAuB,CACrC,UAAU,EAAE,SAAS,uBAAuB,EAAE,EAC9C,UAAU,EAAE,kBAAkB,GAC7B,aAAa,EAAE,CAsEjB;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,EAAE,SAAS,qBAAqB,EAAE,EAC5C,UAAU,EAAE,kBAAkB,GAC7B,aAAa,EAAE,CAqDjB;AAID;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,8BAA8B,CAC5C,UAAU,EAAE,SAAS,uBAAuB,EAAE,EAC9C,UAAU,EAAE,kBAAkB,GAC7B,qBAAqB,EAAE,CAwGzB"}