eslint-plugin-unslop 0.4.0 → 0.4.2

package/README.md

@@ -51,7 +51,7 @@ This turns on:
 | `unslop/export-control`      | error    | Restricts export patterns and forbids `export *` in module entrypoints |
 | `unslop/no-false-sharing`    | error    | Flags shared entrypoint symbols with fewer than two consumer groups    |
 | `unslop/no-special-unicode`  | error    | Catches smart quotes, invisible spaces, and other unicode impostors    |
-| `unslop/no-unicode-escape`   | error    | Prefers `"(c)"` over `"\u00A9"`                                        |
+| `unslop/no-unicode-escape`   | error    | Prefers `"©"` over `"\u00A9"`                                          |
 | `unslop/read-friendly-order` | error    | Enforces top-down, dependency-friendly declaration order               |
 
 The `configs.minimal` config contains only the zero-config symbol fixers (`no-special-unicode` and `no-unicode-escape`). It is included automatically within `configs.full`, or can be used standalone for projects that don't need architecture enforcement:
@@ -245,7 +245,7 @@ function assertCorrect(value) {
 
 ### `unslop/no-special-unicode`
 
-Disallows special unicode punctuation and whitespace characters in string literals and template literals. LLMs love to sprinkle in smart quotes (`"like this"`), non-breaking spaces, and other invisible gremlins that look fine in a PR review but cause fun bugs at runtime.
+Disallows special unicode punctuation and whitespace characters in string literals and template literals. LLMs love to sprinkle in smart quotes (`“like this”`), non-breaking spaces, and other invisible gremlins that look fine in a PR review but cause fun bugs at runtime.
 
 Caught characters include: left/right smart quotes (`“” ‘’`), non-breaking space, en/em dash, horizontal ellipsis, zero-width space, and various other exotic whitespace.
 
@@ -265,7 +265,7 @@ the problem this rule catches.
 
 ### `unslop/no-unicode-escape`
 
-Prefers actual characters over `\uXXXX` escape sequences. If your string says `\u00A9`, just write `(c)` - your coworkers will thank you. LLM-generated code sometimes encodes characters as escape sequences for no good reason.
+Prefers actual characters over `\uXXXX` escape sequences. If your string says `\u00A9`, just write `©` - your coworkers will thank you. LLM-generated code sometimes encodes characters as escape sequences for no good reason.
 
 ```js
 // Bad
@@ -273,8 +273,8 @@ const copyright = '\u00A9 2025'
 const arrow = '\u2192'
 
 // Good
-const copyright = '(c) 2025'
-const arrow = '->'
+const copyright = '© 2025'
+const arrow = '→'
 ```
 
 ## A Note on Provenance
@@ -283,58 +283,6 @@ Yes, a fair amount of this was vibe-coded with LLM assistance - which is fitting
 
 The project also dogfoods itself: `eslint-plugin-unslop` is linted using `eslint-plugin-unslop`.
 
-## Maintainer: Main Branch Protection
-
-This repository treats `main` as a protected branch with pull-request-only merges.
-
-Baseline policy:
-
-- Require pull requests before merge
-- Require at least 1 approving review
-- Dismiss stale approvals when new commits are pushed
-- Require branch to be up to date before merge
-- Require status check: `PR Gate`
-- Apply restrictions to admins too (`enforce_admins`)
-
-The required check is produced by `.github/workflows/test.yml` (workflow/job name: `PR Gate`) and runs:
-
-1. `npm run verify`
-2. `npm run test`
-
-### Safe Workflow Renames
-
-If you rename the workflow or job that produces `PR Gate`, update branch protection required checks immediately to match the new check context.
-
-Recommended update command:
-
-```bash
-gh api -X PUT repos/skhoroshavin/eslint-plugin-unslop/branches/main/protection \
-  -H "Accept: application/vnd.github+json" \
-  -F 'required_status_checks[strict]=true' \
-  -F 'required_status_checks[contexts][]=PR Gate' \
-  -F 'enforce_admins=true' \
-  -F 'required_pull_request_reviews[dismiss_stale_reviews]=true' \
-  -F 'required_pull_request_reviews[require_code_owner_reviews]=false' \
-  -F 'required_pull_request_reviews[required_approving_review_count]=1' \
-  -F 'restrictions=null'
-```
-
-### Branch Protection Audit
-
-Run these checks periodically:
-
-```bash
-gh api repos/skhoroshavin/eslint-plugin-unslop/branches/main/protection
-gh run list -workflow "Test" -limit 5
-```
-
-Expected audit outcomes:
-
-- `required_status_checks.contexts` includes `Test`
-- `required_pull_request_reviews.required_approving_review_count` is `1` or greater
-- `required_pull_request_reviews.dismiss_stale_reviews` is `true`
-- `enforce_admins.enabled` is `true`
-
 ## Contributing
 
 See [AGENTS.md](./AGENTS.md) for development setup and guidelines.

package/dist/index.cjs

@@ -37,7 +37,7 @@ module.exports = __toCommonJS(index_exports);
 // package.json
 var package_default = {
   name: "eslint-plugin-unslop",
-  version: "0.4.0",
+  version: "0.4.2",
   description: "ESLint plugin with rules for reducing AI-generated code smells",
   repository: {
     type: "git",
@@ -106,7 +106,7 @@ var package_default = {
 };
 
 // src/rules/no-special-unicode/index.ts
-var rule = {
+var no_special_unicode_default = {
   meta: {
     type: "suggestion",
     docs: {
@@ -216,10 +216,9 @@ function isSafe(entry, wrapper) {
 function formatCode(char) {
   return char.codePointAt(0).toString(16).toUpperCase().padStart(4, "0");
 }
-var no_special_unicode_default = rule;
 
 // src/rules/no-unicode-escape/index.ts
-var rule2 = {
+var no_unicode_escape_default = {
   meta: {
     type: "suggestion",
     docs: {
@@ -288,18 +287,17 @@ function replaceMatches(raw, matches) {
   return result;
 }
 var ESCAPE_RE = /\\u([0-9A-Fa-f]{4})/g;
+function isUnsafe(codePoint, wrapper) {
+  if (codePoint < 32) return true;
+  if (ALWAYS_UNSAFE.has(codePoint)) return true;
+  return codePoint === WRAPPER_UNSAFE[wrapper];
+}
 var ALWAYS_UNSAFE = /* @__PURE__ */ new Set([92]);
 var WRAPPER_UNSAFE = {
   '"': 34,
   "'": 39,
   "`": 96
 };
-function isUnsafe(codePoint, wrapper) {
-  if (codePoint < 32) return true;
-  if (ALWAYS_UNSAFE.has(codePoint)) return true;
-  return codePoint === WRAPPER_UNSAFE[wrapper];
-}
-var no_unicode_escape_default = rule2;
 
 // src/rules/no-false-sharing/index.ts
 var import_node_fs2 = __toESM(require("fs"), 1);
@@ -570,9 +568,7 @@ function hasStringName(value) {
 }
 
 // src/rules/no-false-sharing/index.ts
-var MIN_CONSUMER_GROUPS = 2;
-var LOCAL_SOURCE_RE = /(?:import|export)\s+(?:type\s+)?([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
-var rule3 = {
+var no_false_sharing_default = {
   meta: {
     type: "suggestion",
     docs: {
@@ -632,6 +628,7 @@ function reportUnsharedSymbols(context, node, options) {
     });
   }
 }
+var MIN_CONSUMER_GROUPS = 2;
 function collectExportedSymbols(program) {
   const symbols = /* @__PURE__ */ new Set();
   for (const statement of program.body) {
@@ -674,6 +671,26 @@ function findImporters(entrypointFile, sourceDir, sourceRoot, exportedSymbols) {
   scanDir(sourceDir, options);
   return options.importers;
 }
+function getConsumerGroup(importerPath, sourceDir) {
+  const rel = normalizePath(import_node_path2.default.relative(sourceDir, importerPath));
+  const parts = rel.split("/");
+  if (parts.length <= 1) return rel;
+  return parts.slice(0, -1).join("/");
+}
+function getSingleConsumerGroup(groups) {
+  if (groups.size === 0) return " (no consumers found)";
+  if (groups.size !== 1) return "";
+  const [single] = [...groups];
+  return ` (group: ${single})`;
+}
+function deriveProjectRoot(filename, sourceRoot) {
+  const normalized = normalizePath(filename);
+  const marker = `/${sourceRoot}/`;
+  const index = normalized.indexOf(marker);
+  if (index === -1) return void 0;
+  return normalized.slice(0, index);
+}
+var LOCAL_SOURCE_RE = /(?:import|export)\s+(?:type\s+)?([\s\S]*?)\s+from\s+['"]([^'"]+)['"]/g;
 function scanDir(dir, options) {
   let entries;
   try {
@@ -760,26 +777,6 @@ function parseNamedSymbol(raw) {
   const normalized = left.trim();
   return normalized.length > 0 ? normalized : void 0;
 }
-function getConsumerGroup(importerPath, sourceDir) {
-  const rel = normalizePath(import_node_path2.default.relative(sourceDir, importerPath));
-  const parts = rel.split("/");
-  if (parts.length <= 1) return rel;
-  return parts.slice(0, -1).join("/");
-}
-function getSingleConsumerGroup(groups) {
-  if (groups.size === 0) return " (no consumers found)";
-  if (groups.size !== 1) return "";
-  const [single] = [...groups];
-  return ` (group: ${single})`;
-}
-function deriveProjectRoot(filename, sourceRoot) {
-  const normalized = normalizePath(filename);
-  const marker = `/${sourceRoot}/`;
-  const index = normalized.indexOf(marker);
-  if (index === -1) return void 0;
-  return normalized.slice(0, index);
-}
-var no_false_sharing_default = rule3;
 
 // src/rules/read-friendly-order/ast-utils.ts
 function prop(obj, key) {
@@ -903,9 +900,55 @@ function walkNodeChildren(node, visit) {
     }
   }
 }
+function getDeclKind(node) {
+  const t = node.type;
+  if (t === "TSInterfaceDeclaration" || t === "TSTypeAliasDeclaration") {
+    return "type";
+  }
+  if (t === "ExportNamedDeclaration") {
+    const decl = prop(node, "declaration");
+    if (decl && typeof decl === "object") {
+      const declType = strProp(decl, "type");
+      if (declType === "TSInterfaceDeclaration" || declType === "TSTypeAliasDeclaration") {
+        return "type";
+      }
+      if (declType === "VariableDeclaration" || declType === "FunctionDeclaration") {
+        return getDeclKind(decl);
+      }
+    }
+    return "other";
+  }
+  if (t === "FunctionDeclaration") {
+    return "function";
+  }
+  if (t === "VariableDeclaration") {
+    const decls = prop(node, "declarations");
+    if (!Array.isArray(decls) || decls.length === 0) return "other";
+    const name = idName(decls[0]);
+    if (name && /^[A-Z][A-Z_0-9]*$/.test(name)) {
+      return "constant";
+    }
+    const initType = strProp(prop(decls[0], "init"), "type");
+    if (initType === "FunctionExpression" || initType === "ArrowFunctionExpression") {
+      return "function";
+    }
+    return "other";
+  }
+  return "other";
+}
+function isLocalPublicExport(node) {
+  if (node.type === "ExportNamedDeclaration") {
+    return !!prop(node, "declaration");
+  }
+  return false;
+}
 function isEagerInit(node) {
   const t = node.type;
   if (t === "ExpressionStatement" || t === "IfStatement") return true;
+  if (t === "ExportDefaultDeclaration") {
+    const declType = strProp(prop(node, "declaration"), "type");
+    return declType === "CallExpression" || declType === "NewExpression";
+  }
   const inner = t === "ExportNamedDeclaration" ? prop(node, "declaration") : node;
   if (strProp(inner, "type") !== "VariableDeclaration") return false;
   const decls = prop(inner, "declarations");
@@ -916,12 +959,26 @@ function isEagerInit(node) {
 }
 function isReexportNode(node) {
   if (node.type === "ExportNamedDeclaration") {
+    if (prop(node, "source")) return true;
+    return false;
+  }
+  if (node.type === "ExportAllDeclaration") {
+    return true;
+  }
+  return false;
+}
+function isLocalExportList(node) {
+  if (node.type === "ExportNamedDeclaration") {
+    if (prop(node, "source")) return false;
     if (prop(node, "declaration")) return false;
     const specs = prop(node, "specifiers");
     return Array.isArray(specs) && specs.length > 0;
   }
+  return false;
+}
+function isLocalExportDefault(node) {
   if (node.type === "ExportDefaultDeclaration") {
-    return strProp(prop(node, "declaration"), "type") === "Identifier";
+    return strProp(prop(node, "declaration"), "type") !== "Identifier";
   }
   return false;
 }
@@ -956,14 +1013,37 @@ function checkFieldOrder(ctx, members, classBody, hasComputed) {
 }
 function checkMethodOrder(ctx, members, classBody, hasComputed) {
   const methods = members.filter((m) => m.kind === "method");
+  const cyclic = findCyclicMethods(methods);
   for (const m of methods) {
-    if (!m.name) continue;
+    if (!m.name || cyclic.has(m.name)) continue;
     if (methods.some((o) => o !== m && o.thisDeps.has(m.name) && o.idx > m.idx)) {
       report(ctx, members, classBody, hasComputed, "moveMemberBelow", m);
       return;
     }
   }
 }
+function findCyclicMethods(methods) {
+  const byName = new Map(methods.filter((m) => m.name).map((m) => [m.name, m]));
+  const inCycle = /* @__PURE__ */ new Set();
+  for (const [name] of byName) {
+    if (methodReachesSelf(name, name, byName, /* @__PURE__ */ new Set())) {
+      inCycle.add(name);
+    }
+  }
+  return inCycle;
+}
+function methodReachesSelf(target, current, byName, visited) {
+  const entry = byName.get(current);
+  if (!entry) return false;
+  for (const dep of entry.thisDeps) {
+    if (!byName.has(dep)) continue;
+    if (dep === target) return true;
+    if (visited.has(dep)) continue;
+    visited.add(dep);
+    if (methodReachesSelf(target, dep, byName, visited)) return true;
+  }
+  return false;
+}
 function report(ctx, members, classBody, hasComputed, messageId, target) {
   const input = { ctx, members, classBody, hasComputed, messageId, target };
   doReport(input);
@@ -1134,7 +1214,7 @@ function buildPhaseOrder(p, calls) {
 }
 
 // src/rules/read-friendly-order/index.ts
-var rule4 = {
+var read_friendly_order_default = {
   meta: {
     type: "suggestion",
     docs: {
@@ -1166,11 +1246,25 @@ var rule4 = {
     };
   }
 };
+function checkTopLevel(ctx, p) {
+  const entries = collectEntries(p);
+  const decls = entries.filter((e) => !e.isImport && !e.isExternalReexport);
+  filterDepsToLocal(decls);
+  const eager = buildEagerSet(decls);
+  const cyclic = findCyclic(decls);
+  const violations = findViolations(decls, eager, cyclic);
+  if (violations.length === 0) return;
+  reportAll(ctx, violations, p, entries);
+}
 function collectEntries(p) {
   const entries = [];
   for (let i = 0; i < p.body.length; i++) {
     const stmt = p.body[i];
     const name = getDeclName(stmt);
+    const isExternalReexport = isReexportNode(stmt);
+    const isLocalExport = isLocalExportList(stmt);
+    const isExportDefault = isLocalExportDefault(stmt);
+    const isPublicExport = isLocalPublicExport(stmt);
     entries.push({
       node: stmt,
       idx: i,
@@ -1178,7 +1272,10 @@ function collectEntries(p) {
       deps: collectDeps(stmt, name),
       eager: isEagerInit(stmt),
       isImport: stmt.type === "ImportDeclaration",
-      isReexport: isReexportNode(stmt)
+      isExternalReexport,
+      isLocalExportList: isLocalExport,
+      isLocalExportDefault: isExportDefault,
+      isLocalPublicExport: isPublicExport
     });
   }
   return entries;
@@ -1236,17 +1333,6 @@ function doReachesSelf(args) {
   }
   return false;
 }
-function checkTopLevel(ctx, p) {
-  const entries = collectEntries(p);
-  const decls = entries.filter((e) => !e.isImport && !e.isReexport);
-  filterDepsToLocal(decls);
-  const eager = buildEagerSet(decls);
-  const cyclic = findCyclic(decls);
-  const violations = findViolations(decls, eager, cyclic);
-  if (violations.length === 0) return;
-  const safe = isFixSafe(ctx, entries);
-  reportAll(ctx, violations, safe, p, entries);
-}
 function filterDepsToLocal(decls) {
   const localNames = new Set(decls.filter((e) => e.name).map((e) => e.name));
   for (const e of decls) {
@@ -1258,21 +1344,32 @@ function findViolations(decls, eager, cyclic) {
   for (const e of decls) {
     if (!e.name || eager.has(e.name) || cyclic.has(e.name)) continue;
     const consumer = firstConsumer(e.name, decls);
-    if (consumer && e.idx < consumer.idx) violations.push(e);
+    if (!consumer) continue;
+    const eBand = getBand(e);
+    const consumerBand = getBand(consumer);
+    if (e.idx < consumer.idx && eBand >= consumerBand) {
+      violations.push(e);
+    }
   }
   return violations;
 }
+function getBand(entry) {
+  if (entry.isImport) return 1;
+  if (entry.isExternalReexport) return 2;
+  if (entry.isLocalExportList || entry.isLocalExportDefault || entry.isLocalPublicExport) return 3;
+  return 4;
+}
 function firstConsumer(name, decls) {
   let best;
   for (const e of decls) {
-    if (e.name === name || e.isReexport) continue;
+    if (e.name === name || e.isExternalReexport || e.isLocalExportList) continue;
     if (!e.deps.has(name)) continue;
     if (!best || e.idx < best.idx) best = e;
   }
   return best;
 }
-function reportAll(ctx, violations, safe, p, entries) {
-  doReportAll({ ctx, violations, safe, p, entries });
+function reportAll(ctx, violations, p, entries) {
+  doReportAll({ ctx, violations, p, entries });
 }
 function doReportAll(args) {
   for (let i = 0; i < args.violations.length; i++) {
@@ -1281,37 +1378,52 @@ function doReportAll(args) {
       node: v.node,
       messageId: isConst(v.name) ? "moveConstantBelow" : "moveHelperBelow",
       data: { name: v.name },
-      fix: args.safe && i === 0 ? buildTopFix(args.ctx, args.p, args.entries) : null
+      fix: i === 0 ? buildTopFix(args.ctx, args.p, args.entries) : null
     });
   }
 }
-function isFixSafe(ctx, entries) {
-  const src = ctx.sourceCode;
-  const stmts = entries.filter((e) => !e.isImport);
-  for (let i = 0; i < stmts.length - 1; i++) {
-    const cur = stmts[i].node;
-    const nxt = stmts[i + 1].node;
-    for (const c of src.getCommentsBefore(nxt)) {
-      if (c.range[0] > cur.range[1]) return false;
-    }
-  }
-  return true;
-}
 function isConst(name) {
   return /^[A-Z][A-Z_0-9]+$/.test(name);
 }
 function buildTopFix(ctx, p, entries) {
   return (fixer) => {
     const src = ctx.sourceCode;
+    const nodeTexts = buildNodeTexts(src, entries);
     const imports = entries.filter((e) => e.isImport);
-    const reexports = entries.filter((e) => e.isReexport);
-    const decls = entries.filter((e) => !e.isImport && !e.isReexport);
-    const sorted = kahnsSort(decls);
-    const all = [...imports, ...sorted, ...reexports];
-    const text = all.map((e) => src.getText(e.node)).join("\n\n");
+    const externalReexports = entries.filter((e) => e.isExternalReexport);
+    const localPublicApi = entries.filter(
+      (e) => e.isLocalExportList || e.isLocalExportDefault || e.isLocalPublicExport
+    );
+    const sortedPublicApi = kahnsSort(localPublicApi);
+    const exportDefaultEntry = sortedPublicApi.find((e) => e.isLocalExportDefault);
+    const otherPublicApi = sortedPublicApi.filter((e) => !e.isLocalExportDefault);
+    const prioritizedPublicApi = exportDefaultEntry ? [exportDefaultEntry, ...otherPublicApi] : otherPublicApi;
+    const privateDecls = entries.filter(
+      (e) => !e.isImport && !e.isExternalReexport && !e.isLocalExportList && !e.isLocalExportDefault && !e.isLocalPublicExport
+    );
+    const sortedPrivate = kahnsSort(privateDecls);
+    const all = [...imports, ...externalReexports, ...prioritizedPublicApi, ...sortedPrivate];
+    const text = all.map((e) => nodeTexts.get(e)).join("\n\n");
     return fixer.replaceTextRange([p.range[0], p.range[1]], text);
   };
 }
+function buildNodeTexts(src, entries) {
+  const result = /* @__PURE__ */ new Map();
+  for (let i = 0; i < entries.length; i++) {
+    const e = entries[i];
+    const comments = src.getCommentsBefore(e.node);
+    const prevEnd = i > 0 ? entries[i - 1].node.range[1] : e.node.range[0];
+    const leadingComments = comments.filter((c) => c.range[0] >= prevEnd);
+    if (leadingComments.length > 0) {
+      const commentStart = leadingComments[0].range[0];
+      const fullText = src.getText().slice(commentStart, e.node.range[1]);
+      result.set(e, fullText);
+    } else {
+      result.set(e, src.getText(e.node));
+    }
+  }
+  return result;
+}
 function kahnsSort(decls) {
   const byName = new Map(decls.filter((e) => e.name).map((e) => [e.name, e]));
   const inDeg = buildInDegrees(decls, byName);
@@ -1331,8 +1443,25 @@ function drainKahns2(decls, inDeg, byName) {
   const queue = decls.filter((e) => !e.name || inDeg.get(e.name) === 0);
   const result = [];
   const placed = /* @__PURE__ */ new Set();
+  const kindPriority = (e) => {
+    const kind = getDeclKind(e.node);
+    switch (kind) {
+      case "constant":
+        return 0;
+      case "type":
+        return 1;
+      case "function":
+        return 2;
+      default:
+        return 3;
+    }
+  };
   while (queue.length > 0) {
-    queue.sort((a, b) => a.idx - b.idx);
+    queue.sort((a, b) => {
+      const priorityDiff = kindPriority(a) - kindPriority(b);
+      if (priorityDiff !== 0) return priorityDiff;
+      return a.idx - b.idx;
+    });
     const e = queue.shift();
     result.push(e);
     if (e.name) placed.add(e.name);
@@ -1350,11 +1479,10 @@ function drainKahns2(decls, inDeg, byName) {
   }
   return result;
 }
-var read_friendly_order_default = rule4;
 
 // src/rules/import-control/index.ts
 var import_node_path3 = __toESM(require("path"), 1);
-var rule5 = {
+var import_control_default = {
   meta: {
     type: "problem",
     docs: {
@@ -1475,10 +1603,9 @@ function isRelativeTooDeep(specifier) {
 function allowsImport(policy, targetMatcher) {
   return policy.imports.includes("*") || policy.imports.includes(targetMatcher);
 }
-var import_control_default = rule5;
 
 // src/rules/export-control/index.ts
-var rule6 = {
+var export_control_default = {
   meta: {
     type: "problem",
     docs: {
@@ -1487,7 +1614,7 @@ var rule6 = {
     },
     schema: [],
     messages: {
-      exportAllForbidden: "Export denied: export * is not allowed in module entrypoints.",
+      exportAllForbidden: "Export denied: export * is not allowed.",
       symbolDenied: 'Export denied: symbol "{{symbol}}" does not match configured exports patterns.',
       invalidExportRegex: 'Configuration error: invalid exports pattern "{{pattern}}"'
     }
@@ -1496,8 +1623,7 @@ var rule6 = {
     const filename = context.filename;
     if (!filename) return {};
     const state = buildRuleState(context, filename);
-    if (state === void 0) return {};
-    if (state.invalidPattern !== void 0) {
+    if (state?.invalidPattern !== void 0) {
       const root = context.getSourceCode().ast;
       context.report({
         node: root,
@@ -1508,14 +1634,13 @@ var rule6 = {
     }
     return {
       ExportNamedDeclaration(node) {
-        checkNamedExport(context, node, state.patterns, state.shouldForbidExportAll);
+        checkNamedExport(context, node, state?.patterns, state?.shouldForbidExportAll ?? true);
       },
       ExportAllDeclaration(node) {
-        if (!state.shouldForbidExportAll) return;
         checkExportAll(context, node);
       },
       ExportDefaultDeclaration(node) {
-        if (state.patterns === void 0) return;
+        if (state?.patterns === void 0) return;
         checkDefaultExport(context, node, state.patterns);
       }
     };
@@ -1583,7 +1708,6 @@ function checkExportAll(context, node) {
 function matchesAnyPattern(symbol, patterns) {
   return patterns.some((pattern) => pattern.test(symbol));
 }
-var export_control_default = rule6;
 
 // src/rules/index.ts
 var rules_default = {