@miragon/modeler-shell 0.0.0-stage → 0.2.0

package/dist/core.cjs

@@ -0,0 +1,873 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/core.ts
+var core_exports = {};
+__export(core_exports, {
+  APPEARANCE_STORAGE_KEY: () => APPEARANCE_STORAGE_KEY,
+  CHROME_ISLANDS: () => CHROME_ISLANDS,
+  FIT_ANIMATION_MS: () => FIT_ANIMATION_MS,
+  INVALID_STATUS_DELAY_MS: () => INVALID_STATUS_DELAY_MS,
+  LEGAL_LINE_HEIGHT: () => LEGAL_LINE_HEIGHT,
+  MAX_FIT_ZOOM: () => MAX_FIT_ZOOM,
+  MAX_TOASTS: () => MAX_TOASTS,
+  PALETTE_CLEARANCE: () => PALETTE_CLEARANCE,
+  REDUCED_MOTION_CLASS: () => REDUCED_MOTION_CLASS,
+  SHELL: () => SHELL,
+  SHELL_TOKENS: () => SHELL_TOKENS,
+  TEXT_FIELD_SELECTOR: () => TEXT_FIELD_SELECTOR,
+  TOAST_DURATION_MS: () => TOAST_DURATION_MS,
+  TOAST_MAX_WIDTH: () => TOAST_MAX_WIDTH,
+  TOOLTIP_DELAY_MS: () => TOOLTIP_DELAY_MS,
+  VIEW_TOLERANCE: () => VIEW_TOLERANCE,
+  ZOOM_MAX: () => ZOOM_MAX,
+  ZOOM_MIN: () => ZOOM_MIN,
+  acceptsFile: () => acceptsFile,
+  appearanceAttributes: () => appearanceAttributes,
+  appearanceFromBodyClasses: () => appearanceFromBodyClasses,
+  appearanceFromColorThemeKind: () => appearanceFromColorThemeKind,
+  ariaKeyShortcuts: () => ariaKeyShortcuts,
+  ariaKeyShortcutsFromLabel: () => ariaKeyShortcutsFromLabel,
+  canZoomIn: () => canZoomIn,
+  canZoomOut: () => canZoomOut,
+  commandKeyLabel: () => commandKeyLabel,
+  decideKey: () => decideKey,
+  decidePaletteRow: () => decidePaletteRow,
+  decideTopRow: () => decideTopRow,
+  defaultMessages: () => defaultMessages,
+  detectPlatform: () => detectPlatform,
+  documentMode: () => documentMode,
+  dragVerdict: () => dragVerdict,
+  easeStandard: () => easeStandard,
+  fitInsets: () => fitInsets,
+  fitViewbox: () => fitViewbox,
+  formatNumber: () => formatNumber,
+  formatPercent: () => formatPercent,
+  freeRectCenter: () => freeRectCenter,
+  interpolateViewbox: () => interpolateViewbox,
+  isUndoRedoKey: () => isUndoRedoKey,
+  legalLineHeight: () => legalLineHeight,
+  legendStartsOpen: () => legendStartsOpen,
+  matchChromeKey: () => matchChromeKey,
+  parseAppearanceChoice: () => parseAppearanceChoice,
+  placeTooltip: () => placeTooltip,
+  problemSummary: () => problemSummary,
+  reducedMotionFromBodyClasses: () => reducedMotionFromBodyClasses,
+  requestedAppearance: () => requestedAppearance,
+  resolveAppearance: () => resolveAppearance,
+  resolveMessages: () => resolveMessages,
+  sameView: () => sameView,
+  shellSizesFromTokens: () => shellSizesFromTokens,
+  shortcutLabel: () => shortcutLabel,
+  toastLifetime: () => toastLifetime,
+  toastStackBottom: () => toastStackBottom,
+  toastStackWidth: () => toastStackWidth,
+  toastToEvict: () => toastToEvict,
+  webHeadMarkup: () => webHeadMarkup,
+  webModeScript: () => webModeScript,
+  zoomReadout: () => zoomReadout,
+  zoomRowRaised: () => zoomRowRaised
+});
+module.exports = __toCommonJS(core_exports);
+
+// src/core/types.ts
+var CHROME_ISLANDS = [
+  "menu",
+  "palette",
+  "primary",
+  "zoom",
+  "problems",
+  "legend",
+  "inspector",
+  "status",
+  "legal",
+  "toasts",
+  "empty-state",
+  "drop-zone",
+  "problems-popover"
+];
+
+// src/core/sizes.ts
+var SHELL_TOKENS = {
+  edge: "--cd-shell-rand",
+  gap: "--cd-shell-luecke",
+  row: "--cd-shell-zeile",
+  target: "--cd-shell-ziel",
+  entry: "--cd-shell-eintrag",
+  free: "--cd-shell-frei",
+  menuMinWidth: "--cd-shell-menue-breite",
+  inspectorWidth: "--cd-shell-inspector-breite",
+  fitInsetTop: "--cd-shell-einpassen-oben",
+  fitInsetTopSecondRow: "--cd-shell-einpassen-oben-schmal",
+  fitInsetSide: "--cd-shell-einpassen-seite",
+  fitInsetBottom: "--cd-shell-einpassen-unten",
+  fitInsetBottomWeb: "--cd-shell-einpassen-unten-web",
+  narrow: "--cd-shell-schmal",
+  veryNarrow: "--cd-shell-sehr-schmal",
+  low: "--cd-shell-niedrig",
+  layerIslands: "--cd-shell-ebene-inseln",
+  layerInspector: "--cd-shell-ebene-inspector",
+  layerTopRow: "--cd-shell-ebene-reihe",
+  layerPopups: "--cd-shell-ebene-aufklapper",
+  layerDialog: "--cd-shell-ebene-dialog",
+  layerToast: "--cd-shell-ebene-toast"
+};
+var SHELL = {
+  edge: 12,
+  gap: 8,
+  row: 40,
+  target: 32,
+  entry: 36,
+  free: 64,
+  menuMinWidth: 248,
+  inspectorWidth: 288,
+  fitInsetTop: 88,
+  fitInsetTopSecondRow: 140,
+  fitInsetSide: 24,
+  fitInsetBottom: 64,
+  fitInsetBottomWeb: 92,
+  narrow: 760,
+  veryNarrow: 440,
+  low: 820,
+  layerIslands: 20,
+  layerInspector: 25,
+  layerTopRow: 30,
+  layerPopups: 40,
+  layerDialog: 50,
+  layerToast: 60
+};
+var PIXEL_OR_PLAIN_NUMBER = /^\s*-?(?:\d+\.?\d*|\.\d+)(?:px)?\s*$/;
+function shellSizesFromTokens(shellGroup) {
+  const sizes = {};
+  for (const name of Object.keys(SHELL_TOKENS)) {
+    const token = SHELL_TOKENS[name];
+    const raw = Object.hasOwn(shellGroup, token) ? shellGroup[token] : void 0;
+    if (raw === void 0) {
+      throw new Error(`@miragon/modeler-shell: the shell token ${token} is missing`);
+    }
+    if (typeof raw !== "string" || !PIXEL_OR_PLAIN_NUMBER.test(raw)) {
+      throw new Error(
+        `@miragon/modeler-shell: the shell token ${token} is not a number: ${JSON.stringify(raw)}`
+      );
+    }
+    sizes[name] = Number.parseFloat(raw);
+  }
+  return sizes;
+}
+
+// src/core/web-chrome/bottom-row.ts
+var LEGAL_LINE_HEIGHT = 20;
+function legalLineHeight(measured) {
+  if (measured === void 0 || !Number.isFinite(measured) || measured <= 0) return LEGAL_LINE_HEIGHT;
+  return Math.max(1, Math.round(measured / LEGAL_LINE_HEIGHT)) * LEGAL_LINE_HEIGHT;
+}
+function zoomRowRaised(input) {
+  const { containerWidth, legalRight, zoomWidth } = input;
+  if (legalRight === void 0 || zoomWidth === void 0) return false;
+  const zoomLeft = containerWidth - SHELL.edge - zoomWidth;
+  return legalRight + SHELL.gap > zoomLeft;
+}
+
+// src/core/fit.ts
+var MAX_FIT_ZOOM = 1;
+var FIT_ANIMATION_MS = 250;
+function fitViewbox(bounds, container, insets, maxZoom = MAX_FIT_ZOOM) {
+  if (!(container.width > 0 && container.height > 0)) return void 0;
+  const hasWidth = bounds.width > 0;
+  const hasHeight = bounds.height > 0;
+  if (!hasWidth && !hasHeight) return void 0;
+  const horizontal = freeExtent(container.width, insets.left, insets.right);
+  const vertical = freeExtent(container.height, insets.top, insets.bottom);
+  const contentWidth = hasWidth ? bounds.width : 0;
+  const contentHeight = hasHeight ? bounds.height : 0;
+  const scale = Math.min(
+    maxZoom,
+    hasWidth ? horizontal.extent / contentWidth : Infinity,
+    hasHeight ? vertical.extent / contentHeight : Infinity
+  );
+  const box = {
+    x: bounds.x + contentWidth / 2 - (horizontal.start + horizontal.extent / 2) / scale,
+    y: bounds.y + contentHeight / 2 - (vertical.start + vertical.extent / 2) / scale,
+    width: container.width / scale,
+    height: container.height / scale,
+    scale
+  };
+  return Object.values(box).every(Number.isFinite) && scale > 0 ? box : void 0;
+}
+function freeExtent(total, before, after) {
+  const extent = total - before - after;
+  return extent > 0 ? { start: before, extent } : { start: 0, extent: total };
+}
+function freeRectCenter(container, insets) {
+  if (!(container.width > 0 && container.height > 0)) return void 0;
+  const horizontal = freeExtent(container.width, insets.left, insets.right);
+  const vertical = freeExtent(container.height, insets.top, insets.bottom);
+  return {
+    x: horizontal.start + horizontal.extent / 2,
+    y: vertical.start + vertical.extent / 2
+  };
+}
+function fitInsets(layout) {
+  const { container, host, paletteRow, problemsVisible, zoomRaised, legendWidth, inspector } = layout;
+  const raisedBottomRow = host === "web" && (problemsVisible || zoomRaised === true);
+  const wrappedLegalLines = legalLineHeight(layout.legalHeight) - LEGAL_LINE_HEIGHT;
+  const insets = {
+    top: paletteRow === "second-row" ? SHELL.fitInsetTopSecondRow : SHELL.fitInsetTop,
+    right: SHELL.fitInsetSide,
+    bottom: raisedBottomRow ? SHELL.fitInsetBottomWeb + wrappedLegalLines : SHELL.fitInsetBottom,
+    left: SHELL.fitInsetSide
+  };
+  const bottomSheetOpen = inspector !== void 0 && container.width <= SHELL.narrow;
+  if (inspector !== void 0 && !bottomSheetOpen) {
+    insets.right = SHELL.edge + SHELL.inspectorWidth + SHELL.fitInsetSide;
+  }
+  if (bottomSheetOpen) {
+    insets.bottom = inspector.sheetTop === void 0 ? SHELL.fitInsetBottom : container.height - inspector.sheetTop + SHELL.edge;
+  } else if (legendWidth !== void 0 && legendWidth > 0 && container.width > SHELL.veryNarrow) {
+    insets.left = SHELL.edge + legendWidth + SHELL.fitInsetSide;
+  }
+  return insets;
+}
+var VIEW_TOLERANCE = 1e-3;
+function sameView(a, b, tolerance = VIEW_TOLERANCE) {
+  const close = (first, second) => Math.abs(first - second) <= tolerance * Math.max(1, Math.abs(first), Math.abs(second));
+  return close(a.scale, b.scale) && close(a.x * a.scale, b.x * b.scale) && close(a.y * a.scale, b.y * b.scale);
+}
+function interpolateViewbox(from, to, progress) {
+  if (!(progress > 0)) return { ...from };
+  if (progress >= 1) return { ...to };
+  const linear = (start, end) => start + (end - start) * progress;
+  const scale = from.scale > 0 && to.scale > 0 ? Math.exp(linear(Math.log(from.scale), Math.log(to.scale))) : linear(from.scale, to.scale);
+  const centreX = linear(from.x + from.width / 2, to.x + to.width / 2);
+  const centreY = linear(from.y + from.height / 2, to.y + to.height / 2);
+  const width = linear(from.width * from.scale, to.width * to.scale) / scale;
+  const height = linear(from.height * from.scale, to.height * to.scale) / scale;
+  return { x: centreX - width / 2, y: centreY - height / 2, width, height, scale };
+}
+function easeStandard(progress) {
+  return STANDARD_EASING(progress);
+}
+var STANDARD_EASING = cubicBezier(0.4, 0, 0.2, 1);
+function cubicBezier(x1, y1, x2, y2) {
+  const polynomial = (first, second) => {
+    const c = 3 * first;
+    const b = 3 * (second - first) - c;
+    const a = 1 - c - b;
+    return {
+      at: (t) => ((a * t + b) * t + c) * t,
+      slope: (t) => (3 * a * t + 2 * b) * t + c
+    };
+  };
+  const curveX = polynomial(x1, x2);
+  const curveY = polynomial(y1, y2);
+  const precision = 1e-7;
+  const parameterFor = (x) => {
+    let t = x;
+    for (let iteration = 0; iteration < 8; iteration++) {
+      const error = curveX.at(t) - x;
+      if (Math.abs(error) < precision) return t;
+      const slope = curveX.slope(t);
+      if (Math.abs(slope) < 1e-6) break;
+      t -= error / slope;
+      if (t < 0 || t > 1) break;
+    }
+    let low = 0;
+    let high = 1;
+    t = x;
+    for (let iteration = 0; iteration < 60; iteration++) {
+      const value = curveX.at(t);
+      if (Math.abs(value - x) < precision) break;
+      if (value < x) low = t;
+      else high = t;
+      t = (low + high) / 2;
+    }
+    return t;
+  };
+  return (progress) => {
+    if (!(progress > 0)) return 0;
+    if (progress >= 1) return 1;
+    return curveY.at(parameterFor(progress));
+  };
+}
+
+// src/core/zoom.ts
+var ZOOM_MIN = 0.2;
+var ZOOM_MAX = 4;
+function canZoomOut(zoom) {
+  return zoom > ZOOM_MIN * 1.001;
+}
+function canZoomIn(zoom) {
+  return zoom < ZOOM_MAX * 0.999;
+}
+function formatPercent(zoom, lang) {
+  return numberFormat(lang, "percent").format(zoom);
+}
+function formatNumber(value, lang) {
+  return numberFormat(lang, "decimal").format(value);
+}
+var FALLBACK_LANG = "en";
+var formats = /* @__PURE__ */ new Map();
+function numberFormat(lang, style) {
+  const key = `${style}|${lang}`;
+  let format = formats.get(key);
+  if (!format) {
+    const options = style === "percent" ? { style, maximumFractionDigits: 0 } : { style };
+    try {
+      format = new Intl.NumberFormat(lang, options);
+    } catch {
+      format = new Intl.NumberFormat(FALLBACK_LANG, options);
+    }
+    formats.set(key, format);
+  }
+  return format;
+}
+function zoomReadout(zoom, lang, messages) {
+  const text = formatPercent(zoom, lang);
+  return {
+    text,
+    ariaLabel: messages.zoomToActualNow(formatPercent(1, lang), text),
+    canZoomOut: canZoomOut(zoom),
+    canZoomIn: canZoomIn(zoom)
+  };
+}
+
+// src/core/keymap.ts
+function matchChromeKey(event) {
+  if (event.altKey) return void 0;
+  if (isCommand(event)) {
+    if (event.key === "+" || event.key === "=" || event.code === "NumpadAdd") return "zoomIn";
+    if (event.key === "-" || event.key === "_" || event.code === "NumpadSubtract") return "zoomOut";
+    if (event.key === "0" || event.code === "Numpad0") return "zoomToActual";
+    return void 0;
+  }
+  return event.shiftKey && event.code === "Digit1" ? "fit" : void 0;
+}
+function isCommand(event) {
+  return event.metaKey || event.ctrlKey;
+}
+function isUndoRedoKey(event) {
+  if (event.altKey || !isCommand(event)) return false;
+  const letter = undoRedoLetter(event);
+  return letter === "z" || letter === "y" && !event.shiftKey;
+}
+function undoRedoLetter(event) {
+  if (event.key.length === 1 && event.key.charCodeAt(0) < 128) return event.key.toLowerCase();
+  if (event.code === "KeyZ") return "z";
+  if (event.code === "KeyY") return "y";
+  return void 0;
+}
+var TEXT_FIELD_SELECTOR = "input, textarea, select, [contenteditable]:not([contenteditable='false'])";
+function decideKey(event, context) {
+  const stop = context.host === "ide";
+  const composing = event.isComposing === true;
+  if (event.key === "Escape" && !event.metaKey && !event.ctrlKey && !event.altKey && !event.shiftKey) {
+    if (context.menuOpen && !composing) {
+      return { action: "closeMenu", preventDefault: true, stopPropagation: stop };
+    }
+    if (context.menuOpen || context.dialogOpen) return { preventDefault: false, stopPropagation: stop };
+  }
+  const chromeKey = matchChromeKey(event);
+  if (chromeKey !== void 0) {
+    if (context.startScreen === true && !stop) return { preventDefault: false, stopPropagation: false };
+    const blocked = composing || context.inTextField || context.modalOpen;
+    if (!blocked) return { action: chromeKey, preventDefault: true, stopPropagation: stop };
+    return { preventDefault: false, stopPropagation: chromeKey === "fit" ? false : stop };
+  }
+  if (context.inTextField && isUndoRedoKey(event)) return { preventDefault: false, stopPropagation: stop };
+  if (context.defaultPrevented) return { preventDefault: false, stopPropagation: stop };
+  return { preventDefault: false, stopPropagation: false };
+}
+function detectPlatform(navigator) {
+  const platform = navigator?.userAgentData?.platform || navigator?.platform || "";
+  return /mac/i.test(platform) ? "mac" : "other";
+}
+function shortcutLabel(key, platform, keyNames) {
+  if (platform === "mac") return MAC_SHORTCUT_LABELS[key];
+  switch (key) {
+    case "zoomIn":
+      return `${keyNames.ctrl}+${keyNames.plus}`;
+    case "zoomOut":
+      return `${keyNames.ctrl}+${keyNames.minus}`;
+    case "zoomToActual":
+      return `${keyNames.ctrl}+0`;
+    case "fit":
+      return `${keyNames.shift}+1`;
+  }
+}
+function commandKeyLabel(key, platform, keyNames) {
+  return platform === "mac" ? `\u2318${key}` : `${keyNames.ctrl}+${key}`;
+}
+var MAC_SHORTCUT_LABELS = {
+  zoomIn: "\u2318+",
+  zoomOut: "\u2318\u2212",
+  zoomToActual: "\u23180",
+  fit: "\u21E71"
+};
+function ariaKeyShortcuts(key, platform) {
+  const command = platform === "mac" ? "Meta" : "Control";
+  switch (key) {
+    case "zoomIn":
+      return `${command}+= ${command}+Plus`;
+    case "zoomOut":
+      return `${command}+-`;
+    case "zoomToActual":
+      return `${command}+0`;
+    case "fit":
+      return "Shift+1";
+  }
+}
+var MAC_MODIFIER_SYMBOLS = {
+  "\u2318": "Meta",
+  "\u21E7": "Shift",
+  "\u2325": "Alt",
+  "\u2303": "Control"
+};
+var MODIFIER_NAMES = {
+  cmd: "Meta",
+  command: "Meta",
+  meta: "Meta",
+  ctrl: "Control",
+  control: "Control",
+  strg: "Control",
+  shift: "Shift",
+  umschalt: "Shift",
+  alt: "Alt",
+  option: "Alt",
+  opt: "Alt"
+};
+var NAMED_KEYS = {
+  esc: "Escape",
+  escape: "Escape",
+  del: "Delete",
+  delete: "Delete",
+  entf: "Delete",
+  backspace: "Backspace",
+  enter: "Enter",
+  return: "Enter",
+  tab: "Tab",
+  space: "Space",
+  home: "Home",
+  end: "End",
+  pageup: "PageUp",
+  pagedown: "PageDown",
+  arrowup: "ArrowUp",
+  arrowdown: "ArrowDown",
+  arrowleft: "ArrowLeft",
+  arrowright: "ArrowRight",
+  "\u2191": "ArrowUp",
+  "\u2193": "ArrowDown",
+  "\u2190": "ArrowLeft",
+  "\u2192": "ArrowRight",
+  plus: "Plus"
+};
+function ariaKeyName(key) {
+  const named = NAMED_KEYS[key.toLowerCase()];
+  if (named) return named;
+  if (/^f\d{1,2}$/i.test(key)) return key.toUpperCase();
+  if (key.length !== 1 || MAC_MODIFIER_SYMBOLS[key]) return void 0;
+  if (key === "+") return "Plus";
+  if (key === " ") return "Space";
+  return key.toUpperCase();
+}
+function ariaKeyShortcutsFromLabel(label) {
+  let rest = label.trim();
+  const modifiers = [];
+  for (let symbol = MAC_MODIFIER_SYMBOLS[rest.charAt(0)]; symbol && rest.length > 1; ) {
+    modifiers.push(symbol);
+    rest = rest.slice(1).trim();
+    symbol = MAC_MODIFIER_SYMBOLS[rest.charAt(0)];
+  }
+  if (!rest || /\s/.test(rest.replace(/\s*\+\s*/g, "+"))) return void 0;
+  const parts = rest.split("+").map((part) => part.trim());
+  let key = parts.pop() ?? "";
+  if (key === "" && parts.at(-1) === "") {
+    parts.pop();
+    key = "+";
+  }
+  for (const part of parts) {
+    const modifier = MODIFIER_NAMES[part.toLowerCase()];
+    if (!modifier) return void 0;
+    modifiers.push(modifier);
+  }
+  const name = ariaKeyName(key);
+  return name ? [...new Set(modifiers), name].join("+") : void 0;
+}
+
+// src/core/appearance.ts
+function resolveAppearance(requested, themes) {
+  const [fallback] = themes;
+  if (fallback === void 0) {
+    throw new Error(
+      "@miragon/modeler-shell: resolveAppearance needs at least one theme the modeler can show"
+    );
+  }
+  const theme = themes.includes(requested.theme) ? requested.theme : fallback;
+  return withKontrast(theme, requested.kontrast);
+}
+function withKontrast(theme, kontrast) {
+  return kontrast === "hoch" ? { theme, kontrast } : { theme };
+}
+function appearanceFromColorThemeKind(kind) {
+  switch (kind) {
+    case 2:
+      return { theme: "dark" };
+    case 3:
+      return { theme: "dark", kontrast: "hoch" };
+    case 4:
+      return { theme: "light", kontrast: "hoch" };
+    default:
+      return { theme: "light" };
+  }
+}
+function requestedAppearance(kind, setting) {
+  const fromKind = appearanceFromColorThemeKind(kind);
+  const theme = setting === "light" || setting === "dark" ? setting : fromKind.theme;
+  return withKontrast(theme, fromKind.kontrast);
+}
+function appearanceFromBodyClasses(classes) {
+  const present = new Set(classes);
+  if (present.has("vscode-high-contrast-light")) return { theme: "light", kontrast: "hoch" };
+  if (present.has("vscode-high-contrast")) return { theme: "dark", kontrast: "hoch" };
+  if (present.has("vscode-dark")) return { theme: "dark" };
+  if (present.has("vscode-light")) return { theme: "light" };
+  return void 0;
+}
+function reducedMotionFromBodyClasses(classes) {
+  return new Set(classes).has("vscode-reduce-motion");
+}
+var REDUCED_MOTION_CLASS = "cd-shell-reduce-motion";
+function appearanceAttributes(appearance) {
+  return appearance.kontrast === "hoch" ? { "data-cd-theme": appearance.theme, "data-cd-kontrast": "hoch" } : { "data-cd-theme": appearance.theme };
+}
+
+// src/core/messages.ts
+var defaultMessages = {
+  menu: "Menu",
+  tools: "Tools",
+  canvas: "Diagram",
+  zoom: "Zoom",
+  zoomOut: "Zoom out",
+  zoomIn: "Zoom in",
+  zoomToActual: (percent) => `Zoom to ${percent}`,
+  zoomToActualNow: (percent, now) => `Zoom to ${percent} (now ${now})`,
+  fit: "Fit to view",
+  legend: "Legend",
+  closeLegend: "Close legend",
+  problems: (count, formattedCount) => `${formattedCount} ${count === 1 ? "problem" : "problems"}`,
+  problemsLabel: (count, errors, formattedCount, formattedErrors) => `${formattedCount} ${count === 1 ? "problem" : "problems"}, ${errors === 0 ? "no errors" : `${formattedErrors} ${errors === 1 ? "error" : "errors"}`}`,
+  showProblems: "Show in Problems view",
+  emptyHint: "Pick a tool from the palette to start.",
+  insertExample: "Insert example",
+  invalidFile: (diagram) => `This file isn't a valid ${diagram} right now. The diagram shows the last valid version and is read-only until you fix the text.`,
+  keyNames: { ctrl: "Ctrl", shift: "Shift", plus: "Plus", minus: "Minus" },
+  share: "Share",
+  legal: "Legal",
+  copyright: (year) => `\xA9 ${year} Miragon GmbH`,
+  opensInNewTab: "Opens in a new tab",
+  newDiagram: "New diagram",
+  openFile: "Open\u2026",
+  showExample: "Show example",
+  importFile: "Import\u2026",
+  appearance: "Appearance",
+  appearanceSystem: "System",
+  appearanceLight: "Light",
+  appearanceDark: "Dark",
+  problemsTitle: "Problems",
+  problemSeverity: (severity) => severity === "error" ? "Error" : "Warning",
+  close: "Close",
+  dropFile: "Drop file here",
+  dropForbidden: (reason) => reason === "multiple" ? "Drop one file at a time" : reason === "dialog" ? "Close the dialog to drop a file" : "This modeler can't open this file type",
+  dropHint: "Or drop a file here",
+  openFileLink: "Open a file\u2026",
+  cannotOpenFile: (name, accepted) => `Couldn't open \u201C${name}\u201D. Drop a ${accepted} file.`
+};
+function resolveMessages(overrides) {
+  const { keyNames, ...texts } = overrides ?? {};
+  return {
+    ...defaultMessages,
+    ...definedEntries(texts),
+    keyNames: { ...defaultMessages.keyNames, ...definedEntries(keyNames ?? {}) }
+  };
+}
+function definedEntries(partial) {
+  return Object.fromEntries(Object.entries(partial).filter(([, value]) => value !== void 0));
+}
+
+// src/core/layout.ts
+var PALETTE_CLEARANCE = 16;
+var TOOLTIP_DELAY_MS = 300;
+var INVALID_STATUS_DELAY_MS = 800;
+function decidePaletteRow(input) {
+  const { containerWidth, paletteWidth, menuRight, primaryLeft } = input;
+  if (containerWidth <= SHELL.narrow) return "second-row";
+  const paletteLeft = (containerWidth - paletteWidth) / 2;
+  const paletteRight = (containerWidth + paletteWidth) / 2;
+  if (paletteLeft < menuRight + PALETTE_CLEARANCE) return "second-row";
+  if (primaryLeft !== void 0 && paletteRight > primaryLeft - PALETTE_CLEARANCE) return "second-row";
+  return "top";
+}
+function legendStartsOpen(containerHeight) {
+  return containerHeight > SHELL.low;
+}
+function placeTooltip(input) {
+  const { anchor, island, tooltip, container } = input;
+  const inUpperHalf = island.y + island.height / 2 < container.height / 2;
+  const y = inUpperHalf ? island.y + island.height + SHELL.gap : island.y - SHELL.gap - tooltip.height;
+  const centred = anchor.x + anchor.width / 2 - tooltip.width / 2;
+  const rightmost = container.width - SHELL.edge - tooltip.width;
+  const x = Math.max(SHELL.edge, Math.min(centred, rightmost));
+  return { x, y };
+}
+
+// src/core/web-chrome/top-row.ts
+function decideTopRow(input) {
+  const { containerWidth, paletteWidth, menuRight, primary } = input;
+  if (!primary) {
+    return {
+      paletteRow: decidePaletteRow({ containerWidth, paletteWidth, menuRight }),
+      primaryLabel: "shown"
+    };
+  }
+  const paletteRowBeside = (primaryWidth) => decidePaletteRow({
+    containerWidth,
+    paletteWidth,
+    menuRight,
+    primaryLeft: containerWidth - SHELL.edge - primaryWidth
+  });
+  if (paletteRowBeside(primary.withLabel) === "top") return { paletteRow: "top", primaryLabel: "shown" };
+  if (paletteRowBeside(primary.iconOnly) === "top") return { paletteRow: "top", primaryLabel: "collapsed" };
+  const labelledLeft = containerWidth - SHELL.edge - primary.withLabel;
+  return {
+    paletteRow: "second-row",
+    primaryLabel: menuRight + PALETTE_CLEARANCE <= labelledLeft ? "shown" : "collapsed"
+  };
+}
+
+// src/core/web-chrome/drop.ts
+function acceptEntries(accept) {
+  const entries = accept.map((entry) => entry.trim().toLowerCase()).filter((entry) => entry !== "");
+  return {
+    extensions: entries.filter((entry) => entry.startsWith(".")),
+    mimeTypes: entries.filter((entry) => !entry.startsWith(".") && entry.includes("/"))
+  };
+}
+function matchesMimeType(type, mimeTypes) {
+  const normalized = type.trim().toLowerCase();
+  if (normalized === "") return false;
+  return mimeTypes.some(
+    (entry) => entry.endsWith("/*") ? normalized.startsWith(entry.slice(0, -1)) : normalized === entry
+  );
+}
+function dragVerdict(items, context) {
+  const files = items.filter((item) => item.kind === "file");
+  if (files.length === 0) return { state: "none" };
+  if (context.dialogOpen) return { state: "forbidden", reason: "dialog" };
+  if (files.length > 1 && !context.multiple) return { state: "forbidden", reason: "multiple" };
+  const { mimeTypes } = acceptEntries(context.accept);
+  const foreignType = (item) => item.type.trim() !== "" && !matchesMimeType(item.type, mimeTypes);
+  if (mimeTypes.length > 0 && files.every(foreignType)) return { state: "forbidden", reason: "type" };
+  return { state: "over" };
+}
+function acceptsFile(file, accept) {
+  const { extensions, mimeTypes } = acceptEntries(accept);
+  if (extensions.length === 0 && mimeTypes.length === 0) return true;
+  const name = file.name.toLowerCase();
+  return extensions.some((extension) => name.endsWith(extension)) || matchesMimeType(file.type, mimeTypes);
+}
+
+// src/core/feedback/toasts.ts
+var MAX_TOASTS = 3;
+var TOAST_DURATION_MS = {
+  success: 2800,
+  info: 2800,
+  warning: 5e3,
+  danger: 5e3
+};
+var TOAST_MAX_WIDTH = 480;
+function toastLifetime(request) {
+  if (request.action) return void 0;
+  const requested = request.durationMs;
+  const longer = requested !== void 0 && Number.isFinite(requested) ? requested : 0;
+  return Math.max(TOAST_DURATION_MS[request.status], longer);
+}
+function toastToEvict(stack) {
+  if (stack.length < MAX_TOASTS) return void 0;
+  const evicted = stack.find((slot) => !slot.engaged && !slot.hasAction) ?? stack.find((slot) => !slot.engaged) ?? stack[0];
+  return evicted?.id;
+}
+function toastStackWidth(containerWidth) {
+  return Math.max(0, Math.min(TOAST_MAX_WIDTH, containerWidth - 2 * SHELL.edge));
+}
+function toastStackBottom(input) {
+  const stackWidth = toastStackWidth(input.containerWidth);
+  const { cardWidth } = input;
+  const width = cardWidth !== void 0 && Number.isFinite(cardWidth) ? Math.min(stackWidth, Math.max(0, cardWidth)) : stackWidth;
+  const left = (input.containerWidth - width) / 2;
+  const right = left + width;
+  let highest;
+  for (const obstacle of input.obstacles) {
+    const distance = Math.max(obstacle.left - right, left - obstacle.right);
+    if (distance >= SHELL.gap) continue;
+    highest = highest === void 0 ? obstacle.top : Math.max(highest, obstacle.top);
+  }
+  return highest === void 0 ? SHELL.edge : Math.max(SHELL.edge, highest + SHELL.gap);
+}
+
+// src/core/feedback/appearance.ts
+var APPEARANCE_STORAGE_KEY = "miragon.darstellung";
+function parseAppearanceChoice(stored) {
+  return stored === "light" || stored === "dark" ? stored : "system";
+}
+function documentMode(choice, themes, colors) {
+  if (!themes.includes("dark")) return fixedMode("light", colors.light);
+  const parsed = parseAppearanceChoice(choice);
+  if (parsed === "system") {
+    return {
+      theme: "system",
+      colorScheme: "light dark",
+      themeColor: { light: colors.light, dark: colors.dark }
+    };
+  }
+  return fixedMode(parsed, colors[parsed]);
+}
+function fixedMode(theme, color) {
+  return { theme, colorScheme: theme, themeColor: { light: color, dark: color } };
+}
+function webModeScript(options) {
+  const contrast = [
+    `if (window.matchMedia && window.matchMedia(${scriptString("(prefers-contrast: more)")}).matches)`,
+    `  document.documentElement.setAttribute("data-cd-kontrast", "hoch");`
+  ];
+  if (!options.themes.includes("dark")) return contrast.join("\n");
+  const { light, dark } = options.themeColors;
+  return [
+    "(function () {",
+    "  var html = document.documentElement;",
+    "  var choice = null;",
+    "  try {",
+    `    choice = window.localStorage.getItem(${scriptString(APPEARANCE_STORAGE_KEY)});`,
+    "  } catch (error) {}",
+    `  if (choice === "light" || choice === "dark") {`,
+    `    var color = choice === "dark" ? ${scriptString(dark)} : ${scriptString(light)};`,
+    `    html.setAttribute("data-cd-theme", choice);`,
+    `    var scheme = document.querySelector("meta[name=color-scheme]");`,
+    `    if (scheme) scheme.setAttribute("content", choice);`,
+    `    var metas = document.querySelectorAll("meta[name=theme-color]");`,
+    `    for (var index = 0; index < metas.length; index++) metas[index].setAttribute("content", color);`,
+    "  }",
+    ...contrast.map((line) => `  ${line}`),
+    "})();"
+  ].join("\n");
+}
+function scriptString(value) {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+}
+function webHeadMarkup(options) {
+  const mode = documentMode("system", options.themes, options.themeColors);
+  const script = `<script>
+${webModeScript(options)}
+</script>`;
+  if (mode.theme !== "system") {
+    return [`<meta name="theme-color" content="${escapeAttribute(mode.themeColor.light)}">`, script].join(
+      "\n"
+    );
+  }
+  return [
+    `<meta name="color-scheme" content="${escapeAttribute(mode.colorScheme)}">`,
+    `<meta name="theme-color" content="${escapeAttribute(mode.themeColor.light)}" media="(prefers-color-scheme: light)">`,
+    `<meta name="theme-color" content="${escapeAttribute(mode.themeColor.dark)}" media="(prefers-color-scheme: dark)">`,
+    script
+  ].join("\n");
+}
+function escapeAttribute(value) {
+  return value.replace(/&/g, "&amp;").replace(/"/g, "&quot;").replace(/'/g, "&#39;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+}
+
+// src/core/feedback/problems.ts
+function problemSummary(items) {
+  const errors = items.filter((item) => item.severity === "error").length;
+  return { count: items.length, errors, items };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  APPEARANCE_STORAGE_KEY,
+  CHROME_ISLANDS,
+  FIT_ANIMATION_MS,
+  INVALID_STATUS_DELAY_MS,
+  LEGAL_LINE_HEIGHT,
+  MAX_FIT_ZOOM,
+  MAX_TOASTS,
+  PALETTE_CLEARANCE,
+  REDUCED_MOTION_CLASS,
+  SHELL,
+  SHELL_TOKENS,
+  TEXT_FIELD_SELECTOR,
+  TOAST_DURATION_MS,
+  TOAST_MAX_WIDTH,
+  TOOLTIP_DELAY_MS,
+  VIEW_TOLERANCE,
+  ZOOM_MAX,
+  ZOOM_MIN,
+  acceptsFile,
+  appearanceAttributes,
+  appearanceFromBodyClasses,
+  appearanceFromColorThemeKind,
+  ariaKeyShortcuts,
+  ariaKeyShortcutsFromLabel,
+  canZoomIn,
+  canZoomOut,
+  commandKeyLabel,
+  decideKey,
+  decidePaletteRow,
+  decideTopRow,
+  defaultMessages,
+  detectPlatform,
+  documentMode,
+  dragVerdict,
+  easeStandard,
+  fitInsets,
+  fitViewbox,
+  formatNumber,
+  formatPercent,
+  freeRectCenter,
+  interpolateViewbox,
+  isUndoRedoKey,
+  legalLineHeight,
+  legendStartsOpen,
+  matchChromeKey,
+  parseAppearanceChoice,
+  placeTooltip,
+  problemSummary,
+  reducedMotionFromBodyClasses,
+  requestedAppearance,
+  resolveAppearance,
+  resolveMessages,
+  sameView,
+  shellSizesFromTokens,
+  shortcutLabel,
+  toastLifetime,
+  toastStackBottom,
+  toastStackWidth,
+  toastToEvict,
+  webHeadMarkup,
+  webModeScript,
+  zoomReadout,
+  zoomRowRaised
+});
+//# sourceMappingURL=core.cjs.map