@setzkasten-cms/astro-admin 1.4.0 → 1.4.1

package/dist/chunk-K22A4ZBS.js

@@ -0,0 +1,1574 @@
+// src/init/astro-detector.ts
+function findAstroPages(files, projectRoot) {
+  const pagesDir = projectRoot ? `${projectRoot}/src/pages/` : "src/pages/";
+  const pages = [];
+  for (const file of files) {
+    if (file.type !== "blob") continue;
+    if (!file.path.startsWith(pagesDir)) continue;
+    if (!file.path.endsWith(".astro")) continue;
+    const relativePath = file.path.slice(pagesDir.length);
+    if (relativePath.startsWith("api/")) continue;
+    if (relativePath.includes("[")) continue;
+    if (relativePath.includes("admin")) continue;
+    if (relativePath === "preview.astro") continue;
+    const name = relativePath.replace(/\.astro$/, "");
+    const isIndex = name === "index" || name.endsWith("/index");
+    const pageKey = isIndex ? name === "index" ? "index" : name.replace(/\/index$/, "") : name;
+    pages.push({
+      filePath: file.path,
+      pageKey,
+      label: pageKey === "index" ? "Startseite" : pageKey
+    });
+  }
+  pages.sort((a, b) => {
+    if (a.pageKey === "index") return -1;
+    if (b.pageKey === "index") return 1;
+    return a.pageKey.localeCompare(b.pageKey);
+  });
+  return pages;
+}
+function extractSectionImports(pageSource, pagePath, allFiles, projectRoot) {
+  const imports = [];
+  const importRegex = /import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = importRegex.exec(pageSource)) !== null) {
+    const componentName = match[1];
+    const importPath = match[2];
+    const isSectionPath = importPath.includes("section");
+    const isSectionName = componentName.endsWith("Section");
+    if (!isSectionPath && !isSectionName) continue;
+    if (!importPath.endsWith(".astro") && !importPath.match(/\/[A-Z]/)) continue;
+    const sectionKey = deriveSectionKey(componentName);
+    const resolvedPath = resolveImportPath(importPath, pagePath, allFiles, projectRoot);
+    imports.push({
+      componentName,
+      importPath,
+      resolvedPath,
+      sectionKey
+    });
+  }
+  return imports;
+}
+function extractLayoutImport(pageSource, pagePath, allFiles, projectRoot) {
+  const importRegex = /import\s+(\w+)\s+from\s+['"]([^'"]+)['"]/g;
+  let match;
+  while ((match = importRegex.exec(pageSource)) !== null) {
+    const componentName = match[1];
+    const importPath = match[2];
+    if (!importPath.includes("layout") && !componentName.includes("Layout")) continue;
+    if (!importPath.endsWith(".astro") && !importPath.match(/\/[A-Z]/)) continue;
+    const resolvedPath = resolveImportPath(importPath, pagePath, allFiles, projectRoot);
+    return { componentName, importPath, resolvedPath };
+  }
+  return null;
+}
+function deriveSectionKey(componentName) {
+  const stripped = componentName.replace(/Section$/, "");
+  return stripped.charAt(0).toLowerCase() + stripped.slice(1);
+}
+function resolveImportPath(importPath, fromFile, allFiles, projectRoot) {
+  if (importPath.startsWith("@/") || importPath.startsWith("~/")) {
+    const aliasPath = importPath.replace(/^[@~]\//, "");
+    const candidates = [
+      `${projectRoot}/src/${aliasPath}`,
+      `${projectRoot}/src/${aliasPath}.astro`
+    ];
+    for (const candidate of candidates) {
+      if (allFiles.some((f) => f.path === candidate)) return candidate;
+    }
+    return null;
+  }
+  if (importPath.startsWith(".")) {
+    const fromDir = fromFile.substring(0, fromFile.lastIndexOf("/"));
+    const parts = importPath.split("/");
+    let currentDir = fromDir;
+    for (const part of parts) {
+      if (part === ".") continue;
+      if (part === "..") {
+        currentDir = currentDir.substring(0, currentDir.lastIndexOf("/"));
+      } else {
+        currentDir = `${currentDir}/${part}`;
+      }
+    }
+    const resolved = currentDir;
+    const candidates = [resolved, `${resolved}.astro`];
+    for (const candidate of candidates) {
+      if (allFiles.some((f) => f.path === candidate)) return candidate;
+    }
+  }
+  return null;
+}
+
+// src/init/astro-section-analyzer-v2.ts
+import { parse } from "@astrojs/compiler";
+import { inferFields } from "@setzkasten-cms/core/init";
+
+// src/init/field-label-enricher.ts
+function enrichFieldLabels(fields) {
+  for (const field of fields) {
+    const label = inferLabel(field);
+    if (label) field.label = label;
+  }
+}
+function inferLabel(field) {
+  if (/^h[1-6]$/.test(field.tag)) return "\xDCberschrift";
+  if (field.type === "array") return "Liste";
+  if (field.tag === "a" && field.type === "link") return "Link";
+  if (field.tag === "a" && field.type === "text") return "Link-Text";
+  const rawValues = field.defaultValues.filter((v) => typeof v === "string");
+  const cleanValues = rawValues.map((v) => stripSpecialChars(v));
+  if (rawValues.length === 0) return void 0;
+  if (rawValues.every((v) => v.trim().length > 0 && v.trim().length < 20 && !v.includes(" "))) {
+    return "Label";
+  }
+  if (rawValues.some((v) => /[€$£¥₹]/.test(v)) && rawValues.every((v) => v.length < 25)) {
+    return "Preis";
+  }
+  if (rawValues.every((v) => /\d/.test(v) && v.length < 25)) {
+    return "Preis";
+  }
+  if (cleanValues.every((v) => v.length > 40)) {
+    return "Beschreibung";
+  }
+  if (field.tag === "p" && cleanValues.every((v) => v.length > 15)) {
+    return "Beschreibung";
+  }
+  return void 0;
+}
+function stripSpecialChars(str) {
+  return str.replace(/[^a-zA-Z0-9äöüÄÖÜß\s]/g, "").trim();
+}
+
+// src/init/astro-section-analyzer-v2.ts
+function walkAst(node, callback, parent = null) {
+  callback(node, parent);
+  if (node.children) {
+    for (const child of node.children) {
+      walkAst(child, callback, node);
+    }
+  }
+}
+async function analyzeAstroSection(source, sectionKey, componentName, componentPath, options) {
+  const isPageMode = options?.mode === "page";
+  const alreadyIntegrated = source.includes("data-sk-field") || source.includes("getSection(") || source.includes("setzkasten:content");
+  const { frontmatter, template, templateOffset } = splitAstroFile(source);
+  const variables = extractFrontmatterVariables(frontmatter).filter((name) => {
+    const propUsageRegex = new RegExp(`\\w+={${name}}`);
+    if (propUsageRegex.test(template)) return false;
+    const fallbackRegex = new RegExp(`(?:\\?\\?|\\|\\|)\\s*${name}\\b`);
+    if (fallbackRegex.test(frontmatter) || fallbackRegex.test(template)) return false;
+    if (!isPageMode) {
+      const hasMapUsage = new RegExp(`\\b${name}\\.map\\s*\\(`).test(template);
+      const hasNonMapUsage = new RegExp(`\\b${name}\\b(?!\\.map)`).test(template);
+      if (hasMapUsage && !hasNonMapUsage) return false;
+    }
+    return true;
+  });
+  const variableFields = inferFields(variables, template);
+  for (const field of variableFields) {
+    if (!field.defaultValue) {
+      field.defaultValue = extractFrontmatterValue(frontmatter, field.key);
+    }
+  }
+  const { fields: templateFields, repeatedGroups } = await extractTemplateFields(template, frontmatter);
+  const posAdjust = templateOffset;
+  for (const group of repeatedGroups) {
+    for (const inst of group.instances) {
+      inst.start += posAdjust;
+      inst.end += posAdjust;
+    }
+    for (const field of group.fields) {
+      for (let i = 0; i < field.positions.length; i++) {
+        const pos = field.positions[i];
+        if (pos) {
+          pos.offset += posAdjust;
+        }
+      }
+    }
+  }
+  for (const group of repeatedGroups) {
+    if (group.classAttrs) {
+      for (const instAttrs of group.classAttrs) {
+        for (const a of instAttrs) {
+          a.sourceOffset += posAdjust;
+        }
+      }
+    }
+  }
+  for (const group of repeatedGroups) {
+    enrichFieldLabels(group.fields);
+  }
+  for (const field of variableFields) {
+    const usageRegex = new RegExp(`\\{\\s*(?:\\w+\\.)?${field.key}(?:[.\\s}(])`, "s");
+    const usageMatch = usageRegex.exec(template);
+    if (usageMatch) {
+      ;
+      field._pos = usageMatch.index;
+    } else {
+      const mapUsage = template.indexOf(`${field.key}.map(`);
+      field._pos = mapUsage !== -1 ? mapUsage : Infinity;
+    }
+  }
+  const existingKeys = new Set(variableFields.map((f) => f.key));
+  const allFields = [
+    ...variableFields,
+    ...templateFields.filter((f) => !existingKeys.has(f.key))
+  ];
+  allFields.sort((a, b) => (a._pos ?? Infinity) - (b._pos ?? Infinity));
+  const fields = allFields.map(({ ...field }) => {
+    delete field._pos;
+    return field;
+  });
+  const analyzerResult = {
+    sectionKey,
+    componentName,
+    componentPath,
+    alreadyIntegrated,
+    fields,
+    repeatedGroups,
+    frontmatter,
+    template
+  };
+  return {
+    key: sectionKey,
+    componentName,
+    componentPath,
+    fields,
+    alreadyIntegrated,
+    _analyzerResult: analyzerResult
+  };
+}
+function splitAstroFile(source) {
+  if (!source.startsWith("---")) return { frontmatter: "", template: source, templateOffset: 0 };
+  const endIdx = source.indexOf("\n---", 3);
+  if (endIdx === -1) return { frontmatter: "", template: source, templateOffset: 0 };
+  const frontmatter = source.slice(4, endIdx);
+  let templateStart = endIdx + 4;
+  while (templateStart < source.length && source[templateStart] === " ") templateStart++;
+  if (templateStart < source.length && source[templateStart] === "\n") templateStart++;
+  return { frontmatter, template: source.slice(templateStart), templateOffset: templateStart };
+}
+function stripTemplateLiterals(source) {
+  let result = "";
+  let i = 0;
+  while (i < source.length) {
+    if (source[i] === "`") {
+      i++;
+      let depth = 0;
+      while (i < source.length) {
+        if (source[i] === "\\") {
+          i += 2;
+          continue;
+        }
+        if (source[i] === "$" && source[i + 1] === "{") {
+          depth++;
+          i += 2;
+          continue;
+        }
+        if (source[i] === "{") {
+          depth++;
+          i++;
+          continue;
+        }
+        if (source[i] === "}" && depth > 0) {
+          depth--;
+          i++;
+          continue;
+        }
+        if (source[i] === "`" && depth === 0) {
+          i++;
+          break;
+        }
+        i++;
+      }
+      result += "``";
+    } else {
+      result += source[i];
+      i++;
+    }
+  }
+  return result;
+}
+function extractFrontmatterVariables(frontmatter) {
+  const stripped = stripTemplateLiterals(frontmatter);
+  const variables = [];
+  const constRegex = /(?:const|let)\s+(\w+)\s*=\s*(.*)/g;
+  let match;
+  while ((match = constRegex.exec(stripped)) !== null) {
+    const name = match[1];
+    const rhs = match[2]?.trim() ?? "";
+    if (isInternalVariable(name)) continue;
+    const charBefore = match.index > 0 ? stripped.slice(Math.max(0, match.index - 10), match.index) : "";
+    if (/export\s*$/.test(charBefore)) continue;
+    if (/\.\s*map\s*\(/.test(rhs) || /\w+\?\.\w+/.test(rhs)) continue;
+    if (/^\[/.test(rhs) && /^default/i.test(name)) continue;
+    if (/^\(|^\w+\s*=>/.test(rhs) && /=>/.test(rhs)) continue;
+    if (/\bget(?:Page|Pages|Section|CollectionEntry)\s*\(/.test(rhs)) continue;
+    variables.push(name);
+  }
+  const propsRegex = /const\s+\{\s*([^}]+)\}\s*=\s*Astro\.props/;
+  const propsMatch = frontmatter.match(propsRegex);
+  if (propsMatch) {
+    const props = propsMatch[1].split(",").map((p) => p.trim().split(":")[0].split("=")[0].trim()).filter((p) => p && !isInternalVariable(p));
+    variables.push(...props);
+  }
+  const interfaceRegex = /interface\s+Props\s*\{([^}]+)\}/s;
+  const interfaceMatch = frontmatter.match(interfaceRegex);
+  if (interfaceMatch) {
+    const fields = interfaceMatch[1].split("\n").map((line) => line.trim()).filter((line) => line && !line.startsWith("//")).map((line) => line.match(/^(\w+)\??:/)?.[1]).filter((name) => !!name && !isInternalVariable(name));
+    variables.push(...fields);
+  }
+  return [...new Set(variables)];
+}
+function extractFrontmatterValue(frontmatter, varName) {
+  const arrayStartRegex = new RegExp(`(?:const|let)\\s+${varName}\\s*=\\s*\\[`);
+  const arrayStartMatch = arrayStartRegex.exec(frontmatter);
+  if (arrayStartMatch) {
+    const startIdx = arrayStartMatch.index + arrayStartMatch[0].length;
+    let depth = 1;
+    let endIdx = startIdx;
+    for (let i = startIdx; i < frontmatter.length && depth > 0; i++) {
+      if (frontmatter[i] === "[") depth++;
+      else if (frontmatter[i] === "]") depth--;
+      endIdx = i;
+    }
+    const content = frontmatter.slice(startIdx, endIdx);
+    const isObjectArray = /\{/.test(content);
+    const isStringArray = /^\s*['"]/.test(content.trim());
+    return extractInlineArrayValues(content, isObjectArray, isStringArray);
+  }
+  const strRegex = new RegExp(`(?:const|let)\\s+${varName}\\s*=\\s*['"]([^'"]+)['"]`);
+  const strMatch = frontmatter.match(strRegex);
+  if (strMatch) return strMatch[1];
+  const numRegex = new RegExp(`(?:const|let)\\s+${varName}\\s*=\\s*(\\d+(?:\\.\\d+)?)`);
+  const numMatch = frontmatter.match(numRegex);
+  if (numMatch) return Number(numMatch[1]);
+  return void 0;
+}
+function isInternalVariable(name) {
+  const skip = /* @__PURE__ */ new Set([
+    "Astro",
+    "props",
+    "data",
+    "class",
+    "className",
+    "style",
+    "id",
+    "slot",
+    "Fragment",
+    "Component",
+    "frontmatter",
+    "url",
+    "site",
+    "generator",
+    "redirect",
+    "response",
+    "request",
+    "cookies",
+    "params",
+    "slots"
+  ]);
+  return skip.has(name) || name.startsWith("_");
+}
+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) => offset <= 0 ? 0 : offset >= map.length ? source.length : 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);
+  }
+}
+var WRAPPER_OFFSET = 8;
+function nodeOffset(node) {
+  return (node.position?.start?.offset ?? Infinity) - WRAPPER_OFFSET;
+}
+function nodeEnd(node) {
+  return (node.position?.end?.offset ?? Infinity) - WRAPPER_OFFSET;
+}
+function getClassValue(node) {
+  if (!node.attributes) return "";
+  const classAttr = node.attributes.find((a) => a.name === "class" || a.name === "className");
+  return classAttr?.value ?? "";
+}
+function getAttr(node, name) {
+  return node.attributes?.find((a) => a.name === name);
+}
+function isAriaHidden(node) {
+  const attr = getAttr(node, "aria-hidden");
+  return attr?.value === "true";
+}
+function extractTextContent(node, stripCmsBound = false) {
+  let text = "";
+  if (node.type === "text") {
+    text += node.value ?? "";
+  } else if (node.type === "expression") {
+    const exprCode = (node.children ?? []).map((c) => c.value ?? "").join("");
+    if (stripCmsBound && /^\s*\(?\s*\w+\?\.\s*\w+/.test(exprCode)) return "";
+    const fallbackMatch = exprCode.match(/\?\?\s*['"]([^'"]+)['"]/);
+    if (fallbackMatch) text += fallbackMatch[1];
+  } else if (node.children) {
+    for (const child of node.children) {
+      text += extractTextContent(child, stripCmsBound);
+    }
+  }
+  return text;
+}
+var INLINE_FORMATTING_TAGS = /* @__PURE__ */ new Set([
+  "strong",
+  "b",
+  "em",
+  "i",
+  "mark",
+  "code",
+  "del",
+  "ins",
+  "sub",
+  "sup",
+  "a",
+  "abbr",
+  "cite",
+  "u",
+  "s",
+  "small",
+  "span"
+  // color/style spans inside text content
+]);
+function hasInlineFormatting(node) {
+  if (!node.children) return false;
+  for (const child of node.children) {
+    if (child.type === "element" && INLINE_FORMATTING_TAGS.has(child.name ?? "")) return true;
+    if (hasInlineFormatting(child)) return true;
+  }
+  return false;
+}
+function collectClassAttrs(node, path = "", source) {
+  const result = [];
+  if (node.type === "element" && node.attributes && source) {
+    const classAttr = node.attributes.find((a) => a.name === "class" && a.kind === "quoted");
+    if (classAttr && classAttr.value) {
+      const elemStart = nodeOffset(node);
+      const tagEndGuess = source.indexOf(">", elemStart);
+      if (tagEndGuess !== -1) {
+        const classIdx = source.indexOf('class="', elemStart);
+        if (classIdx !== -1 && classIdx < tagEndGuess) {
+          const sourceLength = 7 + classAttr.value.length + 1;
+          result.push({
+            path,
+            value: classAttr.value,
+            sourceOffset: classIdx,
+            sourceLength
+          });
+        }
+      }
+    }
+  }
+  if (node.children) {
+    const tagCounts = {};
+    for (const child of node.children) {
+      if (child.type === "element" && child.name) {
+        const tag = child.name;
+        const nth = tagCounts[tag] ?? 0;
+        tagCounts[tag] = nth + 1;
+        const childPath = path ? `${path}/${tag}:${nth}` : `${tag}:${nth}`;
+        result.push(...collectClassAttrs(child, childPath, source));
+      } else if (child.type === "expression" && child.children) {
+        for (const exprChild of child.children) {
+          if (exprChild.type === "element" && exprChild.name) {
+            const tag = exprChild.name;
+            const nth = tagCounts[tag] ?? 0;
+            tagCounts[tag] = nth + 1;
+            const childPath = path ? `${path}/${tag}:${nth}` : `${tag}:${nth}`;
+            result.push(...collectClassAttrs(exprChild, childPath, source));
+          }
+        }
+      }
+    }
+  }
+  return result;
+}
+function containsElement(node, tagName) {
+  if (node.type === "element" && node.name === tagName) return true;
+  if (node.children) {
+    for (const child of node.children) {
+      if (containsElement(child, tagName)) return true;
+    }
+  }
+  return false;
+}
+function serializeNode(node) {
+  if (node.type === "text") return node.value ?? "";
+  if (node.type === "expression") {
+    const inner = (node.children ?? []).map((c) => c.value ?? "").join("");
+    return `{${inner}}`;
+  }
+  let result = "";
+  if (node.type === "element" || node.type === "component") {
+    result += `<${node.name ?? ""}`;
+    for (const attr of node.attributes ?? []) {
+      if (attr.kind === "quoted") result += ` ${attr.name}="${attr.value}"`;
+      else if (attr.kind === "expression") result += ` ${attr.name}={${attr.value}}`;
+      else if (attr.kind === "empty") result += ` ${attr.name}`;
+      else result += ` ${attr.name}="${attr.value}"`;
+    }
+    result += ">";
+  }
+  for (const child of node.children ?? []) {
+    result += serializeNode(child);
+  }
+  if ((node.type === "element" || node.type === "component") && node.name) {
+    result += `</${node.name}>`;
+  }
+  return result;
+}
+function camelToLabel(str) {
+  return str.replace(/([A-Z])/g, " $1").replace(/^./, (s) => s.toUpperCase()).trim();
+}
+function inferInnerFieldType(name) {
+  const n = name.toLowerCase();
+  if (/icon/.test(n)) return "icon";
+  if (/image|img|photo|avatar|logo|thumbnail|src/.test(n)) return "image";
+  if (/color|colour/.test(n)) return "color";
+  if (/count|amount|number|quantity|total|rating|score|percent|order|index|size|width|height/.test(n)) return "number";
+  if (/^is[A-Z]/.test(name) || /^has[A-Z]/.test(name) || /enabled|disabled|visible|hidden|active|checked|selected|highlight|accent|featured/.test(n)) return "boolean";
+  return "text";
+}
+function extractInlineArrayValues(arrayContent, isObjectArray, isStringArray) {
+  if (isStringArray || !isObjectArray) {
+    const strings = [];
+    const strRegex = /['"]([^'"]+)['"]/g;
+    let sm;
+    while ((sm = strRegex.exec(arrayContent)) !== null) strings.push(sm[1]);
+    return strings;
+  }
+  const objects = [];
+  let i = 0;
+  while (i < arrayContent.length) {
+    if (arrayContent[i] === "{") {
+      const end = findMatchingBracket(arrayContent, i, "{", "}");
+      const objStr = arrayContent.slice(i + 1, end);
+      const obj = parseObjectLiteral(objStr);
+      if (Object.keys(obj).length > 0) objects.push(obj);
+      i = end + 1;
+    } else {
+      i++;
+    }
+  }
+  return objects;
+}
+function findMatchingBracket(source, start, open, close) {
+  let depth = 1;
+  let i = start + 1;
+  while (i < source.length && depth > 0) {
+    const ch = source[i];
+    if (ch === "'" || ch === '"') {
+      i++;
+      while (i < source.length && source[i] !== ch) i++;
+    } else if (ch === open) {
+      depth++;
+    } else if (ch === close) {
+      depth--;
+    }
+    i++;
+  }
+  return i - 1;
+}
+function parseObjectLiteral(objStr) {
+  const obj = {};
+  let i = 0;
+  while (i < objStr.length) {
+    while (i < objStr.length && /[\s,]/.test(objStr[i])) i++;
+    if (i >= objStr.length) break;
+    const keyMatch = objStr.slice(i).match(/^(\w+)\s*:\s*/);
+    if (!keyMatch) {
+      i++;
+      continue;
+    }
+    const key = keyMatch[1];
+    i += keyMatch[0].length;
+    const ch = objStr[i];
+    if (ch === "'" || ch === '"') {
+      let j = i + 1;
+      while (j < objStr.length && objStr[j] !== ch) j++;
+      obj[key] = objStr.slice(i + 1, j);
+      i = j + 1;
+    } else if (ch === "[") {
+      const end = findMatchingBracket(objStr, i, "[", "]");
+      const innerContent = objStr.slice(i + 1, end);
+      const hasObjects = /\{/.test(innerContent);
+      if (hasObjects) {
+        obj[key] = extractInlineArrayValues(innerContent, true, false);
+      } else {
+        const items = [];
+        const strRegex = /['"]([^'"]+)['"]/g;
+        let sm;
+        while ((sm = strRegex.exec(innerContent)) !== null) items.push(sm[1]);
+        obj[key] = items;
+      }
+      i = end + 1;
+    } else if (ch === "{") {
+      const end = findMatchingBracket(objStr, i, "{", "}");
+      obj[key] = parseObjectLiteral(objStr.slice(i + 1, end));
+      i = end + 1;
+    } else if (ch && /\d/.test(ch)) {
+      const numMatch = objStr.slice(i).match(/^(\d+(?:\.\d+)?)/);
+      if (numMatch) {
+        obj[key] = Number(numMatch[1]);
+        i += numMatch[0].length;
+      }
+    } else if (objStr.slice(i, i + 4) === "true") {
+      obj[key] = true;
+      i += 4;
+    } else if (objStr.slice(i, i + 5) === "false") {
+      obj[key] = false;
+      i += 5;
+    } else {
+      while (i < objStr.length && objStr[i] !== ",") i++;
+    }
+  }
+  return obj;
+}
+async function extractTemplateFields(template, frontmatter = "") {
+  const fields = [];
+  const usedKeys = /* @__PURE__ */ new Set();
+  const repeatedGroups = [];
+  let ast;
+  try {
+    const wrappedSource = `---
+---
+${template}`;
+    const result = await parse(wrappedSource);
+    ast = result.ast;
+    convertAstPositions(ast, buildByteToCharMap(wrappedSource));
+  } catch (err) {
+    console.error("[setzkasten] section-analyzer: parse() failed:", err);
+    return { fields, repeatedGroups };
+  }
+  function addField(field, pos) {
+    if (!usedKeys.has(field.key)) {
+      usedKeys.add(field.key);
+      let finalPos = pos ?? -1;
+      if (finalPos === -1) {
+        if (typeof field.defaultValue === "string" && field.defaultValue.length >= 3) {
+          finalPos = template.indexOf(field.defaultValue);
+        } else if (Array.isArray(field.defaultValue) && field.defaultValue.length > 0) {
+          const firstItem = typeof field.defaultValue[0] === "string" ? field.defaultValue[0] : typeof field.defaultValue[0] === "object" && field.defaultValue[0] ? Object.values(field.defaultValue[0])[0] : null;
+          if (typeof firstItem === "string" && firstItem.length >= 2) {
+            finalPos = template.indexOf(firstItem);
+          }
+        }
+      }
+      if (finalPos === -1) finalPos = template.indexOf(`?.${field.key}`);
+      if (finalPos === -1) {
+        const keyRegex = new RegExp(`(?<![\\w-])${field.key}(?![\\w-])`);
+        const keyMatch = keyRegex.exec(template);
+        if (keyMatch) finalPos = keyMatch.index;
+      }
+      fields.push({ ...field, _pos: finalPos === -1 ? Infinity : finalPos });
+    }
+  }
+  function numberedKey(base, count) {
+    return count === 1 ? base : `${base}${count}`;
+  }
+  function numberedLabel(base, count) {
+    return count === 1 ? base : `${base} ${count}`;
+  }
+  const ariaHiddenRanges = [];
+  walkAst(ast, (node) => {
+    if (node.type !== "element" && node.type !== "component") return;
+    const isHidden = isAriaHidden(node) || getAttr(node, "role")?.value === "img";
+    if (isHidden) {
+      const start = nodeOffset(node);
+      const end = node.position?.end?.offset ? node.position.end.offset - WRAPPER_OFFSET : start + 1;
+      ariaHiddenRanges.push({ start, end });
+    }
+  });
+  const mapExpressionRanges = [];
+  walkAst(ast, (node) => {
+    if (node.type !== "expression") return;
+    const exprCode = (node.children ?? []).map((c) => c.value ?? "").join("");
+    if (/\.map\s*\(/.test(exprCode)) {
+      const start = nodeOffset(node);
+      const end = node.position?.end?.offset ? node.position.end.offset - WRAPPER_OFFSET : start + 1;
+      mapExpressionRanges.push({ start, end });
+    }
+  });
+  const SEMANTIC_REPEATED_TAGS = /* @__PURE__ */ new Set(["article", "aside", "figure", "details", "blockquote"]);
+  const repeatedElementGroups = [];
+  const repeatedElementRanges = [];
+  walkAst(ast, (node) => {
+    if (node.type !== "element" && node.type !== "fragment") return;
+    if (!node.children || node.children.length < 2) return;
+    const childrenByTag = /* @__PURE__ */ new Map();
+    for (const child of node.children) {
+      if (child.type !== "element") continue;
+      const tag = child.name ?? "";
+      if (!tag) continue;
+      if (!childrenByTag.has(tag)) childrenByTag.set(tag, []);
+      childrenByTag.get(tag).push(child);
+    }
+    for (const [tag, siblings] of childrenByTag) {
+      if (siblings.length < 2) continue;
+      if (!SEMANTIC_REPEATED_TAGS.has(tag)) continue;
+      repeatedElementGroups.push({ tag, instances: siblings });
+      for (const inst of siblings) {
+        const start = nodeOffset(inst);
+        const end = inst.position?.end?.offset ? inst.position.end.offset - WRAPPER_OFFSET : start + 1;
+        repeatedElementRanges.push({ start, end });
+      }
+    }
+  });
+  walkAst(ast, (node) => {
+    if (node.type !== "element" || node.name !== "tbody") return;
+    const trRows = (node.children ?? []).filter((c) => c.type === "element" && c.name === "tr");
+    if (trRows.length < 2) return;
+    repeatedElementGroups.push({ tag: "tr", instances: trRows });
+    for (const row of trRows) {
+      const start = nodeOffset(row);
+      const end = row.position?.end?.offset ? row.position.end.offset - WRAPPER_OFFSET : start + 1;
+      repeatedElementRanges.push({ start, end });
+    }
+  });
+  function isInAriaHidden(offset) {
+    return ariaHiddenRanges.some((r) => offset >= r.start && offset < r.end);
+  }
+  function isInMapExpression(offset) {
+    return mapExpressionRanges.some((r) => offset >= r.start && offset < r.end);
+  }
+  function isInRepeatedElement(offset) {
+    return repeatedElementRanges.some((r) => offset >= r.start && offset < r.end);
+  }
+  const cmsBoundOffsets = /* @__PURE__ */ new Set();
+  walkAst(ast, (node) => {
+    if (node.type !== "expression") return;
+    const exprCode = (node.children ?? []).map((c) => c.value ?? "").join("");
+    const cmsVarMatch = exprCode.match(/^\s*\(?\s*\w+\?\.\s*(\w+)/);
+    if (cmsVarMatch) {
+      const fieldKey = cmsVarMatch[1];
+      const arrayFallbackMatch = exprCode.match(/\?\?\s*\[([^\]]*)\]\s*\)\.map\(/);
+      if (arrayFallbackMatch) {
+        const items = [];
+        const itemRe = /`([^`]*)`|'([^']*)'|"([^"]*)"/g;
+        let m;
+        while ((m = itemRe.exec(arrayFallbackMatch[1])) !== null) {
+          items.push(m[1] ?? m[2] ?? m[3] ?? "");
+        }
+        const hasFormatting = items.some((s) => /<[a-z]/.test(s));
+        addField({
+          key: fieldKey,
+          type: "array",
+          label: camelToLabel(fieldKey),
+          confidence: "high",
+          defaultValue: items.length > 0 ? items : void 0,
+          options: { arrayItem: { type: "text", ...hasFormatting ? { formatting: true } : {} } }
+        }, nodeOffset(node));
+      } else {
+        const strFallback = exprCode.match(/\?\?\s*(?:`([\s\S]*?)`|'([^']*)'|"([^"]*)")/);
+        const defaultValue = strFallback ? (strFallback[1] ?? strFallback[2] ?? strFallback[3] ?? "").trim() : void 0;
+        const hasHtml = defaultValue ? /<[a-z]/.test(defaultValue) : false;
+        addField({
+          key: fieldKey,
+          type: "text",
+          label: camelToLabel(fieldKey),
+          confidence: "high",
+          ...defaultValue ? { defaultValue } : {},
+          ...hasHtml ? { options: { formatting: true } } : {}
+        }, nodeOffset(node));
+      }
+      cmsBoundOffsets.add(nodeOffset(node));
+    }
+  });
+  walkAst(ast, (node) => {
+    if (node.type !== "element" && node.type !== "component") return;
+    for (const attr of node.attributes ?? []) {
+      if (attr.kind !== "expression") continue;
+      const cmsAttrMatch = attr.value.match(/^\s*\w+\?\.\s*(\w+)\s*\?\?\s*(?:`([\s\S]*?)`|'([^']*)'|"([^"]*)")/);
+      if (cmsAttrMatch) {
+        const fieldKey = cmsAttrMatch[1];
+        const fallback = (cmsAttrMatch[2] ?? cmsAttrMatch[3] ?? cmsAttrMatch[4] ?? "").trim();
+        const pos = attr.position?.start?.offset ? attr.position.start.offset - WRAPPER_OFFSET : nodeOffset(node);
+        const isSetHtml = attr.name === "set:html";
+        const fallbackHasHtml = fallback ? /<[a-z]/.test(fallback) : false;
+        const hasHtml = fallbackHasHtml || isSetHtml && !fallback;
+        addField({
+          key: fieldKey,
+          type: "text",
+          label: camelToLabel(fieldKey),
+          confidence: "high",
+          ...fallback ? { defaultValue: fallback } : {},
+          ...hasHtml ? { options: { formatting: true } } : {}
+        }, pos);
+        cmsBoundOffsets.add(nodeOffset(node));
+      }
+    }
+  });
+  function shouldSkipForContent(node) {
+    const offset = nodeOffset(node);
+    return isInAriaHidden(offset) || cmsBoundOffsets.has(offset) || isInRepeatedElement(offset);
+  }
+  function shouldSkipMapChild(node) {
+    return isInMapExpression(nodeOffset(node));
+  }
+  walkAst(ast, (node) => {
+    if (node.type !== "element") return;
+    if (node.name !== "p" && node.name !== "span") return;
+    if (shouldSkipForContent(node)) return;
+    const classVal = getClassValue(node);
+    if (!/uppercase|tracking-widest/.test(classVal)) return;
+    const text = extractTextContent(node, true).trim();
+    if (text.length >= 2 && text.length <= 80) {
+      addField({ key: "overline", type: "text", label: "Overline", confidence: "medium", defaultValue: text }, nodeOffset(node));
+    }
+  });
+  let headingCount = Array.from(usedKeys).filter((k) => k === "heading" || /^heading\d+$/.test(k)).length;
+  walkAst(ast, (node) => {
+    if (node.type !== "element") return;
+    if (!/^h[1-6]$/.test(node.name ?? "")) return;
+    if (shouldSkipForContent(node)) return;
+    const text = extractTextContent(node, true).replace(/\s+/g, " ").trim();
+    if (text.length >= 2) {
+      headingCount++;
+      const headingOpts = { required: true };
+      if (hasInlineFormatting(node)) headingOpts.formatting = true;
+      addField({
+        key: numberedKey("heading", headingCount),
+        type: "text",
+        label: numberedLabel("Heading", headingCount),
+        confidence: "high",
+        defaultValue: text,
+        options: headingOpts
+      }, nodeOffset(node));
+    }
+  });
+  let descCount = Array.from(usedKeys).filter((k) => k === "description" || /^description\d+$/.test(k)).length;
+  walkAst(ast, (node) => {
+    if (node.type !== "element") return;
+    if (node.name !== "p" && node.name !== "div") return;
+    if (shouldSkipForContent(node)) return;
+    const classVal = getClassValue(node);
+    const serialized = serializeNode(node);
+    if (/uppercase|tracking-widest/.test(classVal) && serialized.length < 250) return;
+    if (/text-2xl|text-3xl|text-\[11px\]|text-\[10px\]|text-\[9px\]|text-\[8px\]/.test(classVal)) return;
+    if (node.name === "div" && (containsElement(node, "a") || containsElement(node, "button"))) {
+      const hasMixedText = (node.children ?? []).some(
+        (c) => c.type === "text" && (c.value ?? "").trim().length > 0
+      );
+      if (!hasMixedText) return;
+    }
+    if (node.name === "div" && ["h1", "h2", "h3", "h4", "h5", "h6"].some((h) => containsElement(node, h))) return;
+    if (node.name === "div") {
+      const contentChildren = (node.children ?? []).filter((c) => c.type !== "text" || (c.value ?? "").trim().length > 0);
+      const hasOnlyElementChildren = contentChildren.length > 0 && contentChildren.every((c) => c.type === "element" || c.type === "component");
+      if (hasOnlyElementChildren) return;
+    }
+    const text = extractTextContent(node, true).replace(/\s+/g, " ").trim();
+    if (text.length < 15) return;
+    descCount++;
+    const descOpts = { multiline: true };
+    if (hasInlineFormatting(node)) descOpts.formatting = true;
+    addField({
+      key: numberedKey("description", descCount),
+      type: "text",
+      label: numberedLabel("Beschreibung", descCount),
+      confidence: "medium",
+      defaultValue: text,
+      options: descOpts
+    }, nodeOffset(node));
+  });
+  let richCount = 0;
+  walkAst(ast, (node) => {
+    if (node.type !== "element" && node.type !== "component") return;
+    const setHtmlAttr = node.attributes?.find((a) => a.name === "set:html");
+    if (!setHtmlAttr || setHtmlAttr.kind !== "expression") return;
+    const expr = setHtmlAttr.value.trim();
+    if (/^\w+\?\.\w+/.test(expr)) return;
+    if (expr.startsWith("'") || expr.startsWith('"') || expr.includes("??")) {
+      richCount++;
+      const strMatch = expr.match(/['"]([^'"]+)['"]/);
+      const fallbackMatch = expr.match(/\?\?\s*['"]([^'"]+)['"]/);
+      const value = fallbackMatch?.[1] ?? strMatch?.[1] ?? "";
+      addField({
+        key: numberedKey("richText", richCount),
+        type: "text",
+        label: numberedLabel("Rich Text", richCount),
+        confidence: "high",
+        defaultValue: value,
+        options: { multiline: true, formatting: true }
+      }, nodeOffset(node));
+    }
+  });
+  let ctaCount = 0;
+  walkAst(ast, (node) => {
+    if (node.type !== "element") return;
+    if (node.name !== "a" && node.name !== "button") return;
+    if (shouldSkipForContent(node)) return;
+    const classVal = getClassValue(node);
+    if (!/rounded|px-|py-|font-semibold|bg-/.test(classVal)) return;
+    const text = extractTextContent(node, true).replace(/\s+/g, " ").trim();
+    if (text.length >= 2 && text.length <= 60) {
+      ctaCount++;
+      addField({
+        key: numberedKey("ctaText", ctaCount),
+        type: "text",
+        label: numberedLabel("Button Text", ctaCount),
+        confidence: "medium",
+        defaultValue: text
+      }, nodeOffset(node));
+    }
+  });
+  let linkCount = 0;
+  walkAst(ast, (node) => {
+    if (node.type !== "element" || node.name !== "a") return;
+    if (shouldSkipForContent(node)) return;
+    const classVal = getClassValue(node);
+    if (!/rounded|px-|py-|font-semibold|bg-/.test(classVal)) return;
+    const hrefAttr = getAttr(node, "href");
+    if (!hrefAttr) return;
+    let href;
+    if (hrefAttr.kind === "quoted") {
+      href = hrefAttr.value;
+    } else if (hrefAttr.kind === "expression") {
+      if (/^\s*\w+\?\.\w+/.test(hrefAttr.value)) return;
+      const fallback = hrefAttr.value.match(/\?\?\s*['"]([^'"]+)['"]/);
+      if (fallback) href = fallback[1];
+    }
+    if (!href) return;
+    if (href.startsWith("#") || href.startsWith("javascript:")) return;
+    linkCount++;
+    addField({
+      key: numberedKey("ctaLink", linkCount),
+      type: "text",
+      label: numberedLabel("Button Link", linkCount),
+      confidence: "medium",
+      defaultValue: href
+    }, nodeOffset(node));
+  });
+  let imgCount = 0;
+  let altCount = 0;
+  walkAst(ast, (node) => {
+    if (node.type !== "element" && node.type !== "component") return;
+    const tagName = node.name ?? "";
+    if (tagName !== "img" && tagName !== "Image" && tagName !== "picture") return;
+    if (shouldSkipForContent(node)) return;
+    const srcAttr = getAttr(node, "src");
+    if (srcAttr) {
+      let src;
+      if (srcAttr.kind === "quoted") src = srcAttr.value;
+      else if (srcAttr.kind === "expression") {
+        const strMatch = srcAttr.value.match(/['"]([^'"]+)['"]/);
+        if (strMatch) src = strMatch[1];
+      }
+      if (src) {
+        imgCount++;
+        addField({
+          key: numberedKey("image", imgCount),
+          type: "image",
+          label: numberedLabel("Bild", imgCount),
+          confidence: "high",
+          defaultValue: { path: src.trim(), alt: "" }
+        }, nodeOffset(node));
+      }
+    }
+    if (tagName === "img" || tagName === "Image") {
+      const altAttr = getAttr(node, "alt");
+      if (altAttr && altAttr.kind === "quoted" && altAttr.value.trim().length >= 2) {
+        altCount++;
+        addField({
+          key: numberedKey("imageAlt", altCount),
+          type: "text",
+          label: numberedLabel("Bild Alt-Text", altCount),
+          confidence: "medium",
+          defaultValue: altAttr.value.trim()
+        }, nodeOffset(node));
+      }
+    }
+  });
+  let iconCount = 0;
+  walkAst(ast, (node, parentNode) => {
+    if (node.type !== "element" || node.name !== "svg") return;
+    if (shouldSkipForContent(node) || shouldSkipMapChild(node)) return;
+    const svgSource = serializeNode(node);
+    if (svgSource.length < 100) return;
+    if (parentNode && (parentNode.name === "a" || parentNode.name === "button")) return;
+    iconCount++;
+    addField({
+      key: numberedKey("icon", iconCount),
+      type: "icon",
+      label: numberedLabel("Icon", iconCount),
+      confidence: "low"
+    }, nodeOffset(node));
+  });
+  let foundIconProp = false;
+  walkAst(ast, (node) => {
+    if (foundIconProp) return;
+    if (node.type !== "component") return;
+    if (shouldSkipMapChild(node)) return;
+    const iconAttr = getAttr(node, "icon");
+    if (iconAttr) {
+      addField({ key: "icon", type: "icon", label: "Icon", confidence: "high" }, nodeOffset(node));
+      foundIconProp = true;
+    }
+  });
+  let arrayCount = 0;
+  walkAst(ast, (node) => {
+    if (node.type !== "expression") return;
+    const exprCode = (node.children ?? []).map((c) => c.value ?? "").join("");
+    const inlineArrayMatch = exprCode.match(/^\s*\[([\s\S]*?)\]\s*\.map\s*\(\s*\(?\s*(\{[^}]*\}|\w+)/);
+    if (!inlineArrayMatch) return;
+    arrayCount++;
+    const arrayContent = inlineArrayMatch[1];
+    const callbackParam = inlineArrayMatch[2];
+    let objectKeys = [];
+    if (callbackParam.startsWith("{")) {
+      objectKeys = callbackParam.replace(/[{}]/g, "").split(",").map((p) => p.trim().split(":")[0].trim()).filter((p) => p && !p.startsWith("..."));
+    } else {
+      const firstObjMatch = arrayContent.match(/\{\s*([\s\S]*?)\}/);
+      if (firstObjMatch) {
+        const keyRegex = /(\w+)\s*:/g;
+        let km;
+        while ((km = keyRegex.exec(firstObjMatch[1])) !== null) objectKeys.push(km[1]);
+      }
+      if (objectKeys.length === 0) {
+        const accessRegex = new RegExp(`${callbackParam}\\.(\\w+)`, "g");
+        let am;
+        const accessedProps = /* @__PURE__ */ new Set();
+        while ((am = accessRegex.exec(exprCode)) !== null) accessedProps.add(am[1]);
+        objectKeys = [...accessedProps];
+      }
+    }
+    const isObjectArray = objectKeys.length > 0;
+    const isStringArray = /^\s*'[^']*'\s*,/.test(arrayContent) || /^\s*"[^"]*"\s*,/.test(arrayContent);
+    const arrayDefaultValue = extractInlineArrayValues(arrayContent, isObjectArray, isStringArray);
+    if (isObjectArray && !isStringArray) {
+      const innerFields = objectKeys.map((prop) => ({
+        key: prop,
+        type: inferInnerFieldType(prop),
+        label: camelToLabel(prop),
+        confidence: "medium"
+      }));
+      addField({
+        key: numberedKey("items", arrayCount),
+        type: "array",
+        label: numberedLabel("Liste", arrayCount),
+        confidence: "high",
+        defaultValue: arrayDefaultValue,
+        options: { arrayItem: { type: "object", fields: innerFields } }
+      }, nodeOffset(node));
+    } else {
+      addField({
+        key: numberedKey("items", arrayCount),
+        type: "array",
+        label: numberedLabel("Liste", arrayCount),
+        confidence: "high",
+        defaultValue: arrayDefaultValue,
+        options: { arrayItem: { type: "text" } }
+      }, nodeOffset(node));
+    }
+  });
+  let staticListCount = 0;
+  walkAst(ast, (node) => {
+    if (node.type !== "element") return;
+    if (node.name !== "ul" && node.name !== "ol") return;
+    if (shouldSkipForContent(node)) return;
+    if (shouldSkipMapChild(node)) 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;
+    let hasNestedList = false;
+    for (const li of node.children ?? []) {
+      if (li.type !== "element" || li.name !== "li") continue;
+      for (const child of li.children ?? []) {
+        if (child.type === "element" && (child.name === "ul" || child.name === "ol")) {
+          hasNestedList = true;
+          break;
+        }
+      }
+      if (hasNestedList) break;
+    }
+    if (hasNestedList) return;
+    const FORMATTING_TAGS = /* @__PURE__ */ new Set(["strong", "em", "b", "i", "code", "a", "s", "u"]);
+    let listHasFormatting = false;
+    const listItems = [];
+    for (const li of node.children ?? []) {
+      if (li.type !== "element" || li.name !== "li") continue;
+      let liHasFormatting = false;
+      walkAst(li, (n) => {
+        if (liHasFormatting) return;
+        if (n.type === "element" && FORMATTING_TAGS.has(n.name ?? "")) liHasFormatting = true;
+      });
+      if (liHasFormatting) {
+        listHasFormatting = true;
+        let contentHTML = null;
+        const liSrcStart = li.position?.start?.offset;
+        const liSrcEnd = li.position?.end?.offset;
+        if (liSrcStart != null && liSrcEnd != null) {
+          const liSrc = template.slice(liSrcStart, liSrcEnd);
+          const spanRegex = /<span[^>]*>([\s\S]*?)<\/span>/g;
+          let spanMatch;
+          while ((spanMatch = spanRegex.exec(liSrc)) !== null) {
+            const inner = spanMatch[1];
+            if (!inner.trim()) continue;
+            contentHTML = inner.replace(/\s+/g, " ").trim();
+            break;
+          }
+        }
+        listItems.push(contentHTML ?? extractTextContent(li, true).replace(/\s+/g, " ").trim());
+      } else {
+        const t = extractTextContent(li, true).replace(/\s+/g, " ").trim();
+        if (t.length >= 1) listItems.push(t);
+      }
+    }
+    if (listItems.length < 1) return;
+    staticListCount++;
+    addField({
+      key: numberedKey("items", arrayCount + staticListCount),
+      type: "array",
+      label: numberedLabel("Liste", arrayCount + staticListCount),
+      confidence: "high",
+      defaultValue: listItems,
+      options: { arrayItem: { type: "text", ...listHasFormatting ? { formatting: true } : {} } }
+    }, nodeOffset(node));
+  });
+  const componentCounts = /* @__PURE__ */ new Map();
+  walkAst(ast, (node) => {
+    if (node.type !== "component" || shouldSkipMapChild(node)) return;
+    componentCounts.set(node.name ?? "", (componentCounts.get(node.name ?? "") ?? 0) + 1);
+  });
+  walkAst(ast, (node) => {
+    if (node.type !== "component") return;
+    if (shouldSkipMapChild(node)) return;
+    if ((componentCounts.get(node.name ?? "") ?? 0) >= 2) return;
+    for (const attr of node.attributes ?? []) {
+      if (attr.kind === "quoted") {
+        const propName = attr.name;
+        const propValue = attr.value;
+        if (/^(class|className|id|style|type|role|width|height|viewBox|fill|stroke|xmlns|d|cx|cy|r|rx|ry|x|y|x1|y1|x2|y2)$/.test(propName)) continue;
+        if (/^(lang|language|filename|file|format|variant|size|loading|decoding|transition|client:.*)$/.test(propName)) continue;
+        if (/^(aria-|data-)/.test(propName)) continue;
+        if (propValue.length < 2) continue;
+        if (propValue === "true" || propValue === "false" || /^\d+$/.test(propValue)) continue;
+        if (propValue.includes("/") && !propValue.includes(" ")) continue;
+        addField({
+          key: propName,
+          type: propName === "icon" ? "icon" : propName === "src" ? "image" : "text",
+          label: camelToLabel(propName),
+          confidence: "medium",
+          defaultValue: propValue
+        }, nodeOffset(node));
+      } else if (attr.kind === "expression") {
+        const propName = attr.name;
+        if (/^(class|className|id|style|type|role|lang|language|filename|file|format|variant|size|loading|decoding)$/.test(propName)) continue;
+        if (/^\s*\w+\s*$/.test(attr.value)) continue;
+        const fallbackMatch = attr.value.match(/\?\?\s*['"]([^'"]+)['"]/);
+        if (fallbackMatch) {
+          addField({
+            key: propName,
+            type: propName === "icon" ? "icon" : propName === "src" ? "image" : "text",
+            label: camelToLabel(propName),
+            confidence: "medium",
+            defaultValue: fallbackMatch[1]
+          }, nodeOffset(node));
+        }
+      }
+    }
+  });
+  const componentInstances = /* @__PURE__ */ new Map();
+  walkAst(ast, (node) => {
+    if (node.type !== "component") return;
+    if (shouldSkipMapChild(node)) return;
+    const name = node.name ?? "";
+    if (!name) return;
+    if (!componentInstances.has(name)) componentInstances.set(name, []);
+    componentInstances.get(name).push(node);
+  });
+  for (const [compName, instances] of componentInstances) {
+    if (instances.length < 2) continue;
+    const allProps = /* @__PURE__ */ new Set();
+    const instanceValues = [];
+    for (const inst of instances) {
+      const item = {};
+      for (const attr of inst.attributes ?? []) {
+        const name = attr.name;
+        if (/^(class|className|id|style|type|role)$/.test(name)) continue;
+        if (/^(aria-|data-)/.test(name)) continue;
+        if (attr.kind === "quoted") {
+          allProps.add(name);
+          item[name] = attr.value;
+        } else if (attr.kind === "expression") {
+          allProps.add(name);
+          const expr = attr.value.trim();
+          if (expr === "true") item[name] = true;
+          else if (expr === "false") item[name] = false;
+          else if (/^\w+$/.test(expr) && frontmatter) {
+            const extractedValue = extractFrontmatterValue(frontmatter, expr);
+            if (extractedValue !== void 0) item[name] = extractedValue;
+          }
+        }
+      }
+      if (Object.keys(item).length > 0) instanceValues.push(item);
+    }
+    if (allProps.size > 0) {
+      const cardKey = compName.replace(/([A-Z])/g, (_m, c, i) => i === 0 ? c.toLowerCase() : "_" + c.toLowerCase()).replace(/_/g, "") + "s";
+      if (!usedKeys.has(cardKey)) {
+        const innerFields = [...allProps].map((p) => {
+          const isArray = instanceValues.some((iv) => Array.isArray(iv[p]));
+          if (isArray) {
+            return { key: p, type: "array", label: camelToLabel(p), confidence: "medium", options: { arrayItem: { type: "text" } } };
+          }
+          return { key: p, type: inferInnerFieldType(p), label: camelToLabel(p), confidence: "medium" };
+        });
+        addField({
+          key: cardKey,
+          type: "array",
+          label: `${compName} Liste`,
+          confidence: "medium",
+          defaultValue: instanceValues.length > 0 ? instanceValues : void 0,
+          options: { arrayItem: { type: "object", fields: innerFields } }
+        }, nodeOffset(instances[0]));
+      }
+    }
+  }
+  for (const group of repeatedElementGroups) {
+    const instanceCount = group.instances.length;
+    const instanceBounds = group.instances.map((inst) => ({
+      start: nodeOffset(inst),
+      end: nodeEnd(inst)
+    }));
+    const instanceFingerprints = [];
+    for (const inst of group.instances) {
+      const items = [];
+      walkContentNodes(inst, 0, items, frontmatter);
+      instanceFingerprints.push(items);
+    }
+    if (instanceFingerprints.length === 0) continue;
+    const signatures = instanceFingerprints.map((fp) => fp.map((i) => i.tag).join(","));
+    const sigCounts = /* @__PURE__ */ new Map();
+    for (const sig of signatures) sigCounts.set(sig, (sigCounts.get(sig) ?? 0) + 1);
+    const mostCommonSig = [...sigCounts.entries()].sort((a, b) => b[1] - a[1])[0][0];
+    const canonicalIdx = signatures.indexOf(mostCommonSig);
+    const canonical = instanceFingerprints[canonicalIdx];
+    const consumedPerInstance = instanceFingerprints.map(() => /* @__PURE__ */ new Set());
+    const innerFields = [];
+    const typeCounts = {};
+    for (let ci = 0; ci < canonical.length; ci++) {
+      const cItem = canonical[ci];
+      const tag = cItem.tag;
+      const isHeading = /^h[1-6]$/.test(tag);
+      const isLink = tag === "a";
+      const isArray = tag === "__array__";
+      let fieldType;
+      let keyBase;
+      if (isHeading) {
+        fieldType = "text";
+        keyBase = "heading";
+      } else if (isLink) {
+        fieldType = "link";
+        keyBase = "link";
+      } else if (isArray) {
+        fieldType = "array";
+        keyBase = "list";
+      } else {
+        fieldType = "text";
+        keyBase = "text";
+      }
+      typeCounts[keyBase] = (typeCounts[keyBase] ?? 0) + 1;
+      const key = typeCounts[keyBase] === 1 ? keyBase : `${keyBase}${typeCounts[keyBase]}`;
+      const positions = [];
+      const defaultValues = [];
+      let presentCount = 0;
+      for (let ii = 0; ii < instanceCount; ii++) {
+        const fp = instanceFingerprints[ii];
+        const consumed = consumedPerInstance[ii];
+        const match = findMatchingItem(fp, cItem, ci, canonical, consumed);
+        if (match) {
+          presentCount++;
+          positions.push({
+            offset: nodeOffset(match.node),
+            length: nodeEnd(match.node) - nodeOffset(match.node),
+            source: match.exprSource
+          });
+          if (isArray && match.exprSource) {
+            defaultValues.push(extractFrontmatterValue(frontmatter, match.exprSource) ?? []);
+          } else if (isLink) {
+            defaultValues.push(match.hrefValue || null);
+          } else {
+            defaultValues.push(match.text || match.hrefValue || null);
+          }
+        } else {
+          positions.push(null);
+          defaultValues.push(null);
+        }
+      }
+      innerFields.push({
+        key,
+        type: fieldType,
+        tag,
+        required: presentCount === instanceCount,
+        positions,
+        defaultValues
+      });
+      if (isLink) {
+        typeCounts["linkText"] = (typeCounts["linkText"] ?? 0) + 1;
+        const ltKey = typeCounts["linkText"] === 1 ? "linkText" : `linkText${typeCounts["linkText"]}`;
+        const ltPositions = [];
+        const ltDefaults = [];
+        for (let ii = 0; ii < instanceCount; ii++) {
+          const fp = instanceFingerprints[ii];
+          const consumed = consumedPerInstance[ii];
+          const match = findMatchingItemPeek(fp, cItem, ci, canonical, consumed);
+          if (match) {
+            ltPositions.push({
+              offset: nodeOffset(match.node),
+              length: nodeEnd(match.node) - nodeOffset(match.node)
+            });
+            ltDefaults.push(match.text || null);
+          } else {
+            ltPositions.push(null);
+            ltDefaults.push(null);
+          }
+        }
+        innerFields.push({
+          key: ltKey,
+          type: "text",
+          tag: "a",
+          required: presentCount === instanceCount,
+          positions: ltPositions,
+          defaultValues: ltDefaults
+        });
+      }
+    }
+    for (let ii = 0; ii < instanceCount; ii++) {
+      if (ii === canonicalIdx) continue;
+      const fp = instanceFingerprints[ii];
+      const consumed = consumedPerInstance[ii];
+      for (let fi = 0; fi < fp.length; fi++) {
+        if (consumed.has(fi)) continue;
+        const item = fp[fi];
+        const tag = item.tag;
+        const isArray = tag === "__array__";
+        const isLink = tag === "a";
+        let fieldType = isArray ? "array" : isLink ? "link" : "text";
+        let keyBase = /^h[1-6]$/.test(tag) ? "heading" : isLink ? "link" : isArray ? "list" : "text";
+        typeCounts[keyBase] = (typeCounts[keyBase] ?? 0) + 1;
+        const key = typeCounts[keyBase] === 1 ? keyBase : `${keyBase}${typeCounts[keyBase]}`;
+        const positions = new Array(instanceCount).fill(null);
+        const defaultValues = new Array(instanceCount).fill(null);
+        positions[ii] = {
+          offset: nodeOffset(item.node),
+          length: nodeEnd(item.node) - nodeOffset(item.node),
+          source: item.exprSource
+        };
+        if (isArray && item.exprSource) {
+          defaultValues[ii] = extractFrontmatterValue(frontmatter, item.exprSource) ?? [];
+        } else {
+          defaultValues[ii] = item.text || item.hrefValue || null;
+        }
+        innerFields.push({ key, type: fieldType, tag, required: false, positions, defaultValues });
+        if (isLink) {
+          typeCounts["linkText"] = (typeCounts["linkText"] ?? 0) + 1;
+          const ltKey = typeCounts["linkText"] === 1 ? "linkText" : `linkText${typeCounts["linkText"]}`;
+          const ltPositions = new Array(instanceCount).fill(null);
+          const ltDefaults = new Array(instanceCount).fill(null);
+          ltPositions[ii] = positions[ii] ?? null;
+          ltDefaults[ii] = item.text || null;
+          innerFields.push({ key: ltKey, type: "text", tag: "a", required: false, positions: ltPositions, defaultValues: ltDefaults });
+        }
+      }
+    }
+    if (innerFields.length === 0) continue;
+    arrayCount++;
+    let fieldKey = numberedKey("items", arrayCount);
+    while (usedKeys.has(fieldKey)) {
+      arrayCount++;
+      fieldKey = numberedKey("items", arrayCount);
+    }
+    const defaultValue = [];
+    for (let ii = 0; ii < instanceCount; ii++) {
+      const item = {};
+      for (const f of innerFields) {
+        if (f.defaultValues[ii] != null) {
+          item[f.key] = f.defaultValues[ii];
+        }
+      }
+      defaultValue.push(item);
+    }
+    const innerFieldDefs = innerFields.map((f) => {
+      if (f.type === "array") {
+        return {
+          key: f.key,
+          type: "array",
+          label: f.label ?? camelToLabel(f.key),
+          confidence: "medium",
+          options: { arrayItem: { type: "text" } }
+        };
+      }
+      return {
+        key: f.key,
+        type: f.type === "link" ? "text" : "text",
+        label: f.label ?? camelToLabel(f.key),
+        confidence: "medium"
+      };
+    });
+    const groupLabel = group.tag === "tr" ? "Tabellen-Zeilen" : `${group.tag.charAt(0).toUpperCase() + group.tag.slice(1)} Liste`;
+    addField({
+      key: fieldKey,
+      type: "array",
+      label: groupLabel,
+      confidence: "high",
+      defaultValue,
+      options: {
+        arrayItem: { type: "object", fields: innerFieldDefs },
+        _repeatedTag: group.tag,
+        _instanceCount: instanceCount
+      }
+    }, instanceBounds[0].start);
+    const classAttrs = group.instances.map((inst) => collectClassAttrs(inst, "", template));
+    repeatedGroups.push({
+      tag: group.tag,
+      fieldKey,
+      instances: instanceBounds,
+      templateIndex: 0,
+      fields: innerFields,
+      classAttrs
+    });
+  }
+  fields.sort((a, b) => a._pos - b._pos);
+  return { fields: fields.map(({ _pos, ...field }) => field), repeatedGroups };
+}
+function walkContentNodes(root, depth, items, frontmatter) {
+  for (const child of root.children ?? []) {
+    if (child.type === "element" && isAriaHidden(child)) continue;
+    if (child.type === "element" && /^h[1-6]$/.test(child.name ?? "")) {
+      const text = extractTextContent(child, true).replace(/\s+/g, " ").trim();
+      if (text.length >= 1) {
+        items.push({ tag: child.name, depth, node: child, text });
+      }
+      continue;
+    }
+    if (child.type === "element" && child.name === "p") {
+      const text = extractTextContent(child, true).replace(/\s+/g, " ").trim();
+      if (text.length >= 1) {
+        items.push({ tag: "p", depth, node: child, text });
+      }
+      continue;
+    }
+    if (child.type === "element" && child.name === "span") {
+      const text = extractTextContent(child, true).replace(/\s+/g, " ").trim();
+      if (text.length >= 1) {
+        items.push({ tag: "span", depth, node: child, text });
+      }
+      continue;
+    }
+    if (child.type === "element" && child.name === "a") {
+      const text = extractTextContent(child, true).replace(/\s+/g, " ").trim();
+      const href = getAttr(child, "href");
+      let hrefValue;
+      if (href?.kind === "quoted") hrefValue = href.value;
+      else if (href?.kind === "expression") {
+        const fb = href.value.match(/['"]([^'"]+)['"]/);
+        if (fb) hrefValue = fb[1];
+      }
+      if (text.length >= 1 || hrefValue) {
+        items.push({ tag: "a", depth, node: child, text, hrefValue });
+      }
+      continue;
+    }
+    if (child.type === "element" && child.name === "td") {
+      const text = extractTextContent(child, true).replace(/\s+/g, " ").trim();
+      if (text.length >= 1) {
+        items.push({ tag: "td", depth, node: child, text });
+      }
+      continue;
+    }
+    if (child.type === "element" && (child.name === "ul" || child.name === "ol")) {
+      let mapSource;
+      walkAst(child, (expr) => {
+        if (mapSource) return;
+        if (expr.type !== "expression") return;
+        const code = (expr.children ?? []).map((c) => c.value ?? "").join("");
+        const mapMatch = code.match(/(\w+)\.map\s*\(/);
+        if (mapMatch) mapSource = mapMatch[1];
+      });
+      if (mapSource) {
+        items.push({ tag: "__array__", depth, node: child, text: "", exprSource: mapSource });
+      } else {
+        const listTexts = [];
+        for (const li of child.children ?? []) {
+          if (li.type === "element" && li.name === "li") {
+            const t = extractTextContent(li, true).trim();
+            if (t.length >= 1) listTexts.push(t);
+          }
+        }
+        if (listTexts.length > 0) {
+          items.push({ tag: "__array__", depth, node: child, text: listTexts.join("\n") });
+        }
+      }
+      continue;
+    }
+    if (child.type === "element") {
+      walkContentNodes(child, depth + 1, items, frontmatter);
+    }
+  }
+}
+function findMatchingItem(targetFp, canonicalItem, canonicalIndex, allCanonical, consumed) {
+  const result = findMatchingItemCore(targetFp, canonicalItem, canonicalIndex, allCanonical, consumed);
+  if (result) consumed.add(result.idx);
+  return result?.item ?? null;
+}
+function findMatchingItemPeek(targetFp, canonicalItem, canonicalIndex, allCanonical, consumed) {
+  const tag = canonicalItem.tag;
+  const candidates = targetFp.map((item, idx) => ({ item, idx })).filter((c) => c.item.tag === tag);
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0].item;
+  const canonicalRelPos = canonicalIndex / Math.max(allCanonical.length - 1, 1);
+  candidates.sort((a, b) => {
+    const relA = a.idx / Math.max(targetFp.length - 1, 1);
+    const relB = b.idx / Math.max(targetFp.length - 1, 1);
+    return Math.abs(relA - canonicalRelPos) - Math.abs(relB - canonicalRelPos);
+  });
+  return candidates[0].item;
+}
+function findMatchingItemCore(targetFp, canonicalItem, canonicalIndex, allCanonical, consumed) {
+  const tag = canonicalItem.tag;
+  const candidates = targetFp.map((item, idx) => ({ item, idx })).filter((c) => c.item.tag === tag && !consumed.has(c.idx));
+  if (candidates.length === 0) return null;
+  if (candidates.length === 1) return candidates[0];
+  const canonicalRelPos = canonicalIndex / Math.max(allCanonical.length - 1, 1);
+  candidates.sort((a, b) => {
+    const relA = a.idx / Math.max(targetFp.length - 1, 1);
+    const relB = b.idx / Math.max(targetFp.length - 1, 1);
+    return Math.abs(relA - canonicalRelPos) - Math.abs(relB - canonicalRelPos);
+  });
+  return candidates[0];
+}
+
+export {
+  findAstroPages,
+  extractSectionImports,
+  extractLayoutImport,
+  analyzeAstroSection
+};