@visulima/string 2.0.3 → 2.0.5

package/dist/outdent.js

@@ -1 +1,117 @@
-var L=Object.defineProperty;var h=(e,n)=>L(e,"name",{value:n,configurable:!0});import{d as R,e as S,f as m,g as W,h as y,i as O}from"./packem_shared/constants-CDcaCZKC.js";var d=Object.defineProperty,g=h((e,n)=>d(e,"name",{value:n,configurable:!0}),"c");const x=Object.prototype.hasOwnProperty,A=g((e,n)=>x.call(e,n),"has"),T=g((e,n)=>{for(const r in n)A(n,r)&&(e[r]=n[r]);return e},"extend"),p=g((e,n,r)=>{if(e.length===0)return[];let t=0;const a=O.exec(e[0]);a&&(t=a[1].length);const i=`(\\r\\n|\\r|\\n).{0,${t}}`,c=new RegExp(i,"g");n&&(e=e.slice(1));const{newline:l,trimLeadingNewline:_,trimTrailingNewline:N}=r,o=typeof l=="string",E=e.length,f=Array.from({length:E});for(let u=0;u<E;u++){let s=e[u];s=s.replace(c,"$1"),u===0&&_&&(s=s.replace(m,"")),u===E-1&&N&&(s=s.replace(W,"")),o&&(s=s.replaceAll(y,l)),f[u]=s}return f},"internalOutdentArray"),b=g((e,n)=>{const r=Array.from({length:e.length+n.length});let t=0;const a=e.length;for(;t<a-1;t++)r[t*2]=e[t],r[t*2+1]=String(n[t]);return r[t*2]=e[t],r.join("")},"concatStringsAndValues"),v=g(e=>A(e,"raw")&&A(e,"length"),"isTemplateStringsArray"),H=new WeakMap,I=g(e=>{const n=e.cache!==!1,r=n?e.cacheStore??H:null,t=e.newline!==void 0;function a(i,...c){if(v(i)){const l=i,_=c.length;if(l.length===1&&l[0]==="")return"";if(_===0){if(n&&r&&!t){const f=r.get(l);if(f)return f[0]}const E=p(l,!1,e);return n&&r&&r.set(l,E),E[0]}const N=(c[0]===a||c[0]===w)&&R.test(l[0])&&S.test(l[1]);let o;return n&&r&&!t&&(o=r.get(l)),o||(o=p(l,N,e),n&&r&&r.set(l,o)),b(o,N?c.slice(1):c)}return I(T(T({},e),i))}return h(a,"g"),g(a,"outdent"),T(a,{string(i){return i===""||!i?"":p([i],!1,e)[0]}})},"createInstance"),w=I({cache:!0,newline:null,trimLeadingNewline:!0,trimTrailingNewline:!0}),C=w;export{C as outdent};
+import { d as RE_LEADING_NEWLINE, e as RE_TRAILING_NEWLINE, f as RE_ONLY_WHITESPACE_WITH_AT_LEAST_ONE_NEWLINE, g as RE_STARTS_WITH_NEWLINE_OR_IS_EMPTY, h as RE_DETECT_INDENTATION, i as RE_MATCH_NEWLINES } from './packem_shared/constants-CTzC6Gjg.js';
+
+const hop = Object.prototype.hasOwnProperty;
+const has = (object, property) => hop.call(object, property);
+const extend = (target, source) => {
+  for (const property of Object.keys(source)) {
+    target[property] = source[property];
+  }
+  return target;
+};
+const internalOutdentArray = (strings, firstInterpolatedValueSetsIndentationLevel, options) => {
+  if (strings.length === 0) {
+    return [];
+  }
+  let indentationLevel = 0;
+  const match = RE_DETECT_INDENTATION.exec(strings[0]);
+  if (match) {
+    indentationLevel = match[1].length;
+  }
+  const reSource = `(\\r\\n|\\r|\\n).{0,${indentationLevel}}`;
+  const reMatchIndent = new RegExp(reSource, "g");
+  if (firstInterpolatedValueSetsIndentationLevel) {
+    strings = strings.slice(1);
+  }
+  const { newline, trimLeadingNewline, trimTrailingNewline } = options;
+  const normalizeNewlines = typeof newline === "string";
+  const l = strings.length;
+  const outdentedStrings = Array.from({ length: l });
+  for (let index = 0; index < l; index++) {
+    let v = strings[index];
+    v = v.replace(reMatchIndent, "$1");
+    if (index === 0 && trimLeadingNewline) {
+      v = v.replace(RE_LEADING_NEWLINE, "");
+    }
+    if (index === l - 1 && trimTrailingNewline) {
+      v = v.replace(RE_TRAILING_NEWLINE, "");
+    }
+    if (normalizeNewlines) {
+      v = v.replaceAll(RE_MATCH_NEWLINES, newline);
+    }
+    outdentedStrings[index] = v;
+  }
+  return outdentedStrings;
+};
+const concatStringsAndValues = (strings, values) => {
+  const chunks = Array.from({ length: strings.length + values.length });
+  let index = 0;
+  const l = strings.length;
+  for (; index < l - 1; index++) {
+    chunks[index * 2] = strings[index];
+    chunks[index * 2 + 1] = String(values[index]);
+  }
+  chunks[index * 2] = strings[index];
+  return chunks.join("");
+};
+const isTemplateStringsArray = (v) => has(v, "raw") && has(v, "length");
+const templateCache = /* @__PURE__ */ new WeakMap();
+const createInstance = (options) => {
+  const enableCache = options.cache !== false;
+  const cache = enableCache ? options.cacheStore ?? templateCache : null;
+  const hasNewlineOption = options.newline !== void 0;
+  function outdent2(stringsOrOptions, ...values) {
+    if (isTemplateStringsArray(stringsOrOptions)) {
+      const strings = stringsOrOptions;
+      const valuesLength = values.length;
+      if (strings.length === 1 && strings[0] === "") {
+        return "";
+      }
+      if (valuesLength === 0) {
+        if (enableCache && cache && !hasNewlineOption) {
+          const cached = cache.get(strings);
+          if (cached) {
+            return cached[0];
+          }
+        }
+        const result = internalOutdentArray(strings, false, options);
+        if (enableCache && cache) {
+          cache.set(strings, result);
+        }
+        return result[0];
+      }
+      const firstValueIsOutdent = values[0] === outdent2 || values[0] === defaultOutdent;
+      const firstInterpolatedValueSetsIndentationLevel = firstValueIsOutdent && RE_ONLY_WHITESPACE_WITH_AT_LEAST_ONE_NEWLINE.test(strings[0]) && RE_STARTS_WITH_NEWLINE_OR_IS_EMPTY.test(strings[1]);
+      let renderedArray;
+      if (enableCache && cache && !hasNewlineOption) {
+        renderedArray = cache.get(strings);
+      }
+      if (!renderedArray) {
+        renderedArray = internalOutdentArray(strings, firstInterpolatedValueSetsIndentationLevel, options);
+        if (enableCache && cache) {
+          cache.set(strings, renderedArray);
+        }
+      }
+      return concatStringsAndValues(renderedArray, firstInterpolatedValueSetsIndentationLevel ? values.slice(1) : values);
+    }
+    return createInstance(extend(extend({}, options), stringsOrOptions));
+  }
+  return extend(outdent2, {
+    string(string_) {
+      if (string_ === "" || !string_) {
+        return "";
+      }
+      return internalOutdentArray([string_], false, options)[0];
+    }
+  });
+};
+const defaultOutdent = createInstance({
+  cache: true,
+  // Enable caching by default
+  // eslint-disable-next-line unicorn/no-null
+  newline: null,
+  trimLeadingNewline: true,
+  trimTrailingNewline: true
+});
+const outdent = defaultOutdent;
+
+export { outdent };

package/dist/packem_shared/LRUCache-3r3SovvR.js

@@ -0,0 +1,46 @@
+class LRUCache {
+  capacity;
+  cache;
+  keyOrder;
+  constructor(capacity) {
+    this.capacity = capacity;
+    this.cache = /* @__PURE__ */ new Map();
+    this.keyOrder = [];
+  }
+  get(key) {
+    if (!this.cache.has(key)) {
+      return void 0;
+    }
+    this.keyOrder = this.keyOrder.filter((k) => k !== key);
+    this.keyOrder.push(key);
+    return this.cache.get(key);
+  }
+  has(key) {
+    return this.cache.has(key);
+  }
+  set(key, value) {
+    if (this.cache.has(key)) {
+      this.keyOrder = this.keyOrder.filter((k) => k !== key);
+    } else if (this.cache.size >= this.capacity) {
+      const lruKey = this.keyOrder.shift();
+      if (lruKey !== void 0) {
+        this.cache.delete(lruKey);
+      }
+    }
+    this.cache.set(key, value);
+    this.keyOrder.push(key);
+  }
+  delete(key) {
+    this.cache.delete(key);
+    this.keyOrder = this.keyOrder.filter((k) => k !== key);
+  }
+  clear() {
+    this.cache.clear();
+    this.keyOrder = [];
+  }
+  size() {
+    return this.cache.size;
+  }
+}
+
+export { LRUCache as default };

package/dist/packem_shared/closest-IHuSvnSn.js

@@ -0,0 +1,139 @@
+const peq = new Uint32Array(65536);
+const myers_32 = (a, b) => {
+  const n = a.length;
+  const m = b.length;
+  const lst = 1 << n - 1;
+  let pv = -1;
+  let mv = 0;
+  let sc = n;
+  let i = n;
+  while (i--) {
+    peq[a.charCodeAt(i)] |= 1 << i;
+  }
+  for (i = 0; i < m; i++) {
+    let eq = peq[b.charCodeAt(i)];
+    const xv = eq | mv;
+    eq |= (eq & pv) + pv ^ pv;
+    mv |= ~(eq | pv);
+    pv &= eq;
+    if (mv & lst) {
+      sc++;
+    }
+    if (pv & lst) {
+      sc--;
+    }
+    mv = mv << 1 | 1;
+    pv = pv << 1 | ~(xv | mv);
+    mv &= xv;
+  }
+  i = n;
+  while (i--) {
+    peq[a.charCodeAt(i)] = 0;
+  }
+  return sc;
+};
+const myers_x = (b, a) => {
+  const n = a.length;
+  const m = b.length;
+  const mhc = [];
+  const phc = [];
+  const hsize = Math.ceil(n / 32);
+  const vsize = Math.ceil(m / 32);
+  for (let i = 0; i < hsize; i++) {
+    phc[i] = -1;
+    mhc[i] = 0;
+  }
+  let j = 0;
+  for (; j < vsize - 1; j++) {
+    let mv2 = 0;
+    let pv2 = -1;
+    const start2 = j * 32;
+    const vlen2 = Math.min(32, m) + start2;
+    for (let k = start2; k < vlen2; k++) {
+      peq[b.charCodeAt(k)] |= 1 << k;
+    }
+    for (let i = 0; i < n; i++) {
+      const eq = peq[a.charCodeAt(i)];
+      const pb = phc[i / 32 | 0] >>> i & 1;
+      const mb = mhc[i / 32 | 0] >>> i & 1;
+      const xv = eq | mv2;
+      const xh = ((eq | mb) & pv2) + pv2 ^ pv2 | eq | mb;
+      let ph = mv2 | ~(xh | pv2);
+      let mh = pv2 & xh;
+      if (ph >>> 31 ^ pb) {
+        phc[i / 32 | 0] ^= 1 << i;
+      }
+      if (mh >>> 31 ^ mb) {
+        mhc[i / 32 | 0] ^= 1 << i;
+      }
+      ph = ph << 1 | pb;
+      mh = mh << 1 | mb;
+      pv2 = mh | ~(xv | ph);
+      mv2 = ph & xv;
+    }
+    for (let k = start2; k < vlen2; k++) {
+      peq[b.charCodeAt(k)] = 0;
+    }
+  }
+  let mv = 0;
+  let pv = -1;
+  const start = j * 32;
+  const vlen = Math.min(32, m - start) + start;
+  for (let k = start; k < vlen; k++) {
+    peq[b.charCodeAt(k)] |= 1 << k;
+  }
+  let score = m;
+  for (let i = 0; i < n; i++) {
+    const eq = peq[a.charCodeAt(i)];
+    const pb = phc[i / 32 | 0] >>> i & 1;
+    const mb = mhc[i / 32 | 0] >>> i & 1;
+    const xv = eq | mv;
+    const xh = ((eq | mb) & pv) + pv ^ pv | eq | mb;
+    let ph = mv | ~(xh | pv);
+    let mh = pv & xh;
+    score += ph >>> m - 1 & 1;
+    score -= mh >>> m - 1 & 1;
+    if (ph >>> 31 ^ pb) {
+      phc[i / 32 | 0] ^= 1 << i;
+    }
+    if (mh >>> 31 ^ mb) {
+      mhc[i / 32 | 0] ^= 1 << i;
+    }
+    ph = ph << 1 | pb;
+    mh = mh << 1 | mb;
+    pv = mh | ~(xv | ph);
+    mv = ph & xv;
+  }
+  for (let k = start; k < vlen; k++) {
+    peq[b.charCodeAt(k)] = 0;
+  }
+  return score;
+};
+const distance = (a, b) => {
+  if (a.length < b.length) {
+    const tmp = b;
+    b = a;
+    a = tmp;
+  }
+  if (b.length === 0) {
+    return a.length;
+  }
+  if (a.length <= 32) {
+    return myers_32(a, b);
+  }
+  return myers_x(a, b);
+};
+const closest = (str, arr) => {
+  let min_distance = Infinity;
+  let min_index = 0;
+  for (let i = 0; i < arr.length; i++) {
+    const dist = distance(str, arr[i]);
+    if (dist < min_distance) {
+      min_distance = dist;
+      min_index = i;
+    }
+  }
+  return arr[min_index];
+};
+
+export { closest, distance };

package/dist/packem_shared/closestN-BREy4E7C.js

@@ -0,0 +1,19 @@
+import { distance } from './closest-IHuSvnSn.js';
+export { closest } from './closest-IHuSvnSn.js';
+
+const closestN = (string_, array, n) => {
+  const distances = new Array(n).fill(Infinity);
+  const values = new Array(n).fill(null);
+  for (let value of array) {
+    let distribution = distance(string_, value);
+    for (let index = 0; index < n; index++) {
+      if (distribution < distances[index]) {
+        [distribution, distances[index]] = [distances[index], distribution];
+        [value, values[index]] = [values[index], value];
+      }
+    }
+  }
+  return values;
+};
+
+export { closestN, distance };

package/dist/packem_shared/constants-CTzC6Gjg.js

@@ -0,0 +1,95 @@
+const r = String.raw;
+const e = r`\p{Emoji}(?:\p{EMod}|[\u{E0020}-\u{E007E}]+\u{E007F}|\uFE0F?\u20E3?)`;
+const emojiRegex = () => new RegExp(r`\p{RI}{2}|(?![#*\d](?!\uFE0F?\u20E3))${e}(?:\u200D${e})*`, "gu");
+
+const ESCAPES = /* @__PURE__ */ new Set(["\x1B", "›"]);
+const ANSI_ESCAPE_BELL = "\x07";
+const ANSI_CSI = "[";
+const ANSI_SGR_TERMINATOR = "m";
+const ANSI_ESCAPE_LINK = `]8;;`;
+const END_CODE = 39;
+const RE_ZERO_WIDTH = /[\u200B\uFEFF\u2060-\u2064]/g;
+const RE_ESCAPE_PATTERN = new RegExp(`(?:\\${ANSI_CSI}(?<code>\\d+)m|\\${ANSI_ESCAPE_LINK}(?<uri>.*)${ANSI_ESCAPE_BELL})`);
+const ANSI_RESET_CODES = Object.freeze(
+  /* @__PURE__ */ new Map([
+    [0, 0],
+    // Reset all
+    [1, 22],
+    // Bold → Not bold
+    [2, 22],
+    // Dim → Not bold
+    [3, 23],
+    // Italic → Not italic
+    [4, 24],
+    // Underline → Not underline
+    [7, 27],
+    // Inverse → Not inverse
+    [8, 28],
+    // Hidden → Not hidden
+    [9, 29],
+    // Strikethrough → Not strikethrough
+    [30, 39],
+    // Foreground colors → Default foreground
+    [31, 39],
+    [32, 39],
+    [33, 39],
+    [34, 39],
+    [35, 39],
+    [36, 39],
+    [37, 39],
+    [40, 49],
+    // Background colors → Default background
+    [41, 49],
+    [42, 49],
+    [43, 49],
+    [44, 49],
+    [45, 49],
+    [46, 49],
+    [47, 49],
+    [90, 39]
+    // Bright foreground → Default foreground
+  ])
+);
+const RE_LEADING_NEWLINE = /^[ \t]*(?:\r\n|\r|\n)/;
+const RE_TRAILING_NEWLINE = /(?:\r\n|\r|\n)[ \t]*$/;
+const RE_STARTS_WITH_NEWLINE_OR_IS_EMPTY = /^(?:[\r\n]|$)/;
+const RE_DETECT_INDENTATION = /(?:\r\n|\r|\n)([ \t]*)(?:[^ \t\r\n]|$)/;
+const RE_ONLY_WHITESPACE_WITH_AT_LEAST_ONE_NEWLINE = /^[ \t]*[\r\n][ \t\r\n]*$/;
+const RE_MATCH_NEWLINES = /\r\n|\n|\r/g;
+const RE_ANSI = /[\u001B\u009B](?:[[()#;?]{0,10}(?:\d{1,4}(?:;\d{0,4})*)?[0-9A-ORZcf-nqry=><]|\]8;;[^\u0007\u001B]{0,100}(?:\u0007|\u001B\\))/g;
+const RE_VALID_ANSI_PAIRS = /\u001B\[(\d+(?:;\d+)*)?m[^\u001B]*(?:\u001B\[(?:\d+(?:;\d+)*)?m|$)/g;
+const RE_VALID_HYPERLINKS = /\u001B\]8;[^\u0007\u001B]*(?:\u0007|\u001B\\)(.*?)\u001B\]8;;(?:\u0007|\u001B\\)/g;
+const RE_CONTROL = /[\u0000-\u0008\n-\u001F\u007F-\u009F]{1,1000}/y;
+const RE_EMOJI = emojiRegex();
+const RE_SEPARATORS = /[-_./\s]+/g;
+const RE_FAST_ANSI = /(\u001B\[[0-9;]*[a-z])/i;
+const RE_ARABIC = new RegExp("\\p{Script=Arabic}", "u");
+const RE_BENGALI = new RegExp("\\p{Script=Bengali}", "u");
+const RE_CYRILLIC = new RegExp("\\p{Script=Cyrillic}", "u");
+const RE_DEVANAGARI = new RegExp("\\p{Script=Devanagari}", "u");
+const RE_ETHIOPIC = new RegExp("\\p{Script=Ethiopic}", "u");
+const RE_GREEK = new RegExp("\\p{Script=Greek}", "u");
+const RE_GREEK_LATIN_SPLIT = new RegExp("\\p{Script=Greek}+|\\p{Script=Latin}+|[^\\p{Script=Greek}\\p{Script=Latin}]+", "gu");
+const RE_GUJARATI = new RegExp("\\p{Script=Gujarati}", "u");
+const RE_GURMUKHI = new RegExp("\\p{Script=Gurmukhi}", "u");
+const RE_HANGUL = new RegExp("\\p{Script=Hangul}", "u");
+const RE_HEBREW = new RegExp("\\p{Script=Hebrew}", "u");
+const RE_HIRAGANA = new RegExp("\\p{Script=Hiragana}", "u");
+const RE_KANJI = new RegExp("\\p{Script=Han}", "u");
+const RE_KANNADA = new RegExp("\\p{Script=Kannada}", "u");
+const RE_KATAKANA = new RegExp("\\p{Script=Katakana}", "u");
+const RE_KHMER = new RegExp("\\p{Script=Khmer}", "u");
+const RE_LAO = new RegExp("\\p{Script=Lao}", "u");
+const RE_LATIN = new RegExp("\\p{Script=Latin}", "u");
+const RE_MALAYALAM = new RegExp("\\p{Script=Malayalam}", "u");
+const RE_MYANMAR = new RegExp("\\p{Script=Myanmar}", "u");
+const RE_ORIYA = new RegExp("\\p{Script=Oriya}", "u");
+const RE_SINHALA = new RegExp("\\p{Script=Sinhala}", "u");
+const RE_TAMIL = new RegExp("\\p{Script=Tamil}", "u");
+const RE_TELUGU = new RegExp("\\p{Script=Telugu}", "u");
+const RE_THAI = new RegExp("\\p{Script=Thai}", "u");
+const RE_TIBETAN = new RegExp("\\p{Script=Tibetan}", "u");
+const RE_UZBEK_LATIN_MODIFIER = /[\u02BB\u02BC\u0027]/u;
+const stripEmoji = (stringValue) => stringValue.replace(RE_EMOJI, "");
+
+export { RE_GURMUKHI as A, RE_KANNADA as B, RE_TAMIL as C, RE_TELUGU as D, RE_MALAYALAM as E, RE_SINHALA as F, RE_THAI as G, RE_LAO as H, RE_TIBETAN as I, RE_MYANMAR as J, RE_ETHIOPIC as K, RE_KHMER as L, RE_ORIYA as M, RE_CONTROL as N, ESCAPES as O, ANSI_ESCAPE_LINK as P, ANSI_SGR_TERMINATOR as Q, RE_FAST_ANSI as R, ANSI_ESCAPE_BELL as S, ANSI_CSI as T, RE_ESCAPE_PATTERN as U, ANSI_RESET_CODES as V, END_CODE as W, RE_ZERO_WIDTH as X, RE_VALID_ANSI_PAIRS as a, RE_VALID_HYPERLINKS as b, RE_ANSI as c, RE_LEADING_NEWLINE as d, RE_TRAILING_NEWLINE as e, RE_ONLY_WHITESPACE_WITH_AT_LEAST_ONE_NEWLINE as f, RE_STARTS_WITH_NEWLINE_OR_IS_EMPTY as g, RE_DETECT_INDENTATION as h, RE_MATCH_NEWLINES as i, RE_EMOJI as j, RE_SEPARATORS as k, RE_CYRILLIC as l, RE_LATIN as m, RE_GREEK as n, RE_GREEK_LATIN_SPLIT as o, RE_UZBEK_LATIN_MODIFIER as p, RE_KATAKANA as q, RE_KANJI as r, stripEmoji as s, RE_HIRAGANA as t, RE_HANGUL as u, RE_HEBREW as v, RE_ARABIC as w, RE_DEVANAGARI as x, RE_BENGALI as y, RE_GUJARATI as z };

package/dist/packem_shared/generate-cache-key-DdayDfjV.js

@@ -0,0 +1,6 @@
+const generateCacheKey = (value, options) => (
+  // Only include options that affect the output
+  `${value}::${options?.joiner ?? ""}::${options?.locale ?? ""}::${options?.knownAcronyms?.join(",") ?? ""}::${options?.normalize ? "true" : "false"}`
+);
+
+export { generateCacheKey as g };

package/dist/packem_shared/joinSegments-CuU8RGpP.js

@@ -0,0 +1,44 @@
+import { R as RE_FAST_ANSI } from './constants-CTzC6Gjg.js';
+
+const joinSegments = (segments, joiner) => {
+  const { length } = segments;
+  if (length === 0) {
+    return "";
+  }
+  if (length === 1) {
+    return segments[0];
+  }
+  const result = [];
+  let ansiStart = "";
+  let currentContent = "";
+  for (let index = 0; index < length; index++) {
+    const segment = segments[index];
+    if (RE_FAST_ANSI.test(segment)) {
+      if (ansiStart) {
+        result.push(ansiStart + currentContent + segment);
+        ansiStart = "";
+        currentContent = "";
+      } else {
+        if (result.length > 0) {
+          result.push(joiner);
+        }
+        ansiStart = segment;
+      }
+      continue;
+    }
+    if (ansiStart) {
+      if (currentContent) {
+        currentContent += joiner;
+      }
+      currentContent += segment;
+    } else {
+      if (result.length > 0) {
+        result.push(joiner);
+      }
+      result.push(segment);
+    }
+  }
+  return result.join("");
+};
+
+export { joinSegments as default };

package/dist/packem_shared/normalize-german-eszett-DEB8-ZPT.js

@@ -0,0 +1,7 @@
+const normalizeGermanEszett = (value) => (
+  // Replace "SS" with "ß" only when both letters are uppercase
+  // This uses a positive lookbehind to ensure we don't convert "ss" or "Ss"
+  value.replaceAll(/(?<![a-zß])SS(?![a-z])/g, "ß")
+);
+
+export { normalizeGermanEszett as n };

package/dist/packem_shared/replaceString-vYvRBMfC.js

@@ -0,0 +1,190 @@
+const mergeIntervals = (intervals) => {
+  if (intervals.length === 0) {
+    return [];
+  }
+  const merged = [];
+  let currentMerge = [...intervals[0]];
+  for (let index = 1; index < intervals.length; index++) {
+    const next = intervals[index];
+    if (next && next[0] <= currentMerge[1] + 1) {
+      currentMerge[1] = Math.max(currentMerge[1], next[1]);
+    } else {
+      merged.push(currentMerge);
+      currentMerge = [...next];
+    }
+  }
+  merged.push(currentMerge);
+  return merged;
+};
+const replaceString = (source, searches, ignoreRanges) => {
+  if (!source) {
+    return "";
+  }
+  const potentialMatches = [];
+  let matchIdCounter = 0;
+  for (const item of searches) {
+    if (!item || item.length < 2) {
+      continue;
+    }
+    const [searchKey, replacementValue] = item;
+    if (replacementValue === void 0) {
+      continue;
+    }
+    try {
+      if (searchKey instanceof RegExp) {
+        const searchPattern = new RegExp(searchKey.source, `${searchKey.flags.replace("g", "")}g`);
+        let match;
+        while ((match = searchPattern.exec(source)) !== null) {
+          const start = match.index;
+          const original = match[0];
+          if (original.length === 0 && searchPattern.lastIndex === match.index) {
+            searchPattern.lastIndex += 1;
+          }
+          const end = start + original.length - 1;
+          const finalReplacement = replacementValue.replaceAll(/\$([\d&$`'])/g, (substringFound, capturedSymbolOrDigits) => {
+            if (capturedSymbolOrDigits === "&") {
+              return original;
+            }
+            if (capturedSymbolOrDigits === "$") {
+              return "$";
+            }
+            if (capturedSymbolOrDigits === "`") {
+              return source.slice(0, Math.max(0, start));
+            }
+            if (capturedSymbolOrDigits === "'") {
+              return source.slice(Math.max(0, start + original.length));
+            }
+            const groupIndex = Number.parseInt(capturedSymbolOrDigits, 10);
+            if (match && groupIndex > 0 && groupIndex < match.length) {
+              return match[groupIndex] ?? "";
+            }
+            return substringFound;
+          });
+          potentialMatches.push({ end, id: matchIdCounter++, original, replacement: finalReplacement, start });
+          if (original.length === 0 && searchPattern.lastIndex === start) {
+            searchPattern.lastIndex += 1;
+          }
+        }
+      } else if (typeof searchKey === "string" && searchKey.length > 0) {
+        for (let index = 0; (index = source.indexOf(searchKey, index)) !== -1; index++) {
+          const start = index;
+          const original = searchKey;
+          const end = start + original.length - 1;
+          const mockMatch = Object.assign([original], { index: start, input: source });
+          const finalReplacement = replacementValue.replaceAll(/\$(\d+|&|\$)/g, (substringFound, capturedSymbolOrDigits) => {
+            if (capturedSymbolOrDigits === "&") {
+              return original;
+            }
+            if (capturedSymbolOrDigits === "$") {
+              return "$";
+            }
+            const groupIndex = Number.parseInt(capturedSymbolOrDigits, 10);
+            if (mockMatch && groupIndex > 0 && groupIndex < mockMatch.length) {
+              return mockMatch[groupIndex] ?? "";
+            }
+            return substringFound;
+          });
+          potentialMatches.push({ end, id: matchIdCounter++, original, replacement: finalReplacement, start });
+        }
+      } else {
+        continue;
+      }
+    } catch {
+      continue;
+    }
+  }
+  potentialMatches.sort((a, b) => {
+    if (a.start !== b.start) {
+      return a.start - b.start;
+    }
+    return b.end - a.end;
+  });
+  const sortedIgnores = [...ignoreRanges].sort((a, b) => a[0] - b[0]);
+  const mergedIgnores = mergeIntervals(sortedIgnores);
+  const processedChars = source.split("").map((char, index) => {
+    return {
+      appliedMatchId: null,
+      char,
+      index,
+      insertBeforeReplacement: null,
+      isIgnored: false,
+      isMatchStart: false,
+      matchReplacement: null
+    };
+  });
+  for (const range of mergedIgnores) {
+    for (let index = range[0]; index <= range[1]; index++) {
+      if (processedChars[index]) {
+        processedChars[index].isIgnored = true;
+      }
+    }
+  }
+  let insertionAfterEnd = "";
+  for (const match of potentialMatches) {
+    if (match.original.length === 0 && match.start >= 0 && match.start <= processedChars.length) {
+      const targetIndex = match.start;
+      if (processedChars[targetIndex]) {
+        const targetChar = processedChars[targetIndex];
+        if (!targetChar.isIgnored) {
+          targetChar.insertBeforeReplacement = (targetChar.insertBeforeReplacement ?? "") + match.replacement;
+        }
+      } else if (targetIndex === processedChars.length) {
+        insertionAfterEnd += match.replacement;
+      }
+    }
+  }
+  for (const match of potentialMatches) {
+    if (match.original.length === 0) {
+      continue;
+    }
+    let canApply = true;
+    for (let index = match.start; index <= match.end; index++) {
+      if (!processedChars[index] || processedChars[index].isIgnored || processedChars[index].appliedMatchId !== null) {
+        canApply = false;
+        break;
+      }
+    }
+    if (canApply && match.start >= 0 && match.start < processedChars.length) {
+      for (let index = match.start; index <= match.end; index++) {
+        if (processedChars[index]) {
+          processedChars[index].appliedMatchId = match.id;
+        }
+      }
+      if (processedChars[match.start]) {
+        processedChars[match.start].isMatchStart = true;
+        processedChars[match.start].matchReplacement = match.replacement;
+      }
+    }
+  }
+  let result = "";
+  let currentIndex = 0;
+  while (currentIndex < processedChars.length) {
+    const pChar = processedChars[currentIndex];
+    if (pChar.insertBeforeReplacement !== null) {
+      result += pChar.insertBeforeReplacement;
+    }
+    if (pChar.isMatchStart && pChar.appliedMatchId !== null) {
+      result += pChar.matchReplacement ?? "";
+      let matchEndIndex = currentIndex;
+      for (let index = currentIndex + 1; index < processedChars.length; index++) {
+        if (processedChars[index]?.appliedMatchId === pChar.appliedMatchId) {
+          matchEndIndex = index;
+        } else {
+          break;
+        }
+      }
+      currentIndex = matchEndIndex + 1;
+    } else if (pChar.appliedMatchId === null) {
+      result += pChar.char;
+      currentIndex += 1;
+    } else {
+      currentIndex += 1;
+    }
+  }
+  if (insertionAfterEnd.length > 0) {
+    result += insertionAfterEnd;
+  }
+  return result;
+};
+
+export { replaceString as default };