meno-astro 0.1.0

package/dist/lib/dialect/index.js

@@ -0,0 +1,1385 @@
+import {
+  singularize
+} from "../../chunks/chunk-LEMVUKVG.js";
+import "../../chunks/chunk-ZYQNHI3W.js";
+
+// lib/dialect/emit/emitContext.ts
+function createEmitContext(width = 80) {
+  return {
+    components: /* @__PURE__ */ new Set(),
+    runtime: /* @__PURE__ */ new Set(),
+    runtimeComponents: /* @__PURE__ */ new Set(),
+    frontmatterConsts: [],
+    listCounter: 0,
+    hoistCounter: 0,
+    tagCounter: 0,
+    width
+  };
+}
+function needRuntime(ctx, name) {
+  ctx.runtime.add(name);
+  return name;
+}
+function needRuntimeComponent(ctx, name) {
+  ctx.runtimeComponents.add(name);
+  return name;
+}
+
+// lib/dialect/emit/serialize.ts
+var DEFAULT_WIDTH = 80;
+var INDENT_STEP = 2;
+var IDENT_RE = /^[A-Za-z_$][A-Za-z0-9_$]*$/;
+function isIdentifier(key) {
+  return IDENT_RE.test(key);
+}
+function renderKey(key) {
+  return isIdentifier(key) ? key : JSON.stringify(key);
+}
+function renderString(value) {
+  return JSON.stringify(value);
+}
+function renderNumber(value) {
+  return Number.isFinite(value) ? String(value) : "null";
+}
+function definedEntries(obj) {
+  return Object.entries(obj).filter(([, v]) => v !== void 0);
+}
+function renderInline(value) {
+  if (value === null) return "null";
+  if (value === void 0) return "undefined";
+  switch (typeof value) {
+    case "string":
+      return renderString(value);
+    case "number":
+      return renderNumber(value);
+    case "boolean":
+      return String(value);
+    case "object": {
+      if (Array.isArray(value)) {
+        if (value.length === 0) return "[]";
+        return "[" + value.map(renderInline).join(", ") + "]";
+      }
+      const entries = definedEntries(value);
+      if (entries.length === 0) return "{}";
+      return "{ " + entries.map(([k, v]) => `${renderKey(k)}: ${renderInline(v)}`).join(", ") + " }";
+    }
+    default:
+      return "null";
+  }
+}
+function serializeLiteral(value, opts = {}) {
+  const width = opts.width ?? DEFAULT_WIDTH;
+  const baseIndent = opts.indent ?? 0;
+  const startCol = opts.startCol ?? baseIndent;
+  const render = (v, contIndent, startCol2) => {
+    if (v === null || typeof v !== "object") return renderInline(v);
+    const inline = renderInline(v);
+    if (startCol2 + inline.length <= width) return inline;
+    const pad2 = " ".repeat(contIndent + INDENT_STEP);
+    const closePad = " ".repeat(contIndent);
+    if (Array.isArray(v)) {
+      if (v.length === 0) return "[]";
+      const items = v.map(
+        (item) => pad2 + render(item, contIndent + INDENT_STEP, contIndent + INDENT_STEP)
+      );
+      return "[\n" + items.join(",\n") + "\n" + closePad + "]";
+    }
+    const entries = definedEntries(v);
+    if (entries.length === 0) return "{}";
+    const lines = entries.map(([k, val]) => {
+      const prefix = pad2 + renderKey(k) + ": ";
+      return prefix + render(val, contIndent + INDENT_STEP, prefix.length);
+    });
+    return "{\n" + lines.join(",\n") + "\n" + closePad + "}";
+  };
+  return render(value, baseIndent, startCol);
+}
+
+// lib/dialect/emit/emitNode.ts
+var INDENT = 2;
+function pad(n) {
+  return " ".repeat(n);
+}
+function shift(block, indent) {
+  const p = pad(indent);
+  return block.split("\n").map((line) => line.length ? p + line : line).join("\n");
+}
+var TEMPLATE_RE = /\{\{([\s\S]*?)\}\}/g;
+function hasTemplate(s) {
+  return /\{\{[\s\S]*?\}\}/.test(s);
+}
+function escapeBacktick(s) {
+  return s.replace(/\\/g, "\\\\").replace(/`/g, "\\`").replace(/\$\{/g, "\\${");
+}
+function templateToExpr(s) {
+  const matches = [...s.matchAll(TEMPLATE_RE)];
+  if (matches.length === 1 && matches[0].index === 0 && matches[0][0].length === s.length) {
+    return matches[0][1].trim();
+  }
+  let out = "";
+  let last = 0;
+  for (const m of matches) {
+    out += escapeBacktick(s.slice(last, m.index));
+    out += "${" + m[1].trim() + "}";
+    last = m.index + m[0].length;
+  }
+  out += escapeBacktick(s.slice(last));
+  return "`" + out + "`";
+}
+function isI18nValue(v) {
+  return typeof v === "object" && v !== null && v._i18n === true;
+}
+function emitAttr(name, value, ctx) {
+  if (isI18nValue(value)) {
+    needRuntime(ctx, "i18n");
+    return `${name}={i18n(${serializeLiteral(value, { indent: INDENT, width: ctx.width })})}`;
+  }
+  if (typeof value === "string") {
+    if (hasTemplate(value)) return `${name}={${templateToExpr(value)}}`;
+    if (!value.includes('"') && !value.includes("\n")) return `${name}="${value}"`;
+    return `${name}={${JSON.stringify(value)}}`;
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return `${name}={${value}}`;
+  }
+  if (value === null || value === void 0) return `${name}={null}`;
+  return `${name}={${serializeLiteral(value, { indent: INDENT, width: ctx.width })}}`;
+}
+function emitClassAttr(node, ctx, extraMeta) {
+  const meta = { ...extraMeta };
+  if (node.interactiveStyles !== void 0) meta.interactive = node.interactiveStyles;
+  if (node.label !== void 0) meta.label = node.label;
+  if (node.generateElementClass !== void 0) meta.genClass = node.generateElementClass;
+  const hasStyle = hasStyleContent(node.style);
+  const hasMeta = Object.keys(meta).length > 0;
+  if (!hasStyle && !hasMeta) return null;
+  needRuntime(ctx, "style");
+  const styleLit = serializeLiteral(node.style ?? {}, { indent: INDENT, width: ctx.width });
+  if (!hasMeta) return `class={style(${styleLit})}`;
+  const metaLit = serializeLiteral(meta, { indent: INDENT, width: ctx.width });
+  return `class={style(${styleLit}, ${metaLit})}`;
+}
+function hasStyleContent(style) {
+  if (!style || typeof style !== "object") return false;
+  for (const v of Object.values(style)) {
+    if (v === void 0 || v === null) continue;
+    if (typeof v === "object") {
+      if (Object.keys(v).length > 0) return true;
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
+function emitAttributes(node, ctx) {
+  if (!node.attributes || typeof node.attributes !== "object") return [];
+  return Object.entries(node.attributes).map(([k, v]) => emitAttr(k, v, ctx));
+}
+var VOID_ELEMENTS = /* @__PURE__ */ new Set([
+  "img",
+  "br",
+  "hr",
+  "input",
+  "meta",
+  "link",
+  "area",
+  "base",
+  "col",
+  "embed",
+  "param",
+  "source",
+  "track",
+  "wbr"
+]);
+var LOCALE_KNOWN_KEYS = /* @__PURE__ */ new Set([
+  "type",
+  "if",
+  "showCurrent",
+  "showSeparator",
+  "showFlag",
+  "displayType",
+  "style",
+  "itemStyle",
+  "activeItemStyle",
+  "separatorStyle",
+  "flagStyle",
+  "interactiveStyles",
+  "label",
+  "generateElementClass"
+]);
+function emitTextChild(text, forceExpr = false) {
+  if (hasTemplate(text)) return `{${templateToExpr(text)}}`;
+  const safeRaw = !forceExpr && text.length > 0 && text === text.trim() && !/[{}<>]/.test(text);
+  return safeRaw ? text : `{${JSON.stringify(text)}}`;
+}
+function emitChildrenList(children, ctx) {
+  if (children === void 0 || children === null) return [];
+  if (typeof children === "string") {
+    return children.length ? [emitTextChild(children)] : [];
+  }
+  if (!Array.isArray(children)) return [];
+  const multi = children.length > 1;
+  return children.map(
+    (child) => typeof child === "string" ? emitTextChild(child, multi) : placeChild(renderNode(child, ctx), 0)
+  );
+}
+function composeElement(tag, attrs, childBlocks, forceVoid = false) {
+  const attrStr = attrs.length ? " " + attrs.join(" ") : "";
+  if (forceVoid || childBlocks.length === 0) {
+    return `<${tag}${attrStr} />`;
+  }
+  if (childBlocks.length === 1 && !childBlocks[0].includes("\n")) {
+    return `<${tag}${attrStr}>${childBlocks[0]}</${tag}>`;
+  }
+  const inner = childBlocks.map((c) => shift(c, INDENT)).join("\n");
+  return `<${tag}${attrStr}>
+${inner}
+</${tag}>`;
+}
+function renderHtml(node, ctx) {
+  let tag = node.tag;
+  if (typeof tag === "string" && hasTemplate(tag)) {
+    const varName = `Tag_${ctx.tagCounter++}`;
+    ctx.frontmatterConsts.push(`const ${varName} = ${tagToTemplateLiteral(tag)};`);
+    tag = varName;
+  }
+  const attrs = [emitClassAttr(node, ctx), ...emitAttributes(node, ctx)].filter(Boolean);
+  const isVoid = VOID_ELEMENTS.has(String(node.tag).toLowerCase());
+  const childBlocks = isVoid ? [] : emitChildrenList(node.children, ctx);
+  return { kind: "element", markup: composeElement(tag, attrs, childBlocks, isVoid) };
+}
+function tagToTemplateLiteral(tag) {
+  const body = tag.replace(TEMPLATE_RE, (_m, e) => "${" + String(e).trim() + "}");
+  return "`" + body + "`";
+}
+function renderComponentInstance(node, ctx) {
+  const tag = astroComponentName(node.component);
+  ctx.components.add(node.component);
+  const attrs = [];
+  if (node.props && typeof node.props === "object") {
+    for (const [k, v] of Object.entries(node.props)) attrs.push(emitAttr(k, v, ctx));
+  }
+  const cls = emitClassAttr(node, ctx, hasStyleContent(node.style) ? { instance: true } : void 0);
+  if (cls) attrs.push(cls);
+  const childBlocks = emitChildrenList(node.children, ctx);
+  return { kind: "element", markup: composeElement(tag, attrs, childBlocks) };
+}
+function renderSlot(node, ctx) {
+  const def = node.default;
+  if (def === void 0) return { kind: "element", markup: "<slot />" };
+  const childBlocks = emitChildrenList(def, ctx);
+  return { kind: "element", markup: composeElement("slot", [], childBlocks) };
+}
+function renderLink(node, ctx) {
+  needRuntimeComponent(ctx, "Link");
+  const attrs = [emitHref(node.href, ctx)];
+  const cls = emitClassAttr(node, ctx);
+  if (cls) attrs.push(cls);
+  attrs.push(...emitAttributes(node, ctx));
+  const childBlocks = emitChildrenList(node.children, ctx);
+  return { kind: "element", markup: composeElement("Link", attrs.filter(Boolean), childBlocks) };
+}
+function emitHref(href, ctx) {
+  if (typeof href === "string") {
+    if (hasTemplate(href)) return `href={${templateToExpr(href)}}`;
+    return `href="${href}"`;
+  }
+  if (isI18nValue(href)) {
+    needRuntime(ctx, "i18n");
+    return `href={i18n(${serializeLiteral(href, { indent: INDENT, width: ctx.width })})}`;
+  }
+  needRuntime(ctx, "href");
+  return `href={href(${serializeLiteral(href, { indent: INDENT, width: ctx.width })})}`;
+}
+function renderEmbed(node, ctx) {
+  needRuntimeComponent(ctx, "Embed");
+  const attrs = [];
+  if (typeof node.html === "string") {
+    if (node.html.includes("\n")) {
+      const name = `__embed${ctx.hoistCounter++}`;
+      ctx.frontmatterConsts.push(`const ${name} = \`${escapeBacktick(node.html)}\`;`);
+      attrs.push(`html={${name}}`);
+    } else {
+      attrs.push(`html={\`${escapeBacktick(node.html)}\`}`);
+    }
+  } else {
+    needRuntime(ctx, "embedHtml");
+    attrs.push(`html={embedHtml(${serializeLiteral(node.html, { indent: INDENT, width: ctx.width })})}`);
+  }
+  const cls = emitClassAttr(node, ctx);
+  if (cls) attrs.push(cls);
+  attrs.push(...emitAttributes(node, ctx));
+  return { kind: "element", markup: composeElement("Embed", attrs, [], true) };
+}
+function renderLocaleList(node, ctx) {
+  needRuntimeComponent(ctx, "LocaleList");
+  const attrs = [];
+  const boolProps = ["showCurrent", "showSeparator", "showFlag"];
+  for (const p of boolProps) if (node[p] !== void 0) attrs.push(emitAttr(p, node[p], ctx));
+  if (node.displayType !== void 0) attrs.push(emitAttr("displayType", node.displayType, ctx));
+  const styleProps = ["style", "itemStyle", "activeItemStyle", "separatorStyle", "flagStyle"];
+  for (const sp of styleProps) {
+    if (hasStyleContent(node[sp])) {
+      needRuntime(ctx, "style");
+      attrs.push(`${sp}={style(${serializeLiteral(node[sp], { indent: INDENT, width: ctx.width })})}`);
+    }
+  }
+  if (node.interactiveStyles !== void 0 || node.label !== void 0 || node.generateElementClass !== void 0) {
+    const meta = {};
+    if (node.interactiveStyles !== void 0) meta.interactive = node.interactiveStyles;
+    if (node.label !== void 0) meta.label = node.label;
+    if (node.generateElementClass !== void 0) meta.genClass = node.generateElementClass;
+    attrs.push(`meta={${serializeLiteral(meta, { indent: INDENT, width: ctx.width })}}`);
+  }
+  for (const [k, v] of Object.entries(node)) {
+    if (LOCALE_KNOWN_KEYS.has(k)) continue;
+    if (typeof v === "string" || typeof v === "number" || typeof v === "boolean") {
+      attrs.push(emitAttr(k, v, ctx));
+    }
+  }
+  return { kind: "element", markup: composeElement("LocaleList", attrs, [], true) };
+}
+function renderList(node, ctx) {
+  const sourceType = node.sourceType ?? "prop";
+  const childBlocks = emitChildrenList(node.children, ctx);
+  const childRenderedAt2 = childBlocks.map((c) => shift(c, INDENT)).join("\n");
+  if (sourceType === "collection") {
+    needRuntime(ctx, "getCollectionList");
+    const itemVar2 = node.itemAs ?? singularize(node.source);
+    const indexVar2 = `${itemVar2}Index`;
+    const query = listQueryLiteral(node, ctx, ["filter", "sort", "limit", "offset", "items", "excludeCurrentItem", "emitTemplate"]);
+    const binding = uniqueBinding(ctx, `${sanitizeIdent(node.source)}List`);
+    ctx.frontmatterConsts.push(
+      `const ${binding} = await getCollectionList(${JSON.stringify(node.source)}${query ? ", " + query : ""}, Astro);`
+    );
+    const expr2 = `${binding}.map((${itemVar2}, ${indexVar2}) => (
+${childRenderedAt2}
+))`;
+    return { kind: "expr", expr: expr2 };
+  }
+  needRuntime(ctx, "list");
+  const itemVar = node.itemAs ?? "item";
+  const indexVar = `${itemVar}Index`;
+  const sourceExpr = typeof node.source === "string" && hasTemplate(node.source) ? templateToExpr(node.source) : sanitizeIdent(String(node.source));
+  const opts = listQueryLiteral(node, ctx, ["limit", "offset"]);
+  const listCall = opts ? `list(${sourceExpr}, ${opts})` : `list(${sourceExpr})`;
+  const expr = `${listCall}.map((${itemVar}, ${indexVar}) => (
+${childRenderedAt2}
+))`;
+  return { kind: "expr", expr };
+}
+function listQueryLiteral(node, ctx, keys) {
+  const obj = {};
+  for (const k of keys) if (node[k] !== void 0) obj[k] = node[k];
+  if (Object.keys(obj).length === 0) return "";
+  return serializeLiteral(obj, { indent: INDENT, width: ctx.width });
+}
+function uniqueBinding(ctx, base) {
+  const existing = ctx.frontmatterConsts.some((l) => l.startsWith(`const ${base} `));
+  if (!existing) return base;
+  return `${base}_${ctx.listCounter++}`;
+}
+function sanitizeIdent(s) {
+  return /^[A-Za-z_$][\w$]*$/.test(s) ? s : s.replace(/[^A-Za-z0-9_$]/g, "_");
+}
+function astroComponentName(name) {
+  const cleaned = name.replace(/[^A-Za-z0-9_$]/g, "");
+  return cleaned.charAt(0).toUpperCase() + cleaned.slice(1);
+}
+function renderNode(node, ctx) {
+  let rendered;
+  switch (node.type) {
+    case "node":
+      rendered = renderHtml(node, ctx);
+      break;
+    case "component":
+      rendered = renderComponentInstance(node, ctx);
+      break;
+    case "slot":
+      rendered = renderSlot(node, ctx);
+      break;
+    case "link":
+      rendered = renderLink(node, ctx);
+      break;
+    case "embed":
+      rendered = renderEmbed(node, ctx);
+      break;
+    case "locale-list":
+      rendered = renderLocaleList(node, ctx);
+      break;
+    case "list":
+      rendered = renderList(node, ctx);
+      break;
+    default:
+      rendered = { kind: "element", markup: `{/* meno:unknown ${JSON.stringify(node.type)} */}` };
+  }
+  return applyIf(node, rendered);
+}
+function applyIf(node, rendered) {
+  if (node.if === void 0 || node.if === true) return rendered;
+  const cond = ifConditionExpr(node.if);
+  if (rendered.kind === "element") {
+    return { kind: "expr", expr: `${cond} && (
+${shift(rendered.markup, INDENT)}
+)` };
+  }
+  return { kind: "expr", expr: `${cond} && (${rendered.expr})` };
+}
+function ifConditionExpr(cond) {
+  if (cond === false) return "false";
+  if (cond === true) return "true";
+  if (typeof cond === "string") return hasTemplate(cond) ? templateToExpr(cond) : cond;
+  return `when(${serializeLiteral(cond)})`;
+}
+function placeChild(rendered, indent) {
+  if (rendered.kind === "element") return shift(rendered.markup, indent);
+  return shift(`{${rendered.expr}}`, indent);
+}
+function emitNode(node, ctx, indent) {
+  if (typeof node === "string") return shift(emitTextChild(node), indent);
+  return placeChild(renderNode(node, ctx), indent);
+}
+
+// lib/dialect/emit/frontmatter.ts
+function buildImportLines(ctx, opts) {
+  const lines = [];
+  const types = [...new Set(opts.typeImports ?? [])].sort();
+  if (types.length) lines.push(`import type { ${types.join(", ")} } from 'meno-astro';`);
+  if (ctx.runtime.size) {
+    lines.push(`import { ${[...ctx.runtime].sort().join(", ")} } from 'meno-astro';`);
+  }
+  if (ctx.runtimeComponents.size) {
+    lines.push(`import { ${[...ctx.runtimeComponents].sort().join(", ")} } from 'meno-astro/components';`);
+  }
+  for (const name of [...ctx.components].sort()) {
+    lines.push(`import ${astroComponentName(name)} from '${opts.componentPrefix}${name}.astro';`);
+  }
+  return lines;
+}
+var WIDTH = 80;
+var CALL_PREFIX = "resolveProps(Astro, ";
+function buildPropsBlock(propInterface) {
+  const def = propInterface ?? {};
+  const names = [];
+  for (const name of Object.keys(def)) {
+    if (name === "children") continue;
+    names.push(name);
+  }
+  names.push("class: className");
+  const head = `const { ${names.join(", ")} } = ${CALL_PREFIX}`;
+  let prefix;
+  let closeCol;
+  if (head.length <= WIDTH) {
+    prefix = head;
+    closeCol = head.length;
+  } else {
+    prefix = ["const {", ...names.map((n) => `  ${n},`), `} = ${CALL_PREFIX}`].join("\n");
+    closeCol = `} = ${CALL_PREFIX}`.length;
+  }
+  const literal = serializeLiteral(def, { indent: 0, startCol: closeCol + 2, width: WIDTH });
+  return [`${prefix}${literal});`];
+}
+
+// lib/dialect/cmsRoute.ts
+function isCmsTemplatePage(page) {
+  if (!page || typeof page !== "object") return false;
+  const meta = page.meta;
+  return !!meta && meta.source === "cms" && !!meta.cms && typeof meta.cms === "object";
+}
+function cmsRouteDirFromUrlPattern(urlPattern) {
+  if (!urlPattern) return "";
+  const withoutLeading = urlPattern.replace(/^\/+/, "");
+  const idx = withoutLeading.indexOf("{{");
+  const prefix = idx < 0 ? withoutLeading : withoutLeading.slice(0, idx);
+  return prefix.replace(/^\/+|\/+$/g, "");
+}
+function buildGetStaticPaths(cms) {
+  const collectionId = cms.id ?? "";
+  const slugField = cms.slugField || "slug";
+  return [
+    `export async function getStaticPaths() {`,
+    `  const entries = await getCollection(${JSON.stringify(collectionId)});`,
+    `  return entries.map((entry) => ({`,
+    `    params: { slug: entry.data.${slugField} ?? entry.id },`,
+    `    props: { cms: entry.data },`,
+    `  }));`,
+    `}`,
+    ``,
+    `const { cms } = Astro.props;`
+  ].join("\n");
+}
+
+// lib/dialect/emit/emitPage.ts
+function emitPage(page) {
+  const ctx = createEmitContext();
+  const body = page.root ? emitNode(page.root, ctx, 2) : "";
+  needRuntimeComponent(ctx, "BaseLayout");
+  const isCms = isCmsTemplatePage(page);
+  const routeDir = isCms ? cmsRouteDirFromUrlPattern(page.meta.cms.urlPattern) : "";
+  const depth = routeDir ? routeDir.split("/").length : 0;
+  const componentPrefix = `${"../".repeat(depth + 1)}components/`;
+  const importLines = buildImportLines(ctx, {
+    typeImports: ["MenoPageMeta"],
+    componentPrefix
+  });
+  const fm = [];
+  if (isCms) fm.push(`import { getCollection } from 'astro:content';`);
+  fm.push(...importLines);
+  fm.push("");
+  if (isCms) {
+    fm.push(buildGetStaticPaths(page.meta.cms));
+    fm.push("");
+  }
+  fm.push(`export const meta = ${serializeLiteral(page.meta ?? {}, { indent: 0 })} satisfies MenoPageMeta;`);
+  if (ctx.frontmatterConsts.length) {
+    fm.push("");
+    fm.push(...ctx.frontmatterConsts);
+  }
+  const wrapped = body ? `<BaseLayout meta={meta}>
+${body}
+</BaseLayout>` : `<BaseLayout meta={meta} />`;
+  return `---
+${fm.join("\n")}
+---
+${wrapped}
+`;
+}
+
+// lib/dialect/emit/emitComponent.ts
+var META_KEYS = ["category", "acceptsStyles", "libraries"];
+function defineVarNames(def) {
+  if (def.defineVars === true) {
+    return Object.keys(def.interface ?? {}).filter((k) => k !== "children");
+  }
+  return def.defineVars ?? [];
+}
+function buildScriptBlock(def) {
+  if (!def.javascript) return "";
+  if (def.defineVars) {
+    const names = defineVarNames(def);
+    return `
+
+<script define:vars={{ ${names.join(", ")} }}>
+${def.javascript}
+</script>`;
+  }
+  return `
+
+<script is:inline>
+${def.javascript}
+</script>`;
+}
+function pickComponentMeta(def) {
+  const meta = {};
+  for (const k of META_KEYS) {
+    const v = def[k];
+    if (v !== void 0) meta[k] = v;
+  }
+  return meta;
+}
+function emitComponent(def) {
+  const ctx = createEmitContext();
+  const body = def.structure ? emitNode(def.structure, ctx, 0) : "<slot />";
+  const componentMeta = pickComponentMeta(def);
+  const hasMeta = Object.keys(componentMeta).length > 0;
+  ctx.runtime.add("resolveProps");
+  const typeImports = [];
+  if (hasMeta) typeImports.push("MenoComponentMeta");
+  const importLines = buildImportLines(ctx, { typeImports, componentPrefix: "./" });
+  const propsBlock = buildPropsBlock(def.interface);
+  const fm = [];
+  fm.push(...importLines);
+  fm.push("");
+  fm.push(...propsBlock);
+  if (hasMeta) {
+    fm.push("");
+    fm.push(`const __meno = ${serializeLiteral(componentMeta, { indent: 0 })} satisfies MenoComponentMeta;`);
+  }
+  if (ctx.frontmatterConsts.length) {
+    fm.push("");
+    fm.push(...ctx.frontmatterConsts);
+  }
+  const styleBlock = def.css ? `
+
+<style>
+${def.css}
+</style>` : "";
+  const scriptBlock = buildScriptBlock(def);
+  return `---
+${fm.join("\n")}
+---
+${body}
+${styleBlock}${scriptBlock}`.replace(/\n+$/, "\n");
+}
+
+// lib/dialect/parse/parseLiteral.ts
+var WS = /* @__PURE__ */ new Set([" ", "	", "\r", "\n"]);
+var IDENT_START = /[A-Za-z_$]/;
+var IDENT_CHAR = /[A-Za-z0-9_$]/;
+function skipWs(src, i) {
+  while (i < src.length && WS.has(src[i])) i++;
+  return i;
+}
+function fail(src, i, msg) {
+  const around = src.slice(Math.max(0, i - 20), i + 20);
+  throw new Error(`parseLiteral: ${msg} at index ${i} (\u2026${around}\u2026)`);
+}
+function parseString(src, i) {
+  let j = i + 1;
+  while (j < src.length) {
+    const c = src[j];
+    if (c === "\\") {
+      j += 2;
+      continue;
+    }
+    if (c === '"') {
+      j++;
+      break;
+    }
+    j++;
+  }
+  const raw = src.slice(i, j);
+  return { value: JSON.parse(raw), end: j };
+}
+function parseNumber(src, i) {
+  let j = i;
+  while (j < src.length && /[-+0-9.eE]/.test(src[j])) j++;
+  const raw = src.slice(i, j);
+  const n = Number(raw);
+  if (Number.isNaN(n) && raw !== "NaN") fail(src, i, `invalid number "${raw}"`);
+  return { value: n, end: j };
+}
+function parseKey(src, i) {
+  if (src[i] === '"') return parseString(src, i);
+  if (!IDENT_START.test(src[i])) fail(src, i, "expected object key");
+  let j = i + 1;
+  while (j < src.length && IDENT_CHAR.test(src[j])) j++;
+  return { value: src.slice(i, j), end: j };
+}
+function parseObject(src, i) {
+  const obj = {};
+  let j = skipWs(src, i + 1);
+  if (src[j] === "}") return { value: obj, end: j + 1 };
+  for (; ; ) {
+    j = skipWs(src, j);
+    const key = parseKey(src, j);
+    j = skipWs(src, key.end);
+    if (src[j] !== ":") fail(src, j, 'expected ":"');
+    j = skipWs(src, j + 1);
+    const val = parseValueAt(src, j);
+    obj[key.value] = val.value;
+    j = skipWs(src, val.end);
+    if (src[j] === ",") {
+      j++;
+      continue;
+    }
+    if (src[j] === "}") return { value: obj, end: j + 1 };
+    fail(src, j, 'expected "," or "}"');
+  }
+}
+function parseArray(src, i) {
+  const arr = [];
+  let j = skipWs(src, i + 1);
+  if (src[j] === "]") return { value: arr, end: j + 1 };
+  for (; ; ) {
+    j = skipWs(src, j);
+    const val = parseValueAt(src, j);
+    arr.push(val.value);
+    j = skipWs(src, val.end);
+    if (src[j] === ",") {
+      j++;
+      continue;
+    }
+    if (src[j] === "]") return { value: arr, end: j + 1 };
+    fail(src, j, 'expected "," or "]"');
+  }
+}
+function parseValueAt(src, i) {
+  i = skipWs(src, i);
+  const c = src[i];
+  if (c === "{") return parseObject(src, i);
+  if (c === "[") return parseArray(src, i);
+  if (c === '"') return parseString(src, i);
+  if (src.startsWith("true", i)) return { value: true, end: i + 4 };
+  if (src.startsWith("false", i)) return { value: false, end: i + 5 };
+  if (src.startsWith("null", i)) return { value: null, end: i + 4 };
+  if (c === "-" || c === "+" || c >= "0" && c <= "9") return parseNumber(src, i);
+  return fail(src, i, `unexpected character "${c ?? "<eof>"}"`);
+}
+function parseLiteral(src) {
+  const { value, end } = parseValueAt(src, 0);
+  const rest = skipWs(src, end);
+  if (rest !== src.length) fail(src, rest, "trailing content after literal");
+  return value;
+}
+
+// lib/dialect/parse/scan.ts
+var CLOSERS = { "{": "}", "(": ")", "[": "]" };
+function scanString(src, i) {
+  const q = src[i];
+  let j = i + 1;
+  while (j < src.length) {
+    if (src[j] === "\\") {
+      j += 2;
+      continue;
+    }
+    if (src[j] === q) return j + 1;
+    j++;
+  }
+  throw new Error(`scanString: unterminated string from ${i}`);
+}
+function scanTemplate(src, i) {
+  let j = i + 1;
+  while (j < src.length) {
+    if (src[j] === "\\") {
+      j += 2;
+      continue;
+    }
+    if (src[j] === "`") return j + 1;
+    if (src[j] === "$" && src[j + 1] === "{") {
+      j = scanBalanced(src, j + 1);
+      continue;
+    }
+    j++;
+  }
+  throw new Error(`scanTemplate: unterminated template from ${i}`);
+}
+function scanBalanced(src, i) {
+  if (!CLOSERS[src[i]]) throw new Error(`scanBalanced: no open delimiter at ${i} ("${src[i]}")`);
+  let depth = 0;
+  let j = i;
+  while (j < src.length) {
+    const c = src[j];
+    if (c === '"' || c === "'") {
+      j = scanString(src, j);
+      continue;
+    }
+    if (c === "`") {
+      j = scanTemplate(src, j);
+      continue;
+    }
+    if (c === "{" || c === "(" || c === "[") {
+      depth++;
+      j++;
+      continue;
+    }
+    if (c === "}" || c === ")" || c === "]") {
+      depth--;
+      j++;
+      if (depth === 0) return j;
+      continue;
+    }
+    j++;
+  }
+  throw new Error(`scanBalanced: unbalanced from ${i}`);
+}
+function findTrailingGroup(expr, openChar = "(") {
+  let j = 0;
+  while (j < expr.length) {
+    const c = expr[j];
+    if (c === '"' || c === "'") {
+      j = scanString(expr, j);
+      continue;
+    }
+    if (c === "`") {
+      j = scanTemplate(expr, j);
+      continue;
+    }
+    if (c === "{" || c === "(" || c === "[") {
+      const end = scanBalanced(expr, j);
+      if (c === openChar && end === expr.length) {
+        return { open: j, inner: expr.slice(j + 1, end - 1) };
+      }
+      j = end;
+      continue;
+    }
+    j++;
+  }
+  return null;
+}
+function splitTopLevel(src, sep) {
+  const parts = [];
+  let start = 0;
+  let j = 0;
+  while (j < src.length) {
+    const c = src[j];
+    if (c === '"' || c === "'") {
+      j = scanString(src, j);
+      continue;
+    }
+    if (c === "`") {
+      j = scanTemplate(src, j);
+      continue;
+    }
+    if (c === "{" || c === "(" || c === "[") {
+      j = scanBalanced(src, j);
+      continue;
+    }
+    if (c === sep) {
+      parts.push(src.slice(start, j));
+      start = j + 1;
+      j++;
+      continue;
+    }
+    j++;
+  }
+  parts.push(src.slice(start));
+  return parts.map((s) => s.trim());
+}
+
+// lib/dialect/parse/callArgs.ts
+function callArgsOf(expr) {
+  const open = expr.indexOf("(");
+  const end = scanBalanced(expr, open);
+  return expr.slice(open + 1, end - 1);
+}
+
+// lib/dialect/parse/parseValue.ts
+function reverseTemplate(content) {
+  let out = "";
+  let i = 0;
+  while (i < content.length) {
+    const c = content[i];
+    if (c === "\\") {
+      const n = content[i + 1];
+      out += n === "\\" ? "\\" : n === "`" ? "`" : n === "$" ? "$" : n;
+      i += 2;
+      continue;
+    }
+    if (c === "$" && content[i + 1] === "{") {
+      const end = scanBalanced(content, i + 1);
+      out += "{{" + content.slice(i + 2, end - 1).trim() + "}}";
+      i = end;
+      continue;
+    }
+    out += c;
+    i++;
+  }
+  return out;
+}
+function interpretExprValue(expr, ctx) {
+  const e = expr.trim();
+  if (ctx.embedConsts.has(e)) return ctx.embedConsts.get(e);
+  if (e.startsWith("i18n(")) return parseLiteral(callArgsOf(e));
+  if (e.startsWith("href(")) return parseLiteral(callArgsOf(e));
+  if (e.startsWith("embedHtml(")) return parseLiteral(callArgsOf(e));
+  if (e[0] === "`") return reverseTemplate(e.slice(1, -1));
+  if (e[0] === "{" || e[0] === "[") return parseLiteral(e);
+  if (e[0] === '"') return parseLiteral(e);
+  if (e === "true") return true;
+  if (e === "false") return false;
+  if (e === "null") return null;
+  if (/^[-+]?(\d|\.\d)/.test(e) && !Number.isNaN(Number(e))) return Number(e);
+  return `{{${e}}}`;
+}
+function interpretStyleCall(expr) {
+  const args = callArgsOf(expr);
+  const parts = splitTopLevel(args, ",").filter((p) => p.length > 0);
+  const out = {};
+  if (parts[0]) out.style = parseLiteral(parts[0]);
+  if (parts[1]) {
+    const meta = parseLiteral(parts[1]);
+    if (meta.interactive !== void 0) out.interactiveStyles = meta.interactive;
+    if (meta.label !== void 0) out.label = meta.label;
+    if (meta.genClass !== void 0) out.generateElementClass = meta.genClass;
+  }
+  return out;
+}
+function reverseCondition(cond) {
+  const c = cond.trim();
+  if (c === "false") return false;
+  if (c === "true") return true;
+  if (c.startsWith("when(")) return parseLiteral(callArgsOf(c));
+  return `{{${c}}}`;
+}
+
+// lib/dialect/parse/parseContext.ts
+function createParseContext() {
+  return {
+    collectionBindings: /* @__PURE__ */ new Map(),
+    embedConsts: /* @__PURE__ */ new Map(),
+    tagConsts: /* @__PURE__ */ new Map(),
+    componentNames: /* @__PURE__ */ new Set()
+  };
+}
+
+// lib/dialect/parse/parseFrontmatter.ts
+function literalAfter(code, anchor) {
+  const idx = code.indexOf(anchor);
+  if (idx < 0) return void 0;
+  return parseValueAt(code, idx + anchor.length).value;
+}
+function parseFrontmatter(code) {
+  const ctx = createParseContext();
+  for (const m of code.matchAll(/import\s+(\w+)\s+from\s+'(?:\.\/|(?:\.\.\/)+components\/)[\w.-]+\.astro'/g)) {
+    ctx.componentNames.add(m[1]);
+  }
+  for (const m of code.matchAll(/const\s+(__embed\d+)\s*=\s*/g)) {
+    const tickStart = code.indexOf("`", m.index + m[0].length);
+    if (tickStart < 0) continue;
+    const tickEnd = scanTemplate(code, tickStart);
+    ctx.embedConsts.set(m[1], reverseTemplate(code.slice(tickStart + 1, tickEnd - 1)));
+  }
+  for (const m of code.matchAll(/const\s+(Tag_\d+)\s*=\s*/g)) {
+    const tickStart = code.indexOf("`", m.index + m[0].length);
+    if (tickStart < 0) continue;
+    const tickEnd = scanTemplate(code, tickStart);
+    ctx.tagConsts.set(m[1], reverseTemplate(code.slice(tickStart + 1, tickEnd - 1)));
+  }
+  for (const m of code.matchAll(/const\s+(\w+)\s*=\s*await\s+getCollectionList\(/g)) {
+    const open = m.index + m[0].length - 1;
+    const inner = code.slice(open + 1, scanBalanced(code, open) - 1);
+    const args = splitTopLevel(inner, ",").filter(Boolean);
+    const source = parseLiteral(args[0]);
+    const query = args.length >= 3 ? parseLiteral(args[1]) : void 0;
+    ctx.collectionBindings.set(m[1], { source, query });
+  }
+  const propsInterface = literalAfter(code, "resolveProps(Astro, ");
+  const componentMeta = literalAfter(code, "const __meno = ") ?? {};
+  const meta = literalAfter(code, "export const meta = ");
+  const kind = code.includes("resolveProps(") ? "component" : "page";
+  return { kind, ctx, meta, propsInterface, componentMeta };
+}
+
+// lib/dialect/parse/parseBody.ts
+var WS2 = /* @__PURE__ */ new Set([" ", "	", "\r", "\n"]);
+var RUNTIME_TAGS = /* @__PURE__ */ new Set(["Link", "Embed", "LocaleList", "BaseLayout"]);
+var LOCALE_STYLE_PROPS = /* @__PURE__ */ new Set([
+  "style",
+  "itemStyle",
+  "activeItemStyle",
+  "separatorStyle",
+  "flagStyle"
+]);
+function skipWs2(src, i) {
+  while (i < src.length && WS2.has(src[i])) i++;
+  return i;
+}
+function readTagName(src, i) {
+  let j = i;
+  while (j < src.length && /[A-Za-z0-9.\-_]/.test(src[j])) j++;
+  return { name: src.slice(i, j), end: j };
+}
+function parseAttributes(src, i) {
+  const attrs = [];
+  let j = i;
+  for (; ; ) {
+    j = skipWs2(src, j);
+    if (src[j] === "/" && src[j + 1] === ">") return { attrs, end: j + 2, selfClose: true };
+    if (src[j] === ">") return { attrs, end: j + 1, selfClose: false };
+    const { name, end } = readTagName(src, j);
+    if (!name) throw new Error(`parseAttributes: expected attribute name at ${j} ("${src.slice(j, j + 15)}")`);
+    j = end;
+    if (src[j] === "=") {
+      j++;
+      if (src[j] === '"' || src[j] === "'") {
+        const q = src[j];
+        let k = j + 1;
+        while (k < src.length && src[k] !== q) {
+          if (src[k] === "\\") k++;
+          k++;
+        }
+        attrs.push({ name, raw: src.slice(j + 1, k), isExpr: false });
+        j = k + 1;
+      } else if (src[j] === "{") {
+        const close = scanBalanced(src, j);
+        attrs.push({ name, raw: src.slice(j + 1, close - 1), isExpr: true });
+        j = close;
+      } else {
+        throw new Error(`parseAttributes: bad attribute value for "${name}" at ${j}`);
+      }
+    } else {
+      attrs.push({ name, raw: "", isExpr: false, shorthand: true });
+    }
+  }
+}
+function attrValue(a, ctx) {
+  if (a.shorthand) return true;
+  if (!a.isExpr) return a.raw;
+  return interpretExprValue(a.raw, ctx);
+}
+function parseElement(src, i, ctx) {
+  i = skipWs2(src, i);
+  if (src[i] !== "<") throw new Error(`parseElement: expected "<" at ${i}`);
+  const { name: tag, end: afterTag } = readTagName(src, i + 1);
+  const { attrs, end: afterAttrs, selfClose } = parseAttributes(src, afterTag);
+  let children = [];
+  let end = afterAttrs;
+  if (!selfClose) {
+    const inner = parseNodes(src, afterAttrs, ctx, tag);
+    children = inner.nodes;
+    const close = src.indexOf(">", inner.end);
+    end = close + 1;
+  }
+  return { node: elementToNode(tag, attrs, children, ctx), end };
+}
+function parseNodes(src, i, ctx, stopTag) {
+  const nodes = [];
+  let j = i;
+  while (j < src.length) {
+    const k = skipWs2(src, j);
+    if (k >= src.length) {
+      j = k;
+      break;
+    }
+    if (stopTag && src[k] === "<" && src[k + 1] === "/") return { nodes, end: k };
+    if (src[k] === "<") {
+      const { node, end } = parseElement(src, k, ctx);
+      nodes.push(node);
+      j = end;
+      continue;
+    }
+    if (src[k] === "{") {
+      const end = scanBalanced(src, k);
+      const child = interpretChildExpr(src.slice(k + 1, end - 1), ctx);
+      if (child !== void 0 && child !== null && child !== "") nodes.push(child);
+      j = end;
+      continue;
+    }
+    let t = k;
+    while (t < src.length && src[t] !== "<" && src[t] !== "{") t++;
+    const text = src.slice(k, t).trim();
+    if (text.length) nodes.push(text);
+    j = t;
+  }
+  return { nodes, end: j };
+}
+function interpretChildExpr(inner, ctx) {
+  const e = inner.trim();
+  if (!e) return void 0;
+  const grp = findTrailingGroup(e, "(");
+  if (grp) {
+    const before = e.slice(0, grp.open).trim();
+    if (before.endsWith("&&")) {
+      const cond = before.slice(0, -2).trim();
+      const body = grp.inner.trim();
+      const node = body.startsWith("<") ? parseElement(body, 0, ctx).node : interpretChildExpr(body, ctx);
+      if (node && typeof node === "object") node.if = reverseCondition(cond);
+      return node;
+    }
+    if (before.endsWith(".map")) {
+      return parseMapExpr(e, ctx);
+    }
+  }
+  const val = interpretExprValue(e, ctx);
+  return val;
+}
+function parseMapExpr(e, ctx) {
+  const mapIdx = e.indexOf(".map(");
+  const head = e.slice(0, mapIdx).trim();
+  const argOpen = mapIdx + 4;
+  const argEnd = scanBalanced(e, argOpen);
+  const arg = e.slice(argOpen + 1, argEnd - 1).trim();
+  const paramsEnd = scanBalanced(arg, 0);
+  const params = splitTopLevel(arg.slice(1, paramsEnd - 1), ",").filter(Boolean);
+  const itemVar = params[0];
+  const bodyGrp = findTrailingGroup(arg.slice(paramsEnd).trim(), "(");
+  const children = bodyGrp ? parseNodes(bodyGrp.inner, 0, ctx).nodes : [];
+  if (head.startsWith("list(")) {
+    const inner = callArgsOf(head);
+    const parts = splitTopLevel(inner, ",").filter(Boolean);
+    const opts = parts[1] ? parseLiteral(parts[1]) : {};
+    const node2 = {
+      type: "list",
+      sourceType: "prop",
+      source: `{{${parts[0]}}}`,
+      ...opts,
+      children
+    };
+    if (itemVar && itemVar !== "item") node2.itemAs = itemVar;
+    return node2;
+  }
+  const binding = ctx.collectionBindings.get(head);
+  const source = binding?.source ?? head;
+  const node = {
+    type: "list",
+    sourceType: "collection",
+    source,
+    ...binding?.query ?? {},
+    children
+  };
+  if (itemVar && itemVar !== singularize(source)) node.itemAs = itemVar;
+  return node;
+}
+function applyClass(node, attrs) {
+  const cls = attrs.find((a) => a.name === "class");
+  if (!cls) return;
+  const parsed = interpretStyleCall(cls.raw);
+  if (parsed.style !== void 0) node.style = parsed.style;
+  if (parsed.interactiveStyles !== void 0) node.interactiveStyles = parsed.interactiveStyles;
+  if (parsed.label !== void 0) node.label = parsed.label;
+  if (parsed.generateElementClass !== void 0) node.generateElementClass = parsed.generateElementClass;
+}
+function otherAttrs(attrs, ctx, skip) {
+  const out = {};
+  for (const a of attrs) {
+    if (skip.has(a.name)) continue;
+    out[a.name] = attrValue(a, ctx);
+  }
+  return out;
+}
+function elementToNode(tag, attrs, children, ctx) {
+  if (ctx.tagConsts.has(tag)) {
+    const node2 = { type: "node", tag: ctx.tagConsts.get(tag) };
+    applyClass(node2, attrs);
+    const attributes2 = otherAttrs(attrs, ctx, /* @__PURE__ */ new Set(["class"]));
+    if (Object.keys(attributes2).length) node2.attributes = attributes2;
+    if (children.length) node2.children = children;
+    return node2;
+  }
+  if (tag === "slot") {
+    const node2 = { type: "slot" };
+    if (children.length) node2.default = children;
+    return node2;
+  }
+  if (tag === "Link") {
+    const node2 = { type: "link" };
+    const href = attrs.find((a) => a.name === "href");
+    if (href) node2.href = attrValue(href, ctx);
+    applyClass(node2, attrs);
+    const rest = otherAttrs(attrs, ctx, /* @__PURE__ */ new Set(["href", "class"]));
+    if (Object.keys(rest).length) node2.attributes = rest;
+    if (children.length) node2.children = children;
+    return node2;
+  }
+  if (tag === "Embed") {
+    const node2 = { type: "embed" };
+    const html = attrs.find((a) => a.name === "html");
+    if (html) node2.html = attrValue(html, ctx);
+    applyClass(node2, attrs);
+    const rest = otherAttrs(attrs, ctx, /* @__PURE__ */ new Set(["html", "class"]));
+    if (Object.keys(rest).length) node2.attributes = rest;
+    return node2;
+  }
+  if (tag === "LocaleList") {
+    const node2 = { type: "locale-list" };
+    for (const a of attrs) {
+      if (LOCALE_STYLE_PROPS.has(a.name) && a.isExpr && a.raw.trimStart().startsWith("style(")) {
+        node2[a.name] = parseLiteral(callArgsOf(a.raw));
+      } else if (a.name === "meta" && a.isExpr) {
+        const meta = parseLiteral(a.raw);
+        if (meta.interactive !== void 0) node2.interactiveStyles = meta.interactive;
+        if (meta.label !== void 0) node2.label = meta.label;
+        if (meta.genClass !== void 0) node2.generateElementClass = meta.genClass;
+      } else {
+        node2[a.name] = attrValue(a, ctx);
+      }
+    }
+    return node2;
+  }
+  const isComponent = /^[A-Z]/.test(tag) && !RUNTIME_TAGS.has(tag);
+  if (isComponent) {
+    const node2 = { type: "component", component: tag };
+    applyClass(node2, attrs);
+    const props = otherAttrs(attrs, ctx, /* @__PURE__ */ new Set(["class"]));
+    if (Object.keys(props).length) node2.props = props;
+    if (children.length) node2.children = children;
+    return node2;
+  }
+  const node = { type: "node", tag };
+  applyClass(node, attrs);
+  const attributes = otherAttrs(attrs, ctx, /* @__PURE__ */ new Set(["class"]));
+  if (Object.keys(attributes).length) node.attributes = attributes;
+  if (children.length) node.children = children;
+  return node;
+}
+
+// lib/dialect/parse/parseFile.ts
+function splitFrontmatter(source) {
+  const m = source.match(/^---\n([\s\S]*?)\n---\n([\s\S]*)$/);
+  return m ? { code: m[1], body: m[2] } : { code: "", body: source };
+}
+function parseDefineVars(openTag) {
+  const m = openTag.match(/define:vars=\{\{([^}]*)\}\}/);
+  if (!m) return void 0;
+  return m[1].split(",").map((s) => s.trim()).filter(Boolean);
+}
+function splitComponentBody(body, ctx) {
+  let rest = body;
+  let javascript;
+  let defineVars;
+  let css;
+  const scriptM = rest.match(/\n*<script([^>]*)>\n([\s\S]*?)\n<\/script>\s*$/);
+  if (scriptM) {
+    javascript = scriptM[2];
+    defineVars = parseDefineVars(scriptM[1]);
+    rest = rest.slice(0, scriptM.index);
+  }
+  const styleM = rest.match(/\n*<style>\n([\s\S]*?)\n<\/style>\s*$/);
+  if (styleM) {
+    css = styleM[1];
+    rest = rest.slice(0, styleM.index);
+  }
+  const markup = rest.trim();
+  const structure = markup ? parseNodes(markup, 0, ctx).nodes[0] : void 0;
+  return { structure, css, javascript, defineVars };
+}
+function parsePageRoot(body, ctx) {
+  const trimmed = body.trim();
+  if (!trimmed.startsWith("<")) return void 0;
+  const wrapper = parseElement(trimmed, 0, ctx).node;
+  const children = wrapper.children;
+  return Array.isArray(children) ? children[0] : void 0;
+}
+function parseFile(source) {
+  const { code, body } = splitFrontmatter(source);
+  const front = parseFrontmatter(code);
+  if (front.kind === "component") {
+    const { structure, css, javascript, defineVars } = splitComponentBody(body, front.ctx);
+    const def = {};
+    if (front.propsInterface && Object.keys(front.propsInterface).length) {
+      def.interface = front.propsInterface;
+    }
+    if (structure !== void 0) def.structure = structure;
+    Object.assign(def, front.componentMeta);
+    if (css !== void 0) def.css = css;
+    if (javascript !== void 0) def.javascript = javascript;
+    if (defineVars !== void 0) def.defineVars = defineVars;
+    return { model: { component: def } };
+  }
+  const root = parsePageRoot(body, front.ctx);
+  const page = {};
+  if (front.meta !== void 0) page.meta = front.meta;
+  if (root !== void 0) page.root = root;
+  return { model: page };
+}
+
+// lib/dialect/normalize.ts
+function hasStyleContent2(style) {
+  if (!style || typeof style !== "object") return false;
+  for (const v of Object.values(style)) {
+    if (v === void 0 || v === null) continue;
+    if (typeof v === "object") {
+      if (Object.keys(v).length > 0) return true;
+    } else {
+      return true;
+    }
+  }
+  return false;
+}
+function normalizeChildren(children) {
+  if (typeof children === "string") return children;
+  if (!Array.isArray(children)) return void 0;
+  const items = children.map(normalizeChild);
+  if (items.length === 0) return void 0;
+  if (items.length === 1 && typeof items[0] === "string") return items[0];
+  return items;
+}
+function normalizeChild(child) {
+  return typeof child === "string" ? child : normalizeNode(child);
+}
+function migrateLegacy(n) {
+  if (n.type === "cms-list") {
+    const { type, collection, style, attributes, children, ...rest } = n;
+    const list = {
+      type: "list",
+      sourceType: "collection",
+      source: collection,
+      ...rest
+    };
+    if (list.itemAs === void 0) list.itemAs = "item";
+    if (children !== void 0) list.children = children;
+    if (style !== void 0 || attributes !== void 0) {
+      const wrapper = { type: "node", tag: "div" };
+      if (style !== void 0) wrapper.style = style;
+      if (attributes !== void 0) wrapper.attributes = attributes;
+      wrapper.children = [list];
+      return wrapper;
+    }
+    return list;
+  }
+  if (n.type === "image") {
+    const { type, src, alt, style, attributes, ...rest } = n;
+    const attrs = { ...attributes };
+    if (src !== void 0) attrs.src = src;
+    if (alt !== void 0) attrs.alt = alt;
+    const img = { type: "node", tag: "img", ...rest };
+    if (Object.keys(attrs).length) img.attributes = attrs;
+    if (style !== void 0) img.style = style;
+    return img;
+  }
+  return n;
+}
+function normalizeNode(node) {
+  if (typeof node === "string") return node;
+  if (!node || typeof node !== "object") return node;
+  const out = migrateLegacy({ ...node });
+  if ("style" in out && !hasStyleContent2(out.style)) delete out.style;
+  if (out.type === "node" && out.props && typeof out.props === "object") {
+    out.attributes = { ...out.props, ...out.attributes ?? {} };
+    delete out.props;
+  }
+  if (out.type === "list") {
+    const sourceType = out.sourceType ?? "prop";
+    if (sourceType !== "collection" && typeof out.source === "string" && !out.source.includes("{{")) {
+      out.source = `{{${out.source}}}`;
+    }
+    const defaultItem = sourceType === "collection" ? singularize(String(out.source)) : "item";
+    if (out.itemAs === defaultItem) delete out.itemAs;
+  }
+  if ("children" in out) {
+    const c = normalizeChildren(out.children);
+    if (c === void 0) delete out.children;
+    else out.children = c;
+  }
+  if ("default" in out) {
+    const d = normalizeChildren(out.default);
+    if (d === void 0) delete out.default;
+    else out.default = d;
+  }
+  return out;
+}
+function normalizeDefineVars(comp) {
+  if (comp.defineVars === void 0) return;
+  if (!comp.javascript) {
+    delete comp.defineVars;
+    return;
+  }
+  if (Array.isArray(comp.defineVars)) {
+    const names = comp.defineVars;
+    const all = Object.keys(comp.interface ?? {}).filter(
+      (k) => k !== "children"
+    );
+    const sameSet = names.length === all.length && new Set(names).size === all.length && all.every((k) => names.includes(k));
+    if (sameSet) comp.defineVars = true;
+  }
+}
+function normalizeModel(model) {
+  if (!model || typeof model !== "object") return model;
+  const m = model;
+  if (m.component && typeof m.component === "object") {
+    const comp = { ...m.component };
+    if ("interface" in comp && (!comp.interface || Object.keys(comp.interface).length === 0)) {
+      delete comp.interface;
+    }
+    if (comp.structure !== void 0) comp.structure = normalizeNode(comp.structure);
+    normalizeDefineVars(comp);
+    return { ...m, component: comp };
+  }
+  const out = { ...m };
+  if ("meta" in out && (!out.meta || Object.keys(out.meta).length === 0)) delete out.meta;
+  if (out.root !== void 0) out.root = normalizeNode(out.root);
+  return out;
+}
+
+// lib/dialect/index.ts
+function emit(model) {
+  const m = normalizeModel(model);
+  if (m && typeof m === "object") {
+    if (m.component && typeof m.component === "object") return emitComponent(m.component);
+    if (m.structure !== void 0 || m.interface !== void 0 || m.javascript !== void 0 || m.css !== void 0) {
+      return emitComponent(m);
+    }
+  }
+  return emitPage(m);
+}
+function parse(source) {
+  const { model } = parseFile(source);
+  return { model: normalizeModel(model), regions: [] };
+}
+export {
+  emit,
+  normalizeModel,
+  parse
+};
+//# sourceMappingURL=index.js.map