@visulima/string 2.0.3 → 2.0.4

package/dist/slice.js

@@ -1 +1,413 @@
-var R=Object.defineProperty;var k=(t,l)=>R(t,"name",{value:l,configurable:!0});import{a as v,b as L,c as O}from"./packem_shared/constants-CDcaCZKC.js";import{getStringWidth as I}from"./get-string-width.js";import N from"./packem_shared/LRUCache-Bjo6gsbC.js";var j=Object.defineProperty,b=k((t,l)=>j(t,"name",{value:l,configurable:!0}),"y");const _=new N(100),F=new Intl.Segmenter("en",{granularity:"grapheme"}),M=new Set(["0","22","23","24","27","28","29","39","49"]),P=new Set(["1","3","4","7","8","9"]),y=new Map([["22","1"],["23","3"],["24","4"],["27","7"],["28","8"],["29","9"]]),S=b(t=>t>="30"&&t<="37"||t>="90"&&t<="97"||t.startsWith("38;"),"isForegroundColor"),w=b(t=>t>="40"&&t<="47"||t>="100"&&t<="107"||t.startsWith("48;"),"isBackgroundColor"),V=[{close:"\x1B[22m",open:"\x1B[1m"},{close:"\x1B[23m",open:"\x1B[3m"},{close:"\x1B[24m",open:"\x1B[4m"},{close:"\x1B[27m",open:"\x1B[7m"},{close:"\x1B[28m",open:"\x1B[8m"},{close:"\x1B[29m",open:"\x1B[9m"}],A=b((t,l)=>{let c=-1;for(const d of l){const h=t.indexOf(d);h!==-1&&(c===-1||h<c)&&(c=h)}return c},"findFirstPositionOfAny"),$=b((t,l)=>{if(!t.includes("\x1B"))return[{after:"",before:"",content:t,visibleLength:I(t,l.width)}];const c=_.get(t);if(c)return c;const d=[],h=[];let g=0,m;for(O.lastIndex=0;(m=O.exec(t))!==null;){const f=m[0];d.push(t.slice(g,m.index)),h.push(f),g=m.index+f.length}g<t.length&&d.push(t.slice(g));const a=[];for(const f of h){if(f==="\x1B[0m"||f==="\x1B]8;;\x07"){a.push(f);continue}if(f.startsWith("\x1B[")&&f.endsWith("m")){const x=f.slice(2,-1);if(M.has(x)){a.push(f);continue}}}const s=new Set,B=[];for(const[f,x]of d.entries()){if(f>0&&h[f-1]){const n=h[f-1];if(n==="\x1B[0m")s.clear();else if(n==="\x1B]8;;\x07"){for(const i of s)if(i.startsWith("\x1B]8;;")&&!i.endsWith("\x1B]8;;\x07")){s.delete(i);break}}else if(n.startsWith("\x1B[")&&n.endsWith("m")){const i=n.slice(2,-1);if(i==="39"){for(const e of s)if(e.startsWith("\x1B[")&&e.endsWith("m")){const o=e.slice(2,-1);if(S(o)){s.delete(e);break}}}else if(i==="49"){for(const e of s)if(e.startsWith("\x1B[")&&e.endsWith("m")){const o=e.slice(2,-1);if(w(o)){s.delete(e);break}}}else if(y.has(i)){const e=y.get(i);for(const o of s)if(o===`\x1B[${e}m`){s.delete(o);break}}else{if(S(i)){for(const e of s)if(e.startsWith("\x1B[")&&e.endsWith("m")){const o=e.slice(2,-1);if(S(o)){s.delete(e);break}}}else if(w(i)){for(const e of s)if(e.startsWith("\x1B[")&&e.endsWith("m")){const o=e.slice(2,-1);if(w(o)){s.delete(e);break}}}else if(P.has(i)){const e=`\x1B[${i}m`;s.has(e)&&s.delete(e)}s.add(n)}}else if(n.startsWith("\x1B]8;;")&&!n.endsWith("\x1B]8;;\x07")){for(const i of s)if(i.startsWith("\x1B]8;;")&&!i.endsWith("\x1B]8;;\x07")){s.delete(i);break}s.add(n)}}if(x==="")continue;let u="";if(s.size>0)if(a.includes("\x1B[0m"))u="\x1B[0m";else{const n=[];let i=!1;for(const r of s)if(r.startsWith("\x1B]8;;")&&!r.endsWith("\x1B]8;;\x07")){i=!0;break}i&&a.includes("\x1B]8;;\x07")&&n.push("\x1B]8;;\x07");let e=!1,o=!1;for(const r of s)if(r.startsWith("\x1B[")&&r.endsWith("m")){const W=r.slice(2,-1);S(W)?e=!0:w(W)&&(o=!0)}if(e&&o){const r=A(t,["\x1B[3","\x1B[9","\x1B[38;"]),W=A(t,["\x1B[4","\x1B[10","\x1B[48;"]);r>=0&&W>=0?r>W?n.push("\x1B[39m","\x1B[49m"):n.push("\x1B[49m","\x1B[39m"):n.push("\x1B[39m","\x1B[49m")}else e&&n.push("\x1B[39m"),o&&n.push("\x1B[49m");e&&o&&t.includes("\x1B[39m")&&t.includes("\x1B[49m")&&(t.indexOf("\x1B[39m")<t.indexOf("\x1B[49m")?(n.length-=e&&o?2:e||o?1:0,n.push("\x1B[39m","\x1B[49m")):t.indexOf("\x1B[49m")<t.indexOf("\x1B[39m")&&(n.length-=e&&o?2:e||o?1:0,n.push("\x1B[49m","\x1B[39m")));const E=V.filter(r=>s.has(r.open)).map(r=>({position:t.indexOf(r.open),style:r})).filter(r=>r.position>=0).sort((r,W)=>W.position-r.position);for(const r of E)a.includes(r.style.close)&&n.push(r.style.close);u=n.join("")}const p=[...s].join("");B.push({after:u,before:p,content:x,visibleLength:I(x,{fullWidth:1,wideWidth:1})})}return _.set(t,B),B},"processIntoStyledSegments"),C=b((t,l,c,d)=>{const h=[...d.segmenter.segment(t)],g=[];let m=0,a=!1;for(const s of h){const B=I(s.segment,d.width),f=m,x=m+B;if(!a)if(f<l){m=x;continue}else a=!0;if(f>=c||x>c)break;g.push(s.segment),m=x}return g.join("")},"fastSlice"),H=b((t,l=0,c=Number.MAX_SAFE_INTEGER,d={})=>{const h={segmenter:F,...d};if(l>=c||t==="")return"";const g=I(t,h.width);if(l===0&&c>=g)return t;if(l<0||c<0)throw new RangeError("Negative indices aren't supported");if(!t.includes("\x1B"))return/^[\u0000-\u007F]*$/.test(t)?t.slice(l,c):C(t,l,c,h);if(v.lastIndex=0,L.lastIndex=0,!v.test(t)&&!L.test(t))return t;const m=$(t,h);if(m.length===0)return"";let a=0;const s=[];for(const[x,u]of m.entries()){const p=a,n=a+u.visibleLength;if(n>l&&p<c){const i=Math.max(0,l-p),e=Math.min(u.visibleLength,c-p);s.push({end:e,index:x,segment:u,start:i})}a=n}if(s.length===0)return"";const B=[],f=s[0].segment;B.push(f.before);for(let x=0;x<s.length;x++){const{end:u,segment:p,start:n}=s[x];if(n===0&&u===p.visibleLength)B.push(p.content);else{const i=[...h.segmenter.segment(p.content)];B.push(i.slice(n,u).map(e=>e.segment).join(""))}if(x<s.length-1){const i=s[x+1].segment,e=p.after,o=i.before;e!==o&&(e||o)&&B.push(e,o)}}return B.push(s.at(-1).segment.after),B.join("")},"slice");export{H as slice};
+import { a as RE_VALID_ANSI_PAIRS, b as RE_VALID_HYPERLINKS, c as RE_ANSI } from './packem_shared/constants-CTzC6Gjg.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 ANSI_RESET_CODES = /* @__PURE__ */ new Set([
+  "0",
+  // Full reset
+  "22",
+  // Bold reset
+  "23",
+  // Italic reset
+  "24",
+  // Underline reset
+  "27",
+  // Inverse reset
+  "28",
+  // Hidden reset
+  "29",
+  // Strikethrough reset
+  "39",
+  // Foreground color reset
+  "49"
+  // Background color reset
+]);
+const STYLE_CODES = /* @__PURE__ */ new Set([
+  "1",
+  // Bold
+  "3",
+  // Italic
+  "4",
+  // Underline
+  "7",
+  // Inverse
+  "8",
+  // Hidden
+  "9"
+  // Strikethrough
+]);
+const FORMAT_RESET_CODES = /* @__PURE__ */ new Map([
+  ["22", "1"],
+  // Bold reset
+  ["23", "3"],
+  // Italic reset
+  ["24", "4"],
+  // Underline reset
+  ["27", "7"],
+  // Inverse reset
+  ["28", "8"],
+  // Hidden reset
+  ["29", "9"]
+  // Strikethrough reset
+]);
+const isForegroundColor = (code) => code >= "30" && code <= "37" || code >= "90" && code <= "97" || code.startsWith("38;");
+const isBackgroundColor = (code) => code >= "40" && code <= "47" || code >= "100" && code <= "107" || code.startsWith("48;");
+const FORMAT_STYLES = [
+  { close: "\x1B[22m", open: "\x1B[1m" },
+  // Bold
+  { close: "\x1B[23m", open: "\x1B[3m" },
+  // Italic
+  { close: "\x1B[24m", open: "\x1B[4m" },
+  // Underline
+  { close: "\x1B[27m", open: "\x1B[7m" },
+  // Inverse
+  { close: "\x1B[28m", open: "\x1B[8m" },
+  // Hidden
+  { close: "\x1B[29m", open: "\x1B[9m" }
+  // Strikethrough
+];
+const findFirstPositionOfAny = (input, substrings) => {
+  let firstPos = -1;
+  for (const substring of substrings) {
+    const pos = input.indexOf(substring);
+    if (pos !== -1 && (firstPos === -1 || pos < firstPos)) {
+      firstPos = pos;
+    }
+  }
+  return firstPos;
+};
+const processIntoStyledSegments = (input, options) => {
+  if (!input.includes("\x1B")) {
+    return [
+      {
+        after: "",
+        before: "",
+        content: input,
+        visibleLength: getStringWidth(input, options.width)
+      }
+    ];
+  }
+  const cachedResult = segmentCache.get(input);
+  if (cachedResult) {
+    return cachedResult;
+  }
+  const parts = [];
+  const matches = [];
+  let lastIndex = 0;
+  let match;
+  RE_ANSI.lastIndex = 0;
+  while ((match = RE_ANSI.exec(input)) !== null) {
+    const matchedText = match[0];
+    parts.push(input.slice(lastIndex, match.index));
+    matches.push(matchedText);
+    lastIndex = match.index + matchedText.length;
+  }
+  if (lastIndex < input.length) {
+    parts.push(input.slice(lastIndex));
+  }
+  const closingSequences = [];
+  for (const ansi of matches) {
+    if (ansi === "\x1B[0m" || ansi === "\x1B]8;;\x07") {
+      closingSequences.push(ansi);
+      continue;
+    }
+    if (ansi.startsWith("\x1B[") && ansi.endsWith("m")) {
+      const code = ansi.slice(2, -1);
+      if (ANSI_RESET_CODES.has(code)) {
+        closingSequences.push(ansi);
+        continue;
+      }
+    }
+  }
+  const activeStylesSet = /* @__PURE__ */ new Set();
+  const segments = [];
+  for (const [index, text] of parts.entries()) {
+    if (index > 0 && matches[index - 1]) {
+      const ansi = matches[index - 1];
+      if (ansi === "\x1B[0m") {
+        activeStylesSet.clear();
+      } else if (ansi === "\x1B]8;;\x07") {
+        for (const style of activeStylesSet) {
+          if (style.startsWith("\x1B]8;;") && !style.endsWith("\x1B]8;;\x07")) {
+            activeStylesSet.delete(style);
+            break;
+          }
+        }
+      } else if (ansi.startsWith("\x1B[") && ansi.endsWith("m")) {
+        const code = ansi.slice(2, -1);
+        if (code === "39") {
+          for (const style of activeStylesSet) {
+            if (style.startsWith("\x1B[") && style.endsWith("m")) {
+              const styleCode = style.slice(2, -1);
+              if (isForegroundColor(styleCode)) {
+                activeStylesSet.delete(style);
+                break;
+              }
+            }
+          }
+        } else if (code === "49") {
+          for (const style of activeStylesSet) {
+            if (style.startsWith("\x1B[") && style.endsWith("m")) {
+              const styleCode = style.slice(2, -1);
+              if (isBackgroundColor(styleCode)) {
+                activeStylesSet.delete(style);
+                break;
+              }
+            }
+          }
+        } else if (FORMAT_RESET_CODES.has(code)) {
+          const targetCode = FORMAT_RESET_CODES.get(code);
+          for (const style of activeStylesSet) {
+            if (style === `\x1B[${targetCode}m`) {
+              activeStylesSet.delete(style);
+              break;
+            }
+          }
+        } else {
+          if (isForegroundColor(code)) {
+            for (const style of activeStylesSet) {
+              if (style.startsWith("\x1B[") && style.endsWith("m")) {
+                const styleCode = style.slice(2, -1);
+                if (isForegroundColor(styleCode)) {
+                  activeStylesSet.delete(style);
+                  break;
+                }
+              }
+            }
+          } else if (isBackgroundColor(code)) {
+            for (const style of activeStylesSet) {
+              if (style.startsWith("\x1B[") && style.endsWith("m")) {
+                const styleCode = style.slice(2, -1);
+                if (isBackgroundColor(styleCode)) {
+                  activeStylesSet.delete(style);
+                  break;
+                }
+              }
+            }
+          } else if (STYLE_CODES.has(code)) {
+            const targetStyle = `\x1B[${code}m`;
+            if (activeStylesSet.has(targetStyle)) {
+              activeStylesSet.delete(targetStyle);
+            }
+          }
+          activeStylesSet.add(ansi);
+        }
+      } else if (ansi.startsWith("\x1B]8;;") && !ansi.endsWith("\x1B]8;;\x07")) {
+        for (const style of activeStylesSet) {
+          if (style.startsWith("\x1B]8;;") && !style.endsWith("\x1B]8;;\x07")) {
+            activeStylesSet.delete(style);
+            break;
+          }
+        }
+        activeStylesSet.add(ansi);
+      }
+    }
+    if (text === "") {
+      continue;
+    }
+    let closingSequence = "";
+    if (activeStylesSet.size > 0) {
+      if (closingSequences.includes("\x1B[0m")) {
+        closingSequence = "\x1B[0m";
+      } else {
+        const closingParts = [];
+        let needsHyperlinkClose = false;
+        for (const style of activeStylesSet) {
+          if (style.startsWith("\x1B]8;;") && !style.endsWith("\x1B]8;;\x07")) {
+            needsHyperlinkClose = true;
+            break;
+          }
+        }
+        if (needsHyperlinkClose && closingSequences.includes("\x1B]8;;\x07")) {
+          closingParts.push("\x1B]8;;\x07");
+        }
+        let needsForegroundClose = false;
+        let needsBackgroundClose = false;
+        for (const style of activeStylesSet) {
+          if (style.startsWith("\x1B[") && style.endsWith("m")) {
+            const styleCode = style.slice(2, -1);
+            if (isForegroundColor(styleCode)) {
+              needsForegroundClose = true;
+            } else if (isBackgroundColor(styleCode)) {
+              needsBackgroundClose = true;
+            }
+          }
+        }
+        if (needsForegroundClose && needsBackgroundClose) {
+          const fgOpenPos = findFirstPositionOfAny(input, [
+            "\x1B[3",
+            // Basic colors 30-37
+            "\x1B[9",
+            // Bright colors 90-97
+            "\x1B[38;"
+            // RGB/256 colors
+          ]);
+          const bgOpenPos = findFirstPositionOfAny(input, [
+            "\x1B[4",
+            // Basic colors 40-47
+            "\x1B[10",
+            // Bright colors 100-107
+            "\x1B[48;"
+            // RGB/256 colors
+          ]);
+          if (fgOpenPos >= 0 && bgOpenPos >= 0) {
+            if (fgOpenPos > bgOpenPos) {
+              closingParts.push("\x1B[39m", "\x1B[49m");
+            } else {
+              closingParts.push("\x1B[49m", "\x1B[39m");
+            }
+          } else {
+            closingParts.push("\x1B[39m", "\x1B[49m");
+          }
+        } else {
+          if (needsForegroundClose) {
+            closingParts.push("\x1B[39m");
+          }
+          if (needsBackgroundClose) {
+            closingParts.push("\x1B[49m");
+          }
+        }
+        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.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.push("\x1B[49m", "\x1B[39m");
+          }
+        }
+        const activeFormatStyles = FORMAT_STYLES.filter((style) => activeStylesSet.has(style.open)).map((style) => {
+          return {
+            position: input.indexOf(style.open),
+            style
+          };
+        }).filter((item) => item.position >= 0).sort((a, b) => b.position - a.position);
+        for (const item of activeFormatStyles) {
+          if (closingSequences.includes(item.style.close)) {
+            closingParts.push(item.style.close);
+          }
+        }
+        closingSequence = closingParts.join("");
+      }
+    }
+    const activeStylesString = [...activeStylesSet].join("");
+    segments.push({
+      after: closingSequence,
+      before: activeStylesString,
+      content: text,
+      visibleLength: getStringWidth(text, {
+        fullWidth: 1,
+        wideWidth: 1
+      })
+    });
+  }
+  segmentCache.set(input, segments);
+  return segments;
+};
+const fastSlice = (inputString, startIndex, endIndex, options) => {
+  const graphemes = [...options.segmenter.segment(inputString)];
+  const result = [];
+  let currentWidth = 0;
+  let startFound = false;
+  for (const grapheme of graphemes) {
+    const graphemeWidth = getStringWidth(grapheme.segment, options.width);
+    const positionBefore = currentWidth;
+    const positionAfter = currentWidth + graphemeWidth;
+    if (!startFound) {
+      if (positionBefore < startIndex) {
+        currentWidth = positionAfter;
+        continue;
+      } else {
+        startFound = true;
+      }
+    }
+    if (positionBefore >= endIndex) {
+      break;
+    }
+    if (positionAfter > endIndex) {
+      break;
+    }
+    result.push(grapheme.segment);
+    currentWidth = positionAfter;
+  }
+  return result.join("");
+};
+const slice = (inputString, startIndex = 0, endIndex = Number.MAX_SAFE_INTEGER, options = {}) => {
+  const config = {
+    segmenter: defaultSegmenter,
+    ...options
+  };
+  if (startIndex >= endIndex || inputString === "") {
+    return "";
+  }
+  const inputStringWidth = getStringWidth(inputString, config.width);
+  if (startIndex === 0 && endIndex >= inputStringWidth) {
+    return inputString;
+  }
+  if (startIndex < 0 || endIndex < 0) {
+    throw new RangeError("Negative indices aren't supported");
+  }
+  if (!inputString.includes("\x1B")) {
+    if (/^[\u0000-\u007F]*$/.test(inputString)) {
+      return inputString.slice(startIndex, endIndex);
+    }
+    return fastSlice(inputString, startIndex, endIndex, config);
+  }
+  RE_VALID_ANSI_PAIRS.lastIndex = 0;
+  RE_VALID_HYPERLINKS.lastIndex = 0;
+  if (!RE_VALID_ANSI_PAIRS.test(inputString) && !RE_VALID_HYPERLINKS.test(inputString)) {
+    return inputString;
+  }
+  const segments = processIntoStyledSegments(inputString, config);
+  if (segments.length === 0) {
+    return "";
+  }
+  let currentPos = 0;
+  const visibleSegments = [];
+  for (const [index, segment] of segments.entries()) {
+    const segmentStart = currentPos;
+    const segmentEnd = currentPos + segment.visibleLength;
+    if (segmentEnd > startIndex && segmentStart < endIndex) {
+      const visibleStart = Math.max(0, startIndex - segmentStart);
+      const visibleEnd = Math.min(segment.visibleLength, endIndex - segmentStart);
+      visibleSegments.push({
+        end: visibleEnd,
+        index,
+        segment,
+        start: visibleStart
+      });
+    }
+    currentPos = segmentEnd;
+  }
+  if (visibleSegments.length === 0) {
+    return "";
+  }
+  const resultParts = [];
+  const firstSegment = visibleSegments[0].segment;
+  resultParts.push(firstSegment.before);
+  for (let index = 0; index < visibleSegments.length; index++) {
+    const { end, segment, start } = visibleSegments[index];
+    if (start === 0 && end === segment.visibleLength) {
+      resultParts.push(segment.content);
+    } else {
+      const graphemes = [...config.segmenter.segment(segment.content)];
+      resultParts.push(
+        graphemes.slice(start, end).map((entry) => entry.segment).join("")
+      );
+    }
+    if (index < visibleSegments.length - 1) {
+      const nextSegment = visibleSegments[index + 1].segment;
+      const segmentAfter = segment.after;
+      const nextBefore = nextSegment.before;
+      if (segmentAfter !== nextBefore && (segmentAfter || nextBefore)) {
+        resultParts.push(segmentAfter, nextBefore);
+      }
+    }
+  }
+  resultParts.push(visibleSegments.at(-1).segment.after);
+  return resultParts.join("");
+};
+
+export { slice };

package/dist/slugify.js

@@ -1 +1,46 @@
-var c=Object.defineProperty;var s=(a,o)=>c(a,"name",{value:o,configurable:!0});import i from"./packem_shared/transliterate-CxVHmZUa.js";import{escapeRegExp as t}from"./utilities.js";var u=Object.defineProperty,p=s((a,o)=>u(a,"name",{value:o,configurable:!0}),"o");const f=p((a,o,e)=>{const r=t(o).replaceAll(String.raw`\-`,"-"),l=new RegExp(`[^${r}]`,"g");return a.replaceAll(l,e)},"removeDisallowedChars"),C=p((a,o)=>{const e={allowedChars:"a-zA-Z0-9-_.~",fixChineseSpacing:!0,ignore:[],lowercase:!0,replaceAfter:[],replaceBefore:[],separator:"-",transliterate:!0,trim:!1,unknown:"",uppercase:!1,...o};e.lowercase&&e.uppercase&&(console.warn("slugify: Both lowercase and uppercase options are true. Defaulting to lowercase."),e.uppercase=!1);let r=e.transliterate?i(a,e):a.normalize("NFC");e.lowercase?r=r.toLowerCase():e.uppercase&&(r=r.toUpperCase()),r=f(r,e.allowedChars,e.separator);const l=t(e.separator);if(l){const n=new RegExp(`${l}+`,"g");r=r.replace(n,e.separator)}return l?r.replaceAll(new RegExp(`^${l}+|${l}+$`,"g"),""):r},"slugify");export{C as default};
+import transliterate from './packem_shared/transliterate-CUF6Ggy_.js';
+import { escapeRegExp } from './utilities.js';
+
+const removeDisallowedChars = (input, allowedChars, separator) => {
+  const escapedChars = escapeRegExp(allowedChars).replaceAll(String.raw`\-`, "-");
+  const pattern = new RegExp(`[^${escapedChars}]`, "g");
+  return input.replaceAll(pattern, separator);
+};
+const slugify = (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;
+};
+
+export { slugify as default };

package/dist/test/utils.js

@@ -1,16 +1,91 @@
-var d=Object.defineProperty;var a=(e,t)=>d(e,"name",{value:t,configurable:!0});import{createRequire as g}from"node:module";import{getStringWidth as l}from"../get-string-width.js";const u=g(import.meta.url),n=typeof globalThis<"u"&&typeof globalThis.process<"u"?globalThis.process:process,f=a(e=>{if(typeof n<"u"&&n.versions&&n.versions.node){const[t,s]=n.versions.node.split(".").map(Number);if(t>22||t===22&&s>=3||t===20&&s>=16)return n.getBuiltinModule(e)}return u(e)},"__cjs_getBuiltinModule"),{stripVTControlCharacters:h,format:m}=f("node:util");var S=Object.defineProperty,o=a((e,t)=>S(e,"name",{value:t,configurable:!0}),"r");const p=o(e=>{const t=h(e);return{ansi:e,json:JSON.stringify(e),lengthDifference:e.length-t.length,stripped:t,visible:e.replaceAll("\x1B",String.raw`\u001B`)}},"formatAnsiString"),j=o((e,t)=>{const s=p(e),i=p(t);return{message:o(()=>{if(e===t)return"ANSI strings are identical";const r=s.stripped===i.stripped;return m(`ANSI string comparison failed:
+import { createRequire as __cjs_createRequire } from "node:module";
 
-Actual:
-  - Visible content: %s
-  - With escape codes: %s
-  - JSON: %s
-  - Length: %d
+const __cjs_require = __cjs_createRequire(import.meta.url);
 
-Expected:
-  - Visible content: %s
-  - With escape codes: %s
-  - JSON: %s
-  - Length: %d
+const __cjs_getProcess = typeof globalThis !== "undefined" && typeof globalThis.process !== "undefined" ? globalThis.process : process;
 
-%s
-`,s.stripped,s.visible,s.json,l(s.ansi),i.stripped,i.visible,i.json,l(i.ansi),r?"✓ Visible content is identical, but escape codes differ":"✗ Visible content differs")},"message"),pass:e===t}},"expectAnsiStrings"),v=o((e,t)=>{const s=p(e),i=p(t),r=s.stripped===i.stripped,c=e===t;return{actual:s,ansiEqual:c,expected:i,strippedEqual:r,summary:{actualLength:e.length,actualStrippedLength:s.stripped.length,ansiEqual:c,expectedLength:t.length,expectedStrippedLength:i.stripped.length,strippedEqual:r}}},"compareAnsiStrings");export{v as compareAnsiStrings,j as expectAnsiStrings,p as formatAnsiString};
+const __cjs_getBuiltinModule = (module) => {
+    // Check if we're in Node.js and version supports getBuiltinModule
+    if (typeof __cjs_getProcess !== "undefined" && __cjs_getProcess.versions && __cjs_getProcess.versions.node) {
+        const [major, minor] = __cjs_getProcess.versions.node.split(".").map(Number);
+        // Node.js 20.16.0+ and 22.3.0+
+        if (major > 22 || (major === 22 && minor >= 3) || (major === 20 && minor >= 16)) {
+            return __cjs_getProcess.getBuiltinModule(module);
+        }
+    }
+    // Fallback to createRequire
+    return __cjs_require(module);
+};
+
+const {
+  stripVTControlCharacters,
+  format
+} = __cjs_getBuiltinModule("node:util");
+import { getStringWidth } from '../get-string-width.js';
+
+const formatAnsiString = (ansiString) => {
+  const stripped = stripVTControlCharacters(ansiString);
+  return {
+    // Original ANSI string
+    ansi: ansiString,
+    // JSON stringified version to see all escape codes
+    json: JSON.stringify(ansiString),
+    // Length difference between ANSI and stripped string
+    lengthDifference: ansiString.length - stripped.length,
+    // String with ANSI codes stripped
+    stripped,
+    // String with ANSI escape codes shown as visible characters
+    visible: ansiString.replaceAll("\x1B", String.raw`\u001B`)
+  };
+};
+const expectAnsiStrings = (actual, expected) => {
+  const actualFormatted = formatAnsiString(actual);
+  const expectedFormatted = formatAnsiString(expected);
+  return {
+    message: () => {
+      if (actual === expected) {
+        return "ANSI strings are identical";
+      }
+      const strippedEqual = actualFormatted.stripped === expectedFormatted.stripped;
+      return format(
+        "ANSI string comparison failed:\n\nActual:\n  - Visible content: %s\n  - With escape codes: %s\n  - JSON: %s\n  - Length: %d\n\nExpected:\n  - Visible content: %s\n  - With escape codes: %s\n  - JSON: %s\n  - Length: %d\n\n%s\n",
+        actualFormatted.stripped,
+        actualFormatted.visible,
+        actualFormatted.json,
+        getStringWidth(actualFormatted.ansi),
+        expectedFormatted.stripped,
+        expectedFormatted.visible,
+        expectedFormatted.json,
+        getStringWidth(expectedFormatted.ansi),
+        strippedEqual ? "✓ Visible content is identical, but escape codes differ" : "✗ Visible content differs"
+      );
+    },
+    pass: actual === expected
+  };
+};
+const compareAnsiStrings = (actual, expected) => {
+  const actualFormatted = formatAnsiString(actual);
+  const expectedFormatted = formatAnsiString(expected);
+  const strippedEqual = actualFormatted.stripped === expectedFormatted.stripped;
+  const ansiEqual = actual === expected;
+  return {
+    // Format information for both strings
+    actual: actualFormatted,
+    // Are the strings identical including ANSI codes?
+    ansiEqual,
+    expected: expectedFormatted,
+    // Are the strings identical when ANSI codes are stripped?
+    strippedEqual,
+    // Summary information
+    summary: {
+      actualLength: actual.length,
+      actualStrippedLength: actualFormatted.stripped.length,
+      ansiEqual,
+      expectedLength: expected.length,
+      expectedStrippedLength: expectedFormatted.stripped.length,
+      strippedEqual
+    }
+  };
+};
+
+export { compareAnsiStrings, expectAnsiStrings, formatAnsiString };

package/dist/test/vitest.js

@@ -1 +1,5 @@
-var i=Object.defineProperty;var t=(e,r)=>i(e,"name",{value:r,configurable:!0});import{expectAnsiStrings as n}from"./utils.js";var o=Object.defineProperty,a=t((e,r)=>o(e,"name",{value:r,configurable:!0}),"i");const c=a((e,r)=>n(e,r),"toEqualAnsi");export{c as toEqualAnsi};
+import { expectAnsiStrings } from './utils.js';
+
+const toEqualAnsi = (actual, expected) => expectAnsiStrings(actual, expected);
+
+export { toEqualAnsi };

package/dist/truncate.js

@@ -1 +1,89 @@
-var g=Object.defineProperty;var l=(t,i)=>g(t,"name",{value:i,configurable:!0});import{getStringTruncatedWidth as p}from"./get-string-truncated-width.js";import{slice as d}from"./slice.js";var b=Object.defineProperty,f=l((t,i)=>b(t,"name",{value:i,configurable:!0}),"h");const u="…",y=3,h=f((t,i,e=!1)=>{if(t.charAt(i)===" ")return i;const r=e?1:-1,c=Math.min(y,e?t.length-i:i);for(let a=1;a<=c;a++){const n=i+a*r;if(t.charAt(n)===" ")return n}return i},"findNearestSpace"),T=f((t,i,e={})=>{if(typeof t!="string")throw new TypeError(`Expected \`input\` to be a string, got ${typeof t}`);if(typeof i!="number")throw new TypeError(`Expected \`limit\` to be a number, got ${typeof i}`);if(t===""||i<=0)return"";t=t.normalize("NFC");const{ellipsis:r=u,position:c="end",preferTruncationOnSpace:a=!1}=e;let n=e.ellipsisWidth??r===u?1:void 0;n===void 0&&(n=p(r,{...e.width,ellipsis:"",ellipsisWidth:0,limit:Number.POSITIVE_INFINITY}).width);const{width:o}=p(t,{...e.width,ellipsis:r,ellipsisWidth:n});if(o<=i)return t;switch(c){case"end":{if(a){const s=h(t,i-1);return d(t,0,s,{width:e.width})+r}return d(t,0,i-n,{width:e.width})+r}case"middle":{const s=Math.floor(i/2);if(a){const w=h(t,s),m=h(t,o-(i-s)+1,!0);return d(t,0,w)+r+d(t,m,o).trim()}return d(t,0,s,{width:e.width})+r+d(t,o-(i-s)+n,o,{width:e.width})}case"start":{if(a){const s=h(t,o-i+1,!0);return r+d(t,s,o).trim()}return r+d(t,o-i+n,o,{width:e.width})}default:throw new Error(`Invalid position: expected 'start', 'middle' or 'end', got '${c}'`)}},"truncate");export{T as truncate};
+import { getStringTruncatedWidth } from './get-string-truncated-width.js';
+import { slice } from './slice.js';
+
+const DEFAULT_ELLIPSIS = "…";
+const MAX_SPACE_SEARCH_DISTANCE = 3;
+const findNearestSpace = (string_, startIndex, searchRight = false) => {
+  if (string_.charAt(startIndex) === " ") {
+    return startIndex;
+  }
+  const direction = searchRight ? 1 : -1;
+  const limit = Math.min(MAX_SPACE_SEARCH_DISTANCE, searchRight ? string_.length - startIndex : startIndex);
+  for (let offset = 1; offset <= limit; offset++) {
+    const index = startIndex + offset * direction;
+    if (string_.charAt(index) === " ") {
+      return index;
+    }
+  }
+  return startIndex;
+};
+const truncate = (input, limit, options = {}) => {
+  if (typeof input !== "string") {
+    throw new TypeError(`Expected \`input\` to be a string, got ${typeof input}`);
+  }
+  if (typeof limit !== "number") {
+    throw new TypeError(`Expected \`limit\` to be a number, got ${typeof limit}`);
+  }
+  if (input === "" || limit <= 0) {
+    return "";
+  }
+  input = input.normalize("NFC");
+  const { ellipsis = DEFAULT_ELLIPSIS, position = "end", preferTruncationOnSpace = false } = options;
+  let ellipsisWidth = options.ellipsisWidth ?? ellipsis === DEFAULT_ELLIPSIS ? 1 : void 0;
+  if (ellipsisWidth === void 0) {
+    ellipsisWidth = getStringTruncatedWidth(ellipsis, {
+      ...options.width,
+      ellipsis: "",
+      ellipsisWidth: 0,
+      limit: Number.POSITIVE_INFINITY
+    }).width;
+  }
+  const { width } = getStringTruncatedWidth(input, {
+    ...options.width,
+    ellipsis,
+    ellipsisWidth
+  });
+  if (width <= limit) {
+    return input;
+  }
+  switch (position) {
+    case "end": {
+      if (preferTruncationOnSpace) {
+        const nearestSpace = findNearestSpace(input, limit - 1);
+        return slice(input, 0, nearestSpace, {
+          width: options.width
+        }) + ellipsis;
+      }
+      return slice(input, 0, limit - ellipsisWidth, {
+        width: options.width
+      }) + ellipsis;
+    }
+    case "middle": {
+      const half = Math.floor(limit / 2);
+      if (preferTruncationOnSpace) {
+        const firstBreak = findNearestSpace(input, half);
+        const secondBreak = findNearestSpace(input, width - (limit - half) + 1, true);
+        return slice(input, 0, firstBreak) + ellipsis + slice(input, secondBreak, width).trim();
+      }
+      return slice(input, 0, half, {
+        width: options.width
+      }) + ellipsis + slice(input, width - (limit - half) + ellipsisWidth, width, {
+        width: options.width
+      });
+    }
+    case "start": {
+      if (preferTruncationOnSpace) {
+        const nearestSpace = findNearestSpace(input, width - limit + 1, true);
+        return ellipsis + slice(input, nearestSpace, width).trim();
+      }
+      return ellipsis + slice(input, width - limit + ellipsisWidth, width, {
+        width: options.width
+      });
+    }
+    default: {
+      throw new Error(`Invalid position: expected 'start', 'middle' or 'end', got '${position}'`);
+    }
+  }
+};
+
+export { truncate };