@coywolf/emdash 0.0.0-stage → 0.35.14

package/src/wpImport/guests.ts

@@ -0,0 +1,329 @@
+/**
+ * Bylines WordPress showed that EmDash's importer doesn't carry over. The
+ * importer credits each post to its WordPress user (`dc:creator`) only, so it
+ * misses:
+ *
+ * - co-authors and guest authors from Co-Authors Plus and PublishPress
+ *   Authors. Both attach `author` taxonomy terms to the post
+ *   (`<category domain="author" nicename="…">`). Co-Authors Plus keeps guest
+ *   profiles as `guest-author` posts (meta cap-display_name, cap-user_login,
+ *   cap-website, cap-description, _thumbnail_id) and names a user's term
+ *   after their login (slug `cap-<login>`); PublishPress Authors keeps
+ *   profiles in term meta (user_url, description, avatar);
+ * - guests from the Coywolf Guest Author plugin, which stores one guest per
+ *   post in post meta (no users, no taxonomy) and overrides the byline:
+ *     _guest_author            name (an empty name means "no guest")
+ *     _guest_author_url        website (optional)
+ *     _guest_author_bio        biographical info (optional, may hold HTML)
+ *     _guest_author_avatar_id  attachment id of the avatar (optional)
+ *
+ * The WordPress import page reads them from the export (wxrGuestAuthors),
+ * groups them into bylines (groupGuests) and posts (postCredits), and credits
+ * each post through EmDash's own admin API (bylines are EmDash core data that
+ * plugins can only read).
+ *
+ * Pure, no imports: runs in the admin (browser), a Node script and tests.
+ */
+
+export interface GuestAuthor {
+	/** WordPress post id. */
+	postId: number | null;
+	postType: string;
+	/** The post's slug, which EmDash's importer keeps. */
+	slug: string;
+	title: string;
+	name: string;
+	url: string;
+	/** Plain text. */
+	bio: string;
+	avatarId: number | null;
+	avatarUrl: string;
+	/** Order among the post's authors (0 = first). */
+	position?: number;
+	/** Where it came from: the Coywolf Guest Author plugin, or author terms (Co-Authors Plus, PublishPress Authors). */
+	source?: "guest-author" | "co-authors";
+}
+
+const CDATA = /<!\[CDATA\[([\s\S]*?)\]\]>/g;
+
+function cdataText(body: string): string {
+	if (!body.includes("<![CDATA[")) return body.replace(/&lt;/g, "<").replace(/&gt;/g, ">").replace(/&quot;/g, '"').replace(/&#039;/g, "'").replace(/&amp;/g, "&");
+	let text = "";
+	for (const m of body.matchAll(CDATA)) text += m[1];
+	return text;
+}
+
+function tag(item: string, name: string): string | null {
+	const m = item.match(new RegExp(`<${name}>([\\s\\S]*?)</${name}>`));
+	return m ? cdataText(m[1] as string) : null;
+}
+
+/** An item's post meta (key → value; the first value wins). */
+export function itemMeta(item: string): Map<string, string> {
+	const meta = new Map<string, string>();
+	for (const m of item.matchAll(/<wp:postmeta>([\s\S]*?)<\/wp:postmeta>/g)) {
+		const key = tag(m[1] as string, "wp:meta_key");
+		const value = tag(m[1] as string, "wp:meta_value");
+		if (key !== null && value !== null && !meta.has(key)) meta.set(key, value);
+	}
+	return meta;
+}
+
+const ENTITIES: Record<string, string> = { amp: "&", lt: "<", gt: ">", quot: '"', apos: "'", nbsp: " ", rsquo: "’", lsquo: "‘", rdquo: "”", ldquo: "“", ndash: "–", mdash: "—", hellip: "…" };
+
+/** Bios as plain text (EmDash bylines hold plain text; the Coywolf plugin's schema helper strips tags too). */
+export function bioText(html: string): string {
+	return html
+		.replace(/<(script|style)\b[\s\S]*?<\/\1\s*>/gi, "")
+		.replace(/<br\s*\/?>|<\/p>/gi, "\n")
+		.replace(/<[^>]*>/g, "")
+		.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (whole, code: string) => {
+			if (code[0] !== "#") return ENTITIES[code.toLowerCase()] ?? whole;
+			const n = code[1] === "x" || code[1] === "X" ? Number.parseInt(code.slice(2), 16) : Number.parseInt(code.slice(1), 10);
+			return Number.isFinite(n) && n > 0 && n <= 0x10ffff ? String.fromCodePoint(n) : "";
+		})
+		.replace(/[ \t]+/g, " ")
+		.replace(/\s*\n\s*/g, "\n")
+		.trim();
+}
+
+interface AuthorProfile {
+	name: string;
+	url: string;
+	bio: string;
+	avatarId: number | null;
+	/** The WordPress user's login, when the author is a user. */
+	login: string;
+}
+
+const validUrl = (url: string) => (/^https?:\/\/\S+$/i.test(url.trim()) ? url.trim() : "");
+const attachmentId = (v: string | undefined) => {
+	const n = Number(v);
+	return Number.isInteger(n) && n > 0 ? n : null;
+};
+
+function decodeSlug(text: string): string {
+	try {
+		return decodeURIComponent(text);
+	} catch {
+		return text;
+	}
+}
+
+/** WordPress users in the export: login → display name. */
+function wxrUsers(xml: string): Map<string, string> {
+	const users = new Map<string, string>();
+	for (const m of xml.matchAll(/<wp:author>([\s\S]*?)<\/wp:author>/g)) {
+		const login = (tag(m[1] as string, "wp:author_login") ?? "").trim();
+		if (login) users.set(login, (tag(m[1] as string, "wp:author_display_name") ?? "").trim() || login);
+	}
+	return users;
+}
+
+/** Author profiles by term slug: Co-Authors Plus guest-author posts and PublishPress Authors terms. */
+function authorProfiles(xml: string, users: Map<string, string>): Map<string, AuthorProfile> {
+	const profiles = new Map<string, AuthorProfile>();
+	for (const m of xml.matchAll(/<item>([\s\S]*?)<\/item>/g)) {
+		const item = m[1] as string;
+		if ((tag(item, "wp:post_type") ?? "").trim() !== "guest-author") continue;
+		const meta = itemMeta(item);
+		const login = (meta.get("cap-user_login") ?? "").trim();
+		const profile: AuthorProfile = {
+			name: (meta.get("cap-display_name") ?? "").trim() || (tag(item, "title") ?? "").trim() || login,
+			url: validUrl(meta.get("cap-website") ?? ""),
+			bio: bioText(meta.get("cap-description") ?? ""),
+			avatarId: attachmentId(meta.get("_thumbnail_id")),
+			login: "",
+		};
+		if (!profile.name) continue;
+		const slug = decodeSlug((tag(item, "wp:post_name") ?? "").trim());
+		if (slug) profiles.set(slug, profile);
+		if (login) profiles.set(`cap-${login.toLowerCase()}`, profile);
+	}
+	for (const m of xml.matchAll(/<wp:term>([\s\S]*?)<\/wp:term>/g)) {
+		const term = m[1] as string;
+		if ((tag(term, "wp:term_taxonomy") ?? "").trim() !== "author") continue;
+		const slug = decodeSlug((tag(term, "wp:term_slug") ?? "").trim());
+		if (!slug || profiles.has(slug)) continue;
+		const meta = new Map<string, string>();
+		for (const tm of term.matchAll(/<wp:termmeta>([\s\S]*?)<\/wp:termmeta>/g)) {
+			const key = tag(tm[1] as string, "wp:meta_key");
+			const value = tag(tm[1] as string, "wp:meta_value");
+			if (key !== null && value !== null && !meta.has(key)) meta.set(key, value);
+		}
+		const name = (tag(term, "wp:term_name") ?? "").trim();
+		// Co-Authors Plus names a user's term after their login: show the user's display name.
+		const login = slug.startsWith("cap-") && users.has(name) ? name : "";
+		profiles.set(slug, {
+			name: login ? (users.get(login) as string) : name,
+			url: validUrl(meta.get("user_url") ?? ""),
+			bio: bioText(meta.get("description") ?? ""),
+			avatarId: attachmentId(meta.get("avatar")),
+			login,
+		});
+	}
+	return profiles;
+}
+
+const SKIP_TYPES = new Set(["attachment", "nav_menu_item", "revision", "guest-author", "wp_block"]);
+
+/**
+ * Every post whose byline isn't (only) its WordPress user, one record per
+ * post and author: the Coywolf Guest Author plugin's guest, or the post's
+ * author terms (Co-Authors Plus, PublishPress Authors) in export order. A post
+ * whose only author term is its own WordPress user is left out (the importer
+ * already credits it). `attachments` maps attachment ids to URLs (for avatars).
+ */
+export function wxrGuestAuthors(xml: string, attachments?: Map<number, string>): GuestAuthor[] {
+	const out: GuestAuthor[] = [];
+	const hasTerms = xml.includes('domain="author"');
+	const users = hasTerms ? wxrUsers(xml) : new Map<string, string>();
+	const profiles = hasTerms ? authorProfiles(xml, users) : new Map<string, AuthorProfile>();
+	const avatar = (id: number | null) => (id ? (attachments?.get(id) ?? "") : "");
+	for (const m of xml.matchAll(/<item>([\s\S]*?)<\/item>/g)) {
+		const item = m[1] as string;
+		const hasGuest = item.includes("_guest_author");
+		if (!hasGuest && !(hasTerms && item.includes('domain="author"'))) continue;
+		const postType = (tag(item, "wp:post_type") ?? "post").trim();
+		const status = (tag(item, "wp:status") ?? "").trim();
+		if (SKIP_TYPES.has(postType) || status === "trash" || status === "auto-draft") continue;
+		const post = {
+			postId: Number(tag(item, "wp:post_id")) || null,
+			postType,
+			slug: (tag(item, "wp:post_name") ?? "").trim(),
+			title: (tag(item, "title") ?? "").trim(),
+		};
+		if (hasGuest) {
+			const meta = itemMeta(item);
+			const name = (meta.get("_guest_author") ?? "").trim();
+			if (name) {
+				const avatarId = attachmentId(meta.get("_guest_author_avatar_id"));
+				out.push({
+					...post,
+					name,
+					url: validUrl(meta.get("_guest_author_url") ?? ""),
+					bio: bioText(meta.get("_guest_author_bio") ?? ""),
+					avatarId,
+					avatarUrl: avatar(avatarId),
+					position: 0,
+					source: "guest-author",
+				});
+				// The plugin replaced the byline, so author terms don't apply.
+				continue;
+			}
+		}
+		if (!hasTerms) continue;
+		const authors: AuthorProfile[] = [];
+		const seen = new Set<string>();
+		for (const t of item.matchAll(/<category\s+domain="author"\s+nicename="([^"]*)"\s*>([\s\S]*?)<\/category>/g)) {
+			const slug = decodeSlug(t[1] as string);
+			const text = cdataText(t[2] as string).trim();
+			const known = profiles.get(slug);
+			const login = known?.login || (slug.startsWith("cap-") && users.has(text) ? text : "");
+			const profile: AuthorProfile = known ?? { name: login ? (users.get(login) as string) : text, url: "", bio: "", avatarId: null, login };
+			const key = nameKey(profile.name);
+			if (!key || seen.has(key)) continue;
+			seen.add(key);
+			authors.push({ ...profile, login });
+		}
+		if (!authors.length) continue;
+		const creator = (tag(item, "dc:creator") ?? "").trim();
+		const only = authors.length === 1 ? authors[0] : undefined;
+		if (only && creator && (only.login === creator || (users.has(creator) && sameName(only.name, users.get(creator) as string)))) continue;
+		authors.forEach((a, position) => {
+			out.push({ ...post, name: a.name, url: a.url, bio: a.bio, avatarId: a.avatarId, avatarUrl: avatar(a.avatarId), position, source: "co-authors" });
+		});
+	}
+	return out;
+}
+
+/** EmDash's collection for a WordPress post type (its importer's mapping for posts and pages). */
+export function collectionFor(postType: string): string {
+	return postType === "post" ? "posts" : postType === "page" ? "pages" : postType;
+}
+
+/** A byline slug for a name: lowercase letters, digits and hyphens, starting with a letter. */
+export function bylineSlug(name: string): string {
+	const slug = name
+		.normalize("NFKD")
+		.replace(/[̀-ͯ]/g, "")
+		.toLowerCase()
+		.replace(/[^a-z0-9]+/g, "-")
+		.replace(/^[^a-z]+|-+$/g, "")
+		.slice(0, 60)
+		.replace(/-+$/g, "");
+	return slug || "guest";
+}
+
+/** One byline to create (or find), with the posts it's credited on. */
+export interface GuestByline {
+	name: string;
+	slug: string;
+	url: string;
+	bio: string;
+	/** Avatar file name (to find it in the media library) and its WordPress URL. */
+	avatarFile: string;
+	avatarUrl: string;
+	posts: GuestAuthor[];
+}
+
+const nameKey = (name: string) => name.normalize("NFKC").trim().replace(/\s+/g, " ").toLowerCase();
+
+/**
+ * Group records by author (same name, case-insensitive). Each byline takes
+ * the first non-empty URL, bio and avatar among its records.
+ */
+export function groupGuests(guests: GuestAuthor[]): GuestByline[] {
+	const groups = new Map<string, GuestByline>();
+	for (const g of guests) {
+		const key = nameKey(g.name);
+		let group = groups.get(key);
+		if (!group) {
+			group = { name: g.name.trim().replace(/\s+/g, " "), slug: bylineSlug(g.name), url: "", bio: "", avatarFile: "", avatarUrl: "", posts: [] };
+			groups.set(key, group);
+		}
+		group.url ||= g.url;
+		group.bio ||= g.bio;
+		if (!group.avatarUrl && g.avatarUrl) {
+			group.avatarUrl = g.avatarUrl;
+			group.avatarFile = decodeURIComponent(g.avatarUrl.split(/[?#]/)[0]?.split("/").pop() ?? "");
+		}
+		group.posts.push(g);
+	}
+	return [...groups.values()];
+}
+
+/** Each post with its authors' names in order, for crediting. */
+export interface PostCredit {
+	collection: string;
+	slug: string;
+	title: string;
+	names: string[];
+}
+
+/** One entry per post (by collection and slug), its authors in order and without repeats. */
+export function postCredits(guests: GuestAuthor[]): PostCredit[] {
+	const posts = new Map<string, { credit: PostCredit; records: GuestAuthor[] }>();
+	for (const g of guests) {
+		const collection = collectionFor(g.postType);
+		const key = `${collection}/${g.slug}`;
+		let post = posts.get(key);
+		if (!post) {
+			post = { credit: { collection, slug: g.slug, title: g.title, names: [] }, records: [] };
+			posts.set(key, post);
+		}
+		post.records.push(g);
+	}
+	return [...posts.values()].map(({ credit, records }) => {
+		for (const g of records.sort((a, b) => (a.position ?? 0) - (b.position ?? 0))) {
+			const name = g.name.trim().replace(/\s+/g, " ");
+			if (!credit.names.some((n) => sameName(n, name))) credit.names.push(name);
+		}
+		return credit;
+	});
+}
+
+/** Does an existing byline's name match a guest? */
+export function sameName(a: string, b: string): boolean {
+	return nameKey(a) === nameKey(b);
+}

package/src/wpImport/gutenberg.ts

@@ -0,0 +1,157 @@
+/**
+ * A small Gutenberg block parser and serializer for the prepare step: it
+ * follows WordPress's block-serialization-default-parser grammar, keeps each
+ * untouched block's original text byte for byte, and lets the prepare step
+ * swap blocks for others (replace an entry in `innerBlocks` and its `null`
+ * slot in `innerContent` stays in place). No imports, so it runs in the browser and Node.
+ */
+
+export interface GBlock {
+	/** Full name ("core/paragraph", "coywolf/video"), or null for HTML between blocks. */
+	name: string | null;
+	attrs: Record<string, unknown>;
+	/** HTML of this block without its inner blocks. */
+	innerHTML: string;
+	innerBlocks: GBlock[];
+	/** Text chunks, with null where each inner block goes. */
+	innerContent: Array<string | null>;
+	/** The opening comment as written ("" for freeform HTML). */
+	opener: string;
+	/** The closing comment as written ("" when void, freeform or never closed). */
+	closer: string;
+	/** Self-closing (`<!-- wp:name /-->`). */
+	void: boolean;
+}
+
+const TOKEN = /<!--\s+(\/)?wp:([a-z][a-z0-9_-]*\/)?([a-z][a-z0-9_-]*)\s+(\{[\s\S]*?\}\s+)?(\/)?-->/g;
+
+const fullName = (ns: string | undefined, name: string) => `${ns ?? "core/"}${name}`;
+
+function freeform(html: string): GBlock {
+	return { name: null, attrs: {}, innerHTML: html, innerBlocks: [], innerContent: [html], opener: "", closer: "", void: false };
+}
+
+interface Frame {
+	block: GBlock;
+	start: number;
+	/** Where the next text chunk inside this block starts. */
+	cursor: number;
+}
+
+/** Parse post content into blocks (top-level HTML between blocks becomes freeform blocks). */
+export function parseBlocks(content: string): GBlock[] {
+	const out: GBlock[] = [];
+	const stack: Frame[] = [];
+	let topCursor = 0;
+	TOKEN.lastIndex = 0;
+	const pushText = (frame: Frame | undefined, end: number) => {
+		if (frame) {
+			const text = content.slice(frame.cursor, end);
+			if (text) {
+				frame.block.innerContent.push(text);
+				frame.block.innerHTML += text;
+			}
+		} else if (end > topCursor) {
+			out.push(freeform(content.slice(topCursor, end)));
+		}
+	};
+	for (let m = TOKEN.exec(content); m; m = TOKEN.exec(content)) {
+		const [whole, closer, ns, short, json, slash] = m;
+		const name = fullName(ns, short as string);
+		const start = m.index;
+		const end = start + whole.length;
+		const parent = stack[stack.length - 1];
+		if (closer) {
+			// Close the nearest open block with this name; ignore stray closers.
+			const at = stack.map((f) => f.block.name).lastIndexOf(name);
+			if (at < 0) continue;
+			while (stack.length - 1 > at) {
+				// Unclosed inner blocks: treat their opener as void-ish and keep their text.
+				const frame = stack.pop() as Frame;
+				pushText(frame, start);
+				const up = stack[stack.length - 1] as Frame;
+				up.block.innerBlocks.push(frame.block);
+				up.block.innerContent.push(null);
+				up.cursor = start;
+			}
+			const frame = stack.pop() as Frame;
+			pushText(frame, start);
+			frame.block.closer = whole;
+			const up = stack[stack.length - 1];
+			if (up) {
+				up.block.innerBlocks.push(frame.block);
+				up.block.innerContent.push(null);
+				up.cursor = end;
+			} else {
+				out.push(frame.block);
+				topCursor = end;
+			}
+			continue;
+		}
+		let attrs: Record<string, unknown> = {};
+		if (json) {
+			try {
+				const parsed = JSON.parse(json.trim()) as unknown;
+				if (parsed && typeof parsed === "object" && !Array.isArray(parsed)) attrs = parsed as Record<string, unknown>;
+			} catch {
+				attrs = {};
+			}
+		}
+		const block: GBlock = { name, attrs, innerHTML: "", innerBlocks: [], innerContent: [], opener: whole, closer: "", void: Boolean(slash) };
+		pushText(parent, start);
+		if (slash) {
+			if (parent) {
+				parent.block.innerBlocks.push(block);
+				parent.block.innerContent.push(null);
+				parent.cursor = end;
+			} else {
+				out.push(block);
+				topCursor = end;
+			}
+		} else {
+			if (parent) parent.cursor = start;
+			stack.push({ block, start, cursor: end });
+		}
+	}
+	// Unclosed blocks at the end: keep their text as they were.
+	while (stack.length) {
+		const frame = stack.pop() as Frame;
+		pushText(frame, content.length);
+		const up = stack[stack.length - 1];
+		if (up) {
+			up.block.innerBlocks.push(frame.block);
+			up.block.innerContent.push(null);
+			up.cursor = content.length;
+		} else {
+			out.push(frame.block);
+			topCursor = content.length;
+		}
+	}
+	if (topCursor < content.length) out.push(freeform(content.slice(topCursor)));
+	return out;
+}
+
+/** The block's rendered-ish HTML: its inner content with inner blocks' HTML filled in (no comments). */
+export function blockHtml(block: GBlock): string {
+	let i = 0;
+	return block.innerContent.map((chunk) => (chunk === null ? blockHtml(block.innerBlocks[i++] as GBlock) : chunk)).join("");
+}
+
+/** A Custom HTML block (core/html) holding `html`. */
+export function htmlBlock(html: string): GBlock {
+	const inner = `\n${html}\n`;
+	return { name: "core/html", attrs: {}, innerHTML: inner, innerBlocks: [], innerContent: [inner], opener: "<!-- wp:html -->", closer: "<!-- /wp:html -->", void: false };
+}
+
+/** Serialize one block. An untouched block comes back exactly as it was parsed. */
+export function serializeBlock(block: GBlock): string {
+	if (block.void) return block.opener;
+	let i = 0;
+	const body = block.innerContent.map((chunk) => (chunk === null ? serializeBlock(block.innerBlocks[i++] as GBlock) : chunk)).join("");
+	return block.opener + body + block.closer;
+}
+
+/** Serialize blocks back to post content. */
+export function serializeBlocks(blocks: GBlock[]): string {
+	return blocks.map(serializeBlock).join("");
+}

package/src/wpImport/markers.ts

@@ -0,0 +1,66 @@
+/**
+ * WordPress import markers. EmDash's importer turns Gutenberg into Portable
+ * Text with @emdash-cms/gutenberg-to-portable-text, which has no hook for
+ * plugins and drops every self-closing block it doesn't know (most Coywolf
+ * blocks store everything in attributes, so they'd vanish). The prepare step
+ * (./prepare.ts) rewrites those blocks into Custom HTML blocks holding a
+ * marker element:
+ *
+ *   <div data-coywolf-wp="NAME" data-coywolf-attrs="{…html-escaped JSON…}">fallback HTML</div>
+ *
+ * which the importer keeps verbatim as an `htmlBlock`. The convert step
+ * (./convert.ts) then turns markers into native Coywolf Pack blocks. The
+ * attributes live in the HTML itself, so they survive an editor round trip
+ * (the editor drops the importer's `originalAttrs`).
+ *
+ * Also reads the markers wellbeing.io's import script wrote
+ * (`<div data-wb-block="NAME" data-wb-attrs="{…}"></div>`).
+ *
+ * Pure, no imports: runs in the Worker, the admin (browser) and tests.
+ */
+
+export interface Marker {
+	/** Short block name, e.g. "cloudflare-stream", "review", "anchor". */
+	name: string;
+	attrs: Record<string, unknown>;
+	/** HTML inside the marker element (the fallback rendering), possibly empty. */
+	inner: string;
+	/** Which marker format it came in. */
+	source: "coywolf" | "wellbeing";
+}
+
+const ESCAPES: Record<string, string> = { "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&#39;" };
+const UNESCAPES: Record<string, string> = { "&amp;": "&", "&lt;": "<", "&gt;": ">", "&quot;": '"', "&#39;": "'", "&#x27;": "'", "&apos;": "'" };
+
+/** Escape text for an HTML attribute value or text node. */
+export function escapeAttr(text: string): string {
+	return text.replace(/[&<>"']/g, (c) => ESCAPES[c] as string);
+}
+
+function unescapeAttr(text: string): string {
+	return text.replace(/&(?:amp|lt|gt|quot|#39|#x27|apos);/g, (e) => UNESCAPES[e] as string);
+}
+
+/** The marker element for a block. `inner` is trusted fallback HTML (already escaped where needed). */
+export function markerHtml(name: string, attrs: Record<string, unknown>, inner = ""): string {
+	return `<div data-coywolf-wp="${escapeAttr(name)}" data-coywolf-attrs="${escapeAttr(JSON.stringify(attrs))}">${inner}</div>`;
+}
+
+const COYWOLF = /^\s*<div data-coywolf-wp="([a-z0-9-]+)" data-coywolf-attrs="([^"]*)">([\s\S]*)<\/div>\s*$/;
+const WELLBEING = /^\s*<div data-wb-block="([a-z0-9-]+)" data-wb-attrs="([^"]*)"><\/div>\s*$/;
+
+/** Parse a marker HTML block, or null when the HTML isn't one (or its JSON is unreadable). */
+export function parseMarker(html: unknown): Marker | null {
+	if (typeof html !== "string" || html.length > 2_000_000) return null;
+	const m = html.match(COYWOLF);
+	const w = m ? null : html.match(WELLBEING);
+	const hit = m ?? w;
+	if (!hit) return null;
+	try {
+		const attrs = JSON.parse(unescapeAttr(hit[2] as string)) as unknown;
+		if (!attrs || typeof attrs !== "object" || Array.isArray(attrs)) return null;
+		return { name: hit[1] as string, attrs: attrs as Record<string, unknown>, inner: m ? (m[3] as string) : "", source: m ? "coywolf" : "wellbeing" };
+	} catch {
+		return null;
+	}
+}