@descent-vtt/spec-guard 0.10.1 → 0.10.3

package/CHANGELOG.md

@@ -5,6 +5,130 @@ All notable changes to this project are documented here. Versions follow
 may change in a minor release — each such change is listed under **Changed**
 with the flag that restores the previous behaviour.
 
+## 0.10.3
+
+Fixes from running 0.10.2 over a Rust and .NET monorepo, where an import rule
+missed five `use` declarations in one crate and said nothing, and from probing
+every other language profile for the same mistake.
+[ADR-0006](docs/adr/0006-comment-classification.md),
+[ADR-0008](docs/adr/0008-polyglot-imports.md).
+
+### Fixed
+
+- **A Rust lifetime hid the code after it.** Every `'` opened a character
+  literal, and a lifetime - `&'static str`, `<'_>`, `'a`, `where 'a: 'b` - has
+  no closing quote, so the literal ran on to the next quote in the file: often
+  an apostrophe in a comment (`// don't`). Every `use` in between went unread
+  without a note, because the literal did close; with no second quote, every
+  `use` after it went unread with one. For a text rule the rest of that comment
+  became code, and a `/*` in it hid code as a comment. Quotes are now read as
+  `rustc_lexer` reads them: a quote and an identifier with no closing quote is a
+  lifetime or a label, and `'a'`, `'\''` and `'"'` are character literals.
+- **A Rust raw string with two or more hashes lost the scan.** `r##"…"##` read
+  as an ordinary string that closed at its first inner quote. Any number of
+  hashes is read now, in byte and C strings too (`br##"…"##`, `cr#"…"#`), and
+  `r#type` stays a raw identifier. `literalValue` strips any number of them.
+- **A `#` inside a word in a shell script or YAML file hid the rest of the
+  line**, as in `${path##*/}`, `${#items[@]}`, `$#` and
+  `url: https://example.com/#top`. `.sh`, `.bash`, `.zsh`, `.yaml` and `.yml`
+  have a profile of their own, `shell-like`, in which `#` opens a comment only
+  at the start of a line or after a space or a tab, as both languages define
+  it. Their quotes follow their specifications as well: `'C:\'` is a complete
+  string, and `$'it\'s'` is one string.
+- **A C++ digit separator opened a string.** `100'000` read its quote as the
+  start of a character literal, which paired with the next quote in the file.
+  In `.c`, `.cpp` and the rest of the C profile, a quote after a word that
+  begins with a digit is now part of the number; `u8'a'` is still a
+  character.
+
+### Changed
+
+- **A Rust character literal ends at the end of its line.** None can hold a
+  line break, and rustc stops reading an unclosed one there, so a quote misread
+  in future costs at most the rest of its line. Such a file is still reported
+  as unreadable, and the note now reads `a string or comment was never closed,
+  so its imports are not trustworthy` - it used to say the literal ran to the
+  end of the file.
+
+JavaScript and TypeScript are read exactly as before: across 7,954 files, the
+new lexer's ranges match 0.10.2's on every one. What it still misreads there - a
+regular expression literal holding a quote, `/["']/` - is recorded in ADR-0006.
+
+## 0.10.2
+
+Fixes from running 0.10.1 over a .NET solution, where a layer rule passed while
+the domain imported the application, and from reading C# as it is written in
+2026 while fixing that.
+[ADR-0011](docs/adr/0011-layers-and-cycles.md),
+[ADR-0008](docs/adr/0008-polyglot-imports.md).
+
+### Fixed
+
+- **A dotted module pattern did not cover what sits beneath it.**
+  `module="Shop.Application"` missed `using Shop.Application.Catalog;`, while
+  `module="Shop/Application"` caught it. A layer named `Shop.Application` had
+  the same gap, so `order="Shop.Domain, Shop.Application"` passed over a domain
+  that imported the application. Each reference in C#, Python and Rust now also
+  goes by every module it sits under, in its own notation, so `Shop.Application`
+  covers `Shop.Application.Catalog` and not `Shop.ApplicationServices`,
+  `app.db` covers `app.db.client`, and `crate::db` covers `crate::db::pool`.
+  An `@assert-import-count` over those languages can count more files than
+  before, and each is a file that depends on the module.
+- **Three kinds of C# using were read under a name no pattern matched.**
+  - `using global::Shop.Application;` read as `global.Shop.Application`, and
+    `using Legacy::Shop.Application;` (an extern alias) as
+    `Legacy.Shop.Application`. The qualifier is now left off.
+  - A using inside a namespace may be relative to it: in `namespace
+    Shop.Domain`, `using Application.Catalog;` can be
+    `Shop.Application.Catalog`. It now counts under each name it can resolve to
+    there.
+- **Two kinds of C# string lost the scan.** A raw string literal (C# 11) that
+  held a quote, or that opened with four quotes to hold three, and an
+  interpolated verbatim string written `@$"C:\"`, were misread. Every using after
+  one could go unread, and a text rule could count a comment as code. Both are
+  now read as strings.
+- **A backslash in a directive attribute was dropped.** Every backslash escaped
+  the character after it, so `symbol="Shop\.(Application|Web)\b" regex="true"`
+  searched for `Shop.(Application|Web)b`, matched nothing and passed, and
+  `exclude="src\gen"` excluded `srcgen`. Only `\"`, `\'` and `\\` are escapes
+  now; any other backslash is kept. Found by running this release's README
+  example against a project file. A pattern written with doubled backslashes to
+  get past the old behaviour, `\\b`, still reads as `\b`.
+- **`.csproj`, `.fsproj`, `.vbproj`, `.props`, `.targets`, `.slnx`, `.nuspec`,
+  `.resx` and `.xaml` were unclassified,** so a text rule over a project file
+  counted a `<ProjectReference>` inside `<!-- -->`. They are now read as XML.
+
+### Changed
+
+- **A layer rule that could not have failed now fails** (`allow-empty="true"`,
+  or `--allow-empty-scope`, makes each a warning again):
+  - **A layer no C# using can reach.** A layer named by its folder,
+    `src/Shop.Application`, holds the right files, but a using names a
+    namespace, never a path. When a layer after the first matches none of the
+    namespaces its own files declare, the rule fails:
+    `no C# using can reach layer "src/Shop.Application": it matches none of the
+    namespaces its files declare, such as Shop.Application.Catalog, so a
+    dependency on it is never seen`. Name a C# layer by its namespace,
+    `Shop.Application`, which matches the folder as well.
+  - **A scope in which no import reaches another layer.** Such a rule would
+    pass with its layers in any order: `no import in scope reaches a layer other
+    than its own file's, so these layers would pass in any order`. This is how
+    a layer named in a way no reference can match shows up in every language.
+- **The files an import rule could not read are named by kind**, as in
+  `analysed 5 of 7 files; 2 are in a language whose imports spec-guard cannot
+  read (.csproj, .razor)`. In a .NET project, the count alone hid the Razor
+  page among project files, and a Razor page can hold an `@using`.
+- **README:** a section on C# and .NET solutions - layers by namespace, what an
+  import rule cannot see and the text rule for each, and the `exclude` list for
+  build output (`bin`, `obj`, `artifacts`, `TestResults`, `.vs`).
+- **API:**
+  - `ModuleReference` has an optional `namespace`, the namespace a C# using sits
+    in.
+  - `FileImports` and `LayerInput` have an optional `namespaces`, those a C#
+    file declares.
+  - `LayerReport` has `crossed` and `unreachable`.
+  - New: `moduleNames` and `enclosingModules`.
+
 ## 0.10.1
 
 Fixes from running 0.10.0 over a large monorepo, and from testing each exclude

package/README.md

@@ -107,7 +107,9 @@ Exit code 1. The ADR is now a test.
 ## Directives
 
 Every directive is an HTML comment. It may span multiple lines. Attribute values
-may use double or single quotes, and a bare attribute means `="true"`.
+may use double or single quotes, and a bare attribute means `="true"`. Inside a
+value, `\"`, `\'` and `\\` are escapes and any other backslash is kept, so a
+regular expression is written as it reads: `symbol="\bTODO\b" regex="true"`.
 
 ### `@assert-absence` - this symbol is gone
 
@@ -204,10 +206,13 @@ touching code, a run that passed this way says so:
 ✔ every spec assertion holds
 ```
 
-Comment syntax is known for around 59 extensions across 9 families (JS/TS, C,
-C#, Rust, Go, Python-style `#`, SQL-style `--`, markup, and formats with no
-comments at all). Strings are tracked too, because `//` inside a URL is not a
-comment and reading it as one would hide real code. Where spec-guard is unsure —
+Comment syntax is known for around 68 extensions across 10 families (JS/TS, C,
+C#, Rust, Go, Python-style `#`, shell and YAML `#`, SQL-style `--`, markup -
+MSBuild project files included - and formats with no comments at all). Strings
+are tracked too, because `//` inside a URL is not a comment and reading it as
+one would hide real code. So is what only looks like either: a Rust lifetime
+(`&'static str`), a C++ digit separator (`100'000`) and a `#` inside a shell
+word (`${#items[@]}`) open nothing. Where spec-guard is unsure —
 an unknown extension, an unterminated literal — the text counts as code, and the
 report says which files it could not classify. A match wrongly kept is a visible
 failure you can argue with; a match wrongly dropped is a lie.
@@ -302,7 +307,7 @@ These read the dependency rather than the text, in **five languages**:
 | Python | `.py .pyi` | `import a.b`, `from .rel import x`, `importlib.import_module("x")` |
 | Go | `.go` | `import "x"` and grouped `import ( ... )`, including aliases and `_` |
 | Rust | `.rs` | `use a::{b, c}` with nested groups, `pub use`, `extern crate` |
-| C# | `.cs .csx` | `using`, `using static`, `global using`, `using X = A.B` |
+| C# | `.cs .csx` | `using`, `using static`, `global using`, `using X = A.B`, `global::` and extern-alias qualifiers, and a using relative to its namespace |
 
 No parser and no new dependency. JavaScript gets a full tokenizer because a
 module reference can appear anywhere in an expression; the other four are read
@@ -315,9 +320,12 @@ this does not.
 
 Module patterns are matched against the resolved `/`-separated path *and*
 against the specifier as written, so `module="System.Text.Json"` and
-`module="System/Text/Json"` both work. Matching is case-sensitive, so a rule
-spanning C# and Go needs both conventions:
-`module="app/db/** App/Db/**"`.
+`module="System/Text/Json"` both work. Either form covers what sits beneath it,
+as `module="lodash"` covers `lodash/fp`: `module="Shop.Application"` matches
+`using Shop.Application.Catalog;` and not `using Shop.ApplicationServices;`,
+`module="app.db"` matches `import app.db.client`, and `module="crate::db"`
+matches `use crate::db::pool`. Matching is case-sensitive, so a rule spanning C#
+and Go needs both conventions: `module="app/db/** App/Db/**"`.
 
 The unit counted is **files** that depend on the module. For JavaScript and
 TypeScript it understands:
@@ -354,7 +362,7 @@ stops it being mistaken for a complete answer. A passing rule prints it without
 `--verbose` too, since a green run is when it would otherwise go unread.
 `--strict` turns those warnings into failures. Files in scope that are not JavaScript or TypeScript are counted
 and reported too, so a rule pointed at the wrong tree says "analysed 2 of 3
-files" rather than quietly passing - and if *none* of them can be read, the
+files; 1 is in a language whose imports spec-guard cannot read (.razor)" rather than quietly passing - and if *none* of them can be read, the
 assertion fails rather than passing on an empty analysis.
 
 [ADR-0005](docs/adr/0005-import-assertions.md) has the measurements and the
@@ -387,15 +395,89 @@ why this works in all five languages above: `src/domain` is anchored at the
 root, and a bare `domain` matches that segment anywhere - in `src/domain/user.ts`,
 in Python's `app.domain.user`, in Rust's `crate::domain::user`. A layer may also
 be a single file; `order="src/parser.ts, src/cli.ts"` understands that
-`./parser.js` is `src/parser.ts`.
+`./parser.js` is `src/parser.ts`. C# is layered by namespace, and has
+[a section of its own](#c-and-net-solutions).
 
 The unit is files, and `max`, `types`, `exclude` and `baseline` mean what they
-mean on `@assert-import-absence`. Three things fail rather than pass, because
-each is a rule that would otherwise check less than it says: a layer that
-matches no file (`order="domain, aplication"`), a file two layers both claim,
-and a target that does not exist. Files that no layer claims are left alone and
-counted, so a directory nobody assigned shows up as a number rather than as
-silence.
+mean on `@assert-import-absence`. Five things fail rather than pass, because
+each is a rule that would otherwise check less than it says:
+
+- a layer that matches no file (`order="domain, aplication"`);
+- a file two layers both claim;
+- a target that does not exist;
+- a layer no C# `using` can reach, because it matches none of the namespaces its
+  own files declare - `src/Shop.Application` rather than `Shop.Application`;
+- a scope in which no import reaches a layer other than its own file's, since
+  that rule passes whatever order its layers are listed in:
+
+```text
+✖ docs/architecture.md:12  @assert-layers
+    src must keep its layers in order, src/domain < src/application < src/infrastructure
+    no import in scope reaches a layer other than its own file's, so these layers would pass in any order (add allow-empty="true" if that is expected)
+```
+
+`allow-empty="true"` turns the first and the last two into warnings. Files that
+no layer claims are left alone and counted, so a directory nobody assigned shows
+up as a number rather than as silence.
+
+### C# and .NET solutions
+
+A .NET project has three names: its folder, its project file and its root
+namespace. `dotnet new` gives all three the same one, and that is what lets a
+single pattern do both halves of a layer rule - hold the files under
+`src/Shop.Domain`, and reach `using Shop.Domain.Orders;` from anywhere else:
+
+```md
+<!-- @assert-layers target="src" order="Shop.Domain, Shop.Application, Shop.Infrastructure, Shop.Web" reason="dependencies point inward" -->
+<!-- @assert-import-absence target="src/Shop.Application" module="Microsoft.EntityFrameworkCore" reason="persistence is infrastructure's" -->
+```
+
+- **Name a C# layer by its namespace.** `Shop.Domain` matches the folder as a
+  path segment, and the namespace with everything under it - `Shop.Domain.Orders`,
+  but not `Shop.DomainEvents`. A folder path such as `src/Shop.Domain` holds the
+  right files, but a using names a namespace, never a path, so nothing can reach
+  it: such a rule fails, and names a namespace the layer's files declare. Where
+  folders and namespaces differ, as when `src/Domain` holds
+  `Acme.Clean.Domain.Entities`, the name they share - `Domain` - does both.
+- **`module=` is a namespace too**, as above: `module="Shop.Infrastructure"`
+  covers `using Shop.Infrastructure.Persistence;`.
+- **What is read**: `using`, `global using`, `using static` and aliases, with
+  any `global::` or extern-alias qualifier left off the name. A using inside a
+  namespace may be relative to it, so `using Application.Orders;` inside
+  `namespace Shop.Domain` also counts as `Shop.Application.Orders`. Nothing in a
+  comment, a verbatim string or a raw string literal is read.
+
+What it cannot see, and the text rule that covers each - a text rule reads a
+name wherever it is written:
+
+| Not seen by an import rule | Held by |
+| --- | --- |
+| A fully qualified name with no using: `new Shop.Infrastructure.Db()` | `@assert-absence target="src/Shop.Domain" glob="*.cs" symbol="Shop.Infrastructure" word="true"` |
+| A `<ProjectReference>`, or a `<Using Include>` in a project file | the same rule with `glob="*.csproj,*.props"` |
+| `@using` in `.razor` and `.cshtml`, which import rules count as files they could not read | the same rule with `glob="*.razor,*.cshtml"` |
+| Code a source generator writes | nothing: it is not in the tree |
+
+In a solution of projects, the project references are the layering the
+compiler enforces - a using of a project that is not referenced does not build -
+so a rule over the project files is worth having beside the layer rule:
+
+```md
+<!-- @assert-absence target="src/Shop.Domain" glob="*.csproj" regex="true" symbol="Shop\.(Application|Infrastructure|Web)\b" reason="the domain references no outer project" -->
+```
+
+Keep build output out of every rule in `.spec-guard.json`:
+
+```json
+{
+  "specs": ["docs/**/*.md"],
+  "exclude": ["bin", "obj", "artifacts", "TestResults", ".vs"]
+}
+```
+
+`bin` and `obj` are MSBuild's output, `artifacts` is where the output goes with
+`UseArtifactsOutput` (.NET 8 and later), `TestResults` is where `dotnet test`
+writes, and `.vs` holds Visual Studio's caches. A front end in the same tree
+adds its own, such as Nuxt's `.output`; `node_modules` is skipped already.
 
 ### `@assert-import-cycle` - no file depends on itself
 
@@ -573,7 +655,7 @@ Passes when every listed path exists relative to `--root`. Directories count.
 | `partner` | structure | Partner templates, any one of which must exist: `[name].test.[ext]` |
 | `types` | import assertions, layers, cycles | `include` (default) or `ignore` for `import type` |
 | `dynamic` | cycles | `include` (default) or `ignore` for `import('x')` |
-| `allow-empty` | all but present | Tolerate a scope that holds no files, a layer that matches none, or no chosen directories. Off by default - see below |
+| `allow-empty` | all but present | Tolerate a scope that holds no files, a layer that matches none, a layer no C# using can reach, layers no import crosses between, or no chosen directories. Off by default - see below |
 | `baseline` | absence, import-absence, layers, structure | Known violations that do not count: `path` or `path:count` |
 | `ratchet` | absence, import-absence, layers, structure | `two-sided` (default) or `one-way` - see below |
 | `reason` | all | Human-readable justification, printed on failure |
@@ -1285,7 +1367,7 @@ prebuilt binary and is never a runtime dependency.
 
 Coverage says a line ran. It does not say an assertion would notice if the line
 behaved differently. This repository measures the difference: line coverage is
-**100%**, and **98.93%** of 8,068 mutants are killed in CI, with 83 survivors and
+**100%**, and **99.00%** of 8,420 mutants are killed in CI, with 81 survivors and
 no file below 95%. The second number is the one worth reading, and what was done
 about the survivors matters more than the score. At 0.5.1 every surviving mutant
 was checked individually, and the 101 left then produced byte-identical output.

package/dist/comments.d.ts

@@ -31,6 +31,25 @@ interface StringRule {
     close: string;
     /** Backslash escapes apply inside. */
     escape: boolean;
+    /**
+     * The opener is a run of its character at least `open` long, and only a run
+     * of the same length closes it: C#'s raw strings, which take `"""` or as many
+     * more quotes as their text needs to hold a `"""` of its own.
+     */
+    run?: boolean;
+    /**
+     * Rust's raw strings: `open`, any number of `#` and a quote, closed only by a
+     * quote and as many `#` - `r"…"`, `r#"…"#`, `r##"…"##`, as many as the text
+     * needs to hold a `"#` of its own. Without the quote it is no string at all:
+     * `r#match` is a raw identifier, and the `r` in `for` is a letter.
+     */
+    hashes?: boolean;
+    /**
+     * The literal cannot hold a line break, so reaching one means it was never
+     * closed. A Rust character literal holds a single character, and rustc stops
+     * reading one at the end of its line.
+     */
+    singleLine?: boolean;
 }
 export interface CommentSyntax {
     name: string;
@@ -40,6 +59,22 @@ export interface CommentSyntax {
     block: ReadonlyArray<readonly [string, string]>;
     /** Block comments nest, as in Rust. */
     nested: boolean;
+    /**
+     * A quote before an identifier that no quote closes is a lifetime or a loop
+     * label, as in Rust - `'a`, `'static`, `'_`, `'outer` - and is code.
+     */
+    lifetimes: boolean;
+    /**
+     * A quote straight after a number is part of it: C++14 and C23 separate
+     * digits with one, `100'000`.
+     */
+    digitSeparators: boolean;
+    /**
+     * A line comment opens only where a word could start - at the start of a
+     * line, or after a space or a tab - as in a shell, where `${#items[@]}` and
+     * `$#` are code, and in YAML, where `a#b` is text.
+     */
+    wordComments: boolean;
     /** Literal forms that may contain comment-looking text. */
     strings: readonly StringRule[];
 }
@@ -55,10 +90,12 @@ export interface LexResult {
     /** Half-open ranges of string literals, delimiters included. */
     strings: CommentRange[];
     /**
-     * True when a string or block comment ran off the end of the file.
+     * True when a literal or block comment was never closed: it ran off the end
+     * of the file, or - for a literal that cannot hold a line break - off the end
+     * of its line.
      *
-     * The ranges are still returned - reading an unterminated literal to EOF is
-     * what a compiler does - but everything after the opening delimiter was
+     * The ranges are still returned - reading an unterminated literal to its end
+     * is what a compiler does - but everything after the opening delimiter was
      * swallowed by it, so anything derived from this scan is missing whatever
      * lived in there. Callers that draw conclusions from absence must say so.
      */

package/dist/comments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"comments.d.ts","sourceRoot":"","sources":["../src/comments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,MAAM,EAAE,OAAO,CAAC;CACjB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,0CAA0C;IAC1C,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChD,uCAAuC;IACvC,MAAM,EAAE,OAAO,CAAC;IAChB,2DAA2D;IAC3D,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;CAChC;AA6ID,2EAA2E;AAC3E,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAEhE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAE9D;AAED,4DAA4D;AAC5D,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AA2CrD,oFAAoF;AACpF,MAAM,WAAW,SAAS;IACxB,4DAA4D;IAC5D,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,gEAAgE;IAChE,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB;;;;;;;OAOG;IACH,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,SAAS,CA2C1E;AAED,yEAAyE;AACzE,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,YAAY,EAAE,CAEnF;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;CACpC;AAQD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,CAqB/E"}
+{"version":3,"file":"comments.d.ts","sourceRoot":"","sources":["../src/comments.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AAIH,UAAU,UAAU;IAClB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,sCAAsC;IACtC,MAAM,EAAE,OAAO,CAAC;IAChB;;;;OAIG;IACH,GAAG,CAAC,EAAE,OAAO,CAAC;IACd;;;;;OAKG;IACH,MAAM,CAAC,EAAE,OAAO,CAAC;IACjB;;;;OAIG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,sDAAsD;IACtD,IAAI,EAAE,SAAS,MAAM,EAAE,CAAC;IACxB,0CAA0C;IAC1C,KAAK,EAAE,aAAa,CAAC,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;IAChD,uCAAuC;IACvC,MAAM,EAAE,OAAO,CAAC;IAChB;;;OAGG;IACH,SAAS,EAAE,OAAO,CAAC;IACnB;;;OAGG;IACH,eAAe,EAAE,OAAO,CAAC;IACzB;;;;OAIG;IACH,YAAY,EAAE,OAAO,CAAC;IACtB,2DAA2D;IAC3D,OAAO,EAAE,SAAS,UAAU,EAAE,CAAC;CAChC;AAgOD,2EAA2E;AAC3E,wBAAgB,SAAS,CAAC,QAAQ,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAEhE;AAED,wBAAgB,WAAW,CAAC,IAAI,EAAE,MAAM,GAAG,aAAa,GAAG,IAAI,CAE9D;AAED,4DAA4D;AAC5D,MAAM,MAAM,YAAY,GAAG,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAuGrD,oFAAoF;AACpF,MAAM,WAAW,SAAS;IACxB,4DAA4D;IAC5D,QAAQ,EAAE,YAAY,EAAE,CAAC;IACzB,gEAAgE;IAChE,OAAO,EAAE,YAAY,EAAE,CAAC;IACxB;;;;;;;;;OASG;IACH,YAAY,EAAE,OAAO,CAAC;CACvB;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,SAAS,CAkD1E;AAED,yEAAyE;AACzE,wBAAgB,aAAa,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,aAAa,GAAG,YAAY,EAAE,CAEnF;AAED;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IAC1B,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAC7B,QAAQ,CAAC,MAAM,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,SAAS,CAAC,MAAM,EAAE,MAAM,GAAG,OAAO,CAAC;CACpC;AAQD,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG,WAAW,CAqB/E"}