@sister.software/oxlint-config 9.3.0 → 11.0.0

package/out/jsdoc-plugin.js

@@ -0,0 +1,68 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The `sister-software/multiline-jsdoc` rule: a JSDoc block always spans multiple lines, even
+ *   when its content would fit on one. A one-line block reads as an aside; the multi-line form reads
+ *   as documentation, and it leaves somewhere to put the second sentence when one is needed.
+ *
+ *   Two shapes are left alone. A JSDoc that shares its line with code is a type cast or an inline
+ *   annotation, and expanding those changes what the line means. A JSDoc on a union or intersection
+ *   member labels one alternative in what reads as a list — three lines per entry turns a list you
+ *   can scan into a page you have to read.
+ */
+/**
+ * The JSDoc opener, so the rule can tell a documentation block from a plain block comment.
+ */
+const JSDOC_OPENER = "/**";
+/**
+ * A `|` or `&` as the next thing after a comment, meaning the comment labels one member of a union or intersection
+ * rather than documenting a declaration.
+ */
+const UNION_MEMBER = /^\s*[|&]/;
+export const multilineJSDocRule = {
+    meta: {
+        name: "multiline-jsdoc",
+        type: "layout",
+        fixable: "whitespace",
+        schema: [{ type: "object", additionalProperties: true }],
+    },
+    create(context) {
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const text = sourceCode.getText();
+        return {
+            Program() {
+                for (const comment of sourceCode.getAllComments()) {
+                    if (comment.type !== "Block")
+                        continue;
+                    const raw = text.slice(comment.range[0], comment.range[1]);
+                    if (!raw.startsWith(JSDOC_OPENER) || raw.includes("\n"))
+                        continue;
+                    // `value` excludes the delimiters, so a one-line block arrives as `"* x "`.
+                    const body = comment.value.replace(/^\*/, "").trim();
+                    if (!body)
+                        continue;
+                    // Everything from the start of the line up to the comment. All-whitespace means the
+                    // block leads its line and owns the indentation; anything else means it is inline.
+                    const lineStart = text.lastIndexOf("\n", comment.range[0] - 1) + 1;
+                    const indent = text.slice(lineStart, comment.range[0]);
+                    if (indent.trim())
+                        continue;
+                    // A block documenting a union or intersection member is a label on one alternative, and
+                    // the members read as a list. Three lines per entry turns a scannable list into a page,
+                    // so the requirement does not reach inside one.
+                    if (UNION_MEMBER.test(text.slice(comment.range[1])))
+                        continue;
+                    context.report({
+                        node: { type: "Block", range: comment.range },
+                        message: "JSDoc should span multiple lines.",
+                        fix(fixer) {
+                            return fixer.replaceTextRange(comment.range, `/**\n${indent} * ${body}\n${indent} */`);
+                        },
+                    });
+                }
+            },
+        };
+    },
+};
+//# sourceMappingURL=jsdoc-plugin.js.map

package/out/jsdoc-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsdoc-plugin.js","sourceRoot":"","sources":["../src/jsdoc-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;GAYG;AAIH;;GAEG;AACH,MAAM,YAAY,GAAG,KAAK,CAAA;AAE1B;;;GAGG;AACH,MAAM,YAAY,GAAG,UAAU,CAAA;AAE/B,MAAM,CAAC,MAAM,kBAAkB,GAAS;IACvC,IAAI,EAAE;QACL,IAAI,EAAE,iBAAiB;QACvB,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,YAAY;QACrB,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,oBAAoB,EAAE,IAAI,EAAE,CAAC;KACxD;IACD,MAAM,CAAC,OAAO;QACb,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,aAAc,EAAE,CAAA;QACjE,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,EAAE,CAAA;QAEjC,OAAO;YACN,OAAO;gBACN,KAAK,MAAM,OAAO,IAAI,UAAU,CAAC,cAAc,EAAE,EAAE,CAAC;oBACnD,IAAI,OAAO,CAAC,IAAI,KAAK,OAAO;wBAAE,SAAQ;oBACtC,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;oBAE1D,IAAI,CAAC,GAAG,CAAC,UAAU,CAAC,YAAY,CAAC,IAAI,GAAG,CAAC,QAAQ,CAAC,IAAI,CAAC;wBAAE,SAAQ;oBAEjE,4EAA4E;oBAC5E,MAAM,IAAI,GAAG,OAAO,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,CAAA;oBAEpD,IAAI,CAAC,IAAI;wBAAE,SAAQ;oBAEnB,oFAAoF;oBACpF,mFAAmF;oBACnF,MAAM,SAAS,GAAG,IAAI,CAAC,WAAW,CAAC,IAAI,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,GAAG,CAAC,CAAC,GAAG,CAAC,CAAA;oBAClE,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,SAAS,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;oBAEtD,IAAI,MAAM,CAAC,IAAI,EAAE;wBAAE,SAAQ;oBAE3B,wFAAwF;oBACxF,wFAAwF;oBACxF,gDAAgD;oBAChD,IAAI,YAAY,CAAC,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;wBAAE,SAAQ;oBAE7D,OAAO,CAAC,MAAM,CAAC;wBACd,IAAI,EAAE,EAAE,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,CAAC,KAAK,EAAE;wBAC7C,OAAO,EAAE,mCAAmC;wBAC5C,GAAG,CAAC,KAAK;4BACR,OAAO,KAAK,CAAC,gBAAgB,CAAC,OAAO,CAAC,KAAK,EAAE,QAAQ,MAAM,MAAM,IAAI,KAAK,MAAM,KAAK,CAAC,CAAA;wBACvF,CAAC;qBACD,CAAC,CAAA;gBACH,CAAC;YACF,CAAC;SACD,CAAA;IACF,CAAC;CACD,CAAA"}

package/out/length-truthiness-plugin.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file A prefer-length-truthiness rule, authored as an oxlint JS plugin (ESLint v9-compatible API).
+ *   It is the house counterpart to `unicorn/explicit-length-check`, which enforces the opposite
+ *   convention and is therefore off: `if (items.length)` reads better here than
+ *   `if (items.length > 0)`.
+ *
+ *   The rule only fires where the value is ALREADY coerced to a boolean — a condition, a ternary
+ *   test, or the operand of `!` — including through `&&`/`||` nested inside one. Outside those
+ *   positions the comparison is the value itself, and rewriting `const hasItems = items.length > 0`
+ *   would silently change its type from boolean to number.
+ */
+import type { Rule } from "./plugin-types.js";
+export declare const preferLengthTruthinessRule: Rule;
+export default preferLengthTruthinessRule;
+//# sourceMappingURL=length-truthiness-plugin.d.ts.map

package/out/length-truthiness-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"length-truthiness-plugin.d.ts","sourceRoot":"","sources":["../src/length-truthiness-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAAkB,IAAI,EAAe,MAAM,mBAAmB,CAAA;AAmD1E,eAAO,MAAM,0BAA0B,EAAE,IAyExC,CAAA;AAED,eAAe,0BAA0B,CAAA"}

package/out/length-truthiness-plugin.js

@@ -0,0 +1,123 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file A prefer-length-truthiness rule, authored as an oxlint JS plugin (ESLint v9-compatible API).
+ *   It is the house counterpart to `unicorn/explicit-length-check`, which enforces the opposite
+ *   convention and is therefore off: `if (items.length)` reads better here than
+ *   `if (items.length > 0)`.
+ *
+ *   The rule only fires where the value is ALREADY coerced to a boolean — a condition, a ternary
+ *   test, or the operand of `!` — including through `&&`/`||` nested inside one. Outside those
+ *   positions the comparison is the value itself, and rewriting `const hasItems = items.length > 0`
+ *   would silently change its type from boolean to number.
+ */
+/**
+ * Comparisons meaning "non-empty", which become the bare length.
+ */
+const TRUTHY_FORMS = new Set(["> 0", "!== 0", "!= 0", ">= 1"]);
+/**
+ * Comparisons meaning "empty", which become a negated length.
+ */
+const FALSY_FORMS = new Set(["=== 0", "== 0", "< 1"]);
+/**
+ * Members whose length-ness the rule understands.
+ */
+const LENGTH_PROPERTIES = new Set(["length", "size"]);
+/**
+ * The comparison rendered as `<operator> <literal>`, or null when it is not a length comparison.
+ */
+function classify(node) {
+    if (node.type !== "BinaryExpression" || !node.operator || !node.left || !node.right)
+        return null;
+    // Accept both `x.length > 0` and the flipped `0 < x.length`.
+    const flipped = { "<": ">", ">": "<", "<=": ">=", ">=": "<=" };
+    let { left, right, operator } = { left: node.left, right: node.right, operator: node.operator };
+    if (left.type === "Literal" || left.type === "NumericLiteral") {
+        ;
+        [left, right] = [right, left];
+        operator = flipped[operator] ?? operator;
+    }
+    if (left.type !== "MemberExpression" && left.type !== "StaticMemberExpression")
+        return null;
+    const property = left.property;
+    if (!property || property.type !== "Identifier" || !LENGTH_PROPERTIES.has(property.name ?? ""))
+        return null;
+    if (right.type !== "Literal" && right.type !== "NumericLiteral")
+        return null;
+    if (typeof right.value !== "number")
+        return null;
+    const form = `${operator} ${right.value}`;
+    if (TRUTHY_FORMS.has(form))
+        return { member: left, negate: false };
+    if (FALSY_FORMS.has(form))
+        return { member: left, negate: true };
+    return null;
+}
+export const preferLengthTruthinessRule = {
+    meta: {
+        name: "prefer-length-truthiness",
+        type: "suggestion",
+        fixable: "code",
+        schema: [{ type: "object", additionalProperties: true }],
+    },
+    create(context) {
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const text = sourceCode.getText();
+        function report(node) {
+            const hit = classify(node);
+            if (!hit)
+                return;
+            const member = text.slice(hit.member.range[0], hit.member.range[1]);
+            const replacement = hit.negate ? `!${member}` : member;
+            context.report({
+                node,
+                message: `Prefer \`${replacement}\` over an explicit length comparison — the house convention is truthiness.`,
+                fix(fixer) {
+                    return fixer.replaceTextRange(node.range, replacement);
+                },
+            });
+        }
+        /**
+         * Walk into a boolean context: logical operands and `!` arguments stay boolean.
+         */
+        function visitCondition(node) {
+            if (!node)
+                return;
+            if (node.type === "LogicalExpression") {
+                visitCondition(node.left);
+                visitCondition(node.right);
+                return;
+            }
+            if (node.type === "UnaryExpression" && node.operator === "!") {
+                visitCondition(node.argument);
+                return;
+            }
+            report(node);
+        }
+        return {
+            IfStatement(node) {
+                visitCondition(node.test);
+            },
+            WhileStatement(node) {
+                visitCondition(node.test);
+            },
+            DoWhileStatement(node) {
+                visitCondition(node.test);
+            },
+            ForStatement(node) {
+                visitCondition(node.test);
+            },
+            ConditionalExpression(node) {
+                visitCondition(node.test);
+            },
+            UnaryExpression(node) {
+                if (node.operator === "!") {
+                    visitCondition(node.argument);
+                }
+            },
+        };
+    },
+};
+export default preferLengthTruthinessRule;
+//# sourceMappingURL=length-truthiness-plugin.js.map

package/out/length-truthiness-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"length-truthiness-plugin.js","sourceRoot":"","sources":["../src/length-truthiness-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAIH;;GAEG;AACH,MAAM,YAAY,GAAG,IAAI,GAAG,CAAC,CAAC,KAAK,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;AAE9D;;GAEG;AACH,MAAM,WAAW,GAAG,IAAI,GAAG,CAAC,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,CAAC,CAAC,CAAA;AAErD;;GAEG;AACH,MAAM,iBAAiB,GAAG,IAAI,GAAG,CAAC,CAAC,QAAQ,EAAE,MAAM,CAAC,CAAC,CAAA;AAErD;;GAEG;AACH,SAAS,QAAQ,CAAC,IAAa;IAC9B,IAAI,IAAI,CAAC,IAAI,KAAK,kBAAkB,IAAI,CAAC,IAAI,CAAC,QAAQ,IAAI,CAAC,IAAI,CAAC,IAAI,IAAI,CAAC,IAAI,CAAC,KAAK;QAAE,OAAO,IAAI,CAAA;IAEhG,6DAA6D;IAC7D,MAAM,OAAO,GAA2B,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,CAAA;IACtF,IAAI,EAAE,IAAI,EAAE,KAAK,EAAE,QAAQ,EAAE,GAAG,EAAE,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,KAAK,EAAE,IAAI,CAAC,KAAK,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAAA;IAE/F,IAAI,IAAI,CAAC,IAAI,KAAK,SAAS,IAAI,IAAI,CAAC,IAAI,KAAK,gBAAgB,EAAE,CAAC;QAC/D,CAAC;QAAA,CAAC,IAAI,EAAE,KAAK,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,CAAC,CAAA;QAC9B,QAAQ,GAAG,OAAO,CAAC,QAAQ,CAAC,IAAI,QAAQ,CAAA;IACzC,CAAC;IAED,IAAI,IAAI,CAAC,IAAI,KAAK,kBAAkB,IAAI,IAAI,CAAC,IAAI,KAAK,wBAAwB;QAAE,OAAO,IAAI,CAAA;IAE3F,MAAM,QAAQ,GAAI,IAAyC,CAAC,QAAQ,CAAA;IAEpE,IAAI,CAAC,QAAQ,IAAI,QAAQ,CAAC,IAAI,KAAK,YAAY,IAAI,CAAC,iBAAiB,CAAC,GAAG,CAAC,QAAQ,CAAC,IAAI,IAAI,EAAE,CAAC;QAAE,OAAO,IAAI,CAAA;IAE3G,IAAI,KAAK,CAAC,IAAI,KAAK,SAAS,IAAI,KAAK,CAAC,IAAI,KAAK,gBAAgB;QAAE,OAAO,IAAI,CAAA;IAE5E,IAAI,OAAO,KAAK,CAAC,KAAK,KAAK,QAAQ;QAAE,OAAO,IAAI,CAAA;IAEhD,MAAM,IAAI,GAAG,GAAG,QAAQ,IAAI,KAAK,CAAC,KAAK,EAAE,CAAA;IAEzC,IAAI,YAAY,CAAC,GAAG,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,CAAA;IAElE,IAAI,WAAW,CAAC,GAAG,CAAC,IAAI,CAAC;QAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,CAAA;IAEhE,OAAO,IAAI,CAAA;AACZ,CAAC;AAED,MAAM,CAAC,MAAM,0BAA0B,GAAS;IAC/C,IAAI,EAAE;QACL,IAAI,EAAE,0BAA0B;QAChC,IAAI,EAAE,YAAY;QAClB,OAAO,EAAE,MAAM;QACf,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,oBAAoB,EAAE,IAAI,EAAE,CAAC;KACxD;IACD,MAAM,CAAC,OAAoB;QAC1B,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,aAAc,EAAE,CAAA;QACjE,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,EAAE,CAAA;QAEjC,SAAS,MAAM,CAAC,IAAa;YAC5B,MAAM,GAAG,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAA;YAE1B,IAAI,CAAC,GAAG;gBAAE,OAAM;YAEhB,MAAM,MAAM,GAAG,IAAI,CAAC,KAAK,CAAC,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,GAAG,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;YACnE,MAAM,WAAW,GAAG,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,IAAI,MAAM,EAAE,CAAC,CAAC,CAAC,MAAM,CAAA;YAEtD,OAAO,CAAC,MAAM,CAAC;gBACd,IAAI;gBACJ,OAAO,EAAE,YAAY,WAAW,6EAA6E;gBAC7G,GAAG,CAAC,KAAY;oBACf,OAAO,KAAK,CAAC,gBAAgB,CAAC,IAAI,CAAC,KAAK,EAAE,WAAW,CAAC,CAAA;gBACvD,CAAC;aACD,CAAC,CAAA;QACH,CAAC;QAED;;WAEG;QACH,SAAS,cAAc,CAAC,IAAgC;YACvD,IAAI,CAAC,IAAI;gBAAE,OAAM;YAEjB,IAAI,IAAI,CAAC,IAAI,KAAK,mBAAmB,EAAE,CAAC;gBACvC,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;gBACzB,cAAc,CAAC,IAAI,CAAC,KAAK,CAAC,CAAA;gBAE1B,OAAM;YACP,CAAC;YAED,IAAI,IAAI,CAAC,IAAI,KAAK,iBAAiB,IAAI,IAAI,CAAC,QAAQ,KAAK,GAAG,EAAE,CAAC;gBAC9D,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;gBAE7B,OAAM;YACP,CAAC;YAED,MAAM,CAAC,IAAI,CAAC,CAAA;QACb,CAAC;QAED,OAAO;YACN,WAAW,CAAC,IAAI;gBACf,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAC1B,CAAC;YACD,cAAc,CAAC,IAAI;gBAClB,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAC1B,CAAC;YACD,gBAAgB,CAAC,IAAI;gBACpB,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAC1B,CAAC;YACD,YAAY,CAAC,IAAI;gBAChB,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAC1B,CAAC;YACD,qBAAqB,CAAC,IAAI;gBACzB,cAAc,CAAC,IAAI,CAAC,IAAI,CAAC,CAAA;YAC1B,CAAC;YACD,eAAe,CAAC,IAAI;gBACnB,IAAI,IAAI,CAAC,QAAQ,KAAK,GAAG,EAAE,CAAC;oBAC3B,cAAc,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAA;gBAC9B,CAAC;YACF,CAAC;SACD,CAAA;IACF,CAAC;CACD,CAAA;AAED,eAAe,0BAA0B,CAAA"}

package/out/multiline-statement-plugin.d.ts

@@ -0,0 +1,18 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The `sister-software/multiline-statement-padding` rule: a statement that spans lines gets a
+ *   blank line on each side, so a reader can see where it starts and stops without matching brackets.
+ *
+ *   One rule covers what look like two habits — a big object literal jammed against the next
+ *   declaration, and a multi-line call jammed against the counter after it. Both are the same thing:
+ *   a statement tall enough to read as a block, sitting flush against its neighbour.
+ *
+ *   Neither edge is required at a block boundary, where the brace already separates. `console.*` calls
+ *   are left to `console-padding`, which groups consecutive ones — this rule would split a run that
+ *   happens to contain a tall call, and a run of output is one thing.
+ */
+import type { Rule } from "./plugin-types.js";
+export declare const multilineStatementPaddingRule: Rule;
+//# sourceMappingURL=multiline-statement-plugin.d.ts.map

package/out/multiline-statement-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"multiline-statement-plugin.d.ts","sourceRoot":"","sources":["../src/multiline-statement-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AAGH,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAwBtD,eAAO,MAAM,6BAA6B,EAAE,IA8D3C,CAAA"}

package/out/multiline-statement-plugin.js

@@ -0,0 +1,93 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The `sister-software/multiline-statement-padding` rule: a statement that spans lines gets a
+ *   blank line on each side, so a reader can see where it starts and stops without matching brackets.
+ *
+ *   One rule covers what look like two habits — a big object literal jammed against the next
+ *   declaration, and a multi-line call jammed against the counter after it. Both are the same thing:
+ *   a statement tall enough to read as a block, sitting flush against its neighbour.
+ *
+ *   Neither edge is required at a block boundary, where the brace already separates. `console.*` calls
+ *   are left to `console-padding`, which groups consecutive ones — this rule would split a run that
+ *   happens to contain a tall call, and a run of output is one thing.
+ */
+import { createPaddingHelpers } from "./padding-utils.js";
+/**
+ * The object whose calls belong to `console-padding` rather than to this rule.
+ */
+const CONSOLE_OBJECT = "console";
+/**
+ * Does this statement's own source span more than one line?
+ */
+function isMultiline(node, text) {
+    return text.slice(node.range[0], node.range[1]).includes("\n");
+}
+/**
+ * Is this statement a bare `console.<method>(…)` call, which `console-padding` owns?
+ */
+function isConsoleStatement(node) {
+    if (node?.type !== "ExpressionStatement")
+        return false;
+    const callee = node.expression?.type === "CallExpression" ? node.expression.callee : undefined;
+    return callee?.type === "MemberExpression" && callee.object?.name === CONSOLE_OBJECT;
+}
+export const multilineStatementPaddingRule = {
+    meta: {
+        name: "multiline-statement-padding",
+        type: "layout",
+        fixable: "whitespace",
+        schema: [{ type: "object", additionalProperties: true }],
+    },
+    create(context) {
+        const sourceCode = context.sourceCode ?? context.getSourceCode();
+        const text = sourceCode.getText();
+        const { requirePadding } = createPaddingHelpers(context);
+        function check(node) {
+            const parent = node.parent;
+            if (!parent || !Array.isArray(parent.body))
+                return;
+            if (!isMultiline(node, text) || isConsoleStatement(node))
+                return;
+            const body = parent.body;
+            const index = body.indexOf(node);
+            if (index === -1)
+                return;
+            const previous = body[index - 1];
+            const next = body[index + 1];
+            if (previous && !isConsoleStatement(previous)) {
+                requirePadding(previous, node, node, "Expected a blank line before this multi-line statement.");
+            }
+            if (next && !isConsoleStatement(next)) {
+                requirePadding(node, next, node, "Expected a blank line after this multi-line statement.");
+            }
+        }
+        // Every statement type that can stand in a statement list and span lines. Block-like statements are
+        // already padded from the front by `padding-lines`; this adds their trailing edge.
+        return Object.fromEntries([
+            "VariableDeclaration",
+            "ExpressionStatement",
+            "IfStatement",
+            "ForStatement",
+            "ForInStatement",
+            "ForOfStatement",
+            "WhileStatement",
+            "DoWhileStatement",
+            "SwitchStatement",
+            "TryStatement",
+            "FunctionDeclaration",
+            "ClassDeclaration",
+            "ReturnStatement",
+            "TSInterfaceDeclaration",
+            "TSTypeAliasDeclaration",
+            "TSEnumDeclaration",
+            "TSModuleDeclaration",
+            // An exported declaration arrives wrapped, and the wrapper spans the same lines as what it
+            // wraps — so matching the wrapper is enough. Without these, every `export` was invisible here.
+            "ExportNamedDeclaration",
+            "ExportDefaultDeclaration",
+        ].map((type) => [type, check]));
+    },
+};
+//# sourceMappingURL=multiline-statement-plugin.js.map

package/out/multiline-statement-plugin.js.map

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

package/out/padding-plugin.d.ts

@@ -3,9 +3,10 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  * @file A padding-lines rule, authored as an oxlint JS plugin (ESLint v9-compatible API). It
- *   requires a blank line before `return` and block-like statements (the equivalent of ESLint's
- *   `padding-line-between-statements` with `{ blankLine: "always", prev: "*", next: "return" | "block-like" }`),
- *   and autofixes by inserting the missing blank line (before any leading comments).
+ *   requires a blank line before the statements that END a path or a step — `return`, `continue`,
+ *   `break`, a bare `x++`/`x--` — and before block-like statements. Roughly ESLint's
+ *   `padding-line-between-statements` with `{ blankLine: "always", prev: "*", next: "return" | "block-like" }`,
+ *   widened to the rest of that family. Autofixes by inserting the blank line before any leading comments.
  */
 import type { Rule } from "./plugin-types.js";
 export declare const paddingRule: Rule;

package/out/padding-plugin.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"padding-plugin.d.ts","sourceRoot":"","sources":["../src/padding-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAmBtD,eAAO,MAAM,WAAW,EAAE,IAiDzB,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"padding-plugin.d.ts","sourceRoot":"","sources":["../src/padding-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAGH,OAAO,KAAK,EAAW,IAAI,EAAE,MAAM,mBAAmB,CAAA;AAkCtD,eAAO,MAAM,WAAW,EAAE,IA+CzB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/out/padding-plugin.js

@@ -3,16 +3,20 @@
  * @license AGPL-3.0
  * @author Teffen Ellis, et al.
  * @file A padding-lines rule, authored as an oxlint JS plugin (ESLint v9-compatible API). It
- *   requires a blank line before `return` and block-like statements (the equivalent of ESLint's
- *   `padding-line-between-statements` with `{ blankLine: "always", prev: "*", next: "return" | "block-like" }`),
- *   and autofixes by inserting the missing blank line (before any leading comments).
+ *   requires a blank line before the statements that END a path or a step — `return`, `continue`,
+ *   `break`, a bare `x++`/`x--` — and before block-like statements. Roughly ESLint's
+ *   `padding-line-between-statements` with `{ blankLine: "always", prev: "*", next: "return" | "block-like" }`,
+ *   widened to the rest of that family. Autofixes by inserting the blank line before any leading comments.
  */
+import { createPaddingHelpers } from "./padding-utils.js";
 /**
- * Statement node types that require a preceding blank line: `return` plus all "block-like" statements (matching
+ * Statement node types that require a preceding blank line: the path-enders plus all "block-like" statements (matching
  * ESLint's `block-like` selector).
  */
 const PADDED_STATEMENT_TYPES = [
     "ReturnStatement",
+    "ContinueStatement",
+    "BreakStatement",
     "BlockStatement",
     "IfStatement",
     "ForStatement",
@@ -22,7 +26,19 @@ const PADDED_STATEMENT_TYPES = [
     "DoWhileStatement",
     "SwitchStatement",
     "TryStatement",
+    // An interface or a type alias with a body reads as a block too — same braces, same weight on the
+    // page — so it wants the same separation from whatever precedes it.
+    "TSInterfaceDeclaration",
+    "TSTypeAliasDeclaration",
+    "TSEnumDeclaration",
+    "TSModuleDeclaration",
 ];
+/**
+ * Does this node type require a preceding blank line?
+ */
+function isPaddedType(type) {
+    return !!type && PADDED_STATEMENT_TYPES.includes(type);
+}
 export const paddingRule = {
     meta: {
         name: "padding-lines",
@@ -31,9 +47,7 @@ export const paddingRule = {
         schema: [{ type: "object", additionalProperties: true }],
     },
     create(context) {
-        const sourceCode = context.sourceCode ?? context.getSourceCode();
-        const text = sourceCode.getText();
-        const comments = sourceCode.getAllComments();
+        const { requirePadding } = createPaddingHelpers(context);
         function check(node) {
             const parent = node.parent;
             // Only statements that are direct members of a statement list (a block/program body).
@@ -43,27 +57,30 @@ export const paddingRule = {
             const index = parent.body.indexOf(node);
             if (index <= 0)
                 return; // first statement in the block — nothing to pad against.
-            const previous = parent.body[index - 1];
-            // A blank line should sit before the statement's own leading comments, so measure the gap
-            // up to the earliest comment between the previous statement and this one.
-            let start = node.range[0];
-            for (const comment of comments) {
-                if (comment.range[0] >= previous.range[1] && comment.range[1] <= node.range[0]) {
-                    start = Math.min(start, comment.range[0]);
-                }
-            }
-            const gap = text.slice(previous.range[1], start);
-            if ((gap.match(/\n/g) ?? []).length >= 2)
-                return; // already a blank line.
-            context.report({
-                node,
-                message: "Expected a blank line before this statement.",
-                fix(fixer) {
-                    return fixer.insertTextAfterRange([previous.range[1], previous.range[1]], "\n");
-                },
-            });
+            requirePadding(parent.body[index - 1], node, node, "Expected a blank line before this statement.");
         }
-        return Object.fromEntries(PADDED_STATEMENT_TYPES.map((type) => [type, check]));
+        return {
+            ...Object.fromEntries(PADDED_STATEMENT_TYPES.map((type) => [type, check])),
+            // A bare `x++` / `x--` is a counter step, and reads like one only when it stands apart. It
+            // arrives as an ExpressionStatement, so it cannot be matched by node type alone.
+            ExpressionStatement(node) {
+                if (node.expression?.type === "UpdateExpression") {
+                    check(node);
+                }
+            },
+            // An exported declaration arrives wrapped. Look through the wrapper so `export interface Foo {}`
+            // is padded exactly like the unexported form.
+            ExportNamedDeclaration(node) {
+                if (isPaddedType(node.declaration?.type)) {
+                    check(node);
+                }
+            },
+            ExportDefaultDeclaration(node) {
+                if (isPaddedType(node.declaration?.type)) {
+                    check(node);
+                }
+            },
+        };
     },
 };
 export default paddingRule;

package/out/padding-plugin.js.map

@@ -1 +1 @@
-{"version":3,"file":"padding-plugin.js","sourceRoot":"","sources":["../src/padding-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAIH;;;GAGG;AACH,MAAM,sBAAsB,GAAG;IAC9B,iBAAiB;IACjB,gBAAgB;IAChB,aAAa;IACb,cAAc;IACd,gBAAgB;IAChB,gBAAgB;IAChB,gBAAgB;IAChB,kBAAkB;IAClB,iBAAiB;IACjB,cAAc;CACL,CAAA;AAEV,MAAM,CAAC,MAAM,WAAW,GAAS;IAChC,IAAI,EAAE;QACL,IAAI,EAAE,eAAe;QACrB,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,YAAY;QACrB,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,oBAAoB,EAAE,IAAI,EAAE,CAAC;KACxD;IACD,MAAM,CAAC,OAAO;QACb,MAAM,UAAU,GAAG,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,aAAc,EAAE,CAAA;QACjE,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,EAAE,CAAA;QACjC,MAAM,QAAQ,GAAG,UAAU,CAAC,cAAc,EAAE,CAAA;QAE5C,SAAS,KAAK,CAAC,IAAa;YAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAA;YAE1B,sFAAsF;YACtF,4EAA4E;YAC5E,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;gBAAE,OAAM;YAElD,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;YAEvC,IAAI,KAAK,IAAI,CAAC;gBAAE,OAAM,CAAC,yDAAyD;YAChF,MAAM,QAAQ,GAAG,MAAM,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAE,CAAA;YAExC,0FAA0F;YAC1F,0EAA0E;YAC1E,IAAI,KAAK,GAAG,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;YAEzB,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;gBAChC,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;oBAChF,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;gBAC1C,CAAC;YACF,CAAC;YAED,MAAM,GAAG,GAAG,IAAI,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAA;YAEhD,IAAI,CAAC,GAAG,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,IAAI,CAAC;gBAAE,OAAM,CAAC,wBAAwB;YAEzE,OAAO,CAAC,MAAM,CAAC;gBACd,IAAI;gBACJ,OAAO,EAAE,8CAA8C;gBACvD,GAAG,CAAC,KAAK;oBACR,OAAO,KAAK,CAAC,oBAAoB,CAAC,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAA;gBAChF,CAAC;aACD,CAAC,CAAA;QACH,CAAC;QAED,OAAO,MAAM,CAAC,WAAW,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC,CAAA;IAC/E,CAAC;CACD,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"padding-plugin.js","sourceRoot":"","sources":["../src/padding-plugin.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,oBAAoB,EAAE,MAAM,oBAAoB,CAAA;AAGzD;;;GAGG;AACH,MAAM,sBAAsB,GAAG;IAC9B,iBAAiB;IACjB,mBAAmB;IACnB,gBAAgB;IAChB,gBAAgB;IAChB,aAAa;IACb,cAAc;IACd,gBAAgB;IAChB,gBAAgB;IAChB,gBAAgB;IAChB,kBAAkB;IAClB,iBAAiB;IACjB,cAAc;IACd,kGAAkG;IAClG,oEAAoE;IACpE,wBAAwB;IACxB,wBAAwB;IACxB,mBAAmB;IACnB,qBAAqB;CACZ,CAAA;AAEV;;GAEG;AACH,SAAS,YAAY,CAAC,IAAwB;IAC7C,OAAO,CAAC,CAAC,IAAI,IAAK,sBAA4C,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAA;AAC9E,CAAC;AAED,MAAM,CAAC,MAAM,WAAW,GAAS;IAChC,IAAI,EAAE;QACL,IAAI,EAAE,eAAe;QACrB,IAAI,EAAE,QAAQ;QACd,OAAO,EAAE,YAAY;QACrB,MAAM,EAAE,CAAC,EAAE,IAAI,EAAE,QAAQ,EAAE,oBAAoB,EAAE,IAAI,EAAE,CAAC;KACxD;IACD,MAAM,CAAC,OAAO;QACb,MAAM,EAAE,cAAc,EAAE,GAAG,oBAAoB,CAAC,OAAO,CAAC,CAAA;QAExD,SAAS,KAAK,CAAC,IAAa;YAC3B,MAAM,MAAM,GAAG,IAAI,CAAC,MAAM,CAAA;YAE1B,sFAAsF;YACtF,4EAA4E;YAC5E,IAAI,CAAC,MAAM,IAAI,CAAC,KAAK,CAAC,OAAO,CAAC,MAAM,CAAC,IAAI,CAAC;gBAAE,OAAM;YAElD,MAAM,KAAK,GAAG,MAAM,CAAC,IAAI,CAAC,OAAO,CAAC,IAAI,CAAC,CAAA;YAEvC,IAAI,KAAK,IAAI,CAAC;gBAAE,OAAM,CAAC,yDAAyD;YAEhF,cAAc,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,GAAG,CAAC,CAAE,EAAE,IAAI,EAAE,IAAI,EAAE,8CAA8C,CAAC,CAAA;QACpG,CAAC;QAED,OAAO;YACN,GAAG,MAAM,CAAC,WAAW,CAAC,sBAAsB,CAAC,GAAG,CAAC,CAAC,IAAI,EAAE,EAAE,CAAC,CAAC,IAAI,EAAE,KAAK,CAAC,CAAC,CAAC;YAC1E,2FAA2F;YAC3F,iFAAiF;YACjF,mBAAmB,CAAC,IAAa;gBAChC,IAAI,IAAI,CAAC,UAAU,EAAE,IAAI,KAAK,kBAAkB,EAAE,CAAC;oBAClD,KAAK,CAAC,IAAI,CAAC,CAAA;gBACZ,CAAC;YACF,CAAC;YACD,iGAAiG;YACjG,8CAA8C;YAC9C,sBAAsB,CAAC,IAAa;gBACnC,IAAI,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,CAAC;oBAC1C,KAAK,CAAC,IAAI,CAAC,CAAA;gBACZ,CAAC;YACF,CAAC;YACD,wBAAwB,CAAC,IAAa;gBACrC,IAAI,YAAY,CAAC,IAAI,CAAC,WAAW,EAAE,IAAI,CAAC,EAAE,CAAC;oBAC1C,KAAK,CAAC,IAAI,CAAC,CAAA;gBACZ,CAAC;YACF,CAAC;SACD,CAAA;IACF,CAAC;CACD,CAAA;AAED,eAAe,WAAW,CAAA"}

package/out/padding-utils.d.ts

@@ -0,0 +1,34 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The blank-line machinery the three padding rules share: how to tell whether two statements are
+ *   already separated, and how to ask for the separation when they are not.
+ *
+ *   All three anchor their fix to the END of the earlier statement. That is deliberate: when two rules
+ *   want the same blank line — a console call before a `return`, say — they emit the identical edit, so
+ *   one is applied and the other is a no-op, instead of each inserting a newline and producing a gap of
+ *   two.
+ */
+import type { AstNode, RuleContext } from "./plugin-types.js";
+/**
+ * What a padding rule needs from its context, resolved once per `create`.
+ */
+export interface PaddingHelpers {
+    /**
+     * Is there already a blank line between these two statements?
+     */
+    isPadded(from: AstNode, to: AstNode): boolean;
+    /**
+     * Report and fix a missing blank line between `from` and `to`, unless one is impossible or present.
+     */
+    requirePadding(from: AstNode, to: AstNode, node: AstNode, message: string): void;
+}
+/**
+ * Build the helpers for one rule invocation.
+ *
+ * A gap is measured to the earliest comment that leads the later statement, so the blank line lands above a statement's
+ * own comments rather than between them and their subject.
+ */
+export declare function createPaddingHelpers(context: RuleContext): PaddingHelpers;
+//# sourceMappingURL=padding-utils.d.ts.map

package/out/padding-utils.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"padding-utils.d.ts","sourceRoot":"","sources":["../src/padding-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,KAAK,EAAE,OAAO,EAAS,WAAW,EAAc,MAAM,mBAAmB,CAAA;AAEhF;;GAEG;AACH,MAAM,WAAW,cAAc;IAC9B;;OAEG;IACH,QAAQ,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,GAAG,OAAO,CAAA;IAC7C;;OAEG;IACH,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,EAAE,OAAO,EAAE,IAAI,EAAE,OAAO,EAAE,OAAO,EAAE,MAAM,GAAG,IAAI,CAAA;CAChF;AAED;;;;;GAKG;AACH,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,WAAW,GAAG,cAAc,CAkCzE"}

package/out/padding-utils.js

@@ -0,0 +1,50 @@
+/**
+ * @copyright Sister Software
+ * @license AGPL-3.0
+ * @author Teffen Ellis, et al.
+ * @file The blank-line machinery the three padding rules share: how to tell whether two statements are
+ *   already separated, and how to ask for the separation when they are not.
+ *
+ *   All three anchor their fix to the END of the earlier statement. That is deliberate: when two rules
+ *   want the same blank line — a console call before a `return`, say — they emit the identical edit, so
+ *   one is applied and the other is a no-op, instead of each inserting a newline and producing a gap of
+ *   two.
+ */
+/**
+ * Build the helpers for one rule invocation.
+ *
+ * A gap is measured to the earliest comment that leads the later statement, so the blank line lands above a statement's
+ * own comments rather than between them and their subject.
+ */
+export function createPaddingHelpers(context) {
+    const sourceCode = context.sourceCode ?? context.getSourceCode();
+    const text = sourceCode.getText();
+    const comments = sourceCode.getAllComments();
+    function isPadded(from, to) {
+        // Two statements with no newline between them cannot be separated by a blank line. This is the
+        // `;(expr)` ASI guard: the semicolon terminates the PREVIOUS statement, so the gap here is zero
+        // characters wide. Asking for padding there is asking for the impossible.
+        if (!text.slice(from.range[1], to.range[0]).includes("\n"))
+            return true;
+        let start = to.range[0];
+        for (const comment of comments) {
+            if (comment.range[0] >= from.range[1] && comment.range[1] <= to.range[0]) {
+                start = Math.min(start, comment.range[0]);
+            }
+        }
+        return (text.slice(from.range[1], start).match(/\n/g) ?? []).length >= 2;
+    }
+    function requirePadding(from, to, node, message) {
+        if (isPadded(from, to))
+            return;
+        context.report({
+            node,
+            message,
+            fix(fixer) {
+                return fixer.insertTextAfterRange([from.range[1], from.range[1]], "\n");
+            },
+        });
+    }
+    return { isPadded, requirePadding };
+}
+//# sourceMappingURL=padding-utils.js.map

package/out/padding-utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"padding-utils.js","sourceRoot":"","sources":["../src/padding-utils.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAkBH;;;;;GAKG;AACH,MAAM,UAAU,oBAAoB,CAAC,OAAoB;IACxD,MAAM,UAAU,GAAe,OAAO,CAAC,UAAU,IAAI,OAAO,CAAC,aAAc,EAAE,CAAA;IAC7E,MAAM,IAAI,GAAG,UAAU,CAAC,OAAO,EAAE,CAAA;IACjC,MAAM,QAAQ,GAAG,UAAU,CAAC,cAAc,EAAE,CAAA;IAE5C,SAAS,QAAQ,CAAC,IAAa,EAAE,EAAW;QAC3C,+FAA+F;QAC/F,gGAAgG;QAChG,0EAA0E;QAC1E,IAAI,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC,QAAQ,CAAC,IAAI,CAAC;YAAE,OAAO,IAAI,CAAA;QACvE,IAAI,KAAK,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,CAAA;QAEvB,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;YAChC,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,EAAE,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,CAAC;gBAC1E,KAAK,GAAG,IAAI,CAAC,GAAG,CAAC,KAAK,EAAE,OAAO,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,CAAA;YAC1C,CAAC;QACF,CAAC;QAED,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,KAAK,CAAC,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,MAAM,IAAI,CAAC,CAAA;IACzE,CAAC;IAED,SAAS,cAAc,CAAC,IAAa,EAAE,EAAW,EAAE,IAAa,EAAE,OAAe;QACjF,IAAI,QAAQ,CAAC,IAAI,EAAE,EAAE,CAAC;YAAE,OAAM;QAE9B,OAAO,CAAC,MAAM,CAAC;YACd,IAAI;YACJ,OAAO;YACP,GAAG,CAAC,KAAY;gBACf,OAAO,KAAK,CAAC,oBAAoB,CAAC,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,EAAE,IAAI,CAAC,CAAA;YACxE,CAAC;SACD,CAAC,CAAA;IACH,CAAC;IAED,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,CAAA;AACpC,CAAC"}