@visulima/string 3.0.0-alpha.1 → 3.0.0-alpha.11

package/dist/packem_shared/indent-D3DSCa6s.js

@@ -0,0 +1,33 @@
+function indentString(string, count = 1, options = {}) {
+  const {
+    indent = " ",
+    includeEmptyLines = false
+  } = options;
+  if (typeof string !== "string") {
+    throw new TypeError(
+      `Expected \`input\` to be a \`string\`, got \`${typeof string}\``
+    );
+  }
+  if (typeof count !== "number") {
+    throw new TypeError(
+      `Expected \`count\` to be a \`number\`, got \`${typeof count}\``
+    );
+  }
+  if (count < 0) {
+    throw new RangeError(
+      `Expected \`count\` to be at least 0, got \`${count}\``
+    );
+  }
+  if (typeof indent !== "string") {
+    throw new TypeError(
+      `Expected \`options.indent\` to be a \`string\`, got \`${typeof indent}\``
+    );
+  }
+  if (count === 0) {
+    return string;
+  }
+  const regex = includeEmptyLines ? /^/gm : /^(?!\s*$)/gm;
+  return string.replace(regex, indent.repeat(count));
+}
+
+export { indentString as default };

package/dist/packem_shared/isFullwidthCodePoint-IFXZxNjq.js

@@ -0,0 +1,10 @@
+import { i as isFullWidth, a as isWide } from './lookup-BE8lEqy4.js';
+
+const isFullwidthCodePoint = (codePoint) => {
+  if (!Number.isInteger(codePoint)) {
+    return false;
+  }
+  return isFullWidth(codePoint) || isWide(codePoint);
+};
+
+export { isFullwidthCodePoint as default };

package/dist/packem_shared/{joinSegments-CuU8RGpP.js → joinSegments-CvxSgKz0.js}

@@ -1,4 +1,4 @@
-import { R as RE_FAST_ANSI } from './constants-CTzC6Gjg.js';
+import { R as RE_FAST_ANSI } from './constants-BsZS5f0z.js';
 
 const joinSegments = (segments, joiner) => {
   const { length } = segments;

package/dist/packem_shared/lookup-BE8lEqy4.js

@@ -0,0 +1,104 @@
+const ambiguousRanges = [161, 161, 164, 164, 167, 168, 170, 170, 173, 174, 176, 180, 182, 186, 188, 191, 198, 198, 208, 208, 215, 216, 222, 225, 230, 230, 232, 234, 236, 237, 240, 240, 242, 243, 247, 250, 252, 252, 254, 254, 257, 257, 273, 273, 275, 275, 283, 283, 294, 295, 299, 299, 305, 307, 312, 312, 319, 322, 324, 324, 328, 331, 333, 333, 338, 339, 358, 359, 363, 363, 462, 462, 464, 464, 466, 466, 468, 468, 470, 470, 472, 472, 474, 474, 476, 476, 593, 593, 609, 609, 708, 708, 711, 711, 713, 715, 717, 717, 720, 720, 728, 731, 733, 733, 735, 735, 768, 879, 913, 929, 931, 937, 945, 961, 963, 969, 1025, 1025, 1040, 1103, 1105, 1105, 8208, 8208, 8211, 8214, 8216, 8217, 8220, 8221, 8224, 8226, 8228, 8231, 8240, 8240, 8242, 8243, 8245, 8245, 8251, 8251, 8254, 8254, 8308, 8308, 8319, 8319, 8321, 8324, 8364, 8364, 8451, 8451, 8453, 8453, 8457, 8457, 8467, 8467, 8470, 8470, 8481, 8482, 8486, 8486, 8491, 8491, 8531, 8532, 8539, 8542, 8544, 8555, 8560, 8569, 8585, 8585, 8592, 8601, 8632, 8633, 8658, 8658, 8660, 8660, 8679, 8679, 8704, 8704, 8706, 8707, 8711, 8712, 8715, 8715, 8719, 8719, 8721, 8721, 8725, 8725, 8730, 8730, 8733, 8736, 8739, 8739, 8741, 8741, 8743, 8748, 8750, 8750, 8756, 8759, 8764, 8765, 8776, 8776, 8780, 8780, 8786, 8786, 8800, 8801, 8804, 8807, 8810, 8811, 8814, 8815, 8834, 8835, 8838, 8839, 8853, 8853, 8857, 8857, 8869, 8869, 8895, 8895, 8978, 8978, 9312, 9449, 9451, 9547, 9552, 9587, 9600, 9615, 9618, 9621, 9632, 9633, 9635, 9641, 9650, 9651, 9654, 9655, 9660, 9661, 9664, 9665, 9670, 9672, 9675, 9675, 9678, 9681, 9698, 9701, 9711, 9711, 9733, 9734, 9737, 9737, 9742, 9743, 9756, 9756, 9758, 9758, 9792, 9792, 9794, 9794, 9824, 9825, 9827, 9829, 9831, 9834, 9836, 9837, 9839, 9839, 9886, 9887, 9919, 9919, 9926, 9933, 9935, 9939, 9941, 9953, 9955, 9955, 9960, 9961, 9963, 9969, 9972, 9972, 9974, 9977, 9979, 9980, 9982, 9983, 10045, 10045, 10102, 10111, 11094, 11097, 12872, 12879, 57344, 63743, 65024, 65039, 65533, 65533, 127232, 127242, 127248, 127277, 127280, 127337, 127344, 127373, 127375, 127376, 127387, 127404, 917760, 917999, 983040, 1048573, 1048576, 1114109];
+const fullwidthRanges = [12288, 12288, 65281, 65376, 65504, 65510];
+const halfwidthRanges = [8361, 8361, 65377, 65470, 65474, 65479, 65482, 65487, 65490, 65495, 65498, 65500, 65512, 65518];
+const narrowRanges = [32, 126, 162, 163, 165, 166, 172, 172, 175, 175, 10214, 10221, 10629, 10630];
+const wideRanges = [4352, 4447, 8986, 8987, 9001, 9002, 9193, 9196, 9200, 9200, 9203, 9203, 9725, 9726, 9748, 9749, 9776, 9783, 9800, 9811, 9855, 9855, 9866, 9871, 9875, 9875, 9889, 9889, 9898, 9899, 9917, 9918, 9924, 9925, 9934, 9934, 9940, 9940, 9962, 9962, 9970, 9971, 9973, 9973, 9978, 9978, 9981, 9981, 9989, 9989, 9994, 9995, 10024, 10024, 10060, 10060, 10062, 10062, 10067, 10069, 10071, 10071, 10133, 10135, 10160, 10160, 10175, 10175, 11035, 11036, 11088, 11088, 11093, 11093, 11904, 11929, 11931, 12019, 12032, 12245, 12272, 12287, 12289, 12350, 12353, 12438, 12441, 12543, 12549, 12591, 12593, 12686, 12688, 12773, 12783, 12830, 12832, 12871, 12880, 42124, 42128, 42182, 43360, 43388, 44032, 55203, 63744, 64255, 65040, 65049, 65072, 65106, 65108, 65126, 65128, 65131, 94176, 94180, 94192, 94198, 94208, 101589, 101631, 101662, 101760, 101874, 110576, 110579, 110581, 110587, 110589, 110590, 110592, 110882, 110898, 110898, 110928, 110930, 110933, 110933, 110948, 110951, 110960, 111355, 119552, 119638, 119648, 119670, 126980, 126980, 127183, 127183, 127374, 127374, 127377, 127386, 127488, 127490, 127504, 127547, 127552, 127560, 127568, 127569, 127584, 127589, 127744, 127776, 127789, 127797, 127799, 127868, 127870, 127891, 127904, 127946, 127951, 127955, 127968, 127984, 127988, 127988, 127992, 128062, 128064, 128064, 128066, 128252, 128255, 128317, 128331, 128334, 128336, 128359, 128378, 128378, 128405, 128406, 128420, 128420, 128507, 128591, 128640, 128709, 128716, 128716, 128720, 128722, 128725, 128728, 128732, 128735, 128747, 128748, 128756, 128764, 128992, 129003, 129008, 129008, 129292, 129338, 129340, 129349, 129351, 129535, 129648, 129660, 129664, 129674, 129678, 129734, 129736, 129736, 129741, 129756, 129759, 129770, 129775, 129784, 131072, 196605, 196608, 262141];
+
+const isInRange = (ranges, codePoint) => {
+  let low = 0;
+  let high = Math.floor(ranges.length / 2) - 1;
+  while (low <= high) {
+    const mid = Math.floor((low + high) / 2);
+    const i = mid * 2;
+    if (codePoint < ranges[i]) {
+      high = mid - 1;
+    } else if (codePoint > ranges[i + 1]) {
+      low = mid + 1;
+    } else {
+      return true;
+    }
+  }
+  return false;
+};
+
+const minimumAmbiguousCodePoint = ambiguousRanges[0];
+const maximumAmbiguousCodePoint = ambiguousRanges.at(-1);
+const minimumFullWidthCodePoint = fullwidthRanges[0];
+const maximumFullWidthCodePoint = fullwidthRanges.at(-1);
+const minimumHalfWidthCodePoint = halfwidthRanges[0];
+const maximumHalfWidthCodePoint = halfwidthRanges.at(-1);
+const minimumNarrowCodePoint = narrowRanges[0];
+const maximumNarrowCodePoint = narrowRanges.at(-1);
+const minimumWideCodePoint = wideRanges[0];
+const maximumWideCodePoint = wideRanges.at(-1);
+const commonCjkCodePoint = 19968;
+const [wideFastPathStart, wideFastPathEnd] = findWideFastPathRange(wideRanges);
+function findWideFastPathRange(ranges) {
+  let fastPathStart = ranges[0];
+  let fastPathEnd = ranges[1];
+  for (let index = 0; index < ranges.length; index += 2) {
+    const start = ranges[index];
+    const end = ranges[index + 1];
+    if (commonCjkCodePoint >= start && commonCjkCodePoint <= end) {
+      return [start, end];
+    }
+    if (end - start > fastPathEnd - fastPathStart) {
+      fastPathStart = start;
+      fastPathEnd = end;
+    }
+  }
+  return [fastPathStart, fastPathEnd];
+}
+const isAmbiguous = (codePoint) => {
+  if (codePoint < minimumAmbiguousCodePoint || codePoint > maximumAmbiguousCodePoint) {
+    return false;
+  }
+  return isInRange(ambiguousRanges, codePoint);
+};
+const isFullWidth = (codePoint) => {
+  if (codePoint < minimumFullWidthCodePoint || codePoint > maximumFullWidthCodePoint) {
+    return false;
+  }
+  return isInRange(fullwidthRanges, codePoint);
+};
+const isHalfWidth = (codePoint) => {
+  if (codePoint < minimumHalfWidthCodePoint || codePoint > maximumHalfWidthCodePoint) {
+    return false;
+  }
+  return isInRange(halfwidthRanges, codePoint);
+};
+const isNarrow = (codePoint) => {
+  if (codePoint < minimumNarrowCodePoint || codePoint > maximumNarrowCodePoint) {
+    return false;
+  }
+  return isInRange(narrowRanges, codePoint);
+};
+const isWide = (codePoint) => {
+  if (codePoint >= wideFastPathStart && codePoint <= wideFastPathEnd) {
+    return true;
+  }
+  if (codePoint < minimumWideCodePoint || codePoint > maximumWideCodePoint) {
+    return false;
+  }
+  return isInRange(wideRanges, codePoint);
+};
+function getCategory(codePoint) {
+  if (isAmbiguous(codePoint)) {
+    return "ambiguous";
+  }
+  if (isFullWidth(codePoint)) {
+    return "fullwidth";
+  }
+  if (isHalfWidth(codePoint)) {
+    return "halfwidth";
+  }
+  if (isNarrow(codePoint)) {
+    return "narrow";
+  }
+  if (isWide(codePoint)) {
+    return "wide";
+  }
+  return "neutral";
+}
+
+export { isWide as a, isAmbiguous as b, getCategory as g, isFullWidth as i };

package/dist/packem_shared/lru-cache.d-BsP6kbVJ.d.ts

@@ -0,0 +1,13 @@
+declare class LRUCache<K, V> {
+  private readonly capacity;
+  private readonly cache;
+  private keyOrder;
+  constructor(capacity: number);
+  get(key: K): V | undefined;
+  has(key: K): boolean;
+  set(key: K, value: V): void;
+  delete(key: K): void;
+  clear(): void;
+  size(): number;
+}
+export { LRUCache as L };

package/dist/packem_shared/{normalize-german-eszett-DEB8-ZPT.js → normalize-german-eszett-4p3yKEzn.js}

@@ -1,7 +1,8 @@
+const RE_GERMAN_DOUBLE_S = /(?<![a-zß])SS(?![a-z])/g;
 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, "ß")
+  value.replaceAll(RE_GERMAN_DOUBLE_S, "ß")
 );
 
 export { normalizeGermanEszett as n };

package/dist/packem_shared/redent-DSb1IJWn.js

@@ -0,0 +1,8 @@
+import stripIndent from './stripIndent-D_TRjxZ_.js';
+import indentString from './indent-D3DSCa6s.js';
+
+function redent(string, count = 0, options = {}) {
+  return indentString(stripIndent(string), count, options);
+}
+
+export { redent as default };

package/dist/packem_shared/{replaceString-vYvRBMfC.js → replaceString-Ce8X2ZQ-.js}

@@ -1,3 +1,5 @@
+const RE_REPLACEMENT_REGEX = /\$([\d&$`'])/g;
+const RE_REPLACEMENT_STRING = /\$(\d+|&|\$)/g;
 const mergeIntervals = (intervals) => {
   if (intervals.length === 0) {
     return [];
@@ -23,9 +25,6 @@ const replaceString = (source, searches, ignoreRanges) => {
   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;
@@ -41,7 +40,7 @@ const replaceString = (source, searches, ignoreRanges) => {
             searchPattern.lastIndex += 1;
           }
           const end = start + original.length - 1;
-          const finalReplacement = replacementValue.replaceAll(/\$([\d&$`'])/g, (substringFound, capturedSymbolOrDigits) => {
+          const finalReplacement = replacementValue.replaceAll(RE_REPLACEMENT_REGEX, (substringFound, capturedSymbolOrDigits) => {
             if (capturedSymbolOrDigits === "&") {
               return original;
             }
@@ -71,7 +70,7 @@ const replaceString = (source, searches, ignoreRanges) => {
           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) => {
+          const finalReplacement = replacementValue.replaceAll(RE_REPLACEMENT_STRING, (substringFound, capturedSymbolOrDigits) => {
             if (capturedSymbolOrDigits === "&") {
               return original;
             }
@@ -79,7 +78,7 @@ const replaceString = (source, searches, ignoreRanges) => {
               return "$";
             }
             const groupIndex = Number.parseInt(capturedSymbolOrDigits, 10);
-            if (mockMatch && groupIndex > 0 && groupIndex < mockMatch.length) {
+            if (groupIndex > 0 && groupIndex < mockMatch.length) {
               return mockMatch[groupIndex] ?? "";
             }
             return substringFound;
@@ -99,20 +98,21 @@ const replaceString = (source, searches, ignoreRanges) => {
     }
     return b.end - a.end;
   });
-  const sortedIgnores = [...ignoreRanges].sort((a, b) => a[0] - b[0]);
+  const sortedIgnores = ignoreRanges.toSorted((a, b) => a[0] - b[0]);
   const mergedIgnores = mergeIntervals(sortedIgnores);
   const processedChars = source.split("").map((char, index) => {
     return {
-      appliedMatchId: null,
+      appliedMatchId: void 0,
       char,
       index,
-      insertBeforeReplacement: null,
+      insertBeforeReplacement: void 0,
       isIgnored: false,
       isMatchStart: false,
-      matchReplacement: null
+      matchReplacement: void 0
     };
   });
-  for (const range of mergedIgnores) {
+  for (const mergedIgnore of mergedIgnores) {
+    const range = mergedIgnore;
     for (let index = range[0]; index <= range[1]; index++) {
       if (processedChars[index]) {
         processedChars[index].isIgnored = true;
@@ -120,7 +120,8 @@ const replaceString = (source, searches, ignoreRanges) => {
     }
   }
   let insertionAfterEnd = "";
-  for (const match of potentialMatches) {
+  for (const potentialMatch of potentialMatches) {
+    const match = potentialMatch;
     if (match.original.length === 0 && match.start >= 0 && match.start <= processedChars.length) {
       const targetIndex = match.start;
       if (processedChars[targetIndex]) {
@@ -133,13 +134,14 @@ const replaceString = (source, searches, ignoreRanges) => {
       }
     }
   }
-  for (const match of potentialMatches) {
+  for (const potentialMatch of potentialMatches) {
+    const match = potentialMatch;
     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) {
+      if (!processedChars[index] || processedChars[index].isIgnored || processedChars[index].appliedMatchId !== void 0) {
         canApply = false;
         break;
       }
@@ -160,10 +162,10 @@ const replaceString = (source, searches, ignoreRanges) => {
   let currentIndex = 0;
   while (currentIndex < processedChars.length) {
     const pChar = processedChars[currentIndex];
-    if (pChar.insertBeforeReplacement !== null) {
+    if (pChar.insertBeforeReplacement !== void 0) {
       result += pChar.insertBeforeReplacement;
     }
-    if (pChar.isMatchStart && pChar.appliedMatchId !== null) {
+    if (pChar.isMatchStart && pChar.appliedMatchId !== void 0) {
       result += pChar.matchReplacement ?? "";
       let matchEndIndex = currentIndex;
       for (let index = currentIndex + 1; index < processedChars.length; index++) {
@@ -174,7 +176,7 @@ const replaceString = (source, searches, ignoreRanges) => {
         }
       }
       currentIndex = matchEndIndex + 1;
-    } else if (pChar.appliedMatchId === null) {
+    } else if (pChar.appliedMatchId === void 0) {
       result += pChar.char;
       currentIndex += 1;
     } else {

package/dist/packem_shared/stripIndent-D_TRjxZ_.js

@@ -0,0 +1,20 @@
+function stripIndent(string) {
+  const match = string.match(/^[ \t]*(?=\S)/gm);
+  if (!match) {
+    return string;
+  }
+  let minIndent = Number.POSITIVE_INFINITY;
+  for (const indent of match) {
+    minIndent = Math.min(minIndent, indent.length);
+  }
+  if (minIndent === 0 || minIndent === Number.POSITIVE_INFINITY) {
+    return string;
+  }
+  return string.replace(new RegExp(`^[ \\t]{${minIndent}}`, "gm"), "");
+}
+function dedent(string) {
+  const trimmed = string.replace(/^(?:[ \t]*\r?\n)+|(?:\r?\n[ \t]*)+$/g, "");
+  return stripIndent(trimmed);
+}
+
+export { dedent, stripIndent as default };

package/dist/packem_shared/{transliterate-CYnKKT8f.js → transliterate-CKt9VK7D.js}

@@ -1,5 +1,5 @@
-import { G as RE_THAI } from './constants-CTzC6Gjg.js';
-import replaceString from './replaceString-vYvRBMfC.js';
+import { H as RE_THAI } from './constants-BsZS5f0z.js';
+import replaceString from './replaceString-Ce8X2ZQ-.js';
 import { findStringOccurrences, hasPunctuationOrSpace, hasChinese } from '../utilities.js';
 
 const UNICODE_BLOCK_0000_00FF = [
@@ -47618,8 +47618,9 @@ const formatReplaceOption = (option) => {
     return structuredClone(option);
   }
   const replaceArray = [];
-  for (const key in option) {
-    if (Object.prototype.hasOwnProperty.call(option, key)) {
+  const keys = Object.keys(option);
+  for (const key of keys) {
+    if (Object.hasOwn(option, key)) {
       const value = option[key];
       if (typeof value === "string") {
         replaceArray.push([key, value]);
@@ -47630,7 +47631,8 @@ const formatReplaceOption = (option) => {
 };
 const applyThaiRomanization = (input) => {
   let output = input;
-  for (const entry of THAI_REPLACEMENT) {
+  for (let entryIndex = 0; entryIndex < THAI_REPLACEMENT.length; entryIndex += 1) {
+    const entry = THAI_REPLACEMENT[entryIndex];
     const [search, replace, type] = entry;
     if (typeof search !== "string" || typeof replace !== "string") {
       continue;
@@ -47687,8 +47689,6 @@ const transliterate = (source, options) => {
     const codePoint = input.codePointAt(index);
     if (codePoint === void 0) {
       char = input[index];
-      charLength = 1;
-      s = opt.unknown;
     } else {
       char = String.fromCodePoint(codePoint);
       charLength = char.length;
@@ -47715,7 +47715,7 @@ const transliterate = (source, options) => {
         s = opt.unknown;
       } else {
         const codePointString = String(currentActualCodePoint);
-        const found = Object.prototype.hasOwnProperty.call(currentCharmap, codePointString);
+        const found = Object.hasOwn(currentCharmap, codePointString);
         if (found) {
           s = currentCharmap[codePointString];
         } else if (isCurrentCharChinese) {
@@ -47724,9 +47724,7 @@ const transliterate = (source, options) => {
           s = opt.unknown;
         }
       }
-      if (s === void 0 || s === null) {
-        s = opt.unknown;
-      }
+      s ??= opt.unknown;
     }
     const determinedCharWasChinese = !isIgnored && isCurrentCharChinese;
     if (opt.fixChineseSpacing && !isIgnored) {
@@ -47738,7 +47736,7 @@ const transliterate = (source, options) => {
     } else {
       lastCharWasChinese = false;
     }
-    result += s ?? "";
+    result += s;
     index += charLength;
   }
   input = result;

package/dist/packem_shared/{types-Daae0hGf.d.ts → types.d-BVNv675q.d.ts}

@@ -4,17 +4,16 @@ type SliceStartType<T extends string, StartIndex extends number, Result extends
 type InternalEndsWithType<T extends string, S extends string, P extends number> = All<[IsStringLiteral<S>, IsNumberLiteral<P>]> extends true ? Math.IsNegative<P> extends false ? P extends Length<T> ? IsStringLiteral<T> extends true ? S extends Slice<T, Math.Subtract<Length<T>, Length<S>>, Length<T>> ? true : false : EndsWithNoPositionType<Slice<T, 0, P>, S> : EndsWithNoPositionType<Slice<T, 0, P>, S> : false : boolean;
 type EndsWithNoPositionType<T extends string, S extends string> = StartsWith<Reverse<T>, Reverse<S>>;
 declare namespace Math {
-    type Subtract<A extends number, B extends number> = number extends A | B ? number : TupleOf<A> extends [...infer U, ...TupleOf<B>] ? U["length"] : 0;
-    type IsNegative<T extends number> = number extends T ? boolean : `${T}` extends `-${number}` ? true : false;
-    type Abs<T extends number> = `${T}` extends `-${infer U extends number}` ? U : T;
-    type GetPositiveIndex<T extends string, I extends number> = IsNegative<I> extends false ? I : Subtract<Length<T>, Abs<I>>;
+  type Subtract<A extends number, B extends number> = number extends A | B ? number : TupleOf<A> extends [...infer U, ...TupleOf<B>] ? U["length"] : 0;
+  type IsNegative<T extends number> = number extends T ? boolean : `${T}` extends `-${number}` ? true : false;
+  type Abs<T extends number> = `${T}` extends `-${infer U extends number}` ? U : T;
+  type GetPositiveIndex<T extends string, I extends number> = IsNegative<I> extends false ? I : Subtract<Length<T>, Abs<I>>;
 }
-
 type IsNumberLiteral<T extends number> = [T] extends [number] ? ([number] extends [T] ? false : true) : false;
 type IsBooleanLiteral<T extends boolean> = [T] extends [boolean] ? ([boolean] extends [T] ? false : true) : false;
 type Reverse<T extends string, Accumulator extends string = ""> = T extends `${infer Head}${infer Tail}` ? Reverse<Tail, `${Head}${Accumulator}`> : Accumulator extends "" ? T : `${T}${Accumulator}`;
 type Any<BoolArray extends boolean[]> = BoolArray extends [infer Head extends boolean, ...infer Rest extends boolean[]] ? IsBooleanLiteral<Head> extends true ? Head extends true ? true : Any<Rest> : Any<Rest> : false;
-type All<BoolArray extends boolean[]> = IsBooleanLiteral<BoolArray[number]> extends true ? BoolArray extends [infer Head extends boolean, ...infer Rest extends boolean[]] ? Head extends true ? Any<Rest> : false : true : false;
+type All<BoolArray extends boolean[]> = IsBooleanLiteral<BoolArray[number]> extends true ? BoolArray extends [infer Head extends boolean, ...infer Rest extends boolean[]] ? Head extends true ? All<Rest> : false : true : false;
 type IsStringLiteral<T extends string> = [T] extends [string] ? [string] extends [T] ? false : Uppercase<T> extends Uppercase<Lowercase<T>> ? Lowercase<T> extends Lowercase<Uppercase<T>> ? true : false : false : false;
 type IsStringLiteralArray<StringArray extends ReadonlyArray<string>> = IsStringLiteral<StringArray[number]> extends true ? true : false;
 type CharAt<T extends string, Index extends number> = All<[IsStringLiteral<T>, IsNumberLiteral<Index>]> extends true ? Split<T>[Index] : string;
@@ -43,22 +42,20 @@ type OptionReplaceArray = [RegExp | string, string | undefined][];
 type OptionReplaceObject = Record<string, string>;
 type OptionReplaceCombined = OptionReplaceArray | OptionReplaceObject;
 interface OptionsTransliterate {
-    fixChineseSpacing?: boolean;
-    ignore?: string[];
-    replaceAfter?: OptionReplaceCombined;
-    replaceBefore?: OptionReplaceCombined;
-    trim?: boolean;
-    unknown?: string;
+  fixChineseSpacing?: boolean;
+  ignore?: string[];
+  replaceAfter?: OptionReplaceCombined;
+  replaceBefore?: OptionReplaceCombined;
+  trim?: boolean;
+  unknown?: string;
 }
 type Charmap = Record<string, string | undefined>;
 interface SlugifyOptions extends OptionsTransliterate {
-    allowedChars?: string;
-    fixChineseSpacing?: boolean;
-    lowercase?: boolean;
-    separator?: string;
-    transliterate?: boolean;
-    uppercase?: boolean;
+  allowedChars?: string;
+  fixChineseSpacing?: boolean;
+  lowercase?: boolean;
+  separator?: string;
+  transliterate?: boolean;
+  uppercase?: boolean;
 }
-
-export { Math as M };
-export type { All as A, CharAt as C, EndsWith as E, Includes as I, Join as J, Length as L, NodeLocale as N, OptionReplaceArray as O, PadEnd as P, Replace as R, Slice as S, ToLowerCase as T, Concat as a, PadStart as b, ReplaceAll as c, Split as d, StartsWith as e, ToUpperCase as f, Trim as g, TrimEnd as h, TrimStart as i, SlugifyOptions as j, IsStringLiteral as k, IntervalArray as l, OptionsTransliterate as m, Any as n, Charmap as o, Interval as p, IsBooleanLiteral as q, IsNumberLiteral as r, IsStringLiteralArray as s, OptionReplaceCombined as t, OptionReplaceObject as u, Repeat as v, Reverse as w };
+export { All as A, CharAt as C, EndsWith as E, IsStringLiteral as I, Join as J, Length as L, Math as M, NodeLocale as N, OptionReplaceArray as O, PadEnd as P, Repeat as R, SlugifyOptions as S, ToLowerCase as T, IntervalArray as a, OptionsTransliterate as b, Any as c, Charmap as d, Concat as e, Includes as f, Interval as g, IsBooleanLiteral as h, IsNumberLiteral as i, IsStringLiteralArray as j, OptionReplaceCombined as k, OptionReplaceObject as l, PadStart as m, Replace as n, ReplaceAll as o, Reverse as p, Slice as q, Split as r, StartsWith as s, ToUpperCase as t, Trim as u, TrimEnd as v, TrimStart as w };

package/dist/packem_shared/{types-CfPsw9ix.d.ts → types.d-DfgbcNKh.d.ts}

@@ -1,6 +1,5 @@
-import { N as NodeLocale, k as IsStringLiteral } from './types-Daae0hGf.js';
-import { L as LRUCache } from './lru-cache-B_t27XwI.js';
-
+import { I as IsStringLiteral, N as NodeLocale } from "./types.d-BVNv675q.js";
+import { L as LRUCache } from "./lru-cache.d-BsP6kbVJ.js";
 type SplitterCharacter = " " | "_" | "-" | "." | "/";
 type LastOfArray<T extends any[]> = T extends [...any, infer R] ? R : never;
 type RemoveLastOfArray<T extends any[]> = T extends [...infer F, any] ? F : never;
@@ -10,17 +9,17 @@ type SameLetterCase<X extends string, Y extends string> = IsUpperCase<X> extends
 type FirstOfString<S extends string> = S extends `${infer F}${string}` ? F : never;
 type RemoveFirstOfString<S extends string> = S extends `${string}${infer R}` ? R : never;
 interface LocaleOptions {
-    locale?: NodeLocale;
+  locale?: NodeLocale;
 }
 interface CaseOptions extends LocaleOptions {
-    cache?: boolean;
-    cacheStore?: LRUCache<string, string>;
-    handleAnsi?: boolean;
-    handleEmoji?: boolean;
-    knownAcronyms?: ReadonlyArray<string>;
-    normalize?: boolean;
-    stripAnsi?: boolean;
-    stripEmoji?: boolean;
+  cache?: boolean;
+  cacheStore?: LRUCache<string, string>;
+  handleAnsi?: boolean;
+  handleEmoji?: boolean;
+  knownAcronyms?: ReadonlyArray<string>;
+  normalize?: boolean;
+  stripAnsi?: boolean;
+  stripEmoji?: boolean;
 }
 type CamelCase<T extends string> = IsStringLiteral<T> extends true ? T extends `${infer F}_${infer R}` ? `${Lowercase<F>}${Capitalize<CamelCase<R>>}` : T extends `${infer F}-${infer R}` ? `${Lowercase<F>}${Capitalize<CamelCase<R>>}` : T extends `${infer F} ${infer R}` ? `${Lowercase<F>}${Capitalize<CamelCase<R>>}` : Lowercase<T> : string;
 type PascalCase<T extends string> = IsStringLiteral<T> extends true ? Capitalize<CamelCase<T>> : string;
@@ -33,27 +32,26 @@ type UpperFirst<T extends string> = IsStringLiteral<T> extends true ? (T extends
 type LowerFirst<T extends string> = IsStringLiteral<T> extends true ? (T extends `${infer F}${infer R}` ? `${Lowercase<F>}${R}` : T) : string;
 type FlipCase<T extends string> = IsStringLiteral<T> extends true ? T extends `${infer C}${infer Rest}` ? `${C extends Uppercase<C> ? Lowercase<C> : Uppercase<C>}${FlipCase<Rest>}` : T : string;
 type DotCase<T extends string> = T & {
-    __dot_case__: never;
+  __dot_case__: never;
 };
 type PathCase<T extends string> = T & {
-    __path_case__: never;
+  __path_case__: never;
 };
 type NoCase<T extends string> = T & {
-    __no_case__: never;
+  __no_case__: never;
 };
 type ConstantCase<T extends string> = T & {
-    __constant_case__: never;
+  __constant_case__: never;
 };
 type CapitalCase<T extends string> = T & {
-    __capital_case__: never;
+  __capital_case__: never;
 };
 type SentenceCase<T extends string> = T & {
-    __sentence_case__: never;
+  __sentence_case__: never;
 };
 type PascalSnakeCase<T extends string> = T & {
-    __pascal_snake_case__: never;
+  __pascal_snake_case__: never;
 };
 type IdentifyCase<T extends string> = IsStringLiteral<T> extends true ? T extends Lowercase<T> ? T extends `${string}_${string}` ? "snake" : T extends `${string}-${string}` ? "kebab" : T extends `${string}${string}` ? "flat" : "lower" : T extends Uppercase<T> ? "upper" : T extends Capitalize<string> ? T extends `${Uppercase<string>}${string}` ? T extends `${string}-${string}` ? "train" : "pascal" : T extends `${Lowercase<string>}${Capitalize<string>}` ? "camel" : T extends `${Capitalize<string>} ${Lowercase<string>}` ? "title" : "mixed" : "mixed" : string;
 type SplitByCase<T, Separator extends string = SplitterCharacter, Accumulator extends unknown[] = []> = string extends Separator ? string[] : T extends `${infer F}${infer R}` ? [LastOfArray<Accumulator>] extends [never] ? SplitByCase<R, Separator, [F]> : LastOfArray<Accumulator> extends string ? R extends "" ? SplitByCase<R, Separator, [...RemoveLastOfArray<Accumulator>, `${LastOfArray<Accumulator>}${F}`]> : SameLetterCase<F, FirstOfString<R>> extends true ? F extends Separator ? FirstOfString<R> extends Separator ? SplitByCase<R, Separator, [...Accumulator, ""]> : IsUpperCase<FirstOfString<R>> extends true ? SplitByCase<RemoveFirstOfString<R>, Separator, [...Accumulator, FirstOfString<R>]> : SplitByCase<R, Separator, [...Accumulator, ""]> : SplitByCase<R, Separator, [...RemoveLastOfArray<Accumulator>, `${LastOfArray<Accumulator>}${F}`]> : IsLowerCase<F> extends true ? SplitByCase<RemoveFirstOfString<R>, Separator, [...RemoveLastOfArray<Accumulator>, `${LastOfArray<Accumulator>}${F}`, FirstOfString<R>]> : SplitByCase<R, Separator, [...Accumulator, F]> : never : Accumulator extends [] ? T extends "" ? [] : string[] : Accumulator;
-
-export type { CaseOptions as C, DotCase as D, FlatCase as F, IdentifyCase as I, KebabCase as K, LocaleOptions as L, NoCase as N, PascalCase as P, SentenceCase as S, TitleCase as T, UpperFirst as U, CamelCase as a, CapitalCase as b, ConstantCase as c, FlipCase as d, LowerFirst as e, PascalSnakeCase as f, PathCase as g, SnakeCase as h, SplitByCase as i, TrainCase as j };
+export { CaseOptions as C, DotCase as D, FlatCase as F, IdentifyCase as I, KebabCase as K, LocaleOptions as L, NoCase as N, PascalCase as P, SentenceCase as S, TitleCase as T, UpperFirst as U, CamelCase as a, CapitalCase as b, ConstantCase as c, FlipCase as d, LowerFirst as e, PascalSnakeCase as f, PathCase as g, SnakeCase as h, SplitByCase as i, TrainCase as j };

package/dist/slice.d.ts

@@ -1,11 +1,8 @@
-import { StringWidthOptions } from './get-string-width.js';
-import './get-string-truncated-width.js';
-
+import { StringWidthOptions } from "./get-string-width.js";
+import "./get-string-truncated-width.js";
 type SliceOptions = {
-    segmenter?: Intl.Segmenter;
-    width?: StringWidthOptions;
+  segmenter?: Intl.Segmenter;
+  width?: StringWidthOptions;
 };
 declare const slice: (inputString: string, startIndex?: number, endIndex?: number, options?: SliceOptions) => string;
-
-export { slice };
-export type { SliceOptions };
+export { SliceOptions, slice };

package/dist/slice.js

@@ -1,9 +1,10 @@
-import { a as RE_VALID_ANSI_PAIRS, b as RE_VALID_HYPERLINKS, c as RE_ANSI } from './packem_shared/constants-CTzC6Gjg.js';
+import { j as RE_VALID_ANSI_PAIRS, k as RE_VALID_HYPERLINKS, g as RE_ANSI } from './packem_shared/constants-BsZS5f0z.js';
 import { getStringWidth } from './get-string-width.js';
 import LRUCache from './packem_shared/LRUCache-3r3SovvR.js';
 
 const segmentCache = new LRUCache(100);
 const defaultSegmenter = new Intl.Segmenter("en", { granularity: "grapheme" });
+const RE_ASCII_ONLY = /^[\u0000-\u007F]*$/;
 const ANSI_RESET_CODES = /* @__PURE__ */ new Set([
   "0",
   // Full reset
@@ -70,8 +71,8 @@ const FORMAT_STYLES = [
 ];
 const findFirstPositionOfAny = (input, substrings) => {
   let firstPos = -1;
-  for (const substring of substrings) {
-    const pos = input.indexOf(substring);
+  for (const sub of substrings) {
+    const pos = input.indexOf(sub);
     if (pos !== -1 && (firstPos === -1 || pos < firstPos)) {
       firstPos = pos;
     }
@@ -271,10 +272,10 @@ const processIntoStyledSegments = (input, options) => {
         }
         if (needsForegroundClose && needsBackgroundClose && input.includes("\x1B[39m") && input.includes("\x1B[49m")) {
           if (input.indexOf("\x1B[39m") < input.indexOf("\x1B[49m")) {
-            closingParts.length -= needsForegroundClose && needsBackgroundClose ? 2 : needsForegroundClose || needsBackgroundClose ? 1 : 0;
+            closingParts.length -= 2;
             closingParts.push("\x1B[39m", "\x1B[49m");
           } else if (input.indexOf("\x1B[49m") < input.indexOf("\x1B[39m")) {
-            closingParts.length -= needsForegroundClose && needsBackgroundClose ? 2 : needsForegroundClose || needsBackgroundClose ? 1 : 0;
+            closingParts.length -= 2;
             closingParts.push("\x1B[49m", "\x1B[39m");
           }
         }
@@ -284,7 +285,8 @@ const processIntoStyledSegments = (input, options) => {
             style
           };
         }).filter((item) => item.position >= 0).toSorted((a, b) => b.position - a.position);
-        for (const item of activeFormatStyles) {
+        for (const activeFormatStyle of activeFormatStyles) {
+          const item = activeFormatStyle;
           if (closingSequences.includes(item.style.close)) {
             closingParts.push(item.style.close);
           }
@@ -350,7 +352,7 @@ const slice = (inputString, startIndex = 0, endIndex = Number.MAX_SAFE_INTEGER,
     throw new RangeError("Negative indices aren't supported");
   }
   if (!inputString.includes("\x1B")) {
-    if (/^[\u0000-\u007F]*$/.test(inputString)) {
+    if (RE_ASCII_ONLY.test(inputString)) {
       return inputString.slice(startIndex, endIndex);
     }
     return fastSlice(inputString, startIndex, endIndex, config);

package/dist/slugify.d.ts

@@ -1,5 +1,3 @@
-import { j as SlugifyOptions } from './packem_shared/types-Daae0hGf.js';
-
+import { S as SlugifyOptions } from "./packem_shared/types.d-BVNv675q.js";
 declare const slugify: (input: string, options?: SlugifyOptions) => string;
-
 export { slugify as default };

package/dist/slugify.js

@@ -1,4 +1,4 @@
-import transliterate from './packem_shared/transliterate-CYnKKT8f.js';
+import transliterate from './packem_shared/transliterate-CKt9VK7D.js';
 import { escapeRegExp } from './utilities.js';
 
 const removeDisallowedChars = (input, allowedChars, separator) => {