obsidian-dev-utils 87.0.2 → 87.0.3

package/dist/lib/cjs/reg-exp.cjs

@@ -129,6 +129,8 @@ __export(reg_exp_exports, {
   NEVER_MATCH_REG_EXP: () => NEVER_MATCH_REG_EXP,
   RegExpMergeFlagsConflictStrategy: () => RegExpMergeFlagsConflictStrategy,
   escapeRegExp: () => escapeRegExp,
+  getMandatoryNamedGroup: () => getMandatoryNamedGroup,
+  getOptionalNamedGroup: () => getOptionalNamedGroup,
   isValidRegExp: () => isValidRegExp,
   oneOf: () => oneOf
 });
@@ -143,6 +145,12 @@ var RegExpMergeFlagsConflictStrategy = /* @__PURE__ */ ((RegExpMergeFlagsConflic
 function escapeRegExp(str) {
   return str.replaceAll(/[.*+?^${}()|[\]\\]/g, "\\$&");
 }
+function getMandatoryNamedGroup(match, groupName) {
+  return (0, import_type_guards.ensureNonNullable)(getOptionalNamedGroup(match, groupName));
+}
+function getOptionalNamedGroup(match, groupName) {
+  return match.groups?.[groupName] ?? null;
+}
 function isValidRegExp(str) {
   try {
     new RegExp(str);
@@ -275,7 +283,9 @@ function oneOf(regExps, strategy = "Throw" /* Throw */) {
   NEVER_MATCH_REG_EXP,
   RegExpMergeFlagsConflictStrategy,
   escapeRegExp,
+  getMandatoryNamedGroup,
+  getOptionalNamedGroup,
   isValidRegExp,
   oneOf
 });
-//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/reg-exp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for regular expressions.\n */\n\nimport {\n  assert,\n  assertNever\n} from './type-guards.ts';\n\n/**\n * A strategy to use when merging multiple regex flags into one alternation.\n */\nexport enum RegExpMergeFlagsConflictStrategy {\n  /**\n   * Keep only the flags present in all regexes.\n   */\n  Intersect = 'Intersect',\n  /**\n   * Throw an error if the regexes have conflicting flags.\n   */\n  Throw = 'Throw',\n  /**\n   * Keep only the flags present in any regex.\n   */\n  Union = 'Union'\n}\n\n/**\n * Escapes special characters in a string to safely use it within a regular expression.\n *\n * @param str - The string to escape.\n * @returns The escaped string with special characters prefixed with a backslash.\n */\nexport function escapeRegExp(str: string): string {\n  // NOTE: We can't use `replaceAll()` from `String.ts` here because it introduces a circular dependency.\n  return str.replaceAll(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\n/**\n * Checks if a string is a valid regular expression.\n *\n * @param str - The string to check.\n * @returns `true` if the string is a valid regular expression, `false` otherwise.\n */\nexport function isValidRegExp(str: string): boolean {\n  try {\n    new RegExp(str);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction hasFlag(regExp: RegExp, flag: string): boolean {\n  return regExp.flags.includes(flag);\n}\n\n/**\n * A regular expression that always matches.\n */\nexport const ALWAYS_MATCH_REG_EXP = /(?:)/;\n\n/**\n * A regular expression that never matches.\n */\nexport const NEVER_MATCH_REG_EXP = /.^/;\n\n/**\n * Merges the flags of multiple regexes into a single flag string, applying a conflict strategy.\n *\n * The cooperating per-flag helpers share the same regexes, strategy, and accumulated flag set, so\n * they are grouped here as methods over those fields rather than threading the state through\n * positional arguments.\n */\nclass RegExpFlagMerger {\n  private readonly finalFlags = new Set<string>();\n\n  /**\n   * Creates a new merger.\n   *\n   * @param regExps - The regexes whose flags are merged.\n   * @param strategy - The strategy to use when flags conflict.\n   */\n  public constructor(private readonly regExps: RegExp[], private readonly strategy: RegExpMergeFlagsConflictStrategy) {}\n\n  /**\n   * Computes the merged flag string for the configured regexes.\n   *\n   * @returns The merged flags joined into a single string.\n   */\n  public computeFlags(): string {\n    this.addSemanticFlags();\n    this.addUnicodeFlags();\n    this.addMetaFlags();\n    return [...this.finalFlags].join('');\n  }\n\n  private addMetaFlags(): void {\n    const META_FLAGS = ['g', 'd'];\n    for (const flag of META_FLAGS) {\n      if (this.regExps.some((regExp) => hasFlag(regExp, flag))) {\n        this.finalFlags.add(flag);\n      }\n    }\n  }\n\n  private addSemanticFlags(): void {\n    const SEMANTIC_FLAGS = ['i', 'm', 's', 'y'];\n    for (const flag of SEMANTIC_FLAGS) {\n      if (this.shouldPickFlag(flag)) {\n        this.finalFlags.add(flag);\n      }\n    }\n  }\n\n  private addUnicodeFlags(): void {\n    const countU = this.regExps.filter((regExp) => hasFlag(regExp, 'u')).length;\n    const countV = this.regExps.filter((regExp) => hasFlag(regExp, 'v')).length;\n\n    let shouldUseUFlag: boolean;\n    let shouldUseVFlag: boolean;\n\n    /* v8 ignore start -- v8 counts the implicit default branch as uncovered even when all enum cases are handled. */\n    switch (this.strategy) {\n      /* v8 ignore stop */\n      case RegExpMergeFlagsConflictStrategy.Intersect:\n        shouldUseUFlag = countU === this.regExps.length;\n        shouldUseVFlag = countV === this.regExps.length;\n        break;\n      case RegExpMergeFlagsConflictStrategy.Throw: {\n        const allU = countU === this.regExps.length;\n        const noneU = countU === 0;\n        const allV = countV === this.regExps.length;\n        const noneV = countV === 0;\n\n        if (!(allU || noneU) || !(allV || noneV)) {\n          throw new Error('Conflicting \\'u\\'/\\'v\\' flags across patterns.');\n        }\n\n        shouldUseUFlag = allU;\n        shouldUseVFlag = allV;\n        break;\n      }\n      case RegExpMergeFlagsConflictStrategy.Union:\n        shouldUseUFlag = countU > 0;\n        shouldUseVFlag = countV > 0;\n        break;\n      default:\n        /* v8 ignore start -- Exhaustive switch guard. */\n        assertNever(this.strategy);\n        /* v8 ignore stop */\n    }\n\n    if (shouldUseUFlag && shouldUseVFlag) {\n      assert(this.strategy !== RegExpMergeFlagsConflictStrategy.Throw, 'Cannot combine both \\'u\\'/\\'v\\' flags in one RegExp.');\n      shouldUseUFlag = false;\n    }\n\n    if (shouldUseUFlag) {\n      this.finalFlags.add('u');\n    }\n    if (shouldUseVFlag) {\n      this.finalFlags.add('v');\n    }\n  }\n\n  private shouldPickFlag(flag: string): boolean {\n    const count = this.regExps.filter((regExp) => hasFlag(regExp, flag)).length;\n    /* v8 ignore start -- v8 counts the implicit default branch as uncovered even when all enum cases are handled. */\n    switch (this.strategy) {\n      /* v8 ignore stop */\n      case RegExpMergeFlagsConflictStrategy.Intersect:\n        return count === this.regExps.length;\n      case RegExpMergeFlagsConflictStrategy.Throw:\n        break;\n      case RegExpMergeFlagsConflictStrategy.Union:\n        return count > 0;\n      default:\n        /* v8 ignore start -- Exhaustive switch guard. */\n        assertNever(this.strategy);\n        /* v8 ignore stop */\n    }\n\n    const allSame = count === 0 || count === this.regExps.length;\n    if (!allSame) {\n      throw new Error(`Conflicting flag '${flag}' across patterns.`);\n    }\n    return count === this.regExps.length;\n  }\n}\n\n/**\n * Combine multiple regexes into one alternation, handling flags.\n *\n * @param regExps - The regexes to combine.\n * @param strategy - The strategy to use when merging flags (default: `RegExpMergeFlagsConflictStrategy.Throw`).\n * @returns The combined regex.\n */\nexport function oneOf(\n  regExps: RegExp[],\n  strategy: RegExpMergeFlagsConflictStrategy = RegExpMergeFlagsConflictStrategy.Throw\n): RegExp {\n  if (regExps.length === 0) {\n    return ALWAYS_MATCH_REG_EXP;\n  }\n\n  if (regExps.length === 1 && regExps[0] !== undefined) {\n    return regExps[0];\n  }\n\n  const source = regExps.map((regExp) => `(?:${regExp.source})`).join('|');\n  const flags = new RegExpFlagMerger(regExps, strategy).computeFlags();\n  return new RegExp(source, flags);\n}\n"],
  "mappings": "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",
  "names": ["RegExpMergeFlagsConflictStrategy"]
}

+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/reg-exp.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for regular expressions.\n */\n\nimport {\n  assert,\n  assertNever,\n  ensureNonNullable\n} from './type-guards.ts';\n\n/**\n * A strategy to use when merging multiple regex flags into one alternation.\n */\nexport enum RegExpMergeFlagsConflictStrategy {\n  /**\n   * Keep only the flags present in all regexes.\n   */\n  Intersect = 'Intersect',\n  /**\n   * Throw an error if the regexes have conflicting flags.\n   */\n  Throw = 'Throw',\n  /**\n   * Keep only the flags present in any regex.\n   */\n  Union = 'Union'\n}\n\n/**\n * Escapes special characters in a string to safely use it within a regular expression.\n *\n * @param str - The string to escape.\n * @returns The escaped string with special characters prefixed with a backslash.\n */\nexport function escapeRegExp(str: string): string {\n  // NOTE: We can't use `replaceAll()` from `String.ts` here because it introduces a circular dependency.\n  return str.replaceAll(/[.*+?^${}()|[\\]\\\\]/g, '\\\\$&');\n}\n\n/**\n * Reads a mandatory named capture group from a regex match.\n *\n * Use this for a named group that is ALWAYS present when the pattern matches \u2014 not wrapped in an optional\n * `(?:\u2026)?` / `(\u2026)?`. Returns the captured string (which may be `''` for a zero-width match such as `\\w*`),\n * throwing if the group \u2014 or the match's `groups` object \u2014 is absent, so a pattern change that drops the\n * group fails loudly instead of silently yielding a wrong value.\n *\n * Prefer this over `match.groups?.[name] ?? ''`: for a mandatory group that fallback is a never-taken (dead)\n * branch that fails a 100%-branch coverage gate, whereas the throw here lives inside `ensureNonNullable`\n * (already covered), leaving no inline branch at the call site. For a group that may legitimately be absent,\n * use {@link getOptionalNamedGroup} and default its `null` with `?? \u2026`.\n *\n * @param match - The match returned by `RegExp.exec`, `String.matchAll`, or `String.match`.\n * @param groupName - The name of the capture group to read.\n * @returns The captured string.\n * @throws When the named group is absent.\n */\nexport function getMandatoryNamedGroup(match: RegExpMatchArray, groupName: string): string {\n  return ensureNonNullable(getOptionalNamedGroup(match, groupName));\n}\n\n/**\n * Reads an optional named capture group from a regex match, distinguishing an absent group from a present\n * empty one.\n *\n * Returns the captured string when the group participated in the match \u2014 which may be `''` for a zero-width\n * match such as `\\w*` \u2014 or `null` when the group, or the match's `groups` object, is absent (e.g. an optional\n * `(?:\u2026)?` group that did not match). Because `null` is returned only for a genuinely-absent group, a\n * caller's `?? <default>` is a live branch rather than the dead one that `match.groups?.[name] ?? ''` leaves\n * for a mandatory group. For a group that must always be present, use {@link getMandatoryNamedGroup}.\n *\n * @param match - The match returned by `RegExp.exec`, `String.matchAll`, or `String.match`.\n * @param groupName - The name of the capture group to read.\n * @returns The captured string, or `null` when the group is absent.\n */\nexport function getOptionalNamedGroup(match: RegExpMatchArray, groupName: string): null | string {\n  return match.groups?.[groupName] ?? null;\n}\n\n/**\n * Checks if a string is a valid regular expression.\n *\n * @param str - The string to check.\n * @returns `true` if the string is a valid regular expression, `false` otherwise.\n */\nexport function isValidRegExp(str: string): boolean {\n  try {\n    new RegExp(str);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nfunction hasFlag(regExp: RegExp, flag: string): boolean {\n  return regExp.flags.includes(flag);\n}\n\n/**\n * A regular expression that always matches.\n */\nexport const ALWAYS_MATCH_REG_EXP = /(?:)/;\n\n/**\n * A regular expression that never matches.\n */\nexport const NEVER_MATCH_REG_EXP = /.^/;\n\n/**\n * Merges the flags of multiple regexes into a single flag string, applying a conflict strategy.\n *\n * The cooperating per-flag helpers share the same regexes, strategy, and accumulated flag set, so\n * they are grouped here as methods over those fields rather than threading the state through\n * positional arguments.\n */\nclass RegExpFlagMerger {\n  private readonly finalFlags = new Set<string>();\n\n  /**\n   * Creates a new merger.\n   *\n   * @param regExps - The regexes whose flags are merged.\n   * @param strategy - The strategy to use when flags conflict.\n   */\n  public constructor(private readonly regExps: RegExp[], private readonly strategy: RegExpMergeFlagsConflictStrategy) {}\n\n  /**\n   * Computes the merged flag string for the configured regexes.\n   *\n   * @returns The merged flags joined into a single string.\n   */\n  public computeFlags(): string {\n    this.addSemanticFlags();\n    this.addUnicodeFlags();\n    this.addMetaFlags();\n    return [...this.finalFlags].join('');\n  }\n\n  private addMetaFlags(): void {\n    const META_FLAGS = ['g', 'd'];\n    for (const flag of META_FLAGS) {\n      if (this.regExps.some((regExp) => hasFlag(regExp, flag))) {\n        this.finalFlags.add(flag);\n      }\n    }\n  }\n\n  private addSemanticFlags(): void {\n    const SEMANTIC_FLAGS = ['i', 'm', 's', 'y'];\n    for (const flag of SEMANTIC_FLAGS) {\n      if (this.shouldPickFlag(flag)) {\n        this.finalFlags.add(flag);\n      }\n    }\n  }\n\n  private addUnicodeFlags(): void {\n    const countU = this.regExps.filter((regExp) => hasFlag(regExp, 'u')).length;\n    const countV = this.regExps.filter((regExp) => hasFlag(regExp, 'v')).length;\n\n    let shouldUseUFlag: boolean;\n    let shouldUseVFlag: boolean;\n\n    /* v8 ignore start -- v8 counts the implicit default branch as uncovered even when all enum cases are handled. */\n    switch (this.strategy) {\n      /* v8 ignore stop */\n      case RegExpMergeFlagsConflictStrategy.Intersect:\n        shouldUseUFlag = countU === this.regExps.length;\n        shouldUseVFlag = countV === this.regExps.length;\n        break;\n      case RegExpMergeFlagsConflictStrategy.Throw: {\n        const allU = countU === this.regExps.length;\n        const noneU = countU === 0;\n        const allV = countV === this.regExps.length;\n        const noneV = countV === 0;\n\n        if (!(allU || noneU) || !(allV || noneV)) {\n          throw new Error('Conflicting \\'u\\'/\\'v\\' flags across patterns.');\n        }\n\n        shouldUseUFlag = allU;\n        shouldUseVFlag = allV;\n        break;\n      }\n      case RegExpMergeFlagsConflictStrategy.Union:\n        shouldUseUFlag = countU > 0;\n        shouldUseVFlag = countV > 0;\n        break;\n      default:\n        /* v8 ignore start -- Exhaustive switch guard. */\n        assertNever(this.strategy);\n        /* v8 ignore stop */\n    }\n\n    if (shouldUseUFlag && shouldUseVFlag) {\n      assert(this.strategy !== RegExpMergeFlagsConflictStrategy.Throw, 'Cannot combine both \\'u\\'/\\'v\\' flags in one RegExp.');\n      shouldUseUFlag = false;\n    }\n\n    if (shouldUseUFlag) {\n      this.finalFlags.add('u');\n    }\n    if (shouldUseVFlag) {\n      this.finalFlags.add('v');\n    }\n  }\n\n  private shouldPickFlag(flag: string): boolean {\n    const count = this.regExps.filter((regExp) => hasFlag(regExp, flag)).length;\n    /* v8 ignore start -- v8 counts the implicit default branch as uncovered even when all enum cases are handled. */\n    switch (this.strategy) {\n      /* v8 ignore stop */\n      case RegExpMergeFlagsConflictStrategy.Intersect:\n        return count === this.regExps.length;\n      case RegExpMergeFlagsConflictStrategy.Throw:\n        break;\n      case RegExpMergeFlagsConflictStrategy.Union:\n        return count > 0;\n      default:\n        /* v8 ignore start -- Exhaustive switch guard. */\n        assertNever(this.strategy);\n        /* v8 ignore stop */\n    }\n\n    const allSame = count === 0 || count === this.regExps.length;\n    if (!allSame) {\n      throw new Error(`Conflicting flag '${flag}' across patterns.`);\n    }\n    return count === this.regExps.length;\n  }\n}\n\n/**\n * Combine multiple regexes into one alternation, handling flags.\n *\n * @param regExps - The regexes to combine.\n * @param strategy - The strategy to use when merging flags (default: `RegExpMergeFlagsConflictStrategy.Throw`).\n * @returns The combined regex.\n */\nexport function oneOf(\n  regExps: RegExp[],\n  strategy: RegExpMergeFlagsConflictStrategy = RegExpMergeFlagsConflictStrategy.Throw\n): RegExp {\n  if (regExps.length === 0) {\n    return ALWAYS_MATCH_REG_EXP;\n  }\n\n  if (regExps.length === 1 && regExps[0] !== undefined) {\n    return regExps[0];\n  }\n\n  const source = regExps.map((regExp) => `(?:${regExp.source})`).join('|');\n  const flags = new RegExpFlagMerger(regExps, strategy).computeFlags();\n  return new RegExp(source, flags);\n}\n"],
  "mappings": "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",
  "names": ["RegExpMergeFlagsConflictStrategy"]
}


package/dist/lib/cjs/reg-exp.d.cts

@@ -28,6 +28,40 @@ export declare enum RegExpMergeFlagsConflictStrategy {
  * @returns The escaped string with special characters prefixed with a backslash.
  */
 export declare function escapeRegExp(str: string): string;
+/**
+ * Reads a mandatory named capture group from a regex match.
+ *
+ * Use this for a named group that is ALWAYS present when the pattern matches — not wrapped in an optional
+ * `(?:…)?` / `(…)?`. Returns the captured string (which may be `''` for a zero-width match such as `\w*`),
+ * throwing if the group — or the match's `groups` object — is absent, so a pattern change that drops the
+ * group fails loudly instead of silently yielding a wrong value.
+ *
+ * Prefer this over `match.groups?.[name] ?? ''`: for a mandatory group that fallback is a never-taken (dead)
+ * branch that fails a 100%-branch coverage gate, whereas the throw here lives inside `ensureNonNullable`
+ * (already covered), leaving no inline branch at the call site. For a group that may legitimately be absent,
+ * use {@link getOptionalNamedGroup} and default its `null` with `?? …`.
+ *
+ * @param match - The match returned by `RegExp.exec`, `String.matchAll`, or `String.match`.
+ * @param groupName - The name of the capture group to read.
+ * @returns The captured string.
+ * @throws When the named group is absent.
+ */
+export declare function getMandatoryNamedGroup(match: RegExpMatchArray, groupName: string): string;
+/**
+ * Reads an optional named capture group from a regex match, distinguishing an absent group from a present
+ * empty one.
+ *
+ * Returns the captured string when the group participated in the match — which may be `''` for a zero-width
+ * match such as `\w*` — or `null` when the group, or the match's `groups` object, is absent (e.g. an optional
+ * `(?:…)?` group that did not match). Because `null` is returned only for a genuinely-absent group, a
+ * caller's `?? <default>` is a live branch rather than the dead one that `match.groups?.[name] ?? ''` leaves
+ * for a mandatory group. For a group that must always be present, use {@link getMandatoryNamedGroup}.
+ *
+ * @param match - The match returned by `RegExp.exec`, `String.matchAll`, or `String.match`.
+ * @param groupName - The name of the capture group to read.
+ * @returns The captured string, or `null` when the group is absent.
+ */
+export declare function getOptionalNamedGroup(match: RegExpMatchArray, groupName: string): null | string;
 /**
  * Checks if a string is a valid regular expression.
  *

package/dist/lib/cjs/script-utils/demo-vault-coverage.cjs

@@ -0,0 +1,289 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  globalThisRecord['__name'] ??= name;
+  const originalRequire = require;
+  if (originalRequire && !originalRequire.__isPatched) {
+    // eslint-disable-next-line no-global-assign, no-implicit-globals -- We need to patch the `require()` function.
+    require = Object.assign(
+      (id) => requirePatched(id),
+      originalRequire,
+      {
+        __isPatched: true
+      }
+    );
+  }
+
+  const newFuncs = {
+    __extractDefault() {
+      return extractDefault;
+    },
+    process() {
+      const browserProcess = {
+        browser: true,
+        cwd() {
+          return '/';
+        },
+        env: {},
+        platform: 'android'
+      };
+      return browserProcess;
+    }
+  };
+
+  for (const key of Object.keys(newFuncs)) {
+    globalThisRecord[key] ??= newFuncs[key]?.();
+  }
+
+  function name(obj) {
+    return obj;
+  }
+
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  'obsidian',
+  '@codemirror/autocomplete',
+  '@codemirror/collab',
+  '@codemirror/commands',
+  '@codemirror/language',
+  '@codemirror/lint',
+  '@codemirror/search',
+  '@codemirror/state',
+  '@codemirror/text',
+  '@codemirror/view',
+  '@lezer/common',
+  '@lezer/lr',
+  '@lezer/highlight'];
+
+
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = [
+  '@codemirror/closebrackets',
+  '@codemirror/comment',
+  '@codemirror/fold',
+  '@codemirror/gutter',
+  '@codemirror/highlight',
+  '@codemirror/history',
+  '@codemirror/matchbrackets',
+  '@codemirror/panel',
+  '@codemirror/rangeset',
+  '@codemirror/rectangular-selection',
+  '@codemirror/stream-parser',
+  '@codemirror/tooltip'];
+
+
+  function requirePatched(id) {
+    if (OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.includes(id)) {
+      return originalRequire?.(id);
+    }
+
+    // eslint-disable-next-line @typescript-eslint/no-deprecated, obsidianmd/no-global-this  -- Need access to app. Actively use globalThis.
+    if (globalThis.app.isMobile) {
+      if (id === 'process' || id === 'node:process') {
+        // eslint-disable-next-line no-console -- Valid usage.
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+        return globalThis.process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+
+    // eslint-disable-next-line no-console -- Valid usage.
+    console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Empty object is returned instead.`);
+    return {};
+  }
+})();
+
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+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 __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var demo_vault_coverage_exports = {};
+__export(demo_vault_coverage_exports, {
+  DemoVaultCoverageChecker: () => DemoVaultCoverageChecker,
+  registerDemoVaultCoverageSuite: () => registerDemoVaultCoverageSuite
+});
+module.exports = __toCommonJS(demo_vault_coverage_exports);
+var import_node_fs = require('node:fs');
+var import_vitest = require('vitest');
+var import_obsidian_plugin_repo_paths = require('../obsidian/plugin/obsidian-plugin-repo-paths.cjs');
+var import_path = require('../path.cjs');
+var import_reg_exp = require('../reg-exp.cjs');
+class DemoVaultCoverageChecker {
+  cachedCorpus = null;
+  demoVaultFolder;
+  rootFolder;
+  /**
+   * Creates a checker rooted at a plugin repo.
+   *
+   * @param params - The parameters for the constructor.
+   */
+  constructor(params) {
+    this.rootFolder = params.rootFolder;
+    this.demoVaultFolder = (0, import_path.join)(this.rootFolder, import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.DemoVault);
+  }
+  /**
+   * Collects the demo notes as paths relative to the demo vault folder (for a non-trivial-surface guard).
+   *
+   * @returns The relative paths of every `*.md` note in the demo vault.
+   */
+  collectDemoNoteRelativePaths() {
+    return this.collectMarkdownFiles(this.demoVaultFolder).map((file) => (0, import_path.relative)(this.demoVaultFolder, file));
+  }
+  /**
+   * Finds members that the demo notes reference on a receiver but that no longer exist on it (rename drift).
+   *
+   * @param params - The parameters for the lookup.
+   * @returns The distinct stale member names referenced in the demo corpus.
+   */
+  findStaleReferences(params) {
+    const validMembers = new Set(params.validMembers);
+    const referenced = [...this.readCorpus().matchAll(new RegExp(`${params.receiver}\\.(?<member>\\w+)`, "g"))].map((match) => (0, import_reg_exp.getMandatoryNamedGroup)(match, "member"));
+    return [...new Set(referenced)].filter((member) => !validMembers.has(member));
+  }
+  /**
+   * Finds members that are not demonstrated anywhere in the demo corpus.
+   *
+   * @param params - The parameters for the lookup.
+   * @returns The member names with no demonstration.
+   */
+  findUndemonstratedMembers(params) {
+    const corpus = this.readCorpus();
+    return params.members.filter((member) => {
+      const needle = params.receiver === void 0 ? member : `${params.receiver}.${member}`;
+      return !corpus.includes(needle);
+    });
+  }
+  /**
+   * Finds feature docs that no demo note links to.
+   *
+   * @param params - The parameters for the lookup.
+   * @returns The feature-doc basenames (without `.md`) not linked from any demo note.
+   */
+  findUnlinkedFeatureDocs(params) {
+    const nonFeatureDocs = new Set(params.nonFeatureDocs);
+    const featureDocs = (0, import_node_fs.readdirSync)((0, import_path.join)(this.rootFolder, params.docsFolder)).filter((file) => file.endsWith(".md")).map((file) => file.replace(/\.md$/, "")).filter((name) => !nonFeatureDocs.has(name));
+    const linkedDocs = new Set(
+      [...this.readCorpus().matchAll(/docs\/(?<doc>[\w-]+)\.md/g)].map((match) => (0, import_reg_exp.getMandatoryNamedGroup)(match, "doc"))
+    );
+    return featureDocs.filter((doc) => !linkedDocs.has(doc));
+  }
+  /**
+   * Parses the members of an `export interface` declared in a source file.
+   *
+   * @param params - The parameters for the lookup.
+   * @returns The parsed {@link InterfaceMembers}.
+   * @throws When the interface cannot be found in the source file.
+   */
+  getInterfaceMembers(params) {
+    const source = (0, import_node_fs.readFileSync)((0, import_path.join)(this.rootFolder, params.sourcePath), "utf-8");
+    const match = new RegExp(`export interface ${params.interfaceName} \\{(?<body>[\\s\\S]*?)\\n\\}`).exec(source);
+    if (!match) {
+      throw new Error(`Could not find interface ${params.interfaceName}`);
+    }
+    const body = (0, import_reg_exp.getMandatoryNamedGroup)(match, "body");
+    const methods = extractMethodNames(body);
+    const properties = extractPropertyNames(body);
+    return {
+      all: [...methods, ...properties],
+      methods,
+      properties
+    };
+  }
+  /**
+   * Reads and caches the demo corpus — every `*.md` note in the demo vault joined into one string.
+   *
+   * @returns The concatenated demo-note contents.
+   */
+  readCorpus() {
+    this.cachedCorpus ??= this.collectMarkdownFiles(this.demoVaultFolder).map((file) => (0, import_node_fs.readFileSync)(file, "utf-8")).join("\n");
+    return this.cachedCorpus;
+  }
+  collectMarkdownFiles(folder) {
+    const result = [];
+    for (const entry of (0, import_node_fs.readdirSync)(folder, { withFileTypes: true })) {
+      if (entry.isDirectory()) {
+        if (entry.name === import_obsidian_plugin_repo_paths.ObsidianPluginRepoPaths.NodeModules) {
+          continue;
+        }
+        result.push(...this.collectMarkdownFiles((0, import_path.join)(folder, entry.name)));
+      } else if (entry.name.endsWith(".md")) {
+        result.push((0, import_path.join)(folder, entry.name));
+      }
+    }
+    return result;
+  }
+}
+function registerDemoVaultCoverageSuite(params) {
+  const checker = new DemoVaultCoverageChecker({ rootFolder: params.rootFolder });
+  (0, import_vitest.describe)("demo-vault coverage", () => {
+    for (const spec of params.interfaces) {
+      (0, import_vitest.it)(`demonstrates every ${spec.interfaceName} ${spec.kind}`, () => {
+        const members = checker.getInterfaceMembers(spec);
+        const demonstrated = members[spec.kind];
+        (0, import_vitest.expect)(demonstrated.length).toBeGreaterThan(0);
+        (0, import_vitest.expect)(checker.findUndemonstratedMembers({ members: demonstrated, receiver: spec.receiver })).toEqual([]);
+      });
+      (0, import_vitest.it)(`references no ${spec.interfaceName} member that no longer exists`, () => {
+        const members = checker.getInterfaceMembers(spec);
+        (0, import_vitest.expect)(checker.findStaleReferences({ receiver: spec.receiver, validMembers: members.all })).toEqual([]);
+      });
+    }
+    for (const spec of params.configInterfaces) {
+      (0, import_vitest.it)(`demonstrates every ${spec.interfaceName} option`, () => {
+        const members = checker.getInterfaceMembers(spec);
+        (0, import_vitest.expect)(members.properties.length).toBeGreaterThan(0);
+        (0, import_vitest.expect)(checker.findUndemonstratedMembers({ members: members.properties })).toEqual([]);
+      });
+    }
+    const docs = params.docs;
+    if (docs) {
+      (0, import_vitest.it)("links a demo note for every feature doc", () => {
+        (0, import_vitest.expect)(checker.findUnlinkedFeatureDocs({ docsFolder: docs.folder, nonFeatureDocs: docs.nonFeatureDocs })).toEqual([]);
+      });
+    }
+    (0, import_vitest.it)("keeps the reflected surface non-trivial", () => {
+      const guard = params.nonTrivialGuard;
+      const members = checker.getInterfaceMembers(guard);
+      (0, import_vitest.expect)(members.all).toContain(guard.expectMember);
+      (0, import_vitest.expect)(checker.collectDemoNoteRelativePaths()).toContain(guard.expectDemoNote);
+    });
+  });
+}
+function extractMethodNames(interfaceBody) {
+  return [...interfaceBody.matchAll(/^ {2}(?<name>\w+)(?:<[^>]*>)?\(/gm)].map((match) => (0, import_reg_exp.getMandatoryNamedGroup)(match, "name"));
+}
+function extractPropertyNames(interfaceBody) {
+  return [...interfaceBody.matchAll(/^ {2}(?<name>\w+)\??:/gm)].map((match) => (0, import_reg_exp.getMandatoryNamedGroup)(match, "name"));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DemoVaultCoverageChecker,
+  registerDemoVaultCoverageSuite
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../../src/script-utils/demo-vault-coverage.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Static coverage/freshness checks that keep a plugin's in-repo `demo-vault/` in sync with its public surface.\n *\n * A plugin can ship a curated demo vault at `demo-vault/` in its repo root. These helpers reflect the real\n * public API/config/docs straight from source and assert \u2014 WITHOUT launching Obsidian \u2014 that every feature is\n * demonstrated in the notes and that the notes reference no API member that no longer exists (rename drift).\n * The runtime behavior of the plugin is covered by its other integration tests, not by the demo vault; the\n * vault is a learning resource, and these checks only guard that it stays truthful.\n *\n * Two layers are exposed:\n * - {@link DemoVaultCoverageChecker} \u2014 a framework-agnostic core that reads the corpus, parses interface\n *   members, and returns diagnostic arrays (what is undemonstrated / stale / unlinked).\n * - {@link registerDemoVaultCoverageSuite} \u2014 a thin wrapper that registers a `vitest` suite over the core, so\n *   a plugin's `demo-vault.no-app.integration.test.ts` is a single declarative call.\n */\n\nimport {\n  readdirSync,\n  readFileSync\n} from 'node:fs';\nimport {\n  describe,\n  expect,\n  it\n} from 'vitest';\n\nimport { ObsidianPluginRepoPaths } from '../obsidian/plugin/obsidian-plugin-repo-paths.ts';\nimport {\n  join,\n  relative\n} from '../path.ts';\nimport { getMandatoryNamedGroup } from '../reg-exp.ts';\n\n/**\n * Reflects a config interface whose options are demonstrated by their bare name.\n */\nexport interface DemoVaultConfigInterfaceCoverageSpec {\n  /**\n   * The name of the `export interface` whose properties are the config options.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * The parameters for the {@link DemoVaultCoverageChecker} constructor.\n */\nexport interface DemoVaultCoverageCheckerConstructorParams {\n  /**\n   * The absolute path of the plugin repo root \u2014 the folder containing `demo-vault/` and the source being\n   * reflected. Callers typically pass `getRootFolder() ?? process.cwd()`.\n   */\n  readonly rootFolder: string;\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.findStaleReferences}.\n */\nexport interface DemoVaultCoverageCheckerFindStaleReferencesParams {\n  /**\n   * The receiver whose `` `${receiver}.<member>` `` references are scanned for in the demo corpus.\n   */\n  readonly receiver: string;\n\n  /**\n   * The members that currently exist on the receiver; any referenced member not in this set is stale.\n   */\n  readonly validMembers: string[];\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.findUndemonstratedMembers}.\n */\nexport interface DemoVaultCoverageCheckerFindUndemonstratedMembersParams {\n  /**\n   * The member names that must each appear in the demo corpus.\n   */\n  readonly members: string[];\n\n  /**\n   * When set, a member is demonstrated only if `` `${receiver}.${member}` `` appears (e.g. a context object's\n   * methods); when absent, the bare member name is looked up (e.g. a config option).\n   */\n  readonly receiver?: string;\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.findUnlinkedFeatureDocs}.\n */\nexport interface DemoVaultCoverageCheckerFindUnlinkedFeatureDocsParams {\n  /**\n   * The docs folder (relative to the repo root) whose top-level `*.md` files are the feature docs.\n   */\n  readonly docsFolder: string;\n\n  /**\n   * The doc basenames (without `.md`) that are NOT per-feature pages and so need no linking demo note.\n   */\n  readonly nonFeatureDocs: string[];\n}\n\n/**\n * The parameters for {@link DemoVaultCoverageChecker.getInterfaceMembers}.\n */\nexport interface DemoVaultCoverageCheckerGetInterfaceMembersParams {\n  /**\n   * The name of the `export interface` to parse.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * Configures the feature-doc linking check.\n */\nexport interface DemoVaultDocsCoverageSpec {\n  /**\n   * The docs folder (relative to the repo root) whose top-level `*.md` files are the feature docs.\n   */\n  readonly folder: string;\n\n  /**\n   * The doc basenames (without `.md`) that are NOT per-feature pages and so need no linking demo note.\n   */\n  readonly nonFeatureDocs: string[];\n}\n\n/**\n * Reflects a single interface's members and demonstrates them via `` `${receiver}.<member>` `` references.\n */\nexport interface DemoVaultInterfaceCoverageSpec {\n  /**\n   * The name of the `export interface` to reflect.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * Whether the demonstrated members are the interface's methods or its properties.\n   */\n  readonly kind: DemoVaultInterfaceMemberKind;\n\n  /**\n   * The identifier the notes call the members on (e.g. `codeButtonContext`).\n   */\n  readonly receiver: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * Whether an interface's demonstrated members are its methods or its properties.\n */\nexport type DemoVaultInterfaceMemberKind = 'methods' | 'properties';\n\n/**\n * Configures the guard that the reflected surface is non-trivial (protects against a parsing regression\n * silently emptying every other check).\n */\nexport interface DemoVaultNonTrivialGuardSpec {\n  /**\n   * A demo note (path relative to the demo vault) that must be present.\n   */\n  readonly expectDemoNote: string;\n\n  /**\n   * A member that must be reflected from {@link DemoVaultNonTrivialGuardSpec.interfaceName}.\n   */\n  readonly expectMember: string;\n\n  /**\n   * The name of the `export interface` whose members are re-parsed for the guard.\n   */\n  readonly interfaceName: string;\n\n  /**\n   * The source file path (relative to the repo root) that declares the interface.\n   */\n  readonly sourcePath: string;\n}\n\n/**\n * The parsed members of a source interface.\n */\nexport interface InterfaceMembers {\n  /**\n   * Every member \u2014 {@link InterfaceMembers.methods} followed by {@link InterfaceMembers.properties}.\n   */\n  readonly all: string[];\n\n  /**\n   * The method members (declared as `name(...)`).\n   */\n  readonly methods: string[];\n\n  /**\n   * The property members (declared as `name?: ...`).\n   */\n  readonly properties: string[];\n}\n\n/**\n * The parameters for {@link registerDemoVaultCoverageSuite}.\n */\nexport interface RegisterDemoVaultCoverageSuiteParams {\n  /**\n   * The config interfaces whose options must each be demonstrated by their bare name.\n   */\n  readonly configInterfaces: DemoVaultConfigInterfaceCoverageSpec[];\n\n  /**\n   * The feature-doc linking check, or `undefined` when the plugin ships no `docs/` folder.\n   */\n  readonly docs?: DemoVaultDocsCoverageSpec;\n\n  /**\n   * The interfaces whose members must each be demonstrated (and referenced without drift).\n   */\n  readonly interfaces: DemoVaultInterfaceCoverageSpec[];\n\n  /**\n   * The guard that keeps the reflected surface non-trivial.\n   */\n  readonly nonTrivialGuard: DemoVaultNonTrivialGuardSpec;\n\n  /**\n   * The absolute path of the plugin repo root. Callers typically pass `getRootFolder() ?? process.cwd()`.\n   */\n  readonly rootFolder: string;\n}\n\n/**\n * Reflects a plugin's public surface from source and checks its in-repo `demo-vault/` stays in sync with it.\n *\n * Every method is a pure query over files under the repo root (the demo corpus is read once and cached), so\n * the checker is trivially unit-testable against a fixture repo and carries no test-framework dependency.\n */\nexport class DemoVaultCoverageChecker {\n  private cachedCorpus: null | string = null;\n  private readonly demoVaultFolder: string;\n  private readonly rootFolder: string;\n\n  /**\n   * Creates a checker rooted at a plugin repo.\n   *\n   * @param params - The parameters for the constructor.\n   */\n  public constructor(params: DemoVaultCoverageCheckerConstructorParams) {\n    this.rootFolder = params.rootFolder;\n    this.demoVaultFolder = join(this.rootFolder, ObsidianPluginRepoPaths.DemoVault);\n  }\n\n  /**\n   * Collects the demo notes as paths relative to the demo vault folder (for a non-trivial-surface guard).\n   *\n   * @returns The relative paths of every `*.md` note in the demo vault.\n   */\n  public collectDemoNoteRelativePaths(): string[] {\n    return this.collectMarkdownFiles(this.demoVaultFolder).map((file) => relative(this.demoVaultFolder, file));\n  }\n\n  /**\n   * Finds members that the demo notes reference on a receiver but that no longer exist on it (rename drift).\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The distinct stale member names referenced in the demo corpus.\n   */\n  public findStaleReferences(params: DemoVaultCoverageCheckerFindStaleReferencesParams): string[] {\n    const validMembers = new Set(params.validMembers);\n    const referenced = [...this.readCorpus().matchAll(new RegExp(`${params.receiver}\\\\.(?<member>\\\\w+)`, 'g'))]\n      .map((match) => getMandatoryNamedGroup(match, 'member'));\n    return [...new Set(referenced)].filter((member) => !validMembers.has(member));\n  }\n\n  /**\n   * Finds members that are not demonstrated anywhere in the demo corpus.\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The member names with no demonstration.\n   */\n  public findUndemonstratedMembers(params: DemoVaultCoverageCheckerFindUndemonstratedMembersParams): string[] {\n    const corpus = this.readCorpus();\n    return params.members.filter((member) => {\n      const needle = params.receiver === undefined ? member : `${params.receiver}.${member}`;\n      return !corpus.includes(needle);\n    });\n  }\n\n  /**\n   * Finds feature docs that no demo note links to.\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The feature-doc basenames (without `.md`) not linked from any demo note.\n   */\n  public findUnlinkedFeatureDocs(params: DemoVaultCoverageCheckerFindUnlinkedFeatureDocsParams): string[] {\n    const nonFeatureDocs = new Set(params.nonFeatureDocs);\n    const featureDocs = readdirSync(join(this.rootFolder, params.docsFolder))\n      .filter((file) => file.endsWith('.md'))\n      .map((file) => file.replace(/\\.md$/, ''))\n      .filter((name) => !nonFeatureDocs.has(name));\n    const linkedDocs = new Set(\n      [...this.readCorpus().matchAll(/docs\\/(?<doc>[\\w-]+)\\.md/g)].map((match) => getMandatoryNamedGroup(match, 'doc'))\n    );\n    return featureDocs.filter((doc) => !linkedDocs.has(doc));\n  }\n\n  /**\n   * Parses the members of an `export interface` declared in a source file.\n   *\n   * @param params - The parameters for the lookup.\n   * @returns The parsed {@link InterfaceMembers}.\n   * @throws When the interface cannot be found in the source file.\n   */\n  public getInterfaceMembers(params: DemoVaultCoverageCheckerGetInterfaceMembersParams): InterfaceMembers {\n    const source = readFileSync(join(this.rootFolder, params.sourcePath), 'utf-8');\n    const match = new RegExp(`export interface ${params.interfaceName} \\\\{(?<body>[\\\\s\\\\S]*?)\\\\n\\\\}`).exec(source);\n    if (!match) {\n      throw new Error(`Could not find interface ${params.interfaceName}`);\n    }\n    const body = getMandatoryNamedGroup(match, 'body');\n    const methods = extractMethodNames(body);\n    const properties = extractPropertyNames(body);\n    return {\n      all: [...methods, ...properties],\n      methods,\n      properties\n    };\n  }\n\n  /**\n   * Reads and caches the demo corpus \u2014 every `*.md` note in the demo vault joined into one string.\n   *\n   * @returns The concatenated demo-note contents.\n   */\n  public readCorpus(): string {\n    this.cachedCorpus ??= this.collectMarkdownFiles(this.demoVaultFolder)\n      .map((file) => readFileSync(file, 'utf-8'))\n      .join('\\n');\n    return this.cachedCorpus;\n  }\n\n  private collectMarkdownFiles(folder: string): string[] {\n    const result: string[] = [];\n    for (const entry of readdirSync(folder, { withFileTypes: true })) {\n      if (entry.isDirectory()) {\n        if (entry.name === ObsidianPluginRepoPaths.NodeModules as string) {\n          continue;\n        }\n        result.push(...this.collectMarkdownFiles(join(folder, entry.name)));\n      } else if (entry.name.endsWith('.md')) {\n        result.push(join(folder, entry.name));\n      }\n    }\n    return result;\n  }\n}\n\n/**\n * Registers a `vitest` suite that keeps a plugin's in-repo `demo-vault/` in sync with its public surface.\n *\n * Call it once from a plugin's `demo-vault.no-app.integration.test.ts`; it registers one test per check,\n * delegating to {@link DemoVaultCoverageChecker}.\n *\n * @param params - The declarative coverage specification.\n */\nexport function registerDemoVaultCoverageSuite(params: RegisterDemoVaultCoverageSuiteParams): void {\n  const checker = new DemoVaultCoverageChecker({ rootFolder: params.rootFolder });\n\n  describe('demo-vault coverage', () => {\n    for (const spec of params.interfaces) {\n      it(`demonstrates every ${spec.interfaceName} ${spec.kind}`, () => {\n        const members = checker.getInterfaceMembers(spec);\n        const demonstrated = members[spec.kind];\n        expect(demonstrated.length).toBeGreaterThan(0);\n        expect(checker.findUndemonstratedMembers({ members: demonstrated, receiver: spec.receiver })).toEqual([]);\n      });\n\n      it(`references no ${spec.interfaceName} member that no longer exists`, () => {\n        const members = checker.getInterfaceMembers(spec);\n        expect(checker.findStaleReferences({ receiver: spec.receiver, validMembers: members.all })).toEqual([]);\n      });\n    }\n\n    for (const spec of params.configInterfaces) {\n      it(`demonstrates every ${spec.interfaceName} option`, () => {\n        const members = checker.getInterfaceMembers(spec);\n        expect(members.properties.length).toBeGreaterThan(0);\n        expect(checker.findUndemonstratedMembers({ members: members.properties })).toEqual([]);\n      });\n    }\n\n    const docs = params.docs;\n    if (docs) {\n      it('links a demo note for every feature doc', () => {\n        expect(checker.findUnlinkedFeatureDocs({ docsFolder: docs.folder, nonFeatureDocs: docs.nonFeatureDocs }))\n          .toEqual([]);\n      });\n    }\n\n    it('keeps the reflected surface non-trivial', () => {\n      const guard = params.nonTrivialGuard;\n      const members = checker.getInterfaceMembers(guard);\n      expect(members.all).toContain(guard.expectMember);\n      expect(checker.collectDemoNoteRelativePaths()).toContain(guard.expectDemoNote);\n    });\n  });\n}\n\nfunction extractMethodNames(interfaceBody: string): string[] {\n  return [...interfaceBody.matchAll(/^ {2}(?<name>\\w+)(?:<[^>]*>)?\\(/gm)].map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n\nfunction extractPropertyNames(interfaceBody: string): string[] {\n  return [...interfaceBody.matchAll(/^ {2}(?<name>\\w+)\\??:/gm)].map((match) => getMandatoryNamedGroup(match, 'name'));\n}\n"],
  "mappings": "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",
  "names": []
}
