rehype-grouping-figure 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Ari Palo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,202 @@
+# rehype-grouping-figure
+
+**rehype** plugin that groups one or more images into a `<figure>` when they are immediately followed by a `<blockquote>`, turning that blockquote into a `<figcaption>`.
+
+## Contents
+
+- What is this?
+- When should I use this?
+- Install
+- Use
+- API
+  - `unified().use(rehypeGroupingFigure[, options])`
+- Examples
+- Types
+- Compatibility
+- Security
+- License
+
+## What is this?
+
+This is a unified (rehype) plugin.
+
+It walks the hast tree and looks for this pattern:
+
+1. A paragraph (`<p>`) that contains only image elements (`<img>`) and optional whitespace text nodes
+2. Immediately followed by a blockquote (`<blockquote>`) (whitespace text nodes between them are ignored)
+
+When found, it rewrites both nodes into:
+
+- `<figure class="group">`
+- all matched `<img>` elements inside the figure
+- `<figcaption>` containing the original blockquote children
+
+## When should I use this?
+
+Use this plugin when your markdown/HTML authoring style places captions in blockquotes after image-only paragraphs, and you want semantic figure markup in output HTML.
+
+You probably **shouldn't** use it if:
+
+- your captions are not represented as blockquotes
+- you need configurable class names or matching rules (the current API is intentionally minimal)
+
+## Install
+
+This package is ESM only. In Node.js (version 20.19+):
+
+```sh
+npm install rehype-grouping-figure
+```
+
+```sh
+pnpm add rehype-grouping-figure
+```
+
+## Use
+
+Say we have the following markdown:
+
+```md
+![A beautiful cat](./cat.jpg)
+
+> This is a caption for the cat image
+```
+
+...and a script `example.js`:
+
+```js
+import {unified} from 'unified'
+import remarkParse from 'remark-parse'
+import remarkRehype from 'remark-rehype'
+import rehypeStringify from 'rehype-stringify'
+import rehypeGroupingFigure from 'rehype-grouping-figure'
+
+const file = await unified()
+  .use(remarkParse)
+  .use(remarkRehype)
+  .use(rehypeGroupingFigure)
+  .use(rehypeStringify)
+  .process('![A beautiful cat](./cat.jpg)\n\n> This is a caption for the cat image')
+
+console.log(String(file))
+```
+
+...running `node example.js` yields:
+
+```html
+<figure class="group"><img src="./cat.jpg" alt="A beautiful cat"><figcaption><p>This is a caption for the cat image</p></figcaption></figure>
+```
+
+## API
+
+This package exports:
+
+- the default identifier `rehypeGroupingFigure`
+- the named schema export `rehypeGroupingFigureSanitizeSchema`
+- the TypeScript type `Options`
+
+### `unified().use(rehypeGroupingFigure[, options])`
+
+Groups image-only paragraphs followed by blockquotes into figure/figcaption markup.
+
+###### Parameters
+
+- `options` (`Options`, optional) — currently empty; reserved for future configuration
+
+###### Returns
+
+Transformer function.
+
+### `rehypeGroupingFigureSanitizeSchema`
+
+Schema extension object for `rehype-sanitize` so generated `figure` / `figcaption` markup and `figure.group` are allowed.
+
+## Examples
+
+### Two images + caption
+
+Input:
+
+```md
+![A beautiful cat](./cat.jpg)
+![A playful dog](./dog.jpg)
+
+> These are our beloved pets
+```
+
+Output:
+
+```html
+<figure class="group">
+  <img src="./cat.jpg" alt="A beautiful cat">
+  <img src="./dog.jpg" alt="A playful dog">
+  <figcaption>
+    <p>These are our beloved pets</p>
+  </figcaption>
+</figure>
+```
+
+### Multi-paragraph captions are preserved
+
+Input:
+
+```md
+![Nature scene](./nature.jpg)
+
+> This is a multi-line caption.
+>
+> It spans multiple paragraphs and provides
+> detailed information about the image.
+>
+> **Bold text** and *italic text* are also supported.
+```
+
+Output `figcaption` keeps all blockquote content structure.
+
+### Not grouped when content appears in between
+
+If any non-whitespace content appears between the image paragraph and blockquote, no grouping happens.
+
+## Types
+
+This package is fully typed with TypeScript.
+
+## Compatibility
+
+- Node.js 20.19+
+- `unified` 11+
+
+## Security
+
+This plugin only reshapes existing HTML structure (`p` + `img` + `blockquote` -> `figure` + `figcaption`) and does not fetch external data or execute code.
+
+If you sanitize downstream with `rehype-sanitize`, merge in the exported schema:
+
+```js
+import rehypeSanitize, {defaultSchema} from 'rehype-sanitize'
+import rehypeGroupingFigure, {
+  rehypeGroupingFigureSanitizeSchema
+} from 'rehype-grouping-figure'
+
+unified()
+  .use(rehypeGroupingFigure)
+  .use(rehypeSanitize, {
+    ...defaultSchema,
+    tagNames: [
+      ...(defaultSchema.tagNames || []),
+      ...rehypeGroupingFigureSanitizeSchema.tagNames
+    ],
+    attributes: {
+      ...defaultSchema.attributes,
+      ...rehypeGroupingFigureSanitizeSchema.attributes
+    },
+    ancestors: {
+      ...defaultSchema.ancestors,
+      ...rehypeGroupingFigureSanitizeSchema.ancestors
+    }
+  })
+```
+
+## License
+
+MIT © Ari Palo

package/dist/index.d.ts

@@ -0,0 +1,325 @@
+//#region node_modules/.pnpm/@types+unist@3.0.3/node_modules/@types/unist/index.d.ts
+// ## Interfaces
+/**
+ * Info associated with nodes by the ecosystem.
+ *
+ * This space is guaranteed to never be specified by unist or specifications
+ * implementing unist.
+ * But you can use it in utilities and plugins to store data.
+ *
+ * This type can be augmented to register custom data.
+ * For example:
+ *
+ * ```ts
+ * declare module 'unist' {
+ *   interface Data {
+ *     // `someNode.data.myId` is typed as `number | undefined`
+ *     myId?: number | undefined
+ *   }
+ * }
+ * ```
+ */
+interface Data$1 {}
+/**
+ * One place in a source file.
+ */
+interface Point {
+  /**
+   * Line in a source file (1-indexed integer).
+   */
+  line: number;
+  /**
+   * Column in a source file (1-indexed integer).
+   */
+  column: number;
+  /**
+   * Character in a source file (0-indexed integer).
+   */
+  offset?: number | undefined;
+}
+/**
+ * Position of a node in a source document.
+ *
+ * A position is a range between two points.
+ */
+interface Position {
+  /**
+   * Place of the first character of the parsed source region.
+   */
+  start: Point;
+  /**
+   * Place of the first character after the parsed source region.
+   */
+  end: Point;
+}
+/**
+ * Abstract unist node.
+ *
+ * The syntactic unit in unist syntax trees are called nodes.
+ *
+ * This interface is supposed to be extended.
+ * If you can use {@link Literal} or {@link Parent}, you should.
+ * But for example in markdown, a `thematicBreak` (`***`), is neither literal
+ * nor parent, but still a node.
+ */
+interface Node$1 {
+  /**
+   * Node type.
+   */
+  type: string;
+  /**
+   * Info from the ecosystem.
+   */
+  data?: Data$1 | undefined;
+  /**
+   * Position of a node in a source document.
+   *
+   * Nodes that are generated (not in the original source document) must not
+   * have a position.
+   */
+  position?: Position | undefined;
+}
+//#endregion
+//#region node_modules/.pnpm/@types+hast@3.0.4/node_modules/@types/hast/index.d.ts
+// ## Interfaces
+/**
+ * Info associated with hast nodes by the ecosystem.
+ *
+ * This space is guaranteed to never be specified by unist or hast.
+ * But you can use it in utilities and plugins to store data.
+ *
+ * This type can be augmented to register custom data.
+ * For example:
+ *
+ * ```ts
+ * declare module 'hast' {
+ *   interface Data {
+ *     // `someNode.data.myId` is typed as `number | undefined`
+ *     myId?: number | undefined
+ *   }
+ * }
+ * ```
+ */
+interface Data extends Data$1 {}
+/**
+ * Info associated with an element.
+ */
+interface Properties {
+  [PropertyName: string]: boolean | number | string | null | undefined | Array<string | number>;
+}
+// ## Content maps
+/**
+ * Union of registered hast nodes that can occur in {@link Element}.
+ *
+ * To register mote custom hast nodes, add them to {@link ElementContentMap}.
+ * They will be automatically added here.
+ */
+type ElementContent = ElementContentMap[keyof ElementContentMap];
+/**
+ * Registry of all hast nodes that can occur as children of {@link Element}.
+ *
+ * For a union of all {@link Element} children, see {@link ElementContent}.
+ */
+interface ElementContentMap {
+  comment: Comment;
+  element: Element;
+  text: Text;
+}
+/**
+ * Union of registered hast nodes that can occur in {@link Root}.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap}.
+ * They will be automatically added here.
+ */
+type RootContent = RootContentMap[keyof RootContentMap];
+/**
+ * Registry of all hast nodes that can occur as children of {@link Root}.
+ *
+ * > 👉 **Note**: {@link Root} does not need to be an entire document.
+ * > it can also be a fragment.
+ *
+ * For a union of all {@link Root} children, see {@link RootContent}.
+ */
+interface RootContentMap {
+  comment: Comment;
+  doctype: Doctype;
+  element: Element;
+  text: Text;
+}
+// ## Abstract nodes
+/**
+ * Abstract hast node.
+ *
+ * This interface is supposed to be extended.
+ * If you can use {@link Literal} or {@link Parent}, you should.
+ * But for example in HTML, a `Doctype` is neither literal nor parent, but
+ * still a node.
+ *
+ * To register custom hast nodes, add them to {@link RootContentMap} and other
+ * places where relevant (such as {@link ElementContentMap}).
+ *
+ * For a union of all registered hast nodes, see {@link Nodes}.
+ */
+interface Node extends Node$1 {
+  /**
+   * Info from the ecosystem.
+   */
+  data?: Data | undefined;
+}
+/**
+ * Abstract hast node that contains the smallest possible value.
+ *
+ * This interface is supposed to be extended if you make custom hast nodes.
+ *
+ * For a union of all registered hast literals, see {@link Literals}.
+ */
+interface Literal extends Node {
+  /**
+   * Plain-text value.
+   */
+  value: string;
+}
+/**
+ * Abstract hast node that contains other hast nodes (*children*).
+ *
+ * This interface is supposed to be extended if you make custom hast nodes.
+ *
+ * For a union of all registered hast parents, see {@link Parents}.
+ */
+interface Parent extends Node {
+  /**
+   * List of children.
+   */
+  children: RootContent[];
+}
+// ## Concrete nodes
+/**
+ * HTML comment.
+ */
+interface Comment extends Literal {
+  /**
+   * Node type of HTML comments in hast.
+   */
+  type: "comment";
+  /**
+   * Data associated with the comment.
+   */
+  data?: CommentData | undefined;
+}
+/**
+ * Info associated with hast comments by the ecosystem.
+ */
+interface CommentData extends Data {}
+/**
+ * HTML document type.
+ */
+interface Doctype extends Node$1 {
+  /**
+   * Node type of HTML document types in hast.
+   */
+  type: "doctype";
+  /**
+   * Data associated with the doctype.
+   */
+  data?: DoctypeData | undefined;
+}
+/**
+ * Info associated with hast doctypes by the ecosystem.
+ */
+interface DoctypeData extends Data {}
+/**
+ * HTML element.
+ */
+interface Element extends Parent {
+  /**
+   * Node type of elements.
+   */
+  type: "element";
+  /**
+   * Tag name (such as `'body'`) of the element.
+   */
+  tagName: string;
+  /**
+   * Info associated with the element.
+   */
+  properties: Properties;
+  /**
+   * Children of element.
+   */
+  children: ElementContent[];
+  /**
+   * When the `tagName` field is `'template'`, a `content` field can be
+   * present.
+   */
+  content?: Root | undefined;
+  /**
+   * Data associated with the element.
+   */
+  data?: ElementData | undefined;
+}
+/**
+ * Info associated with hast elements by the ecosystem.
+ */
+interface ElementData extends Data {}
+/**
+ * Document fragment or a whole document.
+ *
+ * Should be used as the root of a tree and must not be used as a child.
+ *
+ * Can also be used as the value for the content field on a `'template'` element.
+ */
+interface Root extends Parent {
+  /**
+   * Node type of hast root.
+   */
+  type: "root";
+  /**
+   * Children of root.
+   */
+  children: RootContent[];
+  /**
+   * Data associated with the hast root.
+   */
+  data?: RootData | undefined;
+}
+/**
+ * Info associated with hast root nodes by the ecosystem.
+ */
+interface RootData extends Data {}
+/**
+ * HTML character data (plain text).
+ */
+interface Text extends Literal {
+  /**
+   * Node type of HTML character data (plain text) in hast.
+   */
+  type: "text";
+  /**
+   * Data associated with the text.
+   */
+  data?: TextData | undefined;
+}
+/**
+ * Info associated with hast texts by the ecosystem.
+ */
+interface TextData extends Data {}
+//#endregion
+//#region src/index.d.ts
+interface Options {}
+/**
+ * Schema extension for `rehype-sanitize` so output from this plugin is preserved.
+ * Compatible with https://github.com/syntax-tree/hast-util-sanitize
+ */
+declare const rehypeGroupingFigureSanitizeSchema: {
+  readonly ancestors: {
+    readonly figcaption: ["figure"];
+  };
+  readonly attributes: {
+    readonly figure: [["className", "group"]];
+  };
+  readonly tagNames: ["figure", "figcaption"];
+};
+declare function rehypeGroupingFigure(_options?: Options): (tree: Root) => void;
+//#endregion
+export { Options, rehypeGroupingFigure as default, rehypeGroupingFigureSanitizeSchema };
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","names":["Data","Point","line","column","offset","Position","start","end","Literal","Node","value","type","data","position","Parent","children","Data","UnistData","Literal","UnistLiteral","Node","UnistNode","Parent","UnistParent","Properties","Array","PropertyName","ElementContent","ElementContentMap","Comment","Element","Text","comment","element","text","RootContent","RootContentMap","Doctype","doctype","Content","Literals","Nodes","Extract","Root","Parents","data","value","children","CommentData","type","DoctypeData","ElementData","tagName","properties","content","RootData","TextData"],"sources":["../node_modules/.pnpm/@types+unist@3.0.3/node_modules/@types/unist/index.d.ts","../node_modules/.pnpm/@types+hast@3.0.4/node_modules/@types/hast/index.d.ts","../src/index.ts"],"x_google_ignoreList":[0,1],"mappings":";;;;;;AA0BA;;;;;;;;;AAqBA;;;;;;UA1BiBA,MAAAA;;;AAgEjB;UA3DiBC,KAAAA;;;;EAIbC,IAAAA;EAwEAW;;;EAnEAV,MAAAA;;;;EAIAC,MAAAA;AAAAA;;;ACZJ;;;UDoBiBC,QAAAA;ECnB+D;AAWhF;;EDYIC,KAAAA,EAAOL,KAAAA;ECZ2D;AAOtE;;EDUIM,GAAAA,EAAKN,KAAAA;AAAAA;ACYT;;;;;;;;;;AAAA,UDiBiBQ,MAAAA;ECfb6B;;;EDmBA3B,IAAAA;ECjBMoB;;;EDsBNnB,IAAAA,GAAOZ,MAAAA;;;;;;;EAQPa,QAAAA,GAAWR,QAAAA;AAAAA;;;;;;AA5Ef;;;;;;;;;AAqBA;;;;;;;UCzBiBW,IAAAA,SAAaC,MAAAA;;AD+D9B;;UC1DiBO,UAAAA;EAAAA,CACZE,YAAAA,0DAAsED,KAAAA;AAAAA;AAAAA;;;;;;;KAW/DE,cAAAA,GAAiBC,iBAAAA,OAAwBA,iBAAAA;;;;AAZrD;;UAmBiBA,iBAAAA;EACbI,OAAAA,EAASH,OAAAA;EACTI,OAAAA,EAASH,OAAAA;EACTI,IAAAA,EAAMH,IAAAA;AAAAA;;;AAHV;;;;KAYYI,WAAAA,GAAcC,cAAAA,OAAqBA,cAAAA;;;;;;;;;UAU9BA,cAAAA;EACbJ,OAAAA,EAASH,OAAAA;EACTS,OAAAA,EAASD,OAAAA;EACTJ,OAAAA,EAASH,OAAAA;EACTI,IAAAA,EAAMH,IAAAA;AAAAA;AAAAA;;;;;AA8FV;;;;;;;;;UAxCiBX,IAAAA,SAAaC,MAAAA;EAsDb2B;;;EAlDbH,IAAAA,GAAO7B,IAAAA;AAAAA;;;;;;;;UAUME,OAAAA,SAAgBE,IAAAA;EAqDX;AAMtB;;EAvDI0B,KAAAA;AAAAA;AA4DJ;;;;;;;AAAA,UAlDiBxB,MAAAA,SAAeF,IAAAA;EAkDO;;;EA9CnC2B,QAAAA,EAAUZ,WAAAA;AAAAA;AAAAA;;;;UAQGN,OAAAA,SAAgBX,OAAAA;EA+DtBiC;;;EA3DPF,IAAAA;EAiEwB;;;EA7DxBJ,IAAAA,GAAOG,WAAAA;AAAAA;;;;UAMMA,WAAAA,SAAoBhC,IAAAA;;;;UAKpBqB,OAAAA,SAAgBhB,MAAAA;EAmEnBc;;;EA/DVc,IAAAA;EAmEe;AAMnB;;EArEIJ,IAAAA,GAAOK,WAAAA;AAAAA;AA0EX;;;AAAA,UApEiBA,WAAAA,SAAoBlC,IAAAA;;;;UAKpBc,OAAAA,SAAgBR,MAAAA;EAuEd;AAMnB;;EAzEI2B,IAAAA;EAyE8BjC;;;EArE9BoC,OAAAA;;ACjNJ;;EDqNIC,UAAAA,EAAY7B,UAAAA;ECrNQ;;AAMxB;EDmNIuB,QAAAA,EAAUpB,cAAAA;;;;;EAKV2B,OAAAA,GAAUX,IAAAA;;;;EAIVE,IAAAA,GAAOM,WAAAA;AAAAA;;;;UAMMA,WAAAA,SAAoBnC,IAAAA;;;;;;;;UASpB2B,IAAAA,SAAarB,MAAAA;;;;EAI1B2B,IAAAA;;;;EAIAF,QAAAA,EAAUZ,WAAAA;;;;EAIVU,IAAAA,GAAOU,QAAAA;AAAAA;;;;UAMMA,QAAAA,SAAiBvC,IAAAA;;;;UAKjBe,IAAAA,SAAab,OAAAA;;;;EAI1B+B,IAAAA;;;;EAIAJ,IAAAA,GAAOW,QAAAA;AAAAA;;;;UAMMA,QAAAA,SAAiBxC,IAAAA;;;UCtRjB,OAAA;;;;AFuBjB;cEjBa,kCAAA;EAAA;;;;;;;;iBAUW,oBAAA,CAAqB,QAAA,GAAU,OAAA,IAC7C,IAAA,EAAM,IAAA"}

package/dist/index.js

@@ -0,0 +1,60 @@
+//#region src/index.ts
+/**
+* Schema extension for `rehype-sanitize` so output from this plugin is preserved.
+* Compatible with https://github.com/syntax-tree/hast-util-sanitize
+*/
+const rehypeGroupingFigureSanitizeSchema = {
+	ancestors: { figcaption: ["figure"] },
+	attributes: { figure: [["className", "group"]] },
+	tagNames: ["figure", "figcaption"]
+};
+function rehypeGroupingFigure(_options = {}) {
+	return (tree) => {
+		processNode(tree);
+	};
+}
+function processNode(node) {
+	if (!node.children || !Array.isArray(node.children)) return;
+	const children = node.children;
+	const newChildren = [];
+	let i = 0;
+	while (i < children.length) {
+		const current = children[i];
+		if (current.type === "element" && current.tagName === "p") {
+			const images = current.children.filter((child) => child.type === "element" && child.tagName === "img");
+			const nonImageChildren = current.children.filter((child) => !(child.type === "element" && child.tagName === "img") && !(child.type === "text" && child.value.trim() === ""));
+			if (images.length > 0 && nonImageChildren.length === 0) {
+				let nextElementIndex = i + 1;
+				while (nextElementIndex < children.length && children[nextElementIndex].type === "text" && "value" in children[nextElementIndex] && children[nextElementIndex].value.trim() === "") nextElementIndex++;
+				if (nextElementIndex < children.length) {
+					const nextElement = children[nextElementIndex];
+					if (nextElement.type === "element" && nextElement.tagName === "blockquote") {
+						const figcaption = {
+							type: "element",
+							tagName: "figcaption",
+							properties: {},
+							children: nextElement.children
+						};
+						const figure = {
+							type: "element",
+							tagName: "figure",
+							properties: { className: "group" },
+							children: [...images, figcaption]
+						};
+						newChildren.push(figure);
+						i = nextElementIndex + 1;
+						continue;
+					}
+				}
+			}
+		}
+		if (current.type === "element") processNode(current);
+		newChildren.push(current);
+		i++;
+	}
+	node.children = newChildren;
+}
+//#endregion
+export { rehypeGroupingFigure as default, rehypeGroupingFigureSanitizeSchema };
+
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../src/index.ts"],"sourcesContent":["import type { Element, Root, RootContent, ElementContent } from 'hast';\nimport type { Schema } from \"hast-util-sanitize\";\n\nexport interface Options {}\n\n/**\n * Schema extension for `rehype-sanitize` so output from this plugin is preserved.\n * Compatible with https://github.com/syntax-tree/hast-util-sanitize\n */\nexport const rehypeGroupingFigureSanitizeSchema = {\n  ancestors: {\n    figcaption: ['figure'],\n  },\n  attributes: {\n    figure: [['className', 'group']],\n  },\n  tagNames: ['figure', 'figcaption'],\n} as const satisfies Schema;\n\nexport default function rehypeGroupingFigure(_options: Options = {}) {\n  return (tree: Root) => {\n    processNode(tree);\n  };\n}\n\nfunction processNode(node: Element | Root) {\n  if (!node.children || !Array.isArray(node.children)) {\n    return;\n  }\n\n  const children = node.children;\n  const newChildren: (RootContent | ElementContent)[] = [];\n  let i = 0;\n\n  while (i < children.length) {\n    const current = children[i];\n\n    // Check if current element is a paragraph containing images\n    if (current.type === 'element' && current.tagName === 'p') {\n      // Extract all image elements from the paragraph\n      const images = current.children.filter(child =>\n        child.type === 'element' && child.tagName === 'img'\n      ) as Element[];\n\n      // Check if this paragraph contains only images and whitespace/text\n      const nonImageChildren = current.children.filter(child =>\n        !(child.type === 'element' && child.tagName === 'img') &&\n        !(child.type === 'text' && child.value.trim() === '')\n      );\n\n      // If we have images and no other significant content\n      if (images.length > 0 && nonImageChildren.length === 0) {\n        // Check if the next element is a blockquote (skip text nodes)\n        let nextElementIndex = i + 1;\n\n        // Skip over text nodes that are just whitespace\n        while (nextElementIndex < children.length &&\n               children[nextElementIndex].type === 'text' &&\n               'value' in children[nextElementIndex] &&\n               (children[nextElementIndex] as any).value.trim() === '') {\n          nextElementIndex++;\n        }\n\n        if (nextElementIndex < children.length) {\n          const nextElement = children[nextElementIndex];\n\n          if (nextElement.type === 'element' && nextElement.tagName === 'blockquote') {\n            // Create figcaption from blockquote content\n            const figcaption: Element = {\n              type: 'element',\n              tagName: 'figcaption',\n              properties: {},\n              children: nextElement.children\n            };\n\n            // Create figure element\n            const figure: Element = {\n              type: 'element',\n              tagName: 'figure',\n              properties: {\n                className: 'group'\n              },\n              children: [\n                ...images,\n                figcaption\n              ]\n            };\n\n            newChildren.push(figure);\n\n            // Skip all the elements we've processed (including whitespace text nodes)\n            i = nextElementIndex + 1;\n            continue;\n          }\n        }\n      }\n    }\n\n    // If no pattern was found, recursively process child elements\n    if (current.type === 'element') {\n      processNode(current);\n    }\n\n    // Add the current element\n    newChildren.push(current);\n    i++;\n  }\n\n  node.children = newChildren as any;\n}\n"],"mappings":";;;;;AASA,MAAa,qCAAqC;CAChD,WAAW,EACT,YAAY,CAAC,SAAS,EACvB;CACD,YAAY,EACV,QAAQ,CAAC,CAAC,aAAa,QAAQ,CAAC,EACjC;CACD,UAAU,CAAC,UAAU,aAAa;CACnC;AAED,SAAwB,qBAAqB,WAAoB,EAAE,EAAE;AACnE,SAAQ,SAAe;AACrB,cAAY,KAAK;;;AAIrB,SAAS,YAAY,MAAsB;AACzC,KAAI,CAAC,KAAK,YAAY,CAAC,MAAM,QAAQ,KAAK,SAAS,CACjD;CAGF,MAAM,WAAW,KAAK;CACtB,MAAM,cAAgD,EAAE;CACxD,IAAI,IAAI;AAER,QAAO,IAAI,SAAS,QAAQ;EAC1B,MAAM,UAAU,SAAS;AAGzB,MAAI,QAAQ,SAAS,aAAa,QAAQ,YAAY,KAAK;GAEzD,MAAM,SAAS,QAAQ,SAAS,QAAO,UACrC,MAAM,SAAS,aAAa,MAAM,YAAY,MAC/C;GAGD,MAAM,mBAAmB,QAAQ,SAAS,QAAO,UAC/C,EAAE,MAAM,SAAS,aAAa,MAAM,YAAY,UAChD,EAAE,MAAM,SAAS,UAAU,MAAM,MAAM,MAAM,KAAK,IACnD;AAGD,OAAI,OAAO,SAAS,KAAK,iBAAiB,WAAW,GAAG;IAEtD,IAAI,mBAAmB,IAAI;AAG3B,WAAO,mBAAmB,SAAS,UAC5B,SAAS,kBAAkB,SAAS,UACpC,WAAW,SAAS,qBACnB,SAAS,kBAA0B,MAAM,MAAM,KAAK,GAC1D;AAGF,QAAI,mBAAmB,SAAS,QAAQ;KACtC,MAAM,cAAc,SAAS;AAE7B,SAAI,YAAY,SAAS,aAAa,YAAY,YAAY,cAAc;MAE1E,MAAM,aAAsB;OAC1B,MAAM;OACN,SAAS;OACT,YAAY,EAAE;OACd,UAAU,YAAY;OACvB;MAGD,MAAM,SAAkB;OACtB,MAAM;OACN,SAAS;OACT,YAAY,EACV,WAAW,SACZ;OACD,UAAU,CACR,GAAG,QACH,WACD;OACF;AAED,kBAAY,KAAK,OAAO;AAGxB,UAAI,mBAAmB;AACvB;;;;;AAOR,MAAI,QAAQ,SAAS,UACnB,aAAY,QAAQ;AAItB,cAAY,KAAK,QAAQ;AACzB;;AAGF,MAAK,WAAW"}

package/package.json

@@ -0,0 +1,78 @@
+{
+  "name": "rehype-grouping-figure",
+  "version": "0.1.0",
+  "description": "rehype plugin that groups images followed by blockquote into a figure and figcaption",
+  "license": "MIT",
+  "author": {
+    "name": "Ari Palo",
+    "email": "opensource@aripalo.com",
+    "url": "https://aripalo.technology"
+  },
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "engines": {
+    "node": ">=20.19.0"
+  },
+  "dependencies": {
+    "hast-util-sanitize": "^5.0.2",
+    "isomorphic-dompurify": "^2.36.0",
+    "unist-util-visit": "^5.1.0",
+    "vfile": "^6.0.3"
+  },
+  "peerDependencies": {
+    "unified": ">=11"
+  },
+  "devDependencies": {
+    "@types/hast": "^3.0.4",
+    "@types/node": "^22.0.0",
+    "@vitest/coverage-v8": "^4.1.4",
+    "rehype-format": "^5.0.1",
+    "rehype-stringify": "^10.0.1",
+    "remark-parse": "^11.0.0",
+    "remark-rehype": "^11.1.2",
+    "tsdown": "^0.21.9",
+    "typescript": "^5.6.0",
+    "unified": "^11.0.5",
+    "vitest": "^4.0.18"
+  },
+  "keywords": [
+    "rehype",
+    "rehype-plugin",
+    "unified",
+    "html",
+    "hast",
+    "figure",
+    "figcaption",
+    "grouping"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/aripalo/rehype-grouping-figure.git"
+  },
+  "bugs": {
+    "url": "https://github.com/aripalo/rehype-grouping-figure/issues",
+    "email": "opensource@aripalo.com"
+  },
+  "homepage": "https://github.com/aripalo/rehype-grouping-figure#readme",
+  "scripts": {
+    "build": "tsdown",
+    "typecheck": "tsc --noEmit -p tsconfig.json",
+    "test": "vitest run",
+    "test:watch": "vitest watch",
+    "test:coverage": "vitest run --coverage"
+  }
+}