@mnaoumov/obsidian-lib 0.0.0 → 1.0.1

package/dist/lib/cjs/parse-link.d.cts

@@ -0,0 +1,288 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * This module provides utilities for parsing markdown and wiki links into structured data, and for
+ * escaping, unescaping, and encoding link components.
+ */
+import type { FrontmatterLinkCache, Reference, ReferenceCache } from 'obsidian' with { 'resolution-mode': 'import' };
+/**
+ * The result of parsing the links from a note's frontmatter via {@link parseFrontmatterLinks}. Internal
+ * single-link frontmatter values are omitted, as Obsidian natively caches them.
+ */
+export interface ParseFrontmatterLinksResult {
+    /**
+     * The external links parsed from single-link (single-value) frontmatter values.
+     */
+    readonly frontmatterExternalLinks: ParseLinkFrontmatterReference[];
+    /**
+     * The external links parsed from multi-link (multi-value) frontmatter values.
+     */
+    readonly multiValueFrontmatterExternalLinks: ParseLinkFrontmatterReferenceWithOffsets[];
+    /**
+     * The internal links parsed from multi-link (multi-value) frontmatter values.
+     */
+    readonly multiValueFrontmatterLinks: ParseLinkFrontmatterReferenceWithOffsets[];
+}
+/**
+ * A {@link FrontmatterLinkCache} for a link parsed from a single-link frontmatter value via
+ * {@link parseLinks}. It carries the full {@link ParseLinkResult} so consumers can inspect the parse
+ * details without re-parsing the link. Use this when the whole frontmatter value is a single link.
+ */
+export interface ParseLinkFrontmatterReference extends FrontmatterLinkCache {
+    /**
+     * The result of parsing the link.
+     */
+    readonly parseLinkResult: ParseLinkResult;
+}
+/**
+ * A {@link ParseLinkFrontmatterReference} for a link parsed from a multi-link frontmatter value via
+ * {@link parseLinks}, additionally carrying the offsets of the link within the frontmatter value. Use
+ * this when the frontmatter value holds multiple links.
+ */
+export interface ParseLinkFrontmatterReferenceWithOffsets extends ParseLinkFrontmatterReference {
+    /**
+     * An end offset of the link in the frontmatter value.
+     */
+    endOffset: number;
+    /**
+     * A start offset of the link in the frontmatter value.
+     */
+    startOffset: number;
+}
+/**
+ * Options for {@link parseLink}. The same as {@link ParseLinksOptions}.
+ */
+export type ParseLinkOptions = ParseLinksOptions;
+/**
+ * A {@link ReferenceCache} for a link parsed from content via {@link parseLinks}. It carries the full
+ * {@link ParseLinkResult} so consumers can inspect the parse details without re-parsing the link.
+ */
+export interface ParseLinkReference extends ReferenceCache {
+    /**
+     * The result of parsing the link.
+     */
+    readonly parseLinkResult: ParseLinkResult;
+}
+/**
+ * A result of parsing a link.
+ */
+export interface ParseLinkResult {
+    /**
+     * An alias of the link.
+     *
+     * @example
+     * ```
+     * [\*alias\*](link.md) -> \*alias\*
+     * ```
+     */
+    readonly alias?: string;
+    /**
+     * An encoded URL of the link.
+     *
+     * @example
+     * ```
+     * [alias](<link with space.md>) -> link%20with%20space.md
+     * ```
+     */
+    readonly encodedUrl?: string;
+    /**
+     * An end offset of the link in the original text.
+     */
+    readonly endOffset: number;
+    /**
+     * Indicates if the link has angle brackets.
+     *
+     * @example
+     * ```
+     * [alias](<link.md>) -> true
+     * [alias](link.md) -> false
+     * ```
+     */
+    readonly hasAngleBrackets?: boolean;
+    /**
+     * Indicates if the link is an embed link.
+     *
+     * @example
+     * ```
+     * ![[alias]] -> true
+     * [[alias]] -> false
+     * ```
+     */
+    readonly isEmbed: boolean;
+    /**
+     * Indicates if the link is external.
+     *
+     * @example
+     * ```
+     * [alias](https://example.com) -> true
+     * [alias](file.md) -> false
+     * ```
+     */
+    readonly isExternal: boolean;
+    /**
+     * Indicates if the link is a `file://` URL.
+     *
+     * @example
+     * ```
+     * [alias](file:///C:/x.txt) -> true
+     * [alias](https://example.com) -> false
+     * ```
+     */
+    readonly isFileUrl: boolean;
+    /**
+     * Indicates if the link is a wikilink.
+     *
+     * @example
+     * ```
+     * [[alias]] -> true
+     * [alias](link.md) -> false
+     * ```
+     */
+    readonly isWikilink: boolean;
+    /**
+     * A raw link text.
+     *
+     * @example
+     * ```
+     * [alias](link.md) -> [alias](link.md)
+     * ```
+     */
+    readonly raw: string;
+    /**
+     * A start offset of the link in the original text.
+     */
+    readonly startOffset: number;
+    /**
+     * A title of the link.
+     *
+     * @example
+     * ```
+     * [alias](link.md "title") -> title
+     * ```
+     */
+    readonly title?: string;
+    /**
+     * An unescaped alias of the link.
+     *
+     * @example
+     * ```
+     * [\*alias\*](link.md) -> *alias*
+     * ```
+     */
+    readonly unescapedAlias?: string;
+    /**
+     * An URL of the link.
+     *
+     * @example
+     * ```
+     * [alias](link%20with%20space.md) -> link with space.md
+     * ```
+     */
+    readonly url: string;
+}
+/**
+ * Options for {@link parseLinks}.
+ */
+export interface ParseLinksOptions {
+    /**
+     * Whether to recognize GFM extended `www.` autolink literals (`www.example.com`, also inside
+     * `<...>`) as external links, as Obsidian does in a note's body. Obsidian does not link them in
+     * frontmatter values, so {@link parseFrontmatterLinks} turns this off.
+     *
+     * Defaults to `true`.
+     */
+    readonly shouldRecognizeWwwAutolinkLiterals?: boolean;
+}
+/**
+ * Params for {@link toParseLinkReference}.
+ */
+export interface ToParseLinkReferenceParams {
+    /**
+     * The content the parsed link's offsets index into. Used to compute the line and column.
+     */
+    readonly content: string;
+    /**
+     * The parsed link to wrap.
+     */
+    readonly parseLinkResult: ParseLinkResult;
+}
+/**
+ * Escapes the alias of a markdown link.
+ *
+ * @param alias - An alias of a markdown link.
+ * @returns An escaped alias.
+ *
+ * @example
+ * ```ts
+ * escapeAlias('**alias**') // '\\*\\*alias\\*\\*'
+ * ```
+ */
+export declare function escapeAlias(alias: string): string;
+/**
+ * Determines whether a reference is a {@link ParseLinkFrontmatterReference}.
+ *
+ * @param reference - The reference to check.
+ * @returns `true` if the reference is a {@link ParseLinkFrontmatterReference}, otherwise `false`.
+ */
+export declare function isParseLinkFrontmatterReference(reference: Reference): reference is ParseLinkFrontmatterReference;
+/**
+ * Determines whether a reference is a {@link ParseLinkReference}.
+ *
+ * @param reference - The reference to check.
+ * @returns `true` if the reference is a {@link ParseLinkReference}, otherwise `false`.
+ */
+export declare function isParseLinkReference(reference: Reference): reference is ParseLinkReference;
+/**
+ * Parses the links from a note's frontmatter. Each string value is parsed via {@link parseLinks}: a value
+ * that is a single link yields an entry without offsets, and a value that holds multiple links yields
+ * offset-carrying entries. Internal single-link values are omitted, as Obsidian natively caches them.
+ *
+ * @param frontmatter - The frontmatter to parse (a value, object, or array).
+ * @returns The parsed frontmatter links.
+ */
+export declare function parseFrontmatterLinks(frontmatter: unknown): ParseFrontmatterLinksResult;
+/**
+ * Parses a link into its components.
+ *
+ * @param $string - The link to parse.
+ * @param options - The parse options.
+ * @returns The parsed link.
+ */
+export declare function parseLink($string: string, options?: ParseLinkOptions): null | ParseLinkResult;
+/**
+ * Parses all links in a string.
+ *
+ * Besides markdown links, wikilinks and autolinks, the plain text between them is scanned for bare
+ * URLs with a scheme (`https://example.com`) and, unless turned off through
+ * {@link ParseLinksOptions.shouldRecognizeWwwAutolinkLiterals}, for GFM extended `www.` autolink
+ * literals (`www.example.com`). Such a literal is reported as an external link whose `url` carries the
+ * `http://` scheme Obsidian opens it with, so a link rebuilt from it stays external: a scheme-less
+ * `[alias](www.example.com)` is an internal link in Obsidian. A literal wrapped in `<...>` reports the
+ * brackets as part of `raw`, so replacing `raw` leaves no stray bracket behind.
+ *
+ * @param $string - The string to parse the links in.
+ * @param options - The parse options.
+ * @returns The parsed links.
+ */
+export declare function parseLinks($string: string, options?: ParseLinksOptions): ParseLinkResult[];
+/**
+ * Wraps a {@link ParseLinkResult} into a {@link ParseLinkReference} so it can flow through the
+ * reference-based file-change pipeline.
+ *
+ * @param params - The parameters for wrapping the parsed link.
+ * @returns The {@link ParseLinkReference}.
+ */
+export declare function toParseLinkReference(params: ToParseLinkReferenceParams): ParseLinkReference;
+/**
+ * Unescapes the alias of a markdown link.
+ *
+ * @param escapedAlias - An escaped alias.
+ * @returns An unescaped alias.
+ *
+ * @example
+ * ```ts
+ * unescapeAlias('\\*\\*alias\\*\\*') // '**alias**'
+ * ```
+ */
+export declare function unescapeAlias(escapedAlias: string): string;

package/dist/lib/cjs/path-settings.cjs

@@ -0,0 +1,269 @@
+/*
+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"
+  };
+  const existingProcess = globalThis.process;
+  if (!existingProcess) {
+    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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord["__name"] ??= keepName;
+  globalThisRecord["__extractDefault"] ??= extractDefault;
+  ensureBrowserProcess();
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+})();
+})();
+(function patchObsidianRequire() {
+  const originalRequire = require;
+  if (!originalRequire || originalRequire.__isPatched) {
+    return;
+  }
+  require = Object.assign(
+    (id) => requirePatched(id),
+    originalRequire,
+    {
+      __isPatched: true
+    }
+  );
+  function extractDefault(module) {
+    return module && module.__esModule && "default" in module ? module.default : module;
+  }
+  const OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@codemirror/autocomplete",
+    "@codemirror/collab",
+    "@codemirror/commands",
+    "@codemirror/language",
+    "@codemirror/lint",
+    "@codemirror/search",
+    "@codemirror/state",
+    "@codemirror/text",
+    "@codemirror/view",
+    "@lezer/common",
+    "@lezer/highlight",
+    "@lezer/lr",
+    "obsidian"
+  ]);
+  const DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES = /* @__PURE__ */ new Set([
+    "@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.has(id) || DEPRECATED_OBSIDIAN_BUILT_IN_MODULE_NAMES.has(id)) {
+      return originalRequire?.(id);
+    }
+    if (globalThis.app.isMobile) {
+      if (id === "process" || id === "node:process") {
+        console.debug(`The most likely you can safely ignore this error. Module not found: ${id}. Fake process object is returned instead.`);
+        return process;
+      }
+    } else {
+      const module = originalRequire?.(id);
+      if (module) {
+        return extractDefault(module);
+      }
+    }
+    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 path_settings_exports = {};
+__export(path_settings_exports, {
+  PathSettings: () => PathSettings,
+  pathsValidator: () => pathsValidator
+});
+module.exports = __toCommonJS(path_settings_exports);
+var import_reg_exp = require('@mnaoumov/typescript-lib/reg-exp');
+var import_string = require('@mnaoumov/typescript-lib/string');
+var import_type_guards = require('@mnaoumov/typescript-lib/type-guards');
+var import_i18n = require('./i18n/i18n.cjs');
+class PathSetting {
+  constructor(type) {
+    this.type = type;
+    this.defaultRegExp = getDefaultRegExp(type);
+    this.regExp = this.defaultRegExp;
+  }
+  type;
+  get array() {
+    return this._array;
+  }
+  set array(value) {
+    this._array = value.filter(Boolean);
+    this.regExp = makeRegExp(this._array, this.defaultRegExp) ?? this.defaultRegExp;
+  }
+  _array = [];
+  defaultRegExp;
+  regExp;
+  isPathIgnored(path) {
+    switch (this.type) {
+      /* v8 ignore stop */
+      case "Exclude" /* Exclude */: {
+        return this.regExp.test(path);
+      }
+      case "Include" /* Include */: {
+        return !this.regExp.test(path);
+      }
+      default: {
+        (0, import_type_guards.assertNever)(this.type);
+      }
+    }
+  }
+}
+class PathSettings {
+  /**
+   * Gets the exclude paths.
+   *
+   * @returns The exclude paths.
+   */
+  get excludePaths() {
+    return this._excludePaths.array;
+  }
+  /**
+   * Sets the exclude paths.
+   *
+   * @param value - The exclude paths.
+   */
+  set excludePaths(value) {
+    this._excludePaths.array = value;
+  }
+  /**
+   * Gets the include paths.
+   *
+   * @returns The include paths.
+   */
+  get includePaths() {
+    return this._includePaths.array;
+  }
+  /**
+   * Sets the include paths.
+   *
+   * @param value - The include paths.
+   */
+  set includePaths(value) {
+    this._includePaths.array = value;
+  }
+  _excludePaths = new PathSetting("Exclude" /* Exclude */);
+  _includePaths = new PathSetting("Include" /* Include */);
+  /**
+   * Checks if a path is ignored by the include/exclude path settings.
+   *
+   * @param path - The path to check.
+   * @returns `true` if the path is ignored, `false` otherwise.
+   */
+  isPathIgnored(path) {
+    return this._includePaths.isPathIgnored(path) || this._excludePaths.isPathIgnored(path);
+  }
+}
+function pathsValidator(paths) {
+  for (const path of paths) {
+    if (path.startsWith("/") && path.endsWith("/") && !(0, import_reg_exp.isValidRegExp)(path.slice(1, -1))) {
+      return (0, import_i18n.t)(($) => $.obsidianDevUtils.pathSettings.invalidRegularExpression, { regExp: path });
+    }
+  }
+}
+function getDefaultRegExp(type) {
+  switch (type) {
+    /* v8 ignore stop */
+    case "Exclude" /* Exclude */: {
+      return import_reg_exp.NEVER_MATCH_REG_EXP;
+    }
+    case "Include" /* Include */: {
+      return import_reg_exp.ALWAYS_MATCH_REG_EXP;
+    }
+    default: {
+      (0, import_type_guards.assertNever)(type);
+    }
+  }
+}
+function makeRegExp(paths, defaultRegExp) {
+  if (paths.length === 0) {
+    return defaultRegExp;
+  }
+  const regExpStringCombined = paths.map((path) => {
+    if (path === "/") {
+      return defaultRegExp.source;
+    }
+    if (path.startsWith("/") && path.endsWith("/")) {
+      return path.slice(1, -1);
+    }
+    path = (0, import_string.trimEnd)({
+      $string: path,
+      suffix: "/"
+    });
+    return `^${(0, import_reg_exp.escapeRegExp)(path)}(/|$)`;
+  }).map((regExpString) => `(${regExpString})`).join("|");
+  try {
+    return new RegExp(regExpStringCombined);
+  } catch {
+    return null;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PathSettings,
+  pathsValidator
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/path-settings.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * This module provides classes and validators for managing include/exclude path settings.\n */\n\nimport type { MaybeReturn } from '@mnaoumov/typescript-lib/type';\n\nimport {\n  ALWAYS_MATCH_REG_EXP,\n  escapeRegExp,\n  isValidRegExp,\n  NEVER_MATCH_REG_EXP\n} from '@mnaoumov/typescript-lib/reg-exp';\nimport { trimEnd } from '@mnaoumov/typescript-lib/string';\nimport { assertNever } from '@mnaoumov/typescript-lib/type-guards';\n\nimport { t } from './i18n/i18n.ts';\n\nenum PathSettingType {\n  Exclude = 'Exclude',\n  Include = 'Include'\n}\n\nclass PathSetting {\n  public get array(): string[] {\n    return this._array;\n  }\n\n  public set array(value: string[]) {\n    this._array = value.filter(Boolean);\n    this.regExp = makeRegExp(this._array, this.defaultRegExp) ?? this.defaultRegExp;\n  }\n\n  private _array: string[] = [];\n  private readonly defaultRegExp: RegExp;\n  private regExp: RegExp;\n\n  public constructor(private readonly type: PathSettingType) {\n    this.defaultRegExp = getDefaultRegExp(type);\n    this.regExp = this.defaultRegExp;\n  }\n\n  public isPathIgnored(path: string): boolean {\n    /* v8 ignore start -- All branches covered but v8 reports switch as partial. */\n    switch (this.type) {\n      /* v8 ignore stop */\n      case PathSettingType.Exclude: {\n        return this.regExp.test(path);\n      }\n      case PathSettingType.Include: {\n        return !this.regExp.test(path);\n      }\n      default: {\n        /* v8 ignore start -- Exhaustive switch guard. */\n        assertNever(this.type);\n      }\n        /* v8 ignore stop */\n    }\n  }\n}\n\n/**\n * A class for managing include/exclude path settings.\n */\nexport class PathSettings {\n  /**\n   * Gets the exclude paths.\n   *\n   * @returns The exclude paths.\n   */\n  public get excludePaths(): string[] {\n    return this._excludePaths.array;\n  }\n\n  /**\n   * Sets the exclude paths.\n   *\n   * @param value - The exclude paths.\n   */\n  public set excludePaths(value: string[]) {\n    this._excludePaths.array = value;\n  }\n\n  /**\n   * Gets the include paths.\n   *\n   * @returns The include paths.\n   */\n  public get includePaths(): string[] {\n    return this._includePaths.array;\n  }\n\n  /**\n   * Sets the include paths.\n   *\n   * @param value - The include paths.\n   */\n  public set includePaths(value: string[]) {\n    this._includePaths.array = value;\n  }\n\n  private readonly _excludePaths = new PathSetting(PathSettingType.Exclude);\n  private readonly _includePaths = new PathSetting(PathSettingType.Include);\n\n  /**\n   * Checks if a path is ignored by the include/exclude path settings.\n   *\n   * @param path - The path to check.\n   * @returns `true` if the path is ignored, `false` otherwise.\n   */\n  public isPathIgnored(path: string): boolean {\n    return this._includePaths.isPathIgnored(path) || this._excludePaths.isPathIgnored(path);\n  }\n}\n\n/**\n * Validates include/exclude path entries, reporting the first entry that is not a parseable regular expression.\n *\n * An entry that starts and ends with `/` is a regular expression literal; every other entry is a plain path and is\n * always valid. An invalid entry does not throw when assigned to {@link PathSettings} \u2014 the whole list falls back to\n * its default pattern instead \u2014 so this validator is what surfaces the problem to the user.\n *\n * @param paths - The path entries to validate.\n * @returns A message naming the first invalid entry, or nothing when every entry is valid.\n */\nexport function pathsValidator(paths: string[]): MaybeReturn<string> {\n  for (const path of paths) {\n    if (path.startsWith('/') && path.endsWith('/') && !isValidRegExp(path.slice(1, -1))) {\n      return t(($) => $.obsidianDevUtils.pathSettings.invalidRegularExpression, { regExp: path });\n    }\n  }\n}\n\nfunction getDefaultRegExp(type: PathSettingType): RegExp {\n  /* v8 ignore start -- All branches covered but v8 reports switch as partial. */\n  switch (type) {\n    /* v8 ignore stop */\n    case PathSettingType.Exclude: {\n      return NEVER_MATCH_REG_EXP;\n    }\n    case PathSettingType.Include: {\n      return ALWAYS_MATCH_REG_EXP;\n    }\n    default: {\n      /* v8 ignore start -- Exhaustive switch guard. */\n      assertNever(type);\n    }\n      /* v8 ignore stop */\n  }\n}\n\nfunction makeRegExp(paths: string[], defaultRegExp: RegExp): null | RegExp {\n  if (paths.length === 0) {\n    return defaultRegExp;\n  }\n\n  const regExpStringCombined = paths.map((path) => {\n    if (path === '/') {\n      return defaultRegExp.source;\n    }\n\n    if (path.startsWith('/') && path.endsWith('/')) {\n      return path.slice(1, -1);\n    }\n\n    path = trimEnd({\n      $string: path,\n      suffix: '/'\n    });\n    return `^${escapeRegExp(path)}(/|$)`;\n  })\n    .map((regExpString) => `(${regExpString})`)\n    .join('|');\n\n  try {\n    return new RegExp(regExpStringCombined);\n  } catch {\n    // A partially typed regex literal (`/^Inbox\\/`) is not parseable.\n    // Report it instead of throwing from a settings setter, which would break both the settings UI and the save path.\n    return null;\n  }\n}\n"],
  "mappings": "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",
  "names": []
}


package/dist/lib/cjs/path-settings.d.cts

@@ -0,0 +1,56 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @file
+ *
+ * This module provides classes and validators for managing include/exclude path settings.
+ */
+import type { MaybeReturn } from '@mnaoumov/typescript-lib/type' with { 'resolution-mode': 'import' };
+/**
+ * A class for managing include/exclude path settings.
+ */
+export declare class PathSettings {
+    /**
+     * Gets the exclude paths.
+     *
+     * @returns The exclude paths.
+     */
+    get excludePaths(): string[];
+    /**
+     * Sets the exclude paths.
+     *
+     * @param value - The exclude paths.
+     */
+    set excludePaths(value: string[]);
+    /**
+     * Gets the include paths.
+     *
+     * @returns The include paths.
+     */
+    get includePaths(): string[];
+    /**
+     * Sets the include paths.
+     *
+     * @param value - The include paths.
+     */
+    set includePaths(value: string[]);
+    private readonly _excludePaths;
+    private readonly _includePaths;
+    /**
+     * Checks if a path is ignored by the include/exclude path settings.
+     *
+     * @param path - The path to check.
+     * @returns `true` if the path is ignored, `false` otherwise.
+     */
+    isPathIgnored(path: string): boolean;
+}
+/**
+ * Validates include/exclude path entries, reporting the first entry that is not a parseable regular expression.
+ *
+ * An entry that starts and ends with `/` is a regular expression literal; every other entry is a plain path and is
+ * always valid. An invalid entry does not throw when assigned to {@link PathSettings} — the whole list falls back to
+ * its default pattern instead — so this validator is what surfaces the problem to the user.
+ *
+ * @param paths - The path entries to validate.
+ * @returns A message naming the first invalid entry, or nothing when every entry is valid.
+ */
+export declare function pathsValidator(paths: string[]): MaybeReturn<string>;