@konvert7/klint 0.1.0

package/rules/no-optional-chain-on-non-nullable.ts

@@ -0,0 +1,68 @@
+import { relative } from "node:path";
+import ts from "typescript";
+import { createProgram } from "../core/ast";
+import type { RawViolation } from "../core/types";
+import { defineRule } from "../core/types";
+
+export const noOptionalChainOnNonNullable = defineRule({
+  check({ files, root }, violations) {
+    const program = createProgram(files, root);
+    const checker = program.getTypeChecker();
+
+    if (!program.getCompilerOptions().strictNullChecks) return;
+
+    const fileSet = new Set(files);
+    for (const sourceFile of program.getSourceFiles()) {
+      if (!fileSet.has(sourceFile.fileName) || sourceFile.isDeclarationFile) continue;
+      visitFile(sourceFile, checker, root, violations);
+    }
+  },
+});
+
+function visitFile(
+  sourceFile: ts.SourceFile,
+  checker: ts.TypeChecker,
+  root: string,
+  violations: RawViolation[]
+): void {
+  function visit(node: ts.Node): void {
+    const receiver = getOptionalChainReceiver(node);
+    if (receiver) {
+      const type = checker.getTypeAtLocation(receiver);
+      if (!isNullable(type)) {
+        const { line } = sourceFile.getLineAndCharacterOfPosition(node.getStart());
+        violations.push({
+          file: relative(root, sourceFile.fileName),
+          line: line + 1,
+          message:
+            "Optional chain (?.) on a non-nullable type — the receiver can never be null or undefined here. Use . to remove misleading dead code.",
+        });
+      }
+    }
+    ts.forEachChild(node, visit);
+  }
+  visit(sourceFile);
+}
+
+function getOptionalChainReceiver(node: ts.Node): ts.Expression | undefined {
+  if (
+    (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) &&
+    node.questionDotToken
+  ) {
+    return node.expression;
+  }
+  if (ts.isCallExpression(node) && node.questionDotToken) {
+    return node.expression;
+  }
+  return undefined;
+}
+
+function isNullable(type: ts.Type): boolean {
+  if (
+    type.flags &
+    (ts.TypeFlags.Null | ts.TypeFlags.Undefined | ts.TypeFlags.Any | ts.TypeFlags.Unknown)
+  )
+    return true;
+  if (type.isUnion()) return type.types.some(isNullable);
+  return false;
+}

package/rules/no-single-char-class.ts

@@ -0,0 +1,118 @@
+import { relative } from "node:path";
+import ts from "typescript";
+import { walkAst } from "../core/ast";
+import type { KlintRule } from "../core/types";
+
+// Unescaped metacharacters that lose their special meaning inside a character class,
+// making [.] a valid shorthand for a literal dot without needing \.
+const METACHAR_EXCEPTIONS = new Set([".", "*", "+", "?", "{", "}", "(", ")", "|", "$"]);
+
+interface CharClass {
+  start: number; // index of '[' in pattern
+  end: number; // index of ']' in pattern
+  inner: string; // the single token inside
+}
+
+function parseCharClasses(pattern: string): CharClass[] {
+  const results: CharClass[] = [];
+  let i = 0;
+  while (i < pattern.length) {
+    if (pattern[i] === "\\") {
+      i += 2;
+      continue;
+    }
+    if (pattern[i] !== "[") {
+      i++;
+      continue;
+    }
+    const start = i++;
+    // Negated classes have different semantics — skip
+    if (i < pattern.length && pattern[i] === "^") {
+      while (i < pattern.length && pattern[i] !== "]") {
+        if (pattern[i] === "\\") i++;
+        i++;
+      }
+      i++;
+      continue;
+    }
+    const tokens: string[] = [];
+    while (i < pattern.length && pattern[i] !== "]") {
+      if (pattern[i] === "\\") {
+        const s = i++;
+        if (i >= pattern.length) break;
+        const c = pattern[i];
+        if (c === "u" && i + 5 <= pattern.length) {
+          i += 5; // \uXXXX
+        } else if (c === "x" && i + 3 <= pattern.length) {
+          i += 3; // \xXX
+        } else if (c === "c" && i + 1 < pattern.length) {
+          i += 2; // \cX
+        } else {
+          i++;
+        }
+        tokens.push(pattern.slice(s, i));
+      } else {
+        tokens.push(pattern[i++]);
+      }
+    }
+    if (i >= pattern.length) break;
+    const end = i++;
+    if (tokens.length === 1) results.push({ start, end, inner: tokens[0] });
+  }
+  return results;
+}
+
+export const noSingleCharClass: KlintRule = {
+  check({ files, root, fileContents }, violations) {
+    for (const file of files) {
+      const content = fileContents.get(file) ?? "";
+      walkAst(file, content, (node, src) => {
+        if (!ts.isRegularExpressionLiteral(node)) return;
+
+        const regexSrc = node.getText(src);
+        const lastSlash = regexSrc.lastIndexOf("/");
+        const pattern = regexSrc.slice(1, lastSlash);
+        const flags = regexSrc.slice(lastSlash + 1);
+
+        const allClasses = parseCharClasses(pattern);
+        const toFix = allClasses.filter((c) => !METACHAR_EXCEPTIONS.has(c.inner));
+        if (toFix.length === 0) return;
+
+        // Build fixed pattern: replace [token] with token for non-exceptions
+        let fixedPattern = "";
+        let prev = 0;
+        for (const cls of allClasses) {
+          if (METACHAR_EXCEPTIONS.has(cls.inner)) continue;
+          fixedPattern += pattern.slice(prev, cls.start);
+          fixedPattern += cls.inner;
+          prev = cls.end + 1;
+        }
+        fixedPattern += pattern.slice(prev);
+
+        const fixedRegex = `/${fixedPattern}/${flags}`;
+        const { line } = src.getLineAndCharacterOfPosition(node.getStart());
+        const { line: endLine } = src.getLineAndCharacterOfPosition(node.getEnd());
+        const lineStarts = src.getLineStarts();
+        const lineStart = lineStarts[line];
+        const lineEnd =
+          endLine + 1 < lineStarts.length ? lineStarts[endLine + 1] - 1 : src.text.length;
+        const linesText = src.text.slice(lineStart, lineEnd);
+        const nodeOffset = node.getStart() - lineStart;
+        const nodeEndOffset = node.getEnd() - lineStart;
+        const fixedLines =
+          linesText.slice(0, nodeOffset) + fixedRegex + linesText.slice(nodeEndOffset);
+
+        violations.push({
+          file: relative(root, file),
+          line: line + 1,
+          message: `Character class [${toFix[0].inner}] contains a single element — remove the brackets.`,
+          fix: {
+            startLine: line + 1,
+            endLine: endLine + 1,
+            replacement: fixedLines,
+          },
+        });
+      });
+    }
+  },
+};

package/rules/no-string-match.ts

@@ -0,0 +1,58 @@
+import { relative } from "node:path";
+import ts from "typescript";
+import { walkAst } from "../core/ast";
+import type { KlintRule } from "../core/types";
+
+export const noStringMatch: KlintRule = {
+  check({ files, root, fileContents }, violations) {
+    for (const file of files) {
+      const content = fileContents.get(file) ?? "";
+      walkAst(file, content, (node, src) => {
+        if (
+          ts.isCallExpression(node) &&
+          ts.isPropertyAccessExpression(node.expression) &&
+          node.expression.name.text === "match" &&
+          node.arguments.length === 1 &&
+          ts.isRegularExpressionLiteral(node.arguments[0])
+        ) {
+          const flags = regexFlags(node.arguments[0].text);
+          if (!flags.includes("g")) {
+            const strText = (
+              node.expression as ts.PropertyAccessExpression
+            ).expression.getText(src);
+            const regexText = node.arguments[0].getText(src);
+            const { line: s } = src.getLineAndCharacterOfPosition(node.getStart());
+            const { line: e } = src.getLineAndCharacterOfPosition(node.getEnd());
+            const fix =
+              s === e
+                ? (() => {
+                    const lineStart = src.getPositionOfLineAndCharacter(s, 0);
+                    const nlPos = src.text.indexOf("\n", lineStart);
+                    const lineText = src.text.slice(
+                      lineStart,
+                      nlPos === -1 ? undefined : nlPos
+                    );
+                    const fixed = lineText.replace(
+                      node.getText(src),
+                      `new RegExp(${regexText}).exec(${strText})`
+                    );
+                    return { startLine: s + 1, endLine: e + 1, replacement: fixed };
+                  })()
+                : undefined;
+            violations.push({
+              file: relative(root, file),
+              line: s + 1,
+              message: `Use RegExp.exec() instead of String.match() for non-global regexes — use new RegExp(${regexText}).exec(${strText}) instead.`,
+              fix,
+            });
+          }
+        }
+      });
+    }
+  },
+};
+
+function regexFlags(literal: string): string {
+  const last = literal.lastIndexOf("/");
+  return last > 0 ? literal.slice(last + 1) : "";
+}

package/rules/no-sync-in-async.ts

@@ -0,0 +1,35 @@
+import { relative } from "node:path";
+import ts from "typescript";
+import { nearestFunctionIsAsync, walkAst } from "../core/ast";
+import type { KlintRule } from "../core/types";
+
+export const noSyncInAsync: KlintRule = {
+  check({ files, root, fileContents }, violations) {
+    for (const file of files) {
+      const content = fileContents.get(file) ?? "";
+      walkAst(file, content, (node, src) => {
+        if (ts.isCallExpression(node)) {
+          const callee = node.expression;
+          let name: string | null = null;
+          if (ts.isIdentifier(callee)) {
+            name = callee.text;
+          } else if (ts.isPropertyAccessExpression(callee)) {
+            name = callee.name.text;
+          }
+          if (
+            name?.endsWith("Sync") &&
+            name !== "existsSync" &&
+            nearestFunctionIsAsync(node)
+          ) {
+            const { line } = src.getLineAndCharacterOfPosition(node.getStart());
+            violations.push({
+              file: relative(root, file),
+              line: line + 1,
+              message: `${name}() blocks the event loop inside an async function — use the async equivalent from node:fs/promises.`,
+            });
+          }
+        }
+      });
+    }
+  },
+};

package/rules/no-unguarded-json-parse.ts

@@ -0,0 +1,30 @@
+import { relative } from "node:path";
+import ts from "typescript";
+import { isInsideTry, walkAst } from "../core/ast";
+import type { KlintRule } from "../core/types";
+
+export const noUnguardedJsonParse: KlintRule = {
+  check({ files, root, fileContents }, violations) {
+    for (const file of files) {
+      const content = fileContents.get(file) ?? "";
+      walkAst(file, content, (node, src) => {
+        if (
+          ts.isCallExpression(node) &&
+          ts.isPropertyAccessExpression(node.expression) &&
+          node.expression.name.text === "parse" &&
+          ts.isIdentifier(node.expression.expression) &&
+          node.expression.expression.text === "JSON" &&
+          !isInsideTry(node)
+        ) {
+          const { line } = src.getLineAndCharacterOfPosition(node.getStart());
+          violations.push({
+            file: relative(root, file),
+            line: line + 1,
+            message:
+              "JSON.parse() called without a surrounding try/catch — a malformed payload will throw an unhandled exception.",
+          });
+        }
+      });
+    }
+  },
+};

package/rules/prefer-at.ts

@@ -0,0 +1,54 @@
+import { relative } from "node:path";
+import ts from "typescript";
+import { walkAst } from "../core/ast";
+import type { KlintRule } from "../core/types";
+
+export const preferAt: KlintRule = {
+  check({ files, root, fileContents }, violations) {
+    for (const file of files) {
+      const content = fileContents.get(file) ?? "";
+      walkAst(file, content, (node, src) => {
+        // Match: base[base.length - n]
+        if (!ts.isElementAccessExpression(node)) return;
+
+        const arg = node.argumentExpression;
+        if (!ts.isBinaryExpression(arg)) return;
+        if (arg.operatorToken.kind !== ts.SyntaxKind.MinusToken) return;
+        if (!ts.isPropertyAccessExpression(arg.left)) return;
+        if (arg.left.name.text !== "length") return;
+        if (!ts.isNumericLiteral(arg.right)) return;
+
+        const n = Number(arg.right.text);
+        // n=0 changes semantics: arr[arr.length - 0] is undefined, arr.at(-0) is arr[0]
+        if (!Number.isInteger(n) || n <= 0) return;
+
+        const baseText = node.expression.getText(src);
+        if (baseText !== arg.left.expression.getText(src)) return;
+
+        const fixedCall = `${baseText}.at(-${n})`;
+        const { line } = src.getLineAndCharacterOfPosition(node.getStart());
+        const { line: endLine } = src.getLineAndCharacterOfPosition(node.getEnd());
+        const lineStarts = src.getLineStarts();
+        const lineStart = lineStarts[line];
+        const lineEnd =
+          endLine + 1 < lineStarts.length ? lineStarts[endLine + 1] - 1 : src.text.length;
+        const linesText = src.text.slice(lineStart, lineEnd);
+        const nodeOffset = node.getStart() - lineStart;
+        const nodeEndOffset = node.getEnd() - lineStart;
+        const fixedLines =
+          linesText.slice(0, nodeOffset) + fixedCall + linesText.slice(nodeEndOffset);
+
+        violations.push({
+          file: relative(root, file),
+          line: line + 1,
+          message: `Prefer ${baseText}.at(-${n}) over ${baseText}[${baseText}.length - ${n}] for cleaner negative indexing.`,
+          fix: {
+            startLine: line + 1,
+            endLine: endLine + 1,
+            replacement: fixedLines,
+          },
+        });
+      });
+    }
+  },
+};

package/rules/prefer-nullish-coalescing-assign.ts

@@ -0,0 +1,68 @@
+import { relative } from "node:path";
+import ts from "typescript";
+import { walkAst } from "../core/ast";
+import type { KlintRule } from "../core/types";
+
+export const preferNullishCoalescingAssign: KlintRule = {
+  check({ files, root, fileContents }, violations) {
+    for (const file of files) {
+      const content = fileContents.get(file) ?? "";
+      walkAst(file, content, (node, src) => {
+        if (
+          !ts.isIfStatement(node) ||
+          node.elseStatement !== undefined ||
+          !ts.isPrefixUnaryExpression(node.expression) ||
+          node.expression.operator !== ts.SyntaxKind.ExclamationToken
+        )
+          return;
+
+        const assignExpr = extractAssignment(node.thenStatement);
+        if (!assignExpr) return;
+
+        const xText = node.expression.operand.getText(src);
+        if (assignExpr.left.getText(src) !== xText) return;
+
+        const yText = assignExpr.right.getText(src);
+        const { line: s } = src.getLineAndCharacterOfPosition(node.getStart());
+        const { line: e } = src.getLineAndCharacterOfPosition(node.getEnd());
+        const indent = getIndent(src, node);
+
+        violations.push({
+          file: relative(root, file),
+          line: s + 1,
+          message: `Prefer \`${xText} ??= ${yText}\` over \`if (!${xText}) ${xText} = ${yText}\` — ??= only assigns when null or undefined.`,
+          fix: {
+            startLine: s + 1,
+            endLine: e + 1,
+            replacement: `${indent}${xText} ??= ${yText};`,
+          },
+        });
+      });
+    }
+  },
+};
+
+function extractAssignment(stmt: ts.Statement): ts.BinaryExpression | undefined {
+  if (ts.isExpressionStatement(stmt)) {
+    return isAssign(stmt.expression) ? stmt.expression : undefined;
+  }
+  if (ts.isBlock(stmt) && stmt.statements.length === 1) {
+    const inner = stmt.statements[0];
+    if (ts.isExpressionStatement(inner) && isAssign(inner.expression)) {
+      return inner.expression;
+    }
+  }
+  return undefined;
+}
+
+function isAssign(node: ts.Expression): node is ts.BinaryExpression {
+  return (
+    ts.isBinaryExpression(node) && node.operatorToken.kind === ts.SyntaxKind.EqualsToken
+  );
+}
+
+function getIndent(src: ts.SourceFile, node: ts.Node): string {
+  const { line } = src.getLineAndCharacterOfPosition(node.getStart());
+  const lineStart = src.getPositionOfLineAndCharacter(line, 0);
+  return new RegExp(/^(\s*)/).exec(src.text.slice(lineStart, node.getStart()))?.[1] ?? "";
+}

package/rules/prefer-string-raw-regexp.ts

@@ -0,0 +1,88 @@
+import { relative } from "node:path";
+import ts from "typescript";
+import { walkAst } from "../core/ast";
+import type { KlintRule } from "../core/types";
+
+export const preferStringRawRegexp: KlintRule = {
+  check({ files, root, fileContents }, violations) {
+    for (const file of files) {
+      const content = fileContents.get(file) ?? "";
+      walkAst(file, content, (node, src) => {
+        if (
+          !ts.isNewExpression(node) ||
+          !ts.isIdentifier(node.expression) ||
+          node.expression.text !== "RegExp" ||
+          !node.arguments ||
+          node.arguments.length === 0
+        )
+          return;
+
+        const arg = node.arguments[0];
+        if (!ts.isNoSubstitutionTemplateLiteral(arg) && !ts.isTemplateExpression(arg))
+          return;
+
+        if (!hasDoubleBackslash(arg as ts.TemplateLiteral, src)) return;
+
+        const { line } = src.getLineAndCharacterOfPosition(node.getStart());
+        const { line: argStartLine } = src.getLineAndCharacterOfPosition(arg.getStart());
+        const { line: argEndLine } = src.getLineAndCharacterOfPosition(arg.getEnd());
+
+        const lineStarts = src.getLineStarts();
+        const lineStart = lineStarts[argStartLine];
+        const lineEnd =
+          argEndLine + 1 < lineStarts.length
+            ? lineStarts[argEndLine + 1] - 1
+            : src.text.length;
+        const linesText = src.text.slice(lineStart, lineEnd);
+
+        const argOffset = arg.getStart() - lineStart;
+        const argEndOffset = arg.getEnd() - lineStart;
+        const fixedArg = toStringRaw(arg as ts.TemplateLiteral, src);
+        const fixedLines =
+          linesText.slice(0, argOffset) + fixedArg + linesText.slice(argEndOffset);
+
+        violations.push({
+          file: relative(root, file),
+          line: line + 1,
+          message:
+            "Use String.raw`...` for RegExp template argument to avoid double backslashes (Sonar S7780).",
+          fix: {
+            startLine: argStartLine + 1,
+            endLine: argEndLine + 1,
+            replacement: fixedLines,
+          },
+        });
+      });
+    }
+  },
+};
+
+function hasDoubleBackslash(node: ts.TemplateLiteral, src: ts.SourceFile): boolean {
+  if (ts.isNoSubstitutionTemplateLiteral(node)) {
+    return node.getText(src).includes("\\\\");
+  }
+  if (node.head.getText(src).includes("\\\\")) return true;
+  for (const span of node.templateSpans) {
+    if (span.literal.getText(src).includes("\\\\")) return true;
+  }
+  return false;
+}
+
+function toStringRaw(node: ts.TemplateLiteral, src: ts.SourceFile): string {
+  if (ts.isNoSubstitutionTemplateLiteral(node)) {
+    const raw = node.getText(src);
+    const inner = raw.slice(1, -1);
+    return `String.raw\`${inner.replaceAll("\\\\", "\\")}\``;
+  }
+  let result = "String.raw`";
+  const headSrc = node.head.getText(src);
+  result += `${headSrc.slice(1, -2).replaceAll("\\\\", "\\")}\${`;
+  for (const span of node.templateSpans) {
+    result += span.expression.getText(src);
+    const litSrc = span.literal.getText(src);
+    const isMiddle = ts.isTemplateMiddle(span.literal);
+    const litContent = isMiddle ? litSrc.slice(1, -2) : litSrc.slice(1, -1);
+    result += `}${litContent.replaceAll("\\\\", "\\")}${isMiddle ? "${" : "`"}`;
+  }
+  return result;
+}

package/rules/prefer-string-raw.ts

@@ -0,0 +1,47 @@
+import { relative } from "node:path";
+import ts from "typescript";
+import { walkAst } from "../core/ast";
+import type { KlintRule } from "../core/types";
+
+export const preferStringRaw: KlintRule = {
+  check({ files, root, fileContents }, violations) {
+    for (const file of files) {
+      const content = fileContents.get(file) ?? "";
+      walkAst(file, content, (node, src) => {
+        if (!ts.isStringLiteral(node)) return;
+
+        const sourceText = node.getText(src);
+        if (!sourceText.includes("\\\\")) return;
+
+        const value = node.text;
+        // Can't embed backtick, ${ (would start interpolation), or trailing \ (would escape closing backtick)
+        if (value.includes("`") || value.includes("${") || value.endsWith("\\")) return;
+
+        const { line } = src.getLineAndCharacterOfPosition(node.getStart());
+        const { line: endLine } = src.getLineAndCharacterOfPosition(node.getEnd());
+        const lineStarts = src.getLineStarts();
+        const lineStart = lineStarts[line];
+        const lineEnd =
+          endLine + 1 < lineStarts.length ? lineStarts[endLine + 1] - 1 : src.text.length;
+        const linesText = src.text.slice(lineStart, lineEnd);
+        const nodeOffset = node.getStart() - lineStart;
+        const nodeEndOffset = node.getEnd() - lineStart;
+        const fixedNode = `String.raw\`${value}\``;
+        const fixedLines =
+          linesText.slice(0, nodeOffset) + fixedNode + linesText.slice(nodeEndOffset);
+
+        violations.push({
+          file: relative(root, file),
+          line: line + 1,
+          message:
+            "String literal with escaped backslashes — use String.raw`...` for clarity (Sonar S6535).",
+          fix: {
+            startLine: line + 1,
+            endLine: endLine + 1,
+            replacement: fixedLines,
+          },
+        });
+      });
+    }
+  },
+};

package/rules/prefer-string-replaceall.ts

@@ -0,0 +1,76 @@
+import { relative } from "node:path";
+import ts from "typescript";
+import { walkAst } from "../core/ast";
+import type { KlintRule } from "../core/types";
+
+export const preferStringReplaceall: KlintRule = {
+  check({ files, root, fileContents }, violations) {
+    for (const file of files) {
+      const content = fileContents.get(file) ?? "";
+      walkAst(file, content, (node, src) => {
+        if (
+          !ts.isCallExpression(node) ||
+          !ts.isPropertyAccessExpression(node.expression) ||
+          node.expression.name.text !== "replace" ||
+          node.arguments.length !== 2 ||
+          !ts.isRegularExpressionLiteral(node.arguments[0])
+        )
+          return;
+
+        const regexSrc = node.arguments[0].getText(src);
+        const flags = extractFlags(regexSrc);
+        const pattern = extractPattern(regexSrc);
+
+        if (flags !== "g") return;
+        if (!isPlainLiteral(pattern)) return;
+
+        const strText = (
+          node.expression as ts.PropertyAccessExpression
+        ).expression.getText(src);
+        const replacementText = node.arguments[1].getText(src);
+        const patternLit = pattern.includes('"')
+          ? `'${pattern.replaceAll("'", "\\'")}'`
+          : `"${pattern}"`;
+        const fixedCall = `${strText}.replaceAll(${patternLit}, ${replacementText})`;
+
+        const { line: s } = src.getLineAndCharacterOfPosition(node.getStart());
+        const { line: e } = src.getLineAndCharacterOfPosition(node.getEnd());
+        const lineStarts = src.getLineStarts();
+        const lineStart = lineStarts[s];
+        const lineEnd =
+          e + 1 < lineStarts.length ? lineStarts[e + 1] - 1 : src.text.length;
+        const linesText = src.text.slice(lineStart, lineEnd);
+        const nodeOffset = node.getStart() - lineStart;
+        const nodeEndOffset = node.getEnd() - lineStart;
+        const fixedLines =
+          linesText.slice(0, nodeOffset) + fixedCall + linesText.slice(nodeEndOffset);
+
+        violations.push({
+          file: relative(root, file),
+          line: s + 1,
+          message: `Prefer \`${strText}.replaceAll(${patternLit}, ...)\` over \`.replace(/${pattern}/g, ...)\` — replaceAll() with a string is clearer and avoids regex escaping pitfalls.`,
+          fix: {
+            startLine: s + 1,
+            endLine: e + 1,
+            replacement: fixedLines,
+          },
+        });
+      });
+    }
+  },
+};
+
+function extractFlags(literal: string): string {
+  const last = literal.lastIndexOf("/");
+  return last > 0 ? literal.slice(last + 1) : "";
+}
+
+function extractPattern(literal: string): string {
+  return literal.slice(1, literal.lastIndexOf("/"));
+}
+
+function isPlainLiteral(pattern: string): boolean {
+  // Strip escaped-backslash pairs (\\) before checking — \\ is a plain literal, not a metachar
+  const stripped = pattern.replaceAll("\\\\", "");
+  return !/[.*+?[\]{}()|^$\\]/.test(stripped);
+}