@readme/markdown 14.2.4 → 14.2.6

package/dist/processor/transform/mdxish/tables/normalize-tag-spacing.d.ts

@@ -0,0 +1,20 @@
+import { type RepairResult } from './utils';
+/**
+ * mdxjs's micromark extension fails when a JSX element's opener-line and
+ * closer-line don't match in "is the tag alone on its line?" Concretely:
+ *
+ *   <span>X\n</span>           ❌  opener-line has text, closer-line is bare
+ *   <span>\nX</span>           ❌  opener-line is bare, closer-line has text
+ *   text <span>X\n</span>      ❌  opener-line has leading + trailing text
+ *   <span>\nX\n</span> text    ❌  closer-line has trailing text
+ *   <span>X\nY</span>          ✅  both lines have adjacent text
+ *   <span>\nX\n</span>         ✅  both lines are bare
+ *   <span>X</span>             ✅  same line
+ *
+ * When the two lines disagree, mdxjs throws "Expected a closing tag…before
+ * the end of `paragraph`" (or its mirror). This pass detects asymmetric
+ * pairs and inserts newlines (+ matching indent) to push the offending side's
+ * non-tag content to a separate line, restoring symmetry. Scoped to the
+ * malformed-retry path; the happy path doesn't touch this.
+ */
+export declare const normalizeTagSpacing: (html: string) => RepairResult;

package/dist/processor/transform/mdxish/tables/remap-positions.d.ts

@@ -0,0 +1,9 @@
+import type { Insert } from './utils';
+import type { Node } from 'mdast';
+/**
+ * Walk `tree`, translating every node's position from the repaired source's
+ * coordinate space back to the original source. Offsets are remapped via the
+ * insert list; line/column are recomputed from the original source so they
+ * remain accurate even if repairs introduced newlines.
+ */
+export declare const remapPositionsToOriginal: (tree: Node, originalSource: string, inserts: Insert[]) => void;

package/dist/processor/transform/mdxish/tables/repair-unclosed-tags.d.ts

@@ -0,0 +1,11 @@
+import { type RepairResult } from './utils';
+/**
+ * Rewrites `html` so every open tag has a matching close. Returns the input
+ * unchanged when nothing needed repair, so callers can cheaply detect no-ops.
+ *
+ * Detection runs through htmlparser2: any close event flagged `implicit` is
+ * a tag the user opened but didn't explicitly close. We pair it with the
+ * matching opener (popped from a stack we maintain) and insert `</name>` at
+ * the end of the opener's line, or at the trigger if they're on the same line.
+ */
+export declare const repairUnclosedTags: (html: string) => RepairResult;

package/dist/processor/transform/mdxish/tables/tag-walker.d.ts

@@ -0,0 +1,19 @@
+interface TagEvent {
+    end: number;
+    name: string;
+    start: number;
+}
+interface CloseEvent extends TagEvent {
+    implicit: boolean;
+}
+interface TagWalkHandlers {
+    onClose?: (event: CloseEvent) => void;
+    onOpen?: (event: TagEvent) => void;
+}
+/**
+ * Drive htmlparser2 over `html` (after masking non-tag regions) and emit
+ * tag-balance events. `start`/`end` use the original-string offsets, so
+ * callers can splice against the input directly.
+ */
+export declare const walkTags: (html: string, handlers: TagWalkHandlers) => void;
+export {};

package/dist/processor/transform/mdxish/tables/utils.d.ts

@@ -1,4 +1,12 @@
 import type { Node } from 'mdast';
+export interface Insert {
+    offset: number;
+    text: string;
+}
+export interface RepairResult {
+    inserts: Insert[];
+    value: string;
+}
 export declare const tableTags: Set<string>;
 /**
  * If the cell has exactly one paragraph child, unwrap it so its inline children sit
@@ -8,3 +16,9 @@ export declare const tableTags: Set<string>;
  * of content that need to be preserved for JSX `<Table>` serialization.
  */
 export declare const unwrapSoleParagraph: (children: Node[]) => Node[];
+/**
+ * Splice each text into `html` at its offset. Inserts at the same offset
+ * are emitted in their input order (a stable sort by offset), so callers can
+ * rely on innermost-first ordering by emitting events in stack-unwind order.
+ */
+export declare const applyInserts: (html: string, inserts: Insert[]) => RepairResult;

package/dist/utils/common-html-words.d.ts

@@ -21,3 +21,9 @@ export declare const RUNTIME_COMPONENT_TAGS: Set<string>;
  * Uses the html-tags package, converted to a Set<string> for efficient lookups.
  */
 export declare const STANDARD_HTML_TAGS: Set<string>;
+/**
+ * HTML void elements — elements that have no closing tag and no children.
+ *
+ * @see https://html.spec.whatwg.org/multipage/syntax.html#void-elements
+ */
+export declare const HTML_VOID_ELEMENTS: Set<string>;

package/package.json

@@ -2,7 +2,7 @@
   "name": "@readme/markdown",
   "description": "ReadMe's React-based Markdown parser",
   "author": "Rafe Goldberg <rafe@readme.io>",
-  "version": "14.2.4",
+  "version": "14.2.6",
   "main": "dist/main.node.js",
   "types": "dist/index.d.ts",
   "browser": "dist/main.js",
@@ -42,6 +42,7 @@
     "hast-util-sanitize": "^4.0.0",
     "hastscript": "^9.0.0",
     "html-tags": "^5.1.0",
+    "htmlparser2": "^12.0.0",
     "lodash.escape": "^4.0.1",
     "lodash.kebabcase": "^4.1.1",
     "mdast-util-find-and-replace": "^3.0.1",
@@ -171,7 +172,7 @@
       },
       {
         "path": "dist/main.node.js",
-        "maxSize": "875KB"
+        "maxSize": "920KB"
       }
     ]
   },