@revenexx/editor 0.1.0

package/dist/module.mjs

@@ -0,0 +1,4935 @@
+import { resolveAlias, resolveFiles, createResolver, addComponent, addImports, addTemplate, useLogger, defineNuxtModule, addPlugin, addBuildPlugin, addVitePlugin, updateTemplates } from '@nuxt/kit';
+import path__default, { basename, dirname as dirname$1, resolve as resolve$1, join } from 'node:path';
+import { createUnplugin } from 'unplugin';
+import MagicString from 'magic-string';
+import { walk } from 'estree-walker-ts';
+import { pathToFileURL } from 'node:url';
+import { parseURL, parseQuery } from 'ufo';
+import { C as Collector, a as CollectedFile, c as extractObjectLiteral, p as parseTsObject, t as toValidVariableName, o as onlyUnique, f as falsy, s as sortObjectKeys } from './shared/editor.Gu7mgJ5Q.mjs';
+import { dirname, resolve, relative } from 'pathe';
+import micromatch from 'micromatch';
+import { hash } from 'ohash';
+import fs__default, { readFileSync, existsSync, readdirSync } from 'node:fs';
+import { TRANSLATION_LANGUAGES, BK_VISIBLE_LANGUAGES, BK_HIDDEN_GLOBALLY } from './global/constants';
+import { createRequire } from 'node:module';
+import { d as defineCodeTemplate, a as defineFileTemplate, w as withHelper } from './shared/editor.6D5vApr0.mjs';
+import * as acorn from 'acorn';
+import { defu, createDefu } from 'defu';
+import 'typescript';
+import 'oxc-walker';
+
+const name = "@revenexx/editor";
+const version = "0.1.0";
+
+function validateOption(optionKey, option, icons) {
+  const errors = [];
+  switch (option.type) {
+    case "radios": {
+      const defaultValue = option.default;
+      const availableOptions = option.options;
+      if (availableOptions && typeof availableOptions === "object" && defaultValue !== void 0) {
+        const optionKeys = Object.keys(availableOptions);
+        if (!optionKeys.includes(defaultValue)) {
+          errors.push({
+            message: `Option "${optionKey}" has default value "${defaultValue}" which is not one of the available options: ${optionKeys.map((k) => `"${k}"`).join(", ")}`,
+            optionKey
+          });
+        }
+      }
+      if (option.displayAs === "icons") {
+        const options = Object.entries(option.options);
+        for (const [optionsOptionKey, optionsOptionValue] of options) {
+          const icon = optionsOptionValue.icon;
+          if (!icons.isValidIconName(icon)) {
+            errors.push({
+              message: `Invalid icon name "${icon}" in option "${optionsOptionKey}" of "${optionKey}".`,
+              optionKey
+            });
+          }
+        }
+      }
+      break;
+    }
+    case "checkboxes": {
+      const defaultValues = option.default;
+      const availableOptions = option.options;
+      if (Array.isArray(defaultValues) && availableOptions && typeof availableOptions === "object") {
+        const optionKeys = Object.keys(availableOptions);
+        for (const value of defaultValues) {
+          if (!optionKeys.includes(value)) {
+            errors.push({
+              message: `Option "${optionKey}" has default value "${value}" which is not one of the available options: ${optionKeys.map((k) => `"${k}"`).join(", ")}`,
+              optionKey
+            });
+          }
+        }
+      }
+      break;
+    }
+    case "number":
+    case "range": {
+      const defaultValue = option.default;
+      const min = option.min;
+      const max = option.max;
+      if (typeof min === "number" && typeof max === "number" && min > max) {
+        errors.push({
+          message: `Option "${optionKey}" has minimum value ${min} which is greater than the maximum value ${max}`,
+          optionKey
+        });
+      }
+      if (typeof defaultValue === "number") {
+        if (typeof min === "number" && defaultValue < min) {
+          errors.push({
+            message: `Option "${optionKey}" has default value ${defaultValue} which is less than the minimum value ${min}`,
+            optionKey
+          });
+        }
+        if (typeof max === "number" && defaultValue > max) {
+          errors.push({
+            message: `Option "${optionKey}" has default value ${defaultValue} which is greater than the maximum value ${max}`,
+            optionKey
+          });
+        }
+      } else if (defaultValue === void 0 && option.type === "number" && !option.nullable) {
+        errors.push({
+          message: `Option "${optionKey}" of type "number" must declare a default value (or set "nullable: true").`,
+          optionKey
+        });
+      }
+      break;
+    }
+    case "color": {
+      const defaultValue = option.default;
+      if (typeof defaultValue === "string") {
+        const hexColorRegex = /^#[0-9A-F]{6}$/i;
+        if (!hexColorRegex.test(defaultValue)) {
+          errors.push({
+            message: `Option "${optionKey}" has default value "${defaultValue}" which is not a valid hex color (expected format: #RRGGBB)`,
+            optionKey
+          });
+        }
+      }
+      break;
+    }
+    case "datetime-local": {
+      const defaultValue = option.default;
+      const min = option.min;
+      const max = option.max;
+      if (typeof defaultValue === "string") {
+        const defaultDate = new Date(defaultValue);
+        if (Number.isNaN(defaultDate.getTime())) {
+          errors.push({
+            message: `Option "${optionKey}" has default value "${defaultValue}" which is not a valid datetime`,
+            optionKey
+          });
+        } else {
+          if (typeof min === "string") {
+            const minDate = new Date(min);
+            if (!Number.isNaN(minDate.getTime()) && defaultDate < minDate) {
+              errors.push({
+                message: `Option "${optionKey}" has default value "${defaultValue}" which is before the minimum "${min}"`,
+                optionKey
+              });
+            }
+          }
+          if (typeof max === "string") {
+            const maxDate = new Date(max);
+            if (!Number.isNaN(maxDate.getTime()) && defaultDate > maxDate) {
+              errors.push({
+                message: `Option "${optionKey}" has default value "${defaultValue}" which is after the maximum "${max}"`,
+                optionKey
+              });
+            }
+          }
+        }
+      }
+      break;
+    }
+  }
+  return errors;
+}
+function validateOptions(options, icons) {
+  if (!options) {
+    return [];
+  }
+  const errors = [];
+  for (const [optionKey, option] of Object.entries(options)) {
+    if (!option || typeof option !== "object") {
+      continue;
+    }
+    const optionErrors = validateOption(optionKey, option, icons);
+    errors.push(...optionErrors);
+  }
+  return errors;
+}
+
+const DEFINE_BLOKKLI = "defineBlokkli";
+const DEFINE_BLOKKLI_FRAGMENT = "defineBlokkliFragment";
+const DEFINE_BLOKKLI_PROVIDER = "defineBlokkliProvider";
+function isEditComponent(filePath) {
+  return filePath.endsWith("/diff.vue") || filePath.endsWith("/proxy.vue");
+}
+function isBlock(definition) {
+  return "bundle" in definition && !("entityType" in definition);
+}
+function isFragment(definition) {
+  return "name" in definition;
+}
+function getVariations(definition) {
+  if (!definition) {
+    return [];
+  }
+  if (isBlock(definition)) {
+    const bundle = definition.bundle;
+    if (!definition.renderFor) {
+      return ["block:" + bundle];
+    }
+    const renderFor = Array.isArray(definition.renderFor) ? definition.renderFor : [definition.renderFor];
+    return renderFor.map((v) => {
+      if ("parentBundle" in v) {
+        return `block:${bundle}__p:${v.parentBundle}`;
+      } else if ("fieldList" in v) {
+        return `block:${bundle}__f:${v.fieldList}`;
+      } else if ("providerType" in v) {
+        return `block:${bundle}__t:${v.providerType}`;
+      } else {
+        return `block:${bundle}__f:${v.fieldListType}`;
+      }
+    }).sort();
+  } else if (isFragment(definition)) {
+    return [`fragment:${definition.name}`];
+  }
+  return [`provider:${definition.entityType}:${definition.bundle}`];
+}
+function getIdentifier(definition) {
+  if (isBlock(definition)) {
+    return toValidVariableName(
+      "b_" + hash(definition.bundle + getVariations(definition).join("__"))
+    );
+  } else if (isFragment(definition)) {
+    return toValidVariableName(
+      "f_" + hash(definition.name + getVariations(definition).join("__"))
+    );
+  }
+  return toValidVariableName(
+    "p_" + hash(
+      definition.entityType + "__" + definition.bundle + getVariations(definition).join("__")
+    )
+  );
+}
+function validateBlockDefinition(definition, icons) {
+  const errors = [];
+  if ("options" in definition && definition.options) {
+    const optionErrors = validateOptions(
+      definition.options,
+      icons
+    );
+    errors.push(...optionErrors);
+  }
+  if ("renderFor" in definition && definition.renderFor) {
+    const renderFor = Array.isArray(definition.renderFor) ? definition.renderFor : [definition.renderFor];
+    for (const entry of renderFor) {
+      if ("fieldList" in entry) {
+        errors.push({
+          message: `renderFor uses deprecated "fieldList" property. Use "fieldListType" instead.`,
+          severity: "warning"
+        });
+      }
+    }
+  }
+  return errors;
+}
+class CollectedBlockFile extends CollectedFile {
+  folder = "";
+  iconPath = null;
+  imagePath = null;
+  iconContents = null;
+  diffComponentPath = null;
+  proxyComponentPath = null;
+  type = null;
+  definition = null;
+  definitionSource = null;
+  hasBlokkliField = false;
+  identifier = "";
+  chunkName = "global";
+  variations = [];
+  objectLiteralString = "";
+  validationCache = null;
+  hasSiblingFile(providedName, helper) {
+    const candidates = Array.isArray(providedName) ? providedName : [providedName];
+    for (let i = 0; i < candidates.length; i++) {
+      const name = candidates[i];
+      const siblingFilePath = path__default.join(this.folder, "/" + name);
+      if (helper.fileCache.fileExists(siblingFilePath)) {
+        return siblingFilePath;
+      }
+    }
+    return null;
+  }
+  async handleChange(helper) {
+    this.validationCache = null;
+    this.folder = dirname(this.filePath);
+    const diffComponentPath = this.hasSiblingFile("diff.vue", helper);
+    const proxyComponentPath = this.hasSiblingFile("proxy.vue", helper);
+    const objectLiteralString = extractObjectLiteral(this.fileContents, [
+      DEFINE_BLOKKLI,
+      DEFINE_BLOKKLI_FRAGMENT,
+      DEFINE_BLOKKLI_PROVIDER
+    ]);
+    if (objectLiteralString === this.objectLiteralString && diffComponentPath === this.diffComponentPath && proxyComponentPath === this.proxyComponentPath) {
+      return false;
+    }
+    this.objectLiteralString = objectLiteralString || "";
+    this.diffComponentPath = diffComponentPath;
+    this.proxyComponentPath = proxyComponentPath;
+    try {
+      if (this.objectLiteralString) {
+        const result = parseTsObject(
+          this.objectLiteralString
+        );
+        this.definition = result.object;
+        this.definitionSource = result.source;
+        if (isBlock(this.definition)) {
+          this.definition.bundle = helper.getMappedBlockBundle(
+            this.definition.bundle
+          );
+        }
+      }
+    } catch (e) {
+      console.log(e);
+      console.error(
+        `Failed to parse component "${this.filePath}": The composabe does not contain a valid object literal. No variables and methods are allowed inside the composable.`,
+        e
+      );
+      return false;
+    }
+    this.hasBlokkliField = this.fileContents.includes("<BlokkliField") || this.fileContents.includes("<blokkli-field") || this.fileContents.includes(':is="BlokkliField"');
+    this.chunkName = this.definition?.chunkName || "global";
+    this.identifier = this.definition ? getIdentifier(this.definition) : "";
+    if (!this.definition) {
+      this.type = null;
+    } else if (isBlock(this.definition)) {
+      if (this.definition.renderFor) {
+        this.type = "context";
+      } else {
+        this.type = "main";
+      }
+    } else if (isFragment(this.definition)) {
+      this.type = "fragment";
+    } else {
+      this.type = "provider";
+    }
+    if (this.type === "main") {
+      this.iconPath = this.hasSiblingFile("icon.svg", helper);
+      this.imagePath = this.hasSiblingFile(
+        ["image.png", "image.jpg", "image.svg"],
+        helper
+      );
+      if (this.iconPath) {
+        this.iconContents = await helper.fileCache.read(this.iconPath);
+      }
+    } else {
+      this.iconPath = null;
+      this.iconContents = null;
+    }
+    this.variations = getVariations(this.definition);
+    return true;
+  }
+  /**
+   * Validate the block definition and return any errors.
+   * Results are cached and invalidated when the file changes.
+   */
+  validate(icons) {
+    if (this.validationCache !== null) {
+      return this.validationCache;
+    }
+    if (!this.definition) {
+      this.validationCache = [];
+      return this.validationCache;
+    }
+    const errors = validateBlockDefinition(this.definition, icons);
+    if (this.type === "main" && isBlock(this.definition)) {
+      const hasIconFile = !!this.iconPath;
+      const hasEditorIcon = !!(this.definition.editor && "icon" in this.definition.editor && this.definition.editor.icon);
+      if (!hasIconFile && !hasEditorIcon) {
+        errors.push({
+          message: `Block is missing an icon. Add an icon.svg file or set editor.icon in the definition.`,
+          severity: "warning"
+        });
+      }
+    }
+    if (this.fileContents.includes("isEditing")) {
+      const isEditingPattern = /\bisEditing\b[^\n\r=\u2028\u2029]*=.*defineBlokkli\s*\(|defineBlokkli\s*\([^)]*\).*\bisEditing\b|\{[^}]*\bisEditing\b[^}]*\}\s*=\s*defineBlokkli/;
+      if (isEditingPattern.test(this.fileContents)) {
+        errors.push({
+          message: `Using deprecated "isEditing" property. Use "import.meta.blokkliEditing" instead.`,
+          severity: "warning"
+        });
+      }
+    }
+    this.validationCache = errors;
+    return this.validationCache;
+  }
+}
+function validateBundleOptionCompatibility(files) {
+  const conflicts = [];
+  const bundleGroups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (!file.definition || !isBlock(file.definition)) {
+      continue;
+    }
+    const bundle = file.definition.bundle;
+    const existing = bundleGroups.get(bundle) || [];
+    existing.push(file);
+    bundleGroups.set(bundle, existing);
+  }
+  for (const [bundle, bundleFiles] of bundleGroups) {
+    if (bundleFiles.length < 2) {
+      continue;
+    }
+    const optionInfos = /* @__PURE__ */ new Map();
+    for (const file of bundleFiles) {
+      if (!file.definition || !isBlock(file.definition)) {
+        continue;
+      }
+      const options = file.definition.options;
+      if (!options) {
+        continue;
+      }
+      for (const [optionKey, option] of Object.entries(options)) {
+        if (!option || typeof option !== "object" || !option.type) {
+          continue;
+        }
+        const info = {
+          filePath: file.filePath,
+          type: option.type
+        };
+        if ((option.type === "radios" || option.type === "checkboxes") && option.options && typeof option.options === "object") {
+          info.optionKeys = Object.keys(option.options).sort();
+        }
+        const existing = optionInfos.get(optionKey) || [];
+        existing.push(info);
+        optionInfos.set(optionKey, existing);
+      }
+    }
+    for (const [optionKey, entries] of optionInfos) {
+      if (entries.length < 2) {
+        continue;
+      }
+      const types = new Set(entries.map((e) => e.type));
+      if (types.size > 1) {
+        conflicts.push({
+          bundle,
+          optionKey,
+          reason: "type",
+          conflicts: entries
+        });
+        continue;
+      }
+      const entriesWithOptionKeys = entries.filter((e) => e.optionKeys);
+      if (entriesWithOptionKeys.length >= 2) {
+        const optionKeySets = entriesWithOptionKeys.map(
+          (e) => e.optionKeys.join(",")
+        );
+        const uniqueOptionKeySets = new Set(optionKeySets);
+        if (uniqueOptionKeySets.size > 1) {
+          conflicts.push({
+            bundle,
+            optionKey,
+            reason: "options",
+            conflicts: entriesWithOptionKeys
+          });
+        }
+      }
+    }
+  }
+  return conflicts;
+}
+function validateRenderForConflicts(files) {
+  const conflicts = [];
+  const bundleGroups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (!file.definition || !isBlock(file.definition)) {
+      continue;
+    }
+    const bundle = file.definition.bundle;
+    const existing = bundleGroups.get(bundle) || [];
+    existing.push(file);
+    bundleGroups.set(bundle, existing);
+  }
+  for (const [bundle, bundleFiles] of bundleGroups) {
+    if (bundleFiles.length < 2) {
+      continue;
+    }
+    const variationToFiles = /* @__PURE__ */ new Map();
+    for (const file of bundleFiles) {
+      for (const variation of file.variations) {
+        const existing = variationToFiles.get(variation) || [];
+        existing.push(file.filePath);
+        variationToFiles.set(variation, existing);
+      }
+    }
+    for (const [variation, filePaths] of variationToFiles) {
+      if (filePaths.length > 1) {
+        conflicts.push({
+          bundle,
+          variation,
+          filePaths
+        });
+      }
+    }
+  }
+  return conflicts;
+}
+function validateMissingMainComponent(files) {
+  const errors = [];
+  const bundleGroups = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    if (!file.definition || !isBlock(file.definition)) {
+      continue;
+    }
+    const bundle = file.definition.bundle;
+    const existing = bundleGroups.get(bundle) || { main: [], context: [] };
+    if (file.type === "main") {
+      existing.main.push(file.filePath);
+    } else if (file.type === "context") {
+      existing.context.push(file.filePath);
+    }
+    bundleGroups.set(bundle, existing);
+  }
+  for (const [bundle, { main, context }] of bundleGroups) {
+    if (context.length > 0 && main.length === 0) {
+      errors.push({
+        bundle,
+        filePaths: context
+      });
+    }
+  }
+  return errors;
+}
+class BlockCollector extends Collector {
+  constructor(helper, icons) {
+    super(helper);
+    this.icons = icons;
+    this.patterns = (helper.options.pattern || []).map((pattern) => {
+      if (pattern.startsWith("/")) {
+        return pattern;
+      } else if (pattern.startsWith(".")) {
+        return helper.resolvers.src.resolve(pattern);
+      }
+      return resolveAlias(pattern);
+    });
+  }
+  patterns;
+  async init() {
+    const files = await resolveFiles(
+      this.helper.nuxt.options.srcDir,
+      this.patterns
+    );
+    const promises = [];
+    for (const filePath of files) {
+      const applies = await this.applies(filePath);
+      if (applies) {
+        promises.push(this.addFile(filePath));
+      }
+    }
+    await Promise.all(promises);
+  }
+  runHooks() {
+    return this.helper.nuxt.hooks.callHook("blokkli:alter-blocks", {
+      blocks: [...this.files.values()]
+    });
+  }
+  createCollectedFile(filePath, fileContents = "") {
+    return new CollectedBlockFile(filePath, fileContents);
+  }
+  findBlockForFolderFile(iconPath) {
+    for (const file of this.files.values()) {
+      if (file.iconPath === iconPath || file.proxyComponentPath === iconPath || file.diffComponentPath === iconPath) {
+        return file.filePath;
+      }
+    }
+    return null;
+  }
+  async handleAdd(filePath) {
+    if (isEditComponent(filePath)) {
+      const folder = dirname(filePath);
+      for (const file of this.files.values()) {
+        if (file.folder === folder) {
+          return super.handleChange(file.filePath);
+        }
+      }
+    }
+    return super.handleAdd(filePath);
+  }
+  async handleUnlink(filePath) {
+    if (isEditComponent(filePath)) {
+      const folder = dirname(filePath);
+      for (const file of this.files.values()) {
+        if (file.folder === folder) {
+          return super.handleChange(file.filePath);
+        }
+      }
+    }
+    return super.handleUnlink(filePath);
+  }
+  async handleChange(filePath) {
+    if (filePath.includes("icon.svg")) {
+      const matchingBlockFilePath = this.findBlockForFolderFile(filePath);
+      if (matchingBlockFilePath) {
+        return this.handleChange(matchingBlockFilePath);
+      }
+      return false;
+    }
+    return super.handleChange(filePath);
+  }
+  async applies(filePath) {
+    if (!filePath.endsWith(".vue")) {
+      return false;
+    }
+    if (!micromatch.isMatch(filePath, this.patterns)) {
+      return false;
+    }
+    if (isEditComponent(filePath)) {
+      return true;
+    }
+    const content = await this.helper.fileCache.read(filePath);
+    return content.includes(DEFINE_BLOKKLI) || content.includes(DEFINE_BLOKKLI_FRAGMENT) || content.includes(DEFINE_BLOKKLI_PROVIDER);
+  }
+  getDependencyTypes() {
+    return ["block-content", "block-path"];
+  }
+  validate(icons) {
+    const hasFileErrors = super.validate(icons);
+    const files = [...this.files.values()];
+    let hasCollectorErrors = false;
+    const optionConflicts = validateBundleOptionCompatibility(files);
+    if (optionConflicts.length > 0) {
+      const lines = optionConflicts.flatMap((conflict) => {
+        const reasonLabel = conflict.reason === "type" ? "conflicting types" : "conflicting option keys";
+        return [
+          `  Bundle "${conflict.bundle}", option "${conflict.optionKey}" (${reasonLabel}):`,
+          ...conflict.conflicts.map((c) => {
+            if (conflict.reason === "options" && c.optionKeys) {
+              return `    - ${c.filePath} (keys: ${c.optionKeys.join(", ")})`;
+            }
+            return `    - ${c.filePath} (type: ${c.type})`;
+          })
+        ];
+      });
+      this.helper.logger.error(
+        `bl\xF6kkli option conflicts across bundle components:
+${lines.join("\n")}`
+      );
+      hasCollectorErrors = true;
+    }
+    const renderForConflicts = validateRenderForConflicts(files);
+    if (renderForConflicts.length > 0) {
+      const lines = renderForConflicts.flatMap((conflict) => [
+        `  Bundle "${conflict.bundle}", variation "${conflict.variation}":`,
+        ...conflict.filePaths.map((fp) => `    - ${fp}`)
+      ]);
+      this.helper.logger.error(
+        `bl\xF6kkli duplicate renderFor entries:
+${lines.join("\n")}`
+      );
+      hasCollectorErrors = true;
+    }
+    const missingMainErrors = validateMissingMainComponent(files);
+    if (missingMainErrors.length > 0) {
+      const lines = missingMainErrors.flatMap((error) => [
+        `  Bundle "${error.bundle}":`,
+        ...error.filePaths.map((fp) => `    - ${fp}`)
+      ]);
+      this.helper.logger.error(
+        `bl\xF6kkli bundles with renderFor components but no main component:
+${lines.join("\n")}`
+      );
+      hasCollectorErrors = true;
+    }
+    return hasFileErrors || hasCollectorErrors;
+  }
+}
+
+function isVue(id, opts = {}) {
+  const { search } = parseURL(decodeURIComponent(pathToFileURL(id).href));
+  if (id.endsWith(".vue") && !search) {
+    return true;
+  }
+  if (!search) {
+    return false;
+  }
+  const query = parseQuery(search);
+  if (query.nuxt_component) {
+    return false;
+  }
+  if (query.macro && (search === "?macro=true" || !opts.type || opts.type.includes("script"))) {
+    return true;
+  }
+  const type = "setup" in query ? "script" : query.type;
+  if (!("vue" in query) || opts.type && !opts.type.includes(type)) {
+    return false;
+  }
+  return true;
+}
+function generateRuntimeArg(definition) {
+  if (isBlock(definition)) {
+    return `${definition.bundle}::${getIdentifier(definition)}`;
+  } else if (isFragment(definition)) {
+    return `${definition.name}::${getIdentifier(definition)}`;
+  }
+  return `${definition.entityType}__${definition.bundle}::${getIdentifier(definition)}`;
+}
+const RuntimeDefinitionPlugin = (nuxt, helper, composableName, argIndex = 0) => {
+  const cache = /* @__PURE__ */ new Map();
+  function extract(source) {
+    const fromCache = cache.get(source);
+    if (fromCache) {
+      return fromCache;
+    }
+    const definition = parseTsObject(source);
+    if (definition.object) {
+      if (isBlock(definition.object)) {
+        definition.object.bundle = helper.getMappedBlockBundle(
+          definition.object.bundle
+        );
+      }
+      cache.set(source, definition.object);
+      return definition.object;
+    }
+    return null;
+  }
+  return createUnplugin(() => {
+    return {
+      name: "blokkli:runtime-definition",
+      enforce: "post",
+      transformInclude(id) {
+        return isVue(id);
+      },
+      transform(source) {
+        if (!source.includes(composableName)) {
+          return;
+        }
+        const s = new MagicString(source);
+        const parsed = this.parse(source, {
+          sourceType: "module",
+          ecmaVersion: "latest"
+        });
+        walk(parsed, {
+          enter: (node) => {
+            if (node.type !== "CallExpression" || node.callee.type !== "Identifier") {
+              return;
+            }
+            const callNode = node;
+            const name = "name" in callNode.callee && callNode.callee.name;
+            if (name === composableName) {
+              const arg = callNode.arguments[argIndex];
+              if (!arg) {
+                return;
+              }
+              const meta = callNode.arguments[argIndex];
+              if (arg.type === "ObjectExpression") {
+                const start = meta.start;
+                const end = meta.end;
+                const objectSource = s.slice(start, end);
+                const object = extract(objectSource);
+                if (object) {
+                  const arg2 = generateRuntimeArg(object);
+                  s.overwrite(start, end, `"${arg2}"`);
+                }
+              }
+            }
+          },
+          leave: () => {
+          }
+        });
+        if (s.hasChanged()) {
+          return {
+            code: s.toString(),
+            map: nuxt.options.sourcemap.client || nuxt.options.sourcemap.server ? s.generateMap({ hires: true }) : null
+          };
+        }
+      }
+    };
+  });
+};
+
+const REPLACE_TARGET = "import.meta.blokkliEditing";
+const EDITING_MARKER = "__blokkli_editing__";
+const BlokkliEditingPlugin = (nuxt) => {
+  return createUnplugin(() => {
+    return {
+      name: "blokkli:editing",
+      enforce: "pre",
+      resolveId(id, importer) {
+        const { pathname, search } = parseURL(decodeURIComponent(id));
+        if (search && pathname.endsWith(".vue")) {
+          const query = parseQuery(search);
+          if (query.blokkliEditing === "true") {
+            let resolved = pathname;
+            if (importer && pathname.startsWith(".")) {
+              const importerBase2 = importer.split("?")[0] || "";
+              resolved = resolve(dirname(importerBase2), pathname);
+            }
+            return resolved.replace(/\.vue$/, `${EDITING_MARKER}.vue`);
+          }
+        }
+        if (!importer || !importer.includes(EDITING_MARKER) || !id.endsWith(".vue")) {
+          return;
+        }
+        const importerWithoutQuery = importer.split("?")[0];
+        if (!importerWithoutQuery) {
+          return;
+        }
+        const importerBase = importerWithoutQuery.replace(EDITING_MARKER, "");
+        const importerDir = dirname(importerBase);
+        let resolvedPath = null;
+        if (id.startsWith(".")) {
+          resolvedPath = resolve(importerDir, id);
+        } else if (id.startsWith("/")) {
+          resolvedPath = id;
+        }
+        if (resolvedPath && existsSync(resolvedPath)) {
+          return resolvedPath.replace(/\.vue$/, `${EDITING_MARKER}.vue`);
+        }
+      },
+      load(id) {
+        if (!id.includes(EDITING_MARKER) || id.includes("?")) {
+          return;
+        }
+        const originalPath = id.replace(EDITING_MARKER, "");
+        this.addWatchFile(originalPath);
+        return readFileSync(originalPath, "utf-8");
+      },
+      transform(source, id) {
+        if (!source.includes(REPLACE_TARGET)) {
+          return;
+        }
+        const isEditing = id.includes(EDITING_MARKER);
+        const replacement = isEditing ? "true" : "false";
+        const s = new MagicString(source);
+        let index = source.indexOf(REPLACE_TARGET);
+        while (index !== -1) {
+          s.overwrite(index, index + REPLACE_TARGET.length, replacement);
+          index = source.indexOf(REPLACE_TARGET, index + 1);
+        }
+        if (s.hasChanged()) {
+          return {
+            code: s.toString(),
+            map: nuxt.options.sourcemap.client || nuxt.options.sourcemap.server ? s.generateMap({ hires: true }) : null
+          };
+        }
+      },
+      vite: {
+        hotUpdate: {
+          order: "post",
+          async handler({ file, modules, server }) {
+            if (!file.endsWith(".vue") || file.includes(EDITING_MARKER)) {
+              return;
+            }
+            const editingVariantPath = file.replace(
+              /\.vue$/,
+              `${EDITING_MARKER}.vue`
+            );
+            const environment = server.environments["client"];
+            if (!environment) {
+              return;
+            }
+            const editingModules = environment.moduleGraph.getModulesByFile(editingVariantPath);
+            if (!editingModules || editingModules.size === 0) {
+              return;
+            }
+            const mainModule = [...editingModules].find(
+              (m) => !m.url.includes("?")
+            );
+            if (mainModule) {
+              environment.moduleGraph.invalidateModule(mainModule);
+              await environment.transformRequest(mainModule.url);
+            }
+            return [...modules, ...editingModules];
+          }
+        }
+      }
+    };
+  });
+};
+
+class IconCollector extends Collector {
+  needsFileContents = false;
+  srcFromModule;
+  validMaterialIconNames;
+  validFileIconNames = /* @__PURE__ */ new Set();
+  constructor(helper) {
+    super(helper);
+    this.srcFromModule = helper.resolvers.module.resolve(
+      "./runtime/editor/icons/svg"
+    );
+    this.validMaterialIconNames = this.loadValidMaterialIconNames();
+  }
+  updateValidFileIconNames() {
+    const names = [...this.files.values()].map((file) => {
+      return basename(file.filePath, ".svg").toLowerCase();
+    });
+    this.validFileIconNames = new Set(names);
+  }
+  /**
+   * Load all valid Material Symbols icon names from the package.
+   */
+  loadValidMaterialIconNames() {
+    const require = createRequire(import.meta.url);
+    const packagePath = dirname$1(
+      require.resolve("@material-symbols/svg-600/rounded/search.svg")
+    );
+    const files = readdirSync(packagePath);
+    const iconNames = files.filter((file) => file.endsWith(".svg")).map((file) => "bk_mdi_" + file.replace(".svg", ""));
+    return new Set(iconNames);
+  }
+  /**
+   * Check if a given string is a valid Material Symbols icon name.
+   *
+   * @param name - The icon name to check (should include `bk_mdi_` prefix).
+   *
+   * @returns True if the icon name is valid.
+   */
+  isValidIconName(name) {
+    return this.isValidMaterialIconName(name) || this.validFileIconNames.has(name);
+  }
+  /**
+   * Check if a given string is a valid Material Symbols icon name.
+   *
+   * @param name - The icon name to check (should include `bk_mdi_` prefix).
+   *
+   * @returns True if the icon name is valid.
+   */
+  isValidMaterialIconName(name) {
+    return this.validMaterialIconNames.has(name);
+  }
+  /**
+   * Get all valid Material Symbols icon names.
+   *
+   * @returns An array of all valid icon names (with `bk_mdi_` prefix).
+   */
+  getValidMaterialIconNames() {
+    return Array.from(this.validMaterialIconNames);
+  }
+  async handleWatchEvent(event, filePath) {
+    const result = await super.handleWatchEvent(event, filePath);
+    if (result.hasChanged) {
+      this.updateValidFileIconNames();
+    }
+    return result;
+  }
+  async init() {
+    const filesModule = await resolveFiles(this.srcFromModule, "*.svg");
+    const filesApp = await resolveFiles(
+      this.helper.paths.srcDir,
+      "**/icon-blokkli-*.svg"
+    );
+    const filesPlayground = this.helper.isModuleBuild ? await resolveFiles("./playground", "**/icon-blokkli-*.svg") : [];
+    const allFiles = [...filesModule, ...filesApp, ...filesPlayground];
+    await Promise.all(allFiles.map((filePath) => this.addFile(filePath)));
+    this.updateValidFileIconNames();
+  }
+  runHooks() {
+    return this.helper.nuxt.hooks.callHook("blokkli:alter-icons", {
+      icons: [...this.files.values()]
+    });
+  }
+  applies(filePath) {
+    return Promise.resolve(
+      filePath.startsWith(this.srcFromModule) || micromatch.isMatch(filePath, "icon-blokkli-*.svg")
+    );
+  }
+  getDependencyTypes() {
+    return ["icons"];
+  }
+  createCollectedFile(filePath, fileContents = "") {
+    return new CollectedFile(filePath, fileContents);
+  }
+}
+
+class FileCache {
+  cache = /* @__PURE__ */ new Map();
+  existingFiles = /* @__PURE__ */ new Set();
+  /**
+   * Read a file from disk.
+   */
+  async read(filePath) {
+    const existing = this.cache.get(filePath);
+    if (existing) {
+      return existing;
+    }
+    const buffer = await fs__default.promises.readFile(filePath);
+    const content = buffer.toString();
+    this.cache.set(filePath, content);
+    return content;
+  }
+  /**
+   * Delete a file.
+   */
+  delete(filePath) {
+    this.cache.delete(filePath);
+  }
+  /**
+   * Check if a file exists.
+   */
+  fileExists(filePath) {
+    if (this.existingFiles.has(filePath)) {
+      return true;
+    }
+    const exists = fs__default.existsSync(filePath);
+    if (exists) {
+      this.existingFiles.add(filePath);
+    }
+    return exists;
+  }
+  /**
+   * Handles the builder watch event.
+   */
+  async handleWatchEvent(event, filePath) {
+    if (event === "add") {
+      this.existingFiles.add(filePath);
+      this.cache.delete(filePath);
+    } else if (event === "change") {
+      this.existingFiles.add(filePath);
+      this.cache.delete(filePath);
+    } else if (event === "unlink") {
+      this.existingFiles.delete(filePath);
+      this.cache.delete(filePath);
+    } else if (event === "unlinkDir") {
+      const filePaths = [...this.existingFiles.keys()];
+      filePaths.forEach((v) => {
+        if (v.startsWith(filePath)) {
+          this.existingFiles.delete(v);
+          this.cache.delete(v);
+        }
+      });
+    }
+  }
+}
+
+const HEX_COLOR_REGEX = /^#(?:[\da-f]{3}|[\da-f]{6})$/i;
+const VALID_ID_REGEX = /^[a-z_$][\w$]*$/i;
+function isHex(value) {
+  return typeof value === "string" && HEX_COLOR_REGEX.test(value);
+}
+function isNonEmptyString(value) {
+  return typeof value === "string" && value.length > 0;
+}
+function hasShades(option) {
+  return "shades" in option && !!option.shades && typeof option.shades === "object";
+}
+function validateColorOption(colorId, option) {
+  const errors = [];
+  if (!VALID_ID_REGEX.test(colorId)) {
+    errors.push({
+      message: `Color id "${colorId}" is not a valid JavaScript identifier (must start with a letter, underscore or $, followed by letters, digits, underscores or $). Color ids may not contain "." \u2014 that character is reserved for shade-qualified ids (e.g. "red.300").`,
+      optionKey: colorId
+    });
+  }
+  if (!isNonEmptyString(option.label)) {
+    errors.push({
+      message: `Option "${colorId}" is missing a non-empty "label".`,
+      optionKey: colorId
+    });
+  }
+  if (hasShades(option)) {
+    const shadeKeys = Object.keys(option.shades);
+    if (shadeKeys.length === 0) {
+      errors.push({
+        message: `Option "${colorId}" declares an empty "shades" object. Either omit "shades" or declare at least one shade.`,
+        optionKey: colorId
+      });
+    }
+    for (const shadeKey of shadeKeys) {
+      const shadeValue = option.shades[shadeKey];
+      if (!isHex(shadeValue)) {
+        errors.push({
+          message: `Option "${colorId}" shade "${shadeKey}" has value "${shadeValue}" which is not a valid hex color (expected format: #RRGGBB or #RGB)`,
+          optionKey: colorId
+        });
+      }
+    }
+    if (!isNonEmptyString(option.mainShade)) {
+      errors.push({
+        message: `Option "${colorId}" declares "shades" but is missing "mainShade".`,
+        optionKey: colorId
+      });
+    } else if (!shadeKeys.includes(option.mainShade)) {
+      errors.push({
+        message: `Option "${colorId}" mainShade "${option.mainShade}" is not a key of shades (available: ${shadeKeys.map((k) => `"${k}"`).join(", ")})`,
+        optionKey: colorId
+      });
+    }
+    if ("hex" in option) {
+      errors.push({
+        message: `Option "${colorId}" declares both "hex" and "shades". Use one or the other: shaded colors derive their base hex from "shades[mainShade]".`,
+        optionKey: colorId
+      });
+    }
+  } else {
+    const hex = option.hex;
+    if (hex === void 0) {
+      errors.push({
+        message: `Option "${colorId}": "hex" is required when "shades" is not provided.`,
+        optionKey: colorId
+      });
+    } else if (!isHex(hex)) {
+      errors.push({
+        message: `Option "${colorId}" has hex value "${hex}" which is not a valid hex color (expected format: #RRGGBB or #RGB)`,
+        optionKey: colorId
+      });
+    }
+  }
+  return errors;
+}
+function validateColorOptions(colorOptions) {
+  if (!colorOptions) {
+    return [];
+  }
+  const errors = [];
+  for (const [colorId, option] of Object.entries(colorOptions)) {
+    if (!option || typeof option !== "object") {
+      continue;
+    }
+    errors.push(...validateColorOption(colorId, option));
+  }
+  return errors;
+}
+
+const defaultColorOptions = {
+  blue: { hex: "#3b82f6", label: "Blue" },
+  red: { hex: "#ef4444", label: "Red" },
+  green: { hex: "#10b981", label: "Green" },
+  amber: { hex: "#f59e0b", label: "Amber" },
+  purple: { hex: "#8b5cf6", label: "Purple" },
+  pink: { hex: "#ec4899", label: "Pink" },
+  teal: { hex: "#14b8a6", label: "Teal" },
+  orange: { hex: "#f97316", label: "Orange" }
+};
+class ModuleHelper {
+  constructor(nuxt, logger, moduleUrl, providedOptions) {
+    this.nuxt = nuxt;
+    this.logger = logger;
+    this.isDev = nuxt.options.dev;
+    this.isPrepare = !!nuxt.options._prepare;
+    this.isModuleBuild = false;
+    this.fileCache = new FileCache();
+    this.resolvers = {
+      module: createResolver(moduleUrl),
+      build: createResolver(nuxt.options.buildDir),
+      src: createResolver(nuxt.options.srcDir),
+      app: createResolver(nuxt.options.dir.app),
+      root: createResolver(nuxt.options.rootDir)
+    };
+    this.paths = {
+      blokkliBuildDir: this.resolvers.build.resolve("blokkli"),
+      srcDir: nuxt.options.srcDir,
+      editAdapter: ""
+    };
+    this.relativePaths = {
+      TYPES: relative(
+        this.paths.blokkliBuildDir,
+        this.resolvers.module.resolve("./runtime/types/index.ts")
+      ),
+      TYPES_DEFINITIONS: relative(
+        this.paths.blokkliBuildDir,
+        this.resolvers.module.resolve("./runtime/types/definitions.ts")
+      ),
+      CONSTANTS: relative(
+        this.paths.blokkliBuildDir,
+        this.resolvers.module.resolve("./runtime/constants/index.ts")
+      ),
+      ADAPTER: relative(
+        this.paths.blokkliBuildDir,
+        this.resolvers.module.resolve("./runtime/editor/adapter/index.ts")
+      ),
+      TYPES_THEME: relative(
+        this.paths.blokkliBuildDir,
+        this.resolvers.module.resolve("./runtime/types/theme.ts")
+      ),
+      TYPES_BLOKK_OPTIONS: relative(
+        this.paths.blokkliBuildDir,
+        this.resolvers.module.resolve("./runtime/types/blockOptions.ts")
+      )
+    };
+    const pattern = providedOptions.pattern || [];
+    pattern.push(
+      this.resolvers.module.resolve(
+        "./runtime/components/Blocks/FromLibrary/*.vue"
+      )
+    );
+    pattern.push(
+      this.resolvers.module.resolve(
+        "./runtime/components/Blocks/Fragment/*.vue"
+      )
+    );
+    if (this.isModuleBuild) {
+      pattern.push(
+        this.resolvers.module.resolve(
+          "./../playground/app/components/Blokkli/**/*.vue"
+        )
+      );
+    }
+    const fieldListTypes = providedOptions.fieldListTypes || [];
+    if (!fieldListTypes.includes("default")) {
+      fieldListTypes.push("default");
+    }
+    const providerTypes = providedOptions.providerTypes || [];
+    if (!providerTypes.includes("default")) {
+      providerTypes.push("default");
+    }
+    const chunkNames = providedOptions.chunkNames || [];
+    if (!chunkNames.includes("global")) {
+      chunkNames.push("global");
+    }
+    this.options = {
+      ...providedOptions,
+      pattern,
+      fieldListTypes: fieldListTypes.filter(onlyUnique),
+      providerTypes: providerTypes.filter(onlyUnique),
+      chunkNames: chunkNames.filter(onlyUnique),
+      colorOptions: providedOptions.colorOptions || defaultColorOptions
+    };
+    this.paths.editAdapter = this.findEditAdapterPath();
+  }
+  relativePaths;
+  paths;
+  resolvers;
+  fileCache;
+  options;
+  isDev;
+  isModuleBuild;
+  isPrepare;
+  /**
+   * Transform the path relative to the module's build directory.
+   *
+   * @param path - The absolute path.
+   *
+   * @returns The path relative to the module's build directory.
+   */
+  toModuleBuildRelative(path) {
+    return relative(this.paths.blokkliBuildDir, path);
+  }
+  /**
+   * Path to the editor's compiled tailwind config. Used by the SFC mangle
+   * pipeline and module CSS processing to inject `@config` so consumer-side
+   * `@apply` resolves against the editor's theme + utilities.
+   *
+   * In dist (npm install): `dist/modules/tailwind/index.mjs`. In source (this
+   * repo's playground): `tailwind.config.ts` at the repo root.
+   */
+  getTailwindConfigPath() {
+    const distPath = this.resolvers.module.resolve(
+      "./modules/tailwind/index.mjs"
+    );
+    if (this.fileCache.fileExists(distPath)) {
+      return distPath;
+    }
+    return this.resolvers.module.resolve("../tailwind.config.ts");
+  }
+  findEditAdapterPath() {
+    const filePath = this.resolvers.app.resolve("blokkli.editAdapter.ts");
+    if (this.fileCache.fileExists(filePath)) {
+      return filePath;
+    }
+    if (this.options.editAdapterPath && this.fileCache.fileExists(this.options.editAdapterPath)) {
+      return this.options.editAdapterPath;
+    }
+    throw new Error(`Missing bl\xF6kkli edit adapter at "${filePath}"`);
+  }
+  getChunkNames() {
+    return this.options.chunkNames || ["global"];
+  }
+  addComponent(name) {
+    addComponent({
+      filePath: this.resolvers.module.resolve("./runtime/components/" + name),
+      name,
+      global: true
+    });
+  }
+  addComposable(name) {
+    addImports({
+      name,
+      from: this.resolvers.module.resolve("./runtime/composables/" + name)
+    });
+  }
+  addAlias(name, path) {
+    this.nuxt.options.alias[name] = path;
+    this.nuxt.options.nitro.typescript ||= {};
+    this.nuxt.options.nitro.typescript.tsConfig ||= {};
+    this.nuxt.options.nitro.typescript.tsConfig.compilerOptions ||= {};
+    this.nuxt.options.nitro.typescript.tsConfig.compilerOptions.paths ||= {};
+    this.nuxt.options.nitro.typescript.tsConfig.compilerOptions.paths[name] = [
+      path
+    ];
+    this.nuxt.options.nitro.typescript.tsConfig.compilerOptions.paths[name + "/*"] = [path + "/*"];
+    this.nuxt.options.typescript.tsConfig ||= {};
+    this.nuxt.options.typescript.tsConfig.compilerOptions ||= {};
+    this.nuxt.options.typescript.tsConfig.compilerOptions.paths ||= {};
+    this.nuxt.options.typescript.tsConfig.compilerOptions.paths[name] = [path];
+    this.nuxt.options.typescript.tsConfig.compilerOptions.paths[name + "/*"] = [
+      path + "/*"
+    ];
+  }
+  /**
+   * Add a directory to the app TypeScript tsconfig includes.
+   */
+  addAppTsInclude(absolutePath) {
+    const rel = relative(this.nuxt.options.buildDir, absolutePath) + "/**/*";
+    this.nuxt.options.typescript.tsConfig ||= {};
+    this.nuxt.options.typescript.tsConfig.include ||= [];
+    this.nuxt.options.typescript.tsConfig.include.push(rel);
+  }
+  /**
+   * Add a directory to the server/Nitro TypeScript tsconfig includes.
+   */
+  addServerTsInclude(absolutePath) {
+    const rel = relative(this.nuxt.options.buildDir, absolutePath) + "/**/*";
+    this.nuxt.options.nitro.typescript ||= {};
+    this.nuxt.options.nitro.typescript.tsConfig ||= {};
+    this.nuxt.options.nitro.typescript.tsConfig.include ||= [];
+    this.nuxt.options.nitro.typescript.tsConfig.include.push(rel);
+  }
+  /**
+   * Add a path to Nitro's externals.inline for server-side usage.
+   * @see https://github.com/nuxt/nuxt/issues/28995
+   */
+  inlineForNitro(path) {
+    this.nuxt.options.nitro.externals ||= {};
+    this.nuxt.options.nitro.externals.inline ||= [];
+    this.nuxt.options.nitro.externals.inline.push(path);
+    this.nuxt.options.build.transpile.push(path);
+  }
+  getMappedBlockBundle(bundle) {
+    if (bundle === "BK_BUNDLE_FROM_LIBRARY") {
+      return this.options.fromLibraryBlockBundle ?? "from_library";
+    } else if (bundle === "BK_BUNDLE_FRAGMENT") {
+      return this.options.fragmentBlockBundle ?? "blokkli_fragment";
+    }
+    return bundle;
+  }
+  validate(icons) {
+    let hasErrors = false;
+    const optionErrors = validateOptions(this.options.globalOptions, icons);
+    if (optionErrors.length > 0) {
+      const lines = optionErrors.map((error) => {
+        const prefix = error.optionKey ? `  Option "${error.optionKey}": ` : "  ";
+        return prefix + error.message;
+      });
+      this.logger.error(
+        `bl\xF6kkli global options validation errors:
+${lines.join("\n")}`
+      );
+      hasErrors = true;
+    }
+    const colorErrors = validateColorOptions(this.options.colorOptions);
+    if (colorErrors.length > 0) {
+      const lines = colorErrors.map((error) => {
+        const prefix = error.optionKey ? `  Option "${error.optionKey}": ` : "  ";
+        return prefix + error.message;
+      });
+      this.logger.error(
+        `bl\xF6kkli colorOptions validation errors:
+${lines.join("\n")}`
+      );
+      hasErrors = true;
+    }
+    return hasErrors;
+  }
+}
+
+const WRITE = false;
+class ModuleContext {
+  constructor(helper, icons, features, blocks, theme) {
+    this.helper = helper;
+    this.icons = icons;
+    this.features = features;
+    this.blocks = blocks;
+    this.theme = theme;
+  }
+  templates = [];
+  templateContents = /* @__PURE__ */ new Map();
+  adapterExtensions = [];
+  featureFragments = /* @__PURE__ */ new Set();
+  complexOptionTypes = /* @__PURE__ */ new Map();
+  cssFiles = [];
+  contentPaths = [];
+  additionalIcons = [];
+  collectors = [];
+  addCSS(filePath) {
+    this.cssFiles.push(filePath);
+  }
+  getCSSFiles() {
+    return this.cssFiles;
+  }
+  /**
+   * Register a directory containing Vue files that should participate in
+   * blökkli's CSS build pipeline. Files in these directories will:
+   * - Have their Tailwind utility classes generated and included in the output
+   * - Have their template class names mangled (_bk_ prefix) at build time
+   * - Have their <style> blocks processed through blökkli's PostCSS pipeline
+   *
+   * @param dirPath - Absolute path to a directory containing Vue components
+   */
+  addContentPath(dirPath) {
+    this.contentPaths.push(dirPath);
+  }
+  getContentPaths() {
+    return this.contentPaths;
+  }
+  addIcon(...names) {
+    this.additionalIcons.push(...names);
+  }
+  getAdditionalIcons() {
+    return this.additionalIcons;
+  }
+  addFeatureFragment(name) {
+    if (this.featureFragments.has(name)) {
+      throw new Error(`A feature fragment with name "${name}" already exists.`);
+    }
+    this.featureFragments.add(name);
+  }
+  getFeatureFragmentNames() {
+    return [...this.featureFragments.values()];
+  }
+  registerComplexOptionType(def) {
+    if (this.complexOptionTypes.has(def.id)) {
+      throw new Error(
+        `A complex option type with id "${def.id}" already exists.`
+      );
+    }
+    this.complexOptionTypes.set(def.id, def);
+  }
+  getComplexOptionTypes() {
+    return [...this.complexOptionTypes.values()];
+  }
+  registerAdapterExtension(namespace, path) {
+    if (this.adapterExtensions.some((e) => e.namespace === namespace)) {
+      throw new Error(`Duplicate adapter extension namespace: ${namespace}`);
+    }
+    this.adapterExtensions.push({ namespace, path });
+  }
+  getAdapterExtensions() {
+    return this.adapterExtensions;
+  }
+  addCollector(collector) {
+    this.collectors.push(collector);
+  }
+  getTemplateContents(type, name) {
+    const contents = this.templateContents.get(type + name);
+    if (contents === void 0) {
+      throw new Error(
+        `Failed to get contents for template "${name}" of type ${type}`
+      );
+    }
+    return contents;
+  }
+  setTemplateContents(type, name, contents) {
+    this.templateContents.set(type + name, contents.trim());
+  }
+  async generateTemplates(dependencies) {
+    for (const template of this.templates) {
+      if (dependencies?.length) {
+        const shouldUpdate = dependencies.some(
+          (v) => template.options.dependencies.includes(v)
+        );
+        if (!shouldUpdate) {
+          continue;
+        }
+      }
+      if (template.type === "code") {
+        this.setTemplateContents(
+          "code",
+          template.name,
+          await template.buildCode(this)
+        );
+        this.setTemplateContents(
+          "types",
+          template.name,
+          await template.buildTypes(this)
+        );
+      } else {
+        this.setTemplateContents(
+          "file",
+          template.fileName,
+          await template.build(this)
+        );
+      }
+    }
+  }
+  addTemplate(template) {
+    this.templates.push(template);
+    const context = template.options.context;
+    if (template.type === "code") {
+      const resolvedTemplate = addTemplate({
+        filename: `blokkli/${template.name}.js`,
+        write: template.options.write || WRITE,
+        getContents: () => this.getTemplateContents("code", template.name)
+      });
+      if (context === "server" || context === "both") {
+        this.inlineForNitro(resolvedTemplate.dst);
+      }
+      this.addTypeTemplate(
+        `blokkli/${template.name}.d.ts`,
+        () => {
+          const lines = this.getTemplateContents("types", template.name).trim().split("\n");
+          const imports = [];
+          const declarations = [];
+          for (const line of lines) {
+            if (line.startsWith("import ")) {
+              imports.push(line);
+            } else {
+              declarations.push(line);
+            }
+          }
+          return `${imports.join("\n")}
+
+declare module '#blokkli-build/${template.name}' {
+  ${declarations.join("\n  ")}
+}`;
+        },
+        context
+      );
+    } else {
+      const filename = template.fileName.startsWith("/") ? template.fileName : `blokkli/${template.fileName}`;
+      if (filename.endsWith(".d.ts")) {
+        this.addTypeTemplate(
+          filename,
+          () => this.getTemplateContents("file", template.fileName),
+          context
+        );
+      } else {
+        const resolvedTemplate = addTemplate({
+          filename,
+          write: true,
+          getContents: () => this.getTemplateContents("file", template.fileName)
+        });
+        if (context === "server" || context === "both") {
+          this.inlineForNitro(resolvedTemplate.dst);
+        }
+      }
+    }
+  }
+  /**
+   * Add a template path to Nitro's externals.inline for server-side usage.
+   * @see https://github.com/nuxt/nuxt/issues/28995
+   */
+  inlineForNitro(path) {
+    const nuxt = this.helper.nuxt;
+    nuxt.options.nitro.externals ||= {};
+    nuxt.options.nitro.externals.inline ||= [];
+    nuxt.options.nitro.externals.inline.push(path);
+    nuxt.options.build.transpile.push(path);
+  }
+  /**
+   * Register a type template without adding to globalTypeFiles.
+   *
+   * Uses addTemplate instead of addTypeTemplate to avoid Vue compiler-sfc
+   * issue where exported types from globalTypeFiles cannot be resolved.
+   * @see https://github.com/nuxt/nuxt/issues/33694
+   */
+  addTypeTemplate(filename, getContents, context = "app") {
+    const resolvedTemplate = addTemplate({
+      filename,
+      write: true,
+      getContents
+    });
+    const forApp = context === "app" || context === "both";
+    const forServer = context === "server" || context === "both";
+    if (forApp) {
+      this.helper.nuxt.hook("prepare:types", (payload) => {
+        payload.references ||= [];
+        payload.references.push({ path: resolvedTemplate.dst });
+      });
+    }
+    if (forServer) {
+      this.helper.nuxt.hook("nitro:prepare:types", (payload) => {
+        payload.references ||= [];
+        payload.references.push({ path: resolvedTemplate.dst });
+      });
+    }
+  }
+}
+
+function toObject(name, map, noExport) {
+  const lines = [...map.entries()].map(([key, value]) => {
+    return `'${key}': ${value}`;
+  }).sort().join(",\n  ");
+  if (noExport) {
+    return `
+const ${name} = {
+  ${lines}
+}
+`;
+  }
+  return `
+export const ${name} = {
+  ${lines}
+}
+`;
+}
+function toImports(map) {
+  return [...map.entries()].map(([key, path]) => {
+    return `import ${key} from '${path}'`;
+  }).sort().join("\n");
+}
+function toTypeLiteral(value) {
+  if (value === null) {
+    return "null";
+  }
+  if (value === void 0) {
+    return "undefined";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value);
+  }
+  if (typeof value === "number" || typeof value === "boolean") {
+    return String(value);
+  }
+  if (Array.isArray(value)) {
+    if (value.length === 0) {
+      return "[]";
+    }
+    const items = value.map((v) => toTypeLiteral(v));
+    return `[${items.join(", ")}]`;
+  }
+  if (typeof value === "object") {
+    const entries = Object.entries(value);
+    if (entries.length === 0) {
+      return "{}";
+    }
+    const props = entries.map(([key, val]) => {
+      const safeKey = /^[a-z_$][\w$]*$/i.test(key) ? key : JSON.stringify(key);
+      return `${safeKey}: ${toTypeLiteral(val)}`;
+    }).join("; ");
+    return `{ ${props} }`;
+  }
+  return "unknown";
+}
+
+const USED_MATERIAL_ICONS = [
+  "bk_mdi_account_tree",
+  "bk_mdi_add",
+  "bk_mdi_add_column_right",
+  "bk_mdi_add_comment",
+  "bk_mdi_add_row_below",
+  "bk_mdi_alternate_email",
+  "bk_mdi_anchor",
+  "bk_mdi_architecture",
+  "bk_mdi_area_chart",
+  "bk_mdi_arrow_back",
+  "bk_mdi_arrow_downward",
+  "bk_mdi_arrow_drop_down",
+  "bk_mdi_arrow_forward",
+  "bk_mdi_arrow_left",
+  "bk_mdi_arrow_left_alt",
+  "bk_mdi_arrow_right",
+  "bk_mdi_arrow_right_alt",
+  "bk_mdi_arrow_selector_tool",
+  "bk_mdi_arrow_top_left",
+  "bk_mdi_arrow_upward",
+  "bk_mdi_attach_file",
+  "bk_mdi_bakery_dining",
+  "bk_mdi_bar_chart",
+  "bk_mdi_book_2",
+  "bk_mdi_bug_report",
+  "bk_mdi_build-fill",
+  "bk_mdi_calendar_clock",
+  "bk_mdi_calendar_month",
+  "bk_mdi_campaign",
+  "bk_mdi_chat",
+  "bk_mdi_chat_bubble-fill",
+  "bk_mdi_check",
+  "bk_mdi_check_box",
+  "bk_mdi_check_box_outline_blank",
+  "bk_mdi_check_circle",
+  "bk_mdi_check_circle-fill",
+  "bk_mdi_checklist",
+  "bk_mdi_chevron_backward",
+  "bk_mdi_chevron_forward",
+  "bk_mdi_close",
+  "bk_mdi_code",
+  "bk_mdi_collapse_all",
+  "bk_mdi_comment",
+  "bk_mdi_construction",
+  "bk_mdi_content_copy",
+  "bk_mdi_content_paste",
+  "bk_mdi_crop_9_16",
+  "bk_mdi_csv",
+  "bk_mdi_dashboard",
+  "bk_mdi_data_object",
+  "bk_mdi_delete",
+  "bk_mdi_dock_to_left",
+  "bk_mdi_dock_to_right",
+  "bk_mdi_docs",
+  "bk_mdi_done_all",
+  "bk_mdi_donut_large",
+  "bk_mdi_download",
+  "bk_mdi_drag_pan",
+  "bk_mdi_edit",
+  "bk_mdi_error",
+  "bk_mdi_error-fill",
+  "bk_mdi_exit_to_app",
+  "bk_mdi_expand_all",
+  "bk_mdi_extension",
+  "bk_mdi_eye_tracking",
+  "bk_mdi_feature_search",
+  "bk_mdi_fit_screen",
+  "bk_mdi_format_bold",
+  "bk_mdi_format_italic",
+  "bk_mdi_format_list_bulleted",
+  "bk_mdi_format_list_numbered",
+  "bk_mdi_format_quote",
+  "bk_mdi_format_strikethrough",
+  "bk_mdi_forum",
+  "bk_mdi_fullscreen",
+  "bk_mdi_fullscreen_exit",
+  "bk_mdi_function",
+  "bk_mdi_grid_view",
+  "bk_mdi_grid_view-fill",
+  "bk_mdi_groups_2",
+  "bk_mdi_help",
+  "bk_mdi_help-fill",
+  "bk_mdi_history",
+  "bk_mdi_hourglass_empty",
+  "bk_mdi_image",
+  "bk_mdi_info-fill",
+  "bk_mdi_ink_selection",
+  "bk_mdi_inventory",
+  "bk_mdi_join",
+  "bk_mdi_keyboard_arrow_down",
+  "bk_mdi_keyboard_command_key",
+  "bk_mdi_laptop_mac",
+  "bk_mdi_lightbulb",
+  "bk_mdi_link",
+  "bk_mdi_lists",
+  "bk_mdi_lock",
+  "bk_mdi_logo_dev",
+  "bk_mdi_mark_chat_read",
+  "bk_mdi_menu",
+  "bk_mdi_mobile",
+  "bk_mdi_mobile_rotate",
+  "bk_mdi_monitor",
+  "bk_mdi_newspaper",
+  "bk_mdi_notifications",
+  "bk_mdi_open_in_new",
+  "bk_mdi_palette",
+  "bk_mdi_person",
+  "bk_mdi_person-fill",
+  "bk_mdi_person_search",
+  "bk_mdi_pie_chart",
+  "bk_mdi_play_circle",
+  "bk_mdi_priority_high",
+  "bk_mdi_publish",
+  "bk_mdi_qr_code",
+  "bk_mdi_question_mark",
+  "bk_mdi_radar",
+  "bk_mdi_radio_button_checked",
+  "bk_mdi_redo",
+  "bk_mdi_remove",
+  "bk_mdi_replay",
+  "bk_mdi_reply",
+  "bk_mdi_resize",
+  "bk_mdi_robot",
+  "bk_mdi_save",
+  "bk_mdi_school-fill",
+  "bk_mdi_search",
+  "bk_mdi_select",
+  "bk_mdi_select_all",
+  "bk_mdi_select_check_box",
+  "bk_mdi_sentiment_dissatisfied",
+  "bk_mdi_sentiment_worried",
+  "bk_mdi_settings",
+  "bk_mdi_show_chart",
+  "bk_mdi_speed",
+  "bk_mdi_stack_group",
+  "bk_mdi_stop",
+  "bk_mdi_stream",
+  "bk_mdi_swap_horiz",
+  "bk_mdi_swap_horizontal_circle",
+  "bk_mdi_swap_vert",
+  "bk_mdi_table_convert",
+  "bk_mdi_tablet",
+  "bk_mdi_text_compare",
+  "bk_mdi_text_select_end",
+  "bk_mdi_texture",
+  "bk_mdi_thumb_down",
+  "bk_mdi_thumb_up",
+  "bk_mdi_thumbs_up_double",
+  "bk_mdi_title",
+  "bk_mdi_track_changes",
+  "bk_mdi_trackpad_input",
+  "bk_mdi_translate",
+  "bk_mdi_tune",
+  "bk_mdi_undo",
+  "bk_mdi_unpublished",
+  "bk_mdi_upload",
+  "bk_mdi_verified",
+  "bk_mdi_video_camera_back",
+  "bk_mdi_visibility",
+  "bk_mdi_visibility_off",
+  "bk_mdi_warning",
+  "bk_mdi_web_traffic",
+  "bk_mdi_widgets",
+  "bk_mdi_workspaces",
+  "bk_mdi_zoom_in"
+];
+
+function getIconsFromOptions(options) {
+  return Object.values(options ?? {}).flatMap((option) => {
+    if (option.type === "radios" && option.displayAs === "icons") {
+      return Object.values(option.options ?? {}).map((v) => v.icon);
+    }
+  }).filter(falsy);
+}
+const icons = defineCodeTemplate(
+  "icons",
+  (ctx) => {
+    const imports = /* @__PURE__ */ new Map();
+    const icons = /* @__PURE__ */ new Map();
+    const files = ctx.icons.files.values();
+    const blockIcons = [...ctx.blocks.files.values()].flatMap((v) => {
+      const icon = v.definition?.editor?.icon;
+      return [icon, ...getIconsFromOptions(v.definition?.options)];
+    });
+    const featureIcons = [...ctx.features.files.values()].map(
+      (v) => v.getDefinition()?.definition.icon
+    );
+    const globalOptionsIcons = getIconsFromOptions(
+      ctx.helper.options.globalOptions
+    );
+    const definitionIcons = [
+      ...blockIcons,
+      ...featureIcons,
+      ...USED_MATERIAL_ICONS,
+      ...globalOptionsIcons,
+      ...ctx.getAdditionalIcons()
+    ].filter(falsy).filter(onlyUnique);
+    for (const file of files) {
+      const name = basename(file.filePath, ".svg").toLowerCase();
+      const importName = "icon_" + toValidVariableName(name);
+      const realtivePath = ctx.helper.toModuleBuildRelative(file.filePath);
+      imports.set(importName, `${realtivePath}?raw`);
+      icons.set(name, importName);
+    }
+    const materialIcons = definitionIcons.filter(
+      (v) => v.startsWith("bk_mdi_") && ctx.icons.isValidIconName(v)
+    );
+    for (const icon of materialIcons) {
+      const importName = "icon_" + toValidVariableName(icon);
+      const mdiImportName = icon.replace("bk_mdi_", "");
+      imports.set(
+        importName,
+        `@material-symbols/svg-600/rounded/${mdiImportName}.svg?raw`
+      );
+      icons.set(icon, importName);
+    }
+    return `${toImports(imports)}
+
+${toObject("icons", icons)}
+`;
+  },
+  (ctx) => {
+    const allIconNames = [...ctx.icons.files.values()].map((file) => {
+      return basename(file.filePath, ".svg").toLowerCase();
+    }).sort().map((name) => `"${name}"`).join("\n  | ") || "'never'";
+    return `
+import type { MaterialIconName } from './material-icons.d'
+
+type ProvidedIconName =
+  | ${allIconNames}
+
+export type BlokkliIcon = MaterialIconName | ProvidedIconName
+export declare const icons: Record<BlokkliIcon, string>
+`;
+  },
+  {
+    dependencies: ["icons", "block-content"]
+  }
+);
+
+const features = defineCodeTemplate(
+  "features",
+  (ctx) => {
+    const features = ctx.features.getEnabledFeatures().sort((a, b) => b.id.localeCompare(a.id));
+    const featuresComponents = /* @__PURE__ */ new Map();
+    const definitions = [];
+    const declarations = [];
+    const imports = /* @__PURE__ */ new Map();
+    for (const feature of features) {
+      if (feature.definition.devOnly && !ctx.helper.isDev) {
+        continue;
+      }
+      const componentVarName = toValidVariableName(`component_${feature.id}`);
+      const declarationVarName = toValidVariableName(`feature_${feature.id}`);
+      declarations.push(
+        `const ${declarationVarName} = ${feature.definitionSource}`
+      );
+      definitions.push(declarationVarName);
+      imports.set(componentVarName, feature.componentPath);
+      featuresComponents.set(feature.id, componentVarName);
+    }
+    const availableFeaturesAtBuild = features.map((v) => v.id);
+    return `${toImports(imports)}
+
+export const availableFeaturesAtBuild = ${JSON.stringify(
+      availableFeaturesAtBuild.sort()
+    )}
+
+${toObject("featureComponents", featuresComponents)}
+
+${declarations.join("\n\n")}
+
+export const featureDefinitions = [
+  ${definitions.join(",\n  ")}
+]
+`;
+  },
+  (ctx) => {
+    const features = ctx.features.getEnabledFeatures();
+    const availableFeaturesAtBuild = features.map((v) => v.id);
+    const typeImports = [];
+    for (const feature of features) {
+      const typesPath = feature.componentPath.replace("/index.vue", "/types.ts");
+      if (existsSync(typesPath)) {
+        const relativePath = ctx.helper.toModuleBuildRelative(
+          feature.componentPath.replace("/index.vue", "/types")
+        );
+        typeImports.push(`import '${relativePath}'`);
+      }
+    }
+    const typeImportsCode = typeImports.length > 0 ? "\n" + typeImports.join("\n") + "\n" : "";
+    return `import type { FeatureDefinition } from '${ctx.helper.relativePaths.TYPES}'
+import type { Component } from 'vue'
+${typeImportsCode}
+export type ValidFeatureKey = ${availableFeaturesAtBuild.map((v) => '"' + v + '"').join(" | ")}
+
+export declare const featureComponents: Record<ValidFeatureKey, Component>
+export declare const featureDefinitions: FeatureDefinition[]
+export declare const availableFeaturesAtBuild: ValidFeatureKey[]
+`;
+  },
+  {
+    dependencies: ["features"]
+  }
+);
+
+const featuresJson = defineFileTemplate("features-data.json", async (ctx) => {
+  const features = [...ctx.features.files.values()];
+  const featuresData = await Promise.all(
+    features.map(async (v) => {
+      const docsPath = v.filePath.replace("index.vue", "docs.md");
+      let docs = "";
+      if (ctx.helper.fileCache.fileExists(docsPath)) {
+        docs = await ctx.helper.fileCache.read(docsPath);
+      }
+      return {
+        definition: v.getDefinition()?.definition,
+        repoRelativePath: v.filePath.replace(/.*\/src/, "/src"),
+        docs
+      };
+    })
+  );
+  return JSON.stringify(featuresData, null, 2);
+});
+
+const TRANSLATIONS_DIR = "./runtime/editor/translations";
+const translations = defineCodeTemplate(
+  "translations",
+  (ctx) => {
+    const userTranslations = ctx.helper.options.translations;
+    const hasUserTranslations = userTranslations && Object.keys(userTranslations).length > 0;
+    const loaderEntries = TRANSLATION_LANGUAGES.map((lang) => {
+      const relativePath = ctx.helper.toModuleBuildRelative(
+        ctx.helper.resolvers.module.resolve(`${TRANSLATIONS_DIR}/${lang}.json`)
+      );
+      const body = hasUserTranslations ? `defu(userTranslations['${lang}'] ?? {}, mod.default)` : `mod.default`;
+      return `  '${lang}': async () => {
+    const mod = await import('${relativePath}')
+    return ${body}
+  }`;
+    }).join(",\n");
+    const preamble = hasUserTranslations ? `import { defu } from 'defu'
+
+const userTranslations = ${JSON.stringify(userTranslations)}
+
+` : "";
+    return `${preamble}export const translationLoaders = {
+${loaderEntries}
+}
+`;
+  },
+  () => {
+    const typeUnion = ["en", ...TRANSLATION_LANGUAGES].map((lang) => `'${lang}'`).join(" | ");
+    return `
+export type InterfaceLanguage = ${typeUnion}
+export type TranslationMap = Record<string, string>
+export type TranslationLoaders = Partial<Record<InterfaceLanguage, () => Promise<TranslationMap>>>
+export const translationLoaders: TranslationLoaders
+`;
+  }
+);
+
+const editAdapter = defineCodeTemplate(
+  "edit-adapter",
+  (ctx) => {
+    const pathRelative = ctx.helper.toModuleBuildRelative(
+      ctx.helper.paths.editAdapter
+    );
+    return `
+  import adapter from '${pathRelative}'
+
+export default adapter
+`;
+  },
+  (ctx) => {
+    return `
+import type { BlokkliAdapterFactory } from '${ctx.helper.relativePaths.ADAPTER}'
+
+const adapter: BlokkliAdapterFactory<any>
+
+export default adapter
+`;
+  },
+  {
+    write: true
+  }
+);
+
+const adapterExtensions = defineCodeTemplate(
+  "adapter-extensions",
+  (ctx) => {
+    const extensions = ctx.getAdapterExtensions();
+    if (extensions.length === 0) {
+      return `export default []`;
+    }
+    const imports = extensions.map(
+      (ext, i) => `import ext${i} from '${ctx.helper.toModuleBuildRelative(ext.path)}'`
+    ).join("\n");
+    return `
+${imports}
+
+export default [
+  ${extensions.map((ext, i) => `{ namespace: '${ext.namespace}', factory: ext${i} }`).join(",\n  ")}
+]
+`;
+  },
+  (ctx) => {
+    return `
+import type { AdapterExtensionDefinition } from '${ctx.helper.toModuleBuildRelative(ctx.helper.resolvers.module.resolve("./runtime/editor/providers/adapters.ts"))}'
+
+const adapterExtensions: AdapterExtensionDefinition[]
+
+export default adapterExtensions
+`;
+  },
+  {
+    write: true
+  }
+);
+
+const logger$2 = useLogger("@blokkli/editor");
+let processor = null;
+let processorUnavailable = false;
+function postcssMangleClasses(selectorParser) {
+  const plugin = () => ({
+    postcssPlugin: "postcss-mangle-blokkli-classes",
+    OnceExit(root) {
+      root.walkRules((rule) => {
+        if (rule.parent && rule.parent.type === "atrule" && rule.parent.name === "keyframes") {
+          return;
+        }
+        rule.selector = selectorParser((selectors) => {
+          selectors.each((selector) => {
+            let hasMangled = false;
+            let hasBk = false;
+            selector.walkClasses((classNode) => {
+              if (classNode.value === "bk") {
+                hasBk = true;
+                return;
+              }
+              if (classNode.value.startsWith("bk-")) return;
+              if (classNode.value.startsWith("_bk_")) {
+                hasMangled = true;
+                return;
+              }
+              classNode.value = "_bk_" + classNode.value;
+              hasMangled = true;
+            });
+            if (hasMangled && !hasBk) {
+              const descendant = selector.clone();
+              descendant.prepend(selectorParser.combinator({ value: " " }));
+              descendant.prepend(selectorParser.className({ value: "bk" }));
+              const compound = selector.clone();
+              compound.prepend(selectorParser.className({ value: "bk" }));
+              selector.replaceWith(descendant, compound);
+            }
+          });
+        }).processSync(rule.selector);
+      });
+    }
+  });
+  plugin.postcss = true;
+  return plugin;
+}
+async function ensureProcessor() {
+  if (processor || processorUnavailable) return processor;
+  processor = await createProcessor();
+  return processor;
+}
+async function processCSS(css, from, contentPaths) {
+  const proc = await ensureProcessor();
+  if (!proc) return css;
+  const sourceDirectives = contentPaths?.length ? "\n" + contentPaths.map((dir) => `@source "${dir}/**/*.vue";`).join("\n") : "";
+  const result = await proc.process(css + sourceDirectives, {
+    from: from || "module.css"
+  });
+  return result.css;
+}
+function resetProcessor() {
+  processor = null;
+}
+async function createProcessor() {
+  const _require = createRequire(import.meta.url);
+  try {
+    const postcss = _require("postcss");
+    const postcssImport = _require("postcss-import");
+    const postcssNesting = _require("postcss-nesting");
+    const tailwindPostcss = _require("@tailwindcss/postcss");
+    const selectorParser = _require("postcss-selector-parser");
+    const postcssReplace = _require("postcss-replace");
+    const remToPx = _require("@thedutchcoder/postcss-rem-to-px");
+    const plugins = [
+      (postcssImport.default || postcssImport)(),
+      (postcssNesting.default || postcssNesting)(),
+      (tailwindPostcss.default || tailwindPostcss)(),
+      postcssMangleClasses(selectorParser)(),
+      // Same scoping rules as postcss.config.cjs: scope selectors to .bk
+      // and rename Tailwind CSS variables from --tw-* to --bk-tw-*.
+      (postcssReplace.default || postcssReplace)({
+        pattern: /(--tw|\*, ::before, ::after)/g,
+        data: {
+          "--tw": "--bk-tw",
+          "*, ::before, ::after": ".bk, .bk *, .bk-sidebar, .bk ::before, .bk ::after, .bk-vars, .bk-vars ::before, .bk-vars ::after",
+          "::backdrop": ".bk::backdrop, .bk ::backdrop"
+        }
+      }),
+      (remToPx.default || remToPx)({ baseValue: 16 })
+    ];
+    return postcss(plugins);
+  } catch (e) {
+    if (e.code === "MODULE_NOT_FOUND") {
+      processorUnavailable = true;
+      const missing = e.message.match(/Cannot find module '([^']+)'/)?.[1] || "unknown";
+      logger$2.warn(
+        `bl\xF6kkli's PostCSS pipeline is disabled \u2014 missing dependency "${missing}". This is only required if you author custom bl\xF6kkli modules or features that use Tailwind v4 \`@apply\` / \`theme()\` in their <style> blocks. To enable it, install:
+  npm install -D postcss tailwindcss @tailwindcss/postcss postcss-import postcss-nesting postcss-replace @thedutchcoder/postcss-rem-to-px`
+      );
+      return null;
+    }
+    throw e;
+  }
+}
+
+function mangleClassName(name) {
+  if (name === "bk" || name.startsWith("bk-") || name.startsWith("_bk_")) {
+    return name;
+  }
+  return "_bk_" + name;
+}
+function mangleClassString(str) {
+  return str.split(/\s+/).filter(Boolean).map(mangleClassName).join(" ");
+}
+
+function collectClassReplacements(node, out) {
+  switch (node.type) {
+    case "Literal":
+      if (typeof node.value === "string" && node.value) {
+        const mangled = mangleClassString(node.value);
+        if (mangled !== node.value) {
+          out.push({ start: node.start + 1, end: node.end - 1, value: mangled });
+        }
+      }
+      break;
+    case "ObjectExpression":
+      for (const prop of node.properties) {
+        if (prop.type === "Property") {
+          if (prop.key.type === "Literal" && typeof prop.key.value === "string") {
+            const mangled = mangleClassString(prop.key.value);
+            if (mangled !== prop.key.value) {
+              out.push({
+                start: prop.key.start + 1,
+                end: prop.key.end - 1,
+                value: mangled
+              });
+            }
+          } else if (prop.computed) {
+            collectClassReplacements(prop.key, out);
+          }
+        }
+      }
+      break;
+    case "ArrayExpression":
+      for (const el of node.elements) {
+        if (el) collectClassReplacements(el, out);
+      }
+      break;
+    case "ConditionalExpression":
+      collectClassReplacements(node.consequent, out);
+      collectClassReplacements(node.alternate, out);
+      break;
+    case "LogicalExpression":
+      collectClassReplacements(node.left, out);
+      collectClassReplacements(node.right, out);
+      break;
+    case "CallExpression":
+      if (node.callee.type === "Identifier" && node.callee.name === "tw") {
+        for (const arg of node.arguments) {
+          if (arg.type === "Literal" && typeof arg.value === "string") {
+            const mangled = mangleClassString(arg.value);
+            if (mangled !== arg.value) {
+              out.push({
+                start: arg.start + 1,
+                end: arg.end - 1,
+                value: mangled
+              });
+            }
+          }
+        }
+      }
+      break;
+  }
+}
+function mangleClassExpression(expr) {
+  let ast;
+  try {
+    ast = acorn.parse("(" + expr + ")", {
+      ecmaVersion: 2022,
+      sourceType: "module"
+    });
+  } catch {
+    return expr;
+  }
+  const body = ast.body[0];
+  if (!body || body.type !== "ExpressionStatement") return expr;
+  const replacements = [];
+  collectClassReplacements(body.expression, replacements);
+  if (replacements.length === 0) return expr;
+  replacements.sort((a, b) => b.start - a.start);
+  let result = expr;
+  for (const r of replacements) {
+    result = result.slice(0, r.start - 1) + r.value + result.slice(r.end - 1);
+  }
+  return result;
+}
+const CLASS_BEARING_PROPS = ["button-class", "background-class"];
+function mangleTemplateAndScript(code) {
+  let result = code;
+  result = result.replace(
+    /(?<![-:.])\bclass="([^"]*)"/g,
+    (_match, value) => `class="${mangleClassString(value)}"`
+  );
+  for (const prop of CLASS_BEARING_PROPS) {
+    const staticAttr = new RegExp(`(?<![:.])\\b${prop}="([^"]*)"`, "g");
+    result = result.replace(
+      staticAttr,
+      (_match, value) => `${prop}="${mangleClassString(value)}"`
+    );
+  }
+  result = result.replace(
+    /\btw\(\s*(['"])([\s\S]*?)\1\s*\)/g,
+    (_match, quote, value) => `tw(${quote}${mangleClassString(value)}${quote})`
+  );
+  result = result.replace(
+    /(?::|v-bind:)class="([^"]*)"/g,
+    (_match, expr) => `:class="${mangleClassExpression(expr)}"`
+  );
+  for (const prop of CLASS_BEARING_PROPS) {
+    const boundAttr = new RegExp(`(:|v-bind:)${prop}="([^"]*)"`, "g");
+    result = result.replace(
+      boundAttr,
+      (_match, prefix, expr) => `${prefix}${prop}="${mangleClassExpression(expr)}"`
+    );
+  }
+  return result;
+}
+function withTailwindConfig(cssContent, tailwindConfigPath) {
+  if (cssContent.includes("@reference") || cssContent.includes("@config")) {
+    return cssContent;
+  }
+  const leadingPattern = /^(?:\s*(?:\/\*[\s\S]*?\*\/|@charset[^;]*;|@import[^;]*;|@layer\s[\w\s,-]+;))*\s*/;
+  const match = cssContent.match(leadingPattern);
+  const insertAt = match ? match[0].length : 0;
+  const injection = `@reference 'tailwindcss';
+@config '${tailwindConfigPath}';
+`;
+  return cssContent.slice(0, insertAt) + injection + cssContent.slice(insertAt);
+}
+let stripProcessor = null;
+async function stripDistBoilerplate(css) {
+  if (!stripProcessor) {
+    const _require = createRequire(import.meta.url);
+    const postcss = _require("postcss");
+    const plugin = () => ({
+      postcssPlugin: "postcss-strip-blokkli-dist-boilerplate",
+      Once(root) {
+        const toUnwrap = [];
+        const toRemove = [];
+        root.walkAtRules("layer", (atRule) => {
+          if (!atRule.nodes) {
+            toRemove.push(atRule);
+            return;
+          }
+          const name = atRule.params.trim();
+          if (name === "base" || name === "theme" || name === "properties") {
+            toRemove.push(atRule);
+          } else if (name === "components" || name === "utilities") {
+            toUnwrap.push(atRule);
+          }
+        });
+        root.walkAtRules("property", (atRule) => {
+          if (atRule.params.startsWith("--bk-tw-")) {
+            toRemove.push(atRule);
+          }
+        });
+        for (const r of toUnwrap) r.replaceWith(r.nodes);
+        for (const r of toRemove) r.remove();
+      }
+    });
+    plugin.postcss = true;
+    stripProcessor = postcss([plugin()]);
+  }
+  const result = await stripProcessor.process(css, { from: void 0 });
+  return result.css;
+}
+async function processStyleBlocks(code, filePath, tailwindConfigPath) {
+  if (!await ensureProcessor()) return code;
+  const styleRegex = /<style([^>]*)>([\s\S]*?)<\/style>/g;
+  let result = code;
+  let styleMatch;
+  while ((styleMatch = styleRegex.exec(result)) !== null) {
+    const fullMatch = styleMatch[0];
+    const attrs = styleMatch[1] || "";
+    const cssContent = styleMatch[2] || "";
+    if (cssContent.trim()) {
+      const withConfig = withTailwindConfig(cssContent, tailwindConfigPath);
+      const processed = await processCSS(withConfig, filePath);
+      const stripped = await stripDistBoilerplate(processed);
+      const cleanAttrs = attrs.replace(/\s*lang=["']postcss["']/g, "");
+      const replacement = `<style${cleanAttrs}>${stripped}</style>`;
+      result = result.slice(0, styleMatch.index) + replacement + result.slice(styleMatch.index + fullMatch.length);
+      styleRegex.lastIndex = styleMatch.index + replacement.length;
+    }
+  }
+  return result;
+}
+async function mangleVueSFC(code, id, tailwindConfigPath) {
+  let result = mangleTemplateAndScript(code);
+  result = await processStyleBlocks(result, id, tailwindConfigPath);
+  if (result === code) return null;
+  return result;
+}
+
+const logger$1 = useLogger("@blokkli/editor");
+const styles = defineFileTemplate(
+  "styles.css",
+  async (ctx) => {
+    const cssFilePath = ctx.helper.resolvers.module.resolve(
+      "./runtime/editor/css/output.css"
+    );
+    let moduleCSS = "";
+    const tailwindConfigPath = ctx.helper.getTailwindConfigPath();
+    const cssFiles = ctx.getCSSFiles();
+    if (cssFiles.length > 0) {
+      resetProcessor();
+      const processed = [];
+      for (const filePath of cssFiles) {
+        const content = await ctx.helper.fileCache.read(filePath);
+        const withConfig = withTailwindConfig(content, tailwindConfigPath);
+        try {
+          const result = await processCSS(withConfig, filePath);
+          processed.push(result);
+        } catch (e) {
+          logger$1.error(
+            `Failed to process module CSS "${filePath}":
+${e.message}`
+          );
+        }
+      }
+      if (processed.length > 0) {
+        moduleCSS = "\n/* Module CSS */\n" + processed.join("\n");
+      }
+    }
+    const editorOwnRuntime = ctx.helper.resolvers.module.resolve("./runtime");
+    const editorOwnModules = ctx.helper.resolvers.module.resolve("./modules");
+    const contentPaths = ctx.getContentPaths().filter(
+      (p) => !p.startsWith(editorOwnRuntime) && !p.startsWith(editorOwnModules)
+    );
+    if (contentPaths.length > 0) {
+      try {
+        const utilities = await processCSS(
+          `@layer theme, base, components, utilities;
+@import 'tailwindcss/theme.css' layer(theme);
+@import 'tailwindcss/utilities.css' layer(utilities);
+@config '${tailwindConfigPath}';`,
+          "module-utilities.css",
+          contentPaths
+        );
+        if (utilities.trim()) {
+          moduleCSS += "\n/* Module Utilities */\n" + utilities;
+        }
+      } catch (e) {
+        logger$1.error(
+          `Failed to generate utilities for module content paths:
+${e.message}`
+        );
+      }
+    }
+    return `
+@import url("${cssFilePath}");
+
+${ctx.theme.css}
+${moduleCSS}
+`;
+  },
+  { dependencies: ["module-css"] }
+);
+
+function buildColorPalette(ctx) {
+  const palette = [];
+  for (const [id, option] of Object.entries(
+    ctx.helper.options.colorOptions || {}
+  )) {
+    if ("shades" in option) {
+      palette.push(`${id}.${option.mainShade}`);
+    } else {
+      palette.push(id);
+    }
+  }
+  return palette;
+}
+function mapVars(ctx) {
+  return {
+    itemEntityType: JSON.stringify(
+      ctx.helper.options.itemEntityType ?? "block"
+    ),
+    fromLibraryBlockBundle: JSON.stringify(
+      ctx.helper.options.fromLibraryBlockBundle ?? "from_library"
+    ),
+    fragmentBlockBundle: JSON.stringify(
+      ctx.helper.options.fragmentBlockBundle ?? "blokkli_fragment"
+    ),
+    colorPalette: JSON.stringify(buildColorPalette(ctx))
+  };
+}
+const config = defineCodeTemplate(
+  "config",
+  (ctx) => {
+    const vars = mapVars(ctx);
+    return `
+export const itemEntityType = ${vars.itemEntityType}
+
+export const fromLibraryBlockBundle = ${vars.fromLibraryBlockBundle}
+
+export const fragmentBlockBundle = ${vars.fragmentBlockBundle}
+
+export const colorPalette = ${vars.colorPalette}
+`;
+  },
+  (ctx) => {
+    const vars = mapVars(ctx);
+    return `
+/**
+ * The block item entity type.
+ */
+export declare const itemEntityType: ${vars.itemEntityType}
+
+export declare const fromLibraryBlockBundle: ${vars.fromLibraryBlockBundle}
+export declare const fragmentBlockBundle: ${vars.fragmentBlockBundle}
+
+/**
+ * Ordered list of canonical default color ids \u2014 one per declared family,
+ * in declaration order. Flat colors appear as bare ids, ramped colors as
+ * \`<id>.<mainShade>\`. Runtime consumers cycle through this to assign
+ * default colors (e.g. dynamic chart series); the runtime composable also
+ * walks it as a fallback cascade when a requested id can't be resolved.
+ */
+export declare const colorPalette: string[]
+`;
+  }
+);
+
+const accent$4 = {
+	"50": [
+		237,
+		247,
+		255
+	],
+	"100": [
+		215,
+		236,
+		255
+	],
+	"200": [
+		183,
+		223,
+		255
+	],
+	"300": [
+		134,
+		205,
+		255
+	],
+	"400": [
+		76,
+		176,
+		255
+	],
+	"500": [
+		35,
+		140,
+		255
+	],
+	"600": [
+		12,
+		107,
+		255
+	],
+	"700": [
+		5,
+		80,
+		230
+	],
+	"800": [
+		12,
+		67,
+		193
+	],
+	"900": [
+		16,
+		61,
+		152
+	],
+	"950": [
+		15,
+		38,
+		92
+	]
+};
+const mono$4 = {
+	"50": [
+		248,
+		250,
+		252
+	],
+	"100": [
+		241,
+		245,
+		249
+	],
+	"200": [
+		226,
+		232,
+		240
+	],
+	"300": [
+		203,
+		213,
+		225
+	],
+	"400": [
+		148,
+		163,
+		184
+	],
+	"500": [
+		100,
+		116,
+		139
+	],
+	"600": [
+		71,
+		85,
+		105
+	],
+	"700": [
+		51,
+		65,
+		85
+	],
+	"800": [
+		30,
+		41,
+		59
+	],
+	"900": [
+		15,
+		23,
+		42
+	],
+	"950": [
+		2,
+		6,
+		23
+	]
+};
+const teal$4 = {
+	light: [
+		204,
+		251,
+		241
+	],
+	normal: [
+		45,
+		212,
+		191
+	],
+	dark: [
+		19,
+		78,
+		74
+	]
+};
+const yellow$4 = {
+	light: [
+		254,
+		252,
+		232
+	],
+	normal: [
+		250,
+		204,
+		21
+	],
+	dark: [
+		113,
+		63,
+		18
+	]
+};
+const orange$1 = {
+	light: [
+		254,
+		243,
+		198
+	],
+	normal: [
+		254,
+		154,
+		0
+	],
+	dark: [
+		70,
+		25,
+		1
+	]
+};
+const red$4 = {
+	light: [
+		254,
+		242,
+		242
+	],
+	normal: [
+		239,
+		68,
+		68
+	],
+	dark: [
+		127,
+		29,
+		29
+	]
+};
+const lime$4 = {
+	light: [
+		236,
+		252,
+		203
+	],
+	normal: [
+		122,
+		196,
+		18
+	],
+	dark: [
+		81,
+		129,
+		19
+	]
+};
+const arctic = {
+	accent: accent$4,
+	mono: mono$4,
+	teal: teal$4,
+	yellow: yellow$4,
+	orange: orange$1,
+	red: red$4,
+	lime: lime$4
+};
+
+const accent$3 = {
+	"50": [
+		251,
+		245,
+		246
+	],
+	"100": [
+		248,
+		235,
+		238
+	],
+	"200": [
+		242,
+		217,
+		223
+	],
+	"300": [
+		230,
+		187,
+		197
+	],
+	"400": [
+		211,
+		134,
+		155
+	],
+	"500": [
+		198,
+		109,
+		135
+	],
+	"600": [
+		175,
+		79,
+		112
+	],
+	"700": [
+		146,
+		62,
+		93
+	],
+	"800": [
+		123,
+		54,
+		82
+	],
+	"900": [
+		123,
+		54,
+		82
+	],
+	"950": [
+		58,
+		23,
+		37
+	]
+};
+const mono$3 = {
+	"50": [
+		254,
+		253,
+		251
+	],
+	"100": [
+		251,
+		248,
+		239
+	],
+	"200": [
+		234,
+		230,
+		220
+	],
+	"300": [
+		230,
+		222,
+		209
+	],
+	"400": [
+		168,
+		153,
+		132
+	],
+	"500": [
+		124,
+		103,
+		100
+	],
+	"600": [
+		102,
+		92,
+		84
+	],
+	"700": [
+		80,
+		73,
+		69
+	],
+	"800": [
+		50,
+		48,
+		39
+	],
+	"900": [
+		40,
+		40,
+		40
+	],
+	"950": [
+		29,
+		32,
+		33
+	]
+};
+const teal$3 = {
+	light: [
+		216,
+		243,
+		233
+	],
+	normal: [
+		131,
+		165,
+		152
+	],
+	dark: [
+		38,
+		59,
+		51
+	]
+};
+const yellow$3 = {
+	light: [
+		251,
+		241,
+		199
+	],
+	normal: [
+		250,
+		189,
+		47
+	],
+	dark: [
+		144,
+		106,
+		20
+	]
+};
+const red$3 = {
+	light: [
+		255,
+		218,
+		214
+	],
+	normal: [
+		251,
+		73,
+		52
+	],
+	dark: [
+		142,
+		24,
+		11
+	]
+};
+const lime$3 = {
+	light: [
+		236,
+		236,
+		197
+	],
+	normal: [
+		184,
+		187,
+		38
+	],
+	dark: [
+		80,
+		80,
+		12
+	]
+};
+const gruvbox = {
+	accent: accent$3,
+	mono: mono$3,
+	teal: teal$3,
+	yellow: yellow$3,
+	red: red$3,
+	lime: lime$3
+};
+
+const accent$2 = {
+	"50": [
+		254,
+		247,
+		238
+	],
+	"100": [
+		254,
+		237,
+		214
+	],
+	"200": [
+		251,
+		215,
+		173
+	],
+	"300": [
+		249,
+		186,
+		120
+	],
+	"400": [
+		245,
+		147,
+		66
+	],
+	"500": [
+		242,
+		116,
+		29
+	],
+	"600": [
+		228,
+		91,
+		19
+	],
+	"700": [
+		188,
+		67,
+		18
+	],
+	"800": [
+		150,
+		54,
+		22
+	],
+	"900": [
+		121,
+		47,
+		21
+	],
+	"950": [
+		65,
+		21,
+		9
+	]
+};
+const mono$2 = {
+	"50": [
+		250,
+		250,
+		249
+	],
+	"100": [
+		245,
+		245,
+		244
+	],
+	"200": [
+		231,
+		229,
+		228
+	],
+	"300": [
+		214,
+		211,
+		209
+	],
+	"400": [
+		168,
+		162,
+		158
+	],
+	"500": [
+		120,
+		113,
+		108
+	],
+	"600": [
+		87,
+		83,
+		78
+	],
+	"700": [
+		68,
+		64,
+		60
+	],
+	"800": [
+		41,
+		37,
+		36
+	],
+	"900": [
+		28,
+		25,
+		23
+	],
+	"950": [
+		12,
+		10,
+		9
+	]
+};
+const teal$2 = {
+	light: [
+		217,
+		239,
+		242
+	],
+	normal: [
+		82,
+		179,
+		188
+	],
+	dark: [
+		3,
+		26,
+		28
+	]
+};
+const yellow$2 = {
+	light: [
+		242,
+		232,
+		202
+	],
+	normal: [
+		238,
+		192,
+		59
+	],
+	dark: [
+		79,
+		64,
+		17
+	]
+};
+const red$2 = {
+	light: [
+		254,
+		242,
+		242
+	],
+	normal: [
+		239,
+		68,
+		68
+	],
+	dark: [
+		127,
+		29,
+		29
+	]
+};
+const lime$2 = {
+	light: [
+		238,
+		243,
+		237
+	],
+	normal: [
+		103,
+		148,
+		88
+	],
+	dark: [
+		56,
+		80,
+		48
+	]
+};
+const fire = {
+	accent: accent$2,
+	mono: mono$2,
+	teal: teal$2,
+	yellow: yellow$2,
+	red: red$2,
+	lime: lime$2
+};
+
+const accent$1 = {
+	"50": [
+		230,
+		255,
+		245
+	],
+	"100": [
+		210,
+		255,
+		237
+	],
+	"200": [
+		169,
+		255,
+		220
+	],
+	"300": [
+		128,
+		255,
+		203
+	],
+	"400": [
+		87,
+		255,
+		186
+	],
+	"500": [
+		47,
+		255,
+		170
+	],
+	"600": [
+		6,
+		255,
+		153
+	],
+	"700": [
+		0,
+		220,
+		130
+	],
+	"800": [
+		0,
+		164,
+		97
+	],
+	"900": [
+		0,
+		108,
+		64
+	],
+	"950": [
+		0,
+		80,
+		47
+	]
+};
+const mono$1 = {
+	"50": [
+		248,
+		250,
+		252
+	],
+	"100": [
+		249,
+		249,
+		251
+	],
+	"200": [
+		238,
+		240,
+		246
+	],
+	"300": [
+		231,
+		233,
+		243
+	],
+	"400": [
+		197,
+		200,
+		221
+	],
+	"500": [
+		95,
+		97,
+		119
+	],
+	"600": [
+		56,
+		58,
+		82
+	],
+	"700": [
+		48,
+		50,
+		80
+	],
+	"800": [
+		14,
+		16,
+		53
+	],
+	"900": [
+		7,
+		9,
+		44
+	],
+	"950": [
+		0,
+		1,
+		15
+	]
+};
+const teal$1 = {
+	light: [
+		211,
+		239,
+		248
+	],
+	normal: [
+		92,
+		174,
+		201
+	],
+	dark: [
+		21,
+		43,
+		50
+	]
+};
+const yellow$1 = {
+	light: [
+		254,
+		252,
+		232
+	],
+	normal: [
+		233,
+		182,
+		63
+	],
+	dark: [
+		95,
+		72,
+		17
+	]
+};
+const red$1 = {
+	light: [
+		243,
+		221,
+		216
+	],
+	normal: [
+		220,
+		79,
+		48
+	],
+	dark: [
+		163,
+		63,
+		41
+	]
+};
+const lime$1 = {
+	light: [
+		230,
+		255,
+		245
+	],
+	normal: [
+		0,
+		164,
+		97
+	],
+	dark: [
+		0,
+		80,
+		47
+	]
+};
+const nuxt = {
+	accent: accent$1,
+	mono: mono$1,
+	teal: teal$1,
+	yellow: yellow$1,
+	red: red$1,
+	lime: lime$1
+};
+
+const accent = {
+	"50": [
+		245,
+		243,
+		255
+	],
+	"100": [
+		237,
+		233,
+		254
+	],
+	"200": [
+		221,
+		214,
+		255
+	],
+	"300": [
+		196,
+		180,
+		255
+	],
+	"400": [
+		166,
+		132,
+		255
+	],
+	"500": [
+		142,
+		81,
+		255
+	],
+	"600": [
+		127,
+		34,
+		254
+	],
+	"700": [
+		112,
+		8,
+		231
+	],
+	"800": [
+		93,
+		14,
+		192
+	],
+	"900": [
+		77,
+		23,
+		154
+	],
+	"950": [
+		47,
+		13,
+		104
+	]
+};
+const mono = {
+	"50": [
+		246,
+		245,
+		249
+	],
+	"100": [
+		243,
+		241,
+		252
+	],
+	"200": [
+		237,
+		236,
+		243
+	],
+	"300": [
+		218,
+		217,
+		226
+	],
+	"400": [
+		164,
+		163,
+		177
+	],
+	"500": [
+		115,
+		114,
+		131
+	],
+	"600": [
+		81,
+		80,
+		99
+	],
+	"700": [
+		59,
+		54,
+		76
+	],
+	"800": [
+		44,
+		28,
+		101
+	],
+	"900": [
+		22,
+		12,
+		55
+	],
+	"950": [
+		11,
+		5,
+		34
+	]
+};
+const teal = {
+	light: [
+		218,
+		247,
+		248
+	],
+	normal: [
+		48,
+		177,
+		196
+	],
+	dark: [
+		0,
+		67,
+		81
+	]
+};
+const yellow = {
+	light: [
+		255,
+		253,
+		211
+	],
+	normal: [
+		229,
+		218,
+		31
+	],
+	dark: [
+		86,
+		79,
+		0
+	]
+};
+const red = {
+	light: [
+		255,
+		219,
+		211
+	],
+	normal: [
+		231,
+		0,
+		11
+	],
+	dark: [
+		127,
+		0,
+		0
+	]
+};
+const lime = {
+	light: [
+		221,
+		255,
+		221
+	],
+	normal: [
+		69,
+		186,
+		80
+	],
+	dark: [
+		13,
+		81,
+		23
+	]
+};
+const orange = {
+	light: [
+		255,
+		235,
+		204
+	],
+	normal: [
+		250,
+		124,
+		32
+	],
+	dark: [
+		134,
+		49,
+		0
+	]
+};
+const revenexx = {
+	accent: accent,
+	mono: mono,
+	teal: teal,
+	yellow: yellow,
+	red: red,
+	lime: lime,
+	orange: orange
+};
+
+const themes = {
+  fire,
+  arctic,
+  gruvbox,
+  nuxt,
+  revenexx
+};
+const getTheme = (v) => {
+  if (typeof v === "string") {
+    if (v === "arctic") {
+      return themes.arctic;
+    } else if (v === "gruvbox") {
+      return themes.gruvbox;
+    } else if (v === "fire") {
+      return themes.fire;
+    } else if (v === "nuxt") {
+      return themes.nuxt;
+    } else if (v === "revenexx") {
+      return themes.revenexx;
+    }
+    throw new Error(`Invalid theme name: ${v}`);
+  }
+  return v || {};
+};
+
+const editorConfig = defineCodeTemplate(
+  "editor-config",
+  (ctx) => {
+    const settingsOverride = ctx.helper.options.settingsOverride || {};
+    const colorOptions = ctx.helper.options.colorOptions || {};
+    const featureFragmentNames = ctx.getFeatureFragmentNames();
+    return `
+export const hasCustomTheme = ${JSON.stringify(ctx.theme.hasCustomTheme)}
+
+export const themes = ${JSON.stringify(themes, null, 2)}
+
+export const theme = ${JSON.stringify(ctx.theme.fullTheme, null, 2)}
+
+export const colorOptions = ${JSON.stringify(colorOptions, null, 2)}
+
+export const settingsOverride = ${JSON.stringify(settingsOverride)}
+
+export const blokkliVersion = ${JSON.stringify(version)}
+
+export const templateEntityType = ${JSON.stringify(ctx.helper.options.templateEntityType ?? null)}
+
+export const storageDefaults  = ${JSON.stringify(
+      ctx.helper.options.storageDefaults || {}
+    )}
+export const defaultLanguage = ${JSON.stringify(
+      ctx.helper.options.defaultLanguage || "en"
+    )}
+export const forceDefaultLanguage = ${JSON.stringify(
+      !!ctx.helper.options.forceDefaultLanguage
+    )}
+
+export const featureFragmentNames = ${JSON.stringify(featureFragmentNames)}
+
+export const textAutoReplace = ${(() => {
+      const opt = ctx.helper.options.textAutoReplace;
+      const all = opt === void 0 || opt === true;
+      const obj = typeof opt === "object" && opt !== null ? opt : null;
+      return JSON.stringify({
+        quotes: obj ? obj.quotes ?? true : all,
+        ellipsis: obj ? obj.ellipsis ?? true : all,
+        enDash: obj ? obj.enDash ?? true : all
+      });
+    })()}
+`;
+  },
+  (ctx) => {
+    const validColorOptions = Object.keys(ctx.helper.options.colorOptions || {}).map((v) => `'${v}'`).join(" | ");
+    return `
+import type { Theme } from '${ctx.helper.relativePaths.TYPES_THEME}'
+import type { ModuleOptionsSettings } from '#blokkli-build/module-types'
+import type { InterfaceLanguage } from '#blokkli-build/translations'
+
+export type ValidColorOption = ${validColorOptions}
+
+export type GeneratedColorOption =
+  | { label: string; hex: string }
+  | { label: string; shades: Record<string, string>; mainShade: string }
+
+/**
+ * Whether the app uses a custom theme.
+ */
+export declare const hasCustomTheme: boolean
+
+/**
+ * All available themes.
+ */
+export declare const themes: Record<string, Theme>
+
+/**
+ * The available color options.
+ */
+export declare const colorOptions: Record<ValidColorOption, GeneratedColorOption>
+
+/**
+ * The default theme.
+ */
+export declare const theme: Theme
+
+/**
+ * Overrides for settings.
+ */
+export declare const settingsOverride: ModuleOptionsSettings
+
+/**
+ * The version of the @blokkli/editor package.
+ */
+export declare const blokkliVersion: string
+
+/**
+ * Default storage settings.
+ */
+export declare const storageDefaults: Record<string, string | boolean | string[]>
+
+/**
+ * The default/fallback language.
+ */
+export declare const defaultLanguage: InterfaceLanguage
+
+/**
+ * The entity type of templates.
+ */
+export declare const templateEntityType: string | null
+
+/**
+ * Whether to always force the default language, even on translation pages.
+ */
+export declare const forceDefaultLanguage: boolean
+
+/**
+ * The fragment names provided by features.
+ */
+export declare const featureFragmentNames: string[]
+
+/**
+ * Text auto-replace configuration.
+ */
+export declare const textAutoReplace: {
+  quotes: boolean
+  ellipsis: boolean
+  enDash: boolean
+}
+`;
+  },
+  {
+    context: "both",
+    write: true
+  }
+);
+
+function transformGlobalOptionsForType(globalOptions) {
+  const result = {};
+  for (const [key, option] of Object.entries(globalOptions)) {
+    const entry = { type: option.type };
+    if (option.type === "radios" || option.type === "checkboxes") {
+      if (option.options && Object.keys(option.options).length > 0) {
+        entry.options = Object.fromEntries(
+          Object.keys(option.options).map((k) => [k, null])
+        );
+      } else {
+        entry.options = "__RECORD_STRING_UNKNOWN__";
+      }
+    }
+    result[key] = entry;
+  }
+  return result;
+}
+function generateGlobalOptionsType(globalOptions) {
+  const transformed = transformGlobalOptionsForType(globalOptions);
+  return toTypeLiteral(transformed).replaceAll(
+    '"__RECORD_STRING_UNKNOWN__"',
+    "Record<string, unknown>"
+  );
+}
+const definitions = defineCodeTemplate(
+  "definitions",
+  (ctx) => {
+    const blocks = [];
+    const fragments = [];
+    const providers = [];
+    const icons = /* @__PURE__ */ new Map();
+    const images = /* @__PURE__ */ new Map();
+    const definitions = [];
+    const files = [...ctx.blocks.files.values()].sort(
+      (a, b) => b.identifier.localeCompare(a.identifier)
+    );
+    let key = "";
+    files.forEach((file) => {
+      if (!file.definition || !file.definitionSource) {
+        return;
+      }
+      const identifier = file.identifier;
+      key += identifier;
+      definitions.push(`const ${identifier} = ${file.definitionSource}`);
+      if (isBlock(file.definition)) {
+        blocks.push(identifier);
+        if (file.iconContents) {
+          icons.set(file.definition.bundle, JSON.stringify(file.iconContents));
+        }
+        if (file.imagePath) {
+          images.set(file.definition.bundle, file.imagePath);
+        }
+      } else if (isFragment(file.definition)) {
+        fragments.push(identifier);
+      } else {
+        providers.push(identifier);
+      }
+    });
+    const renderKey = hash(key);
+    const imageImports = [...images.entries()].map(([bundle, imagePath]) => {
+      return `import image_${bundle} from '${imagePath}?url'`;
+    }).join("\n");
+    const imageObject = [...images.keys()].map((bundle) => {
+      return `${bundle}: image_${bundle}`;
+    }).join(",\n  ");
+    return `
+${imageImports}
+
+${definitions.join("\n\n")}
+
+const images = {
+  ${imageObject}
+}
+
+const blocks = [
+  ${blocks.join(",\n  ")}
+]
+
+const fragments = [
+  ${fragments.join(",\n  ")}
+]
+
+const providers = [
+  ${providers.join(",\n  ")}
+]
+
+${toObject("icons", icons, true)}
+
+
+const globalOptions = ${JSON.stringify(ctx.helper.options.globalOptions || {})}
+
+const renderKey = "${renderKey}"
+
+const definitions = {
+  blocks,
+  fragments,
+  providers,
+  icons,
+  images,
+  globalOptions,
+  renderKey
+}
+
+export default definitions
+`;
+  },
+  (ctx) => {
+    const fragmentNames = [];
+    for (const file of ctx.blocks.files.values()) {
+      if (!file.definition) {
+        continue;
+      }
+      if (isFragment(file.definition)) {
+        fragmentNames.push(`'${file.definition.name}'`);
+      }
+    }
+    return `
+import type { GlobalOptionsKey } from '#blokkli-build/generated-types'
+import type { BlockDefinitionInput, BlockDefinitionOptionsInput, FragmentDefinitionInput, ProviderDefinitionInput } from '${ctx.helper.relativePaths.TYPES_DEFINITIONS}'
+
+export type BlockDefinition = BlockDefinitionInput<BlockDefinitionOptionsInput, GlobalOptionsKey[]>
+export type FragmentDefinition = FragmentDefinitionInput<Record<string, any>, GlobalOptionsKey[]>
+export type ProviderDefinition = ProviderDefinitionInput<Record<string, any>, GlobalOptionsKey[]>
+
+export type BlokkliFragmentName = ${fragmentNames.join(" | ") || "never"}
+
+export type GlobalOptionsType = ${generateGlobalOptionsType(ctx.helper.options.globalOptions || {})}
+
+export type Definitions = {
+  blocks: BlockDefinition[]
+  fragments: FragmentDefinition[]
+  providers: ProviderDefinition[]
+  icons: Record<string, string>
+  images: Record<string, string>
+  globalOptions: BlockDefinitionOptionsInput
+  renderKey: string
+}
+
+const definitions: Definitions
+
+export default definitions
+`;
+  },
+  {
+    dependencies: ["block-content", "block-path"]
+  }
+);
+
+const moduleTypes = defineCodeTemplate(
+  "module-types",
+  () => {
+    return `export {}`;
+  },
+  (ctx) => {
+    const features = ctx.features.getEnabledFeatures();
+    const settings = [];
+    features.forEach((feature) => {
+      if (feature.definition.settings) {
+        Object.entries(feature.definition.settings).sort((a, b) => a[0].localeCompare(b[0])).forEach(([key, setting]) => {
+          const settingsKey = `feature:${feature.id}:${key}`;
+          settings.push(`/** ${setting.label} */`);
+          if (setting.type === "radios") {
+            const type = Object.keys(setting.options).map((v) => `'${v}'`).join(" | ");
+            settings.push(
+              `'${settingsKey}'?: { disable?: boolean, default?: ${type} }
+`
+            );
+          } else if (setting.type === "checkbox") {
+            settings.push(
+              `'${settingsKey}'?: { disable?: boolean, default?: boolean }
+`
+            );
+          } else if (setting.type === "slider") {
+            settings.push(
+              `'${settingsKey}'?: { disable?: boolean, default?: number }
+`
+            );
+          } else {
+            settings.push(`'${settingsKey}'?: { disable?: boolean }
+`);
+          }
+        });
+      }
+    });
+    return `
+export type ModuleOptionsSettings = {
+  ${settings.join("\n  ")}
+}
+  `;
+  },
+  {
+    dependencies: ["features"]
+  }
+);
+
+function toRuntimeOptionArray(option) {
+  if (option.type === "radios") {
+    return [option.type, option.default, Object.keys(option.options)];
+  } else if (option.type === "checkboxes") {
+    return [option.type, option.default, Object.keys(option.options)];
+  } else if (option.type === "number") {
+    const hasBounds = option.min !== void 0 || option.max !== void 0;
+    if (option.nullable) {
+      return [option.type, option.default, [option.min, option.max], true];
+    }
+    if (hasBounds) {
+      return [option.type, option.default, [option.min, option.max]];
+    }
+    return [option.type, option.default];
+  } else if (option.type === "range") {
+    return [option.type, option.default, [option.min, option.max]];
+  } else if (option.type === "datetime-local") {
+    if (option.min !== void 0 || option.max !== void 0) {
+      return [option.type, option.default, [option.min, option.max]];
+    }
+    return [option.type, option.default];
+  } else if (option.type === "checkbox") {
+    return [option.type, option.default];
+  } else if (option.type === "color") {
+    return [option.type, option.default];
+  } else if (option.type === "json") {
+    if (option.dataType) {
+      return [option.type, option.default, option.dataType];
+    }
+    return [option.type, option.default];
+  }
+  return [option.type, option.default];
+}
+
+const runtimeOptions = defineCodeTemplate(
+  "runtime-options",
+  (ctx) => {
+    const globalOptions = ctx.helper.options.globalOptions || {};
+    const files = [...ctx.blocks.files.values()];
+    const items = files.map((v) => {
+      if (v.definition && v.identifier) {
+        return {
+          varName: v.identifier,
+          definition: v.definition,
+          variations: v.variations
+        };
+      }
+      return null;
+    }).filter(falsy);
+    const declarations = [];
+    const OPTIONS = /* @__PURE__ */ new Map();
+    const FIELD_MAPPING = /* @__PURE__ */ new Map();
+    for (const item of items) {
+      const optionDefinitions = Object.entries(item.definition.options || {});
+      const options = {};
+      if (item.definition.globalOptions) {
+        item.definition.globalOptions.forEach((name) => {
+          const option = globalOptions[name];
+          if (option) {
+            options[name] = toRuntimeOptionArray(option);
+          }
+        });
+      }
+      optionDefinitions.forEach(([name, option]) => {
+        options[name] = toRuntimeOptionArray(option);
+      });
+      const hasOptions = Object.keys(options).length > 0;
+      if (hasOptions) {
+        declarations.push(`const ${item.varName} = ${JSON.stringify(options)}`);
+        OPTIONS.set(item.varName, item.varName);
+      }
+      item.variations.forEach((variation) => {
+        if (hasOptions) {
+          OPTIONS.set(variation, item.varName);
+        }
+      });
+      if (isBlock(item.definition)) {
+        if (item.definition.propsFieldMapping) {
+          const mapping = Object.entries(
+            item.definition.propsFieldMapping
+          ).reduce(
+            (acc, [propName, mapping2]) => {
+              if (mapping2) {
+                acc[propName] = [mapping2.type, mapping2.name];
+              }
+              return acc;
+            },
+            {}
+          );
+          FIELD_MAPPING.set(
+            item.definition.bundle,
+            JSON.stringify(mapping, null, 2)
+          );
+        }
+      }
+    }
+    return `
+${declarations.join("\n")}
+
+${toObject("OPTIONS", OPTIONS)}
+${toObject("FIELD_MAPPING", FIELD_MAPPING)}
+`;
+  },
+  (ctx) => {
+    const globalOptions = ctx.helper.options.globalOptions || {};
+    const blocks = [...ctx.blocks.files.values()].map((v) => {
+      if (v.definition && isBlock(v.definition)) {
+        return v.definition;
+      }
+      return null;
+    }).filter(falsy);
+    function getOptionTypes(definition) {
+      const definedOptions = definition.options || {};
+      const blockGlobalOptions = definition.globalOptions || [];
+      blockGlobalOptions.forEach((key) => {
+        if (globalOptions[key]) {
+          definedOptions[key] = globalOptions[key];
+        }
+      });
+      return Object.entries(definedOptions || {}).map(([key, option]) => {
+        if (option.type === "text" || option.type === "datetime-local") {
+          return `${key}: string`;
+        } else if (option.type === "checkbox") {
+          return `${key}: boolean`;
+        } else if (option.type === "checkboxes") {
+          const possibleValues = Object.keys(option.options).map((v) => `'${v}'`).join(" | ") || "string";
+          return `${key}: Array<${possibleValues}>`;
+        } else if (option.type === "radios") {
+          const possibleValues = Object.keys(option.options).map((v) => `'${v}'`).join(" | ") || "string";
+          return `${key}: ${possibleValues}`;
+        } else if (option.type === "color") {
+          return key + ": `#${string}`";
+        } else if (option.type === "range") {
+          return `${key}: number`;
+        } else if (option.type === "number") {
+          return option.nullable ? `${key}: number | undefined` : `${key}: number`;
+        }
+      });
+    }
+    const runtimeMappedOptionTypes = blocks.map((definition) => {
+      if (definition.renderFor) {
+        return null;
+      }
+      const bundle = definition.bundle;
+      const options = getOptionTypes(definition).join("\n    ");
+      if (!options) {
+        return `  ${bundle}: {}`;
+      }
+      return `  ${bundle}: {
+    ${options}
+  }`;
+    }).filter(falsy).join(",\n");
+    return `
+import type { BlockOptionDefinition } from '${ctx.helper.relativePaths.TYPES_BLOKK_OPTIONS}'
+
+export type RuntimeBlockOptions = {
+${runtimeMappedOptionTypes}
+}
+
+export type PropsFieldMappingType = 'editable' | 'droppable' | 'field'
+
+export declare const OPTIONS: Record<string, Record<string, RuntimeBlockOptionArray>>
+export declare const FIELD_MAPPING: Record<string, Record<string, [PropsFieldMappingType, string]>>
+`;
+  },
+  {
+    dependencies: ["block-content", "block-path"]
+  }
+);
+
+const editComponents = defineCodeTemplate(
+  "edit-components",
+  (ctx) => {
+    const imports = {};
+    const proxyComponents = /* @__PURE__ */ new Map();
+    const diffComponents = /* @__PURE__ */ new Map();
+    for (const file of ctx.blocks.files.values()) {
+      if (!file.definition || !isBlock(file.definition)) {
+        continue;
+      }
+      const { bundle } = file.definition;
+      if (file.proxyComponentPath) {
+        const importName = "proxy_" + bundle;
+        imports[importName] = file.proxyComponentPath;
+        proxyComponents.set(bundle, importName);
+      } else if (file.diffComponentPath) {
+        const importName = "diff_" + file.definition.bundle;
+        imports[importName] = file.diffComponentPath;
+        diffComponents.set(bundle, importName);
+      }
+    }
+    const importLines = Object.entries(imports).map(([variableName, path]) => {
+      return `import ${variableName} from '${path}'`;
+    }).join("\n");
+    return `
+${importLines}
+
+${toObject("PROXY_COMPONENTS", proxyComponents)}
+
+${toObject("DIFF_COMPONENTS", diffComponents)}
+`;
+  },
+  () => {
+    return `
+export declare const PROXY_COMPONENTS: Record<string, any>
+export declare const DIFF_COMPONENTS: Record<string, any>
+`;
+  },
+  {
+    dependencies: ["block-path"]
+  }
+);
+
+function toStringUnion(strings) {
+  return strings.sort().map((v) => `'${v}'`).join(" | ") || "never";
+}
+function getOptionTypes(definition, globalOptions) {
+  const definedOptions = { ...definition.options || {} };
+  const blockGlobalOptions = definition.globalOptions || [];
+  blockGlobalOptions.forEach((key) => {
+    if (globalOptions[key]) {
+      definedOptions[key] = globalOptions[key];
+    }
+  });
+  const options = Object.entries(definedOptions || {}).map(([key, option]) => {
+    if (option.type === "checkbox") {
+      return `${key}: '1' | '0' | undefined`;
+    } else if (option.type === "text" || option.type === "radios" || option.type === "checkboxes" || option.type === "color" || option.type === "datetime-local") {
+      return `${key}: string | undefined`;
+    } else if (option.type === "range" || option.type === "number") {
+      return `${key}: number | string | undefined`;
+    }
+  }).join("\n    ");
+  return `{
+    ${options}
+  }`;
+}
+const generatedTypes = defineCodeTemplate(
+  "generated-types",
+  () => {
+    return `export {}`;
+  },
+  (ctx) => {
+    const fromLibraryBlockBundle = ctx.helper.options.fromLibraryBlockBundle;
+    const fragmentBlockBundle = ctx.helper.options.fragmentBlockBundle;
+    const mappedGetBundlePropsType = (bundle, file) => {
+      if (bundle === fromLibraryBlockBundle || bundle === fragmentBlockBundle) {
+        return {
+          typeName: "Props",
+          from: file.filePath
+        };
+      } else if (ctx.helper.options.getBundlePropsType) {
+        return ctx.helper.options.getBundlePropsType(bundle, file);
+      }
+      return null;
+    };
+    const chunkNames = ctx.helper.options.chunkNames || ["global"];
+    const fieldListTypes = ctx.helper.options.fieldListTypes || ["default"];
+    const providerTypes = ctx.helper.options.providerTypes || ["default"];
+    const globalOptions = ctx.helper.options.globalOptions || {};
+    const validGlobalOptions = Object.keys(globalOptions);
+    const blockBundlesWithNested = [];
+    const validBlockBundles = [];
+    const propTypeImports = {};
+    const propTypes = {};
+    const typedFieldListItems = [];
+    for (const file of ctx.blocks.files.values()) {
+      if (!file.definition || !isBlock(file.definition)) {
+        continue;
+      }
+      if (file.hasBlokkliField) {
+        blockBundlesWithNested.push(file.definition.bundle);
+      }
+      if (file.definition.bundle !== ctx.helper.options.fromLibraryBlockBundle && !validBlockBundles.includes(file.definition.bundle)) {
+        validBlockBundles.push(file.definition.bundle);
+      }
+      if (!file.definition.renderFor) {
+        const bundle = file.definition.bundle;
+        const options = getOptionTypes(file.definition, globalOptions);
+        const generatedTypeName = `FieldListItem_${bundle}`;
+        const lines = [`  bundle: '${bundle}'`, `options: ${options}`];
+        const bundlePropsType = mappedGetBundlePropsType(bundle, file);
+        if (bundlePropsType) {
+          const { typeName, from } = bundlePropsType;
+          if (!propTypeImports[from]) {
+            propTypeImports[from] = [];
+          }
+          propTypeImports[from].push({ bundle, typeName });
+          const tsTypeName = `Bundle_${bundle}_Props`;
+          lines.push(`props: ${tsTypeName}`);
+          propTypes[bundle] = tsTypeName;
+        }
+        const typeDefinition = `
+type ${generatedTypeName} = {
+${lines.join("\n  ")}
+}`;
+        typedFieldListItems.push({
+          typeName: generatedTypeName,
+          typeDefinition
+        });
+      }
+    }
+    const propTypeImportStatements = Object.entries(propTypeImports).map(([from, items]) => {
+      const imports = items.map((v) => {
+        return `${v.typeName} as Bundle_${v.bundle}_Props`;
+      }).join(", ");
+      const importPath = from.startsWith("/") ? ctx.helper.toModuleBuildRelative(from) : from;
+      return `import type { ${imports} } from '${importPath}'`;
+    }).join("\n");
+    const BundleProps = Object.entries(propTypes).map(([key, type]) => {
+      return `'${key}': ${type}`;
+    }).join("\n  ");
+    return `
+${propTypeImportStatements}
+import type { FieldListItem } from "${ctx.helper.relativePaths.TYPES}"
+
+export type ValidFieldListTypes = ${toStringUnion(fieldListTypes)}
+
+export type ValidProviderTypes = ${toStringUnion(providerTypes)}
+
+export type BlockBundle = ${toStringUnion(validBlockBundles)}
+
+export type BlockBundleWithNested = ${toStringUnion(blockBundlesWithNested)}
+
+export type ValidChunkNames = ${toStringUnion(chunkNames)}
+
+export type BundleProps = {
+  ${BundleProps}
+}
+
+export type GlobalOptionsKey = ${toStringUnion(validGlobalOptions)}
+
+export type ValidGlobalConfigKeys = Array<GlobalOptionsKey>
+
+${typedFieldListItems.map((v) => v.typeDefinition).join("\n\n")}
+
+export type FieldListItemTyped = Omit<FieldListItem, 'props'> & (${typedFieldListItems.map((v) => v.typeName).sort().join(" | ")})
+export type FieldListItemTypedArray = Array<FieldListItemTyped>
+`;
+  },
+  {
+    dependencies: ["block-path"]
+  }
+);
+
+const defaultGlobalOptions = defineCodeTemplate(
+  "default-global-options",
+  (ctx) => {
+    const globalOptions = ctx.helper.options.globalOptions || {};
+    const defaults = Object.entries(globalOptions).reduce(
+      (acc, [key, option]) => {
+        if (option.default !== void 0 && option.default !== null) {
+          acc[key] = {
+            default: option.default,
+            type: option.type
+          };
+        }
+        return acc;
+      },
+      {}
+    );
+    const bundlesWithVisibleLanguage = [];
+    const bundlesWithHiddenGlobally = [];
+    for (const file of ctx.blocks.files.values()) {
+      if (!file.definition || !isBlock(file.definition)) {
+        continue;
+      }
+      const usedGlobalOptions = file.definition.globalOptions || [];
+      if (usedGlobalOptions.includes(BK_VISIBLE_LANGUAGES)) {
+        bundlesWithVisibleLanguage.push(file.definition.bundle);
+      }
+      if (usedGlobalOptions.includes(BK_HIDDEN_GLOBALLY)) {
+        bundlesWithHiddenGlobally.push(file.definition.bundle);
+      }
+    }
+    return `
+export const bundlesWithVisibleLanguage = ${JSON.stringify(bundlesWithVisibleLanguage.sort())}
+export const bundlesWithHiddenGlobally = ${JSON.stringify(bundlesWithHiddenGlobally.sort())}
+
+export const globalOptionsDefaults = ${JSON.stringify(defaults, null, 2)}`;
+  },
+  (ctx) => {
+    return `
+import type { BlockOptionDefinition } from '${ctx.helper.relativePaths.TYPES_BLOKK_OPTIONS}'
+
+type GlobalOptionsDefaults = {
+  type: BlockOptionDefinition['type']
+  default: any
+}
+
+export declare const bundlesWithVisibleLanguage: string[]
+export declare const bundlesWithHiddenGlobally: string[]
+
+export declare const globalOptionsDefaults: Record<string, GlobalOptionsDefaults>
+`;
+  },
+  {
+    dependencies: ["block-path"]
+  }
+);
+
+const imports = defineCodeTemplate(
+  "imports",
+  (ctx) => {
+    const chunkMapping = {};
+    for (const file of ctx.blocks.files.values()) {
+      if (!file.definition) {
+        continue;
+      }
+      file.variations.forEach((variation) => {
+        chunkMapping[variation] = file.chunkName;
+      });
+    }
+    const lines = Object.entries(chunkMapping).map(
+      ([variation, importName]) => {
+        return `'${variation}': '${importName}'`;
+      }
+    );
+    const chunks = ctx.helper.getChunkNames().map((chunkName) => {
+      if (chunkName === "global") {
+        return null;
+      }
+      return `${chunkName}: () => import('#blokkli-build/chunk-${chunkName}.js').then(v => v['${chunkName}'])`;
+    }).filter(falsy).sort().join(",\n  ");
+    return `
+import { global } from '#blokkli-build/chunk-global.js'
+
+export const chunks = {
+  global,
+  ${chunks}
+}
+
+export const chunkMapping = {
+  ${lines.sort().join(",\n  ")}
+}
+`;
+  },
+  () => {
+    return `
+import type { Component } from 'vue'
+
+export type ChunkGroup = Record<string, Component | { loadComponent: () => Promise<Component> } >
+export type ChunkGroupEntry = ChunkGroup | (() => Promise<ChunkGroup>)
+
+/**
+ * Mapping of block/fragment variation ID to a chunk group.
+ *
+ * The variation is only present if its chunkName is not 'global'.
+ */
+export declare const chunkMapping: Record<string, string>
+
+/**
+ * All available chunks.
+ */
+export declare const chunks: Record<string, ChunkGroupEntry>
+`;
+  },
+  {
+    dependencies: ["block-path", "block-content"]
+  }
+);
+
+const optionsSchema = withHelper((helper) => {
+  let fileName = "options-schema.json";
+  const outputPath = helper.options.schemaOptionsPath;
+  if (outputPath) {
+    const resolved = resolveAlias(outputPath);
+    fileName = helper.resolvers.src.resolve(resolved);
+  }
+  return defineFileTemplate(fileName, (ctx) => {
+    const globalOptions = ctx.helper.options.globalOptions || {};
+    const blocks = [...ctx.blocks.files.values()];
+    const schema = blocks.reduce((acc, v) => {
+      if (v.definition && isBlock(v.definition)) {
+        const bundle = v.definition.bundle;
+        const existing = acc[v.definition.bundle] || {};
+        acc[v.definition.bundle] = defu(existing, v.definition.options || {});
+        const globalOptionKeys = v.definition.globalOptions || [];
+        globalOptionKeys.forEach((name) => {
+          if (globalOptions[name]) {
+            acc[bundle][name] = globalOptions[name];
+          }
+        });
+      }
+      return acc;
+    }, {});
+    const sorted = sortObjectKeys(schema);
+    return JSON.stringify(sorted, null, 2);
+  });
+});
+
+const chunkGroup = withHelper((helper) => {
+  return helper.getChunkNames().map((chunkName) => {
+    return defineCodeTemplate(
+      "chunk-" + chunkName,
+      (ctx) => {
+        const imports = [];
+        const map = {};
+        for (const file of ctx.blocks.files.values()) {
+          if (!file.definition) {
+            continue;
+          }
+          if (file.type === "provider") {
+            continue;
+          }
+          if (!fs__default.existsSync(file.filePath)) {
+            continue;
+          }
+          if (file.chunkName !== chunkName) {
+            continue;
+          }
+          if (helper.isDev) {
+            imports.push(
+              `const ${file.identifier} = () => import('${file.filePath}').then(v => v.default)`
+            );
+            file.variations.forEach((variation) => {
+              map[variation] = `{ loadComponent: ${file.identifier} }`;
+            });
+          } else {
+            imports.push(`import ${file.identifier} from '${file.filePath}'`);
+            file.variations.forEach((variation) => {
+              map[variation] = file.identifier;
+            });
+          }
+        }
+        const lines = Object.entries(map).map(([variation, importName]) => {
+          return `'${variation}': ${importName}`;
+        });
+        return `
+${imports.sort().join("\n")}
+
+export const ${chunkName} = {
+  ${lines.sort().join(",\n  ")}
+}
+`;
+      },
+      () => {
+        return `
+import type { Component } from 'vue'
+export declare const ${chunkName}: Record<string, { loadComponent: () => Promise<Component> } | Component>
+`;
+      },
+      {
+        dependencies: ["block-path", "block-content"]
+      }
+    );
+  });
+});
+
+const chunkEditing = defineCodeTemplate(
+  "chunk-editing",
+  (ctx) => {
+    const imports = [];
+    const map = /* @__PURE__ */ new Map();
+    for (const file of ctx.blocks.files.values()) {
+      if (!file.definition) {
+        continue;
+      }
+      if (file.type === "provider") {
+        continue;
+      }
+      if (!fs__default.existsSync(file.filePath)) {
+        continue;
+      }
+      imports.push(
+        `import ${file.identifier} from '${file.filePath}?blokkliEditing=true'`
+      );
+      file.variations.forEach((variation) => {
+        map.set(variation, file.identifier);
+      });
+    }
+    return `
+${imports.sort().join("\n")}
+
+${toObject("allComponents", map)}
+`;
+  },
+  () => {
+    return `
+import type { Component } from 'vue'
+
+/**
+ * A map of block import identifier and block component.
+ *
+ * This should ONLY be imported in editor code, since it imports ALL block components.
+ */
+export declare const allComponents: Record<string, Component>
+`;
+  },
+  {
+    dependencies: ["block-path", "block-content"]
+  }
+);
+
+const importMeta = defineFileTemplate("import-meta.d.ts", () => {
+  return `declare global {
+  interface ImportMeta {
+    /**
+     * Whether this block or fragment component is rendered in the editor
+     * bundle.
+     *
+     * This only works in components that either contain defineBlokkli or
+     * defineBlokkliFragment or in components that are imported by any of these
+     * components.
+     *
+     * It will always resolve to "false" if used in any other place.
+     */
+    readonly blokkliEditing: boolean
+  }
+}
+
+export {}
+`;
+});
+
+const materialIcons = defineFileTemplate("material-icons.d.ts", (ctx) => {
+  const iconNames = ctx.icons.getValidMaterialIconNames();
+  return `
+/**
+ * All available Material Symbols icon names (rounded style).
+ */
+export type MaterialIconName =
+${iconNames.map((name) => `  | '${name}'`).join("\n")}
+`;
+});
+
+const complexOptionTypes = defineCodeTemplate(
+  "complex-option-types",
+  (ctx) => {
+    const types = ctx.getComplexOptionTypes();
+    if (types.length === 0) {
+      return `export const COMPLEX_OPTION_TYPES = {}`;
+    }
+    const entries = types.map(
+      (t) => `  '${t.id}': {
+    editorComponent: defineAsyncComponent(() => import('${ctx.helper.toModuleBuildRelative(t.editorComponentPath)}')),
+    editTitle: ${JSON.stringify(t.editTitle)},
+    editorIcon: '${t.editorIcon}',
+  }`
+    ).join(",\n");
+    return `import { defineAsyncComponent } from 'vue'
+
+export const COMPLEX_OPTION_TYPES = {
+${entries}
+}`;
+  },
+  (ctx) => {
+    const types = ctx.getComplexOptionTypes();
+    if (types.length === 0) {
+      return `export interface ComplexOptionTypeMap {}
+export const COMPLEX_OPTION_TYPES: Record<string, never>`;
+    }
+    const imports = types.map(
+      (t) => `import type { ${t.typeName} } from '${ctx.helper.toModuleBuildRelative(t.typePath)}'`
+    ).join("\n");
+    const entries = types.map((t) => `  '${t.id}': ${t.typeName}`).join("\n");
+    return `${imports}
+import type { BlokkliIcon } from './icons'
+import type { Component } from 'vue'
+
+export interface ComplexOptionTypeMap {
+${entries}
+}
+
+export const COMPLEX_OPTION_TYPES: Record<string, {
+  editorComponent: Component
+  editTitle: { key: string; defaultTranslation: string }
+  editorIcon: BlokkliIcon
+}>`;
+  },
+  {
+    write: true
+  }
+);
+
+const TEMPLATES = [
+  icons,
+  features,
+  featuresJson,
+  translations,
+  editAdapter,
+  adapterExtensions,
+  styles,
+  config,
+  editorConfig,
+  definitions,
+  moduleTypes,
+  runtimeOptions,
+  editComponents,
+  generatedTypes,
+  defaultGlobalOptions,
+  imports,
+  optionsSchema,
+  chunkGroup,
+  chunkEditing,
+  importMeta,
+  materialIcons,
+  complexOptionTypes
+];
+
+class CollectedFeatureFile extends CollectedFile {
+  definition = null;
+  composableName = "defineBlokkliFeature";
+  enabled = true;
+  objectLiteral = void 0;
+  getDefinition() {
+    return this.definition;
+  }
+  async handleChange() {
+    const objectLiteral = extractObjectLiteral(this.fileContents, [
+      this.composableName
+    ]);
+    if (this.objectLiteral === objectLiteral) {
+      return false;
+    }
+    this.objectLiteral = objectLiteral;
+    if (!this.objectLiteral) {
+      return false;
+    }
+    try {
+      const { object: definition, source } = parseTsObject(this.objectLiteral);
+      const regex = /\/Features\/([^/]+)\//;
+      const componentName = this.filePath.match(regex)?.[1] || "";
+      this.definition = {
+        id: definition.id,
+        componentName,
+        componentPath: this.filePath,
+        definition,
+        definitionSource: source
+      };
+    } catch (e) {
+      console.error(
+        `Failed to parse component "${this.filePath}": ${this.composableName} does not contain a valid object literal. No variables and methods are allowed inside ${this.composableName}().`,
+        e
+      );
+    }
+    return Promise.resolve(true);
+  }
+  isEnabled() {
+    return this.enabled;
+  }
+  /**
+   * Disable the feature.
+   */
+  disable() {
+    this.enabled = false;
+  }
+}
+class FeatureCollector extends Collector {
+  needsFileContents = true;
+  disabledFeatures = /* @__PURE__ */ new Set();
+  srcFromModule;
+  srcFromBlokkliDir;
+  constructor(helper) {
+    super(helper);
+    this.srcFromModule = helper.resolvers.module.resolve(
+      "./runtime/editor/features"
+    );
+    this.srcFromBlokkliDir = helper.resolvers.root.resolve("./blokkli/features");
+  }
+  getEnabledFeatures() {
+    return [...this.files.values()].filter((v) => v.isEnabled()).map((v) => v.getDefinition()).filter(falsy).filter((v) => !this.disabledFeatures.has(v.id));
+  }
+  async init() {
+    const builtinFeatures = await resolveFiles(
+      this.srcFromModule,
+      ["*/index.vue"],
+      {
+        followSymbolicLinks: false
+      }
+    );
+    const blokkliDirFeatures = await resolveFiles(
+      this.srcFromBlokkliDir,
+      ["*/index.vue"],
+      {
+        followSymbolicLinks: false
+      }
+    );
+    const customFeatures = this.helper.options.featureImports ? await resolveFiles(
+      this.helper.paths.srcDir,
+      this.helper.options.featureImports,
+      {
+        followSymbolicLinks: false
+      }
+    ) : [];
+    await Promise.all(
+      [...builtinFeatures, ...blokkliDirFeatures, ...customFeatures].map(
+        (v) => this.addFile(v)
+      )
+    );
+    const features = [...this.files.values()];
+    if (!this.helper.options.enableThemeEditor) {
+      const themeFeature = features.find(
+        (v) => v.getDefinition()?.id === "theme"
+      );
+      if (themeFeature) {
+        themeFeature.disable();
+      }
+    }
+  }
+  runHooks() {
+    return this.helper.nuxt.hooks.callHook("blokkli:alter-features", {
+      features: [...this.files.values()]
+    });
+  }
+  createCollectedFile(filePath, fileContents = "") {
+    return new CollectedFeatureFile(filePath, fileContents);
+  }
+  applies(filePath) {
+    return Promise.resolve(
+      filePath.startsWith(this.srcFromModule) || micromatch.isMatch(filePath, "icon-blokkli-*.svg")
+    );
+  }
+  getDependencyTypes() {
+    return ["features"];
+  }
+  disableFeature(id) {
+    this.disabledFeatures.add(id);
+  }
+}
+
+function hexToRgb(hex) {
+  if (hex.startsWith("#")) {
+    hex = hex.slice(1);
+  }
+  if (hex.length === 3) {
+    hex = hex.split("").map((char) => char + char).join("");
+  }
+  const r = Number.parseInt(hex.slice(0, 2), 16);
+  const g = Number.parseInt(hex.slice(2, 4), 16);
+  const b = Number.parseInt(hex.slice(4, 6), 16);
+  return [r, g, b];
+}
+const buildThemeData = (themeOption) => {
+  const hasCustomTheme = !!themeOption;
+  const mergeTheme = createDefu((obj, key, value) => {
+    if (Array.isArray(obj[key])) {
+      obj[key] = value;
+      return true;
+    }
+  });
+  const theme = mergeTheme(getTheme(themeOption), themes.arctic);
+  const vars = Object.entries(theme).map(([group, colors]) => {
+    return Object.entries(colors).map(([shade, color]) => {
+      const rgb = typeof color === "string" ? hexToRgb(color) : color;
+      return `--bk-theme-${group}-${shade}: ${rgb[0]} ${rgb[1]} ${rgb[2]}`;
+    });
+  }).flat().join(";\n");
+  const themeCss = `
+  :root {
+    ${vars}
+  }
+  `;
+  const fullTheme = Object.entries(theme).reduce(
+    (acc, [group, colors]) => {
+      acc[group] = Object.entries(colors).reduce(
+        (colorAcc, [key, color]) => {
+          const rgb = typeof color === "string" ? hexToRgb(color) : color;
+          colorAcc[key] = rgb;
+          return colorAcc;
+        },
+        {}
+      );
+      return acc;
+    },
+    {}
+  );
+  return { themeCss, fullTheme, hasCustomTheme };
+};
+class ThemeData {
+  css;
+  fullTheme;
+  hasCustomTheme;
+  constructor(helper) {
+    const data = buildThemeData(helper.options.theme);
+    this.css = data.themeCss;
+    this.fullTheme = data.fullTheme;
+    this.hasCustomTheme = data.hasCustomTheme;
+  }
+}
+
+const logger = useLogger("@blokkli/editor");
+const module$1 = defineNuxtModule({
+  meta: {
+    name,
+    configKey: "blokkli",
+    version,
+    compatibility: {
+      nuxt: ">=3.15.0"
+    }
+  },
+  defaults: {
+    globalOptions: {
+      [BK_VISIBLE_LANGUAGES]: {
+        type: "checkboxes",
+        label: "Visible languages",
+        description: "Only show on specific languages.",
+        options: {},
+        default: []
+      },
+      [BK_HIDDEN_GLOBALLY]: {
+        type: "checkbox",
+        label: "Hide globally",
+        description: "Always hides the block.",
+        default: false
+      }
+    },
+    chunkNames: ["global"],
+    fromLibraryBlockBundle: "from_library",
+    fragmentBlockBundle: "blokkli_fragment"
+  },
+  async setup(moduleOptions, nuxt) {
+    const blokkliModules = moduleOptions.modules || [];
+    for (const module of blokkliModules) {
+      if (module.init.alterOptions) {
+        module.init.alterOptions(moduleOptions);
+      }
+    }
+    const helper = new ModuleHelper(
+      nuxt,
+      logger,
+      import.meta.url,
+      moduleOptions
+    );
+    const colorOptions = {};
+    for (const [id, option] of Object.entries(
+      helper.options.colorOptions || {}
+    )) {
+      if ("shades" in option) {
+        colorOptions[id] = option.shades[option.mainShade];
+        for (const [shadeId, hex] of Object.entries(option.shades)) {
+          colorOptions[`${id}.${shadeId}`] = hex;
+        }
+      } else {
+        colorOptions[id] = option.hex;
+      }
+    }
+    nuxt.options.appConfig.blokkli = {
+      // @ts-expect-error generic type vs runtime derived type.
+      colorOptions
+    };
+    const theme = new ThemeData(helper);
+    const iconCollector = new IconCollector(helper);
+    const featureCollector = new FeatureCollector(helper);
+    const blockCollector = new BlockCollector(helper, iconCollector);
+    const collectors = [
+      iconCollector,
+      featureCollector,
+      blockCollector
+    ];
+    const context = new ModuleContext(
+      helper,
+      iconCollector,
+      featureCollector,
+      blockCollector,
+      theme
+    );
+    const distMarker = helper.resolvers.module.resolve(
+      "./modules/tailwind/index.mjs"
+    );
+    const isRunningFromDist = helper.fileCache.fileExists(distMarker);
+    if (!isRunningFromDist) {
+      context.addContentPath(helper.resolvers.module.resolve("./runtime"));
+      context.addContentPath(helper.resolvers.module.resolve("./modules"));
+    }
+    const app = {
+      helper,
+      context,
+      $t: (key, defaultText) => ({
+        key,
+        defaultTranslation: defaultText
+      })
+    };
+    for (const module of blokkliModules) {
+      await module.init.setup(app, module.options);
+    }
+    app.context.collectors.forEach((collector) => {
+      collectors.push(collector);
+    });
+    await Promise.all(collectors.map((v) => v.init()));
+    await Promise.all(collectors.map((v) => v.runHooks()));
+    const hasErrors = [...collectors, helper].flatMap((v) => v.validate(iconCollector)).some((v) => v);
+    if (!helper.isDev && !helper.isPrepare && hasErrors) {
+      throw new Error("Failed to build bl\xF6kkli due to validation errors.");
+    }
+    TEMPLATES.forEach((v) => {
+      if (typeof v === "function") {
+        const result = v(helper);
+        const templates = Array.isArray(result) ? result : [result];
+        templates.forEach((template) => {
+          context.addTemplate(template);
+        });
+      } else {
+        context.addTemplate(v);
+      }
+    });
+    await context.generateTemplates();
+    helper.addAlias("#blokkli-build", helper.paths.blokkliBuildDir);
+    helper.inlineForNitro(helper.paths.blokkliBuildDir);
+    const moduleDir = import.meta.url;
+    const resolver = createResolver(moduleDir);
+    nuxt.options.build.transpile.push(resolver.resolve("runtime"));
+    nuxt.options.vite.optimizeDeps ??= {};
+    nuxt.options.vite.optimizeDeps.include ??= [];
+    nuxt.options.vite.optimizeDeps.include.push("papaparse", "pofile");
+    helper.addComponent("BlokkliField");
+    helper.addComponent("BlokkliEditable");
+    helper.addComponent("BlokkliProvider");
+    helper.addComponent("BlokkliItem");
+    helper.addComposable("defineBlokkli");
+    helper.addComposable("defineBlokkliFragment");
+    helper.addComposable("defineBlokkliFeature");
+    helper.addComposable("defineBlokkliProvider");
+    helper.addComposable("useBlokkli");
+    helper.addComposable("useBlokkliHelper");
+    helper.addComposable("useBlokkliRuntimeConfig");
+    helper.addAlias(
+      "#blokkli/analyzer",
+      resolver.resolve("runtime/editor/features/analyze/analyzers")
+    );
+    helper.addAlias("#blokkli-build", helper.paths.blokkliBuildDir);
+    helper.addAlias("#blokkli/types", resolver.resolve("runtime/types"));
+    helper.addAlias("#blokkli/constants", resolver.resolve("runtime/constants"));
+    helper.addAlias("#blokkli/editor", resolver.resolve("runtime/editor"));
+    helper.addAlias("#blokkli/helpers", resolver.resolve("runtime/helpers"));
+    helper.addAlias(
+      "#blokkli/runtime-helpers",
+      resolver.resolve("runtime/helpers/runtimeHelpers")
+    );
+    const blokkliModulesDir = resolve$1(nuxt.options.rootDir, "blokkli/modules");
+    helper.addAppTsInclude(join(blokkliModulesDir, "*/app"));
+    helper.addServerTsInclude(join(blokkliModulesDir, "*/server"));
+    const blokkliFeaturesDir = helper.resolvers.root.resolve("./blokkli/features");
+    context.addContentPath(blokkliFeaturesDir);
+    nuxt.hook("nitro:config", (nitroConfig) => {
+      nitroConfig.publicAssets ||= [];
+      nitroConfig.publicAssets.push({
+        dir: resolver.resolve("./runtime/public"),
+        maxAge: 60 * 60 * 24 * 365
+        // 1 year
+      });
+    });
+    addPlugin({
+      src: resolver.resolve("./runtime/plugins/blokkliDirectives")
+    });
+    addBuildPlugin(RuntimeDefinitionPlugin(nuxt, helper, "defineBlokkli"));
+    addBuildPlugin(
+      RuntimeDefinitionPlugin(nuxt, helper, "defineBlokkliFragment")
+    );
+    addBuildPlugin(
+      RuntimeDefinitionPlugin(nuxt, helper, "defineBlokkliProvider", 1)
+    );
+    addBuildPlugin(BlokkliEditingPlugin(nuxt));
+    const contentPaths = context.getContentPaths();
+    if (contentPaths.length > 0) {
+      const tailwindConfigPath = helper.getTailwindConfigPath();
+      addVitePlugin({
+        name: "blokkli-mangle-module-classes",
+        enforce: "pre",
+        async transform(code, id) {
+          if (!id.endsWith(".vue")) return null;
+          if (!contentPaths.some((dir) => id.startsWith(dir))) return null;
+          const result = await mangleVueSFC(code, id, tailwindConfigPath);
+          return result ? { code: result, map: null } : null;
+        },
+        hotUpdate: {
+          order: "post",
+          async handler({ file, server, modules: hmrModules }) {
+            if (!file.endsWith(".vue")) return;
+            if (!contentPaths.some((dir) => file.startsWith(dir))) return;
+            const environment = server.environments["client"];
+            if (!environment) return;
+            const modules = environment.moduleGraph.getModulesByFile(file);
+            if (!modules || modules.size === 0) return;
+            const mainModule = [...modules].find((m) => !m.url.includes("?"));
+            if (mainModule) {
+              environment.moduleGraph.invalidateModule(mainModule);
+              await environment.transformRequest(mainModule.url);
+            }
+            const styleModules = [...modules].filter(
+              (m) => m.url.includes("type=style")
+            );
+            if (styleModules.length) {
+              for (const styleMod of styleModules) {
+                environment.moduleGraph.invalidateModule(styleMod);
+              }
+              const result = [...hmrModules];
+              for (const styleMod of styleModules) {
+                if (!result.some((m) => m.url === styleMod.url)) {
+                  result.push(styleMod);
+                }
+              }
+              return result;
+            }
+          }
+        }
+      });
+    }
+    if (nuxt.options.dev) {
+      for (const cssFile of context.getCSSFiles()) {
+        nuxt.options.watch.push(dirname$1(cssFile));
+      }
+      nuxt.hook("builder:watch", async (event, providedFilePath) => {
+        const filePath = providedFilePath.startsWith("/") ? providedFilePath : helper.resolvers.src.resolve(providedFilePath);
+        helper.fileCache.handleWatchEvent(event, filePath);
+        const dependenciesToUpdate = [];
+        for (const collector of collectors) {
+          const result = await collector.handleWatchEvent(event, filePath);
+          if (result.hasChanged) {
+            collector.validate(iconCollector);
+            dependenciesToUpdate.push(...collector.getDependencyTypes());
+          }
+        }
+        const cssFiles = context.getCSSFiles();
+        if (cssFiles.length > 0) {
+          const cssFileDirs = cssFiles.map((f) => dirname$1(f));
+          const isModuleCSSRelated = cssFiles.some(
+            (cssFile, i) => filePath === cssFile || filePath.startsWith(cssFileDirs[i] + "/")
+          );
+          if (isModuleCSSRelated) {
+            dependenciesToUpdate.push("module-css");
+          }
+        }
+        if (dependenciesToUpdate.length) {
+          await context.generateTemplates(dependenciesToUpdate);
+          await updateTemplates();
+        }
+      });
+    }
+  }
+});
+
+export { module$1 as default };