@mnaoumov/typescript-lib 0.0.0 → 1.0.1

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

@@ -0,0 +1,196 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"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": ";;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAMA,yBAIO;AAKA,IAAK,mCAAL,kBAAKA,sCAAL;AAIL,EAAAA,kCAAA,eAAY;AAIZ,EAAAA,kCAAA,WAAQ;AAIR,EAAAA,kCAAA,WAAQ;AAZE,SAAAA;AAAA,GAAA;AAqBL,SAAS,aAAa,SAAyB;AAEpD,SAAO,QAAQ,WAAW,uBAAuB,OAAO,QAAQ;AAClE;AAoBO,SAAS,uBAAuB,OAAyB,WAA2B;AACzF,aAAO,sCAAkB,sBAAsB,OAAO,SAAS,CAAC;AAClE;AAgBO,SAAS,sBAAsB,OAAyB,WAAkC;AAC/F,SAAO,MAAM,SAAS,SAAS,KAAK;AACtC;AAQO,SAAS,cAAc,SAA0B;AACtD,MAAI;AACF,QAAI,OAAO,OAAO;AAClB,WAAO;AAAA,EACT,QAAQ;AACN,WAAO;AAAA,EACT;AACF;AAEA,SAAS,QAAQ,QAAgB,MAAuB;AACtD,SAAO,OAAO,MAAM,SAAS,IAAI;AACnC;AAKO,MAAM,uBAAuB;AAK7B,MAAM,sBAAsB;AASnC,MAAM,iBAAiB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASd,YAA6B,SAAoC,UAA4C;AAAhF;AAAoC;AAAA,EAA6C;AAAA,EAAjF;AAAA,EAAoC;AAAA,EARvD,aAAa,oBAAI,IAAY;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAevC,eAAuB;AAC5B,SAAK,iBAAiB;AACtB,SAAK,gBAAgB;AACrB,SAAK,aAAa;AAClB,WAAO,CAAC,GAAG,KAAK,UAAU,EAAE,KAAK,EAAE;AAAA,EACrC;AAAA,EAEQ,eAAqB;AAC3B,UAAM,aAAa,CAAC,KAAK,GAAG;AAC5B,eAAW,QAAQ,YAAY;AAC7B,UAAI,KAAK,QAAQ,KAAK,CAAC,WAAW,QAAQ,QAAQ,IAAI,CAAC,GAAG;AACxD,aAAK,WAAW,IAAI,IAAI;AAAA,MAC1B;AAAA,IACF;AAAA,EACF;AAAA,EAEQ,mBAAyB;AAC/B,UAAM,iBAAiB,CAAC,KAAK,KAAK,KAAK,GAAG;AAC1C,eAAW,QAAQ,gBAAgB;AACjC,UAAI,KAAK,eAAe,IAAI,GAAG;AAC7B,aAAK,WAAW,IAAI,IAAI;AAAA,MAC1B;AAAA,IACF;AAAA,EACF;AAAA,EAEQ,kBAAwB;AAC9B,UAAM,SAAS,KAAK,QAAQ,OAAO,CAAC,WAAW,QAAQ,QAAQ,GAAG,CAAC,EAAE;AACrE,UAAM,SAAS,KAAK,QAAQ,OAAO,CAAC,WAAW,QAAQ,QAAQ,GAAG,CAAC,EAAE;AAErE,QAAI;AACJ,QAAI;AAGJ,YAAQ,KAAK,UAAU;AAAA;AAAA,MAErB,KAAK,6BAA4C;AAC/C,yBAAiB,WAAW,KAAK,QAAQ;AACzC,yBAAiB,WAAW,KAAK,QAAQ;AACzC;AAAA,MACF;AAAA,MACA,KAAK,qBAAwC;AAC3C,cAAM,eAAe,WAAW,KAAK,QAAQ;AAC7C,cAAM,cAAc,WAAW;AAC/B,cAAM,eAAe,WAAW,KAAK,QAAQ;AAC7C,cAAM,cAAc,WAAW;AAE/B,YAAI,EAAE,gBAAgB,gBAAgB,EAAE,gBAAgB,cAAc;AACpE,gBAAM,IAAI,MAAM,4CAAgD;AAAA,QAClE;AAEA,yBAAiB;AACjB,yBAAiB;AACjB;AAAA,MACF;AAAA,MACA,KAAK,qBAAwC;AAC3C,yBAAiB,SAAS;AAC1B,yBAAiB,SAAS;AAC1B;AAAA,MACF;AAAA,MACA,SAAS;AAEP,4CAAY,KAAK,QAAQ;AAAA,MAC3B;AAAA,IAEF;AAEA,QAAI,kBAAkB,gBAAgB;AACpC,qCAAO,KAAK,aAAa,qBAAwC,kDAAsD;AACvH,uBAAiB;AAAA,IACnB;AAEA,QAAI,gBAAgB;AAClB,WAAK,WAAW,IAAI,GAAG;AAAA,IACzB;AACA,QAAI,gBAAgB;AAClB,WAAK,WAAW,IAAI,GAAG;AAAA,IACzB;AAAA,EACF;AAAA,EAEQ,eAAe,MAAuB;AAC5C,UAAM,QAAQ,KAAK,QAAQ,OAAO,CAAC,WAAW,QAAQ,QAAQ,IAAI,CAAC,EAAE;AAErE,YAAQ,KAAK,UAAU;AAAA;AAAA,MAErB,KAAK,6BAA4C;AAC/C,eAAO,UAAU,KAAK,QAAQ;AAAA,MAChC;AAAA,MACA,KAAK,qBAAwC;AAC3C;AAAA,MACF;AAAA,MACA,KAAK,qBAAwC;AAC3C,eAAO,QAAQ;AAAA,MACjB;AAAA,MACA,SAAS;AAEP,4CAAY,KAAK,QAAQ;AAAA,MAC3B;AAAA,IAEF;AAEA,UAAM,kBAAkB,UAAU,KAAK,UAAU,KAAK,QAAQ;AAC9D,QAAI,CAAC,iBAAiB;AACpB,YAAM,IAAI,MAAM,qBAAqB,IAAI,oBAAoB;AAAA,IAC/D;AACA,WAAO,UAAU,KAAK,QAAQ;AAAA,EAChC;AACF;AASO,SAAS,MACd,SACA,WAA6C,qBACrC;AACR,MAAI,QAAQ,WAAW,GAAG;AACxB,WAAO;AAAA,EACT;AAEA,MAAI,QAAQ,WAAW,KAAK,QAAQ,CAAC,MAAM,QAAW;AACpD,WAAO,QAAQ,CAAC;AAAA,EAClB;AAEA,QAAM,SAAS,QAAQ,IAAI,CAAC,WAAW,MAAM,OAAO,MAAM,GAAG,EAAE,KAAK,GAAG;AACvE,QAAM,QAAQ,IAAI,iBAAiB,SAAS,QAAQ,EAAE,aAAa;AACnE,SAAO,IAAI,OAAO,QAAQ,KAAK;AACjC;",
  "names": ["RegExpMergeFlagsConflictStrategy"]
}


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

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

package/dist/lib/cjs/string.cjs

@@ -0,0 +1,268 @@
+/*
+THIS IS A GENERATED/BUNDLED FILE BY ESBUILD
+if you want to view the source, please visit the github repository of this plugin
+*/
+
+"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 string_exports = {};
+__export(string_exports, {
+  EMPTY: () => EMPTY,
+  ensureEndsWith: () => ensureEndsWith,
+  ensureLfEndings: () => ensureLfEndings,
+  ensureStartsWith: () => ensureStartsWith,
+  escape: () => escape,
+  getLfNormalizedOffsetToOriginalOffsetMapper: () => getLfNormalizedOffsetToOriginalOffsetMapper,
+  hasSingleOccurrence: () => hasSingleOccurrence,
+  indent: () => indent,
+  insertAt: () => insertAt,
+  makeValidVariableName: () => makeValidVariableName,
+  normalizeString: () => normalizeString,
+  replace: () => replace,
+  replaceAll: () => replaceAll,
+  replaceAllAsync: () => replaceAllAsync,
+  trimEnd: () => trimEnd,
+  trimStart: () => trimStart,
+  unescape: () => unescape,
+  unindent: () => unindent
+});
+module.exports = __toCommonJS(string_exports);
+var import_abort_controller = require('./abort-controller.cjs');
+var import_reg_exp = require('./reg-exp.cjs');
+var import_type_guards = require('./type-guards.cjs');
+var import_value_provider = require('./value-provider.cjs');
+const EMPTY = "";
+const ESCAPE_MAP = {
+  "\n": String.raw`\n`,
+  "\r": String.raw`\r`,
+  "	": String.raw`\t`,
+  "\b": String.raw`\b`,
+  "\f": String.raw`\f`,
+  "'": String.raw`\'`,
+  '"': String.raw`\"`,
+  "\\": "\\\\"
+};
+const CR = "\r";
+const LF = "\n";
+const NOT_FOUND_INDEX = -1;
+const UNESCAPE_MAP = {};
+for (const [key, value] of Object.entries(ESCAPE_MAP)) {
+  UNESCAPE_MAP[value] = key;
+}
+function ensureEndsWith(params) {
+  const { $string, suffix } = params;
+  return $string.endsWith(suffix) ? $string : $string + suffix;
+}
+function ensureLfEndings($string) {
+  return $string.replaceAll(/\r\n?/g, "\n");
+}
+function ensureStartsWith(params) {
+  const { $string, prefix } = params;
+  return $string.startsWith(prefix) ? $string : prefix + $string;
+}
+function escape($string) {
+  return replace($string, ESCAPE_MAP);
+}
+function getLfNormalizedOffsetToOriginalOffsetMapper($string) {
+  const lfOffsetToOriginalOffsetMap = [];
+  for (let index = 0; index < $string.length; index++) {
+    if ($string[index] === CR && $string[index + 1] === LF) {
+      lfOffsetToOriginalOffsetMap.push(index + 1);
+      index++;
+    } else {
+      lfOffsetToOriginalOffsetMap.push(index);
+    }
+  }
+  return (lfOffset) => {
+    if (lfOffset < 0) {
+      return lfOffset;
+    }
+    if (lfOffset >= lfOffsetToOriginalOffsetMap.length) {
+      return lfOffset - lfOffsetToOriginalOffsetMap.length + $string.length;
+    }
+    (0, import_type_guards.assert)(lfOffsetToOriginalOffsetMap[lfOffset] !== void 0, "Could not map offset");
+    return lfOffsetToOriginalOffsetMap[lfOffset];
+  };
+}
+function hasSingleOccurrence(params) {
+  const { $string, searchValue } = params;
+  const firstIndex = $string.indexOf(searchValue);
+  const lastIndex = $string.lastIndexOf(searchValue);
+  return firstIndex !== NOT_FOUND_INDEX && firstIndex === lastIndex;
+}
+function indent(params) {
+  const { prefix, text } = params;
+  return text.split("\n").map((line) => `${prefix}${line}`).join("\n");
+}
+function insertAt(params) {
+  const {
+    $string,
+    endIndex,
+    startIndex,
+    substring
+  } = params;
+  const effectiveEndIndex = endIndex ?? startIndex;
+  return $string.slice(0, startIndex) + substring + $string.slice(effectiveEndIndex);
+}
+function makeValidVariableName($string) {
+  return replaceAll({
+    $string,
+    replacer: "_",
+    searchValue: /[^a-zA-Z0-9_]/g
+  });
+}
+function normalizeString($string) {
+  return replaceAll({
+    $string,
+    replacer: " ",
+    // eslint-disable-next-line unicorn/prefer-unicode-code-point-escapes -- These are the conventional spellings for U+00A0 and U+202F. The code-point form is only unambiguous with the `u` flag, so taking the fix would also change how the pattern is parsed.
+    searchValue: /\u00A0|\u202F/g
+  }).normalize("NFC");
+}
+function replace($string, replacementsMap) {
+  const regExp = new RegExp(Object.keys(replacementsMap).map((source) => (0, import_reg_exp.escapeRegExp)(source)).join("|"), "g");
+  return replaceAll({
+    $string,
+    replacer: ({ substring: source }) => (0, import_type_guards.ensureNonNullable)(replacementsMap[source]),
+    searchValue: regExp
+  });
+}
+function replaceAll(params) {
+  const { $string, replacer } = params;
+  let { searchValue } = params;
+  if (replacer === void 0) {
+    return $string;
+  }
+  if (searchValue instanceof RegExp && !searchValue.global) {
+    searchValue = new RegExp(searchValue.source, `${searchValue.flags}g`);
+  }
+  return typeof replacer === "string" ? $string.replaceAll(searchValue, replacer) : $string.replaceAll(searchValue, (substring, ...$arguments) => {
+    const SOURCE_INDEX_OFFSET_FOR_GROUP_ARG = 2;
+    const hasGroupsArgument = typeof $arguments.at(-1) === "object";
+    const sourceIndex = hasGroupsArgument ? $arguments.length - SOURCE_INDEX_OFFSET_FOR_GROUP_ARG : $arguments.length - 1;
+    const replaceArguments = {
+      // eslint-disable-next-line no-restricted-syntax -- Can't avoid.
+      capturedGroupArguments: [],
+      groups: hasGroupsArgument ? $arguments.at(-1) : void 0,
+      missingGroupIndices: [],
+      offset: $arguments.at(sourceIndex - 1),
+      source: $arguments.at(sourceIndex),
+      substring
+    };
+    for (let index = 0; index < sourceIndex - 1; index++) {
+      const item = $arguments[index];
+      if (typeof item === "string") {
+        replaceArguments.capturedGroupArguments.push(item);
+      } else if (item === void 0) {
+        replaceArguments.missingGroupIndices.push(index);
+      }
+    }
+    return replacer(replaceArguments) ?? replaceArguments.substring;
+  });
+}
+async function replaceAllAsync(params) {
+  const { $string, replacer, searchValue } = params;
+  let { abortSignal } = params;
+  abortSignal ??= (0, import_abort_controller.abortSignalNever)();
+  abortSignal.throwIfAborted();
+  if (typeof replacer === "string") {
+    return replaceAll({
+      $string,
+      replacer,
+      searchValue
+    });
+  }
+  const replacementAsyncFns = [];
+  replaceAll({
+    $string,
+    replacer: ($arguments) => {
+      replacementAsyncFns.push(() => (0, import_value_provider.resolveValue)(replacer, { abortSignal, ...$arguments }));
+      return "";
+    },
+    searchValue
+  });
+  const replacements = [];
+  for (const asyncFunction of replacementAsyncFns) {
+    abortSignal.throwIfAborted();
+    replacements.push(await asyncFunction());
+  }
+  abortSignal.throwIfAborted();
+  return replaceAll({
+    $string,
+    replacer: ($arguments) => replacements.shift() ?? $arguments.substring,
+    searchValue
+  });
+}
+function trimEnd(params) {
+  const { $string, shouldValidate, suffix } = params;
+  if ($string.endsWith(suffix)) {
+    return $string.slice(0, -suffix.length);
+  }
+  if (shouldValidate) {
+    throw new Error(`String ${$string} does not end with suffix ${suffix}`);
+  }
+  return $string;
+}
+function trimStart(params) {
+  const { $string, prefix, shouldValidate } = params;
+  if ($string.startsWith(prefix)) {
+    return $string.slice(prefix.length);
+  }
+  if (shouldValidate) {
+    throw new Error(`String ${$string} does not start with prefix ${prefix}`);
+  }
+  return $string;
+}
+function unescape($string) {
+  return replace($string, UNESCAPE_MAP);
+}
+function unindent(params) {
+  const { prefix, shouldThrowIfNotIndented = false, text } = params;
+  return text.split("\n").map((line) => {
+    if (line.startsWith(prefix)) {
+      return line.slice(prefix.length);
+    }
+    if (shouldThrowIfNotIndented) {
+      throw new Error(`Line "${line}" is not indented with "${prefix}"`);
+    }
+    return line;
+  }).join("\n");
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  EMPTY,
+  ensureEndsWith,
+  ensureLfEndings,
+  ensureStartsWith,
+  escape,
+  getLfNormalizedOffsetToOriginalOffsetMapper,
+  hasSingleOccurrence,
+  indent,
+  insertAt,
+  makeValidVariableName,
+  normalizeString,
+  replace,
+  replaceAll,
+  replaceAllAsync,
+  trimEnd,
+  trimStart,
+  unescape,
+  unindent
+});
+//# sourceMappingURL=data:application/json;base64,{
  "version": 3,
  "sources": ["../../../src/string.ts"],
  "sourcesContent": ["/**\n * @file\n *\n * Contains utility functions for string operations.\n */\n\nimport type { MaybeReturn } from './type.ts';\nimport type { ValueProvider } from './value-provider.ts';\n\nimport { abortSignalNever } from './abort-controller.ts';\nimport { escapeRegExp } from './reg-exp.ts';\nimport {\n  assert,\n  ensureNonNullable\n} from './type-guards.ts';\nimport { resolveValue } from './value-provider.ts';\n\n/**\n * An empty string constant.\n *\n * A shared sentinel for the `${EMPTY}` prefix that silences the `obsidianmd/ui/sentence-case` ESLint\n * false positive on legitimate lower-case UI text (e.g. `cursor` colliding with the `Cursor` brand).\n * `setName(`${EMPTY}...at cursor...`)` renders byte-identical `''` at runtime while the `{...}`\n * placeholder makes the rule skip the string. Consumers import this instead of redefining a per-file\n * `const EMPTY = ''`.\n */\nexport const EMPTY = '';\n\n/**\n * A synchronous/asynchronous function that generates replacement strings, or a string to replace with.\n *\n * @typeParam CapturedGroupArguments - The types of the captured group arguments.\n */\nexport type AsyncReplacer<CapturedGroupArguments extends string[]> = ValueProvider<StringReplacement, ReplaceArguments<CapturedGroupArguments>>;\n\n/**\n * Common arguments for the `replaceAll`/`replaceAllAsync` functions.\n *\n * @typeParam CapturedGroupArguments - The types of the captured group arguments.\n */\nexport interface ReplaceArguments<CapturedGroupArguments extends string[]> {\n  /**\n   * Captured group arguments.\n   */\n  capturedGroupArguments: CapturedGroupArguments;\n\n  /**\n   * Groups of the match.\n   */\n  groups: Record<string, string | undefined> | undefined;\n\n  /**\n   * Indices of the groups that were not found in the match.\n   */\n  missingGroupIndices: number[];\n\n  /**\n   * An offset of the match.\n   */\n  offset: number;\n\n  /**\n   * A source of the match.\n   */\n  source: string;\n\n  /**\n   * A substring of the match.\n   */\n  substring: string;\n}\n\n/**\n * A synchronous function that generates replacement strings, or a string to replace with.\n *\n * @typeParam CapturedGroupArguments - The types of the captured group arguments.\n */\nexport type Replacer<CapturedGroupArguments extends string[]> = (($arguments: ReplaceArguments<CapturedGroupArguments>) => StringReplacement) | StringReplacement;\n\ntype StringReplacement = MaybeReturn<string>;\n\n/**\n * Mapping of special characters to their escaped counterparts.\n */\nconst ESCAPE_MAP: Record<string, string> = {\n  '\\n': String.raw`\\n`,\n  '\\r': String.raw`\\r`,\n  '\\t': String.raw`\\t`,\n  '\\b': String.raw`\\b`,\n  '\\f': String.raw`\\f`,\n  '\\'': String.raw`\\'`,\n  '\"': String.raw`\\\"`,\n  '\\\\': '\\\\\\\\'\n} as const;\n\nconst CR = '\\r';\nconst LF = '\\n';\nconst NOT_FOUND_INDEX = -1;\n\n/**\n * Mapping of escaped special characters to their unescaped counterparts.\n */\nconst UNESCAPE_MAP: Record<string, string> = {};\nfor (const [key, value] of Object.entries(ESCAPE_MAP)) {\n  UNESCAPE_MAP[value] = key;\n}\n\n/**\n * Parameters for {@link ensureEndsWith}.\n */\nexport interface EnsureEndsWithParams {\n  /**\n   * The string to check.\n   */\n  readonly $string: string;\n\n  /**\n   * The suffix to ensure.\n   */\n  readonly suffix: string;\n}\n\n/**\n * Parameters for {@link ensureStartsWith}.\n */\nexport interface EnsureStartsWithParams {\n  /**\n   * The string to check.\n   */\n  readonly $string: string;\n\n  /**\n   * The prefix to ensure.\n   */\n  readonly prefix: string;\n}\n\n/**\n * Parameters for {@link hasSingleOccurrence}.\n */\nexport interface HasSingleOccurrenceParams {\n  /**\n   * The string to check.\n   */\n  readonly $string: string;\n\n  /**\n   * The search value to check for.\n   */\n  readonly searchValue: string;\n}\n\n/**\n * Parameters for {@link indent}.\n */\nexport interface IndentParams {\n  /**\n   * The prefix to add to each line.\n   */\n  readonly prefix: string;\n\n  /**\n   * The string to indent.\n   */\n  readonly text: string;\n}\n\n/**\n * Parameters for {@link insertAt}.\n */\nexport interface InsertAtParams {\n  /**\n   * The string to insert the substring into.\n   */\n  readonly $string: string;\n\n  /**\n   * The index to end the substring at.\n   */\n  readonly endIndex?: number;\n\n  /**\n   * The index to insert the substring at.\n   */\n  readonly startIndex: number;\n\n  /**\n   * The substring to insert.\n   */\n  readonly substring: string;\n}\n\n/**\n * Parameters for {@link replaceAllAsync}.\n *\n * @typeParam ReplaceGroupArguments - The types of the captured group arguments.\n */\nexport interface ReplaceAllAsyncParams<ReplaceGroupArguments extends string[]> {\n  /**\n   * The string in which to perform replacements.\n   */\n  readonly $string: string;\n\n  /**\n   * The abort signal to control the execution of the function.\n   */\n  readonly abortSignal?: AbortSignal;\n\n  /**\n   * A synchronous/asynchronous function that generates replacement strings, or a string to replace with.\n   */\n  readonly replacer: AsyncReplacer<ReplaceGroupArguments>;\n\n  /**\n   * The string or regular expression to search for.\n   */\n  readonly searchValue: RegExp | string;\n}\n\n/**\n * Parameters for {@link replaceAll}.\n *\n * @typeParam CapturedGroupArguments - The types of the captured group arguments.\n */\nexport interface ReplaceAllParams<CapturedGroupArguments extends string[]> {\n  /**\n   * The string in which to perform replacements.\n   */\n  readonly $string: string;\n\n  /**\n   * A replacer function that generates replacement strings, or a string to replace with.\n   */\n  readonly replacer: Replacer<CapturedGroupArguments>;\n\n  /**\n   * The string or regular expression to search for.\n   */\n  readonly searchValue: RegExp | string;\n}\n\n/**\n * Parameters for {@link trimEnd}.\n */\nexport interface TrimEndParams {\n  /**\n   * The string to trim.\n   */\n  readonly $string: string;\n\n  /**\n   * If `true`, throws an error if the string does not end with the suffix.\n   *\n   * @default `false`\n   */\n  readonly shouldValidate?: boolean;\n\n  /**\n   * The suffix to remove from the end of the string.\n   */\n  readonly suffix: string;\n}\n\n/**\n * Parameters for {@link trimStart}.\n */\nexport interface TrimStartParams {\n  /**\n   * The string to trim.\n   */\n  readonly $string: string;\n\n  /**\n   * The prefix to remove from the start of the string.\n   */\n  readonly prefix: string;\n\n  /**\n   * If `true`, throws an error if the string does not start with the prefix.\n   *\n   * @default `false`\n   */\n  readonly shouldValidate?: boolean;\n}\n\n/**\n * Parameters for {@link unindent}.\n */\nexport interface UnindentParams {\n  /**\n   * The prefix to remove from each line.\n   */\n  readonly prefix: string;\n\n  /**\n   * If `true`, throws an error if a line is not indented with the prefix.\n   *\n   * @default `false`\n   */\n  readonly shouldThrowIfNotIndented?: boolean;\n\n  /**\n   * The string to unindent.\n   */\n  readonly text: string;\n}\n\n/**\n * Ensures that a string ends with the specified suffix, adding it if necessary.\n *\n * @param params - The parameters.\n * @returns The string that ends with the suffix.\n */\nexport function ensureEndsWith(params: EnsureEndsWithParams): string {\n  const { $string, suffix } = params;\n  return $string.endsWith(suffix) ? $string : $string + suffix;\n}\n\n/**\n * Ensures that a string has `LF` line endings.\n *\n * It replaces `CRLF` line endings with `LF`.\n *\n * @param $string - The string.\n * @returns The string with `LF` line endings.\n */\nexport function ensureLfEndings($string: string): string {\n  return $string.replaceAll(/\\r\\n?/g, '\\n');\n}\n\n/**\n * Ensures that a string starts with the specified prefix, adding it if necessary.\n *\n * @param params - The parameters.\n * @returns The string that starts with the prefix.\n */\nexport function ensureStartsWith(params: EnsureStartsWithParams): string {\n  const { $string, prefix } = params;\n  return $string.startsWith(prefix) ? $string : prefix + $string;\n}\n\n/**\n * Escapes special characters in a string.\n *\n * @param $string - The string to escape.\n * @returns The escaped string.\n */\nexport function escape($string: string): string {\n  return replace($string, ESCAPE_MAP);\n}\n\n/**\n * Returns a function that maps LF-normalized offsets to original offsets.\n *\n * @param $string - The string to get the LF-normalized indices from.\n * @returns A function that maps LF-normalized offsets to original offsets.\n */\nexport function getLfNormalizedOffsetToOriginalOffsetMapper($string: string): (lfOffset: number) => number {\n  const lfOffsetToOriginalOffsetMap: number[] = [];\n\n  for (let index = 0; index < $string.length; index++) {\n    if ($string[index] === CR && $string[index + 1] === LF) {\n      lfOffsetToOriginalOffsetMap.push(index + 1);\n      index++;\n    } else {\n      lfOffsetToOriginalOffsetMap.push(index);\n    }\n  }\n\n  return (lfOffset: number): number => {\n    if (lfOffset < 0) {\n      return lfOffset;\n    }\n    if (lfOffset >= lfOffsetToOriginalOffsetMap.length) {\n      return lfOffset - lfOffsetToOriginalOffsetMap.length + $string.length;\n    }\n\n    assert(lfOffsetToOriginalOffsetMap[lfOffset] !== undefined, 'Could not map offset');\n    return lfOffsetToOriginalOffsetMap[lfOffset];\n  };\n}\n\n/**\n * Checks if a string has a single occurrence of a search value.\n *\n * @param params - The parameters.\n * @returns `true` if the string has a single occurrence of the search value, `false` otherwise.\n */\nexport function hasSingleOccurrence(params: HasSingleOccurrenceParams): boolean {\n  const { $string, searchValue } = params;\n  const firstIndex = $string.indexOf(searchValue);\n  const lastIndex = $string.lastIndexOf(searchValue);\n  return firstIndex !== NOT_FOUND_INDEX && firstIndex === lastIndex;\n}\n\n/**\n * Indents a string by adding a prefix to each line.\n *\n * @param params - The parameters.\n * @returns The indented string.\n */\nexport function indent(params: IndentParams): string {\n  const { prefix, text } = params;\n  return text.split('\\n').map((line) => `${prefix}${line}`).join('\\n');\n}\n\n/**\n * Inserts a substring at a specified position in a string.\n *\n * @param params - The parameters.\n * @returns The modified string with the substring inserted.\n */\nexport function insertAt(params: InsertAtParams): string {\n  const {\n    $string,\n    endIndex,\n    startIndex,\n    substring\n  } = params;\n  const effectiveEndIndex = endIndex ?? startIndex;\n  return $string.slice(0, startIndex) + substring + $string.slice(effectiveEndIndex);\n}\n\n/**\n * Converts a string into a valid JavaScript variable name by replacing invalid characters with underscores.\n *\n * @param $string - The string to convert.\n * @returns The valid variable name.\n */\nexport function makeValidVariableName($string: string): string {\n  return replaceAll({\n    $string,\n    replacer: '_',\n    searchValue: /[^a-zA-Z0-9_]/g\n  });\n}\n\n/**\n * Normalizes a string by converting it to the NFC form and replacing non-breaking spaces with regular spaces.\n *\n * @param $string - The string to normalize.\n * @returns The normalized string.\n */\nexport function normalizeString($string: string): string {\n  return replaceAll({\n    $string,\n    replacer: ' ',\n    // eslint-disable-next-line unicorn/prefer-unicode-code-point-escapes -- These are the conventional spellings for U+00A0 and U+202F. The code-point form is only unambiguous with the `u` flag, so taking the fix would also change how the pattern is parsed.\n    searchValue: /\\u00A0|\\u202F/g\n  }).normalize('NFC');\n}\n\n/**\n * Replaces occurrences of strings in a given string based on a replacements map.\n *\n * @param $string - The string to perform replacements on.\n * @param replacementsMap - An object mapping strings to their replacement values.\n * @returns The modified string with replacements applied.\n */\nexport function replace($string: string, replacementsMap: Record<string, string>): string {\n  const regExp = new RegExp(Object.keys(replacementsMap).map((source) => escapeRegExp(source)).join('|'), 'g');\n  return replaceAll({\n    $string,\n    replacer: ({ substring: source }) => ensureNonNullable(replacementsMap[source]),\n    searchValue: regExp\n  });\n}\n\n/**\n * Replaces all occurrences of a search string or pattern with the results of an replacer function.\n *\n * @typeParam CapturedGroupArguments - The types of the captured group arguments.\n * @param params - The parameters.\n * @returns The string with all replacements made.\n */\nexport function replaceAll<CapturedGroupArguments extends string[]>(params: ReplaceAllParams<CapturedGroupArguments>): string {\n  const { $string, replacer } = params;\n  let { searchValue } = params;\n  if (replacer === undefined) {\n    return $string;\n  }\n\n  if (searchValue instanceof RegExp && !searchValue.global) {\n    searchValue = new RegExp(searchValue.source, `${searchValue.flags}g`);\n  }\n\n  return typeof replacer === 'string'\n    // eslint-disable-next-line unicorn/no-unsafe-string-replacement -- The pass-through is load-bearing: callers rely on `$&` and friends being expanded. `escapeAlias` passes `\\$&` to prefix each matched character with a backslash, and `cli-utils` passes `^$&`. Inserting the string literally would break both.\n    ? $string.replaceAll(searchValue, replacer)\n    : $string.replaceAll(searchValue, (substring: string, ...$arguments: unknown[]) => {\n      const SOURCE_INDEX_OFFSET_FOR_GROUP_ARG = 2;\n      const hasGroupsArgument = typeof $arguments.at(-1) === 'object';\n      const sourceIndex = hasGroupsArgument ? $arguments.length - SOURCE_INDEX_OFFSET_FOR_GROUP_ARG : $arguments.length - 1;\n\n      const replaceArguments: ReplaceArguments<CapturedGroupArguments> = {\n        // eslint-disable-next-line no-restricted-syntax -- Can't avoid.\n        capturedGroupArguments: [] as unknown[] as CapturedGroupArguments,\n        groups: hasGroupsArgument ? $arguments.at(-1) as Record<string, string | undefined> : undefined,\n        missingGroupIndices: [],\n        offset: $arguments.at(sourceIndex - 1) as number,\n        source: $arguments.at(sourceIndex) as string,\n        substring\n      };\n\n      for (let index = 0; index < sourceIndex - 1; index++) {\n        const item = $arguments[index];\n        if (typeof item === 'string') {\n          replaceArguments.capturedGroupArguments.push(item);\n          /* v8 ignore start -- v8 tracks the implicit else branch that never happens. */\n        } else if (item === undefined) {\n          /* v8 ignore stop */\n          replaceArguments.missingGroupIndices.push(index);\n        }\n      }\n\n      return (replacer(replaceArguments) as string | undefined) ?? replaceArguments.substring;\n    });\n}\n\n/**\n * Asynchronously replaces all occurrences of a search string or pattern with the results of an asynchronous replacer function.\n *\n * @typeParam ReplaceGroupArguments - The types of the captured group arguments.\n * @param params - The parameters.\n * @returns A {@link Promise} that resolves to the string with all replacements made.\n */\nexport async function replaceAllAsync<ReplaceGroupArguments extends string[]>(params: ReplaceAllAsyncParams<ReplaceGroupArguments>): Promise<string> {\n  const { $string, replacer, searchValue } = params;\n  let { abortSignal } = params;\n  abortSignal ??= abortSignalNever();\n  abortSignal.throwIfAborted();\n  if (typeof replacer === 'string') {\n    return replaceAll({\n      $string,\n      replacer,\n      searchValue\n    });\n  }\n\n  const replacementAsyncFns: (() => Promise<StringReplacement>)[] = [];\n\n  replaceAll<ReplaceGroupArguments>({\n    $string,\n    replacer: ($arguments) => {\n      replacementAsyncFns.push(() => resolveValue(replacer, { abortSignal, ...$arguments }));\n      return '';\n    },\n    searchValue\n  });\n\n  const replacements: StringReplacement[] = [];\n\n  for (const asyncFunction of replacementAsyncFns) {\n    abortSignal.throwIfAborted();\n    replacements.push(await asyncFunction());\n  }\n\n  abortSignal.throwIfAborted();\n  return replaceAll({\n    $string,\n    replacer: ($arguments): string => replacements.shift() ?? $arguments.substring,\n    searchValue\n  });\n}\n\n/**\n * Trims the specified suffix from the end of a string.\n *\n * @param params - The parameters.\n * @returns The trimmed string.\n * @throws If `shouldValidate` is `true` and the string does not end with the suffix.\n */\nexport function trimEnd(params: TrimEndParams): string {\n  const { $string, shouldValidate, suffix } = params;\n  if ($string.endsWith(suffix)) {\n    return $string.slice(0, -suffix.length);\n  }\n\n  if (shouldValidate) {\n    throw new Error(`String ${$string} does not end with suffix ${suffix}`);\n  }\n\n  return $string;\n}\n\n/**\n * Trims the specified prefix from the start of a string.\n *\n * @param params - The parameters.\n * @returns The trimmed string.\n * @throws If `shouldValidate` is `true` and the string does not start with the prefix.\n */\nexport function trimStart(params: TrimStartParams): string {\n  const { $string, prefix, shouldValidate } = params;\n  if ($string.startsWith(prefix)) {\n    return $string.slice(prefix.length);\n  }\n\n  if (shouldValidate) {\n    throw new Error(`String ${$string} does not start with prefix ${prefix}`);\n  }\n\n  return $string;\n}\n\n/**\n * Unescapes a string by replacing escape sequences with their corresponding characters.\n *\n * @param $string - The string to unescape.\n * @returns The unescaped string.\n */\nexport function unescape($string: string): string {\n  return replace($string, UNESCAPE_MAP);\n}\n\n/**\n * Unindents a string by removing a prefix from each line.\n *\n * @param params - The parameters.\n * @returns The unindented string.\n */\nexport function unindent(params: UnindentParams): string {\n  const { prefix, shouldThrowIfNotIndented = false, text } = params;\n  return text.split('\\n').map((line) => {\n    if (line.startsWith(prefix)) {\n      return line.slice(prefix.length);\n    }\n    if (shouldThrowIfNotIndented) {\n      throw new Error(`Line \"${line}\" is not indented with \"${prefix}\"`);\n    }\n    return line;\n  }).join('\\n');\n}\n"],
  "mappings": "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",
  "names": []
}
