polytypo 1.2.0 → 1.3.0

package/dist/{chunk-POGDWVG5.cjs → chunk-KRY73ZPE.cjs}

@@ -2,13 +2,17 @@
 
 
 
+var _chunk72GQS2N7cjs = require('./chunk-72GQS2N7.cjs');
 
-var _chunkLS57O4KJcjs = require('./chunk-LS57O4KJ.cjs');
 
 
+var _chunk7S5PZ7T5cjs = require('./chunk-7S5PZ7T5.cjs');
 
 
-var _chunkB4O4R6HIcjs = require('./chunk-B4O4R6HI.cjs');
+
+
+
+var _chunkYX6QTWOVcjs = require('./chunk-YX6QTWOV.cjs');
 
 // src/modes/markdown.ts
 var _micromark = require('micromark');
@@ -35,9 +39,11 @@ var SKIPPED_TOKEN_TYPES = /* @__PURE__ */ new Set([
   "mdxFlowExpression",
   "mdxTextExpression",
   "mdxjsEsm",
-  // Not in modes.md 3.7, and it has to be: without it the second `---` of a YAML block reads as
-  // a setext underline, `title: Une note` becomes a paragraph, and `fr` puts a narrow no-break
-  // space in front of the colon of a machine-read metadata field. Reported as a spec gap.
+  // modes.md 3.7.3, and it matters: without it the second `---` of a YAML block reads as a setext
+  // underline, `title: Une note` becomes a paragraph, and `fr` puts a narrow no-break space in
+  // front of the colon of a machine-read metadata field. Covered by conformance fixtures
+  // en-us-markdown-{commonmark,mdx}-frontmatter, fr-markdown-{commonmark,mdx}-frontmatter-nbsp,
+  // en-us-markdown-commonmark-frontmatter-toml and -frontmatter-unterminated.
   "frontmatter"
 ]);
 var RAW_TAG_TOKEN_TYPES = /* @__PURE__ */ new Set([
@@ -84,7 +90,7 @@ function updateElementStack(stack, tag, caseSensitive) {
     if (stack[stack.length - 1] === name) stack.pop();
     return;
   }
-  if (!parsed.selfClosing && _chunkLS57O4KJcjs.isSkippedElement.call(void 0, name)) stack.push(name);
+  if (!parsed.selfClosing && _chunk72GQS2N7cjs.isSkippedElement.call(void 0, name)) stack.push(name);
 }
 function tokenize(source, extensions) {
   return _micromark.postprocess.call(void 0, 
@@ -94,21 +100,23 @@ function tokenize(source, extensions) {
 function resolveDialect(dialect) {
   if (dialect === "commonmark" || dialect === "mdx") return dialect;
   if (dialect === void 0) {
-    throw new (0, _chunkB4O4R6HIcjs.PolytypoError)(
+    throw new (0, _chunkYX6QTWOVcjs.PolytypoError)(
       "POLYTYPO_INVALID_DIALECT",
       'Mode "markdown" requires a dialect. Expected "commonmark" or "mdx"; there is no default.'
     );
   }
-  throw new (0, _chunkB4O4R6HIcjs.PolytypoError)(
+  throw new (0, _chunkYX6QTWOVcjs.PolytypoError)(
     "POLYTYPO_INVALID_DIALECT",
     `Unknown dialect "${String(dialect)}". Expected "commonmark" or "mdx".`
   );
 }
+var FRONTMATTER_MATTERS = ["yaml", "toml"];
 function extensionsFor(dialect) {
-  return dialect === "mdx" ? [_micromarkextensionfrontmatter.frontmatter.call(void 0, ), _micromarkextensiongfm.gfm.call(void 0, ), _micromarkextensionmdxjs.mdxjs.call(void 0, )] : [_micromarkextensionfrontmatter.frontmatter.call(void 0, ), _micromarkextensiongfm.gfm.call(void 0, )];
+  const fm = _micromarkextensionfrontmatter.frontmatter.call(void 0, [...FRONTMATTER_MATTERS]);
+  return dialect === "mdx" ? [fm, _micromarkextensiongfm.gfm.call(void 0, ), _micromarkextensionmdxjs.mdxjs.call(void 0, )] : [fm, _micromarkextensiongfm.gfm.call(void 0, )];
 }
 function markdownSpans(source, dialect) {
-  const events = _chunkLS57O4KJcjs.wrapParserErrors.call(void 0, dialect, () => tokenize(source, extensionsFor(dialect)));
+  const events = _chunk72GQS2N7cjs.wrapParserErrors.call(void 0, dialect, () => tokenize(source, extensionsFor(dialect)));
   const spans = [];
   const elementStack = [];
   let skipDepth = 0;
@@ -131,7 +139,7 @@ function markdownSpans(source, dialect) {
     }
     if (type === "htmlFlow") {
       if (kind === "enter" && skipDepth === 0 && elementStack.length === 0) {
-        for (const span of _chunkLS57O4KJcjs.htmlFragmentSpans.call(void 0, 
+        for (const span of _chunk72GQS2N7cjs.htmlFragmentSpans.call(void 0, 
           source.slice(token.start.offset, token.end.offset),
           token.start.offset
         )) {
@@ -150,14 +158,30 @@ function markdownSpans(source, dialect) {
 
 // src/engine/markdown-pipeline.ts
 function runMarkdownPipeline(input, options) {
-  const planned = _chunkB4O4R6HIcjs.planRules.call(void 0, options.rules);
-  const locale = _chunkB4O4R6HIcjs.getLocaleData.call(void 0, options.locale);
+  const narrowTarget = _chunkYX6QTWOVcjs.resolveNarrowTarget.call(void 0, options.narrowNbsp);
+  const planned = _chunkYX6QTWOVcjs.planRules.call(void 0, options.rules);
+  const locale = _chunkYX6QTWOVcjs.getLocaleData.call(void 0, options.locale);
   const dialect = resolveDialect(options.dialect);
   const spans = markdownSpans(input, dialect);
-  return _chunkLS57O4KJcjs.runOverSpans.call(void 0, input, spans, planned, locale, "markdown");
+  return _chunk7S5PZ7T5cjs.runOverSpans.call(void 0, input, spans, planned, locale, "markdown", narrowTarget);
 }
+function analyzeMarkdownPipeline(input, options) {
+  const narrowTarget = _chunkYX6QTWOVcjs.resolveNarrowTarget.call(void 0, options.narrowNbsp);
+  const planned = _chunkYX6QTWOVcjs.planRules.call(void 0, options.rules);
+  const locale = _chunkYX6QTWOVcjs.getLocaleData.call(void 0, options.locale);
+  const dialect = resolveDialect(options.dialect);
+  return _chunk7S5PZ7T5cjs.analyzeOverSpans.call(void 0, 
+    input,
+    markdownSpans(input, dialect),
+    planned,
+    locale,
+    "markdown",
+    narrowTarget
+  );
+}
+
 
 
 
-exports.runMarkdownPipeline = runMarkdownPipeline;
-//# sourceMappingURL=chunk-POGDWVG5.cjs.map
+exports.runMarkdownPipeline = runMarkdownPipeline; exports.analyzeMarkdownPipeline = analyzeMarkdownPipeline;
+//# sourceMappingURL=chunk-KRY73ZPE.cjs.map

package/dist/chunk-KRY73ZPE.cjs.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/home/runner/work/polytypo-js/polytypo-js/dist/chunk-KRY73ZPE.cjs","../src/modes/markdown.ts","../src/engine/markdown-pipeline.ts"],"names":[],"mappings":"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","file":"/home/runner/work/polytypo-js/polytypo-js/dist/chunk-KRY73ZPE.cjs","sourcesContent":[null,"import { parse, postprocess, preprocess } from \"micromark\";\nimport { frontmatter } from \"micromark-extension-frontmatter\";\nimport { gfm } from \"micromark-extension-gfm\";\nimport { mdxjs } from \"micromark-extension-mdxjs\";\nimport type { Event, Extension } from \"micromark-util-types\";\nimport { PolytypoError } from \"../errors.js\";\nimport type { Dialect } from \"../types.js\";\nimport { htmlFragmentSpans, isSkippedElement } from \"./html.js\";\nimport { wrapParserErrors } from \"./parse-error.js\";\nimport type { Span } from \"./spans.js\";\n\n/**\n * spec/rules/modes.md 3.7. Each entry is skipped **whole**, including anything that looks\n * processable inside it. The complement is not enumerated: a span is emitted only for a\n * micromark `data` token, which is the tokenizer's own name for \"literal content\", so list\n * markers, emphasis delimiters, heading sequences, table padding, line endings, hard-break\n * spaces, character escapes and character references are outside every span by construction\n * rather than by a second list that could drift from the first.\n */\nconst SKIPPED_TOKEN_TYPES: ReadonlySet<string> = new Set([\n  // fenced code blocks (including the info string and the fences) and indented code blocks\n  \"codeFenced\",\n  \"codeIndented\",\n  // inline code spans, including the backticks\n  \"codeText\",\n  // autolinks `<https://…>`, and GFM's bare-URL form\n  \"autolink\",\n  \"literalAutolink\",\n  // link and image destinations and titles; the definition line of a reference link. The link\n  // *text* is a `labelText`, which is not skipped.\n  \"resource\",\n  \"reference\",\n  \"definition\",\n  // MDX: expression containers in full, and every JSX attribute — the whole tag is skipped, so\n  // attributes never surface. JSX element *children* sit outside the tag tokens and are\n  // processable.\n  \"mdxFlowExpression\",\n  \"mdxTextExpression\",\n  \"mdxjsEsm\",\n  // modes.md 3.7.3, and it matters: without it the second `---` of a YAML block reads as a setext\n  // underline, `title: Une note` becomes a paragraph, and `fr` puts a narrow no-break space in\n  // front of the colon of a machine-read metadata field. Covered by conformance fixtures\n  // en-us-markdown-{commonmark,mdx}-frontmatter, fr-markdown-{commonmark,mdx}-frontmatter-nbsp,\n  // en-us-markdown-commonmark-frontmatter-toml and -frontmatter-unterminated.\n  \"frontmatter\",\n]);\n\n/** Token types whose enter/exit also maintains the skipped-element stack. */\nconst RAW_TAG_TOKEN_TYPES: ReadonlySet<string> = new Set([\n  \"htmlText\",\n  \"mdxJsxTextTag\",\n  \"mdxJsxFlowTag\",\n]);\n\nconst LESS_THAN = 0x3c;\nconst GREATER_THAN = 0x3e;\nconst SLASH = 0x2f;\nconst EXCLAMATION = 0x21;\nconst QUESTION = 0x3f;\n\nfunction isAsciiLetter(unit: number): boolean {\n  return (unit >= 0x61 && unit <= 0x7a) || (unit >= 0x41 && unit <= 0x5a);\n}\n\nfunction isTagNameUnit(unit: number): boolean {\n  // Deliberately permissive: anything that is not a delimiter belongs to the name. Custom\n  // elements (`my-callout`) and member expressions (`Foo.Bar`) must come out whole so that they\n  // fail the skip-list membership test rather than being truncated into something that passes.\n  return (\n    unit !== GREATER_THAN &&\n    unit !== SLASH &&\n    unit !== 0x20 &&\n    unit !== 0x09 &&\n    unit !== 0x0a &&\n    unit !== 0x0d\n  );\n}\n\n/** ASCII-only, because HTML tag names are ASCII case-insensitive and `toLowerCase()` is not. */\nfunction asciiLower(value: string): string {\n  let out = \"\";\n  for (let i = 0; i < value.length; i += 1) {\n    const unit = value.charCodeAt(i);\n    out += unit >= 0x41 && unit <= 0x5a ? String.fromCharCode(unit + 0x20) : value[i];\n  }\n  return out;\n}\n\ninterface RawTag {\n  readonly name: string;\n  readonly closing: boolean;\n  readonly selfClosing: boolean;\n}\n\nfunction readTag(tag: string): RawTag | null {\n  if (tag.charCodeAt(0) !== LESS_THAN) return null;\n  let i = 1;\n  const closing = tag.charCodeAt(i) === SLASH;\n  if (closing) i += 1;\n  // Comments, declarations and processing instructions carry no element name.\n  if (tag.charCodeAt(i) === EXCLAMATION || tag.charCodeAt(i) === QUESTION) return null;\n  if (!isAsciiLetter(tag.charCodeAt(i))) return null;\n  const nameAt = i;\n  while (i < tag.length && isTagNameUnit(tag.charCodeAt(i))) i += 1;\n  const selfClosing = tag.charCodeAt(tag.length - 2) === SLASH;\n  return { name: tag.slice(nameAt, i), closing, selfClosing };\n}\n\n/**\n * modes.md 3.7: raw HTML is \"handed to the html skip list of 3.6\". Inline raw HTML reaches the\n * tokenizer as isolated tags with ordinary markdown content between them, so honouring the\n * subtree rule means tracking which skipped element is currently open. JSX names are compared\n * case-sensitively (`<Code>` is a component, `<code>` is an element); HTML names are not.\n */\nfunction updateElementStack(stack: string[], tag: string, caseSensitive: boolean): void {\n  const parsed = readTag(tag);\n  if (parsed === null) return;\n  const name = caseSensitive ? parsed.name : asciiLower(parsed.name);\n  if (parsed.closing) {\n    if (stack[stack.length - 1] === name) stack.pop();\n    return;\n  }\n  if (!parsed.selfClosing && isSkippedElement(name)) stack.push(name);\n}\n\nfunction tokenize(source: string, extensions: readonly Extension[]): Event[] {\n  return postprocess(\n    parse({ extensions: [...extensions] })\n      .document()\n      .write(preprocess()(source, null, true)),\n  );\n}\n\n/**\n * modes.md 3.7.1. The dialect is the caller's, never detected: `\"commonmark\"` is CommonMark 0.31\n * plus GFM, `\"mdx\"` is the same minus indented code blocks and `<…>` autolinks, plus JSX and\n * `{…}` expression containers. Both enable frontmatter and GFM, which 3.7.2 makes normative —\n * §4's promise that table alignment rows survive is empty unless tables are recognised at all.\n */\nexport function resolveDialect(dialect: Dialect | undefined): Dialect {\n  if (dialect === \"commonmark\" || dialect === \"mdx\") return dialect;\n  if (dialect === undefined) {\n    throw new PolytypoError(\n      \"POLYTYPO_INVALID_DIALECT\",\n      'Mode \"markdown\" requires a dialect. Expected \"commonmark\" or \"mdx\"; there is no default.',\n    );\n  }\n  throw new PolytypoError(\n    \"POLYTYPO_INVALID_DIALECT\",\n    `Unknown dialect \"${String(dialect)}\". Expected \"commonmark\" or \"mdx\".`,\n  );\n}\n\n// modes.md 3.7.3 names both frontmatter delimiters, `---` (YAML) and `+++` (TOML), and skips\n// either whole. micromark's default matter is YAML alone, so both must be asked for by name: with\n// the default, a `+++` block parses as prose and the machine-read fields inside it get typeset.\nconst FRONTMATTER_MATTERS = [\"yaml\", \"toml\"] as const;\n\nfunction extensionsFor(dialect: Dialect): Extension[] {\n  const fm = frontmatter([...FRONTMATTER_MATTERS]);\n  return dialect === \"mdx\" ? [fm, gfm(), mdxjs()] : [fm, gfm()];\n}\n\nexport function markdownSpans(source: string, dialect: Dialect): Span[] {\n  const events = wrapParserErrors(dialect, () => tokenize(source, extensionsFor(dialect)));\n  const spans: Span[] = [];\n  const elementStack: string[] = [];\n  let skipDepth = 0;\n\n  for (const [kind, token] of events) {\n    const type = token.type;\n\n    if (SKIPPED_TOKEN_TYPES.has(type)) {\n      skipDepth += kind === \"enter\" ? 1 : -1;\n      continue;\n    }\n\n    if (RAW_TAG_TOKEN_TYPES.has(type)) {\n      if (kind === \"enter\") {\n        updateElementStack(\n          elementStack,\n          source.slice(token.start.offset, token.end.offset),\n          type !== \"htmlText\",\n        );\n      }\n      skipDepth += kind === \"enter\" ? 1 : -1;\n      continue;\n    }\n\n    // An HTML block is handed to the `html` extractor rather than skipped whole, so that the\n    // prose inside `<div>…</div>` is typeset while the markup is not.\n    if (type === \"htmlFlow\") {\n      if (kind === \"enter\" && skipDepth === 0 && elementStack.length === 0) {\n        for (const span of htmlFragmentSpans(\n          source.slice(token.start.offset, token.end.offset),\n          token.start.offset,\n        )) {\n          spans.push(span);\n        }\n      }\n      skipDepth += kind === \"enter\" ? 1 : -1;\n      continue;\n    }\n\n    if (kind === \"enter\" && type === \"data\" && skipDepth === 0 && elementStack.length === 0) {\n      spans.push({ start: token.start.offset, end: token.end.offset });\n    }\n  }\n\n  return spans;\n}\n","import { markdownSpans, resolveDialect } from \"../modes/markdown.js\";\nimport type { Options } from \"../types.js\";\nimport { getLocaleData } from \"./locale.js\";\nimport { resolveNarrowTarget } from \"./narrow-target.js\";\nimport { planRules } from \"./rule-runner.js\";\nimport { analyzeOverSpans, runOverSpans } from \"./span-runner.js\";\nimport type { Change } from \"./origin.js\";\n\n/**\n * `markdown` mode only. Imports the Micromark/MDX stack and `parse5` (via `../modes/markdown.js`\n * importing `../modes/html.js` for normative embedded-HTML handling, modes.md 3.7) — both are\n * legitimately reachable from `polytypo/markdown` (AUDIT_REMEDIATION_AND_RELEASE_PLAN.md 5.1).\n *\n * Validation order — `planRules`, then `getLocaleData`, then `resolveDialect`/parsing — mirrors\n * the pre-Stage-5 aggregate `runPipeline` exactly: an unknown-rule error wins over an\n * unknown-locale error, which wins over a missing/invalid dialect, which wins over a parse\n * failure. All four are public, tested behaviour this refactor was not authorised to change.\n */\nexport function runMarkdownPipeline(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 dialect = resolveDialect(options.dialect);\n  const spans = markdownSpans(input, dialect);\n  return runOverSpans(input, spans, planned, locale, \"markdown\", narrowTarget);\n}\n\n/** analyze.md §1, `markdown` mode. Dialect validation happens here exactly as it does for\n * `runMarkdownPipeline`, so an absent dialect throws POLYTYPO_INVALID_DIALECT from `analyze`\n * too (analyze.md §4 A1). */\nexport function analyzeMarkdownPipeline(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 dialect = resolveDialect(options.dialect);\n  return analyzeOverSpans(\n    input,\n    markdownSpans(input, dialect),\n    planned,\n    locale,\n    \"markdown\",\n    narrowTarget,\n  );\n}\n"]}

package/dist/{chunk-YYHKX5HE.cjs → chunk-M7YWQ47K.cjs}

@@ -1,11 +1,11 @@
 "use strict";Object.defineProperty(exports, "__esModule", {value: true});
 
-var _chunkB4O4R6HIcjs = require('./chunk-B4O4R6HI.cjs');
+var _chunkYX6QTWOVcjs = require('./chunk-YX6QTWOV.cjs');
 
 // src/engine/assert-fixed-mode.ts
 function assertFixedMode(mode, fixed, entryPoint) {
   if (mode === void 0 || mode === fixed) return;
-  throw new (0, _chunkB4O4R6HIcjs.PolytypoError)(
+  throw new (0, _chunkYX6QTWOVcjs.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-YYHKX5HE.cjs.map
+//# sourceMappingURL=chunk-M7YWQ47K.cjs.map

package/dist/{chunk-YYHKX5HE.cjs.map → chunk-M7YWQ47K.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/polytypo-js/polytypo-js/dist/chunk-YYHKX5HE.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-YYHKX5HE.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-M7YWQ47K.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-M7YWQ47K.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-VARU43JT.js → chunk-NT2RADO3.js}

@@ -1,13 +1,6 @@
 import {
-  LINE_MARKER,
-  MARKER,
-  PolytypoError,
-  RULES,
-  applyEdits,
-  fromCodePoints,
-  isMarker,
-  toCodePoints
-} from "./chunk-OHF7OFWY.js";
+  PolytypoError
+} from "./chunk-GLQQOA6T.js";
 
 // src/modes/html.ts
 import { parse, parseFragment } from "parse5";
@@ -145,153 +138,10 @@ function htmlFragmentSpans(source, offset) {
   return offset === 0 ? spans : spans.map((span) => ({ start: span.start + offset, end: span.end + offset }));
 }
 
-// src/modes/spans.ts
-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 && r > d && (p === span.first || q === span.last)) 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;
-}
-
-// src/engine/span-runner.ts
-function runRulesOverSpans(cp, planned, locale, mode) {
-  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 });
-    current = applyEdits(current, filterBoundaryEdits(current, edits, spanRangesOf(current)), id);
-  }
-  return current;
-}
-function runOverSpans(source, spans, planned, locale, mode) {
-  const normalized = normalizeSpans(spans);
-  if (normalized.length === 0) return source;
-  const transformed = runRulesOverSpans(
-    concatenateSpans(source, normalized),
-    planned,
-    locale,
-    mode
-  );
-  const pieces = splitOnMarker(transformed, normalized.length);
-  let out = "";
-  let cursor = 0;
-  for (let i = 0; i < normalized.length; i += 1) {
-    const span = normalized[i];
-    const replacement = fromCodePoints(pieces[i]);
-    const original = source.slice(span.start, span.end);
-    out += source.slice(cursor, span.start);
-    out += replacement === original ? original : replacement;
-    cursor = span.end;
-  }
-  return out + source.slice(cursor);
-}
-
 export {
   wrapParserErrors,
   isSkippedElement,
   htmlSpans,
-  htmlFragmentSpans,
-  runOverSpans
+  htmlFragmentSpans
 };
-//# sourceMappingURL=chunk-VARU43JT.js.map
+//# sourceMappingURL=chunk-NT2RADO3.js.map

package/dist/chunk-NT2RADO3.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/modes/html.ts","../src/modes/parse-error.ts"],"sourcesContent":["import { parse, parseFragment } from \"parse5\";\nimport type { DefaultTreeAdapterMap } from \"parse5\";\nimport { wrapParserErrors } from \"./parse-error.js\";\nimport type { Span } from \"./spans.js\";\n\ntype Node = DefaultTreeAdapterMap[\"node\"];\ntype ParentNode = DefaultTreeAdapterMap[\"parentNode\"];\n\n/**\n * spec/rules/modes.md 3.6, exhaustive and **closed**: extending it is a spec change, not an\n * implementation decision. `svg` and `math` are here because in MathML a quotation mark, a\n * hyphen and a prime are operators and identifiers — substituting a curly glyph changes what\n * the expression means. Everything not listed is processable, **including unknown and custom\n * elements**: guessing from a tag name is exactly the heuristic that diverges across runtimes.\n */\nconst SKIPPED_ELEMENTS: ReadonlySet<string> = new Set([\n  \"code\",\n  \"pre\",\n  \"kbd\",\n  \"samp\",\n  \"var\",\n  \"script\",\n  \"style\",\n  \"textarea\",\n  \"svg\",\n  \"math\",\n]);\n\nexport function isSkippedElement(tagName: string): boolean {\n  return SKIPPED_ELEMENTS.has(tagName);\n}\n\nconst AMPERSAND = 0x26;\nconst SEMICOLON = 0x3b;\nconst HASH = 0x23;\nconst LOWER_X = 0x78;\nconst UPPER_X = 0x58;\n\n/** Longest named reference in the WHATWG table is 32 characters; the guard is a bound, not a rule. */\nconst MAX_REFERENCE_BODY = 34;\n\nfunction isAsciiDigit(unit: number): boolean {\n  return unit >= 0x30 && unit <= 0x39;\n}\n\nfunction isAsciiHexDigit(unit: number): boolean {\n  return isAsciiDigit(unit) || (unit >= 0x61 && unit <= 0x66) || (unit >= 0x41 && unit <= 0x46);\n}\n\nfunction isAsciiAlphanumeric(unit: number): boolean {\n  return isAsciiDigit(unit) || (unit >= 0x61 && unit <= 0x7a) || (unit >= 0x41 && unit <= 0x5a);\n}\n\n/**\n * The end offset of a well-formed character reference starting at `at`, or -1. A bare `&` that a\n * parser would repair is deliberately **not** treated as a reference: it stays inside the span,\n * where no rule can emit or delete it, rather than manufacturing a boundary that suppresses\n * conversions around it.\n */\nfunction characterReferenceEnd(source: string, at: number, limit: number): number {\n  if (source.charCodeAt(at) !== AMPERSAND) return -1;\n  let i = at + 1;\n  if (i >= limit) return -1;\n\n  if (source.charCodeAt(i) === HASH) {\n    i += 1;\n    const unit = i < limit ? source.charCodeAt(i) : -1;\n    const hex = unit === LOWER_X || unit === UPPER_X;\n    if (hex) i += 1;\n    const digitsAt = i;\n    while (\n      i < limit &&\n      (hex ? isAsciiHexDigit(source.charCodeAt(i)) : isAsciiDigit(source.charCodeAt(i)))\n    ) {\n      i += 1;\n    }\n    if (i === digitsAt) return -1;\n    return i < limit && source.charCodeAt(i) === SEMICOLON ? i + 1 : -1;\n  }\n\n  const nameAt = i;\n  while (\n    i < limit &&\n    i - nameAt < MAX_REFERENCE_BODY &&\n    isAsciiAlphanumeric(source.charCodeAt(i))\n  ) {\n    i += 1;\n  }\n  if (i === nameAt) return -1;\n  return i < limit && source.charCodeAt(i) === SEMICOLON ? i + 1 : -1;\n}\n\n/**\n * modes.md 3.6: every character reference is skipped as an **opaque unit**, and a text node\n * containing one is split into spans around it. That is the only way `&nbsp;` survives as\n * `&nbsp;` instead of becoming a literal U+00A0 on the way out.\n */\nexport function splitCharacterReferences(source: string, start: number, end: number): Span[] {\n  const spans: Span[] = [];\n  let cursor = start;\n  let i = start;\n  while (i < end) {\n    if (source.charCodeAt(i) === AMPERSAND) {\n      const stop = characterReferenceEnd(source, i, end);\n      if (stop > 0) {\n        if (i > cursor) spans.push({ start: cursor, end: i });\n        cursor = stop;\n        i = stop;\n        continue;\n      }\n    }\n    i += 1;\n  }\n  if (end > cursor) spans.push({ start: cursor, end });\n  return spans;\n}\n\nfunction isParent(node: Node): node is ParentNode {\n  return \"childNodes\" in node;\n}\n\nfunction collect(node: Node, source: string, spans: Span[]): void {\n  if (node.nodeName === \"#text\") {\n    const location = node.sourceCodeLocation;\n    if (location === undefined || location === null) return;\n    for (const span of splitCharacterReferences(source, location.startOffset, location.endOffset)) {\n      spans.push(span);\n    }\n    return;\n  }\n\n  // Comments, doctype and processing instructions never contribute a span (modes.md 3.6).\n  if (node.nodeName === \"#comment\" || node.nodeName === \"#documentType\") return;\n\n  if (\"tagName\" in node && isSkippedElement(node.tagName)) return;\n\n  // A `template`'s children live in a separate document fragment; `template` is not skipped.\n  if (node.nodeName === \"template\" && \"content\" in node) {\n    collect(node.content, source, spans);\n    return;\n  }\n\n  if (!isParent(node)) return;\n  for (const child of node.childNodes) collect(child, source, spans);\n}\n\n/**\n * Locate the processable spans of an HTML document. The tree is used only to find offsets and is\n * then discarded — modes.md 4 forbids reserialisation, which is what makes attribute quoting,\n * self-closing forms, entity spelling, tag case and malformed-input recovery preserved by\n * construction rather than by effort.\n */\nexport function htmlSpans(source: string): Span[] {\n  const document = wrapParserErrors(\"HTML\", () => parse(source, { sourceCodeLocationInfo: true }));\n  const spans: Span[] = [];\n  collect(document, source, spans);\n  return spans;\n}\n\n/** The same, for a fragment: used for HTML blocks embedded in markdown (modes.md 3.7). */\nexport function htmlFragmentSpans(source: string, offset: number): Span[] {\n  const fragment = wrapParserErrors(\"HTML\", () =>\n    parseFragment(source, { sourceCodeLocationInfo: true }),\n  );\n  const spans: Span[] = [];\n  collect(fragment, source, spans);\n  return offset === 0\n    ? spans\n    : spans.map((span) => ({ start: span.start + offset, end: span.end + offset }));\n}\n","import { PolytypoError } from \"../errors.js\";\n\ninterface PositionedError {\n  readonly reason?: unknown;\n  readonly place?: { readonly line?: unknown; readonly column?: unknown } | null;\n}\n\nfunction describe(error: unknown): string {\n  if (typeof error !== \"object\" || error === null) return String(error);\n  const positioned = error as PositionedError;\n  const reason =\n    typeof positioned.reason === \"string\" ? positioned.reason : (error as Error).message;\n  const place = positioned.place;\n  if (\n    place !== null &&\n    place !== undefined &&\n    typeof place.line === \"number\" &&\n    typeof place.column === \"number\"\n  ) {\n    return `${reason} (line ${place.line}, column ${place.column})`;\n  }\n  return reason;\n}\n\n/**\n * spec/rules/modes.md 3.7.2. **The parser's own error type must never escape.** A\n * `VFileMessage`, a `Nokogiri::SyntaxError` or a Python exception on the public surface puts a\n * dependency's type into the contract and is unreproducible in the other four runtimes; only the\n * code is contractual (ARCHITECTURE.md 4.6), while the message and the source position are\n * useful and are not.\n *\n * Reachable in exactly one place: `dialect: \"mdx\"`, because MDX embeds JavaScript. HTML parsing\n * is specified with total error recovery and every byte sequence is valid CommonMark, so neither\n * of the other two languages can fail. The wrapper is applied to all of them anyway — the\n * guarantee is that no parser type escapes, not that this particular parser is trusted.\n */\nexport function wrapParserErrors<T>(what: string, run: () => T): T {\n  try {\n    return run();\n  } catch (error) {\n    if (error instanceof PolytypoError) throw error;\n    throw new PolytypoError(\n      \"POLYTYPO_MALFORMED_INPUT\",\n      `Input does not parse as ${what}: ${describe(error)}`,\n    );\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-PLWW5KPC.js

@@ -0,0 +1,205 @@
+import {
+  LINE_MARKER,
+  MARKER,
+  NO_ORIGIN,
+  PolytypoError,
+  RULES,
+  applyEdits,
+  fromCodePoints,
+  isMarker,
+  runRulesRecording,
+  toCodePoints
+} from "./chunk-GLQQOA6T.js";
+
+// src/modes/spans.ts
+var SPACE = 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 === SPACE && cp[p] !== SPACE) continue;
+      if (r > 0 && q === span.last && last === SPACE && cp[q] !== SPACE) 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 runOverSpans(source, spans, planned, locale, mode, narrowTarget) {
+  const normalized = normalizeSpans(spans);
+  if (normalized.length === 0) return source;
+  const transformed = runRulesOverSpans(
+    concatenateSpans(source, normalized),
+    planned,
+    locale,
+    mode,
+    narrowTarget
+  );
+  const pieces = splitOnMarker(transformed, normalized.length);
+  let out = "";
+  let cursor = 0;
+  for (let i = 0; i < normalized.length; i += 1) {
+    const span = normalized[i];
+    const replacement = fromCodePoints(pieces[i]);
+    const original = source.slice(span.start, span.end);
+    out += source.slice(cursor, span.start);
+    out += replacement === original ? original : replacement;
+    cursor = span.end;
+  }
+  return out + source.slice(cursor);
+}
+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))
+  );
+}
+
+export {
+  runOverSpans,
+  analyzeOverSpans
+};
+//# sourceMappingURL=chunk-PLWW5KPC.js.map

package/dist/chunk-PLWW5KPC.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/modes/spans.ts","../src/engine/span-runner.ts"],"sourcesContent":["import { toCodePoints } from \"../engine/codepoints.js\";\nimport { isMarker, LINE_MARKER, MARKER } from \"../engine/sentinels.js\";\nimport { PolytypoError } from \"../errors.js\";\nimport type { Edit } from \"../types.js\";\nimport { NO_ORIGIN } from \"../engine/origin.js\";\n\n/**\n * The boundary markers are defined in the engine (src/engine/sentinels.ts), which is where all\n * three non-code-point sentinels live and where their disjointness is maintained. They are\n * re-exported here because the mode layer is what writes them into the array.\n *\n * Which marker separates two spans is decided by the **raw source bytes of the gap between\n * them**, so it is decidable without asking the parser anything and is identical in five\n * runtimes: a gap containing a line terminator gives `LINE_MARKER`, anything else `MARKER`.\n */\nexport { LINE_MARKER, MARKER, isMarker } from \"../engine/sentinels.js\";\n\n/** `BREAK` as the rules define it (`spaces.md` 3.1), tested against the gap's raw source. */\n/** U+0020, the one emitted code point whose meaning is positional (modes.md 3.4, 5 item 2). */\nconst SPACE = 0x20;\n\nconst LINE_TERMINATORS: ReadonlySet<number> = new Set([\n  0x0a, 0x0d, 0x0b, 0x0c, 0x85, 0x2028, 0x2029,\n]);\n\nfunction gapIsLineBoundary(source: string, from: number, to: number): boolean {\n  for (let i = from; i < to; i += 1) {\n    if (LINE_TERMINATORS.has(source.charCodeAt(i))) return true;\n  }\n  return false;\n}\n\n/**\n * A processable span, identified by its offsets in the **original source**. Offsets are UTF-16\n * indices into the JS source string, which is what every JS parser reports; they are an\n * implementation detail of this runtime and never reach the rules, which index code points.\n */\nexport interface Span {\n  readonly start: number;\n  readonly end: number;\n}\n\n/** A span's extent in the concatenated code-point array: `s₀` and `s₁` of modes.md 3.4. */\nexport interface SpanRange {\n  readonly first: number;\n  readonly last: number;\n}\n\n/**\n * Sort, drop empties, and coalesce spans separated by nothing in the source (modes.md 7.5:\n * a parser that reports one text run as two adjacent nodes must not manufacture a boundary).\n * Overlapping spans are an extractor bug and are rejected rather than silently merged.\n */\nexport function normalizeSpans(spans: readonly Span[]): Span[] {\n  const sorted = spans.filter((s) => s.end > s.start).sort((a, b) => a.start - b.start);\n  const out: Span[] = [];\n  for (const span of sorted) {\n    const last = out[out.length - 1];\n    if (last === undefined) {\n      out.push(span);\n      continue;\n    }\n    if (span.start < last.end) {\n      throw new PolytypoError(\n        \"POLYTYPO_RULE_CONTRACT\",\n        `mode extractor produced overlapping spans (${last.start}, ${last.end}) and (${span.start}, ${span.end})`,\n      );\n    }\n    if (span.start === last.end) {\n      out[out.length - 1] = { start: last.start, end: span.end };\n      continue;\n    }\n    out.push(span);\n  }\n  return out;\n}\n\n/** `S₁ ⌢ [marker] ⌢ S₂ ⌢ … ⌢ Sₘ` (modes.md 3.5 step 2). */\nexport function concatenateSpans(source: string, spans: readonly Span[]): number[] {\n  const cp: number[] = [];\n  let previous: Span | undefined;\n  for (const span of spans) {\n    if (previous !== undefined) {\n      cp.push(gapIsLineBoundary(source, previous.end, span.start) ? LINE_MARKER : MARKER);\n    }\n    for (const value of toCodePoints(source.slice(span.start, span.end))) cp.push(value);\n    previous = span;\n  }\n  return cp;\n}\n\n/**\n * The span extents of the array as it stands. Recomputed after every rule, because applying\n * edits shifts every index after the first one — the markers themselves are guaranteed to\n * survive, since no edit may contain one.\n */\nexport function spanRangesOf(cp: readonly number[]): SpanRange[] {\n  const ranges: SpanRange[] = [];\n  let first = 0;\n  for (let i = 0; i < cp.length; i += 1) {\n    if (isMarker(cp[i] as number)) {\n      ranges.push({ first, last: i - 1 });\n      first = i + 1;\n    }\n  }\n  ranges.push({ first, last: cp.length - 1 });\n  return ranges;\n}\n\nfunction spanContaining(ranges: readonly SpanRange[], p: number): SpanRange | undefined {\n  for (const range of ranges) {\n    if (p >= range.first && p <= range.last + 1) return range;\n  }\n  return undefined;\n}\n\n/**\n * modes.md 3.4, two safety nets, both pure functions of `(p, q, r, s₀, s₁)` — so the verdict is\n * identical on every run, which is what makes redistribution deterministic (modes.md 5, point 3).\n *\n * 1. **No edit may contain a marker.** No rule can produce one; one that does is a bug, and the\n *    edit is discarded rather than treated as a redistribution question.\n * 2. **The edge-growth rule.** An edit is discarded if it would place code points at an\n *    extremity of its span that were not there before: with `d = q - p + 1` the replaced length\n *    and `r` the replacement length, discard when `p = s₀ and r > d`, or `q = s₁ and r > d`.\n *\n * The length test is the whole rule and needs no knowledge of Markdown or HTML syntax. It\n * separates exactly the cases that matter: `\"` → `“` at an edge is 1 → 1 and applies; `--` →\n * `␣–␣` at an edge is 2 → 3 and is discarded, while the same edit interior to a span applies;\n * `(c)` → `©` is 3 → 1 and applies, because shrinking is always safe. An insertion has `d = 0`,\n * so it is discarded exactly when its position coincides with a span edge — the rule this one\n * generalises.\n *\n * **Deletion at an edge is not restricted here**, and must not be: `r > d` is false for a\n * deletion, so this filter never sees one. Deletion at an edge is governed by modes.md 3.3's\n * *Edge tests* clause instead — where a rule asks \"am I at the edge of the text I am allowed to\n * modify\" rather than \"what character is here\", the marker behaves as `NONE`. That clause is the\n * one place a rule may treat a span edge as the end of the text, it exists because `spaces` is\n * the only rule that deletes, and 3.3 states the division: **a rule that deletes must treat a\n * span edge as the end of the text; a rule that replaces or inserts must not, and is governed by\n * this filter.** The single test that claims the clause is `spaces.md` 3.2 step 4.\n */\nexport function filterBoundaryEdits(\n  cp: readonly number[],\n  edits: readonly Edit[],\n  ranges: readonly SpanRange[],\n): Edit[] {\n  const out: Edit[] = [];\n  for (const edit of edits) {\n    let containsMarker = false;\n    for (let i = edit.start; i < edit.end; i += 1) {\n      if (isMarker(cp[i] as number)) {\n        containsMarker = true;\n        break;\n      }\n    }\n    if (containsMarker) continue;\n\n    // `[start, end)` in the engine's half-open form is `cp[p … q]` with p = start, q = end - 1;\n    // an insertion is `q = p - 1`, which falls out of the same expression.\n    const p = edit.start;\n    const q = edit.end - 1;\n    const d = edit.end - edit.start;\n    const r = edit.replacement.length;\n    const span = spanContaining(ranges, p);\n    if (span !== undefined && (p === span.first || q === span.last)) {\n      if (r > d) continue;\n      // The character clause. `r > d` is not the rule, only a formalisation of it that misses\n      // `r === d`: `dashes` P3 admits a run of THREE dashes, so `---` -> `␣–␣` is 3 -> 3 and the\n      // length test sees nothing while U+0020 lands on both extremities anyway. Testing the\n      // character catches it, and only U+0020 needs testing — it is the one code point any rule\n      // emits whose meaning comes from its position rather than from itself (modes.md 5 item 2).\n      const first = edit.replacement[0];\n      const last = edit.replacement[r - 1];\n      if (r > 0 && p === span.first && first === SPACE && cp[p] !== SPACE) continue;\n      if (r > 0 && q === span.last && last === SPACE && cp[q] !== SPACE) continue;\n    }\n\n    out.push(edit);\n  }\n  return out;\n}\n\n/** Redistribute the transformed array back to one piece per span (modes.md 3.5 step 4). */\nexport function splitOnMarker(cp: readonly number[], expected: number): number[][] {\n  const pieces: number[][] = [[]];\n  for (const value of cp) {\n    if (isMarker(value)) {\n      pieces.push([]);\n      continue;\n    }\n    (pieces[pieces.length - 1] as number[]).push(value);\n  }\n  if (pieces.length !== expected) {\n    throw new PolytypoError(\n      \"POLYTYPO_RULE_CONTRACT\",\n      `boundary markers did not survive the pipeline: expected ${expected} spans, found ${pieces.length}`,\n    );\n  }\n  return pieces;\n}\n\n/**\n * The origin map for `concatenateSpans` (analyze.md §2): for every code point of the joined\n * array, the code-point offset of the character it came from IN THE DOCUMENT, and NO_ORIGIN for\n * the markers, which came from nowhere. `Span` bounds are native string indices, so the\n * conversion to code-point offsets happens here and not in the caller — this is the one place\n * that knows both coordinate systems.\n */\nexport function originOfSpans(source: string, spans: readonly Span[]): number[] {\n  const codePointIndexOf = new Array<number>(source.length + 1);\n  let cpIndex = 0;\n  for (let i = 0; i < source.length;) {\n    codePointIndexOf[i] = cpIndex;\n    const code = source.codePointAt(i) as number;\n    const width = code > 0xffff ? 2 : 1;\n    if (width === 2) codePointIndexOf[i + 1] = cpIndex;\n    i += width;\n    cpIndex += 1;\n  }\n  codePointIndexOf[source.length] = cpIndex;\n\n  const origin: number[] = [];\n  let previous: Span | undefined;\n  for (const span of spans) {\n    if (previous !== undefined) origin.push(NO_ORIGIN);\n    const base = codePointIndexOf[span.start] as number;\n    const length = toCodePoints(source.slice(span.start, span.end)).length;\n    for (let k = 0; k < length; k += 1) origin.push(base + k);\n    previous = span;\n  }\n  return origin;\n}\n","import {\n  concatenateSpans,\n  filterBoundaryEdits,\n  normalizeSpans,\n  originOfSpans,\n  spanRangesOf,\n  splitOnMarker,\n  type Span,\n} from \"../modes/spans.js\";\nimport { RULES } from \"../rules/registry.js\";\nimport type { LocaleData, Mode, RuleId } from \"../types.js\";\nimport { applyEdits } from \"./edits.js\";\nimport { fromCodePoints, toCodePoints } from \"./codepoints.js\";\nimport type { Change } from \"./origin.js\";\nimport { runRulesRecording } from \"./rule-runner.js\";\n\n/**\n * The same sequence as `runRules` (`./rule-runner.js`), with the two boundary filters of\n * modes.md 3.4 interposed. The span extents are recomputed after every rule, because applying\n * an edit shifts every index after it; the markers themselves always survive, since no edit may\n * contain one.\n */\nfunction runRulesOverSpans(\n  cp: readonly number[],\n  planned: readonly RuleId[],\n  locale: LocaleData,\n  mode: Mode,\n  narrowTarget: number,\n): readonly number[] {\n  let current = cp;\n  for (const id of planned) {\n    const rule = RULES[id];\n    if (rule === undefined) continue;\n    const edits = rule.apply({ cp: current, locale, mode, narrowTarget });\n    current = applyEdits(current, filterBoundaryEdits(current, edits, spanRangesOf(current)), id);\n  }\n  return current;\n}\n\n/**\n * modes.md 3.5. The pipeline runs **once**, over the marker-separated concatenation of every\n * processable span — not per span, which would pair quotation marks in isolation, and not over a\n * naive concatenation, which would manufacture adjacencies the document does not have.\n *\n * The output is the input with a set of disjoint substring replacements applied and nothing else\n * (modes.md 4). A span whose content the rules did not change contributes no replacement, so a\n * document needing no changes comes back byte-identical; the parser located the spans and was\n * then discarded, and the document is never serialised.\n */\nexport function runOverSpans(\n  source: string,\n  spans: readonly Span[],\n  planned: readonly RuleId[],\n  locale: LocaleData,\n  mode: Mode,\n  narrowTarget: number,\n): string {\n  const normalized = normalizeSpans(spans);\n  if (normalized.length === 0) return source;\n\n  const transformed = runRulesOverSpans(\n    concatenateSpans(source, normalized),\n    planned,\n    locale,\n    mode,\n    narrowTarget,\n  );\n  const pieces = splitOnMarker(transformed, normalized.length);\n\n  let out = \"\";\n  let cursor = 0;\n  for (let i = 0; i < normalized.length; i += 1) {\n    const span = normalized[i] as Span;\n    const replacement = fromCodePoints(pieces[i] as number[]);\n    const original = source.slice(span.start, span.end);\n    out += source.slice(cursor, span.start);\n    out += replacement === original ? original : replacement;\n    cursor = span.end;\n  }\n  return out + source.slice(cursor);\n}\n\n/**\n * `runOverSpans`, reporting instead of applying (analyze.md §1). The span table supplies the\n * origin map, so every change comes back in DOCUMENT coordinates — analyze.md §6 names a\n * runtime that reports span-local offsets here as the mistake that passes every text-mode test.\n */\nexport function analyzeOverSpans(\n  source: string,\n  spans: readonly Span[],\n  planned: readonly RuleId[],\n  locale: LocaleData,\n  mode: Mode,\n  narrowTarget: number,\n): Change[] {\n  const normalized = normalizeSpans(spans);\n  if (normalized.length === 0) return [];\n  return runRulesRecording(\n    concatenateSpans(source, normalized),\n    planned,\n    locale,\n    mode,\n    narrowTarget,\n    originOfSpans(source, normalized),\n    toCodePoints(source).length,\n    (current, edits) => filterBoundaryEdits(current, edits, spanRangesOf(current)),\n  );\n}\n"],"mappings":"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","names":[]}