polytypo 1.12.0 → 1.14.0

package/dist/{chunk-QDF6EDLT.js → chunk-NVKII62N.js}

@@ -65,6 +65,7 @@ var KNOWN_LOCALES = [
   "ro",
   "ru",
   "sk",
+  "sr",
   "sv",
   "tr",
   "uk"
@@ -96,6 +97,7 @@ var LOCALES = {
   ro: { locale: "ro", name: "Romanian", quotes: { primary: { open: "\u201E", close: "\u201D", innerSpace: "none" }, secondary: { open: "\xAB", close: "\xBB", innerSpace: "none" }, elisionIdioms: [], elisionClitics: { before: [], after: [] } }, dash: { parenthetical: "en-spaced", range: "none" }, ellipsis: { abbreviatedAfterTerminal: false }, hyphen: { prefixes: [], suffixes: [], compounds: [] }, nbsp: { beforePunctuation: [], narrowBeforePunctuation: [], afterShortWords: [], abbreviations: [], beforeUnits: ["km", "kg", "cm", "mm", "km/h", "\xB0C"], beforeNumber: ["art.", "nr."], beforeWord: [], afterSymbols: [], initialBinding: "single" } },
   ru: { locale: "ru", name: "Russian", quotes: { primary: { open: "\xAB", close: "\xBB", innerSpace: "none" }, secondary: { open: "\u201E", close: "\u201C", innerSpace: "none" }, elisionIdioms: [], elisionClitics: { before: [], after: [] } }, dash: { parenthetical: "em-spaced", range: "em-tight" }, ellipsis: { abbreviatedAfterTerminal: true }, hyphen: { prefixes: ["\u043A\u043E\u0435-", "\u043A\u043E\u0439-"], suffixes: ["-\u0442\u043E", "-\u043B\u0438\u0431\u043E", "-\u043D\u0438\u0431\u0443\u0434\u044C", "-\u0442\u0430\u043A\u0438", "-\u043A\u0430"], compounds: ["\u0438\u0437-\u0437\u0430", "\u0438\u0437-\u043F\u043E\u0434"] }, nbsp: { beforePunctuation: [], narrowBeforePunctuation: [], afterShortWords: ["\u0430", "\u0432", "\u0438", "\u043A", "\u043E", "\u0441", "\u0443", "\u0432\u043E", "\u0434\u043E", "\u0437\u0430", "\u0438\u0437", "\u043A\u043E", "\u043D\u0430", "\u043E\u0431", "\u043E\u0442", "\u043F\u043E", "\u0441\u043E"], abbreviations: ["\u0438 \u0442. \u0434.", "\u0438 \u0442. \u043F.", "\u0442. \u0435.", "\u0438 \u0434\u0440."], beforeUnits: ["%", "\u2030", "\u20BD", "\xB0C", "\u043A\u043C", "\u0441\u043C", "\u043C\u043C", "\u043A\u0433", "\u0433.", "\u0433\u0433.", "\u0432.", "\u0432\u0432.", "\u0442\u044B\u0441.", "\u043C\u043B\u043D", "\u043C\u043B\u0440\u0434"], beforeNumber: [], beforeWord: ["\u0443\u043B.", "\u043F\u043B."], afterSymbols: ["\u2116", "\xA7"], initialBinding: "chain" } },
   sk: { locale: "sk", name: "Slovak", quotes: { primary: { open: "\u201E", close: "\u201C", innerSpace: "none" }, secondary: { open: "\u201A", close: "\u2018", innerSpace: "none" }, elisionIdioms: [], elisionClitics: { before: [], after: [] } }, dash: { parenthetical: "en-spaced", range: "en-spaced" }, ellipsis: { abbreviatedAfterTerminal: false }, hyphen: { prefixes: [], suffixes: [], compounds: [] }, nbsp: { beforePunctuation: [], narrowBeforePunctuation: [], afterShortWords: [], abbreviations: ["t. j.", "a pod.", "a. s."], beforeUnits: ["%", "\u2030", "kg", "km", "km/s", "m/s", "min"], beforeNumber: ["\u010D.", "ods.", "s."], beforeWord: [], afterSymbols: ["\xA7"], initialBinding: "none" } },
+  sr: { locale: "sr", name: "Serbian", quotes: { primary: { open: "\u201E", close: "\u201D", innerSpace: "none" }, secondary: { open: "\u2019", close: "\u2019", innerSpace: "none" }, elisionIdioms: [], elisionClitics: { before: [], after: [] } }, dash: { parenthetical: "en-spaced", range: "en-tight" }, ellipsis: { abbreviatedAfterTerminal: false }, hyphen: { prefixes: [], suffixes: [], compounds: [] }, nbsp: { beforePunctuation: [], narrowBeforePunctuation: [], afterShortWords: [], abbreviations: [], beforeUnits: [], beforeNumber: [], beforeWord: [], afterSymbols: [], initialBinding: "none" } },
   sv: { locale: "sv", name: "Swedish", quotes: { primary: { open: "\u201D", close: "\u201D", innerSpace: "none" }, secondary: { open: "\u2019", close: "\u2019", innerSpace: "none" }, elisionIdioms: [], elisionClitics: { before: [], after: [] } }, dash: { parenthetical: "en-spaced", range: "en-tight" }, ellipsis: { abbreviatedAfterTerminal: false }, hyphen: { prefixes: [], suffixes: [], compounds: [] }, nbsp: { beforePunctuation: [], narrowBeforePunctuation: [], afterShortWords: [], abbreviations: [], beforeUnits: ["%", "\u2030", "kr", "\u20AC", "kg", "g", "mg", "km", "m", "cm", "mm", "l", "dl", "cl", "ml", "kW", "kWh", "min", "sek", "tim", "h", "\xB0C"], beforeNumber: [], beforeWord: [], afterSymbols: ["\xA7"], initialBinding: "none" } },
   tr: { locale: "tr", name: "Turkish", quotes: { primary: { open: "\u201C", close: "\u201D", innerSpace: "none" }, secondary: { open: "\u2018", close: "\u2019", innerSpace: "none" }, elisionIdioms: [], elisionClitics: { before: [], after: ["nin", "n\u0131n", "de", "da", "te", "ye", "yle", "n\u0131", "dan", "den", "lik", "nci", "\xFCm"] } }, dash: { parenthetical: "none", range: "none" }, ellipsis: { abbreviatedAfterTerminal: true }, hyphen: { prefixes: [], suffixes: [], compounds: [] }, nbsp: { beforePunctuation: [], narrowBeforePunctuation: [], afterShortWords: [], abbreviations: ["Kur. B\u015Fk.", "N\xF6. Sb."], beforeUnits: ["mm", "cm", "km", "kg", "mg", "hl", "m\xB2", "cm\xB2", "\xB0C", "ton"], beforeNumber: [], beforeWord: [], afterSymbols: [], initialBinding: "none" } },
   uk: { locale: "uk", name: "Ukrainian", quotes: { primary: { open: "\xAB", close: "\xBB", innerSpace: "none" }, secondary: { open: "\u201C", close: "\u201D", innerSpace: "none" }, elisionIdioms: [], elisionClitics: { before: [], after: [] } }, dash: { parenthetical: "em-spaced", range: "em-tight" }, ellipsis: { abbreviatedAfterTerminal: true }, hyphen: { prefixes: ["\u0431\u0443\u0434\u044C-", "\u043A\u0430\u0437\u043D\u0430-", "\u0445\u0442\u043E\u0437\u043D\u0430-", "\u0431\u043E\u0437\u043D\u0430-"], suffixes: ["-\u0431\u043E", "-\u043D\u043E", "-\u043E\u0442", "-\u0442\u043E", "-\u0442\u0430\u043A\u0438", "-\u0431\u0443\u0434\u044C", "-\u043D\u0435\u0431\u0443\u0434\u044C"], compounds: ["\u0432\u0438\u0434-\u0432\u043E", "\u0433\u0440-\u043D", "\u0456\u043D-\u0442", "\u0440-\u043D", "\u0443\u043D-\u0442", "\u0444-\u043A\u0430", "\u0442-\u0432\u043E", "\u0437-\u0437\u0430", "\u0456\u0437-\u0437\u0430", "\u0437-\u043D\u0430\u0434", "\u0437-\u043F\u0435\u0440\u0435\u0434", "\u0437-\u043F\u0456\u0434", "\u0456\u0437-\u043F\u0456\u0434", "\u0437-\u043F\u043E\u0437\u0430", "\u0437-\u043F\u043E\u043C\u0456\u0436", "\u0437-\u043F\u043E\u043D\u0430\u0434", "\u0437-\u043F\u043E\u043F\u0456\u0434", "\u0437-\u043F\u043E\u0441\u0435\u0440\u0435\u0434", "\u0437-\u043F\u0440\u043E\u043C\u0456\u0436"] }, nbsp: { beforePunctuation: [], narrowBeforePunctuation: [], afterShortWords: [], abbreviations: ["\u0456 \u0442. \u0434.", "\u0456 \u0442. \u0456\u043D.", "\u0442\u0430 \u0456\u043D.", "\u043A\u0443\u0431. \u0441\u043C"], beforeUnits: ["%", "\u0433\u0430", "\u0433\u043E\u0434", "\u0434\u043C", "\u043A\u0411", "\u043A\u0412\u0442", "\u043A\u0433", "\u043A\u043C", "\u043C\u043C", "\u0441\u043C", "\u0445\u0432", "\u0412\u0442", "\u043A\u043C/\u0433\u043E\u0434", "\u043C/\u0441", "\u043C\u043B\u043D", "\u043C\u043B\u0440\u0434", "\u0442\u0440\u043B\u043D", "\u0433\u0440\u043D", "\u0440."], beforeNumber: [], beforeWord: ["\u0430\u043A\u0430\u0434.", "\u0434\u043E\u0446.", "\u043F\u0440\u043E\u0444."], afterSymbols: [], initialBinding: "chain" } }
@@ -5778,11 +5780,18 @@ function applyEditsToOrigin(origin, edits) {
   for (let i = cursor; i < origin.length; i += 1) out.push(origin[i]);
   return out;
 }
+function endOf(origin, edit, inputLength) {
+  for (let i = edit.end - 1; i >= edit.start; i -= 1) {
+    const value = origin[i];
+    if (value !== NO_ORIGIN) return value + 1;
+  }
+  return originAt(origin, edit.end, inputLength);
+}
 function recordChanges(cp, edits, origin, inputLength, ruleId) {
   return edits.map((edit) => ({
     ruleId,
     start: originAt(origin, edit.start, inputLength),
-    end: originAt(origin, edit.end, inputLength),
+    end: endOf(origin, edit, inputLength),
     before: fromCodePoints(cp.slice(edit.start, edit.end)),
     after: fromCodePoints(edit.replacement)
   }));
@@ -5831,20 +5840,334 @@ function runRulesRecording(cp, planned, locale, mode, narrowTarget, origin, inpu
   return changes;
 }
 
+// src/modes/spans.ts
+var SPACE5 = 32;
+var LINE_TERMINATORS = /* @__PURE__ */ new Set([
+  10,
+  13,
+  11,
+  12,
+  133,
+  8232,
+  8233
+]);
+function gapIsLineBoundary(source, from, to) {
+  for (let i = from; i < to; i += 1) {
+    if (LINE_TERMINATORS.has(source.charCodeAt(i))) return true;
+  }
+  return false;
+}
+function normalizeSpans(spans) {
+  const sorted = spans.filter((s) => s.end > s.start).sort((a, b) => a.start - b.start);
+  const out = [];
+  for (const span of sorted) {
+    const last = out[out.length - 1];
+    if (last === void 0) {
+      out.push(span);
+      continue;
+    }
+    if (span.start < last.end) {
+      throw new PolytypoError(
+        "POLYTYPO_RULE_CONTRACT",
+        `mode extractor produced overlapping spans (${last.start}, ${last.end}) and (${span.start}, ${span.end})`
+      );
+    }
+    if (span.start === last.end) {
+      out[out.length - 1] = { start: last.start, end: span.end };
+      continue;
+    }
+    out.push(span);
+  }
+  return out;
+}
+function concatenateSpans(source, spans) {
+  const cp = [];
+  let previous;
+  for (const span of spans) {
+    if (previous !== void 0) {
+      cp.push(gapIsLineBoundary(source, previous.end, span.start) ? LINE_MARKER : MARKER);
+    }
+    for (const value of toCodePoints(source.slice(span.start, span.end))) cp.push(value);
+    previous = span;
+  }
+  return cp;
+}
+function spanRangesOf(cp) {
+  const ranges = [];
+  let first = 0;
+  for (let i = 0; i < cp.length; i += 1) {
+    if (isMarker(cp[i])) {
+      ranges.push({ first, last: i - 1 });
+      first = i + 1;
+    }
+  }
+  ranges.push({ first, last: cp.length - 1 });
+  return ranges;
+}
+function spanContaining(ranges, p) {
+  for (const range of ranges) {
+    if (p >= range.first && p <= range.last + 1) return range;
+  }
+  return void 0;
+}
+function filterBoundaryEdits(cp, edits, ranges) {
+  const out = [];
+  for (const edit of edits) {
+    let containsMarker = false;
+    for (let i = edit.start; i < edit.end; i += 1) {
+      if (isMarker(cp[i])) {
+        containsMarker = true;
+        break;
+      }
+    }
+    if (containsMarker) continue;
+    const p = edit.start;
+    const q = edit.end - 1;
+    const d = edit.end - edit.start;
+    const r = edit.replacement.length;
+    const span = spanContaining(ranges, p);
+    if (span !== void 0 && (p === span.first || q === span.last)) {
+      if (r > d) continue;
+      const first = edit.replacement[0];
+      const last = edit.replacement[r - 1];
+      if (r > 0 && p === span.first && first === SPACE5 && cp[p] !== SPACE5) continue;
+      if (r > 0 && q === span.last && last === SPACE5 && cp[q] !== SPACE5) continue;
+    }
+    out.push(edit);
+  }
+  return out;
+}
+function splitOnMarker(cp, expected) {
+  const pieces = [[]];
+  for (const value of cp) {
+    if (isMarker(value)) {
+      pieces.push([]);
+      continue;
+    }
+    pieces[pieces.length - 1].push(value);
+  }
+  if (pieces.length !== expected) {
+    throw new PolytypoError(
+      "POLYTYPO_RULE_CONTRACT",
+      `boundary markers did not survive the pipeline: expected ${expected} spans, found ${pieces.length}`
+    );
+  }
+  return pieces;
+}
+function originOfSpans(source, spans) {
+  const codePointIndexOf = new Array(source.length + 1);
+  let cpIndex = 0;
+  for (let i = 0; i < source.length; ) {
+    codePointIndexOf[i] = cpIndex;
+    const code = source.codePointAt(i);
+    const width = code > 65535 ? 2 : 1;
+    if (width === 2) codePointIndexOf[i + 1] = cpIndex;
+    i += width;
+    cpIndex += 1;
+  }
+  codePointIndexOf[source.length] = cpIndex;
+  const origin = [];
+  let previous;
+  for (const span of spans) {
+    if (previous !== void 0) origin.push(NO_ORIGIN);
+    const base = codePointIndexOf[span.start];
+    const length = toCodePoints(source.slice(span.start, span.end)).length;
+    for (let k = 0; k < length; k += 1) origin.push(base + k);
+    previous = span;
+  }
+  return origin;
+}
+
+// src/engine/span-runner.ts
+function runRulesOverSpans(cp, planned, locale, mode, narrowTarget) {
+  let current = cp;
+  for (const id of planned) {
+    const rule = RULES[id];
+    if (rule === void 0) continue;
+    const edits = rule.apply({ cp: current, locale, mode, narrowTarget });
+    current = applyEdits(current, filterBoundaryEdits(current, edits, spanRangesOf(current)), id);
+  }
+  return current;
+}
+function replacementsOfUnit(source, spans, planned, locale, mode, narrowTarget) {
+  const normalized = normalizeSpans(spans);
+  if (normalized.length === 0) return [];
+  const transformed = runRulesOverSpans(
+    concatenateSpans(source, normalized),
+    planned,
+    locale,
+    mode,
+    narrowTarget
+  );
+  const pieces = splitOnMarker(transformed, normalized.length);
+  return normalized.map((span, i) => ({ span, text: fromCodePoints(pieces[i]) }));
+}
+function emit2(source, replacements) {
+  let out = "";
+  let cursor = 0;
+  for (const { span, text } of replacements) {
+    const original = source.slice(span.start, span.end);
+    out += source.slice(cursor, span.start);
+    out += text === original ? original : text;
+    cursor = span.end;
+  }
+  return out + source.slice(cursor);
+}
+function runOverSpans(source, spans, planned, locale, mode, narrowTarget) {
+  return emit2(source, replacementsOfUnit(source, spans, planned, locale, mode, narrowTarget));
+}
+function runOverUnits(source, units, planned, locale, mode, narrowTarget) {
+  const replacements = units.flatMap((spans) => replacementsOfUnit(source, spans, planned, locale, mode, narrowTarget)).sort((a, b) => a.span.start - b.span.start);
+  return emit2(source, replacements);
+}
+function analyzeOverUnits(source, units, planned, locale, mode, narrowTarget) {
+  return units.flatMap((spans) => analyzeOverSpans(source, spans, planned, locale, mode, narrowTarget)).sort((a, b) => a.start - b.start);
+}
+function analyzeOverSpans(source, spans, planned, locale, mode, narrowTarget) {
+  const normalized = normalizeSpans(spans);
+  if (normalized.length === 0) return [];
+  return runRulesRecording(
+    concatenateSpans(source, normalized),
+    planned,
+    locale,
+    mode,
+    narrowTarget,
+    originOfSpans(source, normalized),
+    toCodePoints(source).length,
+    (current, edits) => filterBoundaryEdits(current, edits, spanRangesOf(current))
+  );
+}
+
+// src/engine/protect.ts
+var LINE_TERMINATORS2 = /* @__PURE__ */ new Set([
+  10,
+  13,
+  11,
+  12,
+  133,
+  8232,
+  8233
+]);
+function invalid(message) {
+  throw new PolytypoError("POLYTYPO_INVALID_OPTION", message);
+}
+function resolveProtect(value, length) {
+  if (value === void 0 || value === null) return [];
+  if (!Array.isArray(value)) invalid("protect must be an array of { start, end } ranges.");
+  const holes = [];
+  let previousEnd = 0;
+  for (const range of value) {
+    if (typeof range !== "object" || range === null) invalid("protect entries must be objects.");
+    const { start, end } = range;
+    if (!Number.isInteger(start) || !Number.isInteger(end)) {
+      invalid("protect start and end must be integers.");
+    }
+    const s = start;
+    const e = end;
+    if (s < 0 || e <= s) invalid(`protect range [${s}, ${e}) is empty or negative.`);
+    if (s < previousEnd)
+      invalid(`protect range [${s}, ${e}) overlaps or precedes the previous one.`);
+    if (e > length)
+      invalid(`protect range [${s}, ${e}) runs past the end of the input (${length}).`);
+    const last = holes[holes.length - 1];
+    if (last !== void 0 && last.end === s)
+      holes[holes.length - 1] = { start: last.start, end: e };
+    else holes.push({ start: s, end: e });
+    previousEnd = e;
+  }
+  return holes;
+}
+function assertNoProtect(value, mode) {
+  if (value === void 0 || value === null) return;
+  if (Array.isArray(value) && value.length === 0) return;
+  invalid(`protect is only available in text mode, not ${mode}.`);
+}
+function layout(cp, holes) {
+  const array = [];
+  const origin = [];
+  let cursor = 0;
+  for (const hole of holes) {
+    for (let i = cursor; i < hole.start; i += 1) {
+      array.push(cp[i]);
+      origin.push(i);
+    }
+    let line = false;
+    for (let i = hole.start; i < hole.end; i += 1) {
+      if (LINE_TERMINATORS2.has(cp[i])) {
+        line = true;
+        break;
+      }
+    }
+    array.push(line ? LINE_MARKER : MARKER);
+    origin.push(NO_ORIGIN);
+    cursor = hole.end;
+  }
+  for (let i = cursor; i < cp.length; i += 1) {
+    array.push(cp[i]);
+    origin.push(i);
+  }
+  return { array, origin };
+}
+function runProtectedMapped(input, holes, planned, locale, narrowTarget) {
+  const cp = toCodePoints(input);
+  const { array } = layout(cp, holes);
+  const out = runRulesOverSpans(array, planned, locale, "text", narrowTarget);
+  const result = [];
+  const mapped = [];
+  let hole = 0;
+  for (const value of out) {
+    if (isMarker(value)) {
+      const h = holes[hole];
+      const start = result.length;
+      for (let i = h.start; i < h.end; i += 1) result.push(cp[i]);
+      mapped.push({ start, end: result.length });
+      hole += 1;
+      continue;
+    }
+    result.push(value);
+  }
+  if (hole !== holes.length) {
+    throw new PolytypoError(
+      "POLYTYPO_RULE_CONTRACT",
+      "boundary markers did not survive the pipeline."
+    );
+  }
+  return { text: fromCodePoints(result), holes: mapped };
+}
+function runProtected(input, holes, planned, locale, narrowTarget) {
+  return runProtectedMapped(input, holes, planned, locale, narrowTarget).text;
+}
+function analyzeProtected(input, holes, planned, locale, narrowTarget) {
+  const cp = toCodePoints(input);
+  const { array, origin } = layout(cp, holes);
+  return runRulesRecording(
+    array,
+    planned,
+    locale,
+    "text",
+    narrowTarget,
+    origin,
+    cp.length,
+    (current, edits) => filterBoundaryEdits(current, edits, spanRangesOf(current))
+  );
+}
+
 export {
   PolytypoError,
   toCodePoints,
   fromCodePoints,
   getLocaleData,
   resolveNarrowTarget,
-  MARKER,
-  LINE_MARKER,
-  isMarker,
-  RULES,
-  applyEdits,
-  NO_ORIGIN,
   planRules,
   runRules,
-  runRulesRecording
+  runRulesRecording,
+  runOverSpans,
+  runOverUnits,
+  analyzeOverUnits,
+  analyzeOverSpans,
+  resolveProtect,
+  assertNoProtect,
+  runProtected,
+  analyzeProtected
 };
-//# sourceMappingURL=chunk-QDF6EDLT.js.map
+//# sourceMappingURL=chunk-NVKII62N.js.map