@storm-software/eslint 0.170.104 → 0.170.106

package/dist/src-XM26HI2Q.js

@@ -0,0 +1,594 @@
+import { GLOB_EXCLUDE, GLOB_TS, GLOB_TSX } from './chunk-WRL7SCXT.js';
+import { __commonJS, init_esm_shims, __toESM } from './chunk-67G5I72Q.js';
+import * as __import__microsoft_tsdocConfig from '@microsoft/tsdoc-config';
+import * as __import_path from 'path';
+import * as __import_fs from 'fs';
+import * as __import__microsoft_tsdoc from '@microsoft/tsdoc';
+
+// ../../node_modules/.pnpm/eslint-plugin-tsdoc@0.4.0_patch_hash=c262176eba68bfd8898c896d48ca12af2147a650ca7a9cbfe8edf1cf981cdbc9/node_modules/eslint-plugin-tsdoc/lib/Debug.js
+var require_Debug = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-tsdoc@0.4.0_patch_hash=c262176eba68bfd8898c896d48ca12af2147a650ca7a9cbfe8edf1cf981cdbc9/node_modules/eslint-plugin-tsdoc/lib/Debug.js"(exports) {
+    init_esm_shims();
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.Debug = void 0;
+    var Debug = class {
+      // To debug the plugin, temporarily uncomment the body of this function
+      static log(message) {
+      }
+    };
+    exports.Debug = Debug;
+  }
+});
+var require_ConfigCache = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-tsdoc@0.4.0_patch_hash=c262176eba68bfd8898c896d48ca12af2147a650ca7a9cbfe8edf1cf981cdbc9/node_modules/eslint-plugin-tsdoc/lib/ConfigCache.js"(exports) {
+    init_esm_shims();
+    var __import___Debug = __toESM(require_Debug());
+    var __createBinding = exports && exports.__createBinding || (Object.create ? (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      var desc = Object.getOwnPropertyDescriptor(m, k);
+      if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+        desc = { enumerable: true, get: function() {
+          return m[k];
+        } };
+      }
+      Object.defineProperty(o, k2, desc);
+    }) : (function(o, m, k, k2) {
+      if (k2 === void 0) k2 = k;
+      o[k2] = m[k];
+    }));
+    var __setModuleDefault = exports && exports.__setModuleDefault || (Object.create ? (function(o, v) {
+      Object.defineProperty(o, "default", { enumerable: true, value: v });
+    }) : function(o, v) {
+      o["default"] = v;
+    });
+    var __importStar = exports && exports.__importStar || function(mod) {
+      if (mod && mod.__esModule) return mod;
+      var result = {};
+      if (mod != null) {
+        for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+      }
+      __setModuleDefault(result, mod);
+      return result;
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.ConfigCache = void 0;
+    var tsdoc_config_1 = __import__microsoft_tsdocConfig;
+    var path = __importStar(__import_path);
+    var Debug_1 = __import___Debug;
+    function _nullishCoalesce(lhs, rhsFn) {
+      if (lhs != null) {
+        return lhs;
+      } else {
+        return rhsFn();
+      }
+    }
+    var _fs = __import_fs;
+    var _path = __import_path;
+    var MAX_PATH_SEARCH_DEPTH = 30;
+    var depth = 0;
+    var ROOT_FILES = [
+      "storm-workspace.json",
+      "storm-workspace.json",
+      "storm-workspace.yaml",
+      "storm-workspace.yml",
+      "storm-workspace.js",
+      "storm-workspace.ts",
+      ".storm-workspace.json",
+      ".storm-workspace.yaml",
+      ".storm-workspace.yml",
+      ".storm-workspace.js",
+      ".storm-workspace.ts",
+      "lerna.json",
+      "nx.json",
+      "turbo.json",
+      "npm-workspace.json",
+      "yarn-workspace.json",
+      "pnpm-workspace.json",
+      "npm-workspace.yaml",
+      "yarn-workspace.yaml",
+      "pnpm-workspace.yaml",
+      "npm-workspace.yml",
+      "yarn-workspace.yml",
+      "pnpm-workspace.yml",
+      "npm-lock.json",
+      "yarn-lock.json",
+      "pnpm-lock.json",
+      "npm-lock.yaml",
+      "yarn-lock.yaml",
+      "pnpm-lock.yaml",
+      "npm-lock.yml",
+      "yarn-lock.yml",
+      "pnpm-lock.yml",
+      "bun.lockb"
+    ];
+    var ROOT_DIRECTORIES = [
+      ".storm-workspace",
+      ".nx",
+      ".github",
+      ".vscode",
+      ".verdaccio"
+    ];
+    function findWorkspaceRoot(startPath) {
+      const _startPath = _nullishCoalesce(startPath, () => process.cwd());
+      if (ROOT_DIRECTORIES.some(
+        (endDirName) => _fs.existsSync.call(void 0, _path.join.call(void 0, _startPath, endDirName))
+      )) {
+        return _startPath;
+      }
+      if (ROOT_FILES.some(
+        (endFileName) => _fs.existsSync.call(void 0, _path.join.call(void 0, _startPath, endFileName))
+      )) {
+        return _startPath;
+      }
+      if (_startPath !== "/" && depth++ < MAX_PATH_SEARCH_DEPTH) {
+        const parent = _path.join.call(void 0, _startPath, "..");
+        return findWorkspaceRoot(parent);
+      }
+      return void 0;
+    }
+    var CACHE_CHECK_INTERVAL_MS = 3 * 1e3;
+    var CACHE_EXPIRE_MS = 20 * 1e3;
+    var CACHE_MAX_SIZE = 100;
+    var ConfigCache = class _ConfigCache {
+      /**
+       * Node.js equivalent of performance.now().
+       */
+      static _getTimeInMs() {
+        const [seconds, nanoseconds] = process.hrtime();
+        return seconds * 1e3 + nanoseconds / 1e6;
+      }
+      static getForSourceFile(sourceFilePath, tsConfigRootDir) {
+        const sourceFileFolder = path.dirname(path.resolve(sourceFilePath));
+        const configFilePath = tsConfigRootDir ? path.join(tsConfigRootDir, tsdoc_config_1.TSDocConfigFile.FILENAME) : tsdoc_config_1.TSDocConfigFile.findConfigPathForFolder(sourceFileFolder);
+        const cacheKey = configFilePath || sourceFileFolder + "/";
+        Debug_1.Debug.log(`Cache key: "${cacheKey}"`);
+        const nowMs = _ConfigCache._getTimeInMs();
+        let cachedConfig = void 0;
+        cachedConfig = _ConfigCache._cachedConfigs.get(cacheKey);
+        if (cachedConfig) {
+          Debug_1.Debug.log("Cache hit");
+          const loadAgeMs = nowMs - cachedConfig.loadTimeMs;
+          const lastCheckAgeMs = nowMs - cachedConfig.lastCheckTimeMs;
+          if (loadAgeMs > CACHE_EXPIRE_MS || loadAgeMs < 0) {
+            Debug_1.Debug.log("Evicting because item is expired");
+            cachedConfig = void 0;
+            _ConfigCache._cachedConfigs.delete(cacheKey);
+          } else if (lastCheckAgeMs > CACHE_CHECK_INTERVAL_MS || lastCheckAgeMs < 0) {
+            Debug_1.Debug.log("Checking for modifications");
+            cachedConfig.lastCheckTimeMs = nowMs;
+            if (cachedConfig.configFile.checkForModifiedFiles()) {
+              Debug_1.Debug.log("Evicting because item was modified");
+              cachedConfig = void 0;
+              _ConfigCache._cachedConfigs.delete(cacheKey);
+            }
+          }
+        }
+        if (!cachedConfig) {
+          if (_ConfigCache._cachedConfigs.size > CACHE_MAX_SIZE) {
+            Debug_1.Debug.log("Clearing cache");
+            _ConfigCache._cachedConfigs.clear();
+          }
+          const configFile = tsdoc_config_1.TSDocConfigFile.loadFile(configFilePath);
+          if (configFile.fileNotFound) {
+            Debug_1.Debug.log(`File not found: "${configFilePath}"`);
+          } else {
+            Debug_1.Debug.log(`Loaded: "${configFilePath}"`);
+          }
+          cachedConfig = {
+            configFile,
+            lastCheckTimeMs: nowMs,
+            loadTimeMs: nowMs
+          };
+          _ConfigCache._cachedConfigs.set(cacheKey, cachedConfig);
+        }
+        return cachedConfig.configFile;
+      }
+      static _checkConfigFilePath(workspaceRoot, configFilePath) {
+        const workspaceRootPath = workspaceRoot ? workspaceRoot : "./";
+        if (!configFilePath) {
+          return void 0;
+        }
+        if (_fs.existsSync(configFilePath)) {
+          return configFilePath;
+        } else if (_fs.existsSync(
+          path.join(
+            workspaceRootPath,
+            configFilePath
+          )
+        )) {
+          return path.join(
+            workspaceRootPath,
+            configFilePath
+          );
+        } else if (_fs.existsSync(
+          path.join(
+            workspaceRootPath,
+            "node_modules",
+            configFilePath
+          )
+        )) {
+          return path.join(
+            workspaceRootPath,
+            "node_modules",
+            configFilePath
+          );
+        } else if (_fs.existsSync(
+          path.join(
+            workspaceRootPath,
+            "node_modules",
+            "@storm-software",
+            "tsdoc",
+            configFilePath
+          )
+        )) {
+          return path.join(
+            workspaceRootPath,
+            "node_modules",
+            "@storm-software",
+            "tsdoc",
+            configFilePath
+          );
+        } else if (_fs.existsSync(
+          path.join(
+            workspaceRootPath,
+            "node_modules",
+            "@storm-software",
+            "tsdoc",
+            "config",
+            configFilePath
+          )
+        )) {
+          return path.join(
+            workspaceRootPath,
+            "node_modules",
+            "@storm-software",
+            "tsdoc",
+            "config",
+            configFilePath
+          );
+        } else if (_fs.existsSync(
+          path.join(
+            workspaceRootPath,
+            "node_modules",
+            "@storm-software",
+            "tsdoc",
+            "dist",
+            configFilePath
+          )
+        )) {
+          return path.join(
+            workspaceRootPath,
+            "node_modules",
+            "@storm-software",
+            "tsdoc",
+            "dist",
+            configFilePath
+          );
+        }
+        return void 0;
+      }
+      static getStormConfigFile(options) {
+        const type = options && options.type ? options.type : "recommended";
+        const configFile = options && options.configFile ? options.configFile : void 0;
+        let workspaceRoot = "";
+        if (process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH) {
+          workspaceRoot = process.env.STORM_WORKSPACE_ROOT || process.env.NX_WORKSPACE_ROOT_PATH;
+        }
+        if (!workspaceRoot) {
+          workspaceRoot = findWorkspaceRoot();
+        }
+        let currentConfigFile = process.env.STORM_TSDOC_CONFIG_FILE ? process.env.STORM_TSDOC_CONFIG_FILE : configFile;
+        Debug_1.Debug.log(`Config file from user options: ${currentConfigFile || "(none)"}`);
+        let configFilePath = _ConfigCache._checkConfigFilePath(
+          workspaceRoot,
+          currentConfigFile
+        );
+        if (!configFilePath) {
+          currentConfigFile = `${((process.env.STORM_TSDOC_TYPE ? process.env.STORM_TSDOC_TYPE : type) || "recommended").replace(/\.jsonc?$/, "")}.json`;
+          Debug_1.Debug.log(`Config file from user options not found, trying: ${currentConfigFile}`);
+          configFilePath = _ConfigCache._checkConfigFilePath(
+            workspaceRoot,
+            currentConfigFile
+          );
+          if (!configFilePath) {
+            configFilePath = _ConfigCache._checkConfigFilePath(
+              workspaceRoot,
+              "recommended.json"
+            );
+            if (!configFilePath) {
+              configFilePath = _ConfigCache._checkConfigFilePath(
+                workspaceRoot,
+                "tsdoc.json"
+              );
+            }
+          }
+        }
+        const cacheKey = configFilePath || "missing-config-file";
+        Debug_1.Debug.log(`Storm Software Configuration Cache key: "${cacheKey}"`);
+        const nowMs = _ConfigCache._getTimeInMs();
+        let cachedConfig = void 0;
+        cachedConfig = _ConfigCache._cachedConfigs.get(cacheKey);
+        if (cachedConfig) {
+          Debug_1.Debug.log("Cache hit");
+          const loadAgeMs = nowMs - cachedConfig.loadTimeMs;
+          const lastCheckAgeMs = nowMs - cachedConfig.lastCheckTimeMs;
+          if (loadAgeMs > CACHE_EXPIRE_MS || loadAgeMs < 0) {
+            Debug_1.Debug.log("Evicting because item is expired");
+            cachedConfig = void 0;
+            _ConfigCache._cachedConfigs.delete(cacheKey);
+          } else if (lastCheckAgeMs > CACHE_CHECK_INTERVAL_MS || lastCheckAgeMs < 0) {
+            Debug_1.Debug.log("Checking for modifications");
+            cachedConfig.lastCheckTimeMs = nowMs;
+            if (cachedConfig.configFile.checkForModifiedFiles()) {
+              Debug_1.Debug.log("Evicting because item was modified");
+              cachedConfig = void 0;
+              _ConfigCache._cachedConfigs.delete(cacheKey);
+            }
+          }
+        }
+        if (!cachedConfig) {
+          if (_ConfigCache._cachedConfigs.size > CACHE_MAX_SIZE) {
+            Debug_1.Debug.log("Clearing cache");
+            _ConfigCache._cachedConfigs.clear();
+          }
+          const configFile2 = tsdoc_config_1.TSDocConfigFile.loadFile(configFilePath);
+          if (configFile2.fileNotFound) {
+            Debug_1.Debug.log(`File not found: "${configFilePath}"`);
+          } else {
+            Debug_1.Debug.log(`Loaded: "${configFilePath}"`);
+          }
+          cachedConfig = {
+            configFile: configFile2,
+            lastCheckTimeMs: nowMs,
+            loadTimeMs: nowMs
+          };
+          _ConfigCache._cachedConfigs.set(cacheKey, cachedConfig);
+        }
+        return cachedConfig.configFile;
+      }
+    };
+    exports.ConfigCache = ConfigCache;
+    ConfigCache._cachedConfigs = /* @__PURE__ */ new Map();
+    ConfigCache._cachedPaths = /* @__PURE__ */ new Map();
+  }
+});
+var require_lib = __commonJS({
+  "../../node_modules/.pnpm/eslint-plugin-tsdoc@0.4.0_patch_hash=c262176eba68bfd8898c896d48ca12af2147a650ca7a9cbfe8edf1cf981cdbc9/node_modules/eslint-plugin-tsdoc/lib/index.js"(exports, module) {
+    init_esm_shims();
+    var __import___Debug = __toESM(require_Debug());
+    var __import___ConfigCache = __toESM(require_ConfigCache());
+    var tsdoc_1 = __import__microsoft_tsdoc;
+    var Debug_1 = __import___Debug;
+    var ConfigCache_1 = __import___ConfigCache;
+    var tsdocMessageIds = {};
+    var defaultTSDocConfiguration = new tsdoc_1.TSDocConfiguration();
+    defaultTSDocConfiguration.allTsdocMessageIds.forEach((messageId) => {
+      tsdocMessageIds[messageId] = `${messageId}: {{unformattedText}}`;
+    });
+    var plugin2 = {
+      rules: {
+        // NOTE: The actual ESLint rule name will be "tsdoc/syntax".  It is calculated by deleting "eslint-plugin-"
+        // from the NPM package name, and then appending this string.
+        syntax: {
+          meta: {
+            messages: Object.assign({
+              "error-loading-storm-config": `Error loading Storm Software's shared TSDoc config file:
+{{details}} 
+
+Please ensure "@storm-software/tsdoc" is installed in the workspace root.`,
+              "error-loading-config-file": "Error loading TSDoc config file:\n{{details}}",
+              "error-applying-storm-config": "Error applying Storm Software's shared TSDoc configuration: {{details}}",
+              "error-applying-config": "Error applying TSDoc configuration: {{details}}"
+            }, tsdocMessageIds),
+            type: "problem",
+            docs: {
+              description: "Validates that TypeScript documentation comments conform to the TSDoc standard",
+              category: "Stylistic Issues",
+              recommended: true,
+              url: "https://tsdoc.org/pages/packages/eslint-plugin-tsdoc"
+            },
+            schema: [
+              {
+                type: "object",
+                properties: {
+                  type: {
+                    type: "string",
+                    enum: ["typedoc", "api-extractor", "base", "core", "callouts", "recommended"],
+                    description: "The TSDoc configuration type to use from '@storm-software/tsdoc'. Defaults to 'recommended' (@storm-software/tsdoc/recommended.json)."
+                  },
+                  configFile: {
+                    type: "string",
+                    description: "The TSDoc configuration file to use."
+                  },
+                  tsconfigRootDir: {
+                    type: "string",
+                    description: "The root directory to use when resolving the tsconfig file. This is only necessary if the tsconfig file is not located in the same directory as the source file being linted. If not provided, eslint will attempt to use the parser option 'tsconfigRootDir' if it is available."
+                  }
+                },
+                additionalProperties: false
+              }
+            ]
+          },
+          defaultOptions: [
+            {
+              type: "recommended"
+            }
+          ],
+          create: (context) => {
+            const tsdocConfiguration = new tsdoc_1.TSDocConfiguration();
+            let tsConfigDir = void 0;
+            const sourceFilePath = context.filename;
+            Debug_1.Debug.log(`Linting: "${sourceFilePath}"`);
+            try {
+              let tsdocConfigFile = {};
+              try {
+                const userOptions = context.options ? Array.isArray(context.options) ? context.options.length > 0 ? context.options[0] : {} : context.options : {};
+                tsConfigDir = userOptions.tsconfigRootDir;
+                if (!tsConfigDir && context.parserOptions && context.parserOptions.tsconfigRootDir) {
+                  tsConfigDir = context.parserOptions.tsconfigRootDir;
+                }
+                const config2 = { type: userOptions.type || "recommended", configFile: userOptions.configFile };
+                Debug_1.Debug.log(`Using eslint-plugin-tsdoc config: ${JSON.stringify(config2, void 0, 2)}`);
+                tsdocConfigFile = ConfigCache_1.ConfigCache.getStormConfigFile(config2);
+                if (!tsdocConfigFile.fileNotFound) {
+                  if (tsdocConfigFile.hasErrors) {
+                    context.report({
+                      loc: { line: 1, column: 1 },
+                      messageId: "error-loading-storm-config",
+                      data: {
+                        details: tsdocConfigFile.getErrorSummary()
+                      }
+                    });
+                  }
+                  try {
+                    tsdocConfigFile.configureParser(tsdocConfiguration);
+                  } catch (e) {
+                    context.report({
+                      loc: { line: 1, column: 1 },
+                      messageId: "error-applying-storm-config",
+                      data: {
+                        details: e.message
+                      }
+                    });
+                  }
+                }
+              } catch (e) {
+                context.report({
+                  loc: { line: 1, column: 1 },
+                  messageId: "error-loading-storm-config",
+                  data: {
+                    details: `Unexpected exception: ${e.message}`
+                  }
+                });
+              }
+              if (!tsdocConfigFile || tsdocConfigFile.fileNotFound || tsdocConfigFile.hasErrors) {
+                tsdocConfigFile = ConfigCache_1.ConfigCache.getForSourceFile(sourceFilePath, tsConfigDir);
+                if (!tsdocConfigFile.fileNotFound) {
+                  if (tsdocConfigFile.hasErrors) {
+                    context.report({
+                      loc: { line: 1, column: 1 },
+                      messageId: "error-loading-config-file",
+                      data: {
+                        details: tsdocConfigFile.getErrorSummary()
+                      }
+                    });
+                  }
+                  try {
+                    tsdocConfigFile.configureParser(tsdocConfiguration);
+                  } catch (e) {
+                    context.report({
+                      loc: { line: 1, column: 1 },
+                      messageId: "error-applying-config",
+                      data: {
+                        details: e.message
+                      }
+                    });
+                  }
+                }
+              }
+            } catch (e) {
+              context.report({
+                loc: { line: 1, column: 1 },
+                messageId: "error-loading-config-file",
+                data: {
+                  details: `Unexpected exception: ${e.message}`
+                }
+              });
+            }
+            const tsdocParser = new tsdoc_1.TSDocParser(tsdocConfiguration);
+            const sourceCode = context.sourceCode || context.getSourceCode();
+            const checkCommentBlocks = function(node) {
+              for (const comment of sourceCode.getAllComments()) {
+                if (comment.type !== "Block") {
+                  continue;
+                }
+                if (!comment.range) {
+                  continue;
+                }
+                const textRange = tsdoc_1.TextRange.fromStringRange(sourceCode.text, comment.range[0], comment.range[1]);
+                if (textRange.length < 5) {
+                  continue;
+                }
+                if (textRange.buffer[textRange.pos + 2] !== "*") {
+                  continue;
+                }
+                const parserContext = tsdocParser.parseRange(textRange);
+                for (const message of parserContext.log.messages) {
+                  context.report({
+                    loc: {
+                      start: sourceCode.getLocFromIndex(message.textRange.pos),
+                      end: sourceCode.getLocFromIndex(message.textRange.end)
+                    },
+                    messageId: message.messageId,
+                    data: {
+                      unformattedText: message.unformattedText
+                    }
+                  });
+                }
+              }
+            };
+            return {
+              Program: checkCommentBlocks
+            };
+          }
+        }
+      }
+    };
+    module.exports = plugin2;
+  }
+});
+
+// ../eslint-plugin-tsdoc/src/index.ts
+init_esm_shims();
+
+// ../eslint-plugin-tsdoc/src/configs/index.ts
+init_esm_shims();
+
+// ../eslint-plugin-tsdoc/src/configs/recommended.ts
+init_esm_shims();
+
+// ../eslint-plugin-tsdoc/src/plugin.ts
+init_esm_shims();
+var import_eslint_plugin_tsdoc = __toESM(require_lib(), 1);
+
+// ../eslint-plugin-tsdoc/package.json
+var package_default = {
+  version: "0.0.35"};
+
+// ../eslint-plugin-tsdoc/src/plugin.ts
+var plugin = {
+  ...import_eslint_plugin_tsdoc.default,
+  meta: {
+    name: "tsdoc",
+    version: package_default.version
+  }
+};
+
+// ../eslint-plugin-tsdoc/src/configs/recommended.ts
+var config = {
+  files: [GLOB_TS, GLOB_TSX],
+  ignores: GLOB_EXCLUDE,
+  name: "tsdoc/recommended",
+  plugins: {
+    tsdoc: plugin
+  },
+  rules: {
+    "tsdoc/syntax": ["error", { type: "recommended" }]
+  }
+};
+var recommended_default = config;
+
+// ../eslint-plugin-tsdoc/src/configs/index.ts
+var configs = {
+  recommended: recommended_default
+};
+
+// ../eslint-plugin-tsdoc/src/index.ts
+var eslintPlugin = {
+  ...plugin,
+  configs
+};
+var src_default = eslintPlugin;
+var rules = plugin.rules;
+
+export { configs, src_default as default, rules };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@storm-software/eslint",
-  "version": "0.170.104",
+  "version": "0.170.106",
   "private": false,
   "description": "A package containing the base ESLint configuration used by Storm Software across many projects.",
   "keywords": [
@@ -141,9 +141,9 @@
     "@eslint/eslintrc": "^3.3.5",
     "@eslint/markdown": "^6.6.0",
     "@nx/eslint-plugin": "22.7.5",
-    "@storm-software/config": "1.138.8",
-    "@storm-software/config-tools": "1.190.71",
-    "@storm-software/package-constants": "0.1.84",
+    "@storm-software/config": "1.138.10",
+    "@storm-software/config-tools": "1.190.73",
+    "@storm-software/package-constants": "0.1.86",
     "@stylistic/eslint-plugin": "^4.4.1",
     "@typescript-eslint/eslint-plugin": "^8.61.1",
     "@typescript-eslint/parser": "^8.61.1",
@@ -196,10 +196,10 @@
     "@next/eslint-plugin-next": "^15.5.19",
     "@nx/eslint": "22.7.5",
     "@prettier/plugin-xml": "^3.4.2",
-    "@storm-software/eslint-plugin-banner": "0.0.36",
-    "@storm-software/eslint-plugin-pnpm": "0.0.34",
-    "@storm-software/eslint-plugin-tsdoc": "0.0.34",
-    "@storm-software/tsdoc": "0.13.224",
+    "@storm-software/eslint-plugin-banner": "0.0.38",
+    "@storm-software/eslint-plugin-pnpm": "0.0.36",
+    "@storm-software/eslint-plugin-tsdoc": "0.0.36",
+    "@storm-software/tsdoc": "0.13.226",
     "@stylistic/eslint-plugin-migrate": "^4.4.1",
     "@types/eslint": "^9.6.1",
     "@types/eslint__js": "^8.42.3",
@@ -272,5 +272,5 @@
     "zod": { "optional": true }
   },
   "publishConfig": { "access": "public" },
-  "gitHead": "61aa40134f04beb1518d087468564cc376f6ce99"
+  "gitHead": "3dd2fb4ab63355ce109d0de971a2a0151d79cdba"
 }