@jameswyse/oxc-config 0.1.0

package/dist/vendor/eslint-stylistic/padding-line-between-statements.js

@@ -0,0 +1,493 @@
+import { isClosingBraceToken, isFunction, isNotSemicolonToken, isParenthesized, isSemicolonToken, isSingleLine, isTokenOnSameLine, isTopLevelExpressionStatement, LINEBREAKS, skipChainExpression, } from "./padding-line-ast.js";
+const CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/u;
+const CJS_IMPORT = /^require\(/u;
+const LT = `[${Array.from(LINEBREAKS).join("")}]`;
+const PADDING_LINE_SEQUENCE = new RegExp(String.raw `^(\s*?${LT})\s*${LT}(\s*;?)$`, "u");
+function isStatementMatcherList(option) {
+    return Array.isArray(option);
+}
+function isSelectorOption(option) {
+    return typeof option === "object" && !isStatementMatcherList(option);
+}
+function newKeywordTester(type, keyword) {
+    return {
+        test(node, sourceCode) {
+            const isSameKeyword = sourceCode.getFirstToken(node)?.value === keyword;
+            const isSameType = Array.isArray(type) ? type.includes(node.type) : type === node.type;
+            return isSameKeyword && isSameType;
+        },
+    };
+}
+function newNodeTypeTester(type) {
+    return { test: (node) => node.type === type };
+}
+function isIIFEStatement(node) {
+    if (node.type === "ExpressionStatement") {
+        let expression = skipChainExpression(node.expression);
+        if (expression.type === "UnaryExpression") {
+            expression = skipChainExpression(expression.argument);
+        }
+        if (expression.type === "CallExpression") {
+            let node2 = expression.callee;
+            while (node2.type === "SequenceExpression") {
+                const lastExpression = node2.expressions.at(-1);
+                if (lastExpression === void 0) {
+                    throw new Error("Padding rule invariant: sequence expression is empty");
+                }
+                node2 = lastExpression;
+            }
+            return isFunction(node2);
+        }
+    }
+    return false;
+}
+function isCJSRequire(node) {
+    if (node.type === "VariableDeclaration") {
+        const declaration = node.declarations[0];
+        if (declaration?.init) {
+            let call = declaration.init;
+            while (call.type === "MemberExpression") {
+                call = call.object;
+            }
+            if (call.type === "CallExpression" && call.callee.type === "Identifier") {
+                return call.callee.name === "require";
+            }
+        }
+    }
+    return false;
+}
+function isBlockLikeStatement(node, sourceCode) {
+    if (node.type === "DoWhileStatement" && node.body.type === "BlockStatement") {
+        return true;
+    }
+    if (isIIFEStatement(node)) {
+        return true;
+    }
+    const lastToken = sourceCode.getLastToken(node, isNotSemicolonToken);
+    const belongingNode = lastToken && isClosingBraceToken(lastToken)
+        ? sourceCode.getNodeByRangeIndex(lastToken.range[0])
+        : null;
+    return (belongingNode !== null &&
+        (belongingNode.type === "BlockStatement" || belongingNode.type === "SwitchStatement"));
+}
+function isDirective(node, sourceCode) {
+    return (isTopLevelExpressionStatement(node) &&
+        node.expression.type === "Literal" &&
+        typeof node.expression.value === "string" &&
+        !isParenthesized(node.expression, sourceCode));
+}
+function isDirectivePrologue(node, sourceCode) {
+    if (isDirective(node, sourceCode) &&
+        node.parent &&
+        "body" in node.parent &&
+        Array.isArray(node.parent.body)) {
+        for (const sibling of node.parent.body) {
+            if (sibling === node) {
+                break;
+            }
+            if (!isDirective(sibling, sourceCode)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    return false;
+}
+function isCJSExport(node) {
+    if (node.type === "ExpressionStatement") {
+        const expression = node.expression;
+        if (expression.type === "AssignmentExpression") {
+            let left = expression.left;
+            if (left.type === "MemberExpression") {
+                while (left.object.type === "MemberExpression") {
+                    left = left.object;
+                }
+                return (left.object.type === "Identifier" &&
+                    (left.object.name === "exports" ||
+                        (left.object.name === "module" &&
+                            left.property.type === "Identifier" &&
+                            left.property.name === "exports")));
+            }
+        }
+    }
+    return false;
+}
+function isExpression(node, sourceCode) {
+    return node.type === "ExpressionStatement" && !isDirectivePrologue(node, sourceCode);
+}
+function getActualLastToken(node, sourceCode) {
+    const semiToken = sourceCode.getLastToken(node);
+    if (semiToken === null) {
+        throw new Error("Padding rule invariant: statement has no last token");
+    }
+    const prevToken = sourceCode.getTokenBefore(semiToken);
+    const nextToken = sourceCode.getTokenAfter(semiToken);
+    const isSemicolonLessStyle = prevToken !== null &&
+        nextToken !== null &&
+        prevToken.range[0] >= node.range[0] &&
+        isSemicolonToken(semiToken) &&
+        !isTokenOnSameLine(prevToken, semiToken) &&
+        isTokenOnSameLine(semiToken, nextToken);
+    return isSemicolonLessStyle ? prevToken : semiToken;
+}
+function replacerToRemovePaddingLines(_, trailingSpaces, indentSpaces) {
+    return trailingSpaces + indentSpaces;
+}
+function getReportLoc(node, sourceCode) {
+    if (isSingleLine(node)) {
+        return node.loc;
+    }
+    const line = node.loc.start.line;
+    const sourceLine = sourceCode.lines[line - 1];
+    if (sourceLine === void 0) {
+        throw new Error("Padding rule invariant: statement source line is missing");
+    }
+    return { start: node.loc.start, end: { line, column: sourceLine.length } };
+}
+function verifyForAny() { }
+function verifyForNever(context, _, nextNode, paddingLines) {
+    if (paddingLines.length === 0) {
+        return;
+    }
+    context.report({
+        node: nextNode,
+        messageId: "unexpectedBlankLine",
+        loc: getReportLoc(nextNode, context.sourceCode),
+        fix(fixer) {
+            if (paddingLines.length >= 2) {
+                return null;
+            }
+            const paddingPair = paddingLines[0];
+            if (paddingPair === void 0) {
+                throw new Error("Padding rule invariant: reported padding pair is missing");
+            }
+            const [prevToken, nextToken] = paddingPair;
+            const start = prevToken.range[1];
+            const end = nextToken.range[0];
+            const text = context.sourceCode.text
+                .slice(start, end)
+                .replace(PADDING_LINE_SEQUENCE, replacerToRemovePaddingLines);
+            return fixer.replaceTextRange([start, end], text);
+        },
+    });
+}
+function verifyForAlways(context, prevNode, nextNode, paddingLines) {
+    if (paddingLines.length > 0) {
+        return;
+    }
+    context.report({
+        node: nextNode,
+        messageId: "expectedBlankLine",
+        loc: getReportLoc(nextNode, context.sourceCode),
+        fix(fixer) {
+            const sourceCode = context.sourceCode;
+            let prevToken = getActualLastToken(prevNode, sourceCode);
+            const nextToken = sourceCode.getFirstTokenBetween(prevToken, nextNode, {
+                includeComments: true,
+                filter(token) {
+                    if (isTokenOnSameLine(prevToken, token)) {
+                        prevToken = token;
+                        return false;
+                    }
+                    return true;
+                },
+            }) ?? nextNode;
+            const insertText = isTokenOnSameLine(prevToken, nextToken) ? "\n\n" : "\n";
+            return fixer.insertTextAfter(prevToken, insertText);
+        },
+    });
+}
+const PaddingTypes = {
+    any: { verify: verifyForAny },
+    never: { verify: verifyForNever },
+    always: { verify: verifyForAlways },
+};
+function hasCJSExportText(node, sourceCode) {
+    return (node.type === "ExpressionStatement" &&
+        node.expression.type === "AssignmentExpression" &&
+        CJS_EXPORT.test(sourceCode.getText(node.expression.left)));
+}
+function hasCJSImportText(node, sourceCode) {
+    if (node.type !== "VariableDeclaration") {
+        return false;
+    }
+    const init = node.declarations[0]?.init ?? null;
+    return init !== null && CJS_IMPORT.test(sourceCode.getText(init));
+}
+const MaybeMultilineStatementType = {
+    "block-like": { test: isBlockLikeStatement },
+    expression: { test: isExpression },
+    return: newKeywordTester("ReturnStatement", "return"),
+    export: newKeywordTester(["ExportAllDeclaration", "ExportDefaultDeclaration", "ExportNamedDeclaration"], "export"),
+    var: newKeywordTester("VariableDeclaration", "var"),
+    let: newKeywordTester("VariableDeclaration", "let"),
+    const: newKeywordTester("VariableDeclaration", "const"),
+    using: {
+        test: (node) => node.type === "VariableDeclaration" && (node.kind === "using" || node.kind === "await using"),
+    },
+    type: newKeywordTester("TSTypeAliasDeclaration", "type"),
+};
+const BaseStatementTypes = {
+    "*": { test: () => true },
+    exports: { test: isCJSExport },
+    require: { test: isCJSRequire },
+    directive: { test: isDirectivePrologue },
+    iife: { test: isIIFEStatement },
+    block: newNodeTypeTester("BlockStatement"),
+    empty: newNodeTypeTester("EmptyStatement"),
+    function: newNodeTypeTester("FunctionDeclaration"),
+    "ts-method": newNodeTypeTester("TSMethodSignature"),
+    break: newKeywordTester("BreakStatement", "break"),
+    case: newKeywordTester("SwitchCase", "case"),
+    class: newKeywordTester("ClassDeclaration", "class"),
+    continue: newKeywordTester("ContinueStatement", "continue"),
+    debugger: newKeywordTester("DebuggerStatement", "debugger"),
+    default: newKeywordTester(["SwitchCase", "ExportDefaultDeclaration"], "default"),
+    do: newKeywordTester("DoWhileStatement", "do"),
+    for: newKeywordTester(["ForStatement", "ForInStatement", "ForOfStatement"], "for"),
+    if: newKeywordTester("IfStatement", "if"),
+    import: newKeywordTester("ImportDeclaration", "import"),
+    switch: newKeywordTester("SwitchStatement", "switch"),
+    throw: newKeywordTester("ThrowStatement", "throw"),
+    try: newKeywordTester("TryStatement", "try"),
+    while: newKeywordTester(["WhileStatement", "DoWhileStatement"], "while"),
+    with: newKeywordTester("WithStatement", "with"),
+    "cjs-export": { test: hasCJSExportText },
+    "cjs-import": { test: hasCJSImportText },
+    enum: newKeywordTester("TSEnumDeclaration", "enum"),
+    interface: newKeywordTester("TSInterfaceDeclaration", "interface"),
+    "function-overload": newNodeTypeTester("TSDeclareFunction"),
+};
+const StatementTypes = new Map([
+    ...Object.entries(BaseStatementTypes),
+    ...Object.entries(MaybeMultilineStatementType).flatMap(([key, value]) => [
+        [key, value],
+        [
+            `singleline-${key}`,
+            {
+                ...value,
+                test: (node, sourceCode) => value.test(node, sourceCode) && isSingleLine(node),
+            },
+        ],
+        [
+            `multiline-${key}`,
+            {
+                ...value,
+                test: (node, sourceCode) => value.test(node, sourceCode) && !isSingleLine(node),
+            },
+        ],
+    ]),
+]);
+function createPaddingLineRule(options) {
+    return {
+        meta: {
+            type: "layout",
+            docs: { description: "Require or disallow padding lines between statements" },
+            fixable: "whitespace",
+            hasSuggestions: false,
+            schema: {
+                $defs: {
+                    paddingType: { type: "string", enum: Object.keys(PaddingTypes) },
+                    statementType: { type: "string", enum: Array.from(StatementTypes.keys()) },
+                    selectorOption: {
+                        type: "object",
+                        properties: {
+                            selector: { type: "string" },
+                            lineMode: { type: "string", enum: ["any", "singleline", "multiline"] },
+                        },
+                        required: ["selector"],
+                        additionalProperties: false,
+                    },
+                    statementMatcher: {
+                        anyOf: [{ $ref: "#/$defs/statementType" }, { $ref: "#/$defs/selectorOption" }],
+                    },
+                    statementOption: {
+                        anyOf: [
+                            { $ref: "#/$defs/statementMatcher" },
+                            {
+                                type: "array",
+                                items: { $ref: "#/$defs/statementMatcher" },
+                                minItems: 1,
+                                uniqueItems: true,
+                                additionalItems: false,
+                            },
+                        ],
+                    },
+                },
+                type: "array",
+                additionalItems: false,
+                items: {
+                    type: "object",
+                    properties: {
+                        blankLine: { $ref: "#/$defs/paddingType" },
+                        prev: { $ref: "#/$defs/statementOption" },
+                        next: { $ref: "#/$defs/statementOption" },
+                    },
+                    additionalProperties: false,
+                    required: ["blankLine", "prev", "next"],
+                },
+            },
+            messages: {
+                unexpectedBlankLine: "Unexpected blank line before this statement.",
+                expectedBlankLine: "Expected blank line before this statement.",
+            },
+        },
+        create(context) {
+            const sourceCode = context.sourceCode;
+            const selectorMatchedNodes = new Map();
+            const pendingPairs = [];
+            function collectSelectorOption(option) {
+                if (isStatementMatcherList(option)) {
+                    for (const item of option) {
+                        collectSelectorOption(item);
+                    }
+                    return;
+                }
+                if (!isSelectorOption(option)) {
+                    return;
+                }
+                selectorMatchedNodes.set(option.selector, new Set());
+            }
+            for (const configure of options) {
+                collectSelectorOption(configure.prev);
+                collectSelectorOption(configure.next);
+            }
+            let scopeInfo = null;
+            function enterScope() {
+                scopeInfo = { upper: scopeInfo, prevNode: null };
+            }
+            function exitScope() {
+                if (scopeInfo) {
+                    scopeInfo = scopeInfo.upper;
+                }
+            }
+            function match(node, type) {
+                let innerStatementNode = node;
+                while (innerStatementNode.type === "LabeledStatement") {
+                    innerStatementNode = innerStatementNode.body;
+                }
+                if (isStatementMatcherList(type)) {
+                    return type.some((item) => match(innerStatementNode, item));
+                }
+                if (isSelectorOption(type)) {
+                    const matchedNodes = selectorMatchedNodes.get(type.selector);
+                    if (!matchedNodes?.has(innerStatementNode)) {
+                        return false;
+                    }
+                    const lineMode = type.lineMode;
+                    if (lineMode === "singleline") {
+                        return isSingleLine(innerStatementNode);
+                    }
+                    else if (lineMode === "multiline") {
+                        return !isSingleLine(innerStatementNode);
+                    }
+                    return true;
+                }
+                else {
+                    const statementType = StatementTypes.get(type);
+                    if (statementType === void 0) {
+                        throw new Error(`Padding rule invariant: unsupported statement type ${type}`);
+                    }
+                    return statementType.test(innerStatementNode, sourceCode);
+                }
+            }
+            function getPaddingType(prevNode, nextNode) {
+                for (let i = options.length - 1; i >= 0; --i) {
+                    const configure = options[i];
+                    if (configure === void 0) {
+                        throw new Error("Padding rule invariant: configuration entry is missing");
+                    }
+                    if (match(prevNode, configure.prev) && match(nextNode, configure.next)) {
+                        return PaddingTypes[configure.blankLine];
+                    }
+                }
+                return PaddingTypes.any;
+            }
+            function getPaddingLineSequences(prevNode, nextNode) {
+                const pairs = [];
+                let prevToken = getActualLastToken(prevNode, sourceCode);
+                if (nextNode.loc.start.line - prevToken.loc.end.line >= 2) {
+                    do {
+                        const token = sourceCode.getTokenAfter(prevToken, { includeComments: true });
+                        if (token === null) {
+                            throw new Error("Padding rule invariant: token after padding is missing");
+                        }
+                        if (token.loc.start.line - prevToken.loc.end.line >= 2) {
+                            pairs.push([prevToken, token]);
+                        }
+                        prevToken = token;
+                    } while (prevToken.range[0] < nextNode.range[0]);
+                }
+                return pairs;
+            }
+            function verify(node) {
+                if (!node.parent ||
+                    ![
+                        "BlockStatement",
+                        "Program",
+                        "StaticBlock",
+                        "SwitchCase",
+                        "SwitchStatement",
+                        "TSInterfaceBody",
+                        "TSModuleBlock",
+                        "TSTypeLiteral",
+                    ].includes(node.parent.type)) {
+                    return;
+                }
+                if (scopeInfo === null) {
+                    throw new Error("Padding rule invariant: statement is outside a scope");
+                }
+                const prevNode = scopeInfo.prevNode;
+                if (prevNode) {
+                    pendingPairs.push({ prevNode, nextNode: node });
+                }
+                scopeInfo.prevNode = node;
+            }
+            function verifyPendingPairs() {
+                for (const { prevNode, nextNode } of pendingPairs) {
+                    const type = getPaddingType(prevNode, nextNode);
+                    const paddingLines = getPaddingLineSequences(prevNode, nextNode);
+                    type.verify(context, prevNode, nextNode, paddingLines);
+                }
+            }
+            function verifyThenEnterScope(node) {
+                verify(node);
+                enterScope();
+            }
+            const selectorMatchListeners = Object.fromEntries(Array.from(selectorMatchedNodes.keys(), (selector) => [
+                selector,
+                (node) => {
+                    selectorMatchedNodes.get(selector)?.add(node);
+                },
+            ]));
+            return {
+                Program: enterScope,
+                "Program:exit": () => {
+                    verifyPendingPairs();
+                    exitScope();
+                },
+                BlockStatement: enterScope,
+                "BlockStatement:exit": exitScope,
+                SwitchStatement: enterScope,
+                "SwitchStatement:exit": exitScope,
+                SwitchCase: verifyThenEnterScope,
+                "SwitchCase:exit": exitScope,
+                StaticBlock: enterScope,
+                "StaticBlock:exit": exitScope,
+                TSInterfaceBody: enterScope,
+                "TSInterfaceBody:exit": exitScope,
+                TSModuleBlock: enterScope,
+                "TSModuleBlock:exit": exitScope,
+                TSTypeLiteral: enterScope,
+                "TSTypeLiteral:exit": exitScope,
+                TSDeclareFunction: verifyThenEnterScope,
+                "TSDeclareFunction:exit": exitScope,
+                TSMethodSignature: verifyThenEnterScope,
+                "TSMethodSignature:exit": exitScope,
+                ":statement": verify,
+                ...selectorMatchListeners,
+            };
+        },
+    };
+}
+export { createPaddingLineRule as default };

package/package.json

@@ -0,0 +1,89 @@
+{
+  "name": "@jameswyse/oxc-config",
+  "version": "0.1.0",
+  "description": "Opinionated Oxlint and Oxfmt configs with custom rules for TypeScript and JavaScript projects",
+  "keywords": [
+    "config",
+    "format",
+    "lint",
+    "nextjs",
+    "oxc",
+    "oxfmt",
+    "oxlint",
+    "react",
+    "typescript"
+  ],
+  "homepage": "https://github.com/jameswyse/oxc-config#readme",
+  "bugs": {
+    "url": "https://github.com/jameswyse/oxc-config/issues"
+  },
+  "license": "MIT",
+  "author": "James Wyse",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jameswyse/oxc-config.git"
+  },
+  "files": [
+    "dist",
+    "src/vendor/anti-slop/LICENSE",
+    "src/vendor/eslint-stylistic/LICENSE",
+    "tsconfig.base.json",
+    "REFERENCE.md"
+  ],
+  "type": "module",
+  "exports": {
+    "./oxlint": "./dist/lint.js",
+    "./oxfmt": "./dist/format.js",
+    "./wyse": "./dist/index.js",
+    "./tsconfig": "./tsconfig.base.json"
+  },
+  "dependencies": {
+    "@e18e/eslint-plugin": "0.8.1",
+    "@oxlint/plugins": "1.86.0",
+    "eslint-plugin-react-you-might-not-need-an-effect": "1.0.2"
+  },
+  "devDependencies": {
+    "@changesets/cli": "3.0.3",
+    "@types/node": "^22.20.5",
+    "oxfmt": "0.71.0",
+    "oxlint": "1.86.0",
+    "oxlint-tsgolint": "7.0.2003",
+    "typescript": "7.0.2"
+  },
+  "peerDependencies": {
+    "oxfmt": ">=0.71.0 <1",
+    "oxlint": ">=1.86.0 <2",
+    "oxlint-tsgolint": ">=7.0.2003 <8"
+  },
+  "peerDependenciesMeta": {
+    "oxfmt": {
+      "optional": true
+    },
+    "oxlint-tsgolint": {
+      "optional": true
+    }
+  },
+  "devEngines": {
+    "packageManager": {
+      "name": "pnpm",
+      "version": "12.6.0"
+    },
+    "runtime": {
+      "name": "node",
+      "version": "24.18.0",
+      "onFail": "download"
+    }
+  },
+  "engines": {
+    "node": ">=22.23.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "check": "pnpm test && pnpm lint && pnpm typecheck && pnpm format:check && pnpm build",
+    "format": "oxfmt .",
+    "format:check": "oxfmt --check .",
+    "lint": "oxlint .",
+    "test": "node --test \"src/**/*.test.ts\"",
+    "typecheck": "tsc"
+  }
+}

package/src/vendor/anti-slop/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Dillon Mulroy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/src/vendor/eslint-stylistic/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright OpenJS Foundation and other contributors, <www.openjsf.org>
+Copyright (c) 2023-PRESENT ESLint Stylistic contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/tsconfig.base.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "strict": true,
+    "noUncheckedIndexedAccess": true,
+    "exactOptionalPropertyTypes": true,
+    "noImplicitOverride": true,
+    "noFallthroughCasesInSwitch": true
+  }
+}