@typescript-eslint/eslint-plugin 8.0.0-alpha.6 → 8.0.0-alpha.61

package/docs/rules/return-await.mdx

@@ -1,5 +1,5 @@
 ---
-description: 'Enforce consistent returning of awaited values.'
+description: 'Enforce consistent awaiting of returned promises.'
 ---
 
 import Tabs from '@theme/Tabs';
@@ -9,30 +9,53 @@ import TabItem from '@theme/TabItem';
 >
 > See **https://typescript-eslint.io/rules/return-await** for documentation.
 
-Returning an awaited promise can make sense for better stack trace information as well as for consistent error handling (returned promises will not be caught in an async function try/catch).
-
 This rule builds on top of the [`eslint/no-return-await`](https://eslint.org/docs/rules/no-return-await) rule.
 It expands upon the base rule to add support for optionally requiring `return await` in certain cases.
 
-The extended rule is named `return-await` instead of `no-return-await` because the extended rule can enforce the positive or the negative. Additionally, while the core rule is now deprecated, the extended rule is still useful in many contexts.
+The extended rule is named `return-await` instead of `no-return-await` because the extended rule can enforce the positive or the negative. Additionally, while the core rule is now deprecated, the extended rule is still useful in many contexts:
+
+- Returning an awaited promise [improves stack trace information](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/await#improving_stack_trace).
+- When the `return` statement is in `try...catch`, awaiting the promise also allows the promise's rejection to be caught instead of leaving the error to the caller.
+- Contrary to popular belief, `return await promise;` is [at least as fast as directly returning the promise](https://github.com/tc39/proposal-faster-promise-adoption).
 
 ## Options
 
 ```ts
-type Options = 'in-try-catch' | 'always' | 'never';
+type Options =
+  | 'in-try-catch'
+  | 'always'
+  | 'error-handling-correctness-only'
+  | 'never';
 
 const defaultOptions: Options = 'in-try-catch';
 ```
 
+The options in this rule distinguish between "ordinary contexts" and "error-handling contexts".
+An error-handling context is anywhere where returning an unawaited promise would cause unexpected control flow regarding exceptions/rejections.
+See detailed examples in the sections for each option.
+
+- If you return a promise within a `try` block, it should be awaited in order to trigger subsequent `catch` or `finally` blocks as expected.
+- If you return a promise within a `catch` block, and there _is_ a `finally` block, it should be awaited in order to trigger the `finally` block as expected.
+- If you return a promise between a `using` or `await using` declaration and the end of its scope, it should be awaited, since it behaves equivalently to code wrapped in a `try` block followed by a `finally`.
+
+Ordinary contexts are anywhere else a promise may be returned.
+The choice of whether to await a returned promise in an ordinary context is mostly stylistic.
+
+With these terms defined, the options may be summarized as follows:
+
+|              Option               | Ordinary Context <br/> (stylistic preference 🎨) |        Error-Handling Context <br/> (catches bugs 🐛)        |                 Should I use this option?                  |
+| :-------------------------------: | :----------------------------------------------: | :----------------------------------------------------------: | :--------------------------------------------------------: |
+|             `always`              |             `return await promise;`              |                   `return await promise;`                    |                          ✅ Yes!                           |
+|          `in-try-catch`           |                `return promise;`                 |                   `return await promise;`                    |                          ✅ Yes!                           |
+| `error-handling-correctness-only` |                  don't care 🤷                   |                   `return await promise;`                    | 🟡 Okay to use, but the above options would be preferable. |
+|              `never`              |                `return promise;`                 | `return promise;` <br/> (⚠️ This behavior may be harmful ⚠️) |             ❌ No. This option is deprecated.              |
+
 ### `in-try-catch`
 
-Requires that a returned promise must be `await`ed in `try-catch-finally` blocks, and disallows it elsewhere.
-Specifically:
+In error-handling contexts, the rule enforces that returned promises must be awaited.
+In ordinary contexts, the rule enforces that returned promises _must not_ be awaited.
 
-- if you `return` a promise within a `try`, then it must be `await`ed.
-- if you `return` a promise within a `catch`, and there **_is no_** `finally`, then it **_must not_** be `await`ed.
-- if you `return` a promise within a `catch`, and there **_is a_** `finally`, then it **_must_** be `await`ed.
-- if you `return` a promise within a `finally`, then it **_must not_** be `await`ed.
+This is a good option if you prefer the shorter `return promise` form for stylistic reasons, wherever it's safe to use.
 
 Examples of code with `in-try-catch`:
 
@@ -42,23 +65,34 @@ Examples of code with `in-try-catch`:
 ```ts option='"in-try-catch"'
 async function invalidInTryCatch1() {
   try {
-    return Promise.resolve('try');
-  } catch (e) {}
+    return Promise.reject('try');
+  } catch (e) {
+    // Doesn't execute due to missing await.
+  }
 }
 
 async function invalidInTryCatch2() {
   try {
     throw new Error('error');
   } catch (e) {
-    return await Promise.resolve('catch');
+    // Unnecessary await; rejections here don't impact control flow.
+    return await Promise.reject('catch');
   }
 }
 
+// Prints 'starting async work', 'cleanup', 'async work done'.
 async function invalidInTryCatch3() {
+  async function doAsyncWork(): Promise<void> {
+    console.log('starting async work');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    console.log('async work done');
+  }
+
   try {
     throw new Error('error');
   } catch (e) {
-    return Promise.resolve('catch');
+    // Missing await.
+    return doAsyncWork();
   } finally {
     console.log('cleanup');
   }
@@ -70,7 +104,8 @@ async function invalidInTryCatch4() {
   } catch (e) {
     throw new Error('error2');
   } finally {
-    return await Promise.resolve('finally');
+    // Unnecessary await; rejections here don't impact control flow.
+    return await Promise.reject('finally');
   }
 }
 
@@ -81,6 +116,11 @@ async function invalidInTryCatch5() {
 async function invalidInTryCatch6() {
   return await 'value';
 }
+
+async function invalidInTryCatch7() {
+  using x = createDisposable();
+  return Promise.reject('using in scope');
+}
 ```
 
 </TabItem>
@@ -89,23 +129,32 @@ async function invalidInTryCatch6() {
 ```ts option='"in-try-catch"'
 async function validInTryCatch1() {
   try {
-    return await Promise.resolve('try');
-  } catch (e) {}
+    return await Promise.reject('try');
+  } catch (e) {
+    // Executes as expected.
+  }
 }
 
 async function validInTryCatch2() {
   try {
     throw new Error('error');
   } catch (e) {
-    return Promise.resolve('catch');
+    return Promise.reject('catch');
   }
 }
 
+// Prints 'starting async work', 'async work done', 'cleanup'.
 async function validInTryCatch3() {
+  async function doAsyncWork(): Promise<void> {
+    console.log('starting async work');
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    console.log('async work done');
+  }
+
   try {
     throw new Error('error');
   } catch (e) {
-    return await Promise.resolve('catch');
+    return await doAsyncWork();
   } finally {
     console.log('cleanup');
   }
@@ -117,7 +166,7 @@ async function validInTryCatch4() {
   } catch (e) {
     throw new Error('error2');
   } finally {
-    return Promise.resolve('finally');
+    return Promise.reject('finally');
   }
 }
 
@@ -128,6 +177,11 @@ async function validInTryCatch5() {
 async function validInTryCatch6() {
   return 'value';
 }
+
+async function validInTryCatch7() {
+  using x = createDisposable();
+  return await Promise.reject('using in scope');
+}
 ```
 
 </TabItem>
@@ -135,7 +189,9 @@ async function validInTryCatch6() {
 
 ### `always`
 
-Requires that all returned promises are `await`ed.
+Requires that all returned promises be awaited.
+
+This is a good option if you like the consistency of simply always awaiting promises, or prefer not having to consider the distinction between error-handling contexts and ordinary contexts.
 
 Examples of code with `always`:
 
@@ -180,9 +236,49 @@ async function validAlways3() {
 </TabItem>
 </Tabs>
 
+### `error-handling-correctness-only`
+
+In error-handling contexts, the rule enforces that returned promises must be awaited.
+In ordinary contexts, the rule does not enforce any particular behavior around whether returned promises are awaited.
+
+This is a good option if you only want to benefit from rule's ability to catch control flow bugs in error-handling contexts, but don't want to enforce a particular style otherwise.
+
+:::info
+We recommend you configure either `in-try-catch` or `always` instead of this option.
+While the choice of whether to await promises outside of error-handling contexts is mostly stylistic, it's generally best to be consistent.
+:::
+
+Examples of additional correct code with `error-handling-correctness-only`:
+
+<Tabs>
+<TabItem value="✅ Correct">
+
+```ts option='"error-handling-correctness-only"'
+async function asyncFunction(): Promise<void> {
+  if (Math.random() < 0.5) {
+    return await Promise.resolve();
+  } else {
+    return Promise.resolve();
+  }
+}
+```
+
+</TabItem>
+</Tabs>
+
 ### `never`
 
-Disallows all `await`ing any returned promises.
+Disallows awaiting any returned promises.
+
+:::warning
+
+This option is deprecated and will be removed in a future major version of typescript-eslint.
+
+The `never` option introduces undesirable behavior in error-handling contexts.
+If you prefer to minimize returning awaited promises, consider instead using `in-try-catch` instead, which also generally bans returning awaited promises, but only where it is _safe_ not to await a promise.
+
+See more details at [typescript-eslint#9433](https://github.com/typescript-eslint/typescript-eslint/issues/9433).
+:::
 
 Examples of code with `never`:
 

package/docs/rules/sort-type-constituents.mdx

@@ -9,6 +9,12 @@ import TabItem from '@theme/TabItem';
 >
 > See **https://typescript-eslint.io/rules/sort-type-constituents** for documentation.
 
+:::danger Deprecated
+This rule has been deprecated in favor of the [`perfectionist/sort-intersection-types`](https://perfectionist.dev/rules/sort-intersection-types) and [`perfectionist/sort-union-types`](https://perfectionist.dev/rules/sort-union-types) rules.
+
+See [Docs: Deprecate sort-type-constituents in favor of eslint-plugin-perfectionist](https://github.com/typescript-eslint/typescript-eslint/issues/8915) and [eslint-plugin: Feature freeze naming and sorting stylistic rules](https://github.com/typescript-eslint/typescript-eslint/issues/8792) for more information.
+:::
+
 Sorting union (`|`) and intersection (`&`) types can help:
 
 - keep your codebase standardized
@@ -19,15 +25,6 @@ This rule reports on any types that aren't sorted alphabetically.
 
 > Types are sorted case-insensitively and treating numbers like a human would, falling back to character code sorting in case of ties.
 
-:::note
-This rule is _feature frozen_: it will no longer receive new features such as new options.
-It still will accept bug and documentation fixes for its existing area of features.
-
-Stylistic rules that enforce naming and/or sorting conventions tend to grow incomprehensibly complex as increasingly obscure features are requested.
-This rule has reached the limit of what is reasonable for the typescript-eslint project to maintain.
-See [eslint-plugin: Feature freeze naming and sorting stylistic rules](https://github.com/typescript-eslint/typescript-eslint/issues/8792) for more information.
-:::
-
 ## Examples
 
 <Tabs>
@@ -97,6 +94,29 @@ type T4 =
 
 ## Options
 
+### `caseSensitive`
+
+Whether to sort using case sensitive string comparisons.
+
+Examples of code with `{ "caseSensitive": true }`:
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts option='{ "caseSensitive": true }'
+type T = 'DeletedAt' | 'DeleteForever';
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts option='{ "caseSensitive": true }'
+type T = 'DeleteForever' | 'DeletedAt';
+```
+
+</TabItem>
+</Tabs>
+
 ### `checkIntersections`
 
 Whether to check intersection types (`&`).

package/docs/rules/sort-type-union-intersection-members.mdx

@@ -0,0 +1,12 @@
+:::danger Deprecated
+
+This rule has been renamed to [`sort-type-constituents`](https://typescript-eslint.io/rules/sort-type-constituents).
+
+:::
+
+<!--
+This doc file has been left on purpose to help direct people to the replacement rule.
+
+Note that there is no actual way to get to this page in the normal navigation,
+so end-users will only be able to get to this page from the search bar.
+-->

package/docs/rules/strict-boolean-expressions.mdx

@@ -21,6 +21,7 @@ The following nodes are considered boolean expressions and their type is checked
 - Operands of logical binary operators (`lhs || rhs` and `lhs && rhs`).
   - Right-hand side operand is ignored when it's not a descendant of another boolean expression.
     This is to allow usage of boolean operators for their short-circuiting behavior.
+- Asserted argument of an assertion function (`assert(arg)`).
 
 ## Examples
 
@@ -55,6 +56,11 @@ let obj = {};
 while (obj) {
   obj = getObj();
 }
+
+// assertion functions without an `is` are boolean contexts.
+declare function assert(value: unknown): asserts value;
+let maybeString = Math.random() > 0.5 ? '' : undefined;
+assert(maybeString);
 ```
 
 </TabItem>

package/docs/rules/unbound-method.mdx

@@ -16,7 +16,7 @@ Otherwise, passing class methods around as values can remove type safety by fail
 This rule reports when a class method is referenced in an unbound manner.
 
 :::note Tip
-If you're working with `jest`, you can use [`eslint-plugin-jest`'s version of this rule](https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/unbound-method.mdx) to lint your test files, which knows when it's ok to pass an unbound method to `expect` calls.
+If you're working with `jest`, you can use [`eslint-plugin-jest`'s version of this rule](https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/unbound-method.md) to lint your test files, which knows when it's ok to pass an unbound method to `expect` calls.
 :::
 
 ## Examples
@@ -105,7 +105,8 @@ log();
 ## When Not To Use It
 
 If your project dynamically changes `this` scopes around in a way TypeScript has difficulties modeling, this rule may not be viable to use.
-One likely difficult pattern is if your code intentionally waits to bind methods after use, such as by passing a `scope: this` along with the method.
+For example, some functions have an additional parameter for specifying the `this` context, such as `Reflect.apply`, and array methods like `Array.prototype.map`.
+This semantic is not easily expressed by TypeScript.
 You might consider using [ESLint disable comments](https://eslint.org/docs/latest/use/configure/rules#using-configuration-comments-1) for those specific situations instead of completely disabling this rule.
 
 If you're wanting to use `toBeCalled` and similar matches in `jest` tests, you can disable this rule for your test files in favor of [`eslint-plugin-jest`'s version of this rule](https://github.com/jest-community/eslint-plugin-jest/blob/main/docs/rules/unbound-method.mdx).

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@typescript-eslint/eslint-plugin",
-  "version": "8.0.0-alpha.6",
+  "version": "8.0.0-alpha.61",
   "description": "TypeScript plugin for ESLint",
   "files": [
     "dist",
@@ -48,44 +48,38 @@
   ],
   "scripts": {
     "build": "tsc -b tsconfig.build.json",
-    "check-docs": "jest tests/docs.test.ts --runTestsByPath --silent --runInBand",
-    "check-configs": "jest tests/configs.test.ts --runTestsByPath --silent --runInBand",
     "clean": "tsc -b tsconfig.build.json --clean",
     "postclean": "rimraf dist && rimraf coverage",
     "format": "prettier --write \"./**/*.{ts,mts,cts,tsx,js,mjs,cjs,jsx,json,md,css}\" --ignore-path ../../.prettierignore",
-    "generate:breaking-changes": "yarn tsx tools/generate-breaking-changes.mts",
-    "generate:configs": "npx nx run repo-tools:generate-configs",
+    "generate:breaking-changes": "tsx tools/generate-breaking-changes.mts",
+    "generate:configs": "npx nx generate-configs repo",
     "lint": "npx nx lint",
     "test": "cross-env NODE_OPTIONS=\"--experimental-vm-modules\" jest --coverage --logHeapUsage",
     "test-single": "cross-env NODE_OPTIONS=\"--experimental-vm-modules\" jest --no-coverage",
-    "typecheck": "tsc -p tsconfig.json --noEmit"
+    "typecheck": "tsc --noEmit"
   },
   "dependencies": {
     "@eslint-community/regexpp": "^4.10.0",
-    "@typescript-eslint/scope-manager": "8.0.0-alpha.6",
-    "@typescript-eslint/type-utils": "8.0.0-alpha.6",
-    "@typescript-eslint/utils": "8.0.0-alpha.6",
-    "@typescript-eslint/visitor-keys": "8.0.0-alpha.6",
-    "debug": "^4.3.4",
+    "@typescript-eslint/scope-manager": "8.0.0-alpha.61",
+    "@typescript-eslint/type-utils": "8.0.0-alpha.61",
+    "@typescript-eslint/utils": "8.0.0-alpha.61",
+    "@typescript-eslint/visitor-keys": "8.0.0-alpha.61",
     "graphemer": "^1.4.0",
     "ignore": "^5.3.1",
     "natural-compare": "^1.4.0",
-    "semver": "^7.6.0",
     "ts-api-utils": "^1.3.0"
   },
   "devDependencies": {
-    "@types/debug": "*",
-    "@types/marked": "*",
+    "@jest/types": "29.6.3",
+    "@types/marked": "^5.0.2",
     "@types/mdast": "^4.0.3",
     "@types/natural-compare": "*",
-    "@typescript-eslint/rule-schema-to-typescript-types": "8.0.0-alpha.6",
-    "@typescript-eslint/rule-tester": "8.0.0-alpha.6",
+    "@typescript-eslint/rule-schema-to-typescript-types": "8.0.0-alpha.61",
+    "@typescript-eslint/rule-tester": "8.0.0-alpha.61",
     "ajv": "^6.12.6",
-    "chalk": "^5.3.0",
     "cross-env": "^7.0.3",
     "cross-fetch": "*",
     "eslint": "*",
-    "grapheme-splitter": "^1.0.4",
     "jest": "29.7.0",
     "jest-specific-snapshot": "^8.0.0",
     "json-schema": "*",
@@ -102,8 +96,8 @@
     "unist-util-visit": "^5.0.0"
   },
   "peerDependencies": {
-    "@typescript-eslint/parser": "^7.0.0",
-    "eslint": "^8.57.0"
+    "@typescript-eslint/parser": "^8.0.0 || ^8.0.0-alpha.0",
+    "eslint": "^8.57.0 || ^9.0.0"
   },
   "peerDependenciesMeta": {
     "typescript": {

package/rules.d.ts

@@ -35,12 +35,43 @@ This is likely not portable. A type annotation is necessary. ts(2742)
 ```
 */
 
-import type { RuleModule } from '@typescript-eslint/utils/ts-eslint';
+import type {
+  RuleModuleWithMetaDocs,
+  RuleRecommendation,
+  RuleRecommendationAcrossConfigs,
+} from '@typescript-eslint/utils/ts-eslint';
+
+export interface ESLintPluginDocs {
+  /**
+   * Does the rule extend (or is it based off of) an ESLint code rule?
+   * Alternately accepts the name of the base rule, in case the rule has been renamed.
+   * This is only used for documentation purposes.
+   */
+  extendsBaseRule?: boolean | string;
+
+  /**
+   * If a string config name, which starting config this rule is enabled in.
+   * If an object, which settings it has enabled in each of those configs.
+   */
+  recommended?: RuleRecommendation | RuleRecommendationAcrossConfigs<unknown[]>;
+
+  /**
+   * Does the rule require us to create a full TypeScript Program in order for it
+   * to type-check code. This is only used for documentation purposes.
+   */
+  requiresTypeChecking?: boolean;
+}
+
+export type ESLintPluginRuleModule = RuleModuleWithMetaDocs<
+  string,
+  readonly unknown[],
+  ESLintPluginDocs
+>;
 
 export type TypeScriptESLintRules = Record<
   string,
-  RuleModule<string, unknown[]>
+  RuleModuleWithMetaDocs<string, unknown[], ESLintPluginDocs>
 >;
+
 declare const rules: TypeScriptESLintRules;
-// eslint-disable-next-line import/no-default-export
 export default rules;

package/dist/rules/ban-types.js.map

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

package/dist/rules/no-throw-literal.js

@@ -1,97 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
-    Object.defineProperty(o, "default", { enumerable: true, value: v });
-}) : function(o, v) {
-    o["default"] = v;
-});
-var __importStar = (this && this.__importStar) || function (mod) {
-    if (mod && mod.__esModule) return mod;
-    var result = {};
-    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
-    __setModuleDefault(result, mod);
-    return result;
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-const utils_1 = require("@typescript-eslint/utils");
-const ts = __importStar(require("typescript"));
-const util_1 = require("../util");
-exports.default = (0, util_1.createRule)({
-    name: 'no-throw-literal',
-    meta: {
-        type: 'problem',
-        deprecated: true,
-        replacedBy: ['@typescript-eslint/only-throw-error'],
-        docs: {
-            description: 'Disallow throwing literals as exceptions',
-            extendsBaseRule: true,
-            requiresTypeChecking: true,
-        },
-        schema: [
-            {
-                type: 'object',
-                properties: {
-                    allowThrowingAny: {
-                        type: 'boolean',
-                    },
-                    allowThrowingUnknown: {
-                        type: 'boolean',
-                    },
-                },
-                additionalProperties: false,
-            },
-        ],
-        messages: {
-            object: 'Expected an error object to be thrown.',
-            undef: 'Do not throw undefined.',
-        },
-    },
-    defaultOptions: [
-        {
-            allowThrowingAny: true,
-            allowThrowingUnknown: true,
-        },
-    ],
-    create(context, [options]) {
-        const services = (0, util_1.getParserServices)(context);
-        function checkThrowArgument(node) {
-            if (node.type === utils_1.AST_NODE_TYPES.AwaitExpression ||
-                node.type === utils_1.AST_NODE_TYPES.YieldExpression) {
-                return;
-            }
-            const type = services.getTypeAtLocation(node);
-            if (type.flags & ts.TypeFlags.Undefined) {
-                context.report({ node, messageId: 'undef' });
-                return;
-            }
-            if (options.allowThrowingAny && (0, util_1.isTypeAnyType)(type)) {
-                return;
-            }
-            if (options.allowThrowingUnknown && (0, util_1.isTypeUnknownType)(type)) {
-                return;
-            }
-            if ((0, util_1.isErrorLike)(services.program, type)) {
-                return;
-            }
-            context.report({ node, messageId: 'object' });
-        }
-        return {
-            ThrowStatement(node) {
-                if (node.argument) {
-                    checkThrowArgument(node.argument);
-                }
-            },
-        };
-    },
-});
-//# sourceMappingURL=no-throw-literal.js.map

package/dist/rules/no-throw-literal.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"no-throw-literal.js","sourceRoot":"","sources":["../../src/rules/no-throw-literal.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;AACA,oDAA0D;AAC1D,+CAAiC;AAEjC,kCAMiB;AAWjB,kBAAe,IAAA,iBAAU,EAAsB;IAC7C,IAAI,EAAE,kBAAkB;IACxB,IAAI,EAAE;QACJ,IAAI,EAAE,SAAS;QACf,UAAU,EAAE,IAAI;QAChB,UAAU,EAAE,CAAC,qCAAqC,CAAC;QACnD,IAAI,EAAE;YACJ,WAAW,EAAE,0CAA0C;YACvD,eAAe,EAAE,IAAI;YACrB,oBAAoB,EAAE,IAAI;SAC3B;QACD,MAAM,EAAE;YACN;gBACE,IAAI,EAAE,QAAQ;gBACd,UAAU,EAAE;oBACV,gBAAgB,EAAE;wBAChB,IAAI,EAAE,SAAS;qBAChB;oBACD,oBAAoB,EAAE;wBACpB,IAAI,EAAE,SAAS;qBAChB;iBACF;gBACD,oBAAoB,EAAE,KAAK;aAC5B;SACF;QACD,QAAQ,EAAE;YACR,MAAM,EAAE,wCAAwC;YAChD,KAAK,EAAE,yBAAyB;SACjC;KACF;IACD,cAAc,EAAE;QACd;YACE,gBAAgB,EAAE,IAAI;YACtB,oBAAoB,EAAE,IAAI;SAC3B;KACF;IACD,MAAM,CAAC,OAAO,EAAE,CAAC,OAAO,CAAC;QACvB,MAAM,QAAQ,GAAG,IAAA,wBAAiB,EAAC,OAAO,CAAC,CAAC;QAE5C,SAAS,kBAAkB,CAAC,IAAmB;YAC7C,IACE,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,eAAe;gBAC5C,IAAI,CAAC,IAAI,KAAK,sBAAc,CAAC,eAAe,EAC5C,CAAC;gBACD,OAAO;YACT,CAAC;YAED,MAAM,IAAI,GAAG,QAAQ,CAAC,iBAAiB,CAAC,IAAI,CAAC,CAAC;YAE9C,IAAI,IAAI,CAAC,KAAK,GAAG,EAAE,CAAC,SAAS,CAAC,SAAS,EAAE,CAAC;gBACxC,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,OAAO,EAAE,CAAC,CAAC;gBAC7C,OAAO;YACT,CAAC;YAED,IAAI,OAAO,CAAC,gBAAgB,IAAI,IAAA,oBAAa,EAAC,IAAI,CAAC,EAAE,CAAC;gBACpD,OAAO;YACT,CAAC;YAED,IAAI,OAAO,CAAC,oBAAoB,IAAI,IAAA,wBAAiB,EAAC,IAAI,CAAC,EAAE,CAAC;gBAC5D,OAAO;YACT,CAAC;YAED,IAAI,IAAA,kBAAW,EAAC,QAAQ,CAAC,OAAO,EAAE,IAAI,CAAC,EAAE,CAAC;gBACxC,OAAO;YACT,CAAC;YAED,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,QAAQ,EAAE,CAAC,CAAC;QAChD,CAAC;QAED,OAAO;YACL,cAAc,CAAC,IAAI;gBACjB,IAAI,IAAI,CAAC,QAAQ,EAAE,CAAC;oBAClB,kBAAkB,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;gBACpC,CAAC;YACH,CAAC;SACF,CAAC;IACJ,CAAC;CACF,CAAC,CAAC"}