@codeperfect/eslint-plugin 1.0.0 → 2.1.0

package/dist/domain/testing/aaa/analyzer.super.helpers.d.ts

@@ -0,0 +1,27 @@
+import type * as ESTree from "estree";
+/**
+ * Visits an ESTree node graph while ignoring cycles.
+ * @param node Input node value.
+ * @param callback Input callback value.
+ * @param seenNodes Input seenNodes value.
+ * @example
+ * ```typescript
+ * visitNode(node, () => {});
+ * ```
+ */
+declare function visitNode(node: ESTree.Node, callback: (node: ESTree.Node) => boolean | undefined, seenNodes?: WeakSet<object>): void;
+/**
+ * Visits child values that may contain nested ESTree nodes.
+ * @param value Input value value.
+ * @param callback Input callback value.
+ * @param seenNodes Input seenNodes value.
+ * @example
+ * ```typescript
+ * visitValue(value, () => {}, new WeakSet<object>());
+ * ```
+ */
+declare function visitValue(value: unknown, callback: (node: ESTree.Node) => boolean | undefined, seenNodes: WeakSet<object>): void;
+/** Companion marker for test isolation. */
+declare const analyzerSuperHelpersCompanion: true;
+export { analyzerSuperHelpersCompanion, visitNode, visitValue };
+//# sourceMappingURL=analyzer.super.helpers.d.ts.map

package/dist/domain/testing/aaa/analyzer.super.helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"analyzer.super.helpers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.super.helpers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAyBtC;;;;;;;;;GASG;AACH,iBAAS,SAAS,CAChB,IAAI,EAAE,MAAM,CAAC,IAAI,EACjB,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,KAAK,OAAO,GAAG,SAAS,EACpD,SAAS,kBAAwB,GAChC,IAAI,CAeN;AAED;;;;;;;;;GASG;AACH,iBAAS,UAAU,CACjB,KAAK,EAAE,OAAO,EACd,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,CAAC,IAAI,KAAK,OAAO,GAAG,SAAS,EACpD,SAAS,EAAE,OAAO,CAAC,MAAM,CAAC,GACzB,IAAI,CAcN;AAED,2CAA2C;AAC3C,QAAA,MAAM,6BAA6B,EAAG,IAAa,CAAC;AAEpD,OAAO,EAAE,6BAA6B,EAAE,SAAS,EAAE,UAAU,EAAE,CAAC"}

package/dist/domain/testing/aaa/analyzer.super.helpers.js

@@ -0,0 +1,66 @@
+/**
+ * Checks whether a value is an ESTree node.
+ * @param value The value to test.
+ * @returns `true` when value is an ESTree node, `false` otherwise.
+ * @example
+ * ```typescript
+ * isNode({ type: "Identifier" }); // true
+ * ```
+ */
+function isNode(value) {
+    return (typeof value === "object" &&
+        value !== null &&
+        "type" in value &&
+        typeof value.type === "string");
+}
+/**
+ * Visits an ESTree node graph while ignoring cycles.
+ * @param node Input node value.
+ * @param callback Input callback value.
+ * @param seenNodes Input seenNodes value.
+ * @example
+ * ```typescript
+ * visitNode(node, () => {});
+ * ```
+ */
+function visitNode(node, callback, seenNodes = new WeakSet()) {
+    if (seenNodes.has(node)) {
+        return;
+    }
+    seenNodes.add(node);
+    if (callback(node) === false) {
+        return;
+    }
+    for (const [key, value] of Object.entries(node)) {
+        if (key !== "parent") {
+            visitValue(value, callback, seenNodes);
+        }
+    }
+}
+/**
+ * Visits child values that may contain nested ESTree nodes.
+ * @param value Input value value.
+ * @param callback Input callback value.
+ * @param seenNodes Input seenNodes value.
+ * @example
+ * ```typescript
+ * visitValue(value, () => {}, new WeakSet<object>());
+ * ```
+ */
+function visitValue(value, callback, seenNodes) {
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            if (isNode(item)) {
+                visitNode(item, callback, seenNodes);
+            }
+        }
+        return;
+    }
+    if (isNode(value)) {
+        visitNode(value, callback, seenNodes);
+    }
+}
+/** Companion marker for test isolation. */
+const analyzerSuperHelpersCompanion = true;
+export { analyzerSuperHelpersCompanion, visitNode, visitValue };
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/testing/aaa/analyzer.super.js

@@ -0,0 +1,211 @@
+import { visitNode as visitNodeImplementation } from "./analyzer.super.helpers.js";
+/**
+ * Creates a local forwarding function for an imported analyzer helper.
+ * @template TParameters Forwarded parameter tuple.
+ * @template TResult Forwarded return type.
+ * @param implementation Imported helper implementation.
+ * @returns Local function that forwards all arguments to the implementation.
+ * @example
+ * ```typescript
+ * const localHelper = forward(implementation);
+ * ```
+ */
+function forward(implementation) {
+    return (...parameters) => implementation(...parameters);
+}
+/** Visits an ESTree node graph while ignoring cycles. */
+const visitNode = forward(visitNodeImplementation);
+/** Array mutator methods that imply observable state changes. */
+const arrayMutationMethods = new Set([
+    "copyWithin",
+    "fill",
+    "pop",
+    "push",
+    "reverse",
+    "shift",
+    "sort",
+    "splice",
+    "unshift",
+]);
+/** Names that usually signal Arrange-oriented helper calls. */
+const setupLikeNames = /^(?:arrange|build|create|fixture|get|given|make|mock|parse|seed|setup|spy|stub|write)/u;
+/** Call names that should be treated as utility operations instead of Act steps. */
+const utilityMethodNames = new Set([
+    "advanceTimersByTime",
+    "clearAllMocks",
+    "debug",
+    "fn",
+    "info",
+    "join",
+    "log",
+    "mockImplementation",
+    "mockRejectedValue",
+    "mockResolvedValue",
+    "mockReturnValue",
+    "push",
+    "resetAllMocks",
+    "resolve",
+    "useFakeTimers",
+    "warn",
+]);
+/** Method names that usually behave like void side-effect helpers. */
+const voidLikeMethodNames = new Set([
+    "clear",
+    "debug",
+    "dispatch",
+    "emit",
+    "flush",
+    "info",
+    "log",
+    "print",
+    "publish",
+    "reset",
+    "set",
+    "trigger",
+    "warn",
+]);
+/**
+ * Gets an expression name when it can be resolved statically.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getExpressionName(expression);
+ * ```
+ */
+function getExpressionName(expression) {
+    if (expression.type === "Super") {
+        return void 0;
+    }
+    if (expression.type === "Identifier") {
+        return expression.name;
+    }
+    if (expression.type === "MemberExpression" &&
+        expression.property.type === "Identifier") {
+        return expression.property.name;
+    }
+    return void 0;
+}
+/**
+ * Gets a callee name for a call or construction expression.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getInvokedName(expression);
+ * ```
+ */
+function getInvokedName(expression) {
+    return getExpressionName(expression.callee);
+}
+/**
+ * Splits an identifier into lowercase word tokens.
+ * @param identifier Input identifier value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * getNameWords("scheduleAndFlush");
+ * ```
+ */
+function getNameWords(identifier) {
+    return identifier
+        .split(/(?=[A-Z])|[_-]/u)
+        .map((segment) => segment.toLowerCase())
+        .filter((segment) => segment.length > 0);
+}
+/**
+ * Checks whether an expression is callable.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isCallableExpression(expression);
+ * ```
+ */
+function isCallableExpression(expression) {
+    return (expression?.type === "CallExpression" ||
+        expression?.type === "NewExpression");
+}
+/**
+ * Checks whether a comment has location metadata.
+ * @param comment Input comment value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isLocatedComment(comment);
+ * ```
+ */
+function isLocatedComment(comment) {
+    return (comment.loc !== null && comment.loc !== void 0 && comment.range !== void 0);
+}
+/**
+ * Checks whether a range is fully contained within another range.
+ * @param range Input range value.
+ * @param container Input container value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isRangeWithin(range, container);
+ * ```
+ */
+function isRangeWithin(range, container) {
+    return range[0] >= container[0] && range[1] <= container[1];
+}
+/**
+ * Checks whether a constructor call should be treated as setup.
+ * @param expression Input expression value.
+ * @param calleeName Input calleeName value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isUtilityConstructor(expression, "Map");
+ * ```
+ */
+function isUtilityConstructor(expression, calleeName) {
+    return (expression.type === "NewExpression" &&
+        (calleeName === "Error" ||
+            calleeName === "Map" ||
+            calleeName === "Set" ||
+            calleeName === "SourceCode" ||
+            calleeName === "ESLint"));
+}
+/**
+ * Checks whether a callee name looks utility-like.
+ * @param calleeName Input calleeName value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isUtilityNamedCall("setupFixture");
+ * ```
+ */
+function isUtilityNamedCall(calleeName) {
+    return utilityMethodNames.has(calleeName) || setupLikeNames.test(calleeName);
+}
+/**
+ * Checks whether a call uses a utility namespace.
+ * @param expression Input expression value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isUtilityNamespaceCall(expression);
+ * ```
+ */
+function isUtilityNamespaceCall(expression) {
+    return (expression.callee.type === "MemberExpression" &&
+        expression.callee.object.type === "Identifier" &&
+        ["console", "vi"].includes(expression.callee.object.name));
+}
+/**
+ * Checks whether a call name is built from void-like verb tokens.
+ * @param calleeName Input calleeName value.
+ * @returns Return value output.
+ * @example
+ * ```typescript
+ * isVoidLikeMethodName("scheduleAndFlush");
+ * ```
+ */
+function isVoidLikeMethodName(calleeName) {
+    return getNameWords(calleeName).some((word) => voidLikeMethodNames.has(word));
+}
+export { arrayMutationMethods, getExpressionName, getInvokedName, isCallableExpression, isLocatedComment, isRangeWithin, isUtilityConstructor, isUtilityNamedCall, isUtilityNamespaceCall, isVoidLikeMethodName, setupLikeNames, utilityMethodNames, visitNode, voidLikeMethodNames, };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"analyzer.super.js","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/analyzer.super.ts"],"names":[],"mappings":"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","sourcesContent":["import type * as ESTree from \"estree\";\r\n\r\nimport type { LocatedComment, SourceComment } from \"./types\";\r\n\r\nimport { visitNode as visitNodeImplementation } from \"./analyzer.super.helpers\";\r\n\r\n/**\r\n * Creates a local forwarding function for an imported analyzer helper.\r\n * @template TParameters Forwarded parameter tuple.\r\n * @template TResult Forwarded return type.\r\n * @param implementation Imported helper implementation.\r\n * @returns Local function that forwards all arguments to the implementation.\r\n * @example\r\n * ```typescript\r\n * const localHelper = forward(implementation);\r\n * ```\r\n */\r\nfunction forward<TParameters extends unknown[], TResult>(\r\n  implementation: (...parameters: TParameters) => TResult,\r\n): (...parameters: TParameters) => TResult {\r\n  return (...parameters) => implementation(...parameters);\r\n}\r\n\r\n/** Visits an ESTree node graph while ignoring cycles. */\r\nconst visitNode = forward(visitNodeImplementation);\r\n\r\n/** Array mutator methods that imply observable state changes. */\r\nconst arrayMutationMethods = new Set([\r\n  \"copyWithin\",\r\n  \"fill\",\r\n  \"pop\",\r\n  \"push\",\r\n  \"reverse\",\r\n  \"shift\",\r\n  \"sort\",\r\n  \"splice\",\r\n  \"unshift\",\r\n]);\r\n\r\n/** Names that usually signal Arrange-oriented helper calls. */\r\nconst setupLikeNames =\r\n  /^(?:arrange|build|create|fixture|get|given|make|mock|parse|seed|setup|spy|stub|write)/u;\r\n\r\n/** Call names that should be treated as utility operations instead of Act steps. */\r\nconst utilityMethodNames = new Set([\r\n  \"advanceTimersByTime\",\r\n  \"clearAllMocks\",\r\n  \"debug\",\r\n  \"fn\",\r\n  \"info\",\r\n  \"join\",\r\n  \"log\",\r\n  \"mockImplementation\",\r\n  \"mockRejectedValue\",\r\n  \"mockResolvedValue\",\r\n  \"mockReturnValue\",\r\n  \"push\",\r\n  \"resetAllMocks\",\r\n  \"resolve\",\r\n  \"useFakeTimers\",\r\n  \"warn\",\r\n]);\r\n\r\n/** Method names that usually behave like void side-effect helpers. */\r\nconst voidLikeMethodNames = new Set([\r\n  \"clear\",\r\n  \"debug\",\r\n  \"dispatch\",\r\n  \"emit\",\r\n  \"flush\",\r\n  \"info\",\r\n  \"log\",\r\n  \"print\",\r\n  \"publish\",\r\n  \"reset\",\r\n  \"set\",\r\n  \"trigger\",\r\n  \"warn\",\r\n]);\r\n\r\n/**\r\n * Gets an expression name when it can be resolved statically.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getExpressionName(expression);\r\n * ```\r\n */\r\nfunction getExpressionName(\r\n  expression: ESTree.Expression | ESTree.PrivateIdentifier | ESTree.Super,\r\n): string | undefined {\r\n  if (expression.type === \"Super\") {\r\n    return void 0;\r\n  }\r\n\r\n  if (expression.type === \"Identifier\") {\r\n    return expression.name;\r\n  }\r\n\r\n  if (\r\n    expression.type === \"MemberExpression\" &&\r\n    expression.property.type === \"Identifier\"\r\n  ) {\r\n    return expression.property.name;\r\n  }\r\n\r\n  return void 0;\r\n}\r\n\r\n/**\r\n * Gets a callee name for a call or construction expression.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getInvokedName(expression);\r\n * ```\r\n */\r\nfunction getInvokedName(\r\n  expression: ESTree.CallExpression | ESTree.NewExpression,\r\n): string | undefined {\r\n  return getExpressionName(expression.callee);\r\n}\r\n\r\n/**\r\n * Splits an identifier into lowercase word tokens.\r\n * @param identifier Input identifier value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * getNameWords(\"scheduleAndFlush\");\r\n * ```\r\n */\r\nfunction getNameWords(identifier: string): string[] {\r\n  return identifier\r\n    .split(/(?=[A-Z])|[_-]/u)\r\n    .map((segment) => segment.toLowerCase())\r\n    .filter((segment) => segment.length > 0);\r\n}\r\n\r\n/**\r\n * Checks whether an expression is callable.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isCallableExpression(expression);\r\n * ```\r\n */\r\nfunction isCallableExpression(\r\n  expression: ESTree.Expression | undefined,\r\n): expression is ESTree.CallExpression | ESTree.NewExpression {\r\n  return (\r\n    expression?.type === \"CallExpression\" ||\r\n    expression?.type === \"NewExpression\"\r\n  );\r\n}\r\n\r\n/**\r\n * Checks whether a comment has location metadata.\r\n * @param comment Input comment value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isLocatedComment(comment);\r\n * ```\r\n */\r\nfunction isLocatedComment(comment: SourceComment): comment is LocatedComment {\r\n  return (\r\n    comment.loc !== null && comment.loc !== void 0 && comment.range !== void 0\r\n  );\r\n}\r\n\r\n/**\r\n * Checks whether a range is fully contained within another range.\r\n * @param range Input range value.\r\n * @param container Input container value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isRangeWithin(range, container);\r\n * ```\r\n */\r\nfunction isRangeWithin(\r\n  range: [number, number],\r\n  container: [number, number],\r\n): boolean {\r\n  return range[0] >= container[0] && range[1] <= container[1];\r\n}\r\n\r\n/**\r\n * Checks whether a constructor call should be treated as setup.\r\n * @param expression Input expression value.\r\n * @param calleeName Input calleeName value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isUtilityConstructor(expression, \"Map\");\r\n * ```\r\n */\r\nfunction isUtilityConstructor(\r\n  expression: ESTree.CallExpression | ESTree.NewExpression,\r\n  calleeName: string,\r\n): boolean {\r\n  return (\r\n    expression.type === \"NewExpression\" &&\r\n    (calleeName === \"Error\" ||\r\n      calleeName === \"Map\" ||\r\n      calleeName === \"Set\" ||\r\n      calleeName === \"SourceCode\" ||\r\n      calleeName === \"ESLint\")\r\n  );\r\n}\r\n\r\n/**\r\n * Checks whether a callee name looks utility-like.\r\n * @param calleeName Input calleeName value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isUtilityNamedCall(\"setupFixture\");\r\n * ```\r\n */\r\nfunction isUtilityNamedCall(calleeName: string): boolean {\r\n  return utilityMethodNames.has(calleeName) || setupLikeNames.test(calleeName);\r\n}\r\n\r\n/**\r\n * Checks whether a call uses a utility namespace.\r\n * @param expression Input expression value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isUtilityNamespaceCall(expression);\r\n * ```\r\n */\r\nfunction isUtilityNamespaceCall(\r\n  expression: ESTree.CallExpression | ESTree.NewExpression,\r\n): boolean {\r\n  return (\r\n    expression.callee.type === \"MemberExpression\" &&\r\n    expression.callee.object.type === \"Identifier\" &&\r\n    [\"console\", \"vi\"].includes(expression.callee.object.name)\r\n  );\r\n}\r\n\r\n/**\r\n * Checks whether a call name is built from void-like verb tokens.\r\n * @param calleeName Input calleeName value.\r\n * @returns Return value output.\r\n * @example\r\n * ```typescript\r\n * isVoidLikeMethodName(\"scheduleAndFlush\");\r\n * ```\r\n */\r\nfunction isVoidLikeMethodName(calleeName: string): boolean {\r\n  return getNameWords(calleeName).some((word) => voidLikeMethodNames.has(word));\r\n}\r\n\r\nexport {\r\n  arrayMutationMethods,\r\n  getExpressionName,\r\n  getInvokedName,\r\n  isCallableExpression,\r\n  isLocatedComment,\r\n  isRangeWithin,\r\n  isUtilityConstructor,\r\n  isUtilityNamedCall,\r\n  isUtilityNamespaceCall,\r\n  isVoidLikeMethodName,\r\n  setupLikeNames,\r\n  utilityMethodNames,\r\n  visitNode,\r\n  voidLikeMethodNames,\r\n};\r\n"]}

package/dist/{testing → domain/testing}/aaa/index.d.ts

@@ -1,3 +1,3 @@
-export { aaaPhaseOrder, analyzeTestBlock, countActStatements, getAssertDeclaredIdentifiers, getAssertionIdentifiers, getFlattenedSections, getIndentationAtOffset, getLineStartRange, getPhaseBoundaryComments, getSectionPhases, hasAssertion, hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, usesPrefix, } from "./analyzer";
-export type { AaaPhase, LocatedComment, LocatedNode, SectionComment, SourceComment, StatementPhase, TestBlockAnalysis, } from "./types";
+export { aaaPhaseOrder, analyzeTestBlock, countActStatements, getAssertDeclaredIdentifiers, getAssertionIdentifiers, getFlattenedSections, getIndentationAtOffset, getLineStartRange, getPhaseBoundaryComments, getSectionPhases, hasAssertion, hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, usesPrefix, } from "./analyzer.js";
+export type { AaaPhase, LocatedComment, LocatedNode, SectionComment, SourceComment, StatementPhase, TestBlockAnalysis, } from "./types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/domain/testing/aaa/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,aAAa,EACb,gBAAgB,EAChB,kBAAkB,EAClB,4BAA4B,EAC5B,uBAAuB,EACvB,oBAAoB,EACpB,sBAAsB,EACtB,iBAAiB,EACjB,wBAAwB,EACxB,gBAAgB,EAChB,YAAY,EACZ,aAAa,EACb,QAAQ,EACR,yBAAyB,EACzB,sBAAsB,EACtB,WAAW,EACX,wBAAwB,EACxB,oBAAoB,EACpB,sBAAsB,EACtB,UAAU,GACX,MAAM,YAAY,CAAC;AACpB,YAAY,EACV,QAAQ,EACR,cAAc,EACd,WAAW,EACX,cAAc,EACd,aAAa,EACb,cAAc,EACd,iBAAiB,GAClB,MAAM,SAAS,CAAC"}

package/dist/domain/testing/aaa/index.js

@@ -0,0 +1,2 @@
+export { aaaPhaseOrder, analyzeTestBlock, countActStatements, getAssertDeclaredIdentifiers, getAssertionIdentifiers, getFlattenedSections, getIndentationAtOffset, getLineStartRange, getPhaseBoundaryComments, getSectionPhases, hasAssertion, hasAsyncLogic, hasAwait, hasBlankLineBeforeComment, hasCapturableActResult, hasMutation, isMeaningfulActStatement, isSetupLikeStatement, isValidAssertStatement, usesPrefix, } from "./analyzer.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvYWFhL2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFDTCxhQUFhLEVBQ2IsZ0JBQWdCLEVBQ2hCLGtCQUFrQixFQUNsQiw0QkFBNEIsRUFDNUIsdUJBQXVCLEVBQ3ZCLG9CQUFvQixFQUNwQixzQkFBc0IsRUFDdEIsaUJBQWlCLEVBQ2pCLHdCQUF3QixFQUN4QixnQkFBZ0IsRUFDaEIsWUFBWSxFQUNaLGFBQWEsRUFDYixRQUFRLEVBQ1IseUJBQXlCLEVBQ3pCLHNCQUFzQixFQUN0QixXQUFXLEVBQ1gsd0JBQXdCLEVBQ3hCLG9CQUFvQixFQUNwQixzQkFBc0IsRUFDdEIsVUFBVSxHQUNYLE1BQU0sWUFBWSxDQUFDIiwic291cmNlc0NvbnRlbnQiOlsiZXhwb3J0IHtcbiAgYWFhUGhhc2VPcmRlcixcbiAgYW5hbHl6ZVRlc3RCbG9jayxcbiAgY291bnRBY3RTdGF0ZW1lbnRzLFxuICBnZXRBc3NlcnREZWNsYXJlZElkZW50aWZpZXJzLFxuICBnZXRBc3NlcnRpb25JZGVudGlmaWVycyxcbiAgZ2V0RmxhdHRlbmVkU2VjdGlvbnMsXG4gIGdldEluZGVudGF0aW9uQXRPZmZzZXQsXG4gIGdldExpbmVTdGFydFJhbmdlLFxuICBnZXRQaGFzZUJvdW5kYXJ5Q29tbWVudHMsXG4gIGdldFNlY3Rpb25QaGFzZXMsXG4gIGhhc0Fzc2VydGlvbixcbiAgaGFzQXN5bmNMb2dpYyxcbiAgaGFzQXdhaXQsXG4gIGhhc0JsYW5rTGluZUJlZm9yZUNvbW1lbnQsXG4gIGhhc0NhcHR1cmFibGVBY3RSZXN1bHQsXG4gIGhhc011dGF0aW9uLFxuICBpc01lYW5pbmdmdWxBY3RTdGF0ZW1lbnQsXG4gIGlzU2V0dXBMaWtlU3RhdGVtZW50LFxuICBpc1ZhbGlkQXNzZXJ0U3RhdGVtZW50LFxuICB1c2VzUHJlZml4LFxufSBmcm9tIFwiLi9hbmFseXplclwiO1xuZXhwb3J0IHR5cGUge1xuICBBYWFQaGFzZSxcbiAgTG9jYXRlZENvbW1lbnQsXG4gIExvY2F0ZWROb2RlLFxuICBTZWN0aW9uQ29tbWVudCxcbiAgU291cmNlQ29tbWVudCxcbiAgU3RhdGVtZW50UGhhc2UsXG4gIFRlc3RCbG9ja0FuYWx5c2lzLFxufSBmcm9tIFwiLi90eXBlc1wiO1xuIl19

package/dist/domain/testing/aaa/types.d.ts

@@ -0,0 +1,58 @@
+import type { Rule } from "eslint";
+import type * as ESTree from "estree";
+/** Named AAA phases recognized by the analyzer. */
+type AaaPhase = "Act" | "Arrange" | "Assert";
+/** Source comment with guaranteed location and range metadata. */
+type LocatedComment = SourceComment & {
+    /** Normalized location for the comment. */
+    loc: NonNullable<SourceComment["loc"]>;
+    /** Inclusive source range for the comment. */
+    range: [number, number];
+};
+/**
+ * ESTree node with required location and range metadata.
+ * @template TNode Node subtype carried by the wrapper.
+ */
+type LocatedNode<TNode extends ESTree.Node = ESTree.Node> = TNode & {
+    /** Normalized location for the node. */
+    loc: NonNullable<ESTree.Node["loc"]>;
+    /** Inclusive source range for the node. */
+    range: [number, number];
+};
+/** Section comment and the AAA phases it declares. */
+interface SectionComment {
+    /** Located line comment used as the section marker. */
+    comment: LocatedComment;
+    /** Phases declared by the section marker. */
+    phases: AaaPhase[];
+}
+/** Raw source comment nodes returned by ESLint. */
+type SourceComment = ReturnType<Rule.RuleContext["sourceCode"]["getAllComments"]>[number];
+/** Statement annotated with its active AAA phases. */
+interface StatementPhase {
+    /** Statement node that belongs to the analyzed test body. */
+    node: LocatedNode<ESTree.Statement>;
+    /** Last active phase before this statement, when any exists. */
+    phase: AaaPhase | undefined;
+    /** All active phases inherited from the nearest section marker. */
+    phases: AaaPhase[];
+}
+/** Derived metadata for a supported test callback. */
+interface TestBlockAnalysis {
+    /** Block body belonging to the test callback. */
+    body: LocatedNode<ESTree.BlockStatement>;
+    /** Number of lines inside the callback body. */
+    bodyLineCount: number;
+    /** Original call expression for `it` or `test`. */
+    callExpression: LocatedNode<ESTree.CallExpression>;
+    /** Newline style used by the source text. */
+    newline: "\n" | "\r\n";
+    /** Ordered AAA section comments within the callback body. */
+    sectionComments: SectionComment[];
+    /** Full source text for the analyzed file. */
+    sourceText: string;
+    /** Statements paired with their resolved AAA phases. */
+    statements: StatementPhase[];
+}
+export type { AaaPhase, LocatedComment, LocatedNode, SectionComment, SourceComment, StatementPhase, TestBlockAnalysis, };
+//# sourceMappingURL=types.d.ts.map

package/dist/domain/testing/aaa/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/aaa/types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AACnC,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AAEtC,mDAAmD;AACnD,KAAK,QAAQ,GAAG,KAAK,GAAG,SAAS,GAAG,QAAQ,CAAC;AAE7C,kEAAkE;AAClE,KAAK,cAAc,GAAG,aAAa,GAAG;IACpC,2CAA2C;IAC3C,GAAG,EAAE,WAAW,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC,CAAC;IAEvC,8CAA8C;IAC9C,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzB,CAAC;AAEF;;;GAGG;AACH,KAAK,WAAW,CAAC,KAAK,SAAS,MAAM,CAAC,IAAI,GAAG,MAAM,CAAC,IAAI,IAAI,KAAK,GAAG;IAClE,wCAAwC;IACxC,GAAG,EAAE,WAAW,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC;IAErC,2CAA2C;IAC3C,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;CACzB,CAAC;AAEF,sDAAsD;AACtD,UAAU,cAAc;IACtB,uDAAuD;IACvD,OAAO,EAAE,cAAc,CAAC;IAExB,6CAA6C;IAC7C,MAAM,EAAE,QAAQ,EAAE,CAAC;CACpB;AAED,mDAAmD;AACnD,KAAK,aAAa,GAAG,UAAU,CAC7B,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC,CAAC,gBAAgB,CAAC,CACjD,CAAC,MAAM,CAAC,CAAC;AAEV,sDAAsD;AACtD,UAAU,cAAc;IACtB,6DAA6D;IAC7D,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,SAAS,CAAC,CAAC;IAEpC,gEAAgE;IAChE,KAAK,EAAE,QAAQ,GAAG,SAAS,CAAC;IAE5B,mEAAmE;IACnE,MAAM,EAAE,QAAQ,EAAE,CAAC;CACpB;AAED,sDAAsD;AACtD,UAAU,iBAAiB;IACzB,iDAAiD;IACjD,IAAI,EAAE,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;IAEzC,gDAAgD;IAChD,aAAa,EAAE,MAAM,CAAC;IAEtB,mDAAmD;IACnD,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,cAAc,CAAC,CAAC;IAEnD,6CAA6C;IAC7C,OAAO,EAAE,IAAI,GAAG,MAAM,CAAC;IAEvB,6DAA6D;IAC7D,eAAe,EAAE,cAAc,EAAE,CAAC;IAElC,8CAA8C;IAC9C,UAAU,EAAE,MAAM,CAAC;IAEnB,wDAAwD;IACxD,UAAU,EAAE,cAAc,EAAE,CAAC;CAC9B;AAED,YAAY,EACV,QAAQ,EACR,cAAc,EACd,WAAW,EACX,cAAc,EACd,aAAa,EACb,cAAc,EACd,iBAAiB,GAClB,CAAC"}

package/dist/domain/testing/aaa/types.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/domain/testing/assert-actual-expected-names/index.d.ts

@@ -0,0 +1,2 @@
+export { assertActualExpectedNamesRule } from "./rule.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/testing/assert-actual-expected-names/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/assert-actual-expected-names/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,6BAA6B,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/testing/assert-actual-expected-names/index.js

@@ -0,0 +1,2 @@
+export { assertActualExpectedNamesRule } from "./rule.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvYXNzZXJ0LWFjdHVhbC1leHBlY3RlZC1uYW1lcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFBQSxPQUFPLEVBQUUsNkJBQTZCLEVBQUUsTUFBTSxRQUFRLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJleHBvcnQgeyBhc3NlcnRBY3R1YWxFeHBlY3RlZE5hbWVzUnVsZSB9IGZyb20gXCIuL3J1bGVcIjtcbiJdfQ==

package/dist/{testing → domain/testing}/assert-actual-expected-names/rule.d.ts

@@ -1,4 +1,5 @@
 import type { Rule } from "eslint";
+/** Enforces actual/expected-style prefixes for assert-phase comparison variables. */
 declare const assertActualExpectedNamesRule: Rule.RuleModule;
 export { assertActualExpectedNamesRule };
 //# sourceMappingURL=rule.d.ts.map

package/dist/domain/testing/assert-actual-expected-names/rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rule.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/assert-actual-expected-names/rule.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,MAAM,QAAQ,CAAC;AAqInC,qFAAqF;AACrF,QAAA,MAAM,6BAA6B,EAAE,IAAI,CAAC,UA0CzC,CAAC;AAEF,OAAO,EAAE,6BAA6B,EAAE,CAAC"}

package/dist/domain/testing/assert-actual-expected-names/rule.js

@@ -0,0 +1,116 @@
+import { analyzeTestBlock, getAssertDeclaredIdentifiers, getAssertionIdentifiers, hasAssertion, usesPrefix, } from "../aaa/index.js";
+/**
+ * Builds the de-duplication key for a reported assertion identifier.
+ * @param prefix Prefix used for the assertion identifier.
+ * @param name Identifier name reported by the rule.
+ * @returns Stable de-duplication key for the identifier.
+ * @example
+ * ```typescript
+ * const key = getReportedNameKey("actual", "value");
+ * ```
+ */
+const getReportedNameKey = (prefix, name) => `${prefix}:${name}`;
+/**
+ * Reports a missing assertion prefix when the declared identifier is eligible.
+ * @param input Composite reporting input for one identifier.
+ * @example
+ * ```typescript
+ * reportAssertionIdentifier({
+ *   context: {} as Rule.RuleContext,
+ *   declaredIdentifiers: new Map(),
+ *   name: "value",
+ *   prefix: "actual",
+ *   reportedNames: new Set(),
+ * });
+ * ```
+ */
+const reportAssertionIdentifier = (input) => {
+    const { context, declaredIdentifiers, name, prefix, reportedNames } = input;
+    const declaredIdentifier = name === void 0 || usesPrefix(name, prefix)
+        ? void 0
+        : declaredIdentifiers.get(name);
+    if (declaredIdentifier === void 0 || name === void 0) {
+        return;
+    }
+    const reportedNameKey = getReportedNameKey(prefix, name);
+    if (reportedNames.has(reportedNameKey)) {
+        return;
+    }
+    reportedNames.add(reportedNameKey);
+    context.report({
+        data: { name, prefix },
+        messageId: "missingPrefix",
+        node: declaredIdentifier,
+    });
+};
+/**
+ * Reports missing prefixes for the actual and expected identifiers in one assertion.
+ * @param input Composite reporting input for one assertion.
+ * @example
+ * ```typescript
+ * reportAssertionPrefixes({
+ *   assertionNode: {} as ESTree.Statement,
+ *   context: {} as Rule.RuleContext,
+ *   declaredIdentifiers: new Map(),
+ *   reportedNames: new Set(),
+ * });
+ * ```
+ */
+const reportAssertionPrefixes = (input) => {
+    const { assertionNode, context, declaredIdentifiers, reportedNames } = input;
+    const { actual, expected } = getAssertionIdentifiers(assertionNode);
+    reportAssertionIdentifier({
+        context,
+        declaredIdentifiers,
+        name: actual,
+        prefix: "actual",
+        reportedNames,
+    });
+    reportAssertionIdentifier({
+        context,
+        declaredIdentifiers,
+        name: expected,
+        prefix: "expected",
+        reportedNames,
+    });
+};
+/** Enforces actual/expected-style prefixes for assert-phase comparison variables. */
+const assertActualExpectedNamesRule = {
+    create(context) {
+        return {
+            CallExpression(node) {
+                const analysis = analyzeTestBlock(context, node);
+                if (analysis === void 0) {
+                    return;
+                }
+                const declaredIdentifiers = getAssertDeclaredIdentifiers(analysis);
+                const reportedNames = new Set();
+                for (const statement of analysis.statements) {
+                    if (statement.phases.includes("Assert") &&
+                        hasAssertion(statement.node)) {
+                        reportAssertionPrefixes({
+                            assertionNode: statement.node,
+                            context,
+                            declaredIdentifiers,
+                            reportedNames,
+                        });
+                    }
+                }
+            },
+        };
+    },
+    meta: {
+        docs: {
+            description: "Require Assert-phase comparison variables to use actual*/expected* prefixes.",
+            recommended: false,
+            url: "https://github.com/parloti/eslint-plugin/blob/main/docs/rules/assert-actual-expected-names.md",
+        },
+        messages: {
+            missingPrefix: "Rename '{{name}}' to use the '{{prefix}}' prefix when comparing values inside // Assert.",
+        },
+        schema: [],
+        type: "suggestion",
+    },
+};
+export { assertActualExpectedNamesRule };
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"rule.js","sourceRoot":"","sources":["../../../../src/domain/testing/assert-actual-expected-names/rule.ts"],"names":[],"mappings":"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","sourcesContent":["import type { Rule } from \"eslint\";\nimport type * as ESTree from \"estree\";\n\nimport {\n  analyzeTestBlock,\n  getAssertDeclaredIdentifiers,\n  getAssertionIdentifiers,\n  hasAssertion,\n  usesPrefix,\n} from \"../aaa\";\n\n/** Supported assertion variable prefixes enforced by this rule. */\ntype AssertionPrefix = \"actual\" | \"expected\";\n\n/** Composite input for reporting one missing assertion prefix. */\ninterface ReportAssertionIdentifierInput {\n  /** Active ESLint rule context. */\n  context: Rule.RuleContext;\n\n  /** Declared identifiers collected from the assert phase. */\n  declaredIdentifiers: ReturnType<typeof getAssertDeclaredIdentifiers>;\n\n  /** Identifier name extracted from the assertion. */\n  name: string | undefined;\n\n  /** Required prefix for the identifier. */\n  prefix: AssertionPrefix;\n\n  /** Set of already reported identifier keys. */\n  reportedNames: Set<string>;\n}\n\n/** Composite input for reporting missing prefixes in one assertion. */\ninterface ReportAssertionPrefixesInput {\n  /** Assertion node whose identifiers should be inspected. */\n  assertionNode: ESTree.Statement;\n\n  /** Active ESLint rule context. */\n  context: Rule.RuleContext;\n\n  /** Declared identifiers collected from the assert phase. */\n  declaredIdentifiers: ReturnType<typeof getAssertDeclaredIdentifiers>;\n\n  /** Set of already reported identifier keys. */\n  reportedNames: Set<string>;\n}\n\n/**\n * Builds the de-duplication key for a reported assertion identifier.\n * @param prefix Prefix used for the assertion identifier.\n * @param name Identifier name reported by the rule.\n * @returns Stable de-duplication key for the identifier.\n * @example\n * ```typescript\n * const key = getReportedNameKey(\"actual\", \"value\");\n * ```\n */\nconst getReportedNameKey = (prefix: AssertionPrefix, name: string): string =>\n  `${prefix}:${name}`;\n\n/**\n * Reports a missing assertion prefix when the declared identifier is eligible.\n * @param input Composite reporting input for one identifier.\n * @example\n * ```typescript\n * reportAssertionIdentifier({\n *   context: {} as Rule.RuleContext,\n *   declaredIdentifiers: new Map(),\n *   name: \"value\",\n *   prefix: \"actual\",\n *   reportedNames: new Set(),\n * });\n * ```\n */\nconst reportAssertionIdentifier = (\n  input: ReportAssertionIdentifierInput,\n): void => {\n  const { context, declaredIdentifiers, name, prefix, reportedNames } = input;\n\n  const declaredIdentifier =\n    name === void 0 || usesPrefix(name, prefix)\n      ? void 0\n      : declaredIdentifiers.get(name);\n  if (declaredIdentifier === void 0 || name === void 0) {\n    return;\n  }\n\n  const reportedNameKey = getReportedNameKey(prefix, name);\n  if (reportedNames.has(reportedNameKey)) {\n    return;\n  }\n\n  reportedNames.add(reportedNameKey);\n  context.report({\n    data: { name, prefix },\n    messageId: \"missingPrefix\",\n    node: declaredIdentifier,\n  });\n};\n\n/**\n * Reports missing prefixes for the actual and expected identifiers in one assertion.\n * @param input Composite reporting input for one assertion.\n * @example\n * ```typescript\n * reportAssertionPrefixes({\n *   assertionNode: {} as ESTree.Statement,\n *   context: {} as Rule.RuleContext,\n *   declaredIdentifiers: new Map(),\n *   reportedNames: new Set(),\n * });\n * ```\n */\nconst reportAssertionPrefixes = (input: ReportAssertionPrefixesInput): void => {\n  const { assertionNode, context, declaredIdentifiers, reportedNames } = input;\n  const { actual, expected } = getAssertionIdentifiers(assertionNode);\n\n  reportAssertionIdentifier({\n    context,\n    declaredIdentifiers,\n    name: actual,\n    prefix: \"actual\",\n    reportedNames,\n  });\n  reportAssertionIdentifier({\n    context,\n    declaredIdentifiers,\n    name: expected,\n    prefix: \"expected\",\n    reportedNames,\n  });\n};\n\n/** Enforces actual/expected-style prefixes for assert-phase comparison variables. */\nconst assertActualExpectedNamesRule: Rule.RuleModule = {\n  create(context: Rule.RuleContext): Rule.RuleListener {\n    return {\n      CallExpression(node): void {\n        const analysis = analyzeTestBlock(context, node);\n        if (analysis === void 0) {\n          return;\n        }\n\n        const declaredIdentifiers = getAssertDeclaredIdentifiers(analysis);\n        const reportedNames = new Set<string>();\n\n        for (const statement of analysis.statements) {\n          if (\n            statement.phases.includes(\"Assert\") &&\n            hasAssertion(statement.node)\n          ) {\n            reportAssertionPrefixes({\n              assertionNode: statement.node,\n              context,\n              declaredIdentifiers,\n              reportedNames,\n            });\n          }\n        }\n      },\n    } satisfies Rule.RuleListener;\n  },\n  meta: {\n    docs: {\n      description:\n        \"Require Assert-phase comparison variables to use actual*/expected* prefixes.\",\n      recommended: false,\n      url: \"https://github.com/parloti/eslint-plugin/blob/main/docs/rules/assert-actual-expected-names.md\",\n    },\n    messages: {\n      missingPrefix:\n        \"Rename '{{name}}' to use the '{{prefix}}' prefix when comparing values inside // Assert.\",\n    },\n    schema: [],\n    type: \"suggestion\",\n  },\n};\n\nexport { assertActualExpectedNamesRule };\n"]}

package/dist/domain/testing/enforce-aaa-phase-purity/index.d.ts

@@ -0,0 +1,2 @@
+export { enforceAaaPhasePurityRule } from "./rule.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/domain/testing/enforce-aaa-phase-purity/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,yBAAyB,EAAE,MAAM,QAAQ,CAAC"}

package/dist/domain/testing/enforce-aaa-phase-purity/index.js

@@ -0,0 +1,2 @@
+export { enforceAaaPhasePurityRule } from "./rule.js";
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi9zcmMvZG9tYWluL3Rlc3RpbmcvZW5mb3JjZS1hYWEtcGhhc2UtcHVyaXR5L2luZGV4LnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBRSx5QkFBeUIsRUFBRSxNQUFNLFFBQVEsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCB7IGVuZm9yY2VBYWFQaGFzZVB1cml0eVJ1bGUgfSBmcm9tIFwiLi9ydWxlXCI7XG4iXX0=

package/dist/domain/testing/enforce-aaa-phase-purity/pattern-identifiers.d.ts

@@ -0,0 +1,13 @@
+import type * as ESTree from "estree";
+/**
+ * Collects all identifier names declared by a destructuring or identifier pattern.
+ * @param pattern Pattern node to inspect.
+ * @param identifiers Identifier set updated in place.
+ * @example
+ * ```typescript
+ * collectPatternIdentifiers({ name: "value", type: "Identifier" }, new Set<string>());
+ * ```
+ */
+declare function collectPatternIdentifiers(pattern: ESTree.Pattern, identifiers: Set<string>): void;
+export { collectPatternIdentifiers };
+//# sourceMappingURL=pattern-identifiers.d.ts.map

package/dist/domain/testing/enforce-aaa-phase-purity/pattern-identifiers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pattern-identifiers.d.ts","sourceRoot":"","sources":["../../../../src/domain/testing/enforce-aaa-phase-purity/pattern-identifiers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,KAAK,MAAM,MAAM,QAAQ,CAAC;AA2FtC;;;;;;;;GAQG;AACH,iBAAS,yBAAyB,CAChC,OAAO,EAAE,MAAM,CAAC,OAAO,EACvB,WAAW,EAAE,GAAG,CAAC,MAAM,CAAC,GACvB,IAAI,CAEN;AA4ED,OAAO,EAAE,yBAAyB,EAAE,CAAC"}