punctilio 5.4.9 → 5.5.0

package/src/remark.ts

@@ -1,12 +1,14 @@
-import type { PhrasingContent, Root, Text } from "mdast"
+import type { Link, PhrasingContent, Root, Text } from "mdast"
 import type { Transformer } from "unified"
 
+import { type Token, Tokenizer } from "parse5"
 import { visitParents } from "unist-util-visit-parents"
 
 import { transformView } from "./index.js"
 import { TRANSFORM_OPTION_KEYS, type TransformOptions } from "./transform-options.js"
 import { MAX_RECURSION_DEPTH } from "./constants.js"
-import { buildProseView, splitAtIndices } from "./prose-view.js"
+import { runAcrossOpaqueGaps } from "./prose-view.js"
+import { DEFAULT_SKIP_TAGS, RAW_TEXT_FORM_TAG } from "./rehype.js"
 import { assertKnownOptionKeys } from "./utils.js"
 
 /**
@@ -20,6 +22,8 @@ const PHRASING_CONTAINERS = new Set(["paragraph", "heading", "tableCell"])
 
 const SKIP_TYPES = new Set(["inlineCode", "html"])
 
+const SKIPPED_HTML_TAGS: ReadonlySet<string> = new Set([...DEFAULT_SKIP_TAGS, RAW_TEXT_FORM_TAG])
+
 // Leaf phrasing nodes that render atomic content and carry no transformable
 // text. Between two text nodes, one is a real visual separator, so the
 // flattener records an opaque gap there (mirroring skipped `inlineCode`/`html`).
@@ -33,6 +37,67 @@ interface ProseCollector {
   // An opaque node was dropped since the last emitted text node; the next
   // emitted node records an opaque gap before it.
   pendingOpaque: boolean
+  // Raw-HTML skip-list tags opened and not yet closed; everything between an
+  // open tag and its close tag is skipped content.
+  openSkippedTags: string[]
+  // Markdown source the tree was parsed from; link positions index into it.
+  source: string
+}
+
+const URL_SCHEMES = ["mailto:", "https://", "http://"]
+
+/** `url` without a leading `mailto:`, `https://` or `http://`, in any letter case. */
+function stripUrlScheme(url: string): string {
+  const lowerCaseUrl = url.toLowerCase()
+  const scheme = URL_SCHEMES.find((candidate) => lowerCaseUrl.startsWith(candidate))
+  return scheme === undefined ? url : url.slice(scheme.length)
+}
+
+/** The Markdown source that produced `node`, or "" when it carries no usable position. */
+function sourceOfLink(node: Link, source: string): string {
+  const start = node.position?.start.offset
+  const end = node.position?.end.offset
+  return start === undefined || end === undefined ? "" : source.slice(start, end)
+}
+
+/**
+ * True for an autolink or bare URL, whose visible text is the URL itself. A
+ * link not written as `[text](url)` (an `<…>` autolink or a GFM literal) is one
+ * by construction; a bracketed link is one when its text is its URL, with or
+ * without the scheme.
+ */
+function isUrlTextLink(node: Link, source: string): boolean {
+  const linkSource = sourceOfLink(node, source)
+  if (linkSource !== "" && !linkSource.startsWith("[")) return true
+  if (node.children.length !== 1 || node.children[0].type !== "text") return false
+  return stripUrlScheme(node.children[0].value) === stripUrlScheme(node.url)
+}
+
+const ignoreToken = (): void => {}
+
+/** Tracks raw-HTML skip-list tags so the text between an open and close tag is skipped. */
+function trackSkippedHtmlTags(html: string, c: ProseCollector): void {
+  const openTag = (token: Token.TagToken): void => {
+    if (!token.selfClosing && SKIPPED_HTML_TAGS.has(token.tagName)) c.openSkippedTags.push(token.tagName)
+  }
+  const closeTag = (token: Token.TagToken): void => {
+    const openIndex = c.openSkippedTags.lastIndexOf(token.tagName)
+    if (openIndex !== -1) c.openSkippedTags.length = openIndex
+  }
+  const tokenizer = new Tokenizer(
+    { sourceCodeLocationInfo: false },
+    {
+      onComment: ignoreToken,
+      onDoctype: ignoreToken,
+      onStartTag: openTag,
+      onEndTag: closeTag,
+      onEof: ignoreToken,
+      onCharacter: ignoreToken,
+      onNullCharacter: ignoreToken,
+      onWhitespaceCharacter: ignoreToken,
+    }
+  )
+  tokenizer.write(html, true)
 }
 
 function collectProse(node: PhrasingContent, depth: number, c: ProseCollector): void {
@@ -41,7 +106,14 @@ function collectProse(node: PhrasingContent, depth: number, c: ProseCollector):
     return
   }
 
-  if (SKIP_TYPES.has(node.type) || OPAQUE_LEAF_TYPES.has(node.type)) {
+  if (node.type === "html") trackSkippedHtmlTags(node.value, c)
+
+  if (
+    SKIP_TYPES.has(node.type) ||
+    OPAQUE_LEAF_TYPES.has(node.type) ||
+    c.openSkippedTags.length > 0 ||
+    (node.type === "link" && isUrlTextLink(node, c.source))
+  ) {
     c.pendingOpaque = true
     return
   }
@@ -58,8 +130,8 @@ function collectProse(node: PhrasingContent, depth: number, c: ProseCollector):
   }
 }
 
-function flattenProse(children: readonly PhrasingContent[]): { nodes: Text[]; opaqueBefore: Set<number> } {
-  const c: ProseCollector = { nodes: [], opaqueBefore: new Set(), pendingOpaque: false }
+function flattenProse(children: readonly PhrasingContent[], source: string): { nodes: Text[]; opaqueBefore: Set<number> } {
+  const c: ProseCollector = { nodes: [], opaqueBefore: new Set(), pendingOpaque: false, openSkippedTags: [], source }
   for (const child of children) collectProse(child, 0, c)
   return { nodes: c.nodes, opaqueBefore: c.opaqueBefore }
 }
@@ -77,7 +149,10 @@ export function remarkPunctilio(
     nbsp: options.nbsp ?? false,
   }
 
-  return (tree: Root) => {
+  // `file` is absent when the transformer is called with a bare tree (the
+  // Prettier plugin); links are then judged by their text alone.
+  return (tree: Root, file?: { toString(): string }) => {
+    const source = file?.toString() ?? ""
     visitParents(tree, (node, ancestors) => {
       if (!PHRASING_CONTAINERS.has(node.type)) {
         return
@@ -93,13 +168,11 @@ export function remarkPunctilio(
         return
       }
 
-      const { nodes, opaqueBefore } = flattenProse(node.children as PhrasingContent[])
+      const { nodes, opaqueBefore } = flattenProse(node.children as PhrasingContent[], source)
 
-      // Split at opaque gaps (inline code, images, breaks) so no pass rewrites
-      // text as adjacent across content that visually separates it.
-      for (const group of splitAtIndices(nodes, opaqueBefore)) {
-        transformView(buildProseView(group), pluginOptions)
-      }
+      // Opaque gaps (inline code, images, breaks) become placeholders, so
+      // quotes pair across them while no pass rewrites text through them.
+      runAcrossOpaqueGaps(nodes, opaqueBefore, (view) => transformView(view, pluginOptions))
     })
   }
 }

package/src/symbols.ts

@@ -147,10 +147,14 @@ const DIGIT_SUFFIX = `(?:${PRIME_ALT}|${UNIT_ALT})?`
 // (1e5x3 — the `e` is a letter) and model SKUs (Surface5x3, RTX3060x2);
 // signed exponents (1e-5x3, 3.5E+10x2) are unambiguously scientific, their
 // operand is preceded by a sign, and they convert.
-const MULTIPLICATION_CHAIN = `(?<firstNum>\\d+${DIGIT_SUFFIX})(?<rest>(?:\\s*[xX*]\\s*\\d+${DIGIT_SUFFIX})+)`
-const MULTIPLICATION_SEGMENT = `(?<spaceBefore>\\s*)[xX*](?<spaceAfter>\\s*)(?<num>\\d+${DIGIT_SUFFIX})`
+//
+// Operator spacing is horizontal whitespace only: an operator across a line
+// break is a list marker (`Step 1\n* 2 cups`), not multiplication.
+const OPERATOR_SPACE = "[^\\S\\n\\v\\f\\r\\u2028\\u2029]*"
+const MULTIPLICATION_CHAIN = `(?<firstNum>\\d+${DIGIT_SUFFIX})(?<rest>(?:${OPERATOR_SPACE}[xX*]${OPERATOR_SPACE}\\d+${DIGIT_SUFFIX})+)`
+const MULTIPLICATION_SEGMENT = `(?<spaceBefore>${OPERATOR_SPACE})[xX*](?<spaceAfter>${OPERATOR_SPACE})(?<num>\\d+${DIGIT_SUFFIX})`
 
-/** A `\s*[xX*]\s*\d+suffix` segment located by absolute clean-text offsets. */
+/** An `OPERATOR_SPACE [xX*] OPERATOR_SPACE \d+suffix` segment located by absolute clean-text offsets. */
 interface ChainSegment {
   /** Absolute offset of the operator character. */
   operatorOffset: number
@@ -183,7 +187,7 @@ function chainSegments(chainStart: number, firstNum: string, rest: string): Chai
 }
 
 /**
- * Each operator's spacing slot (`\s*[xX*]\s*`) tolerates one node boundary at
+ * Each operator's spacing slot (`OPERATOR_SPACE [xX*] OPERATOR_SPACE`) tolerates one node boundary at
  * each outer edge and none inside the spacing; a second adjacent boundary at an
  * edge breaks the segment. The operator's slot is the span [slotStart, slotEnd)
  * covering its surrounding spaces and the operator itself.

package/src/transform-options.ts

@@ -35,8 +35,9 @@ export interface TransformOptions {
    *   (U+201E/U+201C double, U+201A/U+2018 single). Punctuation outside quotes.
    * - `"french"`: French style. Uses guillemets with NNBSP padding: «\u202F...\u202F»
    *   Single quotes remain as curly quotes. Punctuation outside quotes.
-   * - `"none"`: Skip all quote and punctuation transforms entirely.
-   *   Straight quotes, apostrophes, and prime marks are left unmodified.
+   * - `"none"`: Skip quote classification and prime conversion. Straight
+   *   quotes, apostrophes, and prime marks are left unmodified; a U+02BC
+   *   modifier-letter apostrophe is still normalized to U+2019.
    *
    * Default: "american"
    */
@@ -121,6 +122,14 @@ export type ResolvedTransformOptions = Required<TransformOptions>
 
 /** Validates `options` and fills in the defaults. */
 export function resolveTransformOptions(options: TransformOptions): ResolvedTransformOptions {
+  // JS callers outside the type system can pass null, a string, or an array;
+  // `Object.keys` would otherwise throw an opaque TypeError or enumerate a
+  // string's indices as unknown option names.
+  if (options === null || typeof options !== "object" || Array.isArray(options)) {
+    throw new TypeError(
+      `transform options must be an object, got ${options === null ? "null" : Array.isArray(options) ? "an array" : typeof options}.`
+    )
+  }
   assertKnownOptionKeys(options, TRANSFORM_OPTION_KEYS, "transform")
 
   const punctuationStyle = options.punctuationStyle ?? "american"