polytypo 1.12.0 → 1.13.0

package/dist/{chunk-QZEJRXXP.cjs.map → chunk-W52W6XGA.cjs.map}

@@ -1 +1 @@
-{"version":3,"sources":["/home/runner/work/polytypo-js/polytypo-js/dist/chunk-QZEJRXXP.cjs","../src/modes/html.ts","../src/modes/parse-error.ts"],"names":[],"mappings":"AAAA;AACE;AACF,wDAA6B;AAC7B;AACA;ACJA,gCAAqC;ADMrC;AACA;AEAA,SAAS,QAAA,CAAS,KAAA,EAAwB;AACxC,EAAA,GAAA,CAAI,OAAO,MAAA,IAAU,SAAA,GAAY,MAAA,IAAU,IAAA,EAAM,OAAO,MAAA,CAAO,KAAK,CAAA;AACpE,EAAA,MAAM,WAAA,EAAa,KAAA;AACnB,EAAA,MAAM,OAAA,EACJ,OAAO,UAAA,CAAW,OAAA,IAAW,SAAA,EAAW,UAAA,CAAW,OAAA,EAAU,KAAA,CAAgB,OAAA;AAC/E,EAAA,MAAM,MAAA,EAAQ,UAAA,CAAW,KAAA;AACzB,EAAA,GAAA,CACE,MAAA,IAAU,KAAA,GACV,MAAA,IAAU,KAAA,EAAA,GACV,OAAO,KAAA,CAAM,KAAA,IAAS,SAAA,GACtB,OAAO,KAAA,CAAM,OAAA,IAAW,QAAA,EACxB;AACA,IAAA,OAAO,CAAA,EAAA;AACT,EAAA;AACO,EAAA;AACT;AAcgB;AACV,EAAA;AACK,IAAA;AACA,EAAA;AACH,IAAA;AACE,IAAA;AACJ,MAAA;AACA,MAAA;AACF,IAAA;AACF,EAAA;AACF;AFjBY;AACA;ACfN;AACJ,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACD;AAEe;AACP,EAAA;AACT;AAEM;AACA;AACO;AACP;AACA;AAGA;AAEG;AACA,EAAA;AACT;AAES;AACA,EAAA;AACT;AAES;AACA,EAAA;AACT;AAQS;AACH,EAAA;AACI,EAAA;AACC,EAAA;AAEL,EAAA;AACG,IAAA;AACC,IAAA;AACA,IAAA;AACG,IAAA;AACH,IAAA;AAEJ,IAAA;AAGK,MAAA;AACP,IAAA;AACI,IAAA;AACG,IAAA;AACT,EAAA;AAEM,EAAA;AAEJ,EAAA;AAIK,IAAA;AACP,EAAA;AACU,EAAA;AACH,EAAA;AACT;AAOgB;AACR,EAAA;AACF,EAAA;AACI,EAAA;AACD,EAAA;AACD,IAAA;AACI,MAAA;AACF,MAAA;AACE,QAAA;AACJ,QAAA;AACI,QAAA;AACJ,QAAA;AACF,MAAA;AACF,IAAA;AACK,IAAA;AACP,EAAA;AACU,EAAA;AACH,EAAA;AACT;AAES;AACA,EAAA;AACT;AAES;AACE,EAAA;AACD,IAAA;AACF,IAAA;AACJ,IAAA;AACQ,MAAA;AACR,IAAA;AACA,IAAA;AACF,EAAA;AAGS,EAAA;AAEL,EAAA;AAGK,EAAA;AACC,IAAA;AACR,IAAA;AACF,EAAA;AAEK,EAAA;AACL,EAAA;AACF;AAQgB;AACR,EAAA;AACA,EAAA;AACE,EAAA;AACD,EAAA;AACT;AAGgB;AACR,EAAA;AAA4B,IAAA;AAChC,IAAA;AACF,EAAA;AACM,EAAA;AACE,EAAA;AACD,EAAA;AAGT;AD9BY;AACA;AACA;AACA;AACA;AACA;AACA","file":"/home/runner/work/polytypo-js/polytypo-js/dist/chunk-QZEJRXXP.cjs","sourcesContent":[null,"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"]}
+{"version":3,"sources":["/home/runner/work/polytypo-js/polytypo-js/dist/chunk-W52W6XGA.cjs","../src/modes/html.ts","../src/modes/parse-error.ts"],"names":[],"mappings":"AAAA;AACE;AACF,wDAA6B;AAC7B;AACA;ACJA,gCAAqC;ADMrC;AACA;AEAA,SAAS,QAAA,CAAS,KAAA,EAAwB;AACxC,EAAA,GAAA,CAAI,OAAO,MAAA,IAAU,SAAA,GAAY,MAAA,IAAU,IAAA,EAAM,OAAO,MAAA,CAAO,KAAK,CAAA;AACpE,EAAA,MAAM,WAAA,EAAa,KAAA;AACnB,EAAA,MAAM,OAAA,EACJ,OAAO,UAAA,CAAW,OAAA,IAAW,SAAA,EAAW,UAAA,CAAW,OAAA,EAAU,KAAA,CAAgB,OAAA;AAC/E,EAAA,MAAM,MAAA,EAAQ,UAAA,CAAW,KAAA;AACzB,EAAA,GAAA,CACE,MAAA,IAAU,KAAA,GACV,MAAA,IAAU,KAAA,EAAA,GACV,OAAO,KAAA,CAAM,KAAA,IAAS,SAAA,GACtB,OAAO,KAAA,CAAM,OAAA,IAAW,QAAA,EACxB;AACA,IAAA,OAAO,CAAA,EAAA;AACT,EAAA;AACO,EAAA;AACT;AAcgB;AACV,EAAA;AACK,IAAA;AACA,EAAA;AACH,IAAA;AACE,IAAA;AACJ,MAAA;AACA,MAAA;AACF,IAAA;AACF,EAAA;AACF;AFjBY;AACA;ACfN;AACJ,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACA,EAAA;AACD;AAEe;AACP,EAAA;AACT;AAEM;AACA;AACO;AACP;AACA;AAGA;AAEG;AACA,EAAA;AACT;AAES;AACA,EAAA;AACT;AAES;AACA,EAAA;AACT;AAQS;AACH,EAAA;AACI,EAAA;AACC,EAAA;AAEL,EAAA;AACG,IAAA;AACC,IAAA;AACA,IAAA;AACG,IAAA;AACH,IAAA;AAEJ,IAAA;AAGK,MAAA;AACP,IAAA;AACI,IAAA;AACG,IAAA;AACT,EAAA;AAEM,EAAA;AAEJ,EAAA;AAIK,IAAA;AACP,EAAA;AACU,EAAA;AACH,EAAA;AACT;AAOgB;AACR,EAAA;AACF,EAAA;AACI,EAAA;AACD,EAAA;AACD,IAAA;AACI,MAAA;AACF,MAAA;AACE,QAAA;AACJ,QAAA;AACI,QAAA;AACJ,QAAA;AACF,MAAA;AACF,IAAA;AACK,IAAA;AACP,EAAA;AACU,EAAA;AACH,EAAA;AACT;AAES;AACA,EAAA;AACT;AAES;AACE,EAAA;AACD,IAAA;AACF,IAAA;AACJ,IAAA;AACQ,MAAA;AACR,IAAA;AACA,IAAA;AACF,EAAA;AAGS,EAAA;AAEL,EAAA;AAGK,EAAA;AACC,IAAA;AACR,IAAA;AACF,EAAA;AAEK,EAAA;AACL,EAAA;AACF;AAQgB;AACR,EAAA;AACA,EAAA;AACE,EAAA;AACD,EAAA;AACT;AAGgB;AACR,EAAA;AAA4B,IAAA;AAChC,IAAA;AACF,EAAA;AACM,EAAA;AACE,EAAA;AACD,EAAA;AAGT;AD9BY;AACA;AACA;AACA;AACA;AACA;AACA","file":"/home/runner/work/polytypo-js/polytypo-js/dist/chunk-W52W6XGA.cjs","sourcesContent":[null,"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"]}

package/dist/{chunk-R2AZYV4E.cjs → chunk-WQEB33J2.cjs}

@@ -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,6 +5838,320 @@ 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))
+  );
+}
+
+
+
 
 
 
@@ -5846,5 +6167,5 @@ function runRulesRecording(cp, planned, locale, mode, narrowTarget, origin, inpu
 
 
 
-exports.PolytypoError = PolytypoError; exports.toCodePoints = toCodePoints; exports.fromCodePoints = fromCodePoints; exports.getLocaleData = getLocaleData; exports.resolveNarrowTarget = resolveNarrowTarget; exports.MARKER = MARKER; exports.LINE_MARKER = LINE_MARKER; exports.isMarker = isMarker; exports.RULES = RULES; exports.applyEdits = applyEdits; exports.NO_ORIGIN = NO_ORIGIN; exports.planRules = planRules; exports.runRules = runRules; exports.runRulesRecording = runRulesRecording;
-//# sourceMappingURL=chunk-R2AZYV4E.cjs.map
+exports.PolytypoError = PolytypoError; exports.toCodePoints = toCodePoints; exports.fromCodePoints = fromCodePoints; exports.getLocaleData = getLocaleData; exports.resolveNarrowTarget = resolveNarrowTarget; exports.planRules = planRules; exports.runRules = runRules; exports.runRulesRecording = runRulesRecording; exports.runOverSpans = runOverSpans; exports.runOverUnits = runOverUnits; exports.analyzeOverUnits = analyzeOverUnits; exports.analyzeOverSpans = analyzeOverSpans; exports.resolveProtect = resolveProtect; exports.assertNoProtect = assertNoProtect; exports.runProtected = runProtected; exports.analyzeProtected = analyzeProtected;
+//# sourceMappingURL=chunk-WQEB33J2.cjs.map