@mnaoumov/typescript-lib 0.0.0 → 1.0.0

package/dist/lib/cjs/string.cjs

@@ -0,0 +1,326 @@
+/*
+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 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": []
}
