@artinstack/migrator 0.1.9 → 0.1.12

package/dist/{bundle-B3XS20r_.d.ts → bundle-CysqqLij.d.ts}

@@ -1,4 +1,4 @@
-import { N as NormalizedPost, a as NormalizedPage, b as NormalizedAsset, c as NormalizedPortfolio, d as NormalizedCategory, e as NormalizedTag, f as NormalizedEntity } from './types-Ce4r6zqt.js';
+import { N as NormalizedPost, a as NormalizedPage, b as NormalizedAsset, c as NormalizedPortfolio, d as NormalizedCategory, e as NormalizedTag, f as NormalizedEntity } from './types-CLNmloya.js';
 
 interface EntityBundle {
     posts: NormalizedPost[];

package/dist/chunk-J7EUSPEA.js

@@ -0,0 +1,667 @@
+import {
+  WORDPRESS_BUILDER_REGISTRY,
+  WORDPRESS_WIDGET_REGISTRY,
+  WP_WIDGET_PLACEHOLDER
+} from "./chunk-QFJXNEXG.js";
+import {
+  normalizeAssetUrl
+} from "./chunk-S4GMDRGX.js";
+
+// src/parsers/wordpress/builders/flatten.ts
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function extractQuotedParam(params, name) {
+  const pattern = new RegExp(`\\b${escapeRegExp(name)}\\s*=\\s*`, "i");
+  const match = pattern.exec(params);
+  if (!match) return void 0;
+  let index = match.index + match[0].length;
+  while (index < params.length && /\s/.test(params[index])) index += 1;
+  if (params.slice(index, index + 6) === "&quot;") {
+    index += 6;
+    let value2 = "";
+    while (index < params.length) {
+      if (params.slice(index, index + 6) === "&quot;") break;
+      value2 += params[index];
+      index += 1;
+    }
+    const trimmed2 = value2.trim();
+    return trimmed2 || void 0;
+  }
+  const quote = params[index];
+  if (quote !== '"' && quote !== "'") return void 0;
+  index += 1;
+  let value = "";
+  while (index < params.length) {
+    const char = params[index];
+    if (char === "\\" && index + 1 < params.length) {
+      value += params[index + 1];
+      index += 2;
+      continue;
+    }
+    if (char === quote) break;
+    value += char;
+    index += 1;
+  }
+  const trimmed = value.trim();
+  return trimmed || void 0;
+}
+function escapeLayoutAttr(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+}
+function parseFractionWidth(fraction) {
+  if (!fraction?.trim()) return void 0;
+  const trimmed = fraction.trim();
+  const match = trimmed.match(/^(\d+)\s*\/\s*(\d+)$/);
+  if (!match) return void 0;
+  const numerator = Number(match[1]);
+  const denominator = Number(match[2]);
+  if (!Number.isFinite(numerator) || !Number.isFinite(denominator) || denominator <= 0) {
+    return void 0;
+  }
+  const percent = numerator / denominator * 100;
+  const rounded = Math.round(percent * 100) / 100;
+  return `${rounded % 1 === 0 ? rounded.toFixed(0) : rounded}%`;
+}
+function parseRowLayoutCols(layout) {
+  if (!layout?.trim()) return void 0;
+  const parts = layout.split("+").map((part) => part.trim()).filter(Boolean);
+  return parts.length > 1 ? parts.length : void 0;
+}
+function openSectionDiv(params, bgParamName) {
+  const attrs = ['data-layout="section"'];
+  const bgImage = extractQuotedParam(params, bgParamName ?? "bg_image");
+  if (bgImage?.startsWith("http")) {
+    attrs.push(`data-bg-image="${escapeLayoutAttr(bgImage)}"`);
+  }
+  return `<div ${attrs.join(" ")}>`;
+}
+function openRowDiv(params, colsParamName) {
+  const attrs = ['data-layout="row"'];
+  const cols = parseRowLayoutCols(extractQuotedParam(params, colsParamName ?? "layout"));
+  if (cols) attrs.push(`data-cols="${cols}"`);
+  return `<div ${attrs.join(" ")}>`;
+}
+function openColumnDiv(params, widthParamName) {
+  const attrs = ['data-layout="column"'];
+  const width = parseFractionWidth(extractQuotedParam(params, widthParamName ?? "width"));
+  if (width) attrs.push(`data-col-width="${width}"`);
+  return `<div ${attrs.join(" ")}>`;
+}
+function applyPrefixedLayoutMap(content, map) {
+  let html = content;
+  html = html.replace(map.sectionRegex, (_, params) => openSectionDiv(params, map.bgParamName));
+  html = html.replace(map.sectionCloseRegex, "</div>");
+  html = html.replace(map.rowRegex, (_, params) => openRowDiv(params, map.colsParamName));
+  html = html.replace(map.rowCloseRegex, "</div>");
+  html = html.replace(map.columnRegex, '<div data-layout="column">');
+  html = html.replace(map.columnCloseRegex, "</div>");
+  return html;
+}
+function applyFractionalLayoutMap(content, map) {
+  let html = content;
+  html = html.replace(map.sectionRegex, (_, params) => openSectionDiv(params, map.bgParamName));
+  html = html.replace(map.sectionCloseRegex, "</div>");
+  html = html.replace(map.rowRegex, (_, params) => openRowDiv(params));
+  html = html.replace(map.rowCloseRegex, "</div>");
+  for (let index = 0; index < map.columnTokens.length; index += 1) {
+    const token = map.columnTokens[index];
+    const width = map.columnWidths[token];
+    const openRegex = map.columnOpenRegexes[index];
+    const closeRegex = map.columnCloseRegexes[index];
+    html = html.replace(openRegex, () => {
+      const attrs = ['data-layout="column"'];
+      if (width) attrs.push(`data-col-width="${width}"`);
+      return `<div ${attrs.join(" ")}>`;
+    });
+    html = html.replace(closeRegex, "</div>");
+  }
+  return html;
+}
+function applyExtendedPrefixedLayoutMap(content, map) {
+  let html = content;
+  const levels = [...map.levels].sort((left, right) => {
+    const leftMax = Math.max(...left.tokens.map((token) => token.length));
+    const rightMax = Math.max(...right.tokens.map((token) => token.length));
+    return rightMax - leftMax;
+  });
+  for (const level of levels) {
+    const tokens = [...level.tokens].sort((left, right) => right.length - left.length);
+    for (const token of tokens) {
+      const openRegex = new RegExp(`\\[${escapeRegExp(token)}\\b([^\\]]*)\\]`, "gi");
+      const closeRegex = new RegExp(`\\[\\/${escapeRegExp(token)}\\b[^\\]]*\\]`, "gi");
+      html = html.replace(openRegex, (_, params) => {
+        switch (level.role) {
+          case "section":
+            return openSectionDiv(params, level.bgParamName);
+          case "row":
+            return openRowDiv(params, level.colsParamName);
+          case "column":
+            return openColumnDiv(params, level.widthParamName);
+        }
+      });
+      html = html.replace(closeRegex, "</div>");
+    }
+  }
+  return html;
+}
+function applyStructuralLayoutMap(content, map) {
+  switch (map.kind) {
+    case "prefixed":
+      return applyPrefixedLayoutMap(content, map);
+    case "fractional":
+      return applyFractionalLayoutMap(content, map);
+    case "extended-prefixed":
+      return applyExtendedPrefixedLayoutMap(content, map);
+  }
+}
+function collectLayoutMaps(theme) {
+  const maps = [];
+  if (theme.layoutMap) maps.push(theme.layoutMap);
+  if (theme.layoutMaps?.length) maps.push(...theme.layoutMaps);
+  return maps;
+}
+function extractShortcodeParam(params, names) {
+  for (const name of names) {
+    const value = extractQuotedParam(params, name);
+    if (value) return value;
+  }
+  return void 0;
+}
+function escapeHtmlText(text) {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+function textToHtml(text, tag) {
+  const paragraphs = text.split(/\n{2,}/).map((part) => part.trim()).filter(Boolean);
+  if (paragraphs.length === 0) return "";
+  return paragraphs.map((paragraph) => {
+    const inner = escapeHtmlText(paragraph).replace(/\n/g, "<br />");
+    return `<${tag}>${inner}</${tag}>`;
+  }).join("\n");
+}
+function emitHtmlTag(tag, url) {
+  const normalized = normalizeAssetUrl(url) ?? url;
+  const escaped = normalized.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+  switch (tag) {
+    case "img":
+      return `<img src="${escaped}" alt="" />`;
+    case "video":
+      return `<video src="${escaped}" controls></video>`;
+    case "iframe":
+      return `<iframe src="${escaped}" loading="lazy"></iframe>`;
+  }
+}
+function convertUrlRule(content, rule) {
+  const prefix = escapeRegExp(rule.shortcodePrefix);
+  const pattern = new RegExp(
+    `\\[${prefix}\\b([^\\]]*)\\]\\s*(?:\\[\\/${prefix}\\b[^\\]]*\\])?`,
+    "gi"
+  );
+  return content.replace(pattern, (block, params) => {
+    const url = extractShortcodeParam(params, rule.urlParams);
+    if (!url) return block;
+    return emitHtmlTag(rule.tag, url);
+  });
+}
+function convertTextRule(content, rule) {
+  const prefix = escapeRegExp(rule.shortcodePrefix);
+  const pattern = new RegExp(
+    `\\[${prefix}\\b([^\\]]*)\\]\\s*(?:\\[\\/${prefix}\\b[^\\]]*\\])?`,
+    "gis"
+  );
+  return content.replace(pattern, (block, params) => {
+    const parts = [];
+    for (const field of rule.fields) {
+      const text = extractQuotedParam(params, field.param);
+      if (!text) continue;
+      const html = textToHtml(text, field.tag);
+      if (html) parts.push(html);
+    }
+    return parts.length > 0 ? parts.join("\n") : block;
+  });
+}
+function convertWrapperRule(content, rule) {
+  const prefix = escapeRegExp(rule.shortcodePrefix);
+  const pattern = new RegExp(
+    `\\[${prefix}\\b([^\\]]*)\\]([\\s\\S]*?)\\[\\/${prefix}\\b[^\\]]*\\]`,
+    "gi"
+  );
+  return content.replace(pattern, (_, params, inner) => {
+    const parts = [];
+    if (rule.urlParams?.length) {
+      const url = extractShortcodeParam(params, rule.urlParams);
+      if (url) parts.push(emitHtmlTag("img", url));
+    }
+    parts.push(inner.trim());
+    return parts.filter(Boolean).join("\n");
+  });
+}
+function isPlaceholderImageUrl(url) {
+  return /placehold\.it|placeholder\.com|via\.placeholder/i.test(url);
+}
+function convertIconImageRule(content, rule) {
+  const prefix = escapeRegExp(rule.shortcodePrefix);
+  const pattern = new RegExp(
+    `\\[${prefix}\\b([^\\]]*)\\]\\s*(?:\\[\\/${prefix}\\b[^\\]]*\\])?`,
+    "gi"
+  );
+  return content.replace(pattern, (_, params) => {
+    const iconImage = extractQuotedParam(params, rule.imageParam) ?? extractQuotedParam(params, "image");
+    if (!iconImage?.startsWith("http") || isPlaceholderImageUrl(iconImage)) {
+      return "";
+    }
+    const img = emitHtmlTag("img", iconImage);
+    if (rule.hrefParam) {
+      const href = extractQuotedParam(params, rule.hrefParam);
+      if (href?.startsWith("http")) {
+        const escapedHref = href.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/</g, "&lt;");
+        return `<a href="${escapedHref}">${img}</a>`;
+      }
+    }
+    return img;
+  });
+}
+function convertPlaceholderRule(content, rule) {
+  const prefix = escapeRegExp(rule.shortcodePrefix);
+  const pattern = new RegExp(
+    `\\[${prefix}\\b([^\\]]*)\\]\\s*(?:\\[\\/${prefix}\\b[^\\]]*\\])?`,
+    "gi"
+  );
+  return content.replace(pattern, rule.html);
+}
+function stripScaffoldingPrefix(content, prefix) {
+  const escaped = escapeRegExp(prefix);
+  const opener = new RegExp(`\\[${escaped}[a-z0-9_-]*[^\\]]*\\]`, "gi");
+  const closer = new RegExp(`\\[\\/${escaped}[a-z0-9_-]*[^\\]]*\\]`, "gi");
+  return content.replace(opener, "").replace(closer, "");
+}
+function stripLegacyTokens(content, tokens) {
+  let result = content;
+  for (const token of tokens) {
+    const escaped = escapeRegExp(token);
+    const opener = new RegExp(`\\[${escaped}\\b[^\\]]*\\]`, "gi");
+    const closer = new RegExp(`\\[\\/${escaped}\\b[^\\]]*\\]`, "gi");
+    result = result.replace(opener, "").replace(closer, "");
+  }
+  return result;
+}
+function detectThemes(content, registry) {
+  return registry.filter((theme) => theme.detect.test(content));
+}
+function extractBareOrQuotedParam(params, name) {
+  const quoted = extractQuotedParam(params, name);
+  if (quoted) return quoted;
+  const pattern = new RegExp(`\\b${escapeRegExp(name)}\\s*=\\s*([^\\s"'\\]]+)`, "i");
+  const match = pattern.exec(params);
+  return match?.[1]?.trim() || void 0;
+}
+function emitWidgetStub(widget, attrs, tag = "div") {
+  const parts = [`data-wp-widget="${escapeLayoutAttr(widget)}"`];
+  for (const [key, value] of Object.entries(attrs)) {
+    if (value) parts.push(`${key}="${escapeLayoutAttr(value)}"`);
+  }
+  return `<${tag} ${parts.join(" ")}>${WP_WIDGET_PLACEHOLDER}</${tag}>`;
+}
+function normalizeVideoEmbedUrl(raw) {
+  const trimmed = raw.trim();
+  if (!trimmed || trimmed.startsWith("data:")) return void 0;
+  try {
+    const url = new URL(trimmed.startsWith("//") ? `https:${trimmed}` : trimmed);
+    const host = url.hostname.replace(/^www\./, "").replace(/^m\./, "");
+    if (host === "youtu.be") {
+      const id = url.pathname.split("/").filter(Boolean)[0];
+      if (id) {
+        return { provider: "youtube", embedUrl: `https://www.youtube-nocookie.com/embed/${id}` };
+      }
+    }
+    if (host === "youtube.com" || host === "youtube-nocookie.com") {
+      const embedMatch = url.pathname.match(/\/embed\/([^/?#]+)/);
+      if (embedMatch?.[1]) {
+        const start = url.searchParams.get("start");
+        const suffix = start ? `?start=${start}` : "";
+        return {
+          provider: "youtube",
+          embedUrl: `https://www.youtube-nocookie.com/embed/${embedMatch[1]}${suffix}`
+        };
+      }
+      const videoId = url.searchParams.get("v");
+      if (videoId) {
+        const t = url.searchParams.get("t") ?? url.searchParams.get("start");
+        const startSeconds = t?.endsWith("s") ? t.slice(0, -1) : t;
+        const suffix = startSeconds ? `?start=${startSeconds}` : "";
+        return {
+          provider: "youtube",
+          embedUrl: `https://www.youtube-nocookie.com/embed/${videoId}${suffix}`
+        };
+      }
+    }
+    if (host === "vimeo.com") {
+      const segments = url.pathname.split("/").filter(Boolean);
+      const id = segments[segments.length - 1];
+      if (id && /^\d+$/.test(id)) {
+        return { provider: "vimeo", embedUrl: `https://player.vimeo.com/video/${id}` };
+      }
+    }
+    if (host === "player.vimeo.com") {
+      const match = url.pathname.match(/\/video\/(\d+)/);
+      if (match?.[1]) {
+        return { provider: "vimeo", embedUrl: `https://player.vimeo.com/video/${match[1]}` };
+      }
+    }
+  } catch {
+    return void 0;
+  }
+  return void 0;
+}
+function emitVideoWidgetFromParams(params, inner) {
+  const url = extractShortcodeParam(params, ["url", "src", "video", "link", "youtube_url", "vimeo_url"]) ?? inner.trim().match(/^https?:\/\/\S+/)?.[0];
+  if (!url) {
+    return emitWidgetStub("video", { "data-video-provider": "external" });
+  }
+  const normalized = normalizeVideoEmbedUrl(url);
+  if (normalized) {
+    return emitWidgetStub("video", {
+      "data-video-provider": normalized.provider,
+      "data-embed-url": normalized.embedUrl
+    });
+  }
+  if (/\.(mp4|webm|ogg)(\?|#|$)/i.test(url)) {
+    return emitHtmlTag("video", url);
+  }
+  return emitWidgetStub("video", {
+    "data-video-provider": "external",
+    "data-embed-url": url
+  });
+}
+function buildGoogleMapsEmbedUrlFromMapParams(params) {
+  const direct = extractShortcodeParam(params, [
+    "embed_url",
+    "url",
+    "src",
+    "map_url",
+    "iframe_url",
+    "embed"
+  ]);
+  if (direct && /google\.com\/maps|maps\.google\.com/i.test(direct)) {
+    return { embedUrl: direct.trim() };
+  }
+  const lat = extractBareOrQuotedParam(params, "lat") ?? extractBareOrQuotedParam(params, "latitude") ?? extractBareOrQuotedParam(params, "map_lat");
+  const lng = extractBareOrQuotedParam(params, "lng") ?? extractBareOrQuotedParam(params, "longitude") ?? extractBareOrQuotedParam(params, "map_lng");
+  const address = extractBareOrQuotedParam(params, "address") ?? extractBareOrQuotedParam(params, "map_address") ?? extractBareOrQuotedParam(params, "location") ?? extractBareOrQuotedParam(params, "map_location") ?? extractBareOrQuotedParam(params, "q");
+  if (lat && lng) {
+    const zoom = extractBareOrQuotedParam(params, "zoom") ?? "14";
+    return {
+      embedUrl: `https://maps.google.com/maps?q=${encodeURIComponent(`${lat},${lng}`)}&z=${zoom}&output=embed`,
+      lat,
+      lng
+    };
+  }
+  if (address) {
+    return {
+      embedUrl: `https://maps.google.com/maps?q=${encodeURIComponent(address)}&output=embed`,
+      query: address
+    };
+  }
+  return {};
+}
+function flattenMapShortcodes(content, widgetRegistry) {
+  let html = content;
+  for (const prefix of widgetRegistry.mapShortcodePrefixes) {
+    const pattern = new RegExp(
+      `\\[${escapeRegExp(prefix)}\\b([^\\]]*)\\]\\s*(?:\\[\\/${escapeRegExp(prefix)}\\b[^\\]]*\\])?`,
+      "gi"
+    );
+    html = html.replace(pattern, (_, params) => {
+      const resolved = buildGoogleMapsEmbedUrlFromMapParams(params);
+      return emitWidgetStub("map", {
+        ...resolved.embedUrl ? { "data-embed-url": resolved.embedUrl } : {},
+        ...resolved.lat ? { "data-wp-map-lat": resolved.lat } : {},
+        ...resolved.lng ? { "data-wp-map-lng": resolved.lng } : {},
+        ...resolved.query ? { "data-wp-map-query": resolved.query } : {}
+      });
+    });
+  }
+  return html;
+}
+function flattenContactFormShortcodes(content, widgetRegistry) {
+  let html = content;
+  for (const rule of widgetRegistry.contactFormRules) {
+    const pattern = new RegExp(
+      `\\[${escapeRegExp(rule.tag)}\\b([^\\]]*)\\]\\s*(?:\\[\\/${escapeRegExp(rule.tag)}\\b[^\\]]*\\])?`,
+      "gi"
+    );
+    html = html.replace(pattern, (_, params) => {
+      const id = extractBareOrQuotedParam(params, rule.idParam);
+      return emitWidgetStub(
+        "contact-form",
+        {
+          "data-wp-form-source": rule.source,
+          ...id ? { "data-wp-form-id": id } : {}
+        },
+        "section"
+      );
+    });
+  }
+  return html;
+}
+function emitInlineGalleryFromIds(idList) {
+  const images = idList.map((id) => `<img data-wp-attachment-id="${escapeLayoutAttr(id)}" alt="" />`).join("");
+  return `<figure data-wp-inline-gallery>${images}</figure>`;
+}
+function parseGalleryAttachmentIds(params) {
+  const ids = extractBareOrQuotedParam(params, "ids");
+  const idList = ids?.split(",").map((part) => part.trim()).filter((part) => /^\d+$/.test(part));
+  return idList?.length ? idList : void 0;
+}
+function flattenIdGalleryShortcode(content, tag) {
+  const escaped = escapeRegExp(tag);
+  const pattern = new RegExp(`\\[${escaped}\\b([^\\]]*)\\](?:\\s*\\[\\/${escaped}\\])?`, "gi");
+  return content.replace(pattern, (fullMatch, params) => {
+    const idList = parseGalleryAttachmentIds(params);
+    if (idList?.length) {
+      return emitInlineGalleryFromIds(idList);
+    }
+    return fullMatch;
+  });
+}
+function flattenGalleryShortcodes(content, widgetRegistry) {
+  const tag = escapeRegExp(widgetRegistry.galleryShortcode);
+  const pattern = new RegExp(`\\[${tag}\\b([^\\]]*)\\](?:\\s*\\[\\/${tag}\\])?`, "gi");
+  return content.replace(pattern, (_, params) => {
+    const idList = parseGalleryAttachmentIds(params);
+    if (idList?.length) {
+      return emitInlineGalleryFromIds(idList);
+    }
+    const category = extractBareOrQuotedParam(params, "category") ?? extractBareOrQuotedParam(params, "type");
+    return emitWidgetStub("portfolio", {
+      "data-wp-gallery-dynamic": "1",
+      ...category ? { "data-wp-portfolio-category": category } : {}
+    });
+  });
+}
+function flattenIdBasedGalleryShortcodes(content, widgetRegistry) {
+  let html = content;
+  for (const tag of widgetRegistry.idGalleryShortcodes) {
+    html = flattenIdGalleryShortcode(html, tag);
+  }
+  return html;
+}
+var SHORTCODE_WORD_COUNTS = {
+  one: "1",
+  two: "2",
+  three: "3",
+  four: "4",
+  five: "5",
+  six: "6",
+  seven: "7",
+  eight: "8",
+  nine: "9",
+  ten: "10"
+};
+function normalizeShortcodeCount(raw) {
+  if (!raw?.trim()) return void 0;
+  const trimmed = raw.trim().toLowerCase();
+  if (/^\d+$/.test(trimmed)) return trimmed;
+  return SHORTCODE_WORD_COUNTS[trimmed];
+}
+function inferBlogListingLayout(params) {
+  const raw = extractBareOrQuotedParam(params, "builderLayout") ?? extractBareOrQuotedParam(params, "layout") ?? extractBareOrQuotedParam(params, "style");
+  if (!raw) return "grid";
+  const normalized = raw.trim().toLowerCase();
+  if (normalized === "list" || normalized === "grid" || normalized === "featured" || normalized === "sidebar") {
+    return normalized;
+  }
+  return "grid";
+}
+function flattenBlogListingShortcodes(content, widgetRegistry) {
+  let html = content;
+  for (const tag of widgetRegistry.blogShortcodeTags) {
+    const escaped = escapeRegExp(tag);
+    const pattern = new RegExp(`\\[${escaped}\\b([^\\]]*)\\](?:\\s*\\[\\/${escaped}\\])?`, "gi");
+    html = html.replace(pattern, (_, params) => {
+      const limit = normalizeShortcodeCount(extractBareOrQuotedParam(params, "number_of_posts")) ?? normalizeShortcodeCount(extractBareOrQuotedParam(params, "count")) ?? normalizeShortcodeCount(extractBareOrQuotedParam(params, "posts_per_page")) ?? normalizeShortcodeCount(extractBareOrQuotedParam(params, "number"));
+      const filterBy = extractBareOrQuotedParam(params, "filter_by")?.toLowerCase();
+      const categories = extractBareOrQuotedParam(params, "categories");
+      const tags = extractBareOrQuotedParam(params, "tags");
+      const col = extractBareOrQuotedParam(params, "col");
+      return emitWidgetStub(
+        "blog-listing",
+        {
+          "data-wp-blog-layout": inferBlogListingLayout(params),
+          ...limit ? { "data-wp-blog-limit": limit } : {},
+          ...col ? { "data-wp-blog-columns": col } : {},
+          ...filterBy === "category" && categories ? { "data-wp-blog-category": categories } : {},
+          ...filterBy === "tag" && tags ? { "data-wp-blog-tags": tags } : {}
+        },
+        "section"
+      );
+    });
+  }
+  return html;
+}
+function flattenPortfolioShortcodes(content, widgetRegistry) {
+  const tag = escapeRegExp(widgetRegistry.portfolioShortcode);
+  const pattern = new RegExp(`\\[${tag}\\b([^\\]]*)\\](?:\\s*\\[\\/${tag}\\])?`, "gi");
+  return content.replace(pattern, (_, params) => {
+    const category = extractBareOrQuotedParam(params, "category");
+    const slug = extractBareOrQuotedParam(params, "slug");
+    return emitWidgetStub("portfolio", {
+      ...category ? { "data-wp-portfolio-category": category } : {},
+      ...slug ? { "data-wp-portfolio-slug": slug } : {}
+    });
+  });
+}
+function flattenVideoShortcodes(content, widgetRegistry) {
+  let html = content;
+  for (const prefix of widgetRegistry.videoShortcodePrefixes) {
+    const wrapped = new RegExp(
+      `\\[${escapeRegExp(prefix)}\\b([^\\]]*)\\]([\\s\\S]*?)\\[\\/${escapeRegExp(prefix)}\\b[^\\]]*\\]`,
+      "gi"
+    );
+    html = html.replace(
+      wrapped,
+      (_, params, inner) => emitVideoWidgetFromParams(params, inner)
+    );
+    const selfClosing = new RegExp(
+      `\\[${escapeRegExp(prefix)}\\b([^\\]]*)\\]`,
+      "gi"
+    );
+    html = html.replace(selfClosing, (_, params) => emitVideoWidgetFromParams(params, ""));
+  }
+  return html;
+}
+function looksLikeContactFormHtml(formHtml) {
+  if (!/<form\b/i.test(formHtml)) return false;
+  const lower = formHtml.toLowerCase();
+  if (/searchform|wp-login-form|loginform|lostpasswordform/i.test(lower)) return false;
+  if (/type\s*=\s*["']search["']/i.test(formHtml)) return false;
+  if (/newsletter|subscribe/i.test(lower) && !/<textarea\b/i.test(formHtml)) return false;
+  const hasEmailField = /type\s*=\s*["']email["']/i.test(formHtml) || /name\s*=\s*["'][^"']*email/i.test(formHtml) || /class\s*=\s*["'][^"']*email/i.test(formHtml);
+  const hasMessageField = /<textarea\b/i.test(formHtml) || /name\s*=\s*["'][^"']*(message|comment|body|enquiry|inquiry)/i.test(formHtml);
+  const hasContactHint = /contact|serverless-contact|get-in-touch|request-quote|quote-request/i.test(lower);
+  if (hasEmailField && hasMessageField) return true;
+  if (hasContactHint && hasEmailField) return true;
+  if (hasContactHint && hasMessageField) return true;
+  return false;
+}
+function stripContactFormHelperScripts(html) {
+  return html.replace(
+    /<script\b[^>]*\bsrc\s*=\s*["'][^"']*(?:recaptcha|contact_form|contact-form)[^"']*["'][^>]*>\s*<\/script>\s*/gi,
+    ""
+  );
+}
+function flattenCustomHtmlContactForms(content) {
+  let html = content.replace(/<form\b[^>]*>[\s\S]*?<\/form>/gi, (formHtml) => {
+    if (!looksLikeContactFormHtml(formHtml)) return formHtml;
+    const formId = formHtml.match(/\bid\s*=\s*["']([^"']+)["']/i)?.[1]?.trim() || formHtml.match(/\bname\s*=\s*["']([^"']+)["']/i)?.[1]?.trim();
+    return emitWidgetStub(
+      "contact-form",
+      {
+        "data-wp-form-source": "custom-html",
+        ...formId ? { "data-wp-form-id": formId } : {}
+      },
+      "section"
+    );
+  });
+  html = stripContactFormHelperScripts(html);
+  return html;
+}
+function flattenWordPressWidgets(content, widgetRegistry = WORDPRESS_WIDGET_REGISTRY) {
+  let html = content;
+  html = flattenGalleryShortcodes(html, widgetRegistry);
+  html = flattenIdBasedGalleryShortcodes(html, widgetRegistry);
+  html = flattenPortfolioShortcodes(html, widgetRegistry);
+  html = flattenBlogListingShortcodes(html, widgetRegistry);
+  html = flattenMapShortcodes(html, widgetRegistry);
+  html = flattenContactFormShortcodes(html, widgetRegistry);
+  html = flattenVideoShortcodes(html, widgetRegistry);
+  html = flattenCustomHtmlContactForms(html);
+  return html;
+}
+function flattenWordPressBuilders(content, options = {}) {
+  if (!content.trim()) {
+    return { html: content, detectedThemes: [] };
+  }
+  const registry = options.registry ?? WORDPRESS_BUILDER_REGISTRY;
+  const themes = detectThemes(content, registry);
+  const widgetRegistry = options.widgetRegistry ?? WORDPRESS_WIDGET_REGISTRY;
+  let html = flattenWordPressWidgets(content, widgetRegistry);
+  for (const theme of themes) {
+    for (const rule of theme.wrapperRules ?? []) {
+      html = convertWrapperRule(html, rule);
+    }
+    for (const rule of theme.textRules ?? []) {
+      html = convertTextRule(html, rule);
+    }
+    for (const rule of theme.urlRules ?? []) {
+      html = convertUrlRule(html, rule);
+    }
+    for (const rule of theme.placeholderRules ?? []) {
+      html = convertPlaceholderRule(html, rule);
+    }
+    for (const rule of theme.iconImageRules ?? []) {
+      html = convertIconImageRule(html, rule);
+    }
+    for (const layoutMap of collectLayoutMaps(theme)) {
+      html = applyStructuralLayoutMap(html, layoutMap);
+    }
+    for (const prefix of theme.scaffoldingPrefixes ?? []) {
+      html = stripScaffoldingPrefix(html, prefix);
+    }
+    if (theme.legacyScaffoldingTokens?.length) {
+      html = stripLegacyTokens(html, theme.legacyScaffoldingTokens);
+    }
+  }
+  html = flattenWordPressWidgets(html, widgetRegistry);
+  html = html.replace(/\n{3,}/g, "\n\n").trim();
+  return {
+    html,
+    detectedThemes: themes.map((theme) => theme.id)
+  };
+}
+
+export {
+  normalizeVideoEmbedUrl,
+  flattenWordPressBuilders
+};
+//# sourceMappingURL=chunk-J7EUSPEA.js.map