polytypo 1.12.0 → 1.13.0

package/README.md

@@ -126,6 +126,24 @@ scalar containing `''` among them, which is how an apostrophe is written inside
 The block is also processed separately from the body, which shows up in exactly one place: an
 unbalanced quotation mark in `title` cannot pair with a mark in your first paragraph.
 
+`text` mode takes a `protect` option for strings with holes in them, such as template literals or
+ICU messages: ranges of the input that are never edited and that the rules read as content. Offsets
+are Unicode code points, `[start, end)`, ascending and non-overlapping:
+
+```ts
+import { transform } from "polytypo/text";
+
+transform("${x} - Rules", { locale: "en-US", protect: [{ start: 0, end: 4 }] });
+// ${x}—Rules
+```
+
+Text next to a hole converts less than the same text would unsplit, never more: a character
+polytypo would insert beside the hole is not written. A hole containing a line break counts as a
+line break to the rules. A malformed list throws `POLYTYPO_INVALID_OPTION`, and so does a non-empty
+list in `html`, `markdown` or `yaml` mode. An empty list is the same as no option. Running the
+output through again is a fixed point only if you move the ranges to where the edits left them;
+`transform` does not return them. `analyze()` takes the same option.
+
 `analyze()` runs the same pipeline and reports what it would do instead of doing it — one record
 per edit, each with the rule that made it and code-point offsets into the input you passed (into
 the **document**, in `html`, `markdown` and `yaml` mode, not into a span):

package/dist/{chunk-MDYQWNEL.js → chunk-6PEHEU6F.js}

@@ -1,6 +1,6 @@
 import {
   PolytypoError
-} from "./chunk-QDF6EDLT.js";
+} from "./chunk-MF6PJO7O.js";
 
 // src/modes/yaml.ts
 var TAB = 9;
@@ -370,4 +370,4 @@ export {
   resolveYamlKeys,
   resolveFrontmatterKeys
 };
-//# sourceMappingURL=chunk-MDYQWNEL.js.map
+//# sourceMappingURL=chunk-6PEHEU6F.js.map

package/dist/{chunk-5XVEBCNU.js → chunk-ANHMGSED.js}

@@ -1,16 +1,15 @@
 import {
   resolveYamlKeys,
   yamlSpans
-} from "./chunk-MDYQWNEL.js";
+} from "./chunk-6PEHEU6F.js";
 import {
   analyzeOverSpans,
-  runOverSpans
-} from "./chunk-SUX5QWB6.js";
-import {
+  assertNoProtect,
   getLocaleData,
   planRules,
-  resolveNarrowTarget
-} from "./chunk-QDF6EDLT.js";
+  resolveNarrowTarget,
+  runOverSpans
+} from "./chunk-MF6PJO7O.js";
 
 // src/engine/yaml-pipeline.ts
 function runYamlPipeline(input, options) {
@@ -18,6 +17,7 @@ function runYamlPipeline(input, options) {
   const planned = planRules(options.rules);
   const locale = getLocaleData(options.locale);
   const keys = resolveYamlKeys(options.keys);
+  assertNoProtect(options.protect, "yaml");
   return runOverSpans(input, yamlSpans(input, keys), planned, locale, "yaml", narrowTarget);
 }
 function analyzeYamlPipeline(input, options) {
@@ -25,6 +25,7 @@ function analyzeYamlPipeline(input, options) {
   const planned = planRules(options.rules);
   const locale = getLocaleData(options.locale);
   const keys = resolveYamlKeys(options.keys);
+  assertNoProtect(options.protect, "yaml");
   return analyzeOverSpans(input, yamlSpans(input, keys), planned, locale, "yaml", narrowTarget);
 }
 
@@ -32,4 +33,4 @@ export {
   runYamlPipeline,
   analyzeYamlPipeline
 };
-//# sourceMappingURL=chunk-5XVEBCNU.js.map
+//# sourceMappingURL=chunk-ANHMGSED.js.map

package/dist/chunk-ANHMGSED.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/engine/yaml-pipeline.ts"],"sourcesContent":["import { yamlSpans } from \"../modes/yaml.js\";\nimport type { Options } from \"../types.js\";\nimport { getLocaleData } from \"./locale.js\";\nimport { resolveNarrowTarget } from \"./narrow-target.js\";\nimport { resolveYamlKeys } from \"./yaml-keys.js\";\nimport { assertNoProtect } from \"./protect.js\";\nimport { planRules } from \"./rule-runner.js\";\nimport { analyzeOverSpans, runOverSpans } from \"./span-runner.js\";\nimport type { Change } from \"./origin.js\";\n\n/**\n * `yaml` mode only, and the only mode pipeline with **no parser dependency at all** — span\n * selection is the specified scan of modes.md 3.8, not a library. There is likewise no\n * `POLYTYPO_MALFORMED_INPUT` counterpart here: with no declared grammar to violate, a file that\n * is not YAML yields few spans or none and comes back byte for byte (modes.md 3.8.3). The only\n * throw this mode adds is `keys`, which is about the call and not the input.\n */\nexport function runYamlPipeline(input: string, options: Partial<Options>): string {\n  const narrowTarget = resolveNarrowTarget(options.narrowNbsp);\n  const planned = planRules(options.rules);\n  const locale = getLocaleData(options.locale);\n  const keys = resolveYamlKeys(options.keys);\n  assertNoProtect(options.protect, \"yaml\");\n  return runOverSpans(input, yamlSpans(input, keys), planned, locale, \"yaml\", narrowTarget);\n}\n\n/** analyze.md §1, `yaml` mode: offsets are into the document, not into a span (analyze.md §6). */\nexport function analyzeYamlPipeline(input: string, options: Partial<Options>): Change[] {\n  const narrowTarget = resolveNarrowTarget(options.narrowNbsp);\n  const planned = planRules(options.rules);\n  const locale = getLocaleData(options.locale);\n  const keys = resolveYamlKeys(options.keys);\n  assertNoProtect(options.protect, \"yaml\");\n  return analyzeOverSpans(input, yamlSpans(input, keys), planned, locale, \"yaml\", narrowTarget);\n}\n"],"mappings":";;;;;;;;;;;;;;AAiBO,SAAS,gBAAgB,OAAe,SAAmC;AAChF,QAAM,eAAe,oBAAoB,QAAQ,UAAU;AAC3D,QAAM,UAAU,UAAU,QAAQ,KAAK;AACvC,QAAM,SAAS,cAAc,QAAQ,MAAM;AAC3C,QAAM,OAAO,gBAAgB,QAAQ,IAAI;AACzC,kBAAgB,QAAQ,SAAS,MAAM;AACvC,SAAO,aAAa,OAAO,UAAU,OAAO,IAAI,GAAG,SAAS,QAAQ,QAAQ,YAAY;AAC1F;AAGO,SAAS,oBAAoB,OAAe,SAAqC;AACtF,QAAM,eAAe,oBAAoB,QAAQ,UAAU;AAC3D,QAAM,UAAU,UAAU,QAAQ,KAAK;AACvC,QAAM,SAAS,cAAc,QAAQ,MAAM;AAC3C,QAAM,OAAO,gBAAgB,QAAQ,IAAI;AACzC,kBAAgB,QAAQ,SAAS,MAAM;AACvC,SAAO,iBAAiB,OAAO,UAAU,OAAO,IAAI,GAAG,SAAS,QAAQ,QAAQ,YAAY;AAC9F;","names":[]}

package/dist/chunk-CJIH6CFO.cjs

@@ -0,0 +1,34 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+var _chunkW52W6XGAcjs = require('./chunk-W52W6XGA.cjs');
+
+
+
+
+
+
+
+var _chunkWQEB33J2cjs = require('./chunk-WQEB33J2.cjs');
+
+// src/engine/html-pipeline.ts
+function runHtmlPipeline(input, options) {
+  const narrowTarget = _chunkWQEB33J2cjs.resolveNarrowTarget.call(void 0, options.narrowNbsp);
+  const planned = _chunkWQEB33J2cjs.planRules.call(void 0, options.rules);
+  const locale = _chunkWQEB33J2cjs.getLocaleData.call(void 0, options.locale);
+  _chunkWQEB33J2cjs.assertNoProtect.call(void 0, options.protect, "html");
+  const spans = _chunkW52W6XGAcjs.htmlSpans.call(void 0, input);
+  return _chunkWQEB33J2cjs.runOverSpans.call(void 0, input, spans, planned, locale, "html", narrowTarget);
+}
+function analyzeHtmlPipeline(input, options) {
+  const narrowTarget = _chunkWQEB33J2cjs.resolveNarrowTarget.call(void 0, options.narrowNbsp);
+  const planned = _chunkWQEB33J2cjs.planRules.call(void 0, options.rules);
+  const locale = _chunkWQEB33J2cjs.getLocaleData.call(void 0, options.locale);
+  _chunkWQEB33J2cjs.assertNoProtect.call(void 0, options.protect, "html");
+  return _chunkWQEB33J2cjs.analyzeOverSpans.call(void 0, input, _chunkW52W6XGAcjs.htmlSpans.call(void 0, input), planned, locale, "html", narrowTarget);
+}
+
+
+
+
+exports.runHtmlPipeline = runHtmlPipeline; exports.analyzeHtmlPipeline = analyzeHtmlPipeline;
+//# sourceMappingURL=chunk-CJIH6CFO.cjs.map

package/dist/chunk-CJIH6CFO.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/polytypo-js/polytypo-js/dist/chunk-CJIH6CFO.cjs","../src/engine/html-pipeline.ts"],"names":[],"mappings":"AAAA;AACE;AACF,wDAA6B;AAC7B;AACE;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACA;ACMO,SAAS,eAAA,CAAgB,KAAA,EAAe,OAAA,EAAmC;AAChF,EAAA,MAAM,aAAA,EAAe,mDAAA,OAAoB,CAAQ,UAAU,CAAA;AAC3D,EAAA,MAAM,QAAA,EAAU,yCAAA,OAAU,CAAQ,KAAK,CAAA;AACvC,EAAA,MAAM,OAAA,EAAS,6CAAA,OAAc,CAAQ,MAAM,CAAA;AAC3C,EAAA,+CAAA,OAAgB,CAAQ,OAAA,EAAS,MAAM,CAAA;AACvC,EAAA,MAAM,MAAA,EAAQ,yCAAA,KAAe,CAAA;AAC7B,EAAA,OAAO,4CAAA,KAAa,EAAO,KAAA,EAAO,OAAA,EAAS,MAAA,EAAQ,MAAA,EAAQ,YAAY,CAAA;AACzE;AAGO,SAAS,mBAAA,CAAoB,KAAA,EAAe,OAAA,EAAqC;AACtF,EAAA,MAAM,aAAA,EAAe,mDAAA,OAAoB,CAAQ,UAAU,CAAA;AAC3D,EAAA,MAAM,QAAA,EAAU,yCAAA,OAAU,CAAQ,KAAK,CAAA;AACvC,EAAA,MAAM,OAAA,EAAS,6CAAA,OAAc,CAAQ,MAAM,CAAA;AAC3C,EAAA,+CAAA,OAAgB,CAAQ,OAAA,EAAS,MAAM,CAAA;AACvC,EAAA,OAAO,gDAAA,KAAiB,EAAO,yCAAA,KAAe,CAAA,EAAG,OAAA,EAAS,MAAA,EAAQ,MAAA,EAAQ,YAAY,CAAA;AACxF;ADNA;AACA;AACE;AACA;AACF,6FAAC","file":"/home/runner/work/polytypo-js/polytypo-js/dist/chunk-CJIH6CFO.cjs","sourcesContent":[null,"import { htmlSpans } from \"../modes/html.js\";\nimport type { Options } from \"../types.js\";\nimport { getLocaleData } from \"./locale.js\";\nimport { resolveNarrowTarget } from \"./narrow-target.js\";\nimport { assertNoProtect } from \"./protect.js\";\nimport { planRules } from \"./rule-runner.js\";\nimport { analyzeOverSpans, runOverSpans } from \"./span-runner.js\";\nimport type { Change } from \"./origin.js\";\n\n/**\n * `html` mode only. Imports `parse5` (via `../modes/html.js`) and nothing from\n * `../modes/markdown.js` or the Micromark/MDX stack — this is what makes `polytypo/html`'s\n * module graph exclude the Markdown parser (AUDIT_REMEDIATION_AND_RELEASE_PLAN.md 5.1).\n *\n * Validation order — `planRules` before `getLocaleData` before parsing — mirrors the pre-Stage-5\n * aggregate `runPipeline` exactly (an unknown-rule error must win over an unknown-locale error,\n * and both must win over a parse failure, since that is public, tested behaviour).\n */\nexport function runHtmlPipeline(input: string, options: Partial<Options>): string {\n  const narrowTarget = resolveNarrowTarget(options.narrowNbsp);\n  const planned = planRules(options.rules);\n  const locale = getLocaleData(options.locale);\n  assertNoProtect(options.protect, \"html\");\n  const spans = htmlSpans(input);\n  return runOverSpans(input, spans, planned, locale, \"html\", narrowTarget);\n}\n\n/** analyze.md §1, `html` mode: offsets are into the document, not into a span (analyze.md §6). */\nexport function analyzeHtmlPipeline(input: string, options: Partial<Options>): Change[] {\n  const narrowTarget = resolveNarrowTarget(options.narrowNbsp);\n  const planned = planRules(options.rules);\n  const locale = getLocaleData(options.locale);\n  assertNoProtect(options.protect, \"html\");\n  return analyzeOverSpans(input, htmlSpans(input), planned, locale, \"html\", narrowTarget);\n}\n"]}

package/dist/{chunk-IOW5V47B.js → chunk-E2HHFHG2.js}

@@ -1,21 +1,21 @@
 import {
   htmlSpans
-} from "./chunk-3H6XONGO.js";
+} from "./chunk-MCQOMIWF.js";
 import {
   analyzeOverSpans,
-  runOverSpans
-} from "./chunk-SUX5QWB6.js";
-import {
+  assertNoProtect,
   getLocaleData,
   planRules,
-  resolveNarrowTarget
-} from "./chunk-QDF6EDLT.js";
+  resolveNarrowTarget,
+  runOverSpans
+} from "./chunk-MF6PJO7O.js";
 
 // src/engine/html-pipeline.ts
 function runHtmlPipeline(input, options) {
   const narrowTarget = resolveNarrowTarget(options.narrowNbsp);
   const planned = planRules(options.rules);
   const locale = getLocaleData(options.locale);
+  assertNoProtect(options.protect, "html");
   const spans = htmlSpans(input);
   return runOverSpans(input, spans, planned, locale, "html", narrowTarget);
 }
@@ -23,6 +23,7 @@ function analyzeHtmlPipeline(input, options) {
   const narrowTarget = resolveNarrowTarget(options.narrowNbsp);
   const planned = planRules(options.rules);
   const locale = getLocaleData(options.locale);
+  assertNoProtect(options.protect, "html");
   return analyzeOverSpans(input, htmlSpans(input), planned, locale, "html", narrowTarget);
 }
 
@@ -30,4 +31,4 @@ export {
   runHtmlPipeline,
   analyzeHtmlPipeline
 };
-//# sourceMappingURL=chunk-IOW5V47B.js.map
+//# sourceMappingURL=chunk-E2HHFHG2.js.map

package/dist/chunk-E2HHFHG2.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/engine/html-pipeline.ts"],"sourcesContent":["import { htmlSpans } from \"../modes/html.js\";\nimport type { Options } from \"../types.js\";\nimport { getLocaleData } from \"./locale.js\";\nimport { resolveNarrowTarget } from \"./narrow-target.js\";\nimport { assertNoProtect } from \"./protect.js\";\nimport { planRules } from \"./rule-runner.js\";\nimport { analyzeOverSpans, runOverSpans } from \"./span-runner.js\";\nimport type { Change } from \"./origin.js\";\n\n/**\n * `html` mode only. Imports `parse5` (via `../modes/html.js`) and nothing from\n * `../modes/markdown.js` or the Micromark/MDX stack — this is what makes `polytypo/html`'s\n * module graph exclude the Markdown parser (AUDIT_REMEDIATION_AND_RELEASE_PLAN.md 5.1).\n *\n * Validation order — `planRules` before `getLocaleData` before parsing — mirrors the pre-Stage-5\n * aggregate `runPipeline` exactly (an unknown-rule error must win over an unknown-locale error,\n * and both must win over a parse failure, since that is public, tested behaviour).\n */\nexport function runHtmlPipeline(input: string, options: Partial<Options>): string {\n  const narrowTarget = resolveNarrowTarget(options.narrowNbsp);\n  const planned = planRules(options.rules);\n  const locale = getLocaleData(options.locale);\n  assertNoProtect(options.protect, \"html\");\n  const spans = htmlSpans(input);\n  return runOverSpans(input, spans, planned, locale, \"html\", narrowTarget);\n}\n\n/** analyze.md §1, `html` mode: offsets are into the document, not into a span (analyze.md §6). */\nexport function analyzeHtmlPipeline(input: string, options: Partial<Options>): Change[] {\n  const narrowTarget = resolveNarrowTarget(options.narrowNbsp);\n  const planned = planRules(options.rules);\n  const locale = getLocaleData(options.locale);\n  assertNoProtect(options.protect, \"html\");\n  return analyzeOverSpans(input, htmlSpans(input), planned, locale, \"html\", narrowTarget);\n}\n"],"mappings":";;;;;;;;;;;;;AAkBO,SAAS,gBAAgB,OAAe,SAAmC;AAChF,QAAM,eAAe,oBAAoB,QAAQ,UAAU;AAC3D,QAAM,UAAU,UAAU,QAAQ,KAAK;AACvC,QAAM,SAAS,cAAc,QAAQ,MAAM;AAC3C,kBAAgB,QAAQ,SAAS,MAAM;AACvC,QAAM,QAAQ,UAAU,KAAK;AAC7B,SAAO,aAAa,OAAO,OAAO,SAAS,QAAQ,QAAQ,YAAY;AACzE;AAGO,SAAS,oBAAoB,OAAe,SAAqC;AACtF,QAAM,eAAe,oBAAoB,QAAQ,UAAU;AAC3D,QAAM,UAAU,UAAU,QAAQ,KAAK;AACvC,QAAM,SAAS,cAAc,QAAQ,MAAM;AAC3C,kBAAgB,QAAQ,SAAS,MAAM;AACvC,SAAO,iBAAiB,OAAO,UAAU,KAAK,GAAG,SAAS,QAAQ,QAAQ,YAAY;AACxF;","names":[]}

package/dist/{chunk-BS2J3F7M.js → chunk-EL7R55TV.js}

@@ -1,6 +1,6 @@
 import {
   PolytypoError
-} from "./chunk-QDF6EDLT.js";
+} from "./chunk-MF6PJO7O.js";
 
 // src/engine/assert-fixed-mode.ts
 function assertFixedMode(mode, fixed, entryPoint) {
@@ -14,4 +14,4 @@ function assertFixedMode(mode, fixed, entryPoint) {
 export {
   assertFixedMode
 };
-//# sourceMappingURL=chunk-BS2J3F7M.js.map
+//# sourceMappingURL=chunk-EL7R55TV.js.map

package/dist/{chunk-ZLR7P7VH.cjs → chunk-FDNDYPPY.cjs}

@@ -1,11 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkR2AZYV4Ecjs = require('./chunk-R2AZYV4E.cjs');
+var _chunkWQEB33J2cjs = require('./chunk-WQEB33J2.cjs');
 
 // src/engine/assert-fixed-mode.ts
 function assertFixedMode(mode, fixed, entryPoint) {
   if (mode === void 0 || mode === fixed) return;
-  throw new (0, _chunkR2AZYV4Ecjs.PolytypoError)(
+  throw new (0, _chunkWQEB33J2cjs.PolytypoError)(
     "POLYTYPO_INVALID_MODE",
     `"${entryPoint}" only supports mode "${fixed}". Received "${String(mode)}" \u2014 import from "polytypo" for the other modes, or omit \`mode\` here.`
   );
@@ -14,4 +14,4 @@ function assertFixedMode(mode, fixed, entryPoint) {
 
 
 exports.assertFixedMode = assertFixedMode;
-//# sourceMappingURL=chunk-ZLR7P7VH.cjs.map
+//# sourceMappingURL=chunk-FDNDYPPY.cjs.map

package/dist/{chunk-ZLR7P7VH.cjs.map → chunk-FDNDYPPY.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/polytypo-js/polytypo-js/dist/chunk-ZLR7P7VH.cjs","../src/engine/assert-fixed-mode.ts"],"names":[],"mappings":"AAAA;AACE;AACF,wDAA6B;AAC7B;AACA;ACMO,SAAS,eAAA,CAAgB,IAAA,EAAe,KAAA,EAAa,UAAA,EAA0B;AACpF,EAAA,GAAA,CAAI,KAAA,IAAS,KAAA,EAAA,GAAa,KAAA,IAAS,KAAA,EAAO,MAAA;AAC1C,EAAA,MAAM,IAAI,oCAAA;AAAA,IACR,uBAAA;AAAA,IACA,CAAA,CAAA,EAAI,UAAU,CAAA,sBAAA,EAAyB,KAAK,CAAA,aAAA,EAAgB,MAAA,CAAO,IAAI,CAAC,CAAA,2EAAA;AAAA,EAE1E,CAAA;AACF;ADLA;AACA;AACE;AACF,0CAAC","file":"/home/runner/work/polytypo-js/polytypo-js/dist/chunk-ZLR7P7VH.cjs","sourcesContent":[null,"import { PolytypoError } from \"../errors.js\";\nimport type { Mode } from \"../types.js\";\n\n/**\n * `polytypo/text`, `polytypo/html` and `polytypo/markdown` each fix `mode` at the type level by\n * omitting it from their Options type (AUDIT_REMEDIATION_AND_RELEASE_PLAN.md 5.1, criterion 6).\n * A plain-JS caller — or a TypeScript caller passing a wider-typed variable, which excess-property\n * checking does not catch — can still supply a conflicting `mode` at runtime. That is rejected\n * explicitly here, never silently ignored or overridden.\n */\nexport function assertFixedMode(mode: unknown, fixed: Mode, entryPoint: string): void {\n  if (mode === undefined || mode === fixed) return;\n  throw new PolytypoError(\n    \"POLYTYPO_INVALID_MODE\",\n    `\"${entryPoint}\" only supports mode \"${fixed}\". Received \"${String(mode)}\" — ` +\n      `import from \"polytypo\" for the other modes, or omit \\`mode\\` here.`,\n  );\n}\n"]}
+{"version":3,"sources":["/home/runner/work/polytypo-js/polytypo-js/dist/chunk-FDNDYPPY.cjs","../src/engine/assert-fixed-mode.ts"],"names":[],"mappings":"AAAA;AACE;AACF,wDAA6B;AAC7B;AACA;ACMO,SAAS,eAAA,CAAgB,IAAA,EAAe,KAAA,EAAa,UAAA,EAA0B;AACpF,EAAA,GAAA,CAAI,KAAA,IAAS,KAAA,EAAA,GAAa,KAAA,IAAS,KAAA,EAAO,MAAA;AAC1C,EAAA,MAAM,IAAI,oCAAA;AAAA,IACR,uBAAA;AAAA,IACA,CAAA,CAAA,EAAI,UAAU,CAAA,sBAAA,EAAyB,KAAK,CAAA,aAAA,EAAgB,MAAA,CAAO,IAAI,CAAC,CAAA,2EAAA;AAAA,EAE1E,CAAA;AACF;ADLA;AACA;AACE;AACF,0CAAC","file":"/home/runner/work/polytypo-js/polytypo-js/dist/chunk-FDNDYPPY.cjs","sourcesContent":[null,"import { PolytypoError } from \"../errors.js\";\nimport type { Mode } from \"../types.js\";\n\n/**\n * `polytypo/text`, `polytypo/html` and `polytypo/markdown` each fix `mode` at the type level by\n * omitting it from their Options type (AUDIT_REMEDIATION_AND_RELEASE_PLAN.md 5.1, criterion 6).\n * A plain-JS caller — or a TypeScript caller passing a wider-typed variable, which excess-property\n * checking does not catch — can still supply a conflicting `mode` at runtime. That is rejected\n * explicitly here, never silently ignored or overridden.\n */\nexport function assertFixedMode(mode: unknown, fixed: Mode, entryPoint: string): void {\n  if (mode === undefined || mode === fixed) return;\n  throw new PolytypoError(\n    \"POLYTYPO_INVALID_MODE\",\n    `\"${entryPoint}\" only supports mode \"${fixed}\". Received \"${String(mode)}\" — ` +\n      `import from \"polytypo\" for the other modes, or omit \\`mode\\` here.`,\n  );\n}\n"]}

package/dist/{chunk-3H6XONGO.js → chunk-MCQOMIWF.js}

@@ -1,6 +1,6 @@
 import {
   PolytypoError
-} from "./chunk-QDF6EDLT.js";
+} from "./chunk-MF6PJO7O.js";
 
 // src/modes/html.ts
 import { parse, parseFragment } from "parse5";
@@ -144,4 +144,4 @@ export {
   htmlSpans,
   htmlFragmentSpans
 };
-//# sourceMappingURL=chunk-3H6XONGO.js.map
+//# sourceMappingURL=chunk-MCQOMIWF.js.map

package/dist/chunk-MDIDDG32.cjs

@@ -0,0 +1,38 @@
+"use strict";Object.defineProperty(exports, "__esModule", {value: true});
+
+
+
+
+
+
+
+
+
+
+var _chunkWQEB33J2cjs = require('./chunk-WQEB33J2.cjs');
+
+// src/engine/text-pipeline.ts
+function runTextPipeline(input, options) {
+  const narrowTarget = _chunkWQEB33J2cjs.resolveNarrowTarget.call(void 0, options.narrowNbsp);
+  const planned = _chunkWQEB33J2cjs.planRules.call(void 0, options.rules);
+  const locale = _chunkWQEB33J2cjs.getLocaleData.call(void 0, options.locale);
+  const holes = _chunkWQEB33J2cjs.resolveProtect.call(void 0, options.protect, _chunkWQEB33J2cjs.toCodePoints.call(void 0, input).length);
+  if (holes.length > 0) return _chunkWQEB33J2cjs.runProtected.call(void 0, input, holes, planned, locale, narrowTarget);
+  return _chunkWQEB33J2cjs.fromCodePoints.call(void 0, _chunkWQEB33J2cjs.runRules.call(void 0, _chunkWQEB33J2cjs.toCodePoints.call(void 0, input), planned, locale, "text", narrowTarget));
+}
+function analyzeTextPipeline(input, options) {
+  const narrowTarget = _chunkWQEB33J2cjs.resolveNarrowTarget.call(void 0, options.narrowNbsp);
+  const planned = _chunkWQEB33J2cjs.planRules.call(void 0, options.rules);
+  const locale = _chunkWQEB33J2cjs.getLocaleData.call(void 0, options.locale);
+  const cp = _chunkWQEB33J2cjs.toCodePoints.call(void 0, input);
+  const holes = _chunkWQEB33J2cjs.resolveProtect.call(void 0, options.protect, cp.length);
+  if (holes.length > 0) return _chunkWQEB33J2cjs.analyzeProtected.call(void 0, input, holes, planned, locale, narrowTarget);
+  const origin = cp.map((_value, index) => index);
+  return _chunkWQEB33J2cjs.runRulesRecording.call(void 0, cp, planned, locale, "text", narrowTarget, origin, cp.length);
+}
+
+
+
+
+exports.runTextPipeline = runTextPipeline; exports.analyzeTextPipeline = analyzeTextPipeline;
+//# sourceMappingURL=chunk-MDIDDG32.cjs.map

package/dist/chunk-MDIDDG32.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/polytypo-js/polytypo-js/dist/chunk-MDIDDG32.cjs","../src/engine/text-pipeline.ts"],"names":[],"mappings":"AAAA;AACE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACF,wDAA6B;AAC7B;AACA;ACMO,SAAS,eAAA,CAAgB,KAAA,EAAe,OAAA,EAAmC;AAChF,EAAA,MAAM,aAAA,EAAe,mDAAA,OAAoB,CAAQ,UAAU,CAAA;AAC3D,EAAA,MAAM,QAAA,EAAU,yCAAA,OAAU,CAAQ,KAAK,CAAA;AACvC,EAAA,MAAM,OAAA,EAAS,6CAAA,OAAc,CAAQ,MAAM,CAAA;AAC3C,EAAA,MAAM,MAAA,EAAQ,8CAAA,OAAe,CAAQ,OAAA,EAAS,4CAAA,KAAkB,CAAA,CAAE,MAAM,CAAA;AACxE,EAAA,GAAA,CAAI,KAAA,CAAM,OAAA,EAAS,CAAA,EAAG,OAAO,4CAAA,KAAa,EAAO,KAAA,EAAO,OAAA,EAAS,MAAA,EAAQ,YAAY,CAAA;AACrF,EAAA,OAAO,8CAAA,wCAAe,4CAAS,KAAkB,CAAA,EAAG,OAAA,EAAS,MAAA,EAAQ,MAAA,EAAQ,YAAY,CAAC,CAAA;AAC5F;AAGO,SAAS,mBAAA,CAAoB,KAAA,EAAe,OAAA,EAAqC;AACtF,EAAA,MAAM,aAAA,EAAe,mDAAA,OAAoB,CAAQ,UAAU,CAAA;AAC3D,EAAA,MAAM,QAAA,EAAU,yCAAA,OAAU,CAAQ,KAAK,CAAA;AACvC,EAAA,MAAM,OAAA,EAAS,6CAAA,OAAc,CAAQ,MAAM,CAAA;AAC3C,EAAA,MAAM,GAAA,EAAK,4CAAA,KAAkB,CAAA;AAC7B,EAAA,MAAM,MAAA,EAAQ,8CAAA,OAAe,CAAQ,OAAA,EAAS,EAAA,CAAG,MAAM,CAAA;AACvD,EAAA,GAAA,CAAI,KAAA,CAAM,OAAA,EAAS,CAAA,EAAG,OAAO,gDAAA,KAAiB,EAAO,KAAA,EAAO,OAAA,EAAS,MAAA,EAAQ,YAAY,CAAA;AACzF,EAAA,MAAM,OAAA,EAAS,EAAA,CAAG,GAAA,CAAI,CAAC,MAAA,EAAQ,KAAA,EAAA,GAAU,KAAK,CAAA;AAC9C,EAAA,OAAO,iDAAA,EAAkB,EAAI,OAAA,EAAS,MAAA,EAAQ,MAAA,EAAQ,YAAA,EAAc,MAAA,EAAQ,EAAA,CAAG,MAAM,CAAA;AACvF;ADNA;AACA;AACE;AACA;AACF,6FAAC","file":"/home/runner/work/polytypo-js/polytypo-js/dist/chunk-MDIDDG32.cjs","sourcesContent":[null,"import type { Options } from \"../types.js\";\nimport { fromCodePoints, toCodePoints } from \"./codepoints.js\";\nimport type { Change } from \"./origin.js\";\nimport { getLocaleData } from \"./locale.js\";\nimport { resolveNarrowTarget } from \"./narrow-target.js\";\nimport { planRules, runRules, runRulesRecording } from \"./rule-runner.js\";\nimport { analyzeProtected, resolveProtect, runProtected } from \"./protect.js\";\n\n/**\n * `text` mode only. Deliberately imports nothing from `../modes/html.js` or\n * `../modes/markdown.js` (or their parser dependencies) — this is what makes `polytypo/text`'s\n * module graph exclude `parse5` and the Micromark stack (AUDIT_REMEDIATION_AND_RELEASE_PLAN.md\n * 5.1).\n *\n * Validation order — `planRules` before `getLocaleData` — mirrors the pre-Stage-5 aggregate\n * `runPipeline` exactly (an unknown-rule error must win over an unknown-locale error when both\n * are present, since that is public, tested behaviour, not an implementation detail this\n * refactor was authorised to change).\n */\nexport function runTextPipeline(input: string, options: Partial<Options>): string {\n  const narrowTarget = resolveNarrowTarget(options.narrowNbsp);\n  const planned = planRules(options.rules);\n  const locale = getLocaleData(options.locale);\n  const holes = resolveProtect(options.protect, toCodePoints(input).length);\n  if (holes.length > 0) return runProtected(input, holes, planned, locale, narrowTarget);\n  return fromCodePoints(runRules(toCodePoints(input), planned, locale, \"text\", narrowTarget));\n}\n\n/** analyze.md §1: the same pipeline as `runTextPipeline`, reporting instead of applying. */\nexport function analyzeTextPipeline(input: string, options: Partial<Options>): Change[] {\n  const narrowTarget = resolveNarrowTarget(options.narrowNbsp);\n  const planned = planRules(options.rules);\n  const locale = getLocaleData(options.locale);\n  const cp = toCodePoints(input);\n  const holes = resolveProtect(options.protect, cp.length);\n  if (holes.length > 0) return analyzeProtected(input, holes, planned, locale, narrowTarget);\n  const origin = cp.map((_value, index) => index);\n  return runRulesRecording(cp, planned, locale, \"text\", narrowTarget, origin, cp.length);\n}\n"]}

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

@@ -5778,11 +5778,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 +5838,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-MF6PJO7O.js.map