@mnaoumov/typescript-lib 0.0.0 → 1.0.0

package/dist/lib/esm/path.d.mts

@@ -0,0 +1,154 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for handling paths.
+ */
+import pathBrowserify from 'path-browserify';
+/**
+ * Provides methods for handling POSIX paths.
+ */
+export declare const posix: pathBrowserify.Path;
+/**
+ * A POSIX path delimiter.
+ */
+export declare const delimiter: string;
+/**
+ * A POSIX segment separator.
+ */
+export declare const separator: string;
+/**
+ * Returns the base name of a file, optionally removing the file extension.
+ *
+ * @param path - The path to get the base name from.
+ * @param ext - An optional extension to remove from the base name.
+ * @returns The base name of the file.
+ */
+export declare const basename: (this: void, path: string, ext?: string) => string;
+/**
+ * Returns the directory name of a path.
+ *
+ * `directory` is used instead of `folder` to preserve compatibility with `node:path` module.
+ *
+ * @param path - The path to get the directory name from.
+ * @returns The directory name of the path.
+ */
+export declare const dirname: (this: void, path: string) => string;
+/**
+ * Returns the file extension of a path.
+ *
+ * @param path - The path to get the extension from.
+ * @returns The file extension of the path.
+ */
+export declare const extname: (this: void, path: string) => string;
+/**
+ * Formats a path object into a path string.
+ *
+ * @param pathObject - The path object to format.
+ * @returns The formatted path string.
+ */
+export declare const format: (this: void, pathObject: Partial<pathBrowserify.PathObject>) => string;
+/**
+ * Determines if a path is absolute.
+ *
+ * @param path - The path to check.
+ * @returns `true` if the path is absolute, `false` otherwise.
+ */
+export declare function isAbsolute(path: string): boolean;
+/**
+ * Joins multiple path segments into a single path.
+ *
+ * @param paths - The path segments to join.
+ * @returns The joined path.
+ */
+export declare const join: (this: void, ...paths: string[]) => string;
+/**
+ * Normalizes a path, resolving '..' and '.' segments.
+ *
+ * @param path - The path to normalize.
+ * @returns The normalized path.
+ */
+export declare const normalizePath: (this: void, path: string) => string;
+/**
+ * Parses a path string into a path object.
+ *
+ * @param path - The path string to parse.
+ * @returns The parsed path object.
+ */
+export declare const parse: (this: void, path: string) => pathBrowserify.PathObject;
+/**
+ * Parameters for {@link makeFileName}.
+ */
+export interface MakeFileNameParams {
+    /**
+     * The file name to append the extension to.
+     */
+    readonly fileBaseName: string;
+    /**
+     * The extension to append to the file name.
+     */
+    readonly fileExtension: string;
+}
+/**
+ * Gets the file name from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.
+ *
+ * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the file name.
+ * @returns The POSIX-style file name.
+ */
+export declare function getFileName(importMetaUrl: string): string;
+/**
+ * Gets the folder name from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.
+ *
+ * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the folder name.
+ * @returns The POSIX-style folder name.
+ */
+export declare function getFolderName(importMetaUrl: string): string;
+/**
+ * Makes a file name by appending an extension to a given file name.
+ * If the extension is empty, the file name is returned as is.
+ *
+ * @param params - The parameters for making the file name.
+ * @returns The file name with the extension appended.
+ */
+export declare function makeFileName(params: MakeFileNameParams): string;
+/**
+ * Normalizes a given path by ensuring it is relative, adding "./" if necessary.
+ *
+ * @param path - The path to normalize.
+ * @returns The normalized path, starting with "./" if it was relative.
+ */
+export declare function normalizeIfRelative(path: string): string;
+/**
+ * Returns the relative path from one path to another.
+ *
+ * `path-browserify`'s own `relative` cannot be used directly: it resolves a relative argument against
+ * `process.cwd()`, which on Windows is `F:\...` rather than a POSIX absolute path, and its slicing then assumes a
+ * leading `/` - so `relative('src', '../x')` came back as `'../..x'`. Both arguments are resolved through
+ * {@link resolve} here instead, and rooted at `/` before the POSIX comparison.
+ *
+ * @param from - The starting path.
+ * @param to - The destination path.
+ * @returns The relative path from `from` to `to`.
+ */
+export declare function relative(from: string, to: string): string;
+/**
+ * Resolves a sequence of paths or path segments into an absolute path.
+ *
+ * @param pathSegments - The sequence of path segments to resolve.
+ * @returns The resolved absolute path.
+ */
+export declare function resolve(...pathSegments: string[]): string;
+/**
+ * Converts a buffer containing a path to a POSIX-style buffer by replacing backslashes with forward slashes.
+ *
+ * @param buffer - The buffer to convert.
+ * @returns A new buffer containing the POSIX-style path.
+ */
+export declare function toPosixBuffer(buffer: Buffer): Buffer;
+/**
+ * Converts a given path to a POSIX-style path by replacing backslashes with forward slashes.
+ *
+ * @param path - The path to convert.
+ * @returns The POSIX-style path.
+ */
+export declare function toPosixPath(path: string): string;

package/dist/lib/esm/path.mjs

@@ -0,0 +1,139 @@
+/*
+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 pathBrowserify from "path-browserify";
+import {
+  ensureStartsWith,
+  replaceAll
+} from "./string.mjs";
+const WINDOWS_DRIVE_REG_EXP = /^[a-zA-Z]:\//;
+const WINDOWS_POSIX_LIKE_PATH_REG_EXP = /[a-zA-Z]:\/[^:]*$/;
+const posix = pathBrowserify.posix;
+const delimiter = posix.delimiter;
+const separator = pathBrowserify.posix.sep;
+const basename = posix.basename;
+const dirname = posix.dirname;
+const extname = posix.extname;
+const format = posix.format;
+function isAbsolute(path) {
+  return posix.isAbsolute(path) || WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path)?.[0] === path;
+}
+const join = posix.join;
+const normalizePath = posix.normalize;
+const parse = posix.parse;
+function getFileName(importMetaUrl) {
+  return resolve(decodeURI(new URL(importMetaUrl).pathname));
+}
+function getFolderName(importMetaUrl) {
+  return dirname(getFileName(importMetaUrl));
+}
+function makeFileName(params) {
+  return params.fileExtension ? `${params.fileBaseName}.${params.fileExtension}` : params.fileBaseName;
+}
+function normalizeIfRelative(path) {
+  return path.startsWith("/") || path.includes(":") ? path : ensureStartsWith({
+    $string: path,
+    prefix: "./"
+  });
+}
+function relative(from, to) {
+  const resolvedFrom = resolve(from);
+  const resolvedTo = resolve(to);
+  const fromDrive = WINDOWS_DRIVE_REG_EXP.exec(resolvedFrom)?.[0].toUpperCase();
+  const toDrive = WINDOWS_DRIVE_REG_EXP.exec(resolvedTo)?.[0].toUpperCase();
+  return fromDrive === toDrive ? posix.relative(toRootedPosixPath(upperCaseDrive(resolvedFrom)), toRootedPosixPath(upperCaseDrive(resolvedTo))) : resolvedTo;
+}
+function resolve(...pathSegments) {
+  const rootedSegments = pathSegments.map((segment) => toRootedPosixPath(segment));
+  if (rootedSegments.every((segment) => !segment.startsWith("/"))) {
+    rootedSegments.unshift(toRootedPosixPath(process.cwd()));
+  }
+  const path = posix.resolve(...rootedSegments);
+  const match = WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path);
+  return match?.[0] ?? path;
+}
+function toPosixBuffer(buffer) {
+  return Buffer.from(toPosixPath(String(buffer)));
+}
+function toPosixPath(path) {
+  return replaceAll({
+    $string: path,
+    replacer: "/",
+    searchValue: "\\"
+  });
+}
+function toRootedPosixPath(path) {
+  const posixPath = toPosixPath(path);
+  return WINDOWS_DRIVE_REG_EXP.test(posixPath) ? `/${posixPath}` : posixPath;
+}
+function upperCaseDrive(path) {
+  return path.replace(WINDOWS_DRIVE_REG_EXP, (drive) => drive.toUpperCase());
+}
+export {
+  basename,
+  delimiter,
+  dirname,
+  extname,
+  format,
+  getFileName,
+  getFolderName,
+  isAbsolute,
+  join,
+  makeFileName,
+  normalizeIfRelative,
+  normalizePath,
+  parse,
+  posix,
+  relative,
+  resolve,
+  separator,
+  toPosixBuffer,
+  toPosixPath
+};
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/path.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for handling paths.\n */\n\nimport pathBrowserify from 'path-browserify';\n\nimport {\n  ensureStartsWith,\n  replaceAll\n} from './string.ts';\n\nconst WINDOWS_DRIVE_REG_EXP = /^[a-zA-Z]:\\//;\nconst WINDOWS_POSIX_LIKE_PATH_REG_EXP = /[a-zA-Z]:\\/[^:]*$/;\n\n/**\n * Provides methods for handling POSIX paths.\n */\nexport const posix = pathBrowserify.posix;\n\n/**\n * A POSIX path delimiter.\n */\nexport const delimiter = posix.delimiter;\n\n/**\n * A POSIX segment separator.\n */\nexport const separator = pathBrowserify.posix.sep;\n\n/**\n * Returns the base name of a file, optionally removing the file extension.\n *\n * @param path - The path to get the base name from.\n * @param ext - An optional extension to remove from the base name.\n * @returns The base name of the file.\n */\nexport const basename = posix.basename;\n\n/**\n * Returns the directory name of a path.\n *\n * `directory` is used instead of `folder` to preserve compatibility with `node:path` module.\n *\n * @param path - The path to get the directory name from.\n * @returns The directory name of the path.\n */\nexport const dirname = posix.dirname;\n\n/**\n * Returns the file extension of a path.\n *\n * @param path - The path to get the extension from.\n * @returns The file extension of the path.\n */\nexport const extname = posix.extname;\n\n/**\n * Formats a path object into a path string.\n *\n * @param pathObject - The path object to format.\n * @returns The formatted path string.\n */\nexport const format = posix.format;\n\n/**\n * Determines if a path is absolute.\n *\n * @param path - The path to check.\n * @returns `true` if the path is absolute, `false` otherwise.\n */\nexport function isAbsolute(path: string): boolean {\n  return posix.isAbsolute(path) || WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path)?.[0] === path;\n}\n\n/**\n * Joins multiple path segments into a single path.\n *\n * @param paths - The path segments to join.\n * @returns The joined path.\n */\nexport const join = posix.join;\n\n/**\n * Normalizes a path, resolving '..' and '.' segments.\n *\n * @param path - The path to normalize.\n * @returns The normalized path.\n */\nexport const normalizePath = posix.normalize;\n\n/**\n * Parses a path string into a path object.\n *\n * @param path - The path string to parse.\n * @returns The parsed path object.\n */\nexport const parse = posix.parse;\n\n/**\n * Parameters for {@link makeFileName}.\n */\nexport interface MakeFileNameParams {\n  /**\n   * The file name to append the extension to.\n   */\n  readonly fileBaseName: string;\n\n  /**\n   * The extension to append to the file name.\n   */\n  readonly fileExtension: string;\n}\n\n/**\n * Gets the file name from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.\n *\n * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the file name.\n * @returns The POSIX-style file name.\n */\nexport function getFileName(importMetaUrl: string): string {\n  return resolve(decodeURI(new URL(importMetaUrl).pathname));\n}\n\n/**\n * Gets the folder name from the `import(dot)meta(dot)url`, converting it to a POSIX-style path.\n *\n * @param importMetaUrl - The `import(dot)meta(dot)url` from which to extract the folder name.\n * @returns The POSIX-style folder name.\n */\nexport function getFolderName(importMetaUrl: string): string {\n  return dirname(getFileName(importMetaUrl));\n}\n\n/**\n * Makes a file name by appending an extension to a given file name.\n * If the extension is empty, the file name is returned as is.\n *\n * @param params - The parameters for making the file name.\n * @returns The file name with the extension appended.\n */\nexport function makeFileName(params: MakeFileNameParams): string {\n  return params.fileExtension ? `${params.fileBaseName}.${params.fileExtension}` : params.fileBaseName;\n}\n\n/**\n * Normalizes a given path by ensuring it is relative, adding \"./\" if necessary.\n *\n * @param path - The path to normalize.\n * @returns The normalized path, starting with \"./\" if it was relative.\n */\nexport function normalizeIfRelative(path: string): string {\n  return path.startsWith('/') || path.includes(':')\n    ? path\n    : ensureStartsWith({\n      $string: path,\n      prefix: './'\n    });\n}\n\n/**\n * Returns the relative path from one path to another.\n *\n * `path-browserify`'s own `relative` cannot be used directly: it resolves a relative argument against\n * `process.cwd()`, which on Windows is `F:\\...` rather than a POSIX absolute path, and its slicing then assumes a\n * leading `/` - so `relative('src', '../x')` came back as `'../..x'`. Both arguments are resolved through\n * {@link resolve} here instead, and rooted at `/` before the POSIX comparison.\n *\n * @param from - The starting path.\n * @param to - The destination path.\n * @returns The relative path from `from` to `to`.\n */\nexport function relative(from: string, to: string): string {\n  const resolvedFrom = resolve(from);\n  const resolvedTo = resolve(to);\n  const fromDrive = WINDOWS_DRIVE_REG_EXP.exec(resolvedFrom)?.[0].toUpperCase();\n  const toDrive = WINDOWS_DRIVE_REG_EXP.exec(resolvedTo)?.[0].toUpperCase();\n  return fromDrive === toDrive\n    ? posix.relative(toRootedPosixPath(upperCaseDrive(resolvedFrom)), toRootedPosixPath(upperCaseDrive(resolvedTo)))\n    : resolvedTo;\n}\n\n/**\n * Resolves a sequence of paths or path segments into an absolute path.\n *\n * @param pathSegments - The sequence of path segments to resolve.\n * @returns The resolved absolute path.\n */\nexport function resolve(...pathSegments: string[]): string {\n  /*\n   * `path-browserify` treats only a leading `/` as absolute and joins `process.cwd()` in as an opaque segment, so on\n   * Windows a `..` climbing out of the working folder cancelled the whole `F:\\...` cwd. Every segment is made POSIX\n   * and a drive root is given a leading `/`, which makes it a root `path-browserify` understands; the `/` is dropped\n   * again below.\n   */\n  const rootedSegments = pathSegments.map((segment) => toRootedPosixPath(segment));\n  if (rootedSegments.every((segment) => !segment.startsWith('/'))) {\n    rootedSegments.unshift(toRootedPosixPath(process.cwd()));\n  }\n  const path = posix.resolve(...rootedSegments);\n  const match = WINDOWS_POSIX_LIKE_PATH_REG_EXP.exec(path);\n  return match?.[0] ?? path;\n}\n\n/**\n * Converts a buffer containing a path to a POSIX-style buffer by replacing backslashes with forward slashes.\n *\n * @param buffer - The buffer to convert.\n * @returns A new buffer containing the POSIX-style path.\n */\nexport function toPosixBuffer(buffer: Buffer): Buffer {\n  return Buffer.from(toPosixPath(String(buffer)));\n}\n\n/**\n * Converts a given path to a POSIX-style path by replacing backslashes with forward slashes.\n *\n * @param path - The path to convert.\n * @returns The POSIX-style path.\n */\nexport function toPosixPath(path: string): string {\n  return replaceAll({\n    $string: path,\n    replacer: '/',\n    searchValue: '\\\\'\n  });\n}\n\nfunction toRootedPosixPath(path: string): string {\n  const posixPath = toPosixPath(path);\n  return WINDOWS_DRIVE_REG_EXP.test(posixPath) ? `/${posixPath}` : posixPath;\n}\n\nfunction upperCaseDrive(path: string): string {\n  return path.replace(WINDOWS_DRIVE_REG_EXP, (drive) => drive.toUpperCase());\n}\n"],
  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAMA,OAAO,oBAAoB;AAE3B;AAAA,EACE;AAAA,EACA;AAAA,OACK;AAEP,MAAM,wBAAwB;AAC9B,MAAM,kCAAkC;AAKjC,MAAM,QAAQ,eAAe;AAK7B,MAAM,YAAY,MAAM;AAKxB,MAAM,YAAY,eAAe,MAAM;AASvC,MAAM,WAAW,MAAM;AAUvB,MAAM,UAAU,MAAM;AAQtB,MAAM,UAAU,MAAM;AAQtB,MAAM,SAAS,MAAM;AAQrB,SAAS,WAAW,MAAuB;AAChD,SAAO,MAAM,WAAW,IAAI,KAAK,gCAAgC,KAAK,IAAI,IAAI,CAAC,MAAM;AACvF;AAQO,MAAM,OAAO,MAAM;AAQnB,MAAM,gBAAgB,MAAM;AAQ5B,MAAM,QAAQ,MAAM;AAuBpB,SAAS,YAAY,eAA+B;AACzD,SAAO,QAAQ,UAAU,IAAI,IAAI,aAAa,EAAE,QAAQ,CAAC;AAC3D;AAQO,SAAS,cAAc,eAA+B;AAC3D,SAAO,QAAQ,YAAY,aAAa,CAAC;AAC3C;AASO,SAAS,aAAa,QAAoC;AAC/D,SAAO,OAAO,gBAAgB,GAAG,OAAO,YAAY,IAAI,OAAO,aAAa,KAAK,OAAO;AAC1F;AAQO,SAAS,oBAAoB,MAAsB;AACxD,SAAO,KAAK,WAAW,GAAG,KAAK,KAAK,SAAS,GAAG,IAC5C,OACA,iBAAiB;AAAA,IACjB,SAAS;AAAA,IACT,QAAQ;AAAA,EACV,CAAC;AACL;AAcO,SAAS,SAAS,MAAc,IAAoB;AACzD,QAAM,eAAe,QAAQ,IAAI;AACjC,QAAM,aAAa,QAAQ,EAAE;AAC7B,QAAM,YAAY,sBAAsB,KAAK,YAAY,IAAI,CAAC,EAAE,YAAY;AAC5E,QAAM,UAAU,sBAAsB,KAAK,UAAU,IAAI,CAAC,EAAE,YAAY;AACxE,SAAO,cAAc,UACjB,MAAM,SAAS,kBAAkB,eAAe,YAAY,CAAC,GAAG,kBAAkB,eAAe,UAAU,CAAC,CAAC,IAC7G;AACN;AAQO,SAAS,WAAW,cAAgC;AAOzD,QAAM,iBAAiB,aAAa,IAAI,CAAC,YAAY,kBAAkB,OAAO,CAAC;AAC/E,MAAI,eAAe,MAAM,CAAC,YAAY,CAAC,QAAQ,WAAW,GAAG,CAAC,GAAG;AAC/D,mBAAe,QAAQ,kBAAkB,QAAQ,IAAI,CAAC,CAAC;AAAA,EACzD;AACA,QAAM,OAAO,MAAM,QAAQ,GAAG,cAAc;AAC5C,QAAM,QAAQ,gCAAgC,KAAK,IAAI;AACvD,SAAO,QAAQ,CAAC,KAAK;AACvB;AAQO,SAAS,cAAc,QAAwB;AACpD,SAAO,OAAO,KAAK,YAAY,OAAO,MAAM,CAAC,CAAC;AAChD;AAQO,SAAS,YAAY,MAAsB;AAChD,SAAO,WAAW;AAAA,IAChB,SAAS;AAAA,IACT,UAAU;AAAA,IACV,aAAa;AAAA,EACf,CAAC;AACH;AAEA,SAAS,kBAAkB,MAAsB;AAC/C,QAAM,YAAY,YAAY,IAAI;AAClC,SAAO,sBAAsB,KAAK,SAAS,IAAI,IAAI,SAAS,KAAK;AACnE;AAEA,SAAS,eAAe,MAAsB;AAC5C,SAAO,KAAK,QAAQ,uBAAuB,CAAC,UAAU,MAAM,YAAY,CAAC;AAC3E;",
  "names": []
}


package/dist/lib/esm/reg-exp.d.mts

@@ -0,0 +1,87 @@
+/// <reference path="./library.d.mts" />
+/**
+ * @file
+ *
+ * Contains utility functions for regular expressions.
+ */
+/**
+ * A strategy to use when merging multiple regex flags into one alternation.
+ */
+export declare enum RegExpMergeFlagsConflictStrategy {
+    /**
+     * Keep only the flags present in all regexes.
+     */
+    Intersect = "Intersect",
+    /**
+     * Throw an error if the regexes have conflicting flags.
+     */
+    Throw = "Throw",
+    /**
+     * Keep only the flags present in any regex.
+     */
+    Union = "Union"
+}
+/**
+ * Escapes special characters in a string to safely use it within a regular expression.
+ *
+ * @param $string - The string to escape.
+ * @returns The escaped string with special characters prefixed with a backslash.
+ */
+export declare function escapeRegExp($string: 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.
+ *
+ * @param $string - The string to check.
+ * @returns `true` if the string is a valid regular expression, `false` otherwise.
+ */
+export declare function isValidRegExp($string: string): boolean;
+/**
+ * A regular expression that always matches.
+ */
+export declare const ALWAYS_MATCH_REG_EXP: RegExp;
+/**
+ * A regular expression that never matches.
+ */
+export declare const NEVER_MATCH_REG_EXP: RegExp;
+/**
+ * Combine multiple regexes into one alternation, handling flags.
+ *
+ * @param regExps - The regexes to combine.
+ * @param strategy - The strategy to use when merging flags (default: `RegExpMergeFlagsConflictStrategy.Throw`).
+ * @returns The combined regex.
+ */
+export declare function oneOf(regExps: RegExp[], strategy?: RegExpMergeFlagsConflictStrategy): RegExp;

package/dist/lib/esm/reg-exp.mjs

@@ -0,0 +1,213 @@
+/*
+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 {
+  assert,
+  assertNever,
+  ensureNonNullable
+} from "./type-guards.mjs";
+var RegExpMergeFlagsConflictStrategy = /* @__PURE__ */ ((RegExpMergeFlagsConflictStrategy2) => {
+  RegExpMergeFlagsConflictStrategy2["Intersect"] = "Intersect";
+  RegExpMergeFlagsConflictStrategy2["Throw"] = "Throw";
+  RegExpMergeFlagsConflictStrategy2["Union"] = "Union";
+  return RegExpMergeFlagsConflictStrategy2;
+})(RegExpMergeFlagsConflictStrategy || {});
+function escapeRegExp($string) {
+  return $string.replaceAll(/[.*+?^${}()|[\]\\]/g, String.raw`\$&`);
+}
+function getMandatoryNamedGroup(match, groupName) {
+  return ensureNonNullable(getOptionalNamedGroup(match, groupName));
+}
+function getOptionalNamedGroup(match, groupName) {
+  return match.groups?.[groupName] ?? null;
+}
+function isValidRegExp($string) {
+  try {
+    new RegExp($string);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function hasFlag(regExp, flag) {
+  return regExp.flags.includes(flag);
+}
+const ALWAYS_MATCH_REG_EXP = /(?:)/;
+const NEVER_MATCH_REG_EXP = /.^/;
+class RegExpFlagMerger {
+  /**
+   * Creates a new merger.
+   *
+   * @param regExps - The regexes whose flags are merged.
+   * @param strategy - The strategy to use when flags conflict.
+   */
+  constructor(regExps, strategy) {
+    this.regExps = regExps;
+    this.strategy = strategy;
+  }
+  regExps;
+  strategy;
+  finalFlags = /* @__PURE__ */ new Set();
+  /**
+   * Computes the merged flag string for the configured regexes.
+   *
+   * @returns The merged flags joined into a single string.
+   */
+  computeFlags() {
+    this.addSemanticFlags();
+    this.addUnicodeFlags();
+    this.addMetaFlags();
+    return [...this.finalFlags].join("");
+  }
+  addMetaFlags() {
+    const META_FLAGS = ["g", "d"];
+    for (const flag of META_FLAGS) {
+      if (this.regExps.some((regExp) => hasFlag(regExp, flag))) {
+        this.finalFlags.add(flag);
+      }
+    }
+  }
+  addSemanticFlags() {
+    const SEMANTIC_FLAGS = ["i", "m", "s", "y"];
+    for (const flag of SEMANTIC_FLAGS) {
+      if (this.shouldPickFlag(flag)) {
+        this.finalFlags.add(flag);
+      }
+    }
+  }
+  addUnicodeFlags() {
+    const countU = this.regExps.filter((regExp) => hasFlag(regExp, "u")).length;
+    const countV = this.regExps.filter((regExp) => hasFlag(regExp, "v")).length;
+    let shouldUseUFlag;
+    let shouldUseVFlag;
+    switch (this.strategy) {
+      /* v8 ignore stop */
+      case "Intersect" /* Intersect */: {
+        shouldUseUFlag = countU === this.regExps.length;
+        shouldUseVFlag = countV === this.regExps.length;
+        break;
+      }
+      case "Throw" /* Throw */: {
+        const haveAllUFlag = countU === this.regExps.length;
+        const haveNoUFlag = countU === 0;
+        const haveAllVFlag = countV === this.regExps.length;
+        const haveNoVFlag = countV === 0;
+        if (!(haveAllUFlag || haveNoUFlag) || !(haveAllVFlag || haveNoVFlag)) {
+          throw new Error("Conflicting 'u'/'v' flags across patterns.");
+        }
+        shouldUseUFlag = haveAllUFlag;
+        shouldUseVFlag = haveAllVFlag;
+        break;
+      }
+      case "Union" /* Union */: {
+        shouldUseUFlag = countU > 0;
+        shouldUseVFlag = countV > 0;
+        break;
+      }
+      default: {
+        assertNever(this.strategy);
+      }
+    }
+    if (shouldUseUFlag && shouldUseVFlag) {
+      assert(this.strategy !== "Throw" /* Throw */, "Cannot combine both 'u'/'v' flags in one RegExp.");
+      shouldUseUFlag = false;
+    }
+    if (shouldUseUFlag) {
+      this.finalFlags.add("u");
+    }
+    if (shouldUseVFlag) {
+      this.finalFlags.add("v");
+    }
+  }
+  shouldPickFlag(flag) {
+    const count = this.regExps.filter((regExp) => hasFlag(regExp, flag)).length;
+    switch (this.strategy) {
+      /* v8 ignore stop */
+      case "Intersect" /* Intersect */: {
+        return count === this.regExps.length;
+      }
+      case "Throw" /* Throw */: {
+        break;
+      }
+      case "Union" /* Union */: {
+        return count > 0;
+      }
+      default: {
+        assertNever(this.strategy);
+      }
+    }
+    const haveAllSameFlag = count === 0 || count === this.regExps.length;
+    if (!haveAllSameFlag) {
+      throw new Error(`Conflicting flag '${flag}' across patterns.`);
+    }
+    return count === this.regExps.length;
+  }
+}
+function oneOf(regExps, strategy = "Throw" /* Throw */) {
+  if (regExps.length === 0) {
+    return ALWAYS_MATCH_REG_EXP;
+  }
+  if (regExps.length === 1 && regExps[0] !== void 0) {
+    return regExps[0];
+  }
+  const source = regExps.map((regExp) => `(?:${regExp.source})`).join("|");
+  const flags = new RegExpFlagMerger(regExps, strategy).computeFlags();
+  return new RegExp(source, flags);
+}
+export {
+  ALWAYS_MATCH_REG_EXP,
+  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  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 $string - The string to escape.\n * @returns The escaped string with special characters prefixed with a backslash.\n */\nexport function escapeRegExp($string: string): string {\n  // NOTE: We can't use `replaceAll()` from `String.ts` here because it introduces a circular dependency.\n  return $string.replaceAll(/[.*+?^${}()|[\\]\\\\]/g, String.raw`\\$&`);\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 $string - The string to check.\n * @returns `true` if the string is a valid regular expression, `false` otherwise.\n */\nexport function isValidRegExp($string: string): boolean {\n  try {\n    new RegExp($string);\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      }\n      case RegExpMergeFlagsConflictStrategy.Throw: {\n        const haveAllUFlag = countU === this.regExps.length;\n        const haveNoUFlag = countU === 0;\n        const haveAllVFlag = countV === this.regExps.length;\n        const haveNoVFlag = countV === 0;\n\n        if (!(haveAllUFlag || haveNoUFlag) || !(haveAllVFlag || haveNoVFlag)) {\n          throw new Error('Conflicting \\'u\\'/\\'v\\' flags across patterns.');\n        }\n\n        shouldUseUFlag = haveAllUFlag;\n        shouldUseVFlag = haveAllVFlag;\n        break;\n      }\n      case RegExpMergeFlagsConflictStrategy.Union: {\n        shouldUseUFlag = countU > 0;\n        shouldUseVFlag = countV > 0;\n        break;\n      }\n      default: {\n        /* v8 ignore start -- Exhaustive switch guard. */\n        assertNever(this.strategy);\n      }\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      }\n      case RegExpMergeFlagsConflictStrategy.Throw: {\n        break;\n      }\n      case RegExpMergeFlagsConflictStrategy.Union: {\n        return count > 0;\n      }\n      default: {\n        /* v8 ignore start -- Exhaustive switch guard. */\n        assertNever(this.strategy);\n      }\n        /* v8 ignore stop */\n    }\n\n    const haveAllSameFlag = count === 0 || count === this.regExps.length;\n    if (!haveAllSameFlag) {\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"]
}
