@visulima/string 1.1.0 → 1.2.1

package/dist/packem_shared/replaceString-C7Dp5vAg.mjs

@@ -0,0 +1,200 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const mergeIntervals = /* @__PURE__ */ __name((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;
+}, "mergeIntervals");
+const replaceString = /* @__PURE__ */ __name((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++;
+          }
+          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.substring(0, start);
+            }
+            if (capturedSymbolOrDigits === "'") {
+              return source.substring(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++;
+          }
+        }
+      } 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 (
+        // eslint-disable-next-line security/detect-object-injection
+        !processedChars[index] || // Out of bounds
+        // eslint-disable-next-line security/detect-object-injection
+        processedChars[index].isIgnored || // Overlaps ignore
+        // eslint-disable-next-line security/detect-object-injection
+        processedChars[index].appliedMatchId !== null
+      ) {
+        canApply = false;
+        break;
+      }
+    }
+    if (canApply && // Apply this valid match
+    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++;
+    } else {
+      currentIndex++;
+    }
+  }
+  if (insertionAfterEnd.length > 0) {
+    result += insertionAfterEnd;
+  }
+  return result;
+}, "replaceString");
+
+export { replaceString as default };

package/dist/packem_shared/replaceString-iYo1cDfZ.cjs

@@ -0,0 +1,202 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const mergeIntervals = /* @__PURE__ */ __name((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;
+}, "mergeIntervals");
+const replaceString = /* @__PURE__ */ __name((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++;
+          }
+          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.substring(0, start);
+            }
+            if (capturedSymbolOrDigits === "'") {
+              return source.substring(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++;
+          }
+        }
+      } 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 (
+        // eslint-disable-next-line security/detect-object-injection
+        !processedChars[index] || // Out of bounds
+        // eslint-disable-next-line security/detect-object-injection
+        processedChars[index].isIgnored || // Overlaps ignore
+        // eslint-disable-next-line security/detect-object-injection
+        processedChars[index].appliedMatchId !== null
+      ) {
+        canApply = false;
+        break;
+      }
+    }
+    if (canApply && // Apply this valid match
+    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++;
+    } else {
+      currentIndex++;
+    }
+  }
+  if (insertionAfterEnd.length > 0) {
+    result += insertionAfterEnd;
+  }
+  return result;
+}, "replaceString");
+
+module.exports = replaceString;

package/dist/packem_shared/slugify-DhE59J2A.mjs

@@ -0,0 +1,48 @@
+import transliterate from './transliterate-DwSldp0o.mjs';
+import { escapeRegExp } from '../utils.mjs';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const removeDisallowedChars = /* @__PURE__ */ __name((input, allowedChars, separator) => {
+  const escapedChars = escapeRegExp(allowedChars).replaceAll("\\-", "-");
+  const pattern = new RegExp(`[^${escapedChars}]`, "g");
+  return input.replaceAll(pattern, separator);
+}, "removeDisallowedChars");
+const slugify = /* @__PURE__ */ __name((input, options) => {
+  const config = {
+    allowedChars: "a-zA-Z0-9-_.~",
+    fixChineseSpacing: true,
+    ignore: [],
+    lowercase: true,
+    replaceAfter: [],
+    replaceBefore: [],
+    separator: "-",
+    transliterate: true,
+    trim: false,
+    unknown: "",
+    uppercase: false,
+    ...options
+  };
+  if (config.lowercase && config.uppercase) {
+    console.warn("slugify: Both lowercase and uppercase options are true. Defaulting to lowercase.");
+    config.uppercase = false;
+  }
+  let slug = config.transliterate ? transliterate(input, config) : input.normalize("NFC");
+  if (config.lowercase) {
+    slug = slug.toLowerCase();
+  } else if (config.uppercase) {
+    slug = slug.toUpperCase();
+  }
+  slug = removeDisallowedChars(slug, config.allowedChars, config.separator);
+  const escapedSeparator = escapeRegExp(config.separator);
+  if (escapedSeparator) {
+    const separatorRegex = new RegExp(`${escapedSeparator}+`, "g");
+    slug = slug.replace(separatorRegex, config.separator);
+  }
+  if (escapedSeparator) {
+    return slug.replaceAll(new RegExp(`^${escapedSeparator}+|${escapedSeparator}+$`, "g"), "");
+  }
+  return slug;
+}, "slugify");
+
+export { slugify as default };

package/dist/packem_shared/slugify-jh6PftAT.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+const transliterate = require('./transliterate-BEci5RC8.cjs');
+const utils = require('../utils.cjs');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const removeDisallowedChars = /* @__PURE__ */ __name((input, allowedChars, separator) => {
+  const escapedChars = utils.escapeRegExp(allowedChars).replaceAll("\\-", "-");
+  const pattern = new RegExp(`[^${escapedChars}]`, "g");
+  return input.replaceAll(pattern, separator);
+}, "removeDisallowedChars");
+const slugify = /* @__PURE__ */ __name((input, options) => {
+  const config = {
+    allowedChars: "a-zA-Z0-9-_.~",
+    fixChineseSpacing: true,
+    ignore: [],
+    lowercase: true,
+    replaceAfter: [],
+    replaceBefore: [],
+    separator: "-",
+    transliterate: true,
+    trim: false,
+    unknown: "",
+    uppercase: false,
+    ...options
+  };
+  if (config.lowercase && config.uppercase) {
+    console.warn("slugify: Both lowercase and uppercase options are true. Defaulting to lowercase.");
+    config.uppercase = false;
+  }
+  let slug = config.transliterate ? transliterate(input, config) : input.normalize("NFC");
+  if (config.lowercase) {
+    slug = slug.toLowerCase();
+  } else if (config.uppercase) {
+    slug = slug.toUpperCase();
+  }
+  slug = removeDisallowedChars(slug, config.allowedChars, config.separator);
+  const escapedSeparator = utils.escapeRegExp(config.separator);
+  if (escapedSeparator) {
+    const separatorRegex = new RegExp(`${escapedSeparator}+`, "g");
+    slug = slug.replace(separatorRegex, config.separator);
+  }
+  if (escapedSeparator) {
+    return slug.replaceAll(new RegExp(`^${escapedSeparator}+|${escapedSeparator}+$`, "g"), "");
+  }
+  return slug;
+}, "slugify");
+
+module.exports = slugify;