@mnaoumov/obsidian-dev-toolkit 0.0.0 → 1.0.0

package/dist/lib/esm/linters/eslint-rules/no-untrusted-input-events.d.mts

@@ -0,0 +1,10 @@
+/// <reference path="../../index.d.mts" />
+import type { Rule } from 'eslint';
+/**
+Message ID reported when an integration test drives the UI with a dispatched input event.
+ */
+export declare const MESSAGE_ID = "noUntrustedInputEvents";
+/**
+ * ESLint rule disallowing untrusted input events in integration tests, where they can silently exercise nothing.
+ */
+export declare const noUntrustedInputEvents: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/no-untrusted-input-events.mjs

@@ -0,0 +1,146 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { toTSESTreeNode } from "@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node";
+const MESSAGE_ID = "noUntrustedInputEvents";
+const ADVICE_BY_EVENT_NAME = /* @__PURE__ */ new Map([
+  ["DragEvent", "there is no trusted equivalent, because `sendInputEvent` cannot express a drag, so keep the dispatch and disable this rule with the reason"],
+  ["KeyboardEvent", "use `pressKey`, focusing the target first, since a trusted key press goes to whatever holds DOM focus"],
+  ["MouseEvent", "use `clickElement`, or `clickMouse` when the point to click is not an element centre"],
+  ["PointerEvent", "use `clickElement`, or `clickMouse` when the point to click is not an element centre"],
+  ["TouchEvent", "there is no trusted equivalent, so keep the dispatch and disable this rule with the reason"],
+  ["WheelEvent", "there is no trusted equivalent, so keep the dispatch and disable this rule with the reason"]
+]);
+const noUntrustedInputEvents = {
+  create(context) {
+    return {
+      "CallExpression"(node) {
+        const callNode = toTSESTreeNode(node);
+        if (!isDispatchEventCall(callNode)) {
+          return;
+        }
+        const argument = callNode.arguments[0];
+        if (!argument) {
+          return;
+        }
+        const eventName = resolveEventName(argument, node, context);
+        if (eventName === null) {
+          return;
+        }
+        const advice = ADVICE_BY_EVENT_NAME.get(eventName);
+        if (advice === void 0) {
+          return;
+        }
+        context.report({
+          data: {
+            advice,
+            eventName
+          },
+          messageId: MESSAGE_ID,
+          node
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Disallow driving integration tests with dispatched (untrusted) input events"
+    },
+    messages: {
+      [MESSAGE_ID]: "A dispatched {{ eventName }} is untrusted (`isTrusted === false`) and Obsidian may ignore it, so this can exercise nothing while still passing: {{ advice }}."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+function findVariable(scope, name) {
+  let currentScope = scope;
+  while (currentScope) {
+    const variable = currentScope.variables.find((candidate) => candidate.name === name);
+    if (variable) {
+      return variable;
+    }
+    currentScope = currentScope.upper;
+  }
+  return null;
+}
+function isDispatchEventCall(node) {
+  const callee = node.callee;
+  return callee.type === "MemberExpression" && callee.property.type === "Identifier" && callee.property.name === "dispatchEvent";
+}
+function readConstructorName(node) {
+  return node.callee.type === "Identifier" ? node.callee.name : null;
+}
+function resolveEventName(argument, node, context) {
+  if (argument.type === "NewExpression") {
+    return readConstructorName(argument);
+  }
+  if (argument.type !== "Identifier") {
+    return null;
+  }
+  const variable = findVariable(context.sourceCode.getScope(node), argument.name);
+  if (!variable) {
+    return null;
+  }
+  for (const definition of variable.defs) {
+    const definitionNode = toTSESTreeNode(definition.node);
+    if (definitionNode.type !== "VariableDeclarator" || !definitionNode.init) {
+      continue;
+    }
+    if (definitionNode.init.type === "NewExpression") {
+      return readConstructorName(definitionNode.init);
+    }
+  }
+  return null;
+}
+export {
+  MESSAGE_ID,
+  noUntrustedInputEvents
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/no-untrusted-input-events.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: no-untrusted-input-events\n *\n * Reports an integration test that drives the UI by dispatching an INPUT event \u2014\n * `el.dispatchEvent(new KeyboardEvent(...))`, `new MouseEvent(...)`, and friends.\n *\n * Such an event is untrusted (`isTrusted === false`), and Obsidian and CodeMirror\n * routinely gate on exactly that: Obsidian 1.13's markdown viewport menu opens from\n * a listener guarded by `e.isTrusted`, so a dispatched `contextmenu` reaches nothing.\n * The test then exercises NOTHING while still passing whatever weaker assertion it\n * makes \u2014 a false-confidence failure, not a flake.\n *\n * The trusted alternatives \u2014 `pressKey`, `clickElement`, `clickMouse`, `hoverElement`,\n * `typeIntoEditor` \u2014 are seeded into the `evalInObsidian` callback's `lib` bag, and are\n * also importable from `obsidian-dev-utils/obsidian/trusted-input`, which picks the\n * desktop or mobile injector itself. All of them work on Android except the hover\n * helpers, which throw there because `:hover` has no touch equivalent.\n *\n * NOTIFICATION events are deliberately NOT reported. `new Event('input')` after setting\n * an element's `.value` is telling the app about a change rather than pretending to be a\n * user, and nothing gates it on `isTrusted`.\n *\n * Not every dispatch is wrong, so the rule is meant to be disabled \u2014 with a reason \u2014 at\n * the sites that have one: a drag sequence, which `sendInputEvent` cannot express at all;\n * the mobile arm of a hover gesture, which has no touch equivalent; and a listener that\n * is the plugin's own and checks nothing but the key. `require-description`\n * makes that reason mandatory, which is the point: the rule turns an invisible assumption\n * into a written one.\n */\nimport type { TSESTree } from '@typescript-eslint/utils';\nimport type {\n  Rule,\n  Scope\n} from 'eslint';\n\nimport { toTSESTreeNode } from '@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node';\n\n/**\nMessage ID reported when an integration test drives the UI with a dispatched input event.\n */\nexport const MESSAGE_ID = 'noUntrustedInputEvents';\n\n/**\n * What to do instead, per event constructor. An event absent from this map is a\n * notification rather than simulated input, and is left alone.\n */\nconst ADVICE_BY_EVENT_NAME = new Map<string, string>([\n  ['DragEvent', 'there is no trusted equivalent, because `sendInputEvent` cannot express a drag, so keep the dispatch and disable this rule with the reason'],\n  ['KeyboardEvent', 'use `pressKey`, focusing the target first, since a trusted key press goes to whatever holds DOM focus'],\n  ['MouseEvent', 'use `clickElement`, or `clickMouse` when the point to click is not an element centre'],\n  ['PointerEvent', 'use `clickElement`, or `clickMouse` when the point to click is not an element centre'],\n  ['TouchEvent', 'there is no trusted equivalent, so keep the dispatch and disable this rule with the reason'],\n  ['WheelEvent', 'there is no trusted equivalent, so keep the dispatch and disable this rule with the reason']\n]);\n\n/**\n * ESLint rule disallowing untrusted input events in integration tests, where they can silently exercise nothing.\n */\nexport const noUntrustedInputEvents: Rule.RuleModule = {\n  create(context) {\n    return {\n      'CallExpression'(node: Rule.Node): void {\n        const callNode = toTSESTreeNode(node) as TSESTree.CallExpression;\n\n        if (!isDispatchEventCall(callNode)) {\n          return;\n        }\n\n        const argument = callNode.arguments[0];\n        if (!argument) {\n          return;\n        }\n\n        const eventName = resolveEventName(argument, node, context);\n        if (eventName === null) {\n          return;\n        }\n\n        const advice = ADVICE_BY_EVENT_NAME.get(eventName);\n        if (advice === undefined) {\n          return;\n        }\n\n        context.report({\n          data: {\n            advice,\n            eventName\n          },\n          messageId: MESSAGE_ID,\n          node\n        });\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Disallow driving integration tests with dispatched (untrusted) input events'\n    },\n    messages: {\n      [MESSAGE_ID]: 'A dispatched {{ eventName }} is untrusted (`isTrusted === false`) and Obsidian may ignore it, so this can exercise nothing while still passing: {{ advice }}.'\n    },\n    schema: [],\n    type: 'problem'\n  }\n};\n\n/**\n * Finds a variable by name, walking outwards from the given scope.\n *\n * @param scope - The scope to start from.\n * @param name - The variable's name.\n * @returns The variable, or `null` when nothing in scope declares that name.\n */\nfunction findVariable(scope: Scope.Scope, name: string): null | Scope.Variable {\n  let currentScope: null | Scope.Scope = scope;\n\n  while (currentScope) {\n    const variable = currentScope.variables.find((candidate) => candidate.name === name);\n    if (variable) {\n      return variable;\n    }\n    currentScope = currentScope.upper;\n  }\n\n  return null;\n}\n\n/**\n * Checks whether a call expression is a `.dispatchEvent(...)` call.\n *\n * @param node - The call expression node.\n * @returns `true` if the call is `<something>.dispatchEvent(...)`.\n */\nfunction isDispatchEventCall(node: TSESTree.CallExpression): boolean {\n  const callee = node.callee;\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return callee.type === 'MemberExpression' && callee.property.type === 'Identifier' && callee.property.name === 'dispatchEvent';\n}\n\n/**\n * Reads the identifier a `new ...()` expression constructs.\n *\n * @param node - The `NewExpression` node.\n * @returns The constructor's name, or `null` when the callee is not a bare identifier.\n */\nfunction readConstructorName(node: TSESTree.NewExpression): null | string {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  return node.callee.type === 'Identifier' ? node.callee.name : null;\n}\n\n/**\n * Reads the constructor name of the event being dispatched.\n *\n * Handles the argument written inline (`dispatchEvent(new MouseEvent(...))`) and the\n * argument held in a variable (`const e = new DragEvent(...); el.dispatchEvent(e)`),\n * which is how a sequence sharing one `DataTransfer` is usually written.\n *\n * @param argument - The first argument of the `dispatchEvent` call.\n * @param node - The call node, used to resolve the enclosing scope.\n * @param context - The rule context.\n * @returns The constructor name, or `null` when it cannot be determined.\n */\nfunction resolveEventName(argument: TSESTree.Node, node: Rule.Node, context: Rule.RuleContext): null | string {\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  if (argument.type === 'NewExpression') {\n    return readConstructorName(argument);\n  }\n\n  // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n  if (argument.type !== 'Identifier') {\n    return null;\n  }\n\n  const variable = findVariable(context.sourceCode.getScope(node), argument.name);\n  if (!variable) {\n    return null;\n  }\n\n  for (const definition of variable.defs) {\n    const definitionNode = toTSESTreeNode(definition.node);\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n    if (definitionNode.type !== 'VariableDeclarator' || !definitionNode.init) {\n      continue;\n    }\n\n    // eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison -- AST node type string literals match the TSESTree enum values.\n    if (definitionNode.init.type === 'NewExpression') {\n      return readConstructorName(definitionNode.init);\n    }\n  }\n\n  return null;\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqCA,SAAS,sBAAsB;AAKxB,MAAM,aAAa;AAM1B,MAAM,uBAAuB,oBAAI,IAAoB;AAAA,EACnD,CAAC,aAAa,4IAA4I;AAAA,EAC1J,CAAC,iBAAiB,uGAAuG;AAAA,EACzH,CAAC,cAAc,sFAAsF;AAAA,EACrG,CAAC,gBAAgB,sFAAsF;AAAA,EACvG,CAAC,cAAc,4FAA4F;AAAA,EAC3G,CAAC,cAAc,4FAA4F;AAC7G,CAAC;AAKM,MAAM,yBAA0C;AAAA,EACrD,OAAO,SAAS;AACd,WAAO;AAAA,MACL,iBAAiB,MAAuB;AACtC,cAAM,WAAW,eAAe,IAAI;AAEpC,YAAI,CAAC,oBAAoB,QAAQ,GAAG;AAClC;AAAA,QACF;AAEA,cAAM,WAAW,SAAS,UAAU,CAAC;AACrC,YAAI,CAAC,UAAU;AACb;AAAA,QACF;AAEA,cAAM,YAAY,iBAAiB,UAAU,MAAM,OAAO;AAC1D,YAAI,cAAc,MAAM;AACtB;AAAA,QACF;AAEA,cAAM,SAAS,qBAAqB,IAAI,SAAS;AACjD,YAAI,WAAW,QAAW;AACxB;AAAA,QACF;AAEA,gBAAQ,OAAO;AAAA,UACb,MAAM;AAAA,YACJ;AAAA,YACA;AAAA,UACF;AAAA,UACA,WAAW;AAAA,UACX;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAAA,EACA,MAAM;AAAA,IACJ,MAAM;AAAA,MACJ,aAAa;AAAA,IACf;AAAA,IACA,UAAU;AAAA,MACR,CAAC,UAAU,GAAG;AAAA,IAChB;AAAA,IACA,QAAQ,CAAC;AAAA,IACT,MAAM;AAAA,EACR;AACF;AASA,SAAS,aAAa,OAAoB,MAAqC;AAC7E,MAAI,eAAmC;AAEvC,SAAO,cAAc;AACnB,UAAM,WAAW,aAAa,UAAU,KAAK,CAAC,cAAc,UAAU,SAAS,IAAI;AACnF,QAAI,UAAU;AACZ,aAAO;AAAA,IACT;AACA,mBAAe,aAAa;AAAA,EAC9B;AAEA,SAAO;AACT;AAQA,SAAS,oBAAoB,MAAwC;AACnE,QAAM,SAAS,KAAK;AAGpB,SAAO,OAAO,SAAS,sBAAsB,OAAO,SAAS,SAAS,gBAAgB,OAAO,SAAS,SAAS;AACjH;AAQA,SAAS,oBAAoB,MAA6C;AAExE,SAAO,KAAK,OAAO,SAAS,eAAe,KAAK,OAAO,OAAO;AAChE;AAcA,SAAS,iBAAiB,UAAyB,MAAiB,SAA0C;AAE5G,MAAI,SAAS,SAAS,iBAAiB;AACrC,WAAO,oBAAoB,QAAQ;AAAA,EACrC;AAGA,MAAI,SAAS,SAAS,cAAc;AAClC,WAAO;AAAA,EACT;AAEA,QAAM,WAAW,aAAa,QAAQ,WAAW,SAAS,IAAI,GAAG,SAAS,IAAI;AAC9E,MAAI,CAAC,UAAU;AACb,WAAO;AAAA,EACT;AAEA,aAAW,cAAc,SAAS,MAAM;AACtC,UAAM,iBAAiB,eAAe,WAAW,IAAI;AAErD,QAAI,eAAe,SAAS,wBAAwB,CAAC,eAAe,MAAM;AACxE;AAAA,IACF;AAGA,QAAI,eAAe,KAAK,SAAS,iBAAiB;AAChD,aAAO,oBAAoB,eAAe,IAAI;AAAA,IAChD;AAAA,EACF;AAEA,SAAO;AACT;",
  "names": []
}


package/dist/lib/esm/linters/eslint-rules/obsidian-dev-utils-plugin.d.mts

@@ -0,0 +1,13 @@
+/// <reference path="../../index.d.mts" />
+/**
+ * @file
+ *
+ * ESLint plugin for Obsidian development utilities.
+ */
+import type { ESLint } from 'eslint';
+/**
+ * ESLint plugin bundling every `obsidian-dev-utils` custom rule, registered under the `obsidian-dev-utils` namespace:
+ * the generic rules of `@mnaoumov/typescript-dev-toolkit` and the Obsidian ones. It is ONE plugin carrying both,
+ * because ESLint refuses two different plugins under one namespace.
+ */
+export declare const obsidianDevUtilsPlugin: ESLint.Plugin;

package/dist/lib/esm/linters/eslint-rules/obsidian-dev-utils-plugin.mjs

@@ -0,0 +1,73 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { genericInHouseEslintRules } from "@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/in-house-plugin";
+import { manifestDescription } from "./manifest-description.mjs";
+import { manifestId } from "./manifest-id.mjs";
+import { manifestName } from "./manifest-name.mjs";
+import { manifestSchema } from "./manifest-schema.mjs";
+import { noOverCapWaitInEvalInObsidian } from "./no-over-cap-wait-in-eval-in-obsidian.mjs";
+import { noUntrustedInputEvents } from "./no-untrusted-input-events.mjs";
+import { requireComponentSuffix } from "./require-component-suffix.mjs";
+const obsidianDevUtilsPlugin = {
+  rules: {
+    ...genericInHouseEslintRules,
+    "manifest-description": manifestDescription,
+    "manifest-id": manifestId,
+    "manifest-name": manifestName,
+    "manifest-schema": manifestSchema,
+    "no-over-cap-wait-in-eval-in-obsidian": noOverCapWaitInEvalInObsidian,
+    "no-untrusted-input-events": noUntrustedInputEvents,
+    "require-component-suffix": requireComponentSuffix
+  }
+};
+export {
+  obsidianDevUtilsPlugin
+};
+//# sourceMappingURL=data:application/json;base64,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

package/dist/lib/esm/linters/eslint-rules/require-component-suffix.d.mts

@@ -0,0 +1,18 @@
+/// <reference path="../../index.d.mts" />
+import type { Rule } from 'eslint';
+/**
+Message ID reported when a class extends `Component` but its name does not end with `Component`.
+ */
+export declare const MESSAGE_ID_MISSING_SUFFIX = "requireComponentSuffix";
+/**
+Message ID reported when an abstract class extends `Component` but its name does not end with `ComponentBase`.
+ */
+export declare const MESSAGE_ID_ABSTRACT_NEEDS_BASE = "abstractNeedsComponentBase";
+/**
+Message ID reported when a class name ends with `ComponentBase` but the class is not abstract.
+ */
+export declare const MESSAGE_ID_BASE_NOT_ABSTRACT = "componentBaseNotAbstract";
+/**
+ * ESLint rule requiring classes that extend `Component` to be named with a `Component` suffix, and abstract ones with a `ComponentBase` suffix.
+ */
+export declare const requireComponentSuffix: Rule.RuleModule;

package/dist/lib/esm/linters/eslint-rules/require-component-suffix.mjs

@@ -0,0 +1,175 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { toTSESTreeNode } from "@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node";
+const MESSAGE_ID_MISSING_SUFFIX = "requireComponentSuffix";
+const MESSAGE_ID_ABSTRACT_NEEDS_BASE = "abstractNeedsComponentBase";
+const MESSAGE_ID_BASE_NOT_ABSTRACT = "componentBaseNotAbstract";
+const EXCLUDED_ANCESTORS = /* @__PURE__ */ new Set(["HoverPopover", "MarkdownRenderChild", "Menu", "Plugin", "QueryController", "View"]);
+const REQUIRED_ANCESTOR = "Component";
+const requireComponentSuffix = {
+  create(context) {
+    const services = context.sourceCode.parserServices;
+    const checker = services.program.getTypeChecker();
+    return {
+      "ClassDeclaration[id]"(node) {
+        reportClass({
+          checker,
+          context,
+          node,
+          services
+        });
+      },
+      "ClassExpression[id]"(node) {
+        reportClass({
+          checker,
+          context,
+          node,
+          services
+        });
+      }
+    };
+  },
+  meta: {
+    docs: {
+      description: "Require classes extending `Component` to have names ending with `Component`"
+    },
+    messages: {
+      [MESSAGE_ID_ABSTRACT_NEEDS_BASE]: "Abstract class `{{ className }}` extends `Component` but its name does not end with `ComponentBase`.",
+      [MESSAGE_ID_BASE_NOT_ABSTRACT]: "Class `{{ className }}` ends with `ComponentBase` but is not abstract. Only abstract classes may use the `ComponentBase` suffix.",
+      [MESSAGE_ID_MISSING_SUFFIX]: "Class `{{ className }}` extends `Component` but its name does not end with `Component`."
+    },
+    schema: [],
+    type: "problem"
+  }
+};
+function collectAncestorNames(type) {
+  const names = /* @__PURE__ */ new Set();
+  const visited = /* @__PURE__ */ new Set();
+  walkAncestors({
+    collectedNames: names,
+    currentType: type,
+    visitedTypes: visited
+  });
+  return names;
+  function walkAncestors(params) {
+    const { collectedNames, currentType, visitedTypes } = params;
+    if (visitedTypes.has(currentType)) {
+      return;
+    }
+    visitedTypes.add(currentType);
+    const baseTypes = currentType.getBaseTypes?.();
+    if (!baseTypes) {
+      return;
+    }
+    for (const baseType of baseTypes) {
+      const $symbol = baseType.getSymbol();
+      if ($symbol) {
+        collectedNames.add($symbol.getName());
+      }
+      walkAncestors({
+        collectedNames,
+        currentType: baseType,
+        visitedTypes
+      });
+    }
+  }
+}
+function reportClass(params) {
+  const { checker, context, node, services } = params;
+  const classNode = toTSESTreeNode(node);
+  const classId = classNode.id;
+  if (!classId) {
+    return;
+  }
+  const className = classId.name;
+  const { abstract: isAbstract } = classNode;
+  const hasComponentBaseSuffix = className.endsWith("ComponentBase");
+  const hasComponentSuffix = !hasComponentBaseSuffix && className.endsWith("Component");
+  if (hasComponentSuffix && !isAbstract || hasComponentBaseSuffix && isAbstract) {
+    return;
+  }
+  const tsNode = services.esTreeNodeToTSNodeMap.get(classNode);
+  const classType = checker.getTypeAtLocation(tsNode);
+  const ancestors = collectAncestorNames(classType);
+  if (!ancestors.has(REQUIRED_ANCESTOR)) {
+    return;
+  }
+  for (const excluded of EXCLUDED_ANCESTORS) {
+    if (ancestors.has(excluded)) {
+      return;
+    }
+  }
+  if (hasComponentBaseSuffix && !isAbstract) {
+    context.report({
+      data: { className },
+      messageId: MESSAGE_ID_BASE_NOT_ABSTRACT,
+      node
+    });
+  } else if (isAbstract) {
+    context.report({
+      data: { className },
+      messageId: MESSAGE_ID_ABSTRACT_NEEDS_BASE,
+      node
+    });
+  } else {
+    context.report({
+      data: { className },
+      messageId: MESSAGE_ID_MISSING_SUFFIX,
+      node
+    });
+  }
+}
+export {
+  MESSAGE_ID_ABSTRACT_NEEDS_BASE,
+  MESSAGE_ID_BASE_NOT_ABSTRACT,
+  MESSAGE_ID_MISSING_SUFFIX,
+  requireComponentSuffix
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../../src/linters/eslint-rules/require-component-suffix.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * ESLint rule: require-component-suffix\n *\n * Reports an error when a class that extends `Component` (from Obsidian,\n * directly or transitively) does not have a name ending with `Component`\n * (or `ComponentBase` for abstract base classes).\n *\n * Classes whose inheritance chain includes any of the Obsidian framework\n * classes that extend `Component` (e.g. `Plugin`, `View`,\n * `MarkdownRenderChild`, `Menu`, `HoverPopover`, `QueryController`)\n * are excluded because they follow Obsidian's own naming conventions.\n *\n * The rule uses the TypeScript type checker to walk the full inheritance\n * chain, so it works regardless of how many intermediate classes sit\n * between the user's class and `Component`.\n */\nimport type {\n  ParserServicesWithTypeInformation,\n  TSESTree\n} from '@typescript-eslint/utils';\nimport type { Rule } from 'eslint';\nimport type { Type } from 'typescript';\n\nimport { toTSESTreeNode } from '@mnaoumov/typescript-dev-toolkit/linters/eslint-rules/ts-estree-node';\n\n/**\nMessage ID reported when a class extends `Component` but its name does not end with `Component`.\n */\nexport const MESSAGE_ID_MISSING_SUFFIX = 'requireComponentSuffix';\n\n/**\nMessage ID reported when an abstract class extends `Component` but its name does not end with `ComponentBase`.\n */\nexport const MESSAGE_ID_ABSTRACT_NEEDS_BASE = 'abstractNeedsComponentBase';\n\n/**\nMessage ID reported when a class name ends with `ComponentBase` but the class is not abstract.\n */\nexport const MESSAGE_ID_BASE_NOT_ABSTRACT = 'componentBaseNotAbstract';\n\n/**\nAncestor class names that opt a subtree out of the suffix requirement.\n */\nconst EXCLUDED_ANCESTORS = new Set(['HoverPopover', 'MarkdownRenderChild', 'Menu', 'Plugin', 'QueryController', 'View']);\n\n/**\nThe ancestor class name that triggers the suffix requirement.\n */\nconst REQUIRED_ANCESTOR = 'Component';\n\ninterface TypeWithBaseTypes {\n  getBaseTypes?: () => Type[] | undefined;\n}\n\n/**\n * ESLint rule requiring classes that extend `Component` to be named with a `Component` suffix, and abstract ones with a `ComponentBase` suffix.\n */\nexport const requireComponentSuffix: Rule.RuleModule = {\n  create(context) {\n    const services = context.sourceCode.parserServices as ParserServicesWithTypeInformation;\n    const checker = services.program.getTypeChecker();\n\n    return {\n      'ClassDeclaration[id]'(node: Rule.Node): void {\n        reportClass({\n          checker,\n          context,\n          node,\n          services\n        });\n      },\n      'ClassExpression[id]'(node: Rule.Node): void {\n        reportClass({\n          checker,\n          context,\n          node,\n          services\n        });\n      }\n    };\n  },\n  meta: {\n    docs: {\n      description: 'Require classes extending `Component` to have names ending with `Component`'\n    },\n    messages: {\n      [MESSAGE_ID_ABSTRACT_NEEDS_BASE]: 'Abstract class `{{ className }}` extends `Component` but its name does not end with `ComponentBase`.',\n      [MESSAGE_ID_BASE_NOT_ABSTRACT]: 'Class `{{ className }}` ends with `ComponentBase` but is not abstract. Only abstract classes may use the `ComponentBase` suffix.',\n      [MESSAGE_ID_MISSING_SUFFIX]: 'Class `{{ className }}` extends `Component` but its name does not end with `Component`.'\n    },\n    schema: [],\n    type: 'problem'\n  }\n};\n\n/**\n * Parameters for {@link reportClass}.\n */\ninterface ReportClassParams {\n  /**\n   * The TypeScript type checker.\n   */\n  readonly checker: ReturnType<ParserServicesWithTypeInformation['program']['getTypeChecker']>;\n\n  /**\n   * The ESLint rule context.\n   */\n  readonly context: Rule.RuleContext;\n\n  /**\n   * The class AST node.\n   */\n  readonly node: Rule.Node;\n\n  /**\n   * The parser services with type information.\n   */\n  readonly services: ParserServicesWithTypeInformation;\n}\n\n/**\n * Parameters for {@link walkAncestors}.\n */\ninterface WalkAncestorsParams {\n  /**\n   * The set to add discovered ancestor names to.\n   */\n  readonly collectedNames: Set<string>;\n\n  /**\n   * The current type to inspect.\n   */\n  readonly currentType: Type;\n\n  /**\n   * Types already visited, to prevent infinite loops.\n   */\n  readonly visitedTypes: Set<Type>;\n}\n\n/**\n * Collects the names of all ancestor types in the inheritance chain.\n *\n * @param type - The TypeScript type to start from.\n * @returns A set of ancestor class names.\n */\nfunction collectAncestorNames(type: Type): Set<string> {\n  const names = new Set<string>();\n  const visited = new Set<Type>();\n\n  walkAncestors({\n    collectedNames: names,\n    currentType: type,\n    visitedTypes: visited\n  });\n\n  return names;\n\n  /**\n   * Recursively walks the base types of a type, collecting their names.\n   *\n   * @param params - The parameters for the walk.\n   */\n  function walkAncestors(params: WalkAncestorsParams): void {\n    const { collectedNames, currentType, visitedTypes } = params;\n    if (visitedTypes.has(currentType)) {\n      return;\n    }\n\n    visitedTypes.add(currentType);\n\n    const baseTypes = (currentType as TypeWithBaseTypes).getBaseTypes?.();\n\n    if (!baseTypes) {\n      return;\n    }\n\n    for (const baseType of baseTypes) {\n      const $symbol = baseType.getSymbol();\n\n      if ($symbol) {\n        collectedNames.add($symbol.getName());\n      }\n\n      walkAncestors({\n        collectedNames,\n        currentType: baseType,\n        visitedTypes\n      });\n    }\n  }\n}\n\n/**\n * Checks a single class declaration or expression.\n *\n * @param params - The parameters for the check.\n */\nfunction reportClass(params: ReportClassParams): void {\n  const { checker, context, node, services } = params;\n  const classNode = toTSESTreeNode(node) as TSESTree.ClassDeclaration | TSESTree.ClassExpression;\n  const classId = classNode.id;\n\n  /* v8 ignore start -- ESLint selector `[id]` guarantees classId is present. */\n  if (!classId) {\n    return;\n  }\n  /* v8 ignore stop */\n\n  const className = classId.name;\n  const { abstract: isAbstract } = classNode;\n  const hasComponentBaseSuffix = className.endsWith('ComponentBase');\n  const hasComponentSuffix = !hasComponentBaseSuffix && className.endsWith('Component');\n\n  // Correct: non-abstract ending with Component, or abstract ending with ComponentBase\n  if ((hasComponentSuffix && !isAbstract) || (hasComponentBaseSuffix && isAbstract)) {\n    return;\n  }\n\n  const tsNode = services.esTreeNodeToTSNodeMap.get(classNode);\n  const classType = checker.getTypeAtLocation(tsNode);\n  const ancestors = collectAncestorNames(classType);\n\n  if (!ancestors.has(REQUIRED_ANCESTOR)) {\n    return;\n  }\n\n  for (const excluded of EXCLUDED_ANCESTORS) {\n    if (ancestors.has(excluded)) {\n      return;\n    }\n  }\n\n  if (hasComponentBaseSuffix && !isAbstract) {\n    context.report({\n      data: { className },\n      messageId: MESSAGE_ID_BASE_NOT_ABSTRACT,\n      node\n    });\n  } else if (isAbstract) {\n    context.report({\n      data: { className },\n      messageId: MESSAGE_ID_ABSTRACT_NEEDS_BASE,\n      node\n    });\n  } else {\n    context.report({\n      data: { className },\n      messageId: MESSAGE_ID_MISSING_SUFFIX,\n      node\n    });\n  }\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyBA,SAAS,sBAAsB;AAKxB,MAAM,4BAA4B;AAKlC,MAAM,iCAAiC;AAKvC,MAAM,+BAA+B;AAK5C,MAAM,qBAAqB,oBAAI,IAAI,CAAC,gBAAgB,uBAAuB,QAAQ,UAAU,mBAAmB,MAAM,CAAC;AAKvH,MAAM,oBAAoB;AASnB,MAAM,yBAA0C;AAAA,EACrD,OAAO,SAAS;AACd,UAAM,WAAW,QAAQ,WAAW;AACpC,UAAM,UAAU,SAAS,QAAQ,eAAe;AAEhD,WAAO;AAAA,MACL,uBAAuB,MAAuB;AAC5C,oBAAY;AAAA,UACV;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AAAA,MACH;AAAA,MACA,sBAAsB,MAAuB;AAC3C,oBAAY;AAAA,UACV;AAAA,UACA;AAAA,UACA;AAAA,UACA;AAAA,QACF,CAAC;AAAA,MACH;AAAA,IACF;AAAA,EACF;AAAA,EACA,MAAM;AAAA,IACJ,MAAM;AAAA,MACJ,aAAa;AAAA,IACf;AAAA,IACA,UAAU;AAAA,MACR,CAAC,8BAA8B,GAAG;AAAA,MAClC,CAAC,4BAA4B,GAAG;AAAA,MAChC,CAAC,yBAAyB,GAAG;AAAA,IAC/B;AAAA,IACA,QAAQ,CAAC;AAAA,IACT,MAAM;AAAA,EACR;AACF;AAqDA,SAAS,qBAAqB,MAAyB;AACrD,QAAM,QAAQ,oBAAI,IAAY;AAC9B,QAAM,UAAU,oBAAI,IAAU;AAE9B,gBAAc;AAAA,IACZ,gBAAgB;AAAA,IAChB,aAAa;AAAA,IACb,cAAc;AAAA,EAChB,CAAC;AAED,SAAO;AAOP,WAAS,cAAc,QAAmC;AACxD,UAAM,EAAE,gBAAgB,aAAa,aAAa,IAAI;AACtD,QAAI,aAAa,IAAI,WAAW,GAAG;AACjC;AAAA,IACF;AAEA,iBAAa,IAAI,WAAW;AAE5B,UAAM,YAAa,YAAkC,eAAe;AAEpE,QAAI,CAAC,WAAW;AACd;AAAA,IACF;AAEA,eAAW,YAAY,WAAW;AAChC,YAAM,UAAU,SAAS,UAAU;AAEnC,UAAI,SAAS;AACX,uBAAe,IAAI,QAAQ,QAAQ,CAAC;AAAA,MACtC;AAEA,oBAAc;AAAA,QACZ;AAAA,QACA,aAAa;AAAA,QACb;AAAA,MACF,CAAC;AAAA,IACH;AAAA,EACF;AACF;AAOA,SAAS,YAAY,QAAiC;AACpD,QAAM,EAAE,SAAS,SAAS,MAAM,SAAS,IAAI;AAC7C,QAAM,YAAY,eAAe,IAAI;AACrC,QAAM,UAAU,UAAU;AAG1B,MAAI,CAAC,SAAS;AACZ;AAAA,EACF;AAGA,QAAM,YAAY,QAAQ;AAC1B,QAAM,EAAE,UAAU,WAAW,IAAI;AACjC,QAAM,yBAAyB,UAAU,SAAS,eAAe;AACjE,QAAM,qBAAqB,CAAC,0BAA0B,UAAU,SAAS,WAAW;AAGpF,MAAK,sBAAsB,CAAC,cAAgB,0BAA0B,YAAa;AACjF;AAAA,EACF;AAEA,QAAM,SAAS,SAAS,sBAAsB,IAAI,SAAS;AAC3D,QAAM,YAAY,QAAQ,kBAAkB,MAAM;AAClD,QAAM,YAAY,qBAAqB,SAAS;AAEhD,MAAI,CAAC,UAAU,IAAI,iBAAiB,GAAG;AACrC;AAAA,EACF;AAEA,aAAW,YAAY,oBAAoB;AACzC,QAAI,UAAU,IAAI,QAAQ,GAAG;AAC3B;AAAA,IACF;AAAA,EACF;AAEA,MAAI,0BAA0B,CAAC,YAAY;AACzC,YAAQ,OAAO;AAAA,MACb,MAAM,EAAE,UAAU;AAAA,MAClB,WAAW;AAAA,MACX;AAAA,IACF,CAAC;AAAA,EACH,WAAW,YAAY;AACrB,YAAQ,OAAO;AAAA,MACb,MAAM,EAAE,UAAU;AAAA,MAClB,WAAW;AAAA,MACX;AAAA,IACF,CAAC;AAAA,EACH,OAAO;AACL,YAAQ,OAAO;AAAA,MACb,MAAM,EAAE,UAAU;AAAA,MAClB,WAAW;AAAA,MACX;AAAA,IACF,CAAC;AAAA,EACH;AACF;",
  "names": []
}


package/dist/lib/esm/linters/eslint.d.mts

@@ -0,0 +1,15 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * Lints an Obsidian plugin with ESLint: the generic runner from `@mnaoumov/typescript-dev-toolkit`, which copies
+ * this package's `eslint.config.mts` template into a project that has no configuration yet.
+ */
+import type { LintOptions } from '@mnaoumov/typescript-dev-toolkit/linters/eslint';
+/**
+ * Lints the project with ESLint.
+ *
+ * @param options - The {@link LintOptions}.
+ */
+export declare function lint(options?: LintOptions): Promise<void>;
+export { type LintOptions } from '@mnaoumov/typescript-dev-toolkit/linters/eslint';

package/dist/lib/esm/linters/eslint.mjs

@@ -0,0 +1,60 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import { lint as lintGeneric } from "@mnaoumov/typescript-dev-toolkit/linters/eslint";
+import { RepoPaths } from "@mnaoumov/typescript-dev-toolkit/repo-paths";
+import { getTemplateFilePath } from "../templates.mjs";
+import {} from "@mnaoumov/typescript-dev-toolkit/linters/eslint";
+async function lint(options) {
+  await lintGeneric({ defaultConfigFilePath: getTemplateFilePath(RepoPaths.EslintConfigMts), ...options });
+}
+export {
+  lint
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2xpbnRlcnMvZXNsaW50LnRzIl0sCiAgInNvdXJjZXNDb250ZW50IjogWyIvKipcbiAqIEBmaWxlXG4gKlxuICogTGludHMgYW4gT2JzaWRpYW4gcGx1Z2luIHdpdGggRVNMaW50OiB0aGUgZ2VuZXJpYyBydW5uZXIgZnJvbSBgQG1uYW91bW92L3R5cGVzY3JpcHQtZGV2LXRvb2xraXRgLCB3aGljaCBjb3BpZXNcbiAqIHRoaXMgcGFja2FnZSdzIGBlc2xpbnQuY29uZmlnLm10c2AgdGVtcGxhdGUgaW50byBhIHByb2plY3QgdGhhdCBoYXMgbm8gY29uZmlndXJhdGlvbiB5ZXQuXG4gKi9cblxuaW1wb3J0IHR5cGUgeyBMaW50T3B0aW9ucyB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWRldi10b29sa2l0L2xpbnRlcnMvZXNsaW50JztcblxuaW1wb3J0IHsgbGludCBhcyBsaW50R2VuZXJpYyB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWRldi10b29sa2l0L2xpbnRlcnMvZXNsaW50JztcbmltcG9ydCB7IFJlcG9QYXRocyB9IGZyb20gJ0BtbmFvdW1vdi90eXBlc2NyaXB0LWRldi10b29sa2l0L3JlcG8tcGF0aHMnO1xuXG5pbXBvcnQgeyBnZXRUZW1wbGF0ZUZpbGVQYXRoIH0gZnJvbSAnLi4vdGVtcGxhdGVzLnRzJztcblxuLyoqXG4gKiBMaW50cyB0aGUgcHJvamVjdCB3aXRoIEVTTGludC5cbiAqXG4gKiBAcGFyYW0gb3B0aW9ucyAtIFRoZSB7QGxpbmsgTGludE9wdGlvbnN9LlxuICovXG5leHBvcnQgYXN5bmMgZnVuY3Rpb24gbGludChvcHRpb25zPzogTGludE9wdGlvbnMpOiBQcm9taXNlPHZvaWQ+IHtcbiAgYXdhaXQgbGludEdlbmVyaWMoeyBkZWZhdWx0Q29uZmlnRmlsZVBhdGg6IGdldFRlbXBsYXRlRmlsZVBhdGgoUmVwb1BhdGhzLkVzbGludENvbmZpZ010cyksIC4uLm9wdGlvbnMgfSk7XG59XG5leHBvcnQgeyB0eXBlIExpbnRPcHRpb25zIH0gZnJvbSAnQG1uYW91bW92L3R5cGVzY3JpcHQtZGV2LXRvb2xraXQvbGludGVycy9lc2xpbnQnO1xuIl0sCiAgIm1hcHBpbmdzIjogIjs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7OztBQVNBLFNBQVMsUUFBUSxtQkFBbUI7QUFDcEMsU0FBUyxpQkFBaUI7QUFFMUIsU0FBUywyQkFBMkI7QUFVcEMsZUFBaUM7QUFIakMsZUFBc0IsS0FBSyxTQUFzQztBQUMvRCxRQUFNLFlBQVksRUFBRSx1QkFBdUIsb0JBQW9CLFVBQVUsZUFBZSxHQUFHLEdBQUcsUUFBUSxDQUFDO0FBQ3pHOyIsCiAgIm5hbWVzIjogW10KfQo=

package/dist/lib/esm/linters/index.d.mts

@@ -0,0 +1,6 @@
+/// <reference path="../index.d.mts" />
+export * as 'eslint-config' from './eslint-config.mjs';
+export * as 'eslint-rules' from './eslint-rules/index.mjs';
+export * as 'eslint' from './eslint.mjs';
+export * as 'markdownlint' from './markdownlint.mjs';
+export * as 'obsidianmd-rule-custom-message' from './obsidianmd-rule-custom-message.mjs';

package/dist/lib/esm/linters/index.mjs

@@ -0,0 +1,62 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function () {
+function ensureDisposeSymbols(symbolConstructor = Symbol) {
+  symbolConstructor.asyncDispose ??= symbolConstructor.for('Symbol.asyncDispose');
+  symbolConstructor.dispose ??= symbolConstructor.for('Symbol.dispose');
+}
+
+function ensureBrowserProcess() {
+  const browserProcess = {
+    browser: true,
+    cwd() {
+      return '/';
+    },
+    env: {},
+    platform: 'android'
+  };
+
+  // eslint-disable-next-line obsidianmd/no-global-this, unicorn/no-unnecessary-global-this -- Must stay `globalThis`-qualified: in the emitted banner a bare `process` is a free identifier, so reading it where the host has none throws a ReferenceError instead of yielding `undefined`. That is the very case this function exists to handle.
+  const existingProcess = globalThis.process;
+
+  if (!existingProcess) {
+    // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+    globalThis.process = browserProcess;
+    return;
+  }
+
+  if (existingProcess.versions?.node) {
+    return;
+  }
+
+  const existingProcessRecord = existingProcess;
+
+  for (const [key, value] of Object.entries(browserProcess)) {
+    existingProcessRecord[key] ??= value;
+  }
+
+  existingProcessRecord['browser'] = true;
+}
+
+(function initEsm() {
+  ensureDisposeSymbols();
+  ensureBrowserProcess();
+})();
+})();
+
+import * as eslint_config from "./eslint-config.mjs";
+import * as eslint_rules from "./eslint-rules/index.mjs";
+import * as eslint from "./eslint.mjs";
+import * as markdownlint from "./markdownlint.mjs";
+import * as obsidianmd_rule_custom_message from "./obsidianmd-rule-custom-message.mjs";
+export {
+  eslint,
+  eslint_config as "eslint-config",
+  eslint_rules as "eslint-rules",
+  markdownlint,
+  obsidianmd_rule_custom_message as "obsidianmd-rule-custom-message"
+};
+//# sourceMappingURL=data:application/json;base64,ewogICJ2ZXJzaW9uIjogMywKICAic291cmNlcyI6IFsiLi4vLi4vLi4vLi4vc3JjL2xpbnRlcnMvaW5kZXgudHMiXSwKICAic291cmNlc0NvbnRlbnQiOiBbIi8qIFRISVMgSVMgQSBHRU5FUkFURUQvQlVORExFRCBGSUxFIEJZIEJVSUxEIFNDUklQVCAqL1xuXG5leHBvcnQgKiBhcyAnZXNsaW50LWNvbmZpZycgZnJvbSAnLi9lc2xpbnQtY29uZmlnLnRzJztcbmV4cG9ydCAqIGFzICdlc2xpbnQtcnVsZXMnIGZyb20gJy4vZXNsaW50LXJ1bGVzL2luZGV4LnRzJztcbmV4cG9ydCAqIGFzICdlc2xpbnQnIGZyb20gJy4vZXNsaW50LnRzJztcbmV4cG9ydCAqIGFzICdtYXJrZG93bmxpbnQnIGZyb20gJy4vbWFya2Rvd25saW50LnRzJztcbmV4cG9ydCAqIGFzICdvYnNpZGlhbm1kLXJ1bGUtY3VzdG9tLW1lc3NhZ2UnIGZyb20gJy4vb2JzaWRpYW5tZC1ydWxlLWN1c3RvbS1tZXNzYWdlLnRzJztcbiJdLAogICJtYXBwaW5ncyI6ICI7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7Ozs7QUFFQSxZQUFZQSxtQkFBcUI7QUFDakMsWUFBWUMsa0JBQW9CO0FBQ2hDLFlBQVksWUFBYztBQUMxQixZQUFZLGtCQUFvQjtBQUNoQyxZQUFZQyxvQ0FBc0M7IiwKICAibmFtZXMiOiBbImVzbGludC1jb25maWciLCAiZXNsaW50LXJ1bGVzIiwgIm9ic2lkaWFubWQtcnVsZS1jdXN0b20tbWVzc2FnZSJdCn0K

package/dist/lib/esm/linters/markdownlint.d.mts

@@ -0,0 +1,15 @@
+/// <reference path="../index.d.mts" />
+/**
+ * @file
+ *
+ * Lints an Obsidian plugin's markdown: the generic runner from `@mnaoumov/typescript-dev-toolkit`, which copies
+ * this package's `.markdownlint-cli2.mjs` template into a project that has no configuration yet.
+ */
+import type { LintOptions } from '@mnaoumov/typescript-dev-toolkit/linters/markdownlint';
+/**
+ * Lints the project's markdown with `markdownlint-cli2` and `linkinator`.
+ *
+ * @param options - The {@link LintOptions}.
+ */
+export declare function lint(options?: LintOptions): Promise<void>;
+export { type LintOptions } from '@mnaoumov/typescript-dev-toolkit/linters/markdownlint';