@mnaoumov/typescript-lib 0.0.0 → 1.0.0

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

@@ -0,0 +1,254 @@
+/*
+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 keepName($unknown) {
+  return $unknown;
+}
+
+(function initCjs() {
+  // eslint-disable-next-line obsidianmd/no-global-this -- Actively use globalThis.
+  const globalThisRecord = globalThis;
+  ensureDisposeSymbols();
+  globalThisRecord['__name'] ??= keepName;
+  globalThisRecord['__extractDefault'] ??= extractDefault;
+
+  ensureBrowserProcess();
+
+  // eslint-disable-next-line unicorn/consistent-function-scoping -- Serialized with initCjs into the banner; at module scope it would be left out of it.
+  function extractDefault(module) {
+    return module && module.__esModule && 'default' in module ? module.default : module;
+  }
+})();
+})();
+
+"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 reg_exp_exports = {};
+__export(reg_exp_exports, {
+  ALWAYS_MATCH_REG_EXP: () => ALWAYS_MATCH_REG_EXP,
+  NEVER_MATCH_REG_EXP: () => NEVER_MATCH_REG_EXP,
+  RegExpMergeFlagsConflictStrategy: () => RegExpMergeFlagsConflictStrategy,
+  escapeRegExp: () => escapeRegExp,
+  getMandatoryNamedGroup: () => getMandatoryNamedGroup,
+  getOptionalNamedGroup: () => getOptionalNamedGroup,
+  isValidRegExp: () => isValidRegExp,
+  oneOf: () => oneOf
+});
+module.exports = __toCommonJS(reg_exp_exports);
+var import_type_guards = require('./type-guards.cjs');
+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 (0, import_type_guards.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: {
+        (0, import_type_guards.assertNever)(this.strategy);
+      }
+    }
+    if (shouldUseUFlag && shouldUseVFlag) {
+      (0, import_type_guards.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: {
+        (0, import_type_guards.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);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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"]
}


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

@@ -0,0 +1,87 @@
+/// <reference path="./library.d.cts" />
+/**
+ * @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;