eslint-plugin-runtime-cleanup 1.2.8

package/dist/plugin.cjs

@@ -0,0 +1,3693 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// dist/plugin.js
+var plugin_exports = {};
+__export(plugin_exports, {
+  default: () => plugin_default
+});
+module.exports = __toCommonJS(plugin_exports);
+var import_parser = __toESM(require("@typescript-eslint/parser"), 1);
+
+// package.json
+var package_default = {
+  $schema: "https://www.schemastore.org/package.json",
+  name: "eslint-plugin-runtime-cleanup",
+  version: "1.2.8",
+  private: false,
+  description: "ESLint rules for requiring cleanup of runtime resources.",
+  keywords: [
+    "eslint",
+    "eslint-plugin",
+    "eslintplugin",
+    "cleanup",
+    "resources",
+    "runtime",
+    "typescript"
+  ],
+  homepage: "https://nick2bad4u.github.io/eslint-plugin-runtime-cleanup/",
+  bugs: {
+    url: "https://github.com/Nick2bad4u/eslint-plugin-runtime-cleanup/issues",
+    email: "20943337+Nick2bad4u@users.noreply.github.com"
+  },
+  repository: {
+    type: "git",
+    url: "git+https://github.com/Nick2bad4u/eslint-plugin-runtime-cleanup.git"
+  },
+  license: "MIT",
+  author: "Nick2bad4u <20943337+Nick2bad4u@users.noreply.github.com> (https://github.com/Nick2bad4u)",
+  contributors: [
+    {
+      name: "Nick2bad4u",
+      email: "20943337+Nick2bad4u@users.noreply.github.com",
+      url: "https://github.com/Nick2bad4u"
+    }
+  ],
+  sideEffects: false,
+  type: "module",
+  exports: {
+    ".": {
+      import: {
+        types: "./dist/plugin.d.ts",
+        default: "./dist/plugin.js"
+      },
+      require: {
+        types: "./dist/plugin.d.cts",
+        default: "./dist/plugin.cjs"
+      },
+      default: "./dist/plugin.js"
+    },
+    "./package.json": "./package.json"
+  },
+  main: "./dist/plugin.cjs",
+  types: "./dist/plugin.d.ts",
+  files: [
+    "dist",
+    "docs/rules/**",
+    "CHANGELOG.md"
+  ],
+  workspaces: [
+    "docs/docusaurus"
+  ],
+  scripts: {
+    prebench: "npm run build",
+    bench: "node benchmarks/run-eslint-stats.mjs",
+    "prebench:compare": "npm run build",
+    "bench:compare": "node benchmarks/run-eslint-stats.mjs --iterations=6 --warmup=2 --compare=coverage/benchmarks/eslint-stats.json",
+    "prebench:eslint:stats": "npm run build",
+    "bench:eslint:stats": "node benchmarks/run-eslint-stats.mjs",
+    "prebench:eslint:timing": "npm run build",
+    "bench:eslint:timing": 'cross-env TIMING=all eslint --config benchmarks/eslint-timing.config.mjs --stats "test/fixtures/typed/*.invalid.ts"',
+    "prebench:rule-benchmark": "npm run build",
+    "bench:rule-benchmark": "eslint-rule-benchmark run",
+    "prebench:ui": "npm run build",
+    "bench:ui": "vitest bench --ui",
+    "prebench:watch": "npm run build",
+    "bench:watch": "vitest bench",
+    build: "tsc -b tsconfig.build.json --force && npm run build:types:cjs && npm run build:cjs",
+    "build:cjs": 'esbuild dist/plugin.js --bundle --format=cjs --platform=node --packages=external --sourcemap --outfile=dist/plugin.cjs --footer:js="module.exports = module.exports.default;"',
+    "build:clean": `node -e "require('node:fs').rmSync('dist',{recursive:true,force:true})"`,
+    "build:eslint-inspector": 'npx -y @eslint/config-inspector@latest build --outDir "docs/docusaurus/static/eslint-inspector" --base "/eslint-plugin-runtime-cleanup/eslint-inspector/"',
+    "build:eslint-inspector:local": "npx @eslint/config-inspector",
+    "build:stylelint-inspector": 'npx -y stylelint-config-inspector@latest build --outDir "docs/docusaurus/static/stylelint-inspector" --base "/eslint-plugin-runtime-cleanup/stylelint-inspector/"',
+    "build:stylelint-inspector:local": "npx stylelint-config-inspector@latest",
+    "build:types:cjs": `node -e "require('node:fs').copyFileSync('dist/plugin.d.ts','dist/plugin.d.cts')"`,
+    changelog: "git-cliff --config cliff.toml --current",
+    "changelog:generate": "git-cliff --config cliff.toml --output CHANGELOG.md",
+    "changelog:preview": "git-cliff --config cliff.toml --unreleased",
+    "changelog:release-notes": "git-cliff --config cliff.toml --latest --strip all",
+    "clean:cache": "del-cli dist coverage cache .cache .vite .turbo",
+    "clean:cache:coverage": "del-cli coverage .coverage",
+    "clean:cache:dist": "del-cli dist release",
+    "clean:cache:eslint": "del-cli .cache/.eslintcache",
+    "clean:cache:ncu": "del-cli .cache/.ncu-cache.json",
+    "clean:cache:prettier": "del-cli .cache/.prettier-cache .prettier-cache .prettiercache",
+    "clean:cache:stryker": "del-cli .stryker-tmp",
+    "clean:cache:stylelint": "del-cli .cache/stylelintcache stylelintcache .stylelintcache",
+    "clean:cache:temp": 'del-cli ".temp/**"',
+    "clean:cache:typescript": "del-cli .cache/**.tsbuildinfo .cache/builds",
+    "clean:cache:vite": "del-cli .cache/vite .cache/vitest .cache/vitest-zero-coverage .cache/vite-zero-coverage",
+    "clean:database": "del-cli %appdata%/uptime-watcher/uptime-watcher.sqlite",
+    "clean:docs": "del-cli docs/docusaurus/.docusaurus/** docs/docusaurus/build/** docs/docusaurus/site-docs/developer/api/**",
+    "clean:docusaurus": "npm run clean:docs && npm run --workspace docs/docusaurus clear",
+    "cognitive-complexity": "cognitive-complexity-ts --threshold 10",
+    precommit: "npm run sync:rules:write",
+    commit: "git-cz",
+    contrib: "all-contributors",
+    "contrib:add": "all-contributors add",
+    "contrib:check": "all-contributors check",
+    "contrib:compare": "npm run contrib:check",
+    "contrib:generate": "all-contributors generate",
+    coverage: "vitest run --coverage",
+    "docs:api": "npm run --workspace docs/docusaurus docs:api",
+    "docs:api:local": "npm run --workspace docs/docusaurus docs:api:local",
+    "docs:build": "npm run --workspace docs/docusaurus build",
+    "docs:build:local": "npm run --workspace docs/docusaurus build:local",
+    "docs:check-links": "npm run docs:api && node ./scripts/check-doc-links.mjs",
+    "docs:devtools:metadata": "node scripts/generate-devtools-workspace-metadata.mjs",
+    "docs:serve": "npm run --workspace docs/docusaurus serve",
+    "docs:start": "npm run --workspace docs/docusaurus start",
+    "docs:start:devtools": "npm run docs:devtools:metadata && npm run docs:api:local && npm run --workspace docs/docusaurus start:devtools",
+    "docs:toc": "remark docs --use remark-toc --output",
+    "docs:typecheck": "npm run --workspace docs/docusaurus typecheck",
+    "docs:typedoc": "npm run --workspace docs/docusaurus docs:api",
+    "docs:typedoc:local": "npm run --workspace docs/docusaurus docs:api:local",
+    "docs:validate-links": "remark docs --use remark-validate-links --frail",
+    knip: "cross-env NODE_OPTIONS=--max_old_space_size=4096 NODE_NO_WARNINGS=1 npx knip -c knip.config.ts --cache --cache-location .cache/knip --tsConfig tsconfig.json",
+    lint: "cross-env NODE_OPTIONS=--max_old_space_size=16384 eslint . --cache --cache-strategy content --cache-location .cache/.eslintcache",
+    "lint:action": "npm run lint:actions",
+    "lint:actions": "node scripts/lint-actionlint.mjs",
+    "lint:all": "npm run lint && npm run typecheck && npm run lint:css && npm run lint:prettier && npm run lint:remark && npm run lint:package && npm run lint:secretlint && npm run lint:yaml && npm run lint:actions && npm run lint:circular && npm run sync:rules:check",
+    "lint:all:fix": "npm run lint:fix && npm run typecheck && npm run lint:css:fix && npm run lint:prettier:fix && npm run lint:remark && npm run lint:package && npm run lint:secretlint && npm run lint:yaml:fix && npm run lint:actions && npm run lint:circular && npm run sync:rules:write",
+    "lint:all:fix:quiet": "npm run lint:fix:quiet && npm run typecheck && npm run lint:css:fix && npm run lint:prettier:fix && npm run lint:remark && npm run lint:package && npm run lint:secretlint && npm run lint:yaml:fix && npm run lint:actions && npm run lint:circular && npm run sync:rules:write",
+    "lint:circular": "npm run madge:circular",
+    "lint:compat:eslint9": "node scripts/eslint9-compat-smoke.mjs",
+    "lint:config:build": "npm run build:eslint-inspector",
+    "lint:config:inspect": "npx eslint --inspect-config",
+    "lint:css": 'stylelint --cache --config stylelint.config.mjs --cache-strategy content --cache-location .cache/stylelintcache src/ docs/ --custom-formatter stylelint-formatter-pretty && echo "Stylelint done!"',
+    "lint:css:fix": 'stylelint --cache --config stylelint.config.mjs --cache-strategy content --cache-location .cache/stylelintcache src/ docs/ --custom-formatter stylelint-formatter-pretty --fix && echo "Stylelint done!"',
+    "lint:depcheck": "npm run knip -- --dependencies",
+    "lint:deps": "npm run knip -- --dependencies",
+    "lint:dupes": "jscpd src/ --config jscpd.json",
+    "lint:dupes:all": "jscpd src/ --config jscpd.json --min-lines 3",
+    "lint:dupes:skiplocal": "jscpd src/ --skipLocal --config jscpd.json",
+    "lint:dupes:skiplocal:all": "jscpd src/ --skipLocal --config jscpd.json --min-lines 3",
+    "lint:duplicates": "npm run lint:dupes",
+    "lint:exports": "ts-unused-exports tsconfig.json src/plugin.ts --excludePathsFromReport=plugin.ts",
+    "lint:fix": "cross-env NODE_OPTIONS=--max_old_space_size=16384 eslint . --cache --cache-strategy content --cache-location .cache/.eslintcache --fix",
+    "lint:fix:quiet": 'cross-env ESLINT_PROGRESS=off NODE_OPTIONS=--max_old_space_size=16384 eslint . --cache --cache-strategy content --cache-location .cache/.eslintcache --fix && echo "Eslint fix done!"',
+    "lint:grype": "grype . -c .grype.yaml --name eslint-plugin-runtime-cleanup",
+    "lint:knip": "npm run knip",
+    "lint:knip:exports": "npm run knip -- --include exports,nsExports,classMembers,types,nsTypes,enumMembers,duplicates",
+    "lint:knip:unused:exports": "npm run knip -- --dependencies --exports",
+    "lint:leaves": "npm run madge:leaves",
+    "lint:metrics": "npm run sloc",
+    "lint:nocache": "cross-env NODE_OPTIONS=--max_old_space_size=16384 eslint .",
+    "lint:node-version-files": "node scripts/sync-node-version-files.mjs --check",
+    "lint:orphans": "npm run madge:orphans",
+    "lint:package": 'npm run lint:node-version-files && npm run lint:package-sort && npm run lint:packagelintrc && echo "Package.json lint done!"',
+    "lint:package:strict": 'npm run lint:node-version-files && npm run lint:package-sort && npm run lint:package-check:strict && npm run lint:packagelintrc && echo "Package.json lint done!"',
+    "lint:package-check": "publint && attw --pack .",
+    "lint:package-check:strict": "publint && node scripts/check-package-types.mjs",
+    "lint:package-sort": 'sort-package-json "./package.json" "./docs/docusaurus/package.json"',
+    "lint:package-sort-check": 'sort-package-json --check "./package.json" "./docs/docusaurus/package.json"',
+    "lint:packagelintrc": "npmPkgJsonLint . --config .npmpackagejsonlintrc.json",
+    "lint:prettier": "prettier . --log-level warn --cache --cache-location=.cache/.prettier-cache --cache-strategy=content --check",
+    "lint:prettier:fix": "prettier . --log-level warn --cache --cache-location=.cache/.prettier-cache --cache-strategy=content --write",
+    "lint:publint": "publint",
+    "lint:quiet": 'cross-env ESLINT_PROGRESS=nofile NODE_OPTIONS=--max_old_space_size=16384 eslint . --cache --cache-strategy content --cache-location .cache/.eslintcache && echo "Eslint done!"',
+    "lint:remark": 'remark --rc-path .remarkrc.mjs --silently-ignore --ignore-path .remarkignore --frail "*.{md,mdx}" "docs/**/*.{md,mdx}" --quiet',
+    "lint:remark:fix": 'prettier --log-level warn --ignore-path prettierignore.remark --cache --cache-location=.cache/.prettier-cache --cache-strategy=content --no-error-on-unmatched-pattern --write "*.{md,mdx}" "docs/**/*.{md,mdx}" && npm run remark:fix',
+    "lint:secretlint": 'secretlint --secretlintrc .secretlintrc.cjs --secretlintignore .secretlintignore "./*" ".vscode/**" "assets/**" "src/**" "electron/**" "shared/**" "config/**" "scripts/**" "playwright/**" "storybook/**" ".storybook" "tests/**" "benchmarks/**" ".devin/**" "public/**" ".github/**" "docs/Architecture/**" "docs/*" "docs/assets/**" "docs/Guides/**" "docs/Testing/**" "docs/TSDoc/**" "docs/docusaurus/src/**" "docs/docusaurus/static/**" "docs/docusaurus/blog/**" "docs/docusaurus/docs/**" "docs/docusaurus/docs/*"',
+    "lint:secrets": "detect-secrets scan",
+    "lint:unused": "npm run knip -- --include unlisted,unresolved,duplicates",
+    "lint:unused-deps": "npm run knip -- --dependencies",
+    "lint:yaml": 'cross-env NODE_OPTIONS=--max_old_space_size=16384 eslint --cache --cache-strategy content --cache-location .cache/.eslintcache "**/*.{yml,yaml}" && echo "YAML lint done!"',
+    "lint:yaml:fix": 'cross-env NODE_OPTIONS=--max_old_space_size=16384 eslint --cache --cache-strategy content --cache-location .cache/.eslintcache --fix "**/*.{yml,yaml}" && echo "YAML lint (fix) done!"',
+    "madge:circular": 'madge --circular --json --no-spinner --ts-config tsconfig.json --extensions ts,tsx,js,jsx,mjs,cjs,cts,mts ./src --exclude "(^|[\\/])(test|dist|node_modules|cache|.cache|coverage|build|eslint-inspector|temp|.docusaurus)($|[\\/])|\\.css$"',
+    "madge:leaves": 'madge --leaves --no-spinner --ts-config tsconfig.json --extensions ts,tsx,js,jsx,mjs,cjs,cts,mts ./src --exclude "(^|[\\/])(test|dist|node_modules|cache|.cache|coverage|build|eslint-inspector|temp|.docusaurus)($|[\\/])|\\.css$"',
+    "madge:orphans": 'madge --orphans --no-spinner --ts-config tsconfig.json --extensions ts,tsx,js,jsx,mjs,cjs,cts,mts ./src --exclude "(^|[\\/])(test|dist|node_modules|cache|.cache|coverage|build|eslint-inspector|temp|.docusaurus)($|[\\/])|\\.css$"',
+    "open:coverage": "open-cli coverage/index.html",
+    prepublishOnly: "npm run release:check",
+    "release:check": "npm run release:verify",
+    "release:verify": "cross-env NODE_OPTIONS= npm run build && cross-env NODE_OPTIONS= npm run lint:nocache && cross-env NODE_OPTIONS= npm run typecheck && cross-env NODE_OPTIONS= VITEST_TYPECHECK=false npm run test && cross-env NODE_OPTIONS= npm run sync:rules:check && cross-env NODE_OPTIONS= npm run docs:check-links && cross-env NODE_OPTIONS= npm run lint:package:strict",
+    "remark:fix": 'remark --rc-path .remarkrc.mjs --silently-ignore --ignore-path .remarkignore --frail --quiet --output -- "*.{md,mdx}" "docs/**/*.{md,mdx}"',
+    "remark:test-config": 'remark --rc-path .remarkrc.mjs --silently-ignore --ignore-path .remarkignore --frail "README.md"',
+    size: "size-limit",
+    "sync:node-version-files": "node scripts/sync-node-version-files.mjs",
+    "sync:peer-eslint-range": "node scripts/sync-peer-eslint-range.mjs",
+    "sync:presets-rules-matrix": "node scripts/sync-presets-rules-matrix.mjs",
+    "sync:readme-rules-table": "node scripts/sync-readme-rules-table.mjs",
+    "sync:readme-rules-table:update": "npm run build && cross-env RUNTIME_CLEANUP_UPDATE_GENERATED_DOCS=1 vitest run test/readme-rules-table-sync.test.ts -u",
+    "sync:readme-rules-table:write": "node scripts/sync-readme-rules-table.mjs --write",
+    "sync:rules:check": "npm run sync:readme-rules-table && npm run sync:presets-rules-matrix",
+    "sync:rules:write": "npm run sync:readme-rules-table:write && node scripts/sync-presets-rules-matrix.mjs --write",
+    pretest: "npm run build",
+    test: "vitest run",
+    "test:autofix:fixtures": `node -e "console.log('No autofix fixtures are defined yet.')"`,
+    "test:autofix:fixtures:typed": `node -e "console.log('No typed autofix fixtures are defined yet.')"`,
+    "test:ci": "cross-env CI=true vitest run --reporter=default",
+    "test:coverage": "vitest run --coverage --reporter=default",
+    "test:coverage:detailed": "vitest run --coverage --reporter=verbose",
+    "test:coverage:minimal": "vitest run --coverage --reporter=dot",
+    "test:coverage:open": "npm run test:coverage && npm run open:coverage",
+    "test:coverage:quiet": "vitest run --coverage --reporter=default --silent",
+    "test:coverage:verbose": "vitest run --coverage --reporter=verbose",
+    "test:detailed": "vitest run --reporter=verbose",
+    "test:minimal": "vitest run --reporter=dot",
+    "test:open": "npm run test:coverage && npm run open:coverage",
+    "test:quiet": "vitest run --reporter=default --silent",
+    "test:serial": "cross-env MAX_THREADS=1 vitest run",
+    "test:stryker": "stryker run --ignoreStatic --concurrency 12 --incrementalFile .cache/stryker/incremental-fast.json",
+    "test:stryker:ci": "cross-env CI=true stryker run --ignoreStatic --concurrency 2 --incrementalFile .cache/stryker/incremental-fast-ci.json",
+    "test:stryker:full": "stryker run --concurrency 12 --incrementalFile .cache/stryker/incremental-full.json",
+    "test:stryker:full:ci": "cross-env CI=true stryker run --concurrency 2 --incrementalFile .cache/stryker/incremental-full-ci.json",
+    "test:verbose": "vitest run --reporter=verbose",
+    "test:watch": "vitest",
+    typecheck: "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.build.json --noEmit && tsc -p tsconfig.eslint.json --noEmit && tsc -p tsconfig.js.json --noEmit && npm run --workspace docs/docusaurus typecheck",
+    "typecheck:all": "npm run typecheck",
+    "types:update": "typesync",
+    "update-deps": "npx ncu -i --install never && npm update --workspaces --force && npm install --force && npm run sync:peer-eslint-range && npm run sync:node-version-files && npm run sync:rules:write",
+    "verify:readme-rules-table": "npm run build && npm run sync:rules:write"
+  },
+  overrides: {
+    "jsonc-eslint-parser": "$jsonc-eslint-parser"
+  },
+  dependencies: {
+    "@typescript-eslint/parser": "^8.59.3",
+    "@typescript-eslint/type-utils": "^8.59.3",
+    "@typescript-eslint/utils": "^8.59.3"
+  },
+  devDependencies: {
+    "@arethetypeswrong/cli": "^0.18.2",
+    "@csstools/stylelint-formatter-github": "^2.0.0",
+    "@double-great/remark-lint-alt-text": "^1.1.1",
+    "@eslint/config-inspector": "^3.0.2",
+    "@microsoft/tsdoc-config": "^0.18.1",
+    "@size-limit/file": "^12.1.0",
+    "@stryker-ignorer/console-all": "^0.3.2",
+    "@stryker-mutator/core": "^9.6.1",
+    "@stryker-mutator/typescript-checker": "^9.6.1",
+    "@stryker-mutator/vitest-runner": "^9.6.1",
+    "@types/htmlhint": "^1.1.5",
+    "@types/madge": "^5.0.3",
+    "@types/node": "^25.8.0",
+    "@types/sloc": "^0.2.3",
+    "@typescript-eslint/rule-tester": "^8.59.3",
+    "@vitest/coverage-v8": "^4.1.6",
+    "@vitest/ui": "^4.1.6",
+    actionlint: "^2.0.6",
+    "all-contributors-cli": "^6.26.1",
+    "cognitive-complexity-ts": "^0.8.1",
+    commitlint: "^21.0.1",
+    "commitlint-config-gitmoji": "^2.3.1",
+    "cross-env": "^10.1.0",
+    "del-cli": "^7.0.0",
+    "detect-secrets": "^1.0.6",
+    esbuild: "^0.28.0",
+    eslint: "^10.4.0",
+    "eslint-config-nick2bad4u": "^1.0.16",
+    "eslint-formatter-unix": "^9.0.1",
+    "eslint-rule-benchmark": "^0.8.0",
+    "fast-check": "^4.8.0",
+    "git-cliff": "^2.13.1",
+    "gitleaks-secret-scanner": "^2.1.1",
+    htmlhint: "^1.9.2",
+    jscpd: "^4.2.2",
+    knip: "^6.14.1",
+    leasot: "^14.4.0",
+    madge: "^8.0.0",
+    "markdown-link-check": "^3.14.2",
+    "npm-check-updates": "^22.2.0",
+    "npm-package-json-lint": "^10.4.0",
+    picocolors: "^1.1.1",
+    prettier: "^3.8.3",
+    "prettier-config-nick2bad4u": "^1.0.13",
+    "prettier-plugin-jsdoc-type": "^0.2.0",
+    publint: "^0.3.21",
+    "rehype-katex": "^7.0.1",
+    remark: "^15.0.1",
+    "remark-cli": "^12.0.1",
+    "remark-config-nick2bad4u": "^1.0.2",
+    secretlint: "^13.0.2",
+    "secretlint-config-nick2bad4u": "^1.0.5",
+    "size-limit": "^12.1.0",
+    sloc: "^0.3.2",
+    "sort-package-json": "^3.6.1",
+    stylelint: "^17.11.1",
+    "stylelint-config-nick2bad4u": "^1.0.11",
+    "ts-unused-exports": "^11.0.1",
+    typedoc: "^0.28.19",
+    typescript: "^6.0.3",
+    "typescript-eslint": "^8.59.3",
+    typesync: "^0.14.3",
+    vfile: "^6.0.3",
+    vite: "^8.0.13",
+    "vite-tsconfig-paths": "^6.1.1",
+    vitest: "^4.1.6",
+    "yamllint-js": "^0.2.4"
+  },
+  peerDependencies: {
+    eslint: "^9.0.0 || ^10.4.0",
+    typescript: "^5.0.0 || ^6.0.2"
+  },
+  packageManager: "npm@11.14.1",
+  engines: {
+    node: ">=22.0.0"
+  },
+  devEngines: {
+    runtime: {
+      name: "node",
+      version: ">=22.0.0",
+      onFail: "error"
+    },
+    packageManager: {
+      name: "npm",
+      version: ">=11.0.0",
+      onFail: "error"
+    }
+  },
+  publishConfig: {
+    provenance: true,
+    registry: "https://registry.npmjs.org/"
+  },
+  readme: "README.md"
+};
+
+// dist/rules/no-floating-abort-controllers.js
+var import_utils3 = require("@typescript-eslint/utils");
+
+// dist/_internal/ast-node.js
+var import_utils = require("@typescript-eslint/utils");
+
+// dist/_internal/cycle-safe-linked-search.js
+var FLOYD_FAST_POINTER_ADVANCE_STEPS = 2;
+var resolveFirstValueInLinkedStructure = ({ getNextNode, resolveValue, startNode }) => {
+  let slowNode = startNode;
+  let fastNode = startNode;
+  while (slowNode !== null) {
+    const resolvedValue = resolveValue(slowNode);
+    if (resolvedValue.found) {
+      return resolvedValue;
+    }
+    slowNode = getNextNode(slowNode);
+    for (let step = 0; step < FLOYD_FAST_POINTER_ADVANCE_STEPS; step += 1) {
+      if (fastNode === null) {
+        break;
+      }
+      fastNode = getNextNode(fastNode);
+    }
+    if (slowNode !== null && fastNode !== null && slowNode === fastNode) {
+      return {
+        found: false
+      };
+    }
+  }
+  return {
+    found: false
+  };
+};
+
+// dist/_internal/ast-node.js
+var hasOptionalParentProperty = (node) => "parent" in node;
+var getParentNode = (node) => hasOptionalParentProperty(node) ? node.parent : void 0;
+
+// dist/_internal/rule-docs-url.js
+var RULE_DOCS_URL_BASE = "https://nick2bad4u.github.io/eslint-plugin-runtime-cleanup/docs/rules/";
+var createRuleDocsUrl = (ruleName) => `${RULE_DOCS_URL_BASE}${ruleName}`;
+
+// dist/_internal/scope-variable.js
+var getVariableInScopeChain = (scope, variableName) => {
+  const lookupResult = resolveFirstValueInLinkedStructure({
+    getNextNode: (currentScope) => currentScope.upper,
+    resolveValue: (currentScope) => {
+      const variable = currentScope.set.get(variableName);
+      return variable === void 0 ? {
+        found: false
+      } : {
+        found: true,
+        value: variable
+      };
+    },
+    startNode: scope
+  });
+  return lookupResult.found ? lookupResult.value : null;
+};
+
+// dist/_internal/typed-rule.js
+var import_utils2 = require("@typescript-eslint/utils");
+
+// dist/_internal/plugin-settings.js
+var RUNTIME_CLEANUP_SETTINGS_KEY = "runtime-cleanup";
+var DISABLE_ALL_AUTOFIXES_KEY = "disableAllAutofixes";
+var settingsByProgram = /* @__PURE__ */ new WeakMap();
+var isObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var getRuntimeCleanupSettings = (settings) => {
+  if (!isObject(settings)) {
+    return null;
+  }
+  const pluginSettings = settings[RUNTIME_CLEANUP_SETTINGS_KEY];
+  return isObject(pluginSettings) ? pluginSettings : null;
+};
+var readBooleanFlag = (object, key) => Object.hasOwn(object, key) && object[key] === true;
+var readDisableAllAutofixesFromSettings = (settings) => {
+  const pluginSettings = getRuntimeCleanupSettings(settings);
+  if (pluginSettings === null) {
+    return false;
+  }
+  return readBooleanFlag(pluginSettings, DISABLE_ALL_AUTOFIXES_KEY);
+};
+var registerProgramSettingsForContext = (context) => {
+  const programNode = context.sourceCode.ast;
+  const parsedSettings = Object.freeze({
+    disableAllAutofixes: readDisableAllAutofixesFromSettings(context.settings)
+  });
+  const existingProgramSettings = settingsByProgram.get(programNode);
+  if (existingProgramSettings !== void 0) {
+    return existingProgramSettings;
+  }
+  settingsByProgram.set(programNode, parsedSettings);
+  return parsedSettings;
+};
+
+// dist/_internal/rule-catalog.js
+var orderedRuleNames = [
+  "no-floating-timers",
+  "no-unmanaged-event-listeners",
+  "no-floating-observers",
+  "no-floating-workers",
+  "no-floating-child-processes",
+  "no-floating-abort-controllers",
+  "no-floating-streams",
+  "no-floating-disposable-stacks",
+  "no-floating-network-connections",
+  "no-floating-file-watchers",
+  "no-floating-broadcast-channels",
+  "no-floating-message-channels",
+  "no-floating-servers",
+  "no-floating-geolocation-watches",
+  "no-floating-media-streams",
+  "no-floating-wake-locks",
+  "no-floating-object-urls",
+  "no-floating-audio-contexts",
+  "no-floating-web-stream-locks",
+  "no-floating-infinite-animations"
+];
+var toRuleCatalogId = (ruleNumber) => `R${String(ruleNumber).padStart(3, "0")}`;
+var runtimeCleanupRuleCatalogEntries = orderedRuleNames.map((ruleName, index) => {
+  const ruleNumber = index + 1;
+  return {
+    ruleId: toRuleCatalogId(ruleNumber),
+    ruleName,
+    ruleNumber
+  };
+});
+var runtimeCleanupRuleCatalogByRuleName = Object.fromEntries(runtimeCleanupRuleCatalogEntries.map((entry) => [entry.ruleName, entry]));
+var getRuleCatalogEntryForRuleNameOrNull = (ruleName) => runtimeCleanupRuleCatalogByRuleName[ruleName] ?? null;
+var runtimeCleanupRuleCatalogByRuleId = new Map(runtimeCleanupRuleCatalogEntries.map((entry) => [entry.ruleId, entry]));
+
+// dist/_internal/typed-rule.js
+var createTypedRule = (ruleDefinition) => {
+  const catalogEntry = getRuleCatalogEntryForRuleNameOrNull(ruleDefinition.name);
+  const createdRule = import_utils2.ESLintUtils.RuleCreator.withoutDocs(ruleDefinition);
+  const ruleDocs = createdRule.meta.docs;
+  if (ruleDocs === void 0) {
+    throw new TypeError(`Rule '${ruleDefinition.name}' must declare meta.docs.`);
+  }
+  const canonicalDocsUrl = createRuleDocsUrl(ruleDefinition.name);
+  if (typeof ruleDocs.url === "string" && ruleDocs.url !== canonicalDocsUrl) {
+    throw new TypeError(`Rule '${ruleDefinition.name}' has non-canonical docs.url '${ruleDocs.url}'. Expected '${canonicalDocsUrl}'.`);
+  }
+  if (catalogEntry === null && ruleDefinition.name.startsWith("require-")) {
+    throw new TypeError(`Rule '${ruleDefinition.name}' is missing from the stable rule catalog.`);
+  }
+  const docsWithCatalog = catalogEntry === null ? {
+    ...ruleDocs,
+    url: canonicalDocsUrl
+  } : {
+    ...ruleDocs,
+    ruleId: catalogEntry.ruleId,
+    ruleNumber: catalogEntry.ruleNumber,
+    url: canonicalDocsUrl
+  };
+  const metaDefaultOptions = createdRule.meta.defaultOptions;
+  return {
+    ...createdRule,
+    create(context) {
+      registerProgramSettingsForContext(context);
+      return createdRule.create(context);
+    },
+    meta: {
+      ...createdRule.meta,
+      ...metaDefaultOptions === void 0 ? {} : { defaultOptions: metaDefaultOptions },
+      docs: docsWithCatalog
+    },
+    name: ruleDefinition.name
+  };
+};
+var getTypedRuleServices = (context) => {
+  const parserServices = import_utils2.ESLintUtils.getParserServices(context, true);
+  const program = parserServices.program;
+  if (program === null) {
+    throw new Error("Typed rule requires parserServices.program; ensure projectService is enabled for this lint run.");
+  }
+  return {
+    checker: program.getTypeChecker(),
+    parserServices
+  };
+};
+
+// dist/rules/no-floating-abort-controllers.js
+var abortControllerConstructorName = "AbortController";
+var globalReceiverNames = [
+  "globalThis",
+  "self",
+  "window"
+];
+var globalReceiverNameSet = new Set(globalReceiverNames);
+var isGlobalReceiverName = (name) => globalReceiverNameSet.has(name);
+var getTransparentWrappedExpression = (node) => {
+  if (node.type === import_utils3.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils3.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils3.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils3.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils3.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName = (node, computed) => {
+  if (!computed && node.type === import_utils3.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (computed && node.type === import_utils3.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var isShadowedAbortControllerIdentifier = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var isDirectAbortControllerConstructor = (context, callee) => callee.type === import_utils3.AST_NODE_TYPES.Identifier && callee.name === abortControllerConstructorName && !isShadowedAbortControllerIdentifier(context, callee);
+var isMemberAbortControllerConstructor = (callee) => callee.type === import_utils3.AST_NODE_TYPES.MemberExpression && !callee.optional && callee.object.type === import_utils3.AST_NODE_TYPES.Identifier && isGlobalReceiverName(callee.object.name) && getStaticPropertyName(callee.property, callee.computed) === abortControllerConstructorName;
+var isAbortControllerConstructor = (context, callee) => isDirectAbortControllerConstructor(context, callee) || isMemberAbortControllerConstructor(callee);
+var isDiscardedAbortControllerHandle = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils3.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils3.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils3.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var isImmediateAbortSignalAccess = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    return parent.type === import_utils3.AST_NODE_TYPES.MemberExpression && parent.object === current && !parent.optional && getStaticPropertyName(parent.property, parent.computed) === "signal";
+  }
+  return false;
+};
+var noFloatingAbortControllers = createTypedRule({
+  create(context) {
+    return {
+      NewExpression(node) {
+        if (!isAbortControllerConstructor(context, node.callee) || !isDiscardedAbortControllerHandle(node) && !isImmediateAbortSignalAccess(node)) {
+          return;
+        }
+        context.report({
+          messageId: "floatingAbortController",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require AbortController handles to be retained so work can be aborted during cleanup.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-abort-controllers")
+    },
+    messages: {
+      floatingAbortController: "Store or return the AbortController handle so abort() can cancel work during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-abort-controllers"
+});
+var no_floating_abort_controllers_default = noFloatingAbortControllers;
+
+// dist/rules/no-floating-audio-contexts.js
+var import_utils5 = require("@typescript-eslint/utils");
+
+// dist/_internal/floating-resource.js
+var import_utils4 = require("@typescript-eslint/utils");
+var getTransparentWrappedExpression2 = (node) => {
+  if (node.type === import_utils4.AST_NODE_TYPES.AwaitExpression) {
+    return node.argument;
+  }
+  if (node.type === import_utils4.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils4.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils4.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils4.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils4.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName2 = (node, computed) => {
+  if (!computed && node.type === import_utils4.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (computed && node.type === import_utils4.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var collectStaticMemberPath = (node) => {
+  if (node.type === import_utils4.AST_NODE_TYPES.Identifier) {
+    return [node.name];
+  }
+  if (node.type !== import_utils4.AST_NODE_TYPES.MemberExpression || node.optional) {
+    return void 0;
+  }
+  const objectPath = collectStaticMemberPath(node.object);
+  const propertyName = getStaticPropertyName2(node.property, node.computed);
+  return objectPath === void 0 || propertyName === void 0 ? void 0 : [...objectPath, propertyName];
+};
+var isDiscardedResourceExpression = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression2(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils4.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils4.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils4.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var isImmediateUnownedMemberReceiver = (node, cleanupMemberNames3) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression2(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type !== import_utils4.AST_NODE_TYPES.MemberExpression || parent.object !== current || parent.optional) {
+      return false;
+    }
+    const propertyName = getStaticPropertyName2(parent.property, parent.computed);
+    return propertyName === void 0 || !cleanupMemberNames3.has(propertyName);
+  }
+  return false;
+};
+
+// dist/rules/no-floating-audio-contexts.js
+var audioContextConstructorNames = [
+  "AudioContext",
+  "webkitAudioContext"
+];
+var cleanupMemberNames = /* @__PURE__ */ new Set(["close"]);
+var globalReceiverNames2 = ["globalThis", "self", "window"];
+var audioContextConstructorNameSet = new Set(audioContextConstructorNames);
+var globalReceiverNameSet2 = new Set(globalReceiverNames2);
+var isAudioContextConstructorName = (name) => audioContextConstructorNameSet.has(name);
+var isShadowedIdentifier = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var getDirectAudioContextConstructorName = (context, callee) => {
+  if (callee.type !== import_utils5.AST_NODE_TYPES.Identifier || !isAudioContextConstructorName(callee.name) || isShadowedIdentifier(context, callee)) {
+    return void 0;
+  }
+  return callee.name;
+};
+var getMemberAudioContextConstructorName = (callee) => {
+  if (callee.type !== import_utils5.AST_NODE_TYPES.MemberExpression || callee.optional) {
+    return void 0;
+  }
+  const path = collectStaticMemberPath(callee);
+  if (path?.length !== 2) {
+    return void 0;
+  }
+  const receiverName = path[0];
+  if (receiverName === void 0 || !globalReceiverNameSet2.has(receiverName)) {
+    return void 0;
+  }
+  const constructorName = path[1];
+  return constructorName !== void 0 && isAudioContextConstructorName(constructorName) ? constructorName : void 0;
+};
+var getAudioContextConstructorName = (context, callee) => getDirectAudioContextConstructorName(context, callee) ?? getMemberAudioContextConstructorName(callee);
+var noFloatingAudioContexts = createTypedRule({
+  create(context) {
+    return {
+      NewExpression(node) {
+        const constructorName = getAudioContextConstructorName(context, node.callee);
+        if (constructorName === void 0 || !isDiscardedResourceExpression(node) && !isImmediateUnownedMemberReceiver(node, cleanupMemberNames)) {
+          return;
+        }
+        context.report({
+          data: { constructorName },
+          messageId: "floatingAudioContext",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require AudioContext instances to be retained so they can be closed.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-audio-contexts")
+    },
+    messages: {
+      floatingAudioContext: "Store or return the {{constructorName}} instance so close() can release audio resources during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-audio-contexts"
+});
+var no_floating_audio_contexts_default = noFloatingAudioContexts;
+
+// dist/rules/no-floating-broadcast-channels.js
+var import_utils6 = require("@typescript-eslint/utils");
+var broadcastChannelConstructorName = "BroadcastChannel";
+var globalReceiverNames3 = [
+  "globalThis",
+  "self",
+  "window"
+];
+var globalReceiverNameSet3 = new Set(globalReceiverNames3);
+var isGlobalReceiverName2 = (name) => globalReceiverNameSet3.has(name);
+var getTransparentWrappedExpression3 = (node) => {
+  if (node.type === import_utils6.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils6.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils6.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils6.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils6.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName3 = (node, computed) => {
+  if (!computed && node.type === import_utils6.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (computed && node.type === import_utils6.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var isShadowedBroadcastChannelIdentifier = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var isDirectBroadcastChannelConstructor = (context, callee) => callee.type === import_utils6.AST_NODE_TYPES.Identifier && callee.name === broadcastChannelConstructorName && !isShadowedBroadcastChannelIdentifier(context, callee);
+var isMemberBroadcastChannelConstructor = (callee) => callee.type === import_utils6.AST_NODE_TYPES.MemberExpression && !callee.optional && callee.object.type === import_utils6.AST_NODE_TYPES.Identifier && isGlobalReceiverName2(callee.object.name) && getStaticPropertyName3(callee.property, callee.computed) === broadcastChannelConstructorName;
+var isBroadcastChannelConstructor = (context, callee) => isDirectBroadcastChannelConstructor(context, callee) || isMemberBroadcastChannelConstructor(callee);
+var isDiscardedBroadcastChannel = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression3(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils6.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils6.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils6.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var isImmediateBroadcastChannelMethodReceiver = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression3(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type !== import_utils6.AST_NODE_TYPES.MemberExpression || parent.object !== current || parent.optional) {
+      return false;
+    }
+    if (getStaticPropertyName3(parent.property, parent.computed) === "close") {
+      return false;
+    }
+    const callExpression = getParentNode(parent);
+    return callExpression?.type === import_utils6.AST_NODE_TYPES.CallExpression && callExpression.callee === parent;
+  }
+  return false;
+};
+var noFloatingBroadcastChannels = createTypedRule({
+  create(context) {
+    return {
+      NewExpression(node) {
+        if (!isBroadcastChannelConstructor(context, node.callee) || !isDiscardedBroadcastChannel(node) && !isImmediateBroadcastChannelMethodReceiver(node)) {
+          return;
+        }
+        context.report({
+          messageId: "floatingBroadcastChannel",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require BroadcastChannel handles to be retained so they can be closed.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-broadcast-channels")
+    },
+    messages: {
+      floatingBroadcastChannel: "Store or return the BroadcastChannel handle so close() can release the channel during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-broadcast-channels"
+});
+var no_floating_broadcast_channels_default = noFloatingBroadcastChannels;
+
+// dist/rules/no-floating-child-processes.js
+var import_utils7 = require("@typescript-eslint/utils");
+var childProcessFactoryNames = [
+  "exec",
+  "execFile",
+  "fork",
+  "spawn"
+];
+var childProcessModuleNames = [
+  "child_process",
+  "node:child_process"
+];
+var immediateCleanupMethodNames = [
+  "disconnect",
+  "kill"
+];
+var childProcessFactoryNameSet = new Set(childProcessFactoryNames);
+var childProcessModuleNameSet = new Set(childProcessModuleNames);
+var immediateCleanupMethodNameSet = new Set(immediateCleanupMethodNames);
+var isChildProcessFactoryName = (name) => childProcessFactoryNameSet.has(name);
+var isImmediateCleanupMethodName = (name) => immediateCleanupMethodNameSet.has(name);
+var getTransparentWrappedExpression4 = (node) => {
+  if (node.type === import_utils7.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils7.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils7.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils7.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils7.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName4 = (node) => {
+  if (node.type === import_utils7.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (node.type === import_utils7.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var getImportSourceValue = (node) => {
+  const parent = getParentNode(node);
+  if (parent?.type === import_utils7.AST_NODE_TYPES.ImportDeclaration && typeof parent.source.value === "string") {
+    return parent.source.value;
+  }
+  return void 0;
+};
+var getRequireSourceValue = (expression) => {
+  if (expression?.type !== import_utils7.AST_NODE_TYPES.CallExpression || expression.callee.type !== import_utils7.AST_NODE_TYPES.Identifier || expression.callee.name !== "require") {
+    return void 0;
+  }
+  const [source] = expression.arguments;
+  return source?.type === import_utils7.AST_NODE_TYPES.Literal && typeof source.value === "string" ? source.value : void 0;
+};
+var getDefinitionModuleSource = (node) => {
+  if (node.type === import_utils7.AST_NODE_TYPES.ImportDefaultSpecifier || node.type === import_utils7.AST_NODE_TYPES.ImportNamespaceSpecifier || node.type === import_utils7.AST_NODE_TYPES.ImportSpecifier) {
+    return getImportSourceValue(node);
+  }
+  if (node.type === import_utils7.AST_NODE_TYPES.VariableDeclarator) {
+    return getRequireSourceValue(node.init);
+  }
+  return void 0;
+};
+var getImportedSpecifierName = (node) => getStaticPropertyName4(node.imported);
+var getObjectPatternPropertyNameForIdentifier = (objectPattern, identifierName) => {
+  for (const property of objectPattern.properties) {
+    if (property.type !== import_utils7.AST_NODE_TYPES.Property || property.value.type !== import_utils7.AST_NODE_TYPES.Identifier || property.value.name !== identifierName) {
+      continue;
+    }
+    return getStaticPropertyName4(property.key);
+  }
+  return void 0;
+};
+var isChildProcessModuleSource = (source) => source !== void 0 && childProcessModuleNameSet.has(source);
+var getDefinitionForIdentifier = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable?.defs[0];
+};
+var isChildProcessModuleBinding = (context, identifier) => {
+  const definition = getDefinitionForIdentifier(context, identifier);
+  if (definition === void 0) {
+    return false;
+  }
+  return isChildProcessModuleSource(getDefinitionModuleSource(definition.node));
+};
+var getNamedChildProcessFactoryBindingName = (context, identifier) => {
+  const definition = getDefinitionForIdentifier(context, identifier);
+  if (definition === void 0) {
+    return void 0;
+  }
+  const source = getDefinitionModuleSource(definition.node);
+  if (!isChildProcessModuleSource(source)) {
+    return void 0;
+  }
+  if (definition.node.type === import_utils7.AST_NODE_TYPES.ImportSpecifier) {
+    const importedName = getImportedSpecifierName(definition.node);
+    return importedName !== void 0 && isChildProcessFactoryName(importedName) ? importedName : void 0;
+  }
+  if (definition.node.type === import_utils7.AST_NODE_TYPES.VariableDeclarator && definition.node.id.type === import_utils7.AST_NODE_TYPES.ObjectPattern) {
+    const propertyName = getObjectPatternPropertyNameForIdentifier(definition.node.id, identifier.name);
+    return propertyName !== void 0 && isChildProcessFactoryName(propertyName) ? propertyName : void 0;
+  }
+  return void 0;
+};
+var getRequireMemberFactoryName = (callee) => {
+  if (callee.type !== import_utils7.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.property.type !== import_utils7.AST_NODE_TYPES.Identifier || !isChildProcessFactoryName(callee.property.name) || callee.object.type !== import_utils7.AST_NODE_TYPES.CallExpression || !isChildProcessModuleSource(getRequireSourceValue(callee.object))) {
+    return void 0;
+  }
+  return callee.property.name;
+};
+var getModuleMemberFactoryName = (context, callee) => {
+  if (callee.type !== import_utils7.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.object.type !== import_utils7.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils7.AST_NODE_TYPES.Identifier || !isChildProcessFactoryName(callee.property.name) || !isChildProcessModuleBinding(context, callee.object)) {
+    return void 0;
+  }
+  return callee.property.name;
+};
+var getChildProcessFactoryName = (context, callee) => {
+  if (callee.type === import_utils7.AST_NODE_TYPES.Identifier) {
+    return getNamedChildProcessFactoryBindingName(context, callee);
+  }
+  return getModuleMemberFactoryName(context, callee) ?? getRequireMemberFactoryName(callee);
+};
+var isDiscardedChildProcessHandle = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression4(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils7.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils7.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils7.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var isImmediateChildProcessMethodReceiver = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression4(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type !== import_utils7.AST_NODE_TYPES.MemberExpression || parent.object !== current || parent.computed || parent.property.type !== import_utils7.AST_NODE_TYPES.Identifier || isImmediateCleanupMethodName(parent.property.name)) {
+      return false;
+    }
+    const callExpression = getParentNode(parent);
+    return callExpression?.type === import_utils7.AST_NODE_TYPES.CallExpression && callExpression.callee === parent;
+  }
+  return false;
+};
+var noFloatingChildProcesses = createTypedRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        const factoryName = getChildProcessFactoryName(context, node.callee);
+        if (factoryName === void 0 || !isDiscardedChildProcessHandle(node) && !isImmediateChildProcessMethodReceiver(node)) {
+          return;
+        }
+        context.report({
+          data: { factoryName },
+          messageId: "floatingChildProcess",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require child process handles to be retained so they can be killed during cleanup.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-child-processes")
+    },
+    messages: {
+      floatingChildProcess: "Store or return the child process handle from {{factoryName}} so it can be killed during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-child-processes"
+});
+var no_floating_child_processes_default = noFloatingChildProcesses;
+
+// dist/rules/no-floating-disposable-stacks.js
+var import_utils8 = require("@typescript-eslint/utils");
+var disposableStackConstructorNames = [
+  "AsyncDisposableStack",
+  "DisposableStack"
+];
+var cleanupMethodNames = [
+  "dispose",
+  "disposeAsync"
+];
+var globalReceiverNames4 = [
+  "globalThis",
+  "self",
+  "window"
+];
+var disposableStackConstructorNameSet = new Set(disposableStackConstructorNames);
+var cleanupMethodNameSet = new Set(cleanupMethodNames);
+var globalReceiverNameSet4 = new Set(globalReceiverNames4);
+var isDisposableStackConstructorName = (name) => disposableStackConstructorNameSet.has(name);
+var isCleanupMethodName = (name) => cleanupMethodNameSet.has(name);
+var isGlobalReceiverName3 = (name) => globalReceiverNameSet4.has(name);
+var getTransparentWrappedExpression5 = (node) => {
+  if (node.type === import_utils8.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils8.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils8.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils8.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils8.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName5 = (node, computed) => {
+  if (!computed && node.type === import_utils8.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (computed && node.type === import_utils8.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var isShadowedDisposableStackIdentifier = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var getDirectDisposableStackConstructorName = (context, callee) => {
+  if (callee.type !== import_utils8.AST_NODE_TYPES.Identifier || !isDisposableStackConstructorName(callee.name) || isShadowedDisposableStackIdentifier(context, callee)) {
+    return void 0;
+  }
+  return callee.name;
+};
+var getMemberDisposableStackConstructorName = (callee) => {
+  if (callee.type !== import_utils8.AST_NODE_TYPES.MemberExpression || callee.optional || callee.object.type !== import_utils8.AST_NODE_TYPES.Identifier || !isGlobalReceiverName3(callee.object.name)) {
+    return void 0;
+  }
+  const constructorName = getStaticPropertyName5(callee.property, callee.computed);
+  return constructorName !== void 0 && isDisposableStackConstructorName(constructorName) ? constructorName : void 0;
+};
+var getDisposableStackConstructorName = (context, callee) => getDirectDisposableStackConstructorName(context, callee) ?? getMemberDisposableStackConstructorName(callee);
+var isDiscardedDisposableStack = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression5(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils8.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils8.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils8.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var isImmediateDisposableStackMethodReceiver = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression5(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type !== import_utils8.AST_NODE_TYPES.MemberExpression || parent.object !== current || parent.optional) {
+      return false;
+    }
+    const methodName = getStaticPropertyName5(parent.property, parent.computed);
+    if (methodName === void 0 || isCleanupMethodName(methodName)) {
+      return false;
+    }
+    const callExpression = getParentNode(parent);
+    return callExpression?.type === import_utils8.AST_NODE_TYPES.CallExpression && callExpression.callee === parent;
+  }
+  return false;
+};
+var noFloatingDisposableStacks = createTypedRule({
+  create(context) {
+    return {
+      NewExpression(node) {
+        const constructorName = getDisposableStackConstructorName(context, node.callee);
+        if (constructorName === void 0 || !isDiscardedDisposableStack(node) && !isImmediateDisposableStackMethodReceiver(node)) {
+          return;
+        }
+        context.report({
+          data: { constructorName },
+          messageId: "floatingDisposableStack",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require DisposableStack handles to be retained so registered disposers run.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-disposable-stacks")
+    },
+    messages: {
+      floatingDisposableStack: "Store, return, or use the {{constructorName}} handle so registered disposers run during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-disposable-stacks"
+});
+var no_floating_disposable_stacks_default = noFloatingDisposableStacks;
+
+// dist/rules/no-floating-file-watchers.js
+var import_utils9 = require("@typescript-eslint/utils");
+var fileWatcherFactoryName = "watch";
+var fsModuleNames = ["fs", "node:fs"];
+var immediateCleanupMethodNames2 = ["close"];
+var fsModuleNameSet = new Set(fsModuleNames);
+var immediateCleanupMethodNameSet2 = new Set(immediateCleanupMethodNames2);
+var isImmediateCleanupMethodName2 = (name) => immediateCleanupMethodNameSet2.has(name);
+var getTransparentWrappedExpression6 = (node) => {
+  if (node.type === import_utils9.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils9.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils9.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils9.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils9.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName6 = (node) => {
+  if (node.type === import_utils9.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (node.type === import_utils9.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var getImportSourceValue2 = (node) => {
+  const parent = getParentNode(node);
+  if (parent?.type === import_utils9.AST_NODE_TYPES.ImportDeclaration && typeof parent.source.value === "string") {
+    return parent.source.value;
+  }
+  return void 0;
+};
+var getRequireSourceValue2 = (expression) => {
+  if (expression?.type !== import_utils9.AST_NODE_TYPES.CallExpression || expression.callee.type !== import_utils9.AST_NODE_TYPES.Identifier || expression.callee.name !== "require") {
+    return void 0;
+  }
+  const [source] = expression.arguments;
+  return source?.type === import_utils9.AST_NODE_TYPES.Literal && typeof source.value === "string" ? source.value : void 0;
+};
+var getDefinitionModuleSource2 = (node) => {
+  if (node.type === import_utils9.AST_NODE_TYPES.ImportDefaultSpecifier || node.type === import_utils9.AST_NODE_TYPES.ImportNamespaceSpecifier || node.type === import_utils9.AST_NODE_TYPES.ImportSpecifier) {
+    return getImportSourceValue2(node);
+  }
+  if (node.type === import_utils9.AST_NODE_TYPES.VariableDeclarator) {
+    return getRequireSourceValue2(node.init);
+  }
+  return void 0;
+};
+var isFsModuleSource = (source) => source !== void 0 && fsModuleNameSet.has(source);
+var getDefinitionForIdentifier2 = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable?.defs[0];
+};
+var isFsModuleBinding = (context, identifier) => {
+  const definition = getDefinitionForIdentifier2(context, identifier);
+  return definition !== void 0 && isFsModuleSource(getDefinitionModuleSource2(definition.node));
+};
+var getImportedSpecifierName2 = (node) => getStaticPropertyName6(node.imported);
+var getObjectPatternPropertyNameForIdentifier2 = (objectPattern, identifierName) => {
+  for (const property of objectPattern.properties) {
+    if (property.type !== import_utils9.AST_NODE_TYPES.Property || property.value.type !== import_utils9.AST_NODE_TYPES.Identifier || property.value.name !== identifierName) {
+      continue;
+    }
+    return getStaticPropertyName6(property.key);
+  }
+  return void 0;
+};
+var getNamedFileWatcherBindingName = (context, identifier) => {
+  const definition = getDefinitionForIdentifier2(context, identifier);
+  if (definition === void 0) {
+    return void 0;
+  }
+  const source = getDefinitionModuleSource2(definition.node);
+  if (!isFsModuleSource(source)) {
+    return void 0;
+  }
+  if (definition.node.type === import_utils9.AST_NODE_TYPES.ImportSpecifier) {
+    return getImportedSpecifierName2(definition.node) === fileWatcherFactoryName ? fileWatcherFactoryName : void 0;
+  }
+  if (definition.node.type === import_utils9.AST_NODE_TYPES.VariableDeclarator && definition.node.id.type === import_utils9.AST_NODE_TYPES.ObjectPattern) {
+    return getObjectPatternPropertyNameForIdentifier2(definition.node.id, identifier.name) === fileWatcherFactoryName ? fileWatcherFactoryName : void 0;
+  }
+  return void 0;
+};
+var getRequireMemberFactoryName2 = (callee) => {
+  if (callee.type !== import_utils9.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.property.type !== import_utils9.AST_NODE_TYPES.Identifier || callee.property.name !== fileWatcherFactoryName || callee.object.type !== import_utils9.AST_NODE_TYPES.CallExpression || !isFsModuleSource(getRequireSourceValue2(callee.object))) {
+    return void 0;
+  }
+  return callee.property.name;
+};
+var getModuleMemberFactoryName2 = (context, callee) => {
+  if (callee.type !== import_utils9.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.object.type !== import_utils9.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils9.AST_NODE_TYPES.Identifier || callee.property.name !== fileWatcherFactoryName || !isFsModuleBinding(context, callee.object)) {
+    return void 0;
+  }
+  return callee.property.name;
+};
+var getFileWatcherFactoryName = (context, callee) => {
+  if (callee.type === import_utils9.AST_NODE_TYPES.Identifier) {
+    return getNamedFileWatcherBindingName(context, callee);
+  }
+  return getModuleMemberFactoryName2(context, callee) ?? getRequireMemberFactoryName2(callee);
+};
+var isDiscardedFileWatcherHandle = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression6(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils9.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils9.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils9.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var isImmediateFileWatcherMethodReceiver = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression6(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type !== import_utils9.AST_NODE_TYPES.MemberExpression || parent.object !== current || parent.computed || parent.property.type !== import_utils9.AST_NODE_TYPES.Identifier || isImmediateCleanupMethodName2(parent.property.name)) {
+      return false;
+    }
+    const callExpression = getParentNode(parent);
+    return callExpression?.type === import_utils9.AST_NODE_TYPES.CallExpression && callExpression.callee === parent;
+  }
+  return false;
+};
+var noFloatingFileWatchers = createTypedRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        const factoryName = getFileWatcherFactoryName(context, node.callee);
+        if (factoryName === void 0 || !isDiscardedFileWatcherHandle(node) && !isImmediateFileWatcherMethodReceiver(node)) {
+          return;
+        }
+        context.report({
+          data: { factoryName },
+          messageId: "floatingFileWatcher",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require Node.js file watcher handles to be retained so they can be closed.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-file-watchers")
+    },
+    messages: {
+      floatingFileWatcher: "Store or return the file watcher from {{factoryName}} so close() can stop watching during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-file-watchers"
+});
+var no_floating_file_watchers_default = noFloatingFileWatchers;
+
+// dist/rules/no-floating-geolocation-watches.js
+var import_utils10 = require("@typescript-eslint/utils");
+var geolocationWatchFunctionName = "watchPosition";
+var globalNavigatorReceiverNames = ["globalThis", "window"];
+var globalNavigatorReceiverNameSet = new Set(globalNavigatorReceiverNames);
+var getTransparentWrappedExpression7 = (node) => {
+  if (node.type === import_utils10.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils10.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils10.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils10.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils10.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName7 = (node, computed) => {
+  if (!computed && node.type === import_utils10.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (computed && node.type === import_utils10.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var collectStaticMemberPath2 = (node) => {
+  if (node.type === import_utils10.AST_NODE_TYPES.Identifier) {
+    return [node.name];
+  }
+  if (node.type !== import_utils10.AST_NODE_TYPES.MemberExpression || node.optional) {
+    return void 0;
+  }
+  const objectPath = collectStaticMemberPath2(node.object);
+  const propertyName = getStaticPropertyName7(node.property, node.computed);
+  return objectPath === void 0 || propertyName === void 0 ? void 0 : [...objectPath, propertyName];
+};
+var isShadowedNavigatorIdentifier = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var getRootIdentifier = (node) => {
+  if (node.type === import_utils10.AST_NODE_TYPES.Identifier) {
+    return node;
+  }
+  return node.type === import_utils10.AST_NODE_TYPES.MemberExpression ? getRootIdentifier(node.object) : void 0;
+};
+var isNavigatorPathShadowed = (context, callee) => {
+  if (callee.type !== import_utils10.AST_NODE_TYPES.MemberExpression) {
+    return false;
+  }
+  const rootIdentifier = getRootIdentifier(callee.object);
+  return rootIdentifier?.name === "navigator" && isShadowedNavigatorIdentifier(context, rootIdentifier);
+};
+var isGeolocationWatchPath = (path) => path.length === 3 && path[0] === "navigator" && path[1] === "geolocation" && path[2] === geolocationWatchFunctionName || path.length === 4 && globalNavigatorReceiverNameSet.has(path[0] ?? "") && path[1] === "navigator" && path[2] === "geolocation" && path[3] === geolocationWatchFunctionName;
+var isGeolocationWatchCall = (context, callee) => {
+  if (callee.type !== import_utils10.AST_NODE_TYPES.MemberExpression || isNavigatorPathShadowed(context, callee)) {
+    return false;
+  }
+  const path = collectStaticMemberPath2(callee);
+  return path !== void 0 && isGeolocationWatchPath(path);
+};
+var isDiscardedWatchId = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression7(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils10.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils10.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils10.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var noFloatingGeolocationWatches = createTypedRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isGeolocationWatchCall(context, node.callee) || !isDiscardedWatchId(node)) {
+          return;
+        }
+        context.report({
+          messageId: "floatingGeolocationWatch",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require geolocation watch IDs to be retained so they can be cleared.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-geolocation-watches")
+    },
+    messages: {
+      floatingGeolocationWatch: "Store or return the geolocation watch ID so navigator.geolocation.clearWatch() can remove the location watcher during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-geolocation-watches"
+});
+var no_floating_geolocation_watches_default = noFloatingGeolocationWatches;
+
+// dist/rules/no-floating-infinite-animations.js
+var import_utils11 = require("@typescript-eslint/utils");
+
+// dist/_internal/type-checker.js
+var hasTypeNameInHierarchy = (checker, type, expectedTypeName, seenTypes = /* @__PURE__ */ new Set()) => {
+  if (seenTypes.has(type)) {
+    return false;
+  }
+  const nextSeenTypes = new Set(seenTypes);
+  nextSeenTypes.add(type);
+  if (type.isUnionOrIntersection()) {
+    return type.types.some((entry) => hasTypeNameInHierarchy(checker, entry, expectedTypeName, nextSeenTypes));
+  }
+  const apparentType = checker.getApparentType(type);
+  const typeName = apparentType.symbol.getName();
+  if (typeName === expectedTypeName) {
+    return true;
+  }
+  if (!apparentType.isClassOrInterface()) {
+    return false;
+  }
+  const baseTypes = checker.getBaseTypes(apparentType);
+  return baseTypes.some((baseType) => hasTypeNameInHierarchy(checker, baseType, expectedTypeName, nextSeenTypes));
+};
+
+// dist/rules/no-floating-infinite-animations.js
+var animationCleanupMemberNames = /* @__PURE__ */ new Set([
+  "cancel",
+  "finish"
+]);
+var isShadowedIdentifier2 = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var isGlobalInfinityIdentifier = (context, node) => node.name === "Infinity" && !isShadowedIdentifier2(context, node);
+var isNumberPositiveInfinity = (node) => {
+  if (node.optional) {
+    return false;
+  }
+  const propertyName = getStaticPropertyName2(node.property, node.computed);
+  if (propertyName !== "POSITIVE_INFINITY") {
+    return false;
+  }
+  if (node.object.type === import_utils11.AST_NODE_TYPES.Identifier) {
+    return node.object.name === "Number";
+  }
+  if (node.object.type !== import_utils11.AST_NODE_TYPES.MemberExpression) {
+    return false;
+  }
+  const objectPropertyName = getStaticPropertyName2(node.object.property, node.object.computed);
+  return objectPropertyName === "Number" && node.object.object.type === import_utils11.AST_NODE_TYPES.Identifier && (node.object.object.name === "globalThis" || node.object.object.name === "window");
+};
+var isInfinityExpression = (context, node) => {
+  if (node.type === import_utils11.AST_NODE_TYPES.Identifier) {
+    return isGlobalInfinityIdentifier(context, node);
+  }
+  if (node.type === import_utils11.AST_NODE_TYPES.UnaryExpression && node.operator === "+" && node.argument.type === import_utils11.AST_NODE_TYPES.Identifier) {
+    return isGlobalInfinityIdentifier(context, node.argument);
+  }
+  return node.type === import_utils11.AST_NODE_TYPES.MemberExpression && isNumberPositiveInfinity(node);
+};
+var getPropertyKeyName = (property) => getStaticPropertyName2(property.key, property.computed);
+var isExpressionPropertyValue = (node) => node.type !== import_utils11.AST_NODE_TYPES.ArrayPattern && node.type !== import_utils11.AST_NODE_TYPES.AssignmentPattern && node.type !== import_utils11.AST_NODE_TYPES.ObjectPattern && node.type !== import_utils11.AST_NODE_TYPES.TSEmptyBodyFunctionExpression;
+var hasInfiniteIterationsOption = (context, options) => {
+  if (options.type !== import_utils11.AST_NODE_TYPES.ObjectExpression) {
+    return false;
+  }
+  return options.properties.some((property) => {
+    if (property.type !== import_utils11.AST_NODE_TYPES.Property || property.kind !== "init" || !isExpressionPropertyValue(property.value) || getPropertyKeyName(property) !== "iterations") {
+      return false;
+    }
+    return isInfinityExpression(context, property.value);
+  });
+};
+var getAnimationReceiver = (callee) => {
+  if (callee.type !== import_utils11.AST_NODE_TYPES.MemberExpression || callee.optional) {
+    return void 0;
+  }
+  if (callee.object.type === import_utils11.AST_NODE_TYPES.Super) {
+    return void 0;
+  }
+  const propertyName = getStaticPropertyName2(callee.property, callee.computed);
+  return propertyName === "animate" ? callee.object : void 0;
+};
+var isReceiverElement = (context, receiver) => {
+  const { checker, parserServices } = getTypedRuleServices(context);
+  const receiverType = checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(receiver));
+  return hasTypeNameInHierarchy(checker, receiverType, "Element");
+};
+var noFloatingInfiniteAnimations = createTypedRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        const receiver = getAnimationReceiver(node.callee);
+        const timingOptions = node.arguments.at(1);
+        if (receiver === void 0 || timingOptions === void 0 || !hasInfiniteIterationsOption(context, timingOptions) || !isReceiverElement(context, receiver) || !isDiscardedResourceExpression(node) && !isImmediateUnownedMemberReceiver(node, animationCleanupMemberNames)) {
+          return;
+        }
+        context.report({
+          messageId: "floatingInfiniteAnimation",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require infinite Web Animations to be retained so they can be canceled.",
+      recommended: true,
+      requiresTypeChecking: true,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-infinite-animations")
+    },
+    messages: {
+      floatingInfiniteAnimation: "Store or return the infinite Animation so cancel() can stop it during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-infinite-animations"
+});
+var no_floating_infinite_animations_default = noFloatingInfiniteAnimations;
+
+// dist/rules/no-floating-media-streams.js
+var import_utils12 = require("@typescript-eslint/utils");
+var mediaCaptureFunctionNames = [
+  "getDisplayMedia",
+  "getUserMedia"
+];
+var globalNavigatorReceiverNames2 = ["globalThis", "window"];
+var mediaCaptureFunctionNameSet = new Set(mediaCaptureFunctionNames);
+var globalNavigatorReceiverNameSet2 = new Set(globalNavigatorReceiverNames2);
+var isMediaCaptureFunctionName = (name) => mediaCaptureFunctionNameSet.has(name);
+var getTransparentWrappedExpression8 = (node) => {
+  if (node.type === import_utils12.AST_NODE_TYPES.AwaitExpression) {
+    return node.argument;
+  }
+  if (node.type === import_utils12.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils12.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils12.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils12.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils12.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName8 = (node, computed) => {
+  if (!computed && node.type === import_utils12.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (computed && node.type === import_utils12.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var collectStaticMemberPath3 = (node) => {
+  if (node.type === import_utils12.AST_NODE_TYPES.Identifier) {
+    return [node.name];
+  }
+  if (node.type !== import_utils12.AST_NODE_TYPES.MemberExpression || node.optional) {
+    return void 0;
+  }
+  const objectPath = collectStaticMemberPath3(node.object);
+  const propertyName = getStaticPropertyName8(node.property, node.computed);
+  return objectPath === void 0 || propertyName === void 0 ? void 0 : [...objectPath, propertyName];
+};
+var isShadowedNavigatorIdentifier2 = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var getRootIdentifier2 = (node) => {
+  if (node.type === import_utils12.AST_NODE_TYPES.Identifier) {
+    return node;
+  }
+  return node.type === import_utils12.AST_NODE_TYPES.MemberExpression ? getRootIdentifier2(node.object) : void 0;
+};
+var isNavigatorPathShadowed2 = (context, callee) => {
+  if (callee.type !== import_utils12.AST_NODE_TYPES.MemberExpression) {
+    return false;
+  }
+  const rootIdentifier = getRootIdentifier2(callee.object);
+  return rootIdentifier?.name === "navigator" && isShadowedNavigatorIdentifier2(context, rootIdentifier);
+};
+var getMediaCaptureNameFromPath = (path) => {
+  const captureName = path.at(-1);
+  if (captureName === void 0 || !isMediaCaptureFunctionName(captureName)) {
+    return void 0;
+  }
+  if (path.length === 3 && path[0] === "navigator" && path[1] === "mediaDevices") {
+    return captureName;
+  }
+  if (path.length === 4 && globalNavigatorReceiverNameSet2.has(path[0] ?? "") && path[1] === "navigator" && path[2] === "mediaDevices") {
+    return captureName;
+  }
+  return void 0;
+};
+var getMediaCaptureFunctionName = (context, callee) => {
+  if (callee.type !== import_utils12.AST_NODE_TYPES.MemberExpression || isNavigatorPathShadowed2(context, callee)) {
+    return void 0;
+  }
+  const path = collectStaticMemberPath3(callee);
+  return path === void 0 ? void 0 : getMediaCaptureNameFromPath(path);
+};
+var isDiscardedMediaStreamRequest = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression8(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils12.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils12.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils12.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var noFloatingMediaStreams = createTypedRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        const captureName = getMediaCaptureFunctionName(context, node.callee);
+        if (captureName === void 0 || !isDiscardedMediaStreamRequest(node)) {
+          return;
+        }
+        context.report({
+          data: { captureName },
+          messageId: "floatingMediaStream",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require captured MediaStream handles to be retained so their tracks can be stopped.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-media-streams")
+    },
+    messages: {
+      floatingMediaStream: "Store or return the MediaStream from {{captureName}} so its tracks can be stopped during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-media-streams"
+});
+var no_floating_media_streams_default = noFloatingMediaStreams;
+
+// dist/rules/no-floating-message-channels.js
+var import_utils13 = require("@typescript-eslint/utils");
+var messageChannelConstructorName = "MessageChannel";
+var messagePortPropertyNames = ["port1", "port2"];
+var globalReceiverNames5 = [
+  "globalThis",
+  "self",
+  "window"
+];
+var globalReceiverNameSet5 = new Set(globalReceiverNames5);
+var messagePortPropertyNameSet = new Set(messagePortPropertyNames);
+var isGlobalReceiverName4 = (name) => globalReceiverNameSet5.has(name);
+var isMessagePortPropertyName = (name) => messagePortPropertyNameSet.has(name);
+var getTransparentWrappedExpression9 = (node) => {
+  if (node.type === import_utils13.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils13.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils13.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils13.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils13.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName9 = (node, computed) => {
+  if (!computed && node.type === import_utils13.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (computed && node.type === import_utils13.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var isShadowedMessageChannelIdentifier = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var isDirectMessageChannelConstructor = (context, callee) => callee.type === import_utils13.AST_NODE_TYPES.Identifier && callee.name === messageChannelConstructorName && !isShadowedMessageChannelIdentifier(context, callee);
+var isMemberMessageChannelConstructor = (callee) => callee.type === import_utils13.AST_NODE_TYPES.MemberExpression && !callee.optional && callee.object.type === import_utils13.AST_NODE_TYPES.Identifier && isGlobalReceiverName4(callee.object.name) && getStaticPropertyName9(callee.property, callee.computed) === messageChannelConstructorName;
+var isMessageChannelConstructor = (context, callee) => isDirectMessageChannelConstructor(context, callee) || isMemberMessageChannelConstructor(callee);
+var isDiscardedMessageChannel = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression9(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils13.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils13.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils13.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var isImmediateMessagePortAccess = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression9(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type !== import_utils13.AST_NODE_TYPES.MemberExpression || parent.object !== current || parent.optional) {
+      return false;
+    }
+    const propertyName = getStaticPropertyName9(parent.property, parent.computed);
+    return propertyName !== void 0 && isMessagePortPropertyName(propertyName);
+  }
+  return false;
+};
+var noFloatingMessageChannels = createTypedRule({
+  create(context) {
+    return {
+      NewExpression(node) {
+        if (!isMessageChannelConstructor(context, node.callee) || !isDiscardedMessageChannel(node) && !isImmediateMessagePortAccess(node)) {
+          return;
+        }
+        context.report({
+          messageId: "floatingMessageChannel",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require MessageChannel ports to be retained so they can be closed.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-message-channels")
+    },
+    messages: {
+      floatingMessageChannel: "Store or return the MessageChannel handle or both MessagePort handles so the ports can be closed during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-message-channels"
+});
+var no_floating_message_channels_default = noFloatingMessageChannels;
+
+// dist/rules/no-floating-network-connections.js
+var import_utils14 = require("@typescript-eslint/utils");
+var networkConnectionConstructorNames = [
+  "EventSource",
+  "WebSocket"
+];
+var globalReceiverNames6 = [
+  "globalThis",
+  "self",
+  "window"
+];
+var networkConnectionConstructorNameSet = new Set(networkConnectionConstructorNames);
+var globalReceiverNameSet6 = new Set(globalReceiverNames6);
+var isNetworkConnectionConstructorName = (name) => networkConnectionConstructorNameSet.has(name);
+var isGlobalReceiverName5 = (name) => globalReceiverNameSet6.has(name);
+var getTransparentWrappedExpression10 = (node) => {
+  if (node.type === import_utils14.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils14.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils14.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils14.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils14.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName10 = (node, computed) => {
+  if (!computed && node.type === import_utils14.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (computed && node.type === import_utils14.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var isShadowedNetworkConnectionIdentifier = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var getDirectNetworkConnectionConstructorName = (context, callee) => {
+  if (callee.type !== import_utils14.AST_NODE_TYPES.Identifier || !isNetworkConnectionConstructorName(callee.name) || isShadowedNetworkConnectionIdentifier(context, callee)) {
+    return void 0;
+  }
+  return callee.name;
+};
+var getMemberNetworkConnectionConstructorName = (callee) => {
+  if (callee.type !== import_utils14.AST_NODE_TYPES.MemberExpression || callee.optional || callee.object.type !== import_utils14.AST_NODE_TYPES.Identifier || !isGlobalReceiverName5(callee.object.name)) {
+    return void 0;
+  }
+  const constructorName = getStaticPropertyName10(callee.property, callee.computed);
+  return constructorName !== void 0 && isNetworkConnectionConstructorName(constructorName) ? constructorName : void 0;
+};
+var getNetworkConnectionConstructorName = (context, callee) => getDirectNetworkConnectionConstructorName(context, callee) ?? getMemberNetworkConnectionConstructorName(callee);
+var isDiscardedNetworkConnection = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression10(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils14.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils14.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils14.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var isImmediateNetworkConnectionMethodReceiver = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression10(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type !== import_utils14.AST_NODE_TYPES.MemberExpression || parent.object !== current || parent.optional) {
+      return false;
+    }
+    if (getStaticPropertyName10(parent.property, parent.computed) === "close") {
+      return false;
+    }
+    const callExpression = getParentNode(parent);
+    return callExpression?.type === import_utils14.AST_NODE_TYPES.CallExpression && callExpression.callee === parent;
+  }
+  return false;
+};
+var noFloatingNetworkConnections = createTypedRule({
+  create(context) {
+    return {
+      NewExpression(node) {
+        const connectionName = getNetworkConnectionConstructorName(context, node.callee);
+        if (connectionName === void 0 || !isDiscardedNetworkConnection(node) && !isImmediateNetworkConnectionMethodReceiver(node)) {
+          return;
+        }
+        context.report({
+          data: { connectionName },
+          messageId: "floatingNetworkConnection",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require browser network connection handles to be retained so they can be closed.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-network-connections")
+    },
+    messages: {
+      floatingNetworkConnection: "Store or return the {{connectionName}} handle so close() can release the connection during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-network-connections"
+});
+var no_floating_network_connections_default = noFloatingNetworkConnections;
+
+// dist/rules/no-floating-object-urls.js
+var import_utils15 = require("@typescript-eslint/utils");
+var globalUrlReceiverNames = ["globalThis", "self", "window"];
+var globalUrlReceiverNameSet = new Set(globalUrlReceiverNames);
+var getRootIdentifier3 = (node) => {
+  if (node.type === import_utils15.AST_NODE_TYPES.Identifier) {
+    return node;
+  }
+  return node.type === import_utils15.AST_NODE_TYPES.MemberExpression ? getRootIdentifier3(node.object) : void 0;
+};
+var isShadowedIdentifier3 = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var isDirectUrlPath = (path) => path.length === 2 && path[0] === "URL" && path[1] === "createObjectURL";
+var isGlobalUrlPath = (path) => path.length === 3 && globalUrlReceiverNameSet.has(path[0] ?? "") && path[1] === "URL" && path[2] === "createObjectURL";
+var isObjectUrlCreateCall = (context, callee) => {
+  if (callee.type !== import_utils15.AST_NODE_TYPES.MemberExpression || callee.optional) {
+    return false;
+  }
+  const path = collectStaticMemberPath(callee);
+  if (path === void 0 || !isDirectUrlPath(path) && !isGlobalUrlPath(path)) {
+    return false;
+  }
+  const rootIdentifier = getRootIdentifier3(callee.object);
+  return rootIdentifier?.name !== "URL" || !isShadowedIdentifier3(context, rootIdentifier);
+};
+var noFloatingObjectUrls = createTypedRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isObjectUrlCreateCall(context, node.callee) || !isDiscardedResourceExpression(node)) {
+          return;
+        }
+        context.report({
+          messageId: "floatingObjectUrl",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require object URLs to be retained so they can be revoked.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-object-urls")
+    },
+    messages: {
+      floatingObjectUrl: "Store or return the object URL so URL.revokeObjectURL() can release the Blob or File when cleanup runs."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-object-urls"
+});
+var no_floating_object_urls_default = noFloatingObjectUrls;
+
+// dist/rules/no-floating-observers.js
+var import_utils16 = require("@typescript-eslint/utils");
+var observerConstructorNames = [
+  "IntersectionObserver",
+  "MutationObserver",
+  "PerformanceObserver",
+  "ReportingObserver",
+  "ResizeObserver"
+];
+var globalReceiverNames7 = [
+  "globalThis",
+  "self",
+  "window"
+];
+var globalReceiverNameSet7 = new Set(globalReceiverNames7);
+var observerConstructorNameSet = new Set(observerConstructorNames);
+var isGlobalReceiverName6 = (name) => globalReceiverNameSet7.has(name);
+var isObserverConstructorName = (name) => observerConstructorNameSet.has(name);
+var getTransparentWrappedExpression11 = (node) => {
+  if (node.type === import_utils16.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils16.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils16.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils16.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils16.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var isShadowedIdentifier4 = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var getDirectObserverConstructorName = (context, callee) => {
+  if (callee.type !== import_utils16.AST_NODE_TYPES.Identifier || !isObserverConstructorName(callee.name) || isShadowedIdentifier4(context, callee)) {
+    return void 0;
+  }
+  return callee.name;
+};
+var getMemberObserverConstructorName = (callee) => {
+  if (callee.type !== import_utils16.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.object.type !== import_utils16.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils16.AST_NODE_TYPES.Identifier || !isGlobalReceiverName6(callee.object.name) || !isObserverConstructorName(callee.property.name)) {
+    return void 0;
+  }
+  return callee.property.name;
+};
+var getObserverConstructorName = (context, callee) => getDirectObserverConstructorName(context, callee) ?? getMemberObserverConstructorName(callee);
+var isObserveMethodCallReceiver = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression11(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type !== import_utils16.AST_NODE_TYPES.MemberExpression || parent.object !== current || parent.computed || parent.property.type !== import_utils16.AST_NODE_TYPES.Identifier || parent.property.name !== "observe") {
+      return false;
+    }
+    const callExpression = getParentNode(parent);
+    return callExpression?.type === import_utils16.AST_NODE_TYPES.CallExpression && callExpression.callee === parent;
+  }
+  return false;
+};
+var isDiscardedObserverInstance = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression11(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils16.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils16.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils16.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var noFloatingObservers = createTypedRule({
+  create(context) {
+    return {
+      NewExpression(node) {
+        const observerName = getObserverConstructorName(context, node.callee);
+        if (observerName === void 0 || !isDiscardedObserverInstance(node) && !isObserveMethodCallReceiver(node)) {
+          return;
+        }
+        context.report({
+          data: { observerName },
+          messageId: "floatingObserver",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require observer instances to be retained so they can be disconnected during cleanup.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-observers")
+    },
+    messages: {
+      floatingObserver: "Store or return the {{observerName}} instance so it can be disconnected during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-observers"
+});
+var no_floating_observers_default = noFloatingObservers;
+
+// dist/rules/no-floating-servers.js
+var import_utils17 = require("@typescript-eslint/utils");
+var serverFactoryNames = [
+  "createSecureServer",
+  "createServer"
+];
+var http2OnlyServerFactoryNames = ["createSecureServer"];
+var serverModuleNames = [
+  "http",
+  "http2",
+  "https",
+  "net",
+  "node:http",
+  "node:http2",
+  "node:https",
+  "node:net"
+];
+var http2ServerModuleNames = ["http2", "node:http2"];
+var immediateCleanupMethodNames3 = ["close"];
+var serverFactoryNameSet = new Set(serverFactoryNames);
+var http2OnlyServerFactoryNameSet = new Set(http2OnlyServerFactoryNames);
+var serverModuleNameSet = new Set(serverModuleNames);
+var http2ServerModuleNameSet = new Set(http2ServerModuleNames);
+var immediateCleanupMethodNameSet3 = new Set(immediateCleanupMethodNames3);
+var isServerFactoryName = (name) => serverFactoryNameSet.has(name);
+var isHttp2OnlyServerFactoryName = (name) => http2OnlyServerFactoryNameSet.has(name);
+var isServerModuleSource = (source) => source !== void 0 && serverModuleNameSet.has(source);
+var isHttp2ServerModuleSource = (source) => source !== void 0 && http2ServerModuleNameSet.has(source);
+var isImmediateCleanupMethodName3 = (name) => immediateCleanupMethodNameSet3.has(name);
+var isValidServerFactoryForSource = (source, factoryName) => isServerModuleSource(source) && isServerFactoryName(factoryName) && (!isHttp2OnlyServerFactoryName(factoryName) || isHttp2ServerModuleSource(source));
+var getTransparentWrappedExpression12 = (node) => {
+  if (node.type === import_utils17.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils17.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils17.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils17.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils17.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName11 = (node) => {
+  if (node.type === import_utils17.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (node.type === import_utils17.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var getImportSourceValue3 = (node) => {
+  const parent = getParentNode(node);
+  if (parent?.type === import_utils17.AST_NODE_TYPES.ImportDeclaration && typeof parent.source.value === "string") {
+    return parent.source.value;
+  }
+  return void 0;
+};
+var getRequireSourceValue3 = (expression) => {
+  if (expression?.type !== import_utils17.AST_NODE_TYPES.CallExpression || expression.callee.type !== import_utils17.AST_NODE_TYPES.Identifier || expression.callee.name !== "require") {
+    return void 0;
+  }
+  const [source] = expression.arguments;
+  return source?.type === import_utils17.AST_NODE_TYPES.Literal && typeof source.value === "string" ? source.value : void 0;
+};
+var getDefinitionModuleSource3 = (node) => {
+  if (node.type === import_utils17.AST_NODE_TYPES.ImportDefaultSpecifier || node.type === import_utils17.AST_NODE_TYPES.ImportNamespaceSpecifier || node.type === import_utils17.AST_NODE_TYPES.ImportSpecifier) {
+    return getImportSourceValue3(node);
+  }
+  if (node.type === import_utils17.AST_NODE_TYPES.VariableDeclarator) {
+    return getRequireSourceValue3(node.init);
+  }
+  return void 0;
+};
+var getDefinitionForIdentifier3 = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable?.defs[0];
+};
+var getImportedSpecifierName3 = (node) => getStaticPropertyName11(node.imported);
+var getObjectPatternPropertyNameForIdentifier3 = (objectPattern, identifierName) => {
+  for (const property of objectPattern.properties) {
+    if (property.type !== import_utils17.AST_NODE_TYPES.Property || property.value.type !== import_utils17.AST_NODE_TYPES.Identifier || property.value.name !== identifierName) {
+      continue;
+    }
+    return getStaticPropertyName11(property.key);
+  }
+  return void 0;
+};
+var getModuleSourceForBinding = (context, identifier) => {
+  const definition = getDefinitionForIdentifier3(context, identifier);
+  return definition === void 0 ? void 0 : getDefinitionModuleSource3(definition.node);
+};
+var getNamedServerFactoryBindingName = (context, identifier) => {
+  const definition = getDefinitionForIdentifier3(context, identifier);
+  if (definition === void 0) {
+    return void 0;
+  }
+  const source = getDefinitionModuleSource3(definition.node);
+  if (definition.node.type === import_utils17.AST_NODE_TYPES.ImportSpecifier) {
+    const importedName = getImportedSpecifierName3(definition.node);
+    return importedName !== void 0 && isValidServerFactoryForSource(source, importedName) ? importedName : void 0;
+  }
+  if (definition.node.type === import_utils17.AST_NODE_TYPES.VariableDeclarator && definition.node.id.type === import_utils17.AST_NODE_TYPES.ObjectPattern) {
+    const propertyName = getObjectPatternPropertyNameForIdentifier3(definition.node.id, identifier.name);
+    return propertyName !== void 0 && isValidServerFactoryForSource(source, propertyName) ? propertyName : void 0;
+  }
+  return void 0;
+};
+var getRequireMemberFactoryName3 = (callee) => {
+  if (callee.type !== import_utils17.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.property.type !== import_utils17.AST_NODE_TYPES.Identifier || callee.object.type !== import_utils17.AST_NODE_TYPES.CallExpression) {
+    return void 0;
+  }
+  const source = getRequireSourceValue3(callee.object);
+  const factoryName = callee.property.name;
+  return isValidServerFactoryForSource(source, factoryName) ? factoryName : void 0;
+};
+var getModuleMemberFactoryName3 = (context, callee) => {
+  if (callee.type !== import_utils17.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.object.type !== import_utils17.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils17.AST_NODE_TYPES.Identifier) {
+    return void 0;
+  }
+  const source = getModuleSourceForBinding(context, callee.object);
+  const factoryName = callee.property.name;
+  return isValidServerFactoryForSource(source, factoryName) ? factoryName : void 0;
+};
+var getServerFactoryName = (context, callee) => {
+  if (callee.type === import_utils17.AST_NODE_TYPES.Identifier) {
+    return getNamedServerFactoryBindingName(context, callee);
+  }
+  return getModuleMemberFactoryName3(context, callee) ?? getRequireMemberFactoryName3(callee);
+};
+var isDiscardedExpression = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression12(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils17.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils17.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils17.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var getImmediateServerMethodCall = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression12(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type !== import_utils17.AST_NODE_TYPES.MemberExpression || parent.object !== current || parent.computed || parent.property.type !== import_utils17.AST_NODE_TYPES.Identifier || isImmediateCleanupMethodName3(parent.property.name)) {
+      return void 0;
+    }
+    const callExpression = getParentNode(parent);
+    return callExpression?.type === import_utils17.AST_NODE_TYPES.CallExpression && callExpression.callee === parent ? callExpression : void 0;
+  }
+  return void 0;
+};
+var isDiscardedImmediateServerMethodChain = (node) => {
+  let currentCall = getImmediateServerMethodCall(node);
+  while (currentCall !== void 0) {
+    if (isDiscardedExpression(currentCall)) {
+      return true;
+    }
+    currentCall = getImmediateServerMethodCall(currentCall);
+  }
+  return false;
+};
+var isDiscardedServerHandle = (node) => isDiscardedExpression(node) || isDiscardedImmediateServerMethodChain(node);
+var noFloatingServers = createTypedRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        const factoryName = getServerFactoryName(context, node.callee);
+        if (factoryName === void 0 || !isDiscardedServerHandle(node)) {
+          return;
+        }
+        context.report({
+          data: { factoryName },
+          messageId: "floatingServer",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require Node.js server handles to be retained so they can be closed.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-servers")
+    },
+    messages: {
+      floatingServer: "Store or return the server from {{factoryName}} so close() can stop it during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-servers"
+});
+var no_floating_servers_default = noFloatingServers;
+
+// dist/rules/no-floating-streams.js
+var import_utils18 = require("@typescript-eslint/utils");
+var fileStreamFactoryNames = [
+  "createReadStream",
+  "createWriteStream"
+];
+var fsModuleNames2 = ["fs", "node:fs"];
+var fileStreamFactoryNameSet = new Set(fileStreamFactoryNames);
+var fsModuleNameSet2 = new Set(fsModuleNames2);
+var isFileStreamFactoryName = (name) => fileStreamFactoryNameSet.has(name);
+var getTransparentWrappedExpression13 = (node) => {
+  if (node.type === import_utils18.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils18.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils18.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils18.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils18.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName12 = (node) => {
+  if (node.type === import_utils18.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (node.type === import_utils18.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var getImportSourceValue4 = (node) => {
+  const parent = getParentNode(node);
+  if (parent?.type === import_utils18.AST_NODE_TYPES.ImportDeclaration && typeof parent.source.value === "string") {
+    return parent.source.value;
+  }
+  return void 0;
+};
+var getRequireSourceValue4 = (expression) => {
+  if (expression?.type !== import_utils18.AST_NODE_TYPES.CallExpression || expression.callee.type !== import_utils18.AST_NODE_TYPES.Identifier || expression.callee.name !== "require") {
+    return void 0;
+  }
+  const [source] = expression.arguments;
+  return source?.type === import_utils18.AST_NODE_TYPES.Literal && typeof source.value === "string" ? source.value : void 0;
+};
+var getDefinitionModuleSource4 = (node) => {
+  if (node.type === import_utils18.AST_NODE_TYPES.ImportDefaultSpecifier || node.type === import_utils18.AST_NODE_TYPES.ImportNamespaceSpecifier || node.type === import_utils18.AST_NODE_TYPES.ImportSpecifier) {
+    return getImportSourceValue4(node);
+  }
+  if (node.type === import_utils18.AST_NODE_TYPES.VariableDeclarator) {
+    return getRequireSourceValue4(node.init);
+  }
+  return void 0;
+};
+var getImportedSpecifierName4 = (node) => getStaticPropertyName12(node.imported);
+var getObjectPatternPropertyNameForIdentifier4 = (objectPattern, identifierName) => {
+  for (const property of objectPattern.properties) {
+    if (property.type !== import_utils18.AST_NODE_TYPES.Property || property.value.type !== import_utils18.AST_NODE_TYPES.Identifier || property.value.name !== identifierName) {
+      continue;
+    }
+    return getStaticPropertyName12(property.key);
+  }
+  return void 0;
+};
+var isFsModuleSource2 = (source) => source !== void 0 && fsModuleNameSet2.has(source);
+var getDefinitionForIdentifier4 = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable?.defs[0];
+};
+var isFsModuleBinding2 = (context, identifier) => {
+  const definition = getDefinitionForIdentifier4(context, identifier);
+  return definition !== void 0 && isFsModuleSource2(getDefinitionModuleSource4(definition.node));
+};
+var getNamedFileStreamFactoryBindingName = (context, identifier) => {
+  const definition = getDefinitionForIdentifier4(context, identifier);
+  if (definition === void 0) {
+    return void 0;
+  }
+  const source = getDefinitionModuleSource4(definition.node);
+  if (!isFsModuleSource2(source)) {
+    return void 0;
+  }
+  if (definition.node.type === import_utils18.AST_NODE_TYPES.ImportSpecifier) {
+    const importedName = getImportedSpecifierName4(definition.node);
+    return importedName !== void 0 && isFileStreamFactoryName(importedName) ? importedName : void 0;
+  }
+  if (definition.node.type === import_utils18.AST_NODE_TYPES.VariableDeclarator && definition.node.id.type === import_utils18.AST_NODE_TYPES.ObjectPattern) {
+    const propertyName = getObjectPatternPropertyNameForIdentifier4(definition.node.id, identifier.name);
+    return propertyName !== void 0 && isFileStreamFactoryName(propertyName) ? propertyName : void 0;
+  }
+  return void 0;
+};
+var getRequireMemberFactoryName4 = (callee) => {
+  if (callee.type !== import_utils18.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.property.type !== import_utils18.AST_NODE_TYPES.Identifier || !isFileStreamFactoryName(callee.property.name) || callee.object.type !== import_utils18.AST_NODE_TYPES.CallExpression || !isFsModuleSource2(getRequireSourceValue4(callee.object))) {
+    return void 0;
+  }
+  return callee.property.name;
+};
+var getModuleMemberFactoryName4 = (context, callee) => {
+  if (callee.type !== import_utils18.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.object.type !== import_utils18.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils18.AST_NODE_TYPES.Identifier || !isFileStreamFactoryName(callee.property.name) || !isFsModuleBinding2(context, callee.object)) {
+    return void 0;
+  }
+  return callee.property.name;
+};
+var getFileStreamFactoryName = (context, callee) => {
+  if (callee.type === import_utils18.AST_NODE_TYPES.Identifier) {
+    return getNamedFileStreamFactoryBindingName(context, callee);
+  }
+  return getModuleMemberFactoryName4(context, callee) ?? getRequireMemberFactoryName4(callee);
+};
+var isDiscardedFileStreamHandle = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression13(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils18.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils18.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils18.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var noFloatingStreams = createTypedRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        const factoryName = getFileStreamFactoryName(context, node.callee);
+        if (factoryName === void 0 || !isDiscardedFileStreamHandle(node)) {
+          return;
+        }
+        context.report({
+          data: { factoryName },
+          messageId: "floatingStream",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require Node.js file stream handles to be retained so they can be closed during cleanup.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-streams")
+    },
+    messages: {
+      floatingStream: "Store, return, pipe, or destroy the stream from {{factoryName}} so cleanup can close its underlying resource."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-streams"
+});
+var no_floating_streams_default = noFloatingStreams;
+
+// dist/rules/no-floating-timers.js
+var import_utils19 = require("@typescript-eslint/utils");
+var timerFunctionNames = [
+  "requestAnimationFrame",
+  "requestIdleCallback",
+  "setImmediate",
+  "setInterval",
+  "setTimeout"
+];
+var globalReceiverNames8 = [
+  "global",
+  "globalThis",
+  "self",
+  "window"
+];
+var timerFunctionNameSet = new Set(timerFunctionNames);
+var globalReceiverNameSet8 = new Set(globalReceiverNames8);
+var isTimerFunctionName = (name) => timerFunctionNameSet.has(name);
+var isGlobalReceiverName7 = (name) => globalReceiverNameSet8.has(name);
+var getTransparentWrappedExpression14 = (node) => {
+  if (node.type === import_utils19.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils19.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils19.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils19.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils19.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var isDiscardedTimerHandle = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression14(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils19.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils19.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils19.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var isShadowedIdentifier5 = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var getDirectTimerName = (context, callee) => {
+  if (callee.type !== import_utils19.AST_NODE_TYPES.Identifier || !isTimerFunctionName(callee.name) || isShadowedIdentifier5(context, callee)) {
+    return void 0;
+  }
+  return callee.name;
+};
+var getMemberTimerName = (callee) => {
+  if (callee.type !== import_utils19.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.object.type !== import_utils19.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils19.AST_NODE_TYPES.Identifier || !isGlobalReceiverName7(callee.object.name) || !isTimerFunctionName(callee.property.name)) {
+    return void 0;
+  }
+  return callee.property.name;
+};
+var noFloatingTimers = createTypedRule({
+  create(context) {
+    const reportFloatingTimer = (node, timerName) => {
+      if (!isDiscardedTimerHandle(node)) {
+        return;
+      }
+      context.report({
+        data: { timerName },
+        messageId: "floatingTimer",
+        node
+      });
+    };
+    return {
+      'CallExpression[callee.type="Identifier"]'(node) {
+        const timerName = getDirectTimerName(context, node.callee);
+        if (timerName !== void 0) {
+          reportFloatingTimer(node, timerName);
+        }
+      },
+      'CallExpression[callee.type="MemberExpression"]'(node) {
+        const timerName = getMemberTimerName(node.callee);
+        if (timerName !== void 0) {
+          reportFloatingTimer(node, timerName);
+        }
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require timer handles to be retained so they can be cleared during cleanup.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-timers")
+    },
+    messages: {
+      floatingTimer: "Store or return the {{timerName}} handle so it can be cleared during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-timers"
+});
+var no_floating_timers_default = noFloatingTimers;
+
+// dist/rules/no-floating-wake-locks.js
+var import_utils20 = require("@typescript-eslint/utils");
+var wakeLockRequestFunctionName = "request";
+var globalNavigatorReceiverNames3 = ["globalThis", "window"];
+var globalNavigatorReceiverNameSet3 = new Set(globalNavigatorReceiverNames3);
+var getTransparentWrappedExpression15 = (node) => {
+  if (node.type === import_utils20.AST_NODE_TYPES.AwaitExpression) {
+    return node.argument;
+  }
+  if (node.type === import_utils20.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils20.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils20.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils20.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils20.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getStaticPropertyName13 = (node, computed) => {
+  if (!computed && node.type === import_utils20.AST_NODE_TYPES.Identifier) {
+    return node.name;
+  }
+  if (computed && node.type === import_utils20.AST_NODE_TYPES.Literal && typeof node.value === "string") {
+    return node.value;
+  }
+  return void 0;
+};
+var collectStaticMemberPath4 = (node) => {
+  if (node.type === import_utils20.AST_NODE_TYPES.Identifier) {
+    return [node.name];
+  }
+  if (node.type !== import_utils20.AST_NODE_TYPES.MemberExpression || node.optional) {
+    return void 0;
+  }
+  const objectPath = collectStaticMemberPath4(node.object);
+  const propertyName = getStaticPropertyName13(node.property, node.computed);
+  return objectPath === void 0 || propertyName === void 0 ? void 0 : [...objectPath, propertyName];
+};
+var isShadowedNavigatorIdentifier3 = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var getRootIdentifier4 = (node) => {
+  if (node.type === import_utils20.AST_NODE_TYPES.Identifier) {
+    return node;
+  }
+  return node.type === import_utils20.AST_NODE_TYPES.MemberExpression ? getRootIdentifier4(node.object) : void 0;
+};
+var isNavigatorPathShadowed3 = (context, callee) => {
+  if (callee.type !== import_utils20.AST_NODE_TYPES.MemberExpression) {
+    return false;
+  }
+  const rootIdentifier = getRootIdentifier4(callee.object);
+  return rootIdentifier?.name === "navigator" && isShadowedNavigatorIdentifier3(context, rootIdentifier);
+};
+var isWakeLockRequestPath = (path) => path.length === 3 && path[0] === "navigator" && path[1] === "wakeLock" && path[2] === wakeLockRequestFunctionName || path.length === 4 && globalNavigatorReceiverNameSet3.has(path[0] ?? "") && path[1] === "navigator" && path[2] === "wakeLock" && path[3] === wakeLockRequestFunctionName;
+var isWakeLockRequestCall = (context, callee) => {
+  if (callee.type !== import_utils20.AST_NODE_TYPES.MemberExpression || isNavigatorPathShadowed3(context, callee)) {
+    return false;
+  }
+  const path = collectStaticMemberPath4(callee);
+  return path !== void 0 && isWakeLockRequestPath(path);
+};
+var isDiscardedWakeLockRequest = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression15(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils20.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils20.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils20.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var noFloatingWakeLocks = createTypedRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        if (!isWakeLockRequestCall(context, node.callee) || !isDiscardedWakeLockRequest(node)) {
+          return;
+        }
+        context.report({
+          messageId: "floatingWakeLock",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require WakeLockSentinel handles to be retained so they can be released.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-wake-locks")
+    },
+    messages: {
+      floatingWakeLock: "Store or return the WakeLockSentinel so release() can release the wake lock during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-wake-locks"
+});
+var no_floating_wake_locks_default = noFloatingWakeLocks;
+
+// dist/rules/no-floating-web-stream-locks.js
+var import_utils21 = require("@typescript-eslint/utils");
+var lockFactoryNames = ["getReader", "getWriter"];
+var cleanupMemberNames2 = /* @__PURE__ */ new Set(["releaseLock"]);
+var lockFactoryMetadataByName = {
+  getReader: {
+    lockKind: "reader",
+    streamTypeName: "ReadableStream"
+  },
+  getWriter: {
+    lockKind: "writer",
+    streamTypeName: "WritableStream"
+  }
+};
+var lockFactoryNameSet = new Set(lockFactoryNames);
+var isLockFactoryName = (name) => lockFactoryNameSet.has(name);
+var getLockFactoryMetadata = (callee) => {
+  if (callee.type !== import_utils21.AST_NODE_TYPES.MemberExpression || callee.optional) {
+    return void 0;
+  }
+  if (callee.object.type === import_utils21.AST_NODE_TYPES.Super) {
+    return void 0;
+  }
+  const factoryName = getStaticPropertyName2(callee.property, callee.computed);
+  if (factoryName === void 0 || !isLockFactoryName(factoryName)) {
+    return void 0;
+  }
+  return {
+    ...lockFactoryMetadataByName[factoryName],
+    receiver: callee.object
+  };
+};
+var isReceiverExpectedWebStream = (context, receiver, streamTypeName) => {
+  const { checker, parserServices } = getTypedRuleServices(context);
+  const receiverType = checker.getTypeAtLocation(parserServices.esTreeNodeToTSNodeMap.get(receiver));
+  return hasTypeNameInHierarchy(checker, receiverType, streamTypeName);
+};
+var noFloatingWebStreamLocks = createTypedRule({
+  create(context) {
+    return {
+      CallExpression(node) {
+        const metadata = getLockFactoryMetadata(node.callee);
+        if (metadata === void 0 || !isReceiverExpectedWebStream(context, metadata.receiver, metadata.streamTypeName) || !isDiscardedResourceExpression(node) && !isImmediateUnownedMemberReceiver(node, cleanupMemberNames2)) {
+          return;
+        }
+        context.report({
+          data: { lockKind: metadata.lockKind },
+          messageId: "floatingWebStreamLock",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require Web Stream readers and writers to be retained so their locks can be released.",
+      recommended: true,
+      requiresTypeChecking: true,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-web-stream-locks")
+    },
+    messages: {
+      floatingWebStreamLock: "Store or return the Web Stream {{lockKind}} so releaseLock() can release the stream lock during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-web-stream-locks"
+});
+var no_floating_web_stream_locks_default = noFloatingWebStreamLocks;
+
+// dist/rules/no-floating-workers.js
+var import_utils22 = require("@typescript-eslint/utils");
+var browserWorkerConstructorNames = [
+  "SharedWorker",
+  "Worker"
+];
+var globalReceiverNames9 = [
+  "globalThis",
+  "self",
+  "window"
+];
+var workerThreadsModuleNames = [
+  "node:worker_threads",
+  "worker_threads"
+];
+var browserWorkerConstructorNameSet = new Set(browserWorkerConstructorNames);
+var globalReceiverNameSet9 = new Set(globalReceiverNames9);
+var workerThreadsModuleNameSet = new Set(workerThreadsModuleNames);
+var isBrowserWorkerConstructorName = (name) => browserWorkerConstructorNameSet.has(name);
+var isGlobalReceiverName8 = (name) => globalReceiverNameSet9.has(name);
+var getTransparentWrappedExpression16 = (node) => {
+  if (node.type === import_utils22.AST_NODE_TYPES.ChainExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils22.AST_NODE_TYPES.TSAsExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils22.AST_NODE_TYPES.TSNonNullExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils22.AST_NODE_TYPES.TSSatisfiesExpression) {
+    return node.expression;
+  }
+  if (node.type === import_utils22.AST_NODE_TYPES.TSTypeAssertion) {
+    return node.expression;
+  }
+  return void 0;
+};
+var getImportSourceValue5 = (node) => {
+  const parent = getParentNode(node);
+  if (parent?.type === import_utils22.AST_NODE_TYPES.ImportDeclaration && typeof parent.source.value === "string") {
+    return parent.source.value;
+  }
+  return void 0;
+};
+var isWorkerThreadsImportBinding = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  const definition = variable?.defs[0];
+  const importSource = definition === void 0 ? void 0 : getImportSourceValue5(definition.node);
+  return identifier.name === "Worker" && importSource !== void 0 && workerThreadsModuleNameSet.has(importSource);
+};
+var isShadowedBrowserWorkerIdentifier = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  return variable !== null && variable.defs.length > 0;
+};
+var getDirectWorkerConstructorName = (context, callee) => {
+  if (callee.type !== import_utils22.AST_NODE_TYPES.Identifier || !isBrowserWorkerConstructorName(callee.name)) {
+    return void 0;
+  }
+  if (isWorkerThreadsImportBinding(context, callee)) {
+    return "Worker";
+  }
+  return isShadowedBrowserWorkerIdentifier(context, callee) ? void 0 : callee.name;
+};
+var getMemberWorkerConstructorName = (callee) => {
+  if (callee.type !== import_utils22.AST_NODE_TYPES.MemberExpression || callee.computed || callee.optional || callee.object.type !== import_utils22.AST_NODE_TYPES.Identifier || callee.property.type !== import_utils22.AST_NODE_TYPES.Identifier || !isGlobalReceiverName8(callee.object.name) || !isBrowserWorkerConstructorName(callee.property.name)) {
+    return void 0;
+  }
+  return callee.property.name;
+};
+var getWorkerConstructorName = (context, callee) => getDirectWorkerConstructorName(context, callee) ?? getMemberWorkerConstructorName(callee);
+var isDiscardedWorkerInstance = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression16(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type === import_utils22.AST_NODE_TYPES.ExpressionStatement && parent.expression === current) {
+      return true;
+    }
+    if (parent.type === import_utils22.AST_NODE_TYPES.UnaryExpression && parent.operator === "void" && parent.argument === current) {
+      const unaryParent = getParentNode(parent);
+      return unaryParent?.type === import_utils22.AST_NODE_TYPES.ExpressionStatement;
+    }
+    return false;
+  }
+  return false;
+};
+var isImmediateWorkerMethodReceiver = (node) => {
+  let current = node;
+  let parent = getParentNode(current);
+  while (parent !== void 0) {
+    const wrappedExpression = getTransparentWrappedExpression16(parent);
+    if (wrappedExpression === current) {
+      current = parent;
+      parent = getParentNode(current);
+      continue;
+    }
+    if (parent.type !== import_utils22.AST_NODE_TYPES.MemberExpression || parent.object !== current || parent.computed || parent.property.type !== import_utils22.AST_NODE_TYPES.Identifier || parent.property.name === "terminate") {
+      return false;
+    }
+    const callExpression = getParentNode(parent);
+    return callExpression?.type === import_utils22.AST_NODE_TYPES.CallExpression && callExpression.callee === parent;
+  }
+  return false;
+};
+var noFloatingWorkers = createTypedRule({
+  create(context) {
+    return {
+      NewExpression(node) {
+        const workerName = getWorkerConstructorName(context, node.callee);
+        if (workerName === void 0 || !isDiscardedWorkerInstance(node) && !isImmediateWorkerMethodReceiver(node)) {
+          return;
+        }
+        context.report({
+          data: { workerName },
+          messageId: "floatingWorker",
+          node
+        });
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require worker handles to be retained so they can be terminated during cleanup.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-floating-workers")
+    },
+    messages: {
+      floatingWorker: "Store or return the {{workerName}} handle so it can be terminated during cleanup."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-floating-workers"
+});
+var no_floating_workers_default = noFloatingWorkers;
+
+// dist/rules/no-unmanaged-event-listeners.js
+var import_utils23 = require("@typescript-eslint/utils");
+var unknownCaptureKey = "*";
+var isCleanupBoundary = (node) => node.type === import_utils23.AST_NODE_TYPES.Program || node.type === import_utils23.AST_NODE_TYPES.FunctionDeclaration || node.type === import_utils23.AST_NODE_TYPES.FunctionExpression || node.type === import_utils23.AST_NODE_TYPES.ArrowFunctionExpression;
+var getCleanupBoundary = (node) => {
+  let current = node;
+  while (current !== void 0) {
+    if (isCleanupBoundary(current)) {
+      return current;
+    }
+    current = getParentNode(current);
+  }
+  throw new TypeError("Expected an addEventListener call to have a program.");
+};
+var getStaticPropertyName14 = (property) => {
+  if (property.type === import_utils23.AST_NODE_TYPES.Identifier) {
+    return property.name;
+  }
+  if (property.type === import_utils23.AST_NODE_TYPES.Literal && typeof property.value === "string") {
+    return property.value;
+  }
+  return void 0;
+};
+var isMethodCallNamed = (callee, methodName) => callee.type === import_utils23.AST_NODE_TYPES.MemberExpression && !callee.computed && callee.property.type === import_utils23.AST_NODE_TYPES.Identifier && callee.property.name === methodName;
+var isUnknownRecord = (value) => typeof value === "object" && value !== null;
+var isVariableDeclarator = (node) => isUnknownRecord(node) && node["type"] === import_utils23.AST_NODE_TYPES.VariableDeclarator;
+var getVariableInitializer = (context, identifier) => {
+  const scope = context.sourceCode.getScope(identifier);
+  const variable = getVariableInScopeChain(scope, identifier.name);
+  const definition = variable?.defs[0];
+  const definitionNode = definition?.node;
+  if (!isVariableDeclarator(definitionNode)) {
+    return void 0;
+  }
+  return definitionNode.init ?? void 0;
+};
+var resolveOptionsExpression = (context, argument) => {
+  if (argument.type === import_utils23.AST_NODE_TYPES.SpreadElement) {
+    return void 0;
+  }
+  if (argument.type === import_utils23.AST_NODE_TYPES.Identifier) {
+    return getVariableInitializer(context, argument);
+  }
+  return argument;
+};
+var objectExpressionHasProperty = (objectExpression, propertyName) => objectExpression.properties.some((property) => {
+  if (property.type === import_utils23.AST_NODE_TYPES.SpreadElement) {
+    return true;
+  }
+  return getStaticPropertyName14(property.key) === propertyName;
+});
+var getBooleanPropertyValue = (objectExpression, propertyName) => {
+  for (const property of objectExpression.properties) {
+    if (property.type === import_utils23.AST_NODE_TYPES.Property && getStaticPropertyName14(property.key) === propertyName && property.value.type === import_utils23.AST_NODE_TYPES.Literal && typeof property.value.value === "boolean") {
+      return property.value.value;
+    }
+  }
+  return void 0;
+};
+var hasAbortSignalOption = (context, argument) => {
+  if (argument === void 0) {
+    return false;
+  }
+  const resolvedOptions = resolveOptionsExpression(context, argument);
+  return resolvedOptions?.type === import_utils23.AST_NODE_TYPES.ObjectExpression && objectExpressionHasProperty(resolvedOptions, "signal");
+};
+var getCaptureKey = (context, argument) => {
+  if (argument === void 0) {
+    return "false";
+  }
+  const resolvedOptions = resolveOptionsExpression(context, argument);
+  if (resolvedOptions === void 0) {
+    return unknownCaptureKey;
+  }
+  if (resolvedOptions.type === import_utils23.AST_NODE_TYPES.Literal && typeof resolvedOptions.value === "boolean") {
+    return String(resolvedOptions.value);
+  }
+  if (resolvedOptions.type === import_utils23.AST_NODE_TYPES.ObjectExpression) {
+    const captureValue = getBooleanPropertyValue(resolvedOptions, "capture");
+    return captureValue === void 0 ? "false" : String(captureValue);
+  }
+  return unknownCaptureKey;
+};
+var getCleanupKey = (context, node) => {
+  if (node.arguments.length < 2 || node.callee.type !== import_utils23.AST_NODE_TYPES.MemberExpression) {
+    return void 0;
+  }
+  const [eventType, listener, options] = node.arguments;
+  if (eventType === void 0 || listener === void 0 || eventType.type === import_utils23.AST_NODE_TYPES.SpreadElement || listener.type === import_utils23.AST_NODE_TYPES.SpreadElement) {
+    return void 0;
+  }
+  const targetText = context.sourceCode.getText(node.callee.object);
+  const eventTypeText = context.sourceCode.getText(eventType);
+  const listenerText = context.sourceCode.getText(listener);
+  const captureKey = getCaptureKey(context, options);
+  return `${targetText}\0${eventTypeText}\0${listenerText}\0${captureKey}`;
+};
+var getWildcardCleanupKey = (cleanupKey) => {
+  const [targetText, eventTypeText, listenerText] = cleanupKey.split("\0", 3);
+  if (targetText === void 0 || eventTypeText === void 0 || listenerText === void 0) {
+    throw new TypeError("Expected a complete event listener cleanup key.");
+  }
+  return `${targetText}\0${eventTypeText}\0${listenerText}\0${unknownCaptureKey}`;
+};
+var noUnmanagedEventListeners = createTypedRule({
+  create(context) {
+    const addsByBoundary = /* @__PURE__ */ new Map();
+    const removesByBoundary = /* @__PURE__ */ new Map();
+    const addRecord = (boundary, record) => {
+      const records = addsByBoundary.get(boundary);
+      if (records === void 0) {
+        addsByBoundary.set(boundary, [record]);
+        return;
+      }
+      records.push(record);
+    };
+    const addRemoveKey = (boundary, cleanupKey) => {
+      const cleanupKeys = removesByBoundary.get(boundary);
+      if (cleanupKeys === void 0) {
+        removesByBoundary.set(boundary, /* @__PURE__ */ new Set([cleanupKey]));
+        return;
+      }
+      cleanupKeys.add(cleanupKey);
+    };
+    return {
+      'CallExpression[callee.type="MemberExpression"]'(node) {
+        if (isMethodCallNamed(node.callee, "addEventListener") && !hasAbortSignalOption(context, node.arguments[2])) {
+          const cleanupKey = getCleanupKey(context, node);
+          if (cleanupKey !== void 0) {
+            addRecord(getCleanupBoundary(node), {
+              cleanupKey,
+              node
+            });
+          }
+        }
+        if (isMethodCallNamed(node.callee, "removeEventListener")) {
+          const cleanupKey = getCleanupKey(context, node);
+          if (cleanupKey !== void 0) {
+            addRemoveKey(getCleanupBoundary(node), cleanupKey);
+          }
+        }
+      },
+      "Program:exit"() {
+        for (const [boundary, addRecords] of addsByBoundary) {
+          const removeKeys = removesByBoundary.get(boundary) ?? /* @__PURE__ */ new Set();
+          for (const { cleanupKey, node } of addRecords) {
+            if (removeKeys.has(cleanupKey) || removeKeys.has(getWildcardCleanupKey(cleanupKey))) {
+              continue;
+            }
+            context.report({
+              messageId: "unmanagedEventListener",
+              node
+            });
+          }
+        }
+      }
+    };
+  },
+  defaultOptions: [],
+  meta: {
+    docs: {
+      description: "require event listeners to have an abort signal or a matching cleanup call.",
+      recommended: true,
+      requiresTypeChecking: false,
+      runtimeCleanupConfigs: [
+        "runtime-cleanup.configs.recommended",
+        "runtime-cleanup.configs.recommended-type-checked",
+        "runtime-cleanup.configs.strict",
+        "runtime-cleanup.configs.all"
+      ],
+      url: createRuleDocsUrl("no-unmanaged-event-listeners")
+    },
+    messages: {
+      unmanagedEventListener: "Add an AbortSignal option or a matching removeEventListener call for this listener."
+    },
+    schema: [],
+    type: "problem"
+  },
+  name: "no-unmanaged-event-listeners"
+});
+var no_unmanaged_event_listeners_default = noUnmanagedEventListeners;
+
+// dist/_internal/rules-registry.js
+var runtimeCleanupRuleRegistry = {
+  "no-floating-abort-controllers": no_floating_abort_controllers_default,
+  "no-floating-audio-contexts": no_floating_audio_contexts_default,
+  "no-floating-broadcast-channels": no_floating_broadcast_channels_default,
+  "no-floating-child-processes": no_floating_child_processes_default,
+  "no-floating-disposable-stacks": no_floating_disposable_stacks_default,
+  "no-floating-file-watchers": no_floating_file_watchers_default,
+  "no-floating-geolocation-watches": no_floating_geolocation_watches_default,
+  "no-floating-infinite-animations": no_floating_infinite_animations_default,
+  "no-floating-media-streams": no_floating_media_streams_default,
+  "no-floating-message-channels": no_floating_message_channels_default,
+  "no-floating-network-connections": no_floating_network_connections_default,
+  "no-floating-object-urls": no_floating_object_urls_default,
+  "no-floating-observers": no_floating_observers_default,
+  "no-floating-servers": no_floating_servers_default,
+  "no-floating-streams": no_floating_streams_default,
+  "no-floating-timers": no_floating_timers_default,
+  "no-floating-wake-locks": no_floating_wake_locks_default,
+  "no-floating-web-stream-locks": no_floating_web_stream_locks_default,
+  "no-floating-workers": no_floating_workers_default,
+  "no-unmanaged-event-listeners": no_unmanaged_event_listeners_default
+};
+var runtimeCleanupRules = runtimeCleanupRuleRegistry;
+
+// dist/_internal/runtime-cleanup-config-references.js
+var runtimeCleanupConfigNames = [
+  "all",
+  "experimental",
+  "minimal",
+  "recommended",
+  "recommended-type-checked",
+  "strict"
+];
+var runtimeCleanupConfigMetadataByName = {
+  all: {
+    icon: "A",
+    presetName: "runtime-cleanup:all",
+    readmeOrder: 5,
+    requiresTypeChecking: true
+  },
+  experimental: {
+    icon: "E",
+    presetName: "runtime-cleanup:experimental",
+    readmeOrder: 6,
+    requiresTypeChecking: false
+  },
+  minimal: {
+    icon: "M",
+    presetName: "runtime-cleanup:minimal",
+    readmeOrder: 1,
+    requiresTypeChecking: false
+  },
+  recommended: {
+    icon: "R",
+    presetName: "runtime-cleanup:recommended",
+    readmeOrder: 2,
+    requiresTypeChecking: false
+  },
+  "recommended-type-checked": {
+    icon: "T",
+    presetName: "runtime-cleanup:recommended-type-checked",
+    readmeOrder: 3,
+    requiresTypeChecking: true
+  },
+  strict: {
+    icon: "S",
+    presetName: "runtime-cleanup:strict",
+    readmeOrder: 4,
+    requiresTypeChecking: true
+  }
+};
+
+// dist/plugin.js
+var TYPE_SCRIPT_FILES = ["**/*.{ts,tsx,mts,cts}"];
+function getPackageVersion(pkg) {
+  if (typeof pkg !== "object" || pkg === null) {
+    return "0.0.0";
+  }
+  const version = Reflect.get(pkg, "version");
+  return typeof version === "string" ? version : "0.0.0";
+}
+var typeScriptParserValue = import_parser.default;
+var defaultParserOptions = {
+  ecmaVersion: "latest",
+  sourceType: "module"
+};
+var normalizeParserOptions = (parserOptions) => parserOptions !== null && typeof parserOptions === "object" && !Array.isArray(parserOptions) ? { ...parserOptions } : { ...defaultParserOptions };
+var runtimeCleanupEslintRules = (
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Internal registry is intentionally narrowed to ESLint's plugin rule map contract.
+  runtimeCleanupRules
+);
+function errorRulesFor(ruleNames) {
+  const rules = {};
+  for (const ruleName of ruleNames) {
+    rules[`runtime-cleanup/${ruleName}`] = "error";
+  }
+  return rules;
+}
+var effectivePresetRuleNamesByConfig = {
+  all: [
+    "no-floating-abort-controllers",
+    "no-floating-audio-contexts",
+    "no-floating-broadcast-channels",
+    "no-floating-child-processes",
+    "no-floating-disposable-stacks",
+    "no-floating-file-watchers",
+    "no-floating-geolocation-watches",
+    "no-floating-infinite-animations",
+    "no-floating-media-streams",
+    "no-floating-message-channels",
+    "no-floating-network-connections",
+    "no-floating-object-urls",
+    "no-floating-observers",
+    "no-floating-servers",
+    "no-floating-streams",
+    "no-floating-timers",
+    "no-floating-wake-locks",
+    "no-floating-web-stream-locks",
+    "no-floating-workers",
+    "no-unmanaged-event-listeners"
+  ],
+  experimental: [],
+  minimal: [],
+  recommended: [
+    "no-floating-abort-controllers",
+    "no-floating-audio-contexts",
+    "no-floating-broadcast-channels",
+    "no-floating-child-processes",
+    "no-floating-disposable-stacks",
+    "no-floating-file-watchers",
+    "no-floating-geolocation-watches",
+    "no-floating-media-streams",
+    "no-floating-message-channels",
+    "no-floating-network-connections",
+    "no-floating-object-urls",
+    "no-floating-observers",
+    "no-floating-servers",
+    "no-floating-streams",
+    "no-floating-timers",
+    "no-floating-wake-locks",
+    "no-floating-workers",
+    "no-unmanaged-event-listeners"
+  ],
+  "recommended-type-checked": [
+    "no-floating-abort-controllers",
+    "no-floating-audio-contexts",
+    "no-floating-broadcast-channels",
+    "no-floating-child-processes",
+    "no-floating-disposable-stacks",
+    "no-floating-file-watchers",
+    "no-floating-geolocation-watches",
+    "no-floating-infinite-animations",
+    "no-floating-media-streams",
+    "no-floating-message-channels",
+    "no-floating-network-connections",
+    "no-floating-object-urls",
+    "no-floating-observers",
+    "no-floating-servers",
+    "no-floating-streams",
+    "no-floating-timers",
+    "no-floating-wake-locks",
+    "no-floating-web-stream-locks",
+    "no-floating-workers",
+    "no-unmanaged-event-listeners"
+  ],
+  strict: [
+    "no-floating-abort-controllers",
+    "no-floating-audio-contexts",
+    "no-floating-broadcast-channels",
+    "no-floating-child-processes",
+    "no-floating-disposable-stacks",
+    "no-floating-file-watchers",
+    "no-floating-geolocation-watches",
+    "no-floating-infinite-animations",
+    "no-floating-media-streams",
+    "no-floating-message-channels",
+    "no-floating-network-connections",
+    "no-floating-object-urls",
+    "no-floating-observers",
+    "no-floating-servers",
+    "no-floating-streams",
+    "no-floating-timers",
+    "no-floating-wake-locks",
+    "no-floating-web-stream-locks",
+    "no-floating-workers",
+    "no-unmanaged-event-listeners"
+  ]
+};
+function withRuntimeCleanupPlugin(config, plugin, options) {
+  const existingLanguageOptions = config.languageOptions ?? {};
+  const existingParserOptions = existingLanguageOptions["parserOptions"];
+  const parserOptions = normalizeParserOptions(existingParserOptions);
+  if (options.requiresTypeChecking && !Object.hasOwn(parserOptions, "projectService")) {
+    Reflect.set(parserOptions, "projectService", true);
+  }
+  const languageOptions = {
+    ...existingLanguageOptions,
+    parser: existingLanguageOptions["parser"] ?? typeScriptParserValue,
+    parserOptions
+  };
+  return {
+    ...config,
+    files: config.files ?? [...TYPE_SCRIPT_FILES],
+    languageOptions,
+    plugins: {
+      ...config.plugins,
+      "runtime-cleanup": plugin
+    }
+  };
+}
+var pluginForConfigs = {
+  rules: runtimeCleanupEslintRules
+};
+var createPresetConfig = (configName) => {
+  const configMetadata = runtimeCleanupConfigMetadataByName[configName];
+  return withRuntimeCleanupPlugin({
+    name: configMetadata.presetName,
+    rules: errorRulesFor(effectivePresetRuleNamesByConfig[configName])
+  }, pluginForConfigs, {
+    requiresTypeChecking: configMetadata.requiresTypeChecking
+  });
+};
+var createRuntimeCleanupConfigsDefinition = () => (
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-type-assertion -- Object.fromEntries cannot preserve the finite preset-key union.
+  Object.fromEntries(runtimeCleanupConfigNames.map((configName) => [
+    configName,
+    createPresetConfig(configName)
+  ]))
+);
+var runtimeCleanupConfigsDefinition = createRuntimeCleanupConfigsDefinition();
+var runtimeCleanupConfigs = runtimeCleanupConfigsDefinition;
+var runtimeCleanupPlugin = {
+  configs: runtimeCleanupConfigs,
+  meta: {
+    name: "eslint-plugin-runtime-cleanup",
+    namespace: "runtime-cleanup",
+    version: getPackageVersion(package_default)
+  },
+  processors: {},
+  rules: runtimeCleanupEslintRules
+};
+var plugin_default = runtimeCleanupPlugin;
+module.exports = module.exports.default;
+//# sourceMappingURL=plugin.cjs.map