@setzkasten-cms/astro-admin 1.4.0 → 1.4.1

package/dist/chunk-RHJONMLK.js

@@ -0,0 +1,1267 @@
+// src/init/template-patcher-v2.ts
+import { parse } from "@astrojs/compiler";
+var normalizeWs = (s) => s.replace(/\s+/g, " ").trim();
+function findNormalizedText(haystack, needle, startFrom) {
+  const exactIdx = haystack.indexOf(needle, startFrom);
+  if (exactIdx !== -1) return { start: exactIdx, end: exactIdx + needle.length };
+  const normalized = normalizeWs(needle);
+  if (!normalized || normalized.length < 2) return null;
+  const escaped = normalized.replace(/[.*+?^${}()|[\]\\]/g, "\\$&").replace(/ /g, "\\s+");
+  const regex = new RegExp(escaped);
+  const match = regex.exec(haystack.slice(startFrom));
+  if (match) return { start: startFrom + match.index, end: startFrom + match.index + match[0].length };
+  return null;
+}
+async function patchTemplateForFields(source, sectionKey, fields, repeatedGroups = [], options) {
+  let result;
+  try {
+    result = await parse(source);
+  } catch (err) {
+    console.error("[setzkasten] template-patcher: parse() failed:", err);
+    return source;
+  }
+  const ast = result.ast;
+  const b2c = buildByteToCharMap(source);
+  convertAstPositions(ast, b2c);
+  const fmNode = ast.children?.find((c) => c.type === "frontmatter");
+  if (!fmNode?.value) return source;
+  let varName = extractVarName(fmNode.value);
+  if (!varName) {
+    varName = "skData";
+    const isPageMode = options?.mode === "page";
+    let propsBlock;
+    if (isPageMode) {
+      propsBlock = `
+import { getSection } from 'setzkasten:content'
+const ${varName} = getSection('${sectionKey}')
+`;
+    } else {
+      propsBlock = `
+interface Props {
+  data: Record<string, any> | null
+}
+const { data: ${varName} } = Astro.props
+`;
+    }
+    const fmEnd = source.indexOf("---", source.indexOf("---") + 3);
+    if (fmEnd === -1) return source;
+    const modifiedSource = source.slice(0, fmEnd) + propsBlock + source.slice(fmEnd);
+    const shift = propsBlock.length;
+    for (const g of repeatedGroups) {
+      for (const inst of g.instances) {
+        inst.start += shift;
+        inst.end += shift;
+      }
+      for (const f of g.fields) {
+        for (let i = 0; i < f.positions.length; i++) {
+          const p = f.positions[i];
+          if (p) p.offset += shift;
+        }
+      }
+      if (g.classAttrs) {
+        for (const instAttrs of g.classAttrs) {
+          for (const a of instAttrs) a.sourceOffset += shift;
+        }
+      }
+    }
+    const patched2 = await patchTemplateForFields(modifiedSource, sectionKey, fields, repeatedGroups, options);
+    return removeOldVarDeclarations(patched2, fields, repeatedGroups, varName);
+  }
+  const existingBindings = /* @__PURE__ */ new Set();
+  walkAst(ast, (node) => {
+    if (isElement(node) && node.attributes) {
+      for (const attr of node.attributes) {
+        if (attr.name === "data-sk-field" && attr.value) {
+          existingBindings.add(attr.value);
+        }
+      }
+    }
+  });
+  const fmVarNames = /* @__PURE__ */ new Set();
+  const fmVarRegex = /(?:const|let)\s+(\w+)\s*=/g;
+  let fmMatch;
+  while ((fmMatch = fmVarRegex.exec(fmNode.value)) !== null) {
+    fmVarNames.add(fmMatch[1]);
+  }
+  const cmsExpressions = [];
+  const varExpressions = [];
+  const textNodes = [];
+  const hrefAttrs = [];
+  const mapExpressions = [];
+  const mixedElements = [];
+  walkAst(ast, (node, parent) => {
+    if (!parent) return;
+    if (isElement(node) && node.children && node.children.length > 1) {
+      const hasText = node.children.some((c) => c.type === "text" && c.value?.trim());
+      const hasChild = node.children.some((c) => isElement(c) || c.type === "expression");
+      if (hasText && hasChild) {
+        const fullText = normalizeWs(getElementTextContent(node));
+        if (fullText) mixedElements.push({ node, normalizedText: fullText });
+      }
+    }
+    if (node.type === "expression" && node.children) {
+      const exprText = node.children.filter((c) => c.type === "text").map((c) => c.value ?? "").join("");
+      const cmsMatch = exprText.match(new RegExp(`${varName}\\?\\.\\s*(\\w+)`));
+      if (cmsMatch) {
+        cmsExpressions.push({ node, parent, fieldKey: cmsMatch[1] });
+      }
+      const trimmedExpr = exprText.trim();
+      if (fmVarNames.has(trimmedExpr) && !trimmedExpr.includes(".") && !trimmedExpr.includes("(")) {
+        varExpressions.push({ node, parent, varName: trimmedExpr });
+      }
+      if (exprText.includes(".map(")) {
+        mapExpressions.push({ node });
+      }
+    }
+    if (node.type === "text" && node.value?.trim()) {
+      textNodes.push({ node, parent });
+    }
+    if (isElement(node) && node.attributes) {
+      for (const attr of node.attributes) {
+        if (attr.name === "href" && attr.kind === "quoted" && attr.value) {
+          hrefAttrs.push({ attr, element: node });
+        }
+      }
+    }
+  });
+  const edits = [];
+  patchSectionId(source, ast, sectionKey, edits, options);
+  const repeatedFieldKeys = /* @__PURE__ */ new Set();
+  if (repeatedGroups.length > 0) {
+    const repeatedEdits = patchRepeatedGroups(source, sectionKey, varName, repeatedGroups);
+    edits.push(...repeatedEdits);
+    for (const g of repeatedGroups) repeatedFieldKeys.add(g.fieldKey);
+    for (const g of repeatedGroups) {
+      const topField = fields.find((f) => f.key === g.fieldKey);
+      if (!topField || !Array.isArray(topField.defaultValue)) continue;
+      const items = topField.defaultValue;
+      for (const innerField of g.fields) {
+        for (let ii = 0; ii < items.length && ii < innerField.defaultValues.length; ii++) {
+          const val = innerField.defaultValues[ii];
+          if (val != null && items[ii] && typeof items[ii] === "object" && !(innerField.key in items[ii])) {
+            items[ii][innerField.key] = val;
+          }
+        }
+      }
+    }
+  }
+  for (const field of fields) {
+    if (repeatedFieldKeys.has(field.key)) continue;
+    const bindingKey = `${sectionKey}.${field.key}`;
+    if (existingBindings.has(bindingKey)) continue;
+    if (field.type === "array" && Array.isArray(field.defaultValue)) {
+      const editsBefore2 = edits.length;
+      patchArrayField(source, sectionKey, field, varName, mapExpressions, edits);
+      if (edits.length === editsBefore2) {
+        patchStaticListField(source, sectionKey, field, varName, ast, edits);
+      }
+      continue;
+    }
+    const cmsExpr = cmsExpressions.find((e) => e.fieldKey === field.key);
+    if (cmsExpr) {
+      patchCmsBoundField(source, sectionKey, field, cmsExpr, edits);
+      continue;
+    }
+    const varExpr = varExpressions.find((e) => e.varName === field.key);
+    if (varExpr) {
+      patchVarExpression(source, sectionKey, field, varName, varExpr, edits);
+      continue;
+    }
+    if (field.type === "icon" || field.type === "image") {
+      patchIconOrImageField(source, sectionKey, field, varName, ast, edits);
+      continue;
+    }
+    if (!field.defaultValue || typeof field.defaultValue !== "string") continue;
+    if (field.defaultValue.length < 2) continue;
+    if (/link|url|href/i.test(field.key)) {
+      const hrefMatch = hrefAttrs.find((h) => h.attr.value === field.defaultValue);
+      if (hrefMatch) {
+        patchHrefField(source, sectionKey, field, varName, hrefMatch, edits);
+        continue;
+      }
+    }
+    const editsBefore = edits.length;
+    patchTextField(source, sectionKey, field, varName, textNodes, edits);
+    if (edits.length === editsBefore) {
+      const dv = field.defaultValue;
+      const mixedMatch = mixedElements.find((m) => m.normalizedText === normalizeWs(dv));
+      if (mixedMatch) {
+        patchMixedContentField(source, sectionKey, field, varName, mixedMatch.node, edits);
+      }
+    }
+  }
+  const patched = applyEdits(source, edits);
+  return convertToSetHtml(patched);
+}
+function convertToSetHtml(source) {
+  const marker = "data-sk-field";
+  let result = source;
+  let searchFrom = 0;
+  while (true) {
+    const idx = result.indexOf(marker, searchFrom);
+    if (idx === -1) break;
+    searchFrom = idx + marker.length;
+    let tagEnd = -1;
+    let braceDepth = 0;
+    for (let i = idx; i < result.length; i++) {
+      const ch = result[i];
+      if (ch === "{") braceDepth++;
+      else if (ch === "}") braceDepth--;
+      else if (ch === ">" && braceDepth === 0) {
+        tagEnd = i;
+        break;
+      }
+    }
+    if (tagEnd === -1) continue;
+    const tagSection = result.slice(idx, tagEnd);
+    if (tagSection.includes("set:html")) continue;
+    const afterTag = result.slice(tagEnd + 1);
+    const innerMatch = afterTag.match(/^(\s*)\{([^{}]+)\}(\s*)<\/(\w+)>/);
+    if (!innerMatch) continue;
+    const expr = innerMatch[2].trim();
+    if (!/^\w+\??\.\w+$/.test(expr)) continue;
+    const fullInnerLength = innerMatch[0].length;
+    const closeTag = `</${innerMatch[4]}>`;
+    const insertion = ` set:html={${expr}}>${closeTag}`;
+    result = result.slice(0, tagEnd) + insertion + result.slice(tagEnd + 1 + fullInnerLength);
+    searchFrom = tagEnd + insertion.length;
+  }
+  return result;
+}
+function buildByteToCharMap(source) {
+  const buf = Buffer.from(source, "utf-8");
+  if (buf.length === source.length) {
+    return (offset) => offset;
+  }
+  const map = new Array(buf.length + 1);
+  let byteIdx = 0;
+  for (let charIdx = 0; charIdx < source.length; charIdx++) {
+    const codePoint = source.codePointAt(charIdx);
+    const charByteLen = codePoint <= 127 ? 1 : codePoint <= 2047 ? 2 : codePoint <= 65535 ? 3 : 4;
+    for (let b = 0; b < charByteLen; b++) {
+      map[byteIdx + b] = charIdx;
+    }
+    byteIdx += charByteLen;
+    if (codePoint > 65535) charIdx++;
+  }
+  map[byteIdx] = source.length;
+  return (offset) => {
+    if (offset <= 0) return 0;
+    if (offset >= map.length) return source.length;
+    return map[offset];
+  };
+}
+function convertAstPositions(node, b2c) {
+  if (node.position?.start) {
+    node.position.start.offset = b2c(node.position.start.offset);
+  }
+  if (node.position?.end) {
+    node.position.end.offset = b2c(node.position.end.offset);
+  }
+  if (node.attributes) {
+    for (const attr of node.attributes) {
+      if (attr.position?.start) {
+        attr.position.start.offset = b2c(attr.position.start.offset);
+      }
+    }
+  }
+  if (node.children) {
+    for (const child of node.children) {
+      convertAstPositions(child, b2c);
+    }
+  }
+}
+function findExpressionBounds(source, node) {
+  const approxStart = node.position?.start?.offset;
+  if (approxStart == null) return null;
+  const exprText = (node.children ?? []).filter((c) => c.type === "text").map((c) => c.value ?? "").join("");
+  if (!exprText) return null;
+  const searchStart = Math.max(0, approxStart - 10);
+  const searchEnd = Math.min(source.length, approxStart + 10);
+  let braceStart = -1;
+  for (let i = searchStart; i < searchEnd; i++) {
+    if (source[i] === "{") {
+      const afterBrace = source.slice(i + 1, i + 1 + exprText.length + 5);
+      if (afterBrace.trimStart().startsWith(exprText.trimStart().slice(0, 20))) {
+        braceStart = i;
+        break;
+      }
+    }
+  }
+  if (braceStart === -1) return null;
+  let depth = 1;
+  let inStr = null;
+  for (let i = braceStart + 1; i < source.length; i++) {
+    const ch = source[i];
+    if (inStr) {
+      if (ch === inStr && source[i - 1] !== "\\") inStr = null;
+      continue;
+    }
+    if (ch === "'" || ch === '"' || ch === "`") {
+      inStr = ch;
+      continue;
+    }
+    if (ch === "{") depth++;
+    if (ch === "}") {
+      depth--;
+      if (depth === 0) return { start: braceStart, end: i + 1 };
+    }
+  }
+  return null;
+}
+function findTextBounds(source, node) {
+  const value = node.value;
+  if (!value) return null;
+  const trimmed = value.trim();
+  if (!trimmed) return null;
+  const approxStart = node.position?.start?.offset;
+  if (approxStart == null) return null;
+  const searchStart = Math.max(0, approxStart - 20);
+  const idx = source.indexOf(trimmed, searchStart);
+  if (idx === -1 || idx > approxStart + 50) return null;
+  let start = idx;
+  while (start > 0 && /\s/.test(source[start - 1]) && source[start - 1] !== ">") {
+    start--;
+  }
+  let end = idx + trimmed.length;
+  while (end < source.length && /\s/.test(source[end]) && source[end] !== "<") {
+    end++;
+  }
+  return { start, end };
+}
+function getElementTextContent(node) {
+  if (node.type === "text") return node.value ?? "";
+  if (node.type === "expression") {
+    return (node.children ?? []).filter((c) => c.type === "text").map((c) => c.value ?? "").join("");
+  }
+  return (node.children ?? []).map(getElementTextContent).join("");
+}
+var PHRASING_ONLY_RTE_WRAPPERS = /* @__PURE__ */ new Set(["p", "span"]);
+function patchMixedContentField(source, sectionKey, field, varName, element, edits) {
+  const bindingKey = `${sectionKey}.${field.key}`;
+  if (element.attributes?.some((a) => a.name === "data-sk-field")) return;
+  const startOffset = element.position?.start?.offset;
+  if (startOffset == null) return;
+  const tagName = element.name;
+  if (!tagName) return;
+  const searchStart = Math.max(0, startOffset - 10);
+  const tagPattern = `<${tagName}`;
+  const tagIdx = source.indexOf(tagPattern, searchStart);
+  if (tagIdx === -1 || tagIdx > startOffset + 10) return;
+  const openTagEnd = findOpeningTagEnd(source, tagIdx);
+  if (openTagEnd === -1) return;
+  const endOffset = element.position?.end?.offset;
+  if (endOffset == null) return;
+  const closeTag = `</${tagName}>`;
+  const closeIdx = source.lastIndexOf(closeTag, endOffset);
+  if (closeIdx === -1 || closeIdx <= openTagEnd) return;
+  const innerStart = openTagEnd + 1;
+  const innerHTML = source.slice(innerStart, closeIdx).trim();
+  const escapedHTML = innerHTML.replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+  edits.push({
+    offset: openTagEnd,
+    deleteCount: 0,
+    insert: ` data-sk-field="${bindingKey}" set:html={${varName}?.${field.key} ?? \`${escapedHTML}\`}`
+  });
+  edits.push({
+    offset: innerStart,
+    deleteCount: closeIdx - innerStart,
+    insert: ""
+  });
+  if (PHRASING_ONLY_RTE_WRAPPERS.has(tagName)) {
+    edits.push({
+      offset: tagIdx + 1,
+      // position of the tag-name char after '<'
+      deleteCount: tagName.length,
+      insert: "div"
+    });
+    edits.push({
+      offset: closeIdx + 2,
+      // position of the tag-name char after '</'
+      deleteCount: tagName.length,
+      insert: "div"
+    });
+  }
+}
+function patchIconOrImageField(source, sectionKey, field, _varName, ast, edits) {
+  const bindingKey = `${sectionKey}.${field.key}`;
+  const defaultStr = typeof field.defaultValue === "string" ? field.defaultValue : "";
+  let targetParent = null;
+  walkAst(ast, (node, parent) => {
+    if (targetParent) return;
+    if (!parent || !isElement(parent)) return;
+    if (parent.attributes?.some((a) => a.name === "data-sk-field")) return;
+    if (field.type === "icon") {
+      const isIconComp = isElement(node) && /icon/i.test(node.name ?? "");
+      const hasIconAttr = node.attributes?.some(
+        (a) => (a.name === "icon" || a.name === "name" || a.name === "data-icon") && (a.value === defaultStr || a.value.includes(field.key))
+      );
+      if (isIconComp || hasIconAttr) {
+        targetParent = parent;
+      }
+    } else if (field.type === "image") {
+      const tag = node.name ?? "";
+      const isImgEl = /^(img|Image|picture)$/.test(tag);
+      const hasSrcAttr = node.attributes?.some(
+        (a) => a.name === "src" && (a.value === defaultStr || a.value.includes(field.key))
+      );
+      if (isImgEl || hasSrcAttr) {
+        targetParent = parent;
+      }
+    }
+  });
+  if (!targetParent) return;
+  addAttributeToElement(source, targetParent, `data-sk-field="${bindingKey}"`, edits);
+}
+function patchCmsBoundField(source, sectionKey, field, cmsExpr, edits) {
+  const bindingKey = `${sectionKey}.${field.key}`;
+  const parentEl = cmsExpr.parent;
+  if (isElement(parentEl) && parentEl.attributes) {
+    for (const attr of parentEl.attributes) {
+      if (attr.name === "data-sk-field") return;
+    }
+    const meaningfulChildren = (parentEl.children ?? []).filter(
+      (c) => !(c.type === "text" && !c.value?.trim())
+    );
+    if (meaningfulChildren.length === 1 && meaningfulChildren[0] === cmsExpr.node) {
+      addAttributeToElement(source, parentEl, `data-sk-field="${bindingKey}"`, edits);
+      return;
+    }
+  }
+  const bounds = findExpressionBounds(source, cmsExpr.node);
+  if (!bounds) return;
+  const exprSource = source.slice(bounds.start, bounds.end);
+  edits.push({
+    offset: bounds.start,
+    deleteCount: bounds.end - bounds.start,
+    insert: `<span data-sk-field="${bindingKey}">${exprSource}</span>`
+  });
+}
+function patchTextField(source, sectionKey, field, varName, textNodes, edits) {
+  const defaultValue = field.defaultValue;
+  const bindingKey = `${sectionKey}.${field.key}`;
+  const cmsExpr = `{${varName}?.${field.key}}`;
+  const normalizedDefault = normalizeWs(defaultValue);
+  const matches = textNodes.filter((t) => normalizeWs(t.node.value ?? "") === normalizedDefault);
+  if (matches.length === 0) return;
+  for (const match of matches) {
+    const textNode = match.node;
+    const parentEl = match.parent;
+    const bounds = findTextBounds(source, textNode);
+    if (!bounds) continue;
+    const { start, end } = bounds;
+    if (edits.some((e) => e.offset === start)) continue;
+    if (isElement(parentEl)) {
+      const meaningfulChildren = (parentEl.children ?? []).filter(
+        (c) => !(c.type === "text" && !c.value?.trim())
+      );
+      const isSoleContent = meaningfulChildren.length === 1 && meaningfulChildren[0] === textNode;
+      if (isSoleContent) {
+        const hasBinding = parentEl.attributes?.some((a) => a.name === "data-sk-field");
+        if (!hasBinding) {
+          addAttributeToElement(source, parentEl, `data-sk-field="${bindingKey}"`, edits);
+        }
+        const originalText2 = source.slice(start, end);
+        const leadingWs2 = originalText2.match(/^(\s*)/)?.[1] ?? "";
+        const trailingWs2 = originalText2.match(/(\s*)$/)?.[1] ?? "";
+        edits.push({
+          offset: start,
+          deleteCount: end - start,
+          insert: `${leadingWs2}${cmsExpr}${trailingWs2}`
+        });
+        continue;
+      }
+    }
+    const originalText = source.slice(start, end);
+    const leadingWs = originalText.match(/^(\s*)/)?.[1] ?? "";
+    const trailingWs = originalText.match(/(\s*)$/)?.[1] ?? "";
+    edits.push({
+      offset: start,
+      deleteCount: end - start,
+      insert: `${leadingWs}<span data-sk-field="${bindingKey}">${cmsExpr}</span>${trailingWs}`
+    });
+  }
+}
+function patchVarExpression(source, sectionKey, field, cmsVarName, varExpr, edits) {
+  const bindingKey = `${sectionKey}.${field.key}`;
+  const bounds = findExpressionBounds(source, varExpr.node);
+  if (!bounds) return;
+  const cmsExpr = `{${cmsVarName}?.${field.key}}`;
+  const parentEl = varExpr.parent;
+  if (isElement(parentEl)) {
+    const meaningfulChildren = (parentEl.children ?? []).filter(
+      (c) => !(c.type === "text" && !c.value?.trim())
+    );
+    if (meaningfulChildren.length === 1 && meaningfulChildren[0] === varExpr.node) {
+      const hasBinding = parentEl.attributes?.some((a) => a.name === "data-sk-field");
+      if (!hasBinding) {
+        addAttributeToElement(source, parentEl, `data-sk-field="${bindingKey}"`, edits);
+      }
+      edits.push({ offset: bounds.start, deleteCount: bounds.end - bounds.start, insert: cmsExpr });
+      return;
+    }
+  }
+  edits.push({
+    offset: bounds.start,
+    deleteCount: bounds.end - bounds.start,
+    insert: `<span data-sk-field="${bindingKey}">${cmsExpr}</span>`
+  });
+}
+function patchHrefField(source, _sectionKey, field, varName, hrefMatch, edits) {
+  const attr = hrefMatch.attr;
+  const approxStart = attr.position?.start?.offset;
+  if (approxStart == null) return;
+  const rawAttr = attr.raw ?? `"${attr.value}"`;
+  const hrefStr = `href=${rawAttr}`;
+  const searchStart = Math.max(0, approxStart - 20);
+  const actualOffset = source.indexOf(hrefStr, searchStart);
+  if (actualOffset === -1) return;
+  edits.push({
+    offset: actualOffset,
+    deleteCount: hrefStr.length,
+    insert: `href={${varName}?.${field.key}}`
+  });
+}
+function patchArrayField(source, sectionKey, field, varName, mapExpressions, edits) {
+  if (mapExpressions.length === 0) return;
+  let mapExpr = mapExpressions[0];
+  if (mapExpressions.length > 1 && Array.isArray(field.defaultValue) && field.defaultValue.length > 0) {
+    const firstItem = field.defaultValue[0];
+    const searchStr = typeof firstItem === "string" ? firstItem.slice(0, 30) : typeof firstItem === "object" && firstItem !== null ? Object.values(firstItem).find((v) => typeof v === "string" && v.length >= 3)?.slice(0, 30) ?? "" : "";
+    if (searchStr.length >= 3) {
+      for (const expr of mapExpressions) {
+        const exprBounds = findExpressionBounds(source, expr.node);
+        if (!exprBounds) continue;
+        const exprSrc = source.slice(exprBounds.start, exprBounds.end);
+        if (exprSrc.includes(searchStr)) {
+          mapExpr = expr;
+          break;
+        }
+      }
+    }
+  }
+  const bounds = findExpressionBounds(source, mapExpr.node);
+  if (!bounds) return;
+  const exprSource = source.slice(bounds.start, bounds.end);
+  const mapParamRegex = /\.map\s*\(\s*\(?\s*(\w+)(\s*,\s*(\w+))?\s*\)?/;
+  const paramMatch = exprSource.match(mapParamRegex);
+  if (!paramMatch) return;
+  const itemParam = paramMatch[1];
+  let indexParam = paramMatch[3];
+  if (!indexParam) {
+    indexParam = "_i";
+    const sigRegex = new RegExp(`\\.map\\s*\\(\\s*\\(?\\s*${itemParam}(\\s*\\)?)`);
+    const sigMatch = exprSource.match(sigRegex);
+    if (sigMatch) {
+      const sigOffset = bounds.start + exprSource.indexOf(sigMatch[0]);
+      const insertPoint = sigOffset + sigMatch[0].length - (sigMatch[1]?.length ?? 0);
+      edits.push({
+        offset: insertPoint,
+        deleteCount: 0,
+        insert: `, ${indexParam}`
+      });
+    }
+  }
+  const arrayAndMapRegex = /(\[[\s\S]*?\])\s*\.map\s*\(/;
+  const arrayMatch = exprSource.match(arrayAndMapRegex);
+  if (arrayMatch) {
+    const arrayLiteral = arrayMatch[1];
+    const arrayStartInExpr = exprSource.indexOf(arrayLiteral);
+    const arrayEndInExpr = arrayStartInExpr + arrayLiteral.length;
+    const arrayStart = bounds.start + arrayStartInExpr;
+    const arrayEnd = bounds.start + arrayEndInExpr;
+    edits.push({
+      offset: arrayStart,
+      deleteCount: arrayEnd - arrayStart,
+      insert: `(${varName}?.${field.key} ?? [])`
+    });
+  } else {
+    const varMapRegex = new RegExp(`(\\w+)\\.map\\s*\\(`);
+    const varMapMatch = exprSource.match(varMapRegex);
+    if (varMapMatch) {
+      const varRef = varMapMatch[1];
+      const varStartInExpr = exprSource.indexOf(varMapMatch[0]);
+      const varEndInExpr = varStartInExpr + varRef.length;
+      const varStart = bounds.start + varStartInExpr;
+      const varEnd = bounds.start + varEndInExpr;
+      edits.push({
+        offset: varStart,
+        deleteCount: varEnd - varStart,
+        insert: `(${varName}?.${field.key} ?? [])`
+      });
+    }
+  }
+  const firstChildElement = findFirstChildElement(mapExpr.node);
+  if (firstChildElement) {
+    const hasSkField = firstChildElement.attributes?.some((a) => a.name === "data-sk-field");
+    if (!hasSkField) {
+      const skFieldExpr = `data-sk-field={\`${sectionKey}.${field.key}.\${${indexParam}}\`}`;
+      addAttributeToElement(source, firstChildElement, skFieldExpr, edits);
+    }
+  }
+  patchArrayItemProperties(source, sectionKey, field, itemParam, indexParam, mapExpr.node, edits);
+}
+function patchStaticListField(source, sectionKey, field, varName, ast, edits) {
+  if (!Array.isArray(field.defaultValue) || field.defaultValue.length === 0) return;
+  const items = field.defaultValue;
+  let matchedUl = null;
+  walkAst(ast, (node) => {
+    if (matchedUl) return;
+    if (node.type !== "element") return;
+    if (node.name !== "ul" && node.name !== "ol") return;
+    let hasMap = false;
+    walkAst(node, (n) => {
+      if (hasMap) return;
+      if (n.type === "expression") {
+        const code = (n.children ?? []).map((c) => c.value ?? "").join("");
+        if (/\.map\s*\(/.test(code)) hasMap = true;
+      }
+    });
+    if (hasMap) return;
+    const stripHtml = (s) => s.replace(/<[^>]+>/g, "").replace(/\s+/g, " ").trim();
+    const liChildren2 = (node.children ?? []).filter((c) => c.type === "element" && c.name === "li");
+    if (liChildren2.length !== items.length) return;
+    const allMatch = liChildren2.every((li, i) => {
+      const text = getElementTextContent(li).replace(/\s+/g, " ").trim();
+      return text === stripHtml(items[i]);
+    });
+    if (allMatch) matchedUl = node;
+  });
+  if (!matchedUl) return;
+  const ulNode = matchedUl;
+  const liChildren = (ulNode.children ?? []).filter(
+    (c) => c.type === "element" && c.name === "li"
+  );
+  if (liChildren.length === 0) return;
+  const firstLi = liChildren[0];
+  const lastLi = liChildren[liChildren.length - 1];
+  const rangeStart = firstLi.position?.start?.offset;
+  const rangeEnd = lastLi.position?.end?.offset;
+  if (rangeStart == null || rangeEnd == null) return;
+  const firstLiEnd = firstLi.position?.end?.offset ?? rangeEnd;
+  let liTemplate = source.slice(rangeStart, firstLiEnd);
+  const liTagEnd = liTemplate.indexOf(">");
+  if (liTagEnd === -1) return;
+  const bindingKey = `${sectionKey}.${field.key}`;
+  liTemplate = liTemplate.slice(0, liTagEnd) + ` data-sk-field={\`${bindingKey}.\${_i}\`}>` + liTemplate.slice(liTagEnd + 1);
+  liTemplate = liTemplate.replace(
+    /<span([^>]*)>([\s\S]*?)<\/span>/g,
+    (_m, attrs, content) => {
+      if (!content.trim()) return _m;
+      if (attrs.includes("set:html") || attrs.includes("data-sk-field")) return _m;
+      return `<span${attrs} set:html={item}></span>`;
+    }
+  );
+  const hasHtmlItems = items.some((s) => /<[a-z]/.test(s));
+  const fallbackItems = hasHtmlItems ? items.map((s) => `\`${s.replace(/`/g, "\\`").replace(/\$/g, "\\$")}\``).join(", ") : items.map((s) => `'${s.replace(/\\/g, "\\\\").replace(/'/g, "\\'")}'`).join(", ");
+  const textBeforeFirstLi = source.slice(0, rangeStart);
+  const lastNewline = textBeforeFirstLi.lastIndexOf("\n");
+  const indent = lastNewline >= 0 ? textBeforeFirstLi.slice(lastNewline + 1).match(/^[ \t]*/)?.[0] ?? "" : "";
+  const replacement = `{(${varName}?.${field.key} ?? [${fallbackItems}]).map((item, _i) => (
+${indent}${liTemplate}
+${indent}))}`;
+  edits.push({
+    offset: rangeStart,
+    deleteCount: rangeEnd - rangeStart,
+    insert: replacement
+  });
+}
+function patchArrayItemProperties(source, sectionKey, field, itemParam, indexParam, mapNode, edits) {
+  walkAst(mapNode, (node, parent) => {
+    if (!parent || node.type !== "expression" || !node.children) return;
+    const exprText = node.children.filter((c) => c.type === "text").map((c) => c.value ?? "").join("").trim();
+    const nestedMapMatch = exprText.match(new RegExp(`^${itemParam}\\.(\\w+)\\.map\\s*\\(`));
+    if (nestedMapMatch) {
+      const innerFieldKey = nestedMapMatch[1];
+      patchNestedMap(source, sectionKey, field.key, innerFieldKey, indexParam, node, edits);
+      return;
+    }
+    const propMatch = exprText.match(new RegExp(`^${itemParam}\\.(\\w+(?:\\.\\w+)*)$`));
+    if (!propMatch) return;
+    const propPath = propMatch[1];
+    const bindingKey = `${sectionKey}.${field.key}.\${${indexParam}}.${propPath}`;
+    if (!isElement(parent) || !parent.attributes) return;
+    if (parent.attributes.some((a) => a.name === "data-sk-field")) return;
+    const meaningfulChildren = (parent.children ?? []).filter(
+      (c) => !(c.type === "text" && !c.value?.trim())
+    );
+    if (meaningfulChildren.length === 1 && meaningfulChildren[0] === node) {
+      const skFieldExpr = `data-sk-field={\`${bindingKey}\`}`;
+      addAttributeToElement(source, parent, skFieldExpr, edits);
+      return;
+    }
+    const bounds = findExpressionBounds(source, node);
+    if (!bounds) return;
+    const exprSource = source.slice(bounds.start, bounds.end);
+    edits.push({
+      offset: bounds.start,
+      deleteCount: bounds.end - bounds.start,
+      insert: `<span data-sk-field={\`${bindingKey}\`}>${exprSource}</span>`
+    });
+  });
+}
+function patchNestedMap(source, sectionKey, outerFieldKey, innerFieldKey, outerIndexParam, exprNode, edits) {
+  const bounds = findExpressionBounds(source, exprNode);
+  if (!bounds) return;
+  const exprSrc = source.slice(bounds.start, bounds.end);
+  const mapParamRegex = /\.map\s*\(\s*\(?\s*(\w+)(\s*,\s*(\w+))?\s*\)?/;
+  const paramMatch = exprSrc.match(mapParamRegex);
+  if (!paramMatch) return;
+  const innerItemParam = paramMatch[1];
+  let innerIndexParam = paramMatch[3];
+  if (!innerIndexParam) {
+    innerIndexParam = "_j";
+    const sigRegex = new RegExp(`\\.map\\s*\\(\\s*\\(?\\s*${innerItemParam}(\\s*\\)?)`);
+    const sigMatch = exprSrc.match(sigRegex);
+    if (sigMatch) {
+      const insertOffset = bounds.start + exprSrc.indexOf(sigMatch[0]) + sigMatch[0].length - (sigMatch[1]?.length ?? 0);
+      edits.push({ offset: insertOffset, deleteCount: 0, insert: `, ${innerIndexParam}` });
+    }
+  }
+  const basePath = `${sectionKey}.${outerFieldKey}.\${${outerIndexParam}}.${innerFieldKey}.\${${innerIndexParam}}`;
+  const firstChild = findFirstChildElement(exprNode);
+  if (firstChild) {
+    const hasSkField = firstChild.attributes?.some((a) => a.name === "data-sk-field");
+    if (!hasSkField) {
+      addAttributeToElement(source, firstChild, `data-sk-field={\`${basePath}\`}`, edits);
+    }
+  }
+  walkAst(exprNode, (node, parent) => {
+    if (!parent || node.type !== "expression" || !node.children) return;
+    const exprText = node.children.filter((c) => c.type === "text").map((c) => c.value ?? "").join("").trim();
+    const propMatch = exprText.match(new RegExp(`^${innerItemParam}\\.(\\w+(?:\\.\\w+)*)$`));
+    if (!propMatch) return;
+    const propPath = propMatch[1];
+    const bindingKey = `${basePath}.${propPath}`;
+    if (!isElement(parent) || !parent.attributes) return;
+    if (parent.attributes.some((a) => a.name === "data-sk-field")) return;
+    const meaningfulChildren = (parent.children ?? []).filter(
+      (c) => !(c.type === "text" && !c.value?.trim())
+    );
+    if (meaningfulChildren.length === 1 && meaningfulChildren[0] === node) {
+      addAttributeToElement(source, parent, `data-sk-field={\`${bindingKey}\`}`, edits);
+      return;
+    }
+    const nodeBounds = findExpressionBounds(source, node);
+    if (!nodeBounds) return;
+    const nodeSrc = source.slice(nodeBounds.start, nodeBounds.end);
+    edits.push({
+      offset: nodeBounds.start,
+      deleteCount: nodeBounds.end - nodeBounds.start,
+      insert: `<span data-sk-field={\`${bindingKey}\`}>${nodeSrc}</span>`
+    });
+  });
+}
+function collectDynamicClassEdits(innerEdits, source, instances, tmpl, group) {
+  const classAttrs = group.classAttrs;
+  if (!classAttrs || classAttrs.length < 2 || instances.length < 2) return;
+  const tmplAttrs = classAttrs[0];
+  if (tmplAttrs.length === 0) return;
+  const otherInstAttrs = classAttrs.slice(1);
+  function findMatch(tmplAttr, instAttrs, claimed) {
+    const tmplParts = new Set(tmplAttr.value.split(/\s+/).filter(Boolean));
+    function sharedClassCount(instValue) {
+      const instParts = new Set(instValue.split(/\s+/).filter(Boolean));
+      if (tmplParts.size === 0 && instParts.size === 0) return 1;
+      return [...tmplParts].filter((p) => instParts.has(p)).length;
+    }
+    for (let i = 0; i < instAttrs.length; i++) {
+      if (!claimed.has(i) && instAttrs[i].path === tmplAttr.path) {
+        if (sharedClassCount(instAttrs[i].value) > 0) {
+          claimed.add(i);
+          return instAttrs[i].value;
+        }
+      }
+    }
+    const stripIdx = (p) => p.split("/").map((s) => s.replace(/:\d+$/, "")).join("/");
+    const tmplTagPath = stripIdx(tmplAttr.path);
+    let bestIdx = -1;
+    let bestShared = 0;
+    for (let i = 0; i < instAttrs.length; i++) {
+      if (claimed.has(i)) continue;
+      if (stripIdx(instAttrs[i].path) !== tmplTagPath) continue;
+      const shared = sharedClassCount(instAttrs[i].value);
+      if (shared > bestShared) {
+        bestShared = shared;
+        bestIdx = i;
+      }
+    }
+    if (bestIdx >= 0 && bestShared > 0) {
+      claimed.add(bestIdx);
+      return instAttrs[bestIdx].value;
+    }
+    return null;
+  }
+  const skipForInstance = tmplAttrs.map(() => /* @__PURE__ */ new Set());
+  for (const field of group.fields) {
+    if (field.required) continue;
+    const tmplPos = field.positions[0];
+    if (!tmplPos) continue;
+    const fieldTag = field.tag;
+    let bestAttrIdx = -1;
+    let bestDist = Infinity;
+    for (let ai = 0; ai < tmplAttrs.length; ai++) {
+      const pathParts = tmplAttrs[ai].path.split("/");
+      const leafTag = (pathParts[pathParts.length - 1] ?? "").replace(/:\d+$/, "");
+      if (!leafTag && fieldTag !== group.tag) continue;
+      if (leafTag && leafTag !== fieldTag) continue;
+      const dist = Math.abs(tmplPos.offset - tmplAttrs[ai].sourceOffset);
+      if (dist < bestDist) {
+        bestDist = dist;
+        bestAttrIdx = ai;
+      }
+    }
+    if (bestAttrIdx < 0) continue;
+    for (let instIdx = 1; instIdx < instances.length; instIdx++) {
+      if (!field.positions[instIdx]) {
+        skipForInstance[bestAttrIdx].add(instIdx - 1);
+      }
+    }
+  }
+  const claimedPerInstance = otherInstAttrs.map(() => /* @__PURE__ */ new Set());
+  let dynamicCount = 0;
+  for (let ai = 0; ai < tmplAttrs.length; ai++) {
+    const tmplAttr = tmplAttrs[ai];
+    const values = [tmplAttr.value];
+    let anyDiffers = false;
+    for (let ii = 0; ii < otherInstAttrs.length; ii++) {
+      if (skipForInstance[ai].has(ii)) {
+        values.push(tmplAttr.value);
+        continue;
+      }
+      const match = findMatch(tmplAttr, otherInstAttrs[ii], claimedPerInstance[ii]);
+      if (match == null) {
+        values.push(tmplAttr.value);
+      } else {
+        values.push(match);
+        if (match !== tmplAttr.value) anyDiffers = true;
+      }
+    }
+    if (!anyDiffers) continue;
+    const relOffset = tmplAttr.sourceOffset - tmpl.start;
+    if (relOffset < 0) continue;
+    const fieldKey = `_class${dynamicCount++}`;
+    group.fields.push({
+      key: fieldKey,
+      type: "text",
+      tag: "class",
+      required: true,
+      positions: instances.map(() => null),
+      defaultValues: values
+    });
+    innerEdits.push({
+      offset: relOffset,
+      deleteCount: tmplAttr.sourceLength,
+      insert: `class={item.${fieldKey}}`
+    });
+  }
+}
+function patchRepeatedGroups(source, sectionKey, varName, groups) {
+  const edits = [];
+  for (const group of groups) {
+    const { tag, fieldKey, instances, fields } = group;
+    if (instances.length < 2) continue;
+    const tmpl = instances[0];
+    let templateSrc = source.slice(tmpl.start, tmpl.end);
+    const innerEdits = [];
+    collectDynamicClassEdits(innerEdits, source, instances, tmpl, group);
+    for (const field of fields) {
+      const pos = field.positions[0];
+      if (!pos) continue;
+      const relOffset = pos.offset - tmpl.start;
+      if (relOffset < 0 || relOffset >= templateSrc.length) continue;
+      if (field.type === "array" && pos.source) {
+        const mapPattern = `${pos.source}.map(`;
+        const mapIdx = templateSrc.indexOf(mapPattern);
+        if (mapIdx !== -1) {
+          innerEdits.push({
+            offset: mapIdx,
+            deleteCount: mapPattern.length,
+            insert: `(item.${field.key} ?? []).map(`
+          });
+        }
+      } else if (field.type === "link") {
+        const fieldSrc = templateSrc.slice(relOffset, relOffset + pos.length);
+        const hrefMatch = fieldSrc.match(/href\s*=\s*"([^"]*)"/);
+        if (hrefMatch) {
+          const hrefStart = relOffset + fieldSrc.indexOf(hrefMatch[0]);
+          innerEdits.push({
+            offset: hrefStart,
+            deleteCount: hrefMatch[0].length,
+            insert: `href={item.${field.key}}`
+          });
+        }
+      } else if (field.type === "text") {
+        const defaultVal = field.defaultValues[0];
+        if (typeof defaultVal === "string" && defaultVal.length >= 1) {
+          const searchFrom = relOffset > 10 ? relOffset - 10 : 0;
+          const found = findNormalizedText(templateSrc, defaultVal, searchFrom);
+          if (found) {
+            innerEdits.push({
+              offset: found.start,
+              deleteCount: found.end - found.start,
+              insert: `{item.${field.key}}`
+            });
+          }
+        }
+      }
+    }
+    for (const field of fields) {
+      if (field.required) continue;
+      const pos = field.positions[0];
+      if (pos) continue;
+      let donorIdx = -1;
+      let donorPos = null;
+      for (let i = 1; i < instances.length; i++) {
+        if (field.positions[i]) {
+          donorIdx = i;
+          donorPos = field.positions[i];
+          break;
+        }
+      }
+      if (!donorPos || donorIdx < 0) continue;
+      const donorInst = instances[donorIdx];
+      const donorSrc = source.slice(donorInst.start, donorInst.end);
+      const donorRelOffset = donorPos.offset - donorInst.start;
+      let elementSrc = donorSrc.slice(donorRelOffset, donorRelOffset + donorPos.length);
+      const templateSrcForCheck = source.slice(tmpl.start, tmpl.end);
+      const beforeElement = donorSrc.slice(0, donorRelOffset).trimEnd();
+      const parentCloseMatch = beforeElement.match(/<(\w+)\s+[^>]*class="([^"]*)"[^>]*>\s*$/);
+      if (parentCloseMatch) {
+        const parentTag = parentCloseMatch[1];
+        const parentClass = parentCloseMatch[2];
+        if (!templateSrcForCheck.includes(`class="${parentClass}"`)) {
+          const parentStart = beforeElement.lastIndexOf(`<${parentTag}`);
+          if (parentStart >= 0) {
+            const closingTag = `</${parentTag}>`;
+            const afterElement = donorSrc.slice(donorRelOffset + donorPos.length);
+            const closingIdx = afterElement.indexOf(closingTag);
+            if (closingIdx >= 0) {
+              const wrapperEnd = donorRelOffset + donorPos.length + closingIdx + closingTag.length;
+              elementSrc = donorSrc.slice(parentStart, wrapperEnd).trim();
+            }
+          }
+        }
+      }
+      const defaultVal = field.defaultValues[donorIdx];
+      if (typeof defaultVal === "string" && defaultVal.length >= 1) {
+        const found = findNormalizedText(elementSrc, defaultVal, 0);
+        if (found) {
+          elementSrc = elementSrc.slice(0, found.start) + `{item.${field.key}}` + elementSrc.slice(found.end);
+        }
+      }
+      const conditionalBlock = `{item.${field.key} && ${elementSrc}}`;
+      const openTagEnd = templateSrc.indexOf(">", 0) + 1;
+      if (openTagEnd > 0) {
+        innerEdits.push({
+          offset: openTagEnd,
+          deleteCount: 0,
+          insert: `
+        ${conditionalBlock}`
+        });
+      }
+    }
+    innerEdits.sort((a, b) => b.offset - a.offset);
+    for (const edit of innerEdits) {
+      templateSrc = templateSrc.slice(0, edit.offset) + edit.insert + templateSrc.slice(edit.offset + edit.deleteCount);
+    }
+    const tagEndIdx = templateSrc.indexOf(">");
+    if (tagEndIdx !== -1) {
+      const skFieldAttr = ` data-sk-field={\`${sectionKey}.${fieldKey}.\${_i}\`}`;
+      templateSrc = templateSrc.slice(0, tagEndIdx) + skFieldAttr + templateSrc.slice(tagEndIdx);
+    }
+    templateSrc = addInnerFieldBindings(templateSrc, sectionKey, fieldKey, fields);
+    const indent = detectIndent(source, tmpl.start);
+    const wrapped = `{(${varName}?.${fieldKey} ?? []).map((item, _i) => (
+${indent}  ${templateSrc}
+${indent}))}`;
+    edits.push({
+      offset: tmpl.start,
+      deleteCount: tmpl.end - tmpl.start,
+      insert: wrapped
+    });
+    for (let i = instances.length - 1; i >= 1; i--) {
+      const inst = instances[i];
+      let deleteStart = inst.start;
+      let deleteEnd = inst.end;
+      while (deleteStart > 0 && /\s/.test(source[deleteStart - 1]) && source[deleteStart - 1] !== "\n") {
+        deleteStart--;
+      }
+      if (deleteStart > 0 && source[deleteStart - 1] === "\n") deleteStart--;
+      edits.push({
+        offset: deleteStart,
+        deleteCount: deleteEnd - deleteStart,
+        insert: ""
+      });
+    }
+  }
+  return edits;
+}
+function addInnerFieldBindings(templateSrc, sectionKey, groupFieldKey, fields) {
+  const inserts = [];
+  for (const field of fields) {
+    if (field.type === "array" || field.type === "link") continue;
+    const itemRef = `{item.${field.key}}`;
+    const idx = templateSrc.indexOf(itemRef);
+    if (idx === -1) continue;
+    let tagStart = idx - 1;
+    while (tagStart >= 0 && templateSrc[tagStart] !== "<") tagStart--;
+    if (tagStart < 0 || templateSrc[tagStart + 1] === "/") continue;
+    let tagEnd = -1;
+    let inQ = null;
+    let inE = 0;
+    for (let i = tagStart; i < idx; i++) {
+      const ch = templateSrc[i];
+      if (inQ) {
+        if (ch === inQ && templateSrc[i - 1] !== "\\") inQ = null;
+        continue;
+      }
+      if (ch === "{") {
+        inE++;
+        continue;
+      }
+      if (ch === "}" && inE > 0) {
+        inE--;
+        continue;
+      }
+      if (inE > 0) continue;
+      if (ch === '"' || ch === "'") {
+        inQ = ch;
+        continue;
+      }
+      if (ch === ">") tagEnd = i;
+    }
+    if (tagEnd === -1) continue;
+    const tagStr = templateSrc.slice(tagStart, tagEnd + 1);
+    if (tagStr.includes("data-sk-field")) continue;
+    inserts.push({
+      offset: tagEnd,
+      text: ` data-sk-field={\`${sectionKey}.${groupFieldKey}.\${_i}.${field.key}\`}`
+    });
+  }
+  inserts.sort((a, b) => b.offset - a.offset);
+  for (const ins of inserts) {
+    templateSrc = templateSrc.slice(0, ins.offset) + ins.text + templateSrc.slice(ins.offset);
+  }
+  return templateSrc;
+}
+function detectIndent(source, offset) {
+  let lineStart = offset;
+  while (lineStart > 0 && source[lineStart - 1] !== "\n") lineStart--;
+  return source.slice(lineStart, offset);
+}
+function patchSectionId(source, ast, sectionKey, edits, options) {
+  const templateChildren = (ast.children ?? []).filter((c) => c.type !== "frontmatter");
+  let rootElement = null;
+  if (options?.mode === "page") {
+    let findFirstHtmlElement2 = function(nodes) {
+      for (const child of nodes) {
+        if (!isElement(child)) continue;
+        if (child.name && /^[a-z]/.test(child.name)) return child;
+        const inner = findFirstHtmlElement2(child.children ?? []);
+        if (inner) return inner;
+      }
+      return null;
+    };
+    var findFirstHtmlElement = findFirstHtmlElement2;
+    rootElement = findFirstHtmlElement2(templateChildren);
+  } else {
+    for (const child of templateChildren) {
+      if (isElement(child)) {
+        rootElement = child;
+        break;
+      }
+    }
+  }
+  if (!rootElement) return;
+  const hasId = rootElement.attributes?.some((a) => a.name === "id");
+  if (hasId) return;
+  addAttributeToElement(source, rootElement, `id="section-${sectionKey}"`, edits);
+}
+function extractVarName(frontmatter) {
+  const propsMatch = frontmatter.match(/const\s*\{\s*data\s*:\s*(\w+)\s*\}/);
+  if (propsMatch) return propsMatch[1];
+  const getSectionMatch = frontmatter.match(/(?:const|let)\s+(\w+)\s*=.*getSection/);
+  if (getSectionMatch) return getSectionMatch[1];
+  return null;
+}
+function isElement(node) {
+  return (node.type === "element" || node.type === "component" || node.type === "custom-element") && Array.isArray(node.attributes);
+}
+function walkAst(node, callback, parent = null) {
+  callback(node, parent);
+  if (node.children) {
+    for (const child of node.children) {
+      walkAst(child, callback, node);
+    }
+  }
+}
+function findFirstChildElement(node) {
+  if (!node.children) return null;
+  for (const child of node.children) {
+    if (isElement(child)) return child;
+    const deeper = findFirstChildElement(child);
+    if (deeper) return deeper;
+  }
+  return null;
+}
+function addAttributeToElement(source, element, attrStr, edits) {
+  const approxStart = element.position?.start?.offset;
+  if (approxStart == null) return;
+  const tagName = element.name;
+  if (!tagName) return;
+  const searchStart = Math.max(0, approxStart - 10);
+  const tagPattern = `<${tagName}`;
+  const tagIdx = source.indexOf(tagPattern, searchStart);
+  if (tagIdx === -1 || tagIdx > approxStart + 10) return;
+  const insertOffset = findOpeningTagEnd(source, tagIdx);
+  if (insertOffset === -1) return;
+  edits.push({
+    offset: insertOffset,
+    deleteCount: 0,
+    insert: ` ${attrStr}`
+  });
+}
+function findOpeningTagEnd(source, startOffset) {
+  let inQuote = null;
+  let inExpr = 0;
+  for (let i = startOffset; i < source.length; i++) {
+    const ch = source[i];
+    if (inQuote) {
+      if (ch === inQuote && source[i - 1] !== "\\") inQuote = null;
+      continue;
+    }
+    if (ch === "{") {
+      inExpr++;
+      continue;
+    }
+    if (ch === "}" && inExpr > 0) {
+      inExpr--;
+      continue;
+    }
+    if (inExpr > 0) continue;
+    if (ch === '"' || ch === "'") {
+      inQuote = ch;
+      continue;
+    }
+    if (ch === ">") return i;
+  }
+  return -1;
+}
+function applyEdits(source, edits) {
+  if (edits.length === 0) return source;
+  const sorted = [...edits].sort((a, b) => b.offset - a.offset);
+  let result = source;
+  for (const edit of sorted) {
+    result = result.slice(0, edit.offset) + edit.insert + result.slice(edit.offset + edit.deleteCount);
+  }
+  return result;
+}
+function removeOldVarDeclarations(source, fields, repeatedGroups, cmsVarName = "skData") {
+  const fmStart = source.indexOf("---");
+  if (fmStart === -1) return source;
+  const fmEnd = source.indexOf("---", fmStart + 3);
+  if (fmEnd === -1) return source;
+  let frontmatter = source.slice(fmStart + 4, fmEnd);
+  const fieldKeys = new Set(fields.map((f) => f.key));
+  if (repeatedGroups) {
+    for (const g of repeatedGroups) {
+      for (const f of g.fields) {
+        for (const pos of f.positions) {
+          if (pos?.source) fieldKeys.add(pos.source);
+        }
+      }
+    }
+  }
+  const removals = [];
+  const aliases = [];
+  const templatePart = source.slice(fmEnd + 3);
+  for (const key of fieldKeys) {
+    const varDeclRegex = new RegExp(`(?:const|let)\\s+${key}\\s*=\\s*`);
+    const declMatch = varDeclRegex.exec(frontmatter);
+    if (!declMatch) continue;
+    const lineStart = frontmatter.lastIndexOf("\n", declMatch.index) + 1;
+    const linePrefix = frontmatter.slice(lineStart, declMatch.index).trim();
+    if (linePrefix === "export") continue;
+    const declStart = declMatch.index;
+    const afterEquals = declStart + declMatch[0].length;
+    const rhsRaw = frontmatter.slice(afterEquals);
+    const leadingWs = rhsRaw.length - rhsRaw.trimStart().length;
+    const rhs = rhsRaw.trimStart();
+    let valueEnd;
+    if (rhs.startsWith("[") || rhs.startsWith("{")) {
+      const open = rhs[0];
+      const close = open === "[" ? "]" : "}";
+      let depth = 1;
+      let inStr = null;
+      let i = 1;
+      for (; i < rhs.length && depth > 0; i++) {
+        const ch = rhs[i];
+        if (inStr) {
+          if (ch === inStr && rhs[i - 1] !== "\\") inStr = null;
+          continue;
+        }
+        if (ch === "'" || ch === '"' || ch === "`") {
+          inStr = ch;
+          continue;
+        }
+        if (ch === open) depth++;
+        if (ch === close) depth--;
+      }
+      valueEnd = i;
+    } else {
+      const lineEnd = rhs.indexOf("\n");
+      valueEnd = lineEnd === -1 ? rhs.length : lineEnd;
+    }
+    let end = afterEquals + leadingWs + valueEnd;
+    if (end < frontmatter.length && frontmatter[end] === ";") end++;
+    if (end < frontmatter.length && frontmatter[end] === "\n") end++;
+    const stillReferenced = new RegExp(`\\b${key}[.([\\[]`).test(templatePart);
+    if (stillReferenced) {
+      aliases.push(`const ${key} = ${cmsVarName}?.${key} ?? []`);
+    }
+    removals.push({ start: declStart, end });
+  }
+  if (removals.length === 0) return source;
+  removals.sort((a, b) => b.start - a.start);
+  for (const { start, end } of removals) {
+    frontmatter = frontmatter.slice(0, start) + frontmatter.slice(end);
+  }
+  if (aliases.length > 0) {
+    frontmatter = frontmatter.trimEnd() + "\n" + aliases.join("\n") + "\n";
+  }
+  frontmatter = frontmatter.replace(/\n{3,}/g, "\n\n");
+  return source.slice(0, fmStart + 4) + frontmatter + source.slice(fmEnd);
+}
+function stripTemplateFallbacks(source) {
+  const fallbacks = {};
+  let result = source;
+  result = result.replace(
+    /set:html=\{(\w+)\?\.(\w+)\s*\?\?\s*(?:`([\s\S]*?)`|'([^']*)'|"([^"]*)")\}/g,
+    (_match, varName, fieldKey, tq, sq, dq) => {
+      const value = (tq ?? sq ?? dq ?? "").trim();
+      fallbacks[fieldKey] = value;
+      return `set:html={${varName}?.${fieldKey}}`;
+    }
+  );
+  result = result.replace(
+    /\((\w+)\?\.(\w+)\s*\?\?\s*\[([^\]]*)\]\)\.map\(/gs,
+    (_match, varName, fieldKey, itemsRaw) => {
+      const items = [];
+      const itemRe = /`([^`]*)`|'([^']*)'|"([^"]*)"/g;
+      let m;
+      while ((m = itemRe.exec(itemsRaw)) !== null) {
+        items.push(m[1] ?? m[2] ?? m[3] ?? "");
+      }
+      if (items.length > 0) fallbacks[fieldKey] = items;
+      return `(${varName}?.${fieldKey} ?? []).map(`;
+    }
+  );
+  return { source: result, fallbacks };
+}
+
+export {
+  patchTemplateForFields,
+  convertToSetHtml,
+  stripTemplateFallbacks
+};