@socprime/logtotal-sanitizer 0.2.0-beta.2 → 0.2.1-beta.0

package/{chunk-XPVOBYVK.cjs → chunk-ZCWN2P2R.cjs}

@@ -1,6 +1,6 @@
 'use strict';
 
-var chunkEUNFMCKE_cjs = require('./chunk-EUNFMCKE.cjs');
+var chunkVELXTD3L_cjs = require('./chunk-VELXTD3L.cjs');
 
 // src/core/constants.ts
 var DEFAULT_PREVIEW_BYTES = 256 * 1024;
@@ -200,11 +200,11 @@ function bytesToHex(bytes) {
 var HEX_PATTERN = /^(?:[0-9a-fA-F]{2})+$/;
 function generateKey(byteLength = DEFAULT_KEY_BYTES) {
   if (!Number.isInteger(byteLength) || byteLength < 16) {
-    throw new chunkEUNFMCKE_cjs.InvalidKeyError(`Key length must be an integer of at least 16 bytes, got ${byteLength}.`);
+    throw new chunkVELXTD3L_cjs.InvalidKeyError(`Key length must be an integer of at least 16 bytes, got ${byteLength}.`);
   }
   const source = globalThis.crypto;
   if (typeof source?.getRandomValues !== "function") {
-    throw new chunkEUNFMCKE_cjs.InvalidKeyError(
+    throw new chunkVELXTD3L_cjs.InvalidKeyError(
       "No secure random source available. Pass an explicit `key` or provide a Web Crypto implementation on globalThis.crypto."
     );
   }
@@ -214,10 +214,10 @@ function generateKey(byteLength = DEFAULT_KEY_BYTES) {
 }
 function assertKey(key, encoding) {
   if (key.length === 0) {
-    throw new chunkEUNFMCKE_cjs.InvalidKeyError("Key must not be empty.");
+    throw new chunkVELXTD3L_cjs.InvalidKeyError("Key must not be empty.");
   }
   if (encoding === "hex" && !HEX_PATTERN.test(key)) {
-    throw new chunkEUNFMCKE_cjs.InvalidKeyError(
+    throw new chunkVELXTD3L_cjs.InvalidKeyError(
       'A hex key must contain an even number of hexadecimal characters. Pass `keyEncoding: "utf8"` for a passphrase.'
     );
   }
@@ -237,7 +237,7 @@ function normalizePatterns(patterns) {
     try {
       new RegExp(source, "u");
     } catch (cause) {
-      throw new chunkEUNFMCKE_cjs.InvalidOptionError(
+      throw new chunkVELXTD3L_cjs.InvalidOptionError(
         `alwaysRedact.patterns contains an invalid regular expression: ${String(cause)}`
       );
     }
@@ -278,7 +278,7 @@ function compileAnchored(patterns) {
   try {
     return new RegExp(`^(?:${combined})$`, "u");
   } catch (cause) {
-    throw new chunkEUNFMCKE_cjs.InvalidOptionError(
+    throw new chunkVELXTD3L_cjs.InvalidOptionError(
       `neverRedact.patterns contains an invalid regular expression: ${String(cause)}`
     );
   }
@@ -365,13 +365,13 @@ function compileOne(rule, aggressive) {
     try {
       fragments.push({
         regex: new RegExp(pattern, "gu"),
-        hasValueGroup: chunkEUNFMCKE_cjs.countCapturingGroups(pattern) === 1
+        hasValueGroup: chunkVELXTD3L_cjs.countCapturingGroups(pattern) === 1
       });
     } catch (cause) {
-      throw new chunkEUNFMCKE_cjs.InvalidRuleError(`Failed to compile rule "${rule.id}": ${String(cause)}`);
+      throw new chunkVELXTD3L_cjs.InvalidRuleError(`Failed to compile rule "${rule.id}": ${String(cause)}`);
     }
   }
-  const gateSource = patterns.map(chunkEUNFMCKE_cjs.deriveGateSource).join("|");
+  const gateSource = patterns.map(chunkVELXTD3L_cjs.deriveGateSource).join("|");
   let gate = null;
   if (!SKIP_REGEX_GATE.has(rule.id) && gateSource.length > 0 && gateSource !== source) {
     try {
@@ -431,10 +431,10 @@ function createLineSplitter(options = {}) {
   const maxLineChars = options.maxLineChars ?? DEFAULT_MAX_LINE_CHARS;
   const overlapChars = options.overlapChars ?? DEFAULT_LINE_OVERLAP_CHARS;
   if (maxLineChars < 1) {
-    throw new chunkEUNFMCKE_cjs.InvalidOptionError("lines.maxLineChars must be at least 1.");
+    throw new chunkVELXTD3L_cjs.InvalidOptionError("lines.maxLineChars must be at least 1.");
   }
   if (overlapChars < 0 || overlapChars >= maxLineChars) {
-    throw new chunkEUNFMCKE_cjs.InvalidOptionError(
+    throw new chunkVELXTD3L_cjs.InvalidOptionError(
       `lines.overlapChars must be between 0 and lines.maxLineChars - 1 (${maxLineChars - 1}), got ${overlapChars}.`
     );
   }
@@ -461,6 +461,181 @@ function createLineSplitter(options = {}) {
   return { push, flush };
 }
 
+// src/core/jsonKeyMatcher.ts
+var RESOLVE_CACHE_LIMIT = 1e4;
+function normalizeKey2(key) {
+  return key.toLowerCase().replace(/[-_.\s]/g, "");
+}
+function shouldPreserveJsonValue(value) {
+  return value.length === 0 || value === "-";
+}
+function buildTables(rules) {
+  const exact = /* @__PURE__ */ new Map();
+  const contains = [];
+  for (const rule of rules) {
+    for (const key of rule.jsonKeys ?? []) {
+      const normalized = normalizeKey2(key);
+      if (!exact.has(normalized)) {
+        exact.set(normalized, rule);
+      }
+    }
+    for (const fragment of rule.jsonKeyContains ?? []) {
+      contains.push({ fragment: normalizeKey2(fragment), rule });
+    }
+  }
+  return { exact, contains };
+}
+function lastSegment(key) {
+  const dot = key.lastIndexOf(".");
+  return dot === -1 ? key : key.slice(dot + 1);
+}
+function resolveUncached(tables, key, parent) {
+  const dot = key.lastIndexOf(".");
+  const leaf = normalizeKey2(dot === -1 ? key : key.slice(dot + 1));
+  const parentRaw = dot === -1 ? parent : key.slice(0, dot);
+  if (leaf.length === 0) {
+    return null;
+  }
+  if (parentRaw !== void 0) {
+    const scoped = tables.exact.get(normalizeKey2(lastSegment(parentRaw)) + leaf);
+    if (scoped) {
+      return scoped;
+    }
+  }
+  const exact = tables.exact.get(leaf);
+  if (exact) {
+    return exact;
+  }
+  for (const entry of tables.contains) {
+    if (leaf.includes(entry.fragment)) {
+      return entry.rule;
+    }
+  }
+  return null;
+}
+function buildMatcher(rules) {
+  const tables = buildTables(rules);
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    resolve(key, parent) {
+      const cacheKey = parent === void 0 ? key : `${parent}\0${key}`;
+      let rule = cache.get(cacheKey);
+      if (rule === void 0) {
+        rule = resolveUncached(tables, key, parent);
+        if (cache.size >= RESOLVE_CACHE_LIMIT) {
+          cache.clear();
+        }
+        cache.set(cacheKey, rule);
+      }
+      return rule ?? void 0;
+    }
+  };
+}
+var matcherCache = /* @__PURE__ */ new WeakMap();
+function jsonKeyMatcher(rules) {
+  const cached = matcherCache.get(rules);
+  if (cached) {
+    return cached;
+  }
+  const matcher = buildMatcher(rules);
+  matcherCache.set(rules, matcher);
+  return matcher;
+}
+
+// src/core/redactKeyValuePairs.ts
+var NUMBER = "(-?\\d+(?:\\.\\d+)?(?:[eE][+-]?\\d+)?)(?![\\w.:+-])";
+var DOUBLE_QUOTED = new RegExp(
+  `(?<![\\\\\\w])"((?:[^"\\\\\\r\\n]|\\\\.){1,128})"\\s*:\\s*(?:"((?:[^"\\\\]|\\\\.)*)"|${NUMBER})`,
+  "g"
+);
+var ESCAPED = new RegExp(
+  `\\\\"((?:[^"\\\\\\r\\n]|\\\\\\\\){1,128})\\\\"\\s*:\\s*(?:\\\\"((?:\\\\\\\\\\\\"|\\\\\\\\|\\\\[^"\\\\]|[^"\\\\])*)\\\\"|${NUMBER})`,
+  "g"
+);
+var SINGLE_QUOTED = new RegExp(
+  `(?<![\\\\\\w])'((?:[^'\\\\\\r\\n]|\\\\.){1,128})'\\s*:\\s*(?:'((?:[^'\\\\]|\\\\.)*)'|"((?:[^"\\\\]|\\\\.)*)"|${NUMBER})`,
+  "g"
+);
+function decodeJsonString(raw) {
+  if (!raw.includes("\\")) {
+    return raw;
+  }
+  try {
+    return JSON.parse(`"${raw}"`);
+  } catch {
+    return raw;
+  }
+}
+function decodeEscapedJsonString(raw) {
+  return decodeJsonString(decodeJsonString(raw));
+}
+function decodePythonString(raw) {
+  return raw.includes("\\") ? raw.replace(/\\(['"\\])/g, "$1") : raw;
+}
+function collect(line, regex, rules, decode, numberQuote, out) {
+  const matcher = jsonKeyMatcher(rules);
+  regex.lastIndex = 0;
+  for (let found = regex.exec(line); found !== null; found = regex.exec(line)) {
+    const rawKey = found[1];
+    let rawValue;
+    let quote = "";
+    for (let group = 2; group < found.length; group += 1) {
+      if (found[group] !== void 0) {
+        rawValue = found[group];
+        quote = group === found.length - 1 ? numberQuote : "";
+        break;
+      }
+    }
+    if (rawValue === void 0) {
+      continue;
+    }
+    const value = quote === "" ? decode(rawValue) : rawValue;
+    if (shouldPreserveJsonValue(value)) {
+      continue;
+    }
+    const rule = matcher.resolve(decode(rawKey));
+    if (!rule) {
+      continue;
+    }
+    const end = found.index + found[0].length - (quote === "" ? 1 : 0);
+    const valueEnd = quote === "" && regex === ESCAPED ? end - 1 : end;
+    out.push({
+      keyStart: found.index,
+      match: { start: valueEnd - rawValue.length, end: valueEnd, value, rule, quote }
+    });
+  }
+}
+function findKeyValueMatches(line, rules) {
+  const doubleQuoted = line.includes('":') || line.includes('" :');
+  const singleQuoted = line.includes("':") || line.includes("' :");
+  if (!doubleQuoted && !singleQuoted) {
+    return [];
+  }
+  const candidates = [];
+  if (doubleQuoted) {
+    collect(line, DOUBLE_QUOTED, rules, decodeJsonString, '"', candidates);
+    if (line.includes('\\"')) {
+      collect(line, ESCAPED, rules, decodeEscapedJsonString, '\\"', candidates);
+    }
+  }
+  if (singleQuoted) {
+    collect(line, SINGLE_QUOTED, rules, decodePythonString, "'", candidates);
+  }
+  if (candidates.length === 0) {
+    return [];
+  }
+  candidates.sort((left, right) => left.keyStart - right.keyStart);
+  const matches = [];
+  let floor = 0;
+  for (const { keyStart, match } of candidates) {
+    if (keyStart >= floor) {
+      matches.push(match);
+      floor = match.end;
+    }
+  }
+  return matches;
+}
+
 // src/core/redactLine.ts
 function sliceContext(text, index, length, chars) {
   return {
@@ -498,7 +673,7 @@ function openCursors(line, compiled) {
   const cursors = [];
   for (let ruleIndex = 0; ruleIndex < compiled.length; ruleIndex += 1) {
     const rule = compiled[ruleIndex];
-    if (rule.gateChars !== null && !chunkEUNFMCKE_cjs.lineHasAnyChar(line, rule.gateChars)) {
+    if (rule.gateChars !== null && !chunkVELXTD3L_cjs.lineHasAnyChar(line, rule.gateChars)) {
       continue;
     }
     if (rule.gate !== null) {
@@ -540,11 +715,21 @@ function pickNext(cursors) {
   }
   return best;
 }
+function blankOut(line, spans) {
+  let out = "";
+  let cursor = 0;
+  for (const span of spans) {
+    out += line.slice(cursor, span.start) + " ".repeat(span.end - span.start);
+    cursor = span.end;
+  }
+  return out + line.slice(cursor);
+}
 function redactLine(line, ctx, options = {}) {
   const { compiled, rulesById, allow, contextChars } = ctx;
   const withSegments = options.withSegments ?? false;
   const withMatches = options.withMatches ?? false;
-  if (compiled.length === 0) {
+  const keyed = ctx.json ? findKeyValueMatches(line, ctx.rules) : [];
+  if (compiled.length === 0 && keyed.length === 0) {
     return {
       output: line,
       counts: {},
@@ -552,18 +737,65 @@ function redactLine(line, ctx, options = {}) {
       segments: withSegments ? { before: [{ text: line, changed: false }], after: [{ text: line, changed: false }] } : void 0
     };
   }
-  const cursors = openCursors(line, compiled);
+  const scan = keyed.length === 0 ? line : blankOut(line, keyed);
+  const cursors = openCursors(scan, compiled);
   const counts = {};
   const matches = [];
   const before = [];
   const after = [];
   let output = "";
   let cursor = 0;
+  let keyedIndex = 0;
   for (; ; ) {
     const next = pickNext(cursors);
+    const pending = keyed[keyedIndex];
+    if (pending !== void 0 && (next === null || pending.start <= next.start)) {
+      keyedIndex += 1;
+      if (!isAllowed(allow, pending.rule.id, pending.value)) {
+        const token = buildReplacement(ctx, pending.rule.id, pending.value);
+        const raw = line.slice(pending.start, pending.end);
+        if (withSegments) {
+          if (pending.start > cursor) {
+            const gap = line.slice(cursor, pending.start);
+            before.push({ text: gap, changed: false });
+            after.push({ text: gap, changed: false });
+          }
+          before.push({ text: raw, changed: true });
+          if (pending.quote) {
+            after.push({ text: pending.quote, changed: false });
+          }
+          after.push({ text: token, changed: true });
+          if (pending.quote) {
+            after.push({ text: pending.quote, changed: false });
+          }
+        }
+        output += line.slice(cursor, pending.start) + pending.quote + token + pending.quote;
+        cursor = pending.end;
+        counts[pending.rule.id] = (counts[pending.rule.id] ?? 0) + 1;
+        if (withMatches) {
+          matches.push({
+            ruleId: pending.rule.id,
+            original: pending.value,
+            replacement: token,
+            index: pending.start,
+            ...contextChars > 0 ? sliceContext(line, pending.start, raw.length, contextChars) : {}
+          });
+        }
+      }
+      for (const candidate of cursors) {
+        if (candidate.active && candidate.start < pending.end) {
+          advance(candidate, scan, pending.end);
+        }
+      }
+      continue;
+    }
     if (next === null) {
       break;
     }
+    if (pending !== void 0 && next.start + next.original.length > pending.start) {
+      advance(next, scan, next.start + 1);
+      continue;
+    }
     const { start, original, ruleId } = next;
     const spanEnd = start + Math.max(original.length, 1);
     const rule = rulesById.get(ruleId);
@@ -594,7 +826,7 @@ function redactLine(line, ctx, options = {}) {
     }
     for (const candidate of cursors) {
       if (candidate.active && candidate.start < spanEnd) {
-        advance(candidate, line, spanEnd);
+        advance(candidate, scan, spanEnd);
       }
     }
   }
@@ -618,51 +850,6 @@ function looksLikeJson(line) {
   const trimmed = line.trim();
   return trimmed.length > 0 && (trimmed.startsWith("{") || trimmed.startsWith("["));
 }
-function normalizeKey2(key) {
-  return key.toLowerCase().replace(/[-_]/g, "");
-}
-function shouldPreserveJsonValue(value) {
-  return value.length === 0 || value === "-";
-}
-function buildJsonKeyMatcher(rules) {
-  const exact = /* @__PURE__ */ new Map();
-  const contains = [];
-  for (const rule of rules) {
-    for (const key of rule.jsonKeys ?? []) {
-      const normalized = normalizeKey2(key);
-      if (!exact.has(normalized)) {
-        exact.set(normalized, rule);
-      }
-    }
-    for (const fragment of rule.jsonKeyContains ?? []) {
-      contains.push({ fragment: normalizeKey2(fragment), rule });
-    }
-  }
-  return { exact, contains };
-}
-function resolveJsonKeyRule(matcher, key) {
-  const normalized = normalizeKey2(key);
-  const exact = matcher.exact.get(normalized);
-  if (exact) {
-    return exact;
-  }
-  for (const entry of matcher.contains) {
-    if (normalized.includes(entry.fragment)) {
-      return entry.rule;
-    }
-  }
-  return void 0;
-}
-var jsonKeyMatcherCache = /* @__PURE__ */ new WeakMap();
-function jsonKeyMatcher(rules) {
-  const cached = jsonKeyMatcherCache.get(rules);
-  if (cached) {
-    return cached;
-  }
-  const matcher = buildJsonKeyMatcher(rules);
-  jsonKeyMatcherCache.set(rules, matcher);
-  return matcher;
-}
 function mergeCounts(target, source) {
   for (const [id, count] of Object.entries(source)) {
     target[id] = (target[id] ?? 0) + count;
@@ -689,7 +876,27 @@ function highlightReplacements(text) {
 function jsonStringContent(value) {
   return JSON.stringify(value).slice(1, -1);
 }
+function locateJsonNumber(text, value, from = 0) {
+  const re = new RegExp(`:\\s*(${escapeRegExp(value)})(?![\\d.eE])`, "g");
+  re.lastIndex = from;
+  const match = re.exec(text);
+  if (match === null) {
+    return null;
+  }
+  return { index: match.index + match[0].length - value.length, length: value.length };
+}
+function locateQuotedJsonValue(text, value, from = 0) {
+  const encoded = jsonStringContent(value);
+  const quotedAt = text.indexOf(`"${encoded}"`, from);
+  if (quotedAt === -1) {
+    return null;
+  }
+  return { index: quotedAt + 1, length: encoded.length };
+}
 function findOriginal(text, original, from) {
+  if (original.number === true) {
+    return locateJsonNumber(text, original.value, from);
+  }
   const encoded = jsonStringContent(original.value);
   if (original.wholeValue) {
     const quoted = `"${encoded}"`;
@@ -772,31 +979,39 @@ function redactJsonLine(line, ctx, options = {}) {
     }
     return { contextBefore: "", contextAfter: "" };
   };
-  const redactValue = (value, key) => {
+  const redactField = (rule, value, number) => {
+    if (isAllowed(ctx.allow, rule.id, value)) {
+      return null;
+    }
+    const replacement = buildReplacement(ctx, rule.id, value);
+    counts[rule.id] = (counts[rule.id] ?? 0) + 1;
+    if (withSegments) {
+      originals.push({ value, wholeValue: true, number });
+    }
+    if (withMatches) {
+      const located = number ? locateJsonNumber(content, value) : locateQuotedJsonValue(content, value);
+      matches.push({
+        ruleId: rule.id,
+        original: value,
+        replacement,
+        index: located?.index ?? 0,
+        ...located && ctx.contextChars > 0 ? sliceContext(content, located.index, located.length, ctx.contextChars) : ctx.contextChars > 0 ? { contextBefore: "", contextAfter: "" } : {}
+      });
+    }
+    return replacement;
+  };
+  const redactValue = (value, key, parent) => {
+    if (typeof value === "number") {
+      const fieldRule = key === void 0 || !Number.isFinite(value) ? void 0 : keyMatcher.resolve(key, parent);
+      return fieldRule ? redactField(fieldRule, String(value), true) ?? value : value;
+    }
     if (typeof value === "string") {
       if (key !== void 0 && shouldPreserveJsonValue(value)) {
         return value;
       }
-      const fieldRule = key === void 0 ? void 0 : resolveJsonKeyRule(keyMatcher, key);
+      const fieldRule = key === void 0 ? void 0 : keyMatcher.resolve(key, parent);
       if (fieldRule) {
-        if (isAllowed(ctx.allow, fieldRule.id, value)) {
-          return value;
-        }
-        const replacement = buildReplacement(ctx, fieldRule.id, value);
-        counts[fieldRule.id] = (counts[fieldRule.id] ?? 0) + 1;
-        if (withSegments) {
-          originals.push({ value, wholeValue: true });
-        }
-        if (withMatches) {
-          matches.push({
-            ruleId: fieldRule.id,
-            original: value,
-            replacement,
-            index: Math.max(content.indexOf(jsonStringContent(value)), 0),
-            ...contextFor(value)
-          });
-        }
-        return replacement;
+        return redactField(fieldRule, value, false) ?? value;
       }
       const result = redactLine(value, ctx, { withMatches: collectOriginals });
       mergeCounts(counts, result.counts);
@@ -813,12 +1028,12 @@ function redactJsonLine(line, ctx, options = {}) {
       return result.output;
     }
     if (Array.isArray(value)) {
-      return value.map((item) => redactValue(item));
+      return value.map((item) => redactValue(item, key, parent));
     }
     if (value !== null && typeof value === "object") {
       const out = {};
       for (const [entryKey, entryValue] of Object.entries(value)) {
-        out[entryKey] = redactValue(entryValue, entryKey);
+        out[entryKey] = redactValue(entryValue, entryKey, key);
       }
       return out;
     }
@@ -846,10 +1061,10 @@ function createReportCollector(options = {}) {
   const maxPerRule = options.maxReplacementsPerRule;
   const limited = maxPerRule !== void 0;
   if (previewBytes < 0) {
-    throw new chunkEUNFMCKE_cjs.InvalidOptionError("report.previewBytes must not be negative.");
+    throw new chunkVELXTD3L_cjs.InvalidOptionError("report.previewBytes must not be negative.");
   }
   if (limited && (maxPerRule < 0 || !Number.isInteger(maxPerRule))) {
-    throw new chunkEUNFMCKE_cjs.InvalidOptionError("report.maxReplacementsPerRule must be a non-negative integer.");
+    throw new chunkVELXTD3L_cjs.InvalidOptionError("report.maxReplacementsPerRule must be a non-negative integer.");
   }
   const counts = {};
   const replacements = /* @__PURE__ */ new Map();
@@ -929,15 +1144,15 @@ function createReportCollector(options = {}) {
 // src/core/resolveRules.ts
 function toRule(selector) {
   if (typeof selector === "string") {
-    const builtin = chunkEUNFMCKE_cjs.getBuiltinRule(selector);
+    const builtin = chunkVELXTD3L_cjs.getBuiltinRule(selector);
     if (!builtin) {
-      throw new chunkEUNFMCKE_cjs.UnknownRuleError(
+      throw new chunkVELXTD3L_cjs.UnknownRuleError(
         `Unknown rule "${selector}". Pass a rule object for custom rules, or one of the built-in identifiers.`
       );
     }
     return builtin;
   }
-  return chunkEUNFMCKE_cjs.validateRule(selector);
+  return chunkVELXTD3L_cjs.validateRule(selector);
 }
 function resolveRules(selectors, extraRules = []) {
   const resolved = [];
@@ -975,7 +1190,7 @@ function createSanitizer(options = {}) {
   assertKey(key, keyEncoding);
   const contextChars = options.report?.contextChars ?? 0;
   if (contextChars < 0) {
-    throw new chunkEUNFMCKE_cjs.InvalidOptionError("report.contextChars must not be negative.");
+    throw new chunkVELXTD3L_cjs.InvalidOptionError("report.contextChars must not be negative.");
   }
   const selected = resolveWithAlwaysRedact(options);
   const ctx = createRuleContext({
@@ -1019,7 +1234,7 @@ function createSanitizer(options = {}) {
     let charsRead = 0;
     const writeLine = async (line) => {
       if (signal?.aborted === true) {
-        throw new chunkEUNFMCKE_cjs.SanitizationAbortedError();
+        throw new chunkVELXTD3L_cjs.SanitizationAbortedError();
       }
       await sink.write(processLine(line, ctx, collector));
     };
@@ -1039,13 +1254,13 @@ function createSanitizer(options = {}) {
   return { key, rules, sanitizeText: sanitizeText2, sanitizeStream: sanitizeStream2 };
 }
 function resolveWithAlwaysRedact(options) {
-  const selected = resolveRules(options.rules ?? chunkEUNFMCKE_cjs.builtinRuleIds, options.extraRules);
+  const selected = resolveRules(options.rules ?? chunkVELXTD3L_cjs.builtinRuleIds, options.extraRules);
   const alwaysRule = createAlwaysRedactRule(options.alwaysRedact);
   if (!alwaysRule) {
     return selected;
   }
   if (selected.some((rule) => rule.id === alwaysRule.id)) {
-    throw new chunkEUNFMCKE_cjs.InvalidOptionError(
+    throw new chunkVELXTD3L_cjs.InvalidOptionError(
       `alwaysRedact.ruleId "${alwaysRule.id}" collides with an active rule. Choose an identifier that is not in use.`
     );
   }
@@ -1238,15 +1453,15 @@ async function snapToNewline(blob, from, probeBytes, maxProbeBytes) {
 }
 async function planLineAlignedRanges(blob, partCount, options = {}) {
   if (!Number.isInteger(partCount) || partCount < 1) {
-    throw new chunkEUNFMCKE_cjs.InvalidOptionError("partCount must be an integer >= 1.");
+    throw new chunkVELXTD3L_cjs.InvalidOptionError("partCount must be an integer >= 1.");
   }
   const probeBytes = options.probeBytes ?? DEFAULT_RANGE_PROBE_BYTES;
   const maxProbeBytes = options.maxProbeBytes ?? DEFAULT_RANGE_MAX_PROBE_BYTES;
   if (!Number.isInteger(probeBytes) || probeBytes < 1) {
-    throw new chunkEUNFMCKE_cjs.InvalidOptionError("probeBytes must be an integer >= 1.");
+    throw new chunkVELXTD3L_cjs.InvalidOptionError("probeBytes must be an integer >= 1.");
   }
   if (!Number.isInteger(maxProbeBytes) || maxProbeBytes < probeBytes) {
-    throw new chunkEUNFMCKE_cjs.InvalidOptionError("maxProbeBytes must be an integer >= probeBytes.");
+    throw new chunkVELXTD3L_cjs.InvalidOptionError("maxProbeBytes must be an integer >= probeBytes.");
   }
   if (blob.size <= 0) {
     return [];
@@ -1308,5 +1523,5 @@ exports.sanitizeText = sanitizeText;
 exports.toCallbackSink = toCallbackSink;
 exports.toNullSink = toNullSink;
 exports.toStringSink = toStringSink;
-//# sourceMappingURL=chunk-XPVOBYVK.cjs.map
-//# sourceMappingURL=chunk-XPVOBYVK.cjs.map
+//# sourceMappingURL=chunk-ZCWN2P2R.cjs.map
+//# sourceMappingURL=chunk-ZCWN2P2R.cjs.map