tsfmt 0.0.0 → 0.2.0

package/dist/core/formatters/rules/imports/ImportOrganizationRule.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ts = require("typescript");
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const ts__namespace = /* @__PURE__ */ _interopNamespaceDefault(ts);
+class ImportOrganizationRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.name = "ImportOrganizationRule";
+  }
+  createSourceFile(source) {
+    return ts__namespace.createSourceFile("temp.ts", source, ts__namespace.ScriptTarget.Latest, true, ts__namespace.ScriptKind.TS);
+  }
+  determineImportGroup(moduleSpecifier) {
+    if (moduleSpecifier.startsWith(".") || moduleSpecifier.startsWith("/")) {
+      return "relative";
+    }
+    if (moduleSpecifier.startsWith("@/") || moduleSpecifier.startsWith("~/")) {
+      return "internal";
+    }
+    return "external";
+  }
+  extractImports(sourceFile) {
+    const imports = [];
+    for (const statement of sourceFile.statements) {
+      if (ts__namespace.isImportDeclaration(statement)) {
+        const moduleSpecifier = statement.moduleSpecifier.text;
+        const isSideEffect = !statement.importClause;
+        const isTypeOnly = statement.importClause?.isTypeOnly || false;
+        const group = this.determineImportGroup(moduleSpecifier);
+        imports.push({
+          statement,
+          moduleSpecifier,
+          importClause: statement.importClause,
+          isTypeOnly,
+          isSideEffect,
+          group
+        });
+      }
+    }
+    return imports;
+  }
+  getImportedIdentifiers(importInfo) {
+    const identifiers = [];
+    if (!importInfo.importClause) {
+      return identifiers;
+    }
+    if (importInfo.importClause.name) {
+      identifiers.push(importInfo.importClause.name.text);
+    }
+    if (importInfo.importClause.namedBindings) {
+      if (ts__namespace.isNamedImports(importInfo.importClause.namedBindings)) {
+        for (const element of importInfo.importClause.namedBindings.elements) {
+          identifiers.push(element.name.text);
+        }
+      } else if (ts__namespace.isNamespaceImport(importInfo.importClause.namedBindings)) {
+        identifiers.push(importInfo.importClause.namedBindings.name.text);
+      }
+    }
+    return identifiers;
+  }
+  isIdentifierUsed(identifier, sourceFile) {
+    let found = false;
+    const visit = (node) => {
+      if (found)
+        return;
+      if (ts__namespace.isIdentifier(node) && node.text === identifier) {
+        const parent = node.parent;
+        if (!ts__namespace.isImportSpecifier(parent) && !ts__namespace.isImportClause(parent)) {
+          found = true;
+        }
+      }
+      ts__namespace.forEachChild(node, visit);
+    };
+    visit(sourceFile);
+    return found;
+  }
+  isImportUsed(importInfo, sourceFile) {
+    if (importInfo.isSideEffect) {
+      return true;
+    }
+    if (!importInfo.importClause) {
+      return true;
+    }
+    const identifiers = this.getImportedIdentifiers(importInfo);
+    return identifiers.some((id) => this.isIdentifierUsed(id, sourceFile));
+  }
+  filterUnusedImports(imports, sourceFile) {
+    const config = this.getImportsConfig();
+    if (!config?.removeUnused) {
+      return imports;
+    }
+    if (!config.removeSideEffects) {
+      return imports.filter((imp) => imp.isSideEffect || this.isImportUsed(imp, sourceFile));
+    }
+    return imports.filter((imp) => this.isImportUsed(imp, sourceFile));
+  }
+  sortImports(imports) {
+    const config = this.getImportsConfig();
+    if (!config?.sortImports) {
+      return imports;
+    }
+    return [...imports].sort((a, b) => {
+      return a.moduleSpecifier.localeCompare(b.moduleSpecifier);
+    });
+  }
+  groupImports(imports) {
+    const config = this.getImportsConfig();
+    if (!config?.groupImports) {
+      return imports;
+    }
+    const groupOrder = config.groupOrder || ["external", "internal", "relative"];
+    const grouped = [];
+    for (const group of groupOrder) {
+      const groupImports = imports.filter((imp) => imp.group === group);
+      grouped.push(...groupImports);
+    }
+    return grouped;
+  }
+  reconstructSource(sourceFile, imports) {
+    const config = this.getImportsConfig();
+    const fullText = sourceFile.getFullText();
+    const leadingCommentsMatch = fullText.match(/^((?:\/\*[\s\S]*?\*\/\s*)+)/);
+    let leadingComments = leadingCommentsMatch ? leadingCommentsMatch[1].trim() : "";
+    if (leadingComments) {
+      const commentBlocks = leadingComments.match(/\/\*[\s\S]*?\*\//g) || [];
+      const uniqueBlocks = new Set(commentBlocks.map((block) => block.trim()));
+      leadingComments = Array.from(uniqueBlocks).join("\n");
+    }
+    const importStatements = sourceFile.statements.filter((stmt) => ts__namespace.isImportDeclaration(stmt));
+    const lastImport = importStatements[importStatements.length - 1];
+    const afterImportsPos = lastImport ? lastImport.getEnd() : leadingCommentsMatch ? leadingCommentsMatch[0].length : 0;
+    let restOfFile = fullText.substring(afterImportsPos);
+    if (restOfFile && !restOfFile.startsWith("\n")) {
+      restOfFile = "\n" + restOfFile;
+    }
+    restOfFile = restOfFile.replace(/^\n{2,}/, "\n");
+    const printer = ts__namespace.createPrinter({
+      newLine: ts__namespace.NewLineKind.LineFeed,
+      removeComments: false
+    });
+    const importLines = [];
+    let lastGroup = null;
+    for (const importInfo of imports) {
+      if (config?.separateGroups && lastGroup !== null && lastGroup !== importInfo.group) {
+        importLines.push("");
+      }
+      let importText = printer.printNode(ts__namespace.EmitHint.Unspecified, importInfo.statement, sourceFile);
+      importText = importText.replace(/^((?:\/\*[\s\S]*?\*\/\s*)+)/, "").trim();
+      importLines.push(importText);
+      lastGroup = importInfo.group;
+    }
+    const sections = [];
+    if (leadingComments) {
+      sections.push(leadingComments);
+    }
+    if (importLines.length > 0) {
+      sections.push(importLines.join("\n"));
+    }
+    if (restOfFile) {
+      sections.push(restOfFile);
+    }
+    let combined = sections.join("\n\n");
+    combined = combined.replace(/(;\n+)+;?\s*$/, "\n");
+    return combined;
+  }
+  apply(source, filePath) {
+    const config = this.getImportsConfig();
+    if (!config?.enabled) {
+      return source;
+    }
+    const sourceFile = this.createSourceFile(source);
+    const imports = this.extractImports(sourceFile);
+    let processedImports = this.filterUnusedImports(imports, sourceFile);
+    processedImports = this.sortImports(processedImports);
+    processedImports = this.groupImports(processedImports);
+    return this.reconstructSource(sourceFile, processedImports);
+  }
+}
+exports.ImportOrganizationRule = ImportOrganizationRule;

package/dist/core/formatters/rules/index-generation/IndexGenerationRule.js

@@ -0,0 +1,208 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const fs = require("fs");
+const path = require("path");
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+class IndexGenerationRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.defaultOptions = {
+      fileExtension: ".ts",
+      indexFileName: "index.ts",
+      recursive: true
+    };
+    this.name = "IndexGenerationRule";
+  }
+  findProjectRoot(filePath) {
+    let current = path__namespace.dirname(filePath);
+    while (current !== path__namespace.dirname(current)) {
+      if (fs__namespace.existsSync(path__namespace.join(current, "package.json"))) {
+        return current;
+      }
+      current = path__namespace.dirname(current);
+    }
+    return null;
+  }
+  isTestDirectory(dirName) {
+    const testDirectories = [
+      "__tests__",
+      "tests",
+      "test",
+      "__mocks__",
+      "__fixtures__",
+      ".storybook"
+    ];
+    return testDirectories.includes(dirName.toLowerCase()) || dirName.endsWith(".test") || dirName.endsWith(".spec");
+  }
+  isTestFile(fileName) {
+    const testPatterns = [
+      /\.test\.(ts|tsx|js|jsx)$/,
+      /\.spec\.(ts|tsx|js|jsx)$/,
+      /\.(test|spec)\.(ts|tsx|js|jsx)$/,
+      /__tests__/,
+      /\.stories\.(ts|tsx|js|jsx)$/
+    ];
+    return testPatterns.some((pattern) => pattern.test(fileName));
+  }
+  generateSingleDirectoryIndex(dir, options) {
+    try {
+      const entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
+      const exports$1 = [];
+      for (const entry of entries) {
+        if (entry.name === options.indexFileName) {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          if (this.isTestDirectory(entry.name)) {
+            continue;
+          }
+          const subIndexPath = path__namespace.join(dir, entry.name, options.indexFileName);
+          if (fs__namespace.existsSync(subIndexPath)) {
+            exports$1.push(`export * from "./${entry.name}";`);
+          }
+        } else if (entry.name.endsWith(".ts") || entry.name.endsWith(".tsx")) {
+          if (entry.name.endsWith(".d.ts")) {
+            continue;
+          }
+          if (this.isTestFile(entry.name)) {
+            continue;
+          }
+          const exportName = entry.name.replace(/\.(ts|tsx)$/, "");
+          exports$1.push(`export * from "./${exportName}";`);
+        }
+      }
+      if (exports$1.length === 0) {
+        return;
+      }
+      exports$1.sort();
+      const content = `// Auto-generated exports - do not edit manually
+// Run tsfmt to regenerate
+
+${exports$1.join("\n")}
+`;
+      const indexPath = path__namespace.join(dir, options.indexFileName);
+      fs__namespace.writeFileSync(indexPath, content, "utf8");
+    } catch (error) {
+      console.warn(`Warning: Failed to generate index for ${dir}: ${error.message}`);
+    }
+  }
+  generateIndexExportRecursive(dir, options) {
+    try {
+      const entries = fs__namespace.readdirSync(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (entry.isDirectory()) {
+          if (this.isTestDirectory(entry.name)) {
+            continue;
+          }
+          const subDir = path__namespace.join(dir, entry.name);
+          this.generateIndexExportRecursive(subDir, options);
+        }
+      }
+      this.generateSingleDirectoryIndex(dir, options);
+    } catch (error) {
+      console.warn(`Warning: Failed to process directory ${dir}: ${error.message}`);
+    }
+  }
+  generateIndexExport(dir, options) {
+    if (!fs__namespace.existsSync(dir)) {
+      return;
+    }
+    if (options.recursive) {
+      this.generateIndexExportRecursive(dir, options);
+    } else {
+      this.generateSingleDirectoryIndex(dir, options);
+    }
+  }
+  discoverExportableModules(srcDir) {
+    try {
+      const entries = fs__namespace.readdirSync(srcDir, { withFileTypes: true });
+      const modules = [];
+      for (const entry of entries) {
+        if (entry.name === "index.ts") {
+          continue;
+        }
+        if (entry.isDirectory()) {
+          if (this.isTestDirectory(entry.name)) {
+            continue;
+          }
+          const indexPath = path__namespace.join(srcDir, entry.name, "index.ts");
+          if (fs__namespace.existsSync(indexPath)) {
+            modules.push(entry.name);
+          }
+        } else if (entry.name.endsWith(".d.ts")) {
+          const moduleName = entry.name.slice(0, -3);
+          modules.push(moduleName);
+        }
+      }
+      return modules.sort();
+    } catch (error) {
+      console.warn(`Warning: Failed to discover modules in ${srcDir}: ${error.message}`);
+      return [];
+    }
+  }
+  updateMainIndex(indexPath, modules) {
+    try {
+      const exports$1 = modules.map((mod) => `export * from "./${mod}";`).join("\n");
+      const content = `// Auto-generated exports - do not edit manually
+// Run tsfmt to regenerate
+
+${exports$1}
+`;
+      fs__namespace.writeFileSync(indexPath, content, "utf8");
+    } catch (error) {
+      console.warn(`Warning: Failed to write main index file: ${error.message}`);
+    }
+  }
+  generateIndexFiles(currentFilePath) {
+    try {
+      const projectRoot = this.findProjectRoot(currentFilePath);
+      if (!projectRoot) {
+        return;
+      }
+      const config = this.getIndexGenerationConfig();
+      const directories = config?.directories || [];
+      const options = { ...this.defaultOptions, ...config?.options };
+      for (const dir of directories) {
+        const fullDirPath = path__namespace.resolve(projectRoot, dir);
+        this.generateIndexExport(fullDirPath, options);
+      }
+      if (config?.updateMainIndex !== false) {
+        const srcDir = path__namespace.join(projectRoot, "src");
+        const mainIndexPath = path__namespace.join(srcDir, "index.ts");
+        if (fs__namespace.existsSync(srcDir)) {
+          const modules = this.discoverExportableModules(srcDir);
+          this.updateMainIndex(mainIndexPath, modules);
+        }
+      }
+    } catch (error) {
+      console.warn(`Warning: Failed to generate index files: ${error.message}`);
+    }
+  }
+  apply(source, filePath) {
+    const config = this.getIndexGenerationConfig();
+    if (!config?.enabled || !filePath) {
+      return source;
+    }
+    this.generateIndexFiles(filePath);
+    return source;
+  }
+}
+exports.IndexGenerationRule = IndexGenerationRule;

package/dist/core/formatters/rules/spacing/BlankLineBeforeReturnsRule.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+class BlankLineBeforeReturnsRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.name = "BlankLineBeforeReturnsRule";
+  }
+  apply(source, filePath) {
+    const config = this.getSpacingConfig();
+    if (!config?.beforeReturns) {
+      return source;
+    }
+    const lines = source.split("\n");
+    const result = [];
+    for (let i = 0; i < lines.length; i++) {
+      const currentLine = lines[i];
+      const trimmedCurrentLine = currentLine.trim();
+      const previousLine = i > 0 ? lines[i - 1] : "";
+      const trimmedPreviousLine = previousLine.trim();
+      const isReturnStatement = trimmedCurrentLine.startsWith("return ");
+      const previousIsComment = trimmedPreviousLine.startsWith("//") || trimmedPreviousLine.startsWith("/*") || trimmedPreviousLine.startsWith("*") || trimmedPreviousLine.endsWith("*/");
+      const previousIsBlank = trimmedPreviousLine === "";
+      if (isReturnStatement && !previousIsBlank && !previousIsComment && i > 0) {
+        result.push("");
+      }
+      result.push(currentLine);
+    }
+    return result.join("\n");
+  }
+}
+exports.BlankLineBeforeReturnsRule = BlankLineBeforeReturnsRule;

package/dist/core/formatters/rules/spacing/BlankLineBetweenDeclarationsRule.js

@@ -0,0 +1,93 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+class BlankLineBetweenDeclarationsRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.name = "BlankLineBetweenDeclarationsRule";
+  }
+  /** Extracts the keyword from a declaration line */
+  getDeclarationKeyword(trimmedLine) {
+    if (trimmedLine.startsWith("export ")) {
+      return "export";
+    }
+    if (trimmedLine.startsWith("function ")) {
+      return "function";
+    }
+    if (trimmedLine.startsWith("const ")) {
+      return "const";
+    }
+    if (trimmedLine.startsWith("let ")) {
+      return "let";
+    }
+    if (trimmedLine.startsWith("var ")) {
+      return "var";
+    }
+    if (trimmedLine.startsWith("enum ")) {
+      return "enum";
+    }
+    if (trimmedLine.startsWith("interface ")) {
+      return "interface";
+    }
+    if (trimmedLine.startsWith("type ")) {
+      return "type";
+    }
+    if (trimmedLine.startsWith("class ")) {
+      return "class";
+    }
+    return null;
+  }
+  apply(source, filePath) {
+    const config = this.getSpacingConfig();
+    if (!config?.betweenDeclarations) {
+      return source;
+    }
+    const lines = source.split("\n");
+    const result = [];
+    let inImportSection = true;
+    let lastNonBlankLineWasDeclarationEnd = false;
+    let lastDeclarationKeyword = null;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmedLine = line.trim();
+      (line.match(/{/g) || []).length;
+      (line.match(/}/g) || []).length;
+      const isBlankLine = trimmedLine === "";
+      const isComment = trimmedLine.startsWith("//") || trimmedLine.startsWith("/*") || trimmedLine.startsWith("*") || trimmedLine === "*/";
+      const isBlockCommentStart = trimmedLine.startsWith("/*") && !trimmedLine.endsWith("*/");
+      const isImport = trimmedLine.startsWith("import ");
+      const declarationKeyword = !isComment && !isImport ? this.getDeclarationKeyword(trimmedLine) : null;
+      const isDeclarationStart = declarationKeyword !== null;
+      if (inImportSection && !isImport && !isBlankLine && !isComment) {
+        inImportSection = false;
+      }
+      if (!inImportSection) {
+        if (isBlockCommentStart && lastNonBlankLineWasDeclarationEnd && result.length > 0 && result[result.length - 1].trim() !== "") {
+          result.push("");
+          lastNonBlankLineWasDeclarationEnd = false;
+        } else if (isDeclarationStart && lastNonBlankLineWasDeclarationEnd && result.length > 0 && result[result.length - 1].trim() !== "" && declarationKeyword !== lastDeclarationKeyword) {
+          result.push("");
+          lastNonBlankLineWasDeclarationEnd = false;
+        }
+      }
+      result.push(line);
+      const hasClosingElement = trimmedLine === "}" || trimmedLine.endsWith("}") || trimmedLine.endsWith(";");
+      const isJustClosingBraces = /^[\s});]*$/.test(trimmedLine);
+      if (!isBlankLine && hasClosingElement) {
+        lastNonBlankLineWasDeclarationEnd = true;
+        if (isDeclarationStart) {
+          lastDeclarationKeyword = declarationKeyword;
+        }
+      } else if (!isBlankLine && !isComment) {
+        if (!isBlockCommentStart && trimmedLine !== "" && !isJustClosingBraces) {
+          lastNonBlankLineWasDeclarationEnd = isDeclarationStart;
+          if (isDeclarationStart) {
+            lastDeclarationKeyword = declarationKeyword;
+          }
+        }
+      }
+    }
+    return result.join("\n");
+  }
+}
+exports.BlankLineBetweenDeclarationsRule = BlankLineBetweenDeclarationsRule;

package/dist/core/formatters/rules/spacing/BlankLineBetweenStatementTypesRule.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+class BlankLineBetweenStatementTypesRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.name = "BlankLineBetweenStatementTypesRule";
+  }
+  /** Determine the type of a statement */
+  getStatementType(trimmedLine) {
+    if (trimmedLine.startsWith("if ") || trimmedLine.startsWith("if(") || trimmedLine.startsWith("else ") || trimmedLine.startsWith("else{") || trimmedLine.startsWith("switch ") || trimmedLine.startsWith("switch(") || trimmedLine.startsWith("case ") || trimmedLine.startsWith("default:")) {
+      return "control";
+    }
+    if (trimmedLine.startsWith("for ") || trimmedLine.startsWith("for(") || trimmedLine.startsWith("while ") || trimmedLine.startsWith("while(") || trimmedLine.startsWith("do ") || trimmedLine.startsWith("do{")) {
+      return "loop";
+    }
+    if (trimmedLine.startsWith("try ") || trimmedLine.startsWith("try{") || trimmedLine.startsWith("catch ") || trimmedLine.startsWith("catch(") || trimmedLine.startsWith("finally ") || trimmedLine.startsWith("finally{") || trimmedLine.startsWith("throw ")) {
+      return "exception";
+    }
+    if (trimmedLine.startsWith("const ") || trimmedLine.startsWith("let ") || trimmedLine.startsWith("var ") || trimmedLine.startsWith("function ") || trimmedLine.startsWith("class ") || trimmedLine.startsWith("interface ") || trimmedLine.startsWith("type ") || trimmedLine.startsWith("enum ") || trimmedLine.startsWith("export ")) {
+      return "declaration";
+    }
+    return "expression";
+  }
+  apply(source, filePath) {
+    const config = this.getSpacingConfig();
+    if (!config?.betweenStatementTypes) {
+      return source;
+    }
+    const lines = source.split("\n");
+    const result = [];
+    let lastStatementType = null;
+    let inImportSection = true;
+    for (let i = 0; i < lines.length; i++) {
+      const line = lines[i];
+      const trimmedLine = line.trim();
+      const isBlankLine = trimmedLine === "";
+      const isComment = trimmedLine.startsWith("//") || trimmedLine.startsWith("/*") || trimmedLine.startsWith("*");
+      const isImport = trimmedLine.startsWith("import ");
+      if (inImportSection && !isImport && !isBlankLine && !isComment) {
+        inImportSection = false;
+      }
+      if (inImportSection || isBlankLine || isComment) {
+        result.push(line);
+        continue;
+      }
+      const currentStatementType = this.getStatementType(trimmedLine);
+      if (lastStatementType !== null && lastStatementType !== currentStatementType && result.length > 0 && result[result.length - 1].trim() !== "") {
+        result.push("");
+      }
+      result.push(line);
+      lastStatementType = currentStatementType;
+    }
+    return result.join("\n");
+  }
+}
+exports.BlankLineBetweenStatementTypesRule = BlankLineBetweenStatementTypesRule;

package/dist/core/formatters/rules/spacing/BlockSpacingRule.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const BaseFormattingRule = require("../../BaseFormattingRule.js");
+class BlockSpacingRule extends BaseFormattingRule.BaseFormattingRule {
+  constructor() {
+    super(...arguments);
+    this.name = "BlockSpacingRule";
+  }
+  apply(source, filePath) {
+    let result = source;
+    result = result.replace(/\{\n\n+(\s*(?:\/\*\*|[a-zA-Z_]))/g, "{\n$1");
+    result = result.replace(/(\*\/)\n\n+(\s+[a-zA-Z_])/g, "$1\n$2");
+    result = result.replace(/\n\n+(\s*\})/g, "\n$1");
+    return result;
+  }
+}
+exports.BlockSpacingRule = BlockSpacingRule;