@restless-dreams/orbit 0.0.0-stage → 0.2.0

package/dist/index.js

@@ -0,0 +1,4357 @@
+import {
+  renderToSVGString2
+} from "./chunk-y748hzcr.js";
+import {
+  renderOrbitElement2,
+  renderOrbitMarkdownBlocks2,
+  defineOrbitMapElement2
+} from "./chunk-zze4tc9n.js";
+import {
+  assignKey,
+  emitYaml,
+  nodeSlug,
+  setParent,
+  ensureUniqueNodeIds,
+  nodesWithExplicitIds,
+  findNodeById2,
+  getNodePath2,
+  guardUrl,
+  resolveUrl,
+  videoPageUrl,
+  youtubeThumbnailUrl,
+  hasMediaSource,
+  DIAGNOSTIC_CODES2,
+  OrbitParseError2,
+  formatDiagnostic2,
+  reportParseDiagnostics,
+  branchPalette,
+  suggest,
+  mediaExtras,
+  THEME_TOKENS2,
+  ORBIT_THEME_PRESETS2,
+  isOrbitThemePreset2,
+  themeName,
+  registerTheme2,
+  isThemeName2,
+  themeNames2,
+  expandTheme,
+  mergeThemes,
+  themeTokens2,
+  resolveThemeTokens,
+  resolvePalette,
+  documentToRendererOptions2,
+  isNodeLink,
+  findLinkedNode,
+  findIndexedLinkedNode,
+  indexNodes,
+  nodeLinksOf,
+  SUPPORTED_SCHEMA_VERSION2,
+  leadingEmoji,
+  parseOrbitMarkdown2,
+  parseOrbitYAML2,
+  parseOrbit2,
+  serializeOrbitMarkdown2,
+  newNodeFrom,
+  addToTree,
+  updateInTree,
+  removeFromTree,
+  moveInTree,
+  ensureStyles,
+  assignNodeColors,
+  registerLanguage2,
+  languageTags2,
+  OrbitWords,
+  wordsFor,
+  parseColor,
+  toHex,
+  toOklch,
+  toneColor,
+  resolveColor,
+  renderNoteMarkdown2,
+  statusTone,
+  registerNodeType2,
+  registerAction2,
+  registerStatus2,
+  MapExtensions,
+  upgradeNodeTypes2,
+  guarded,
+  OrbitSVGRenderer2
+} from "./chunk-fkdfgtx9.js";
+// src/core/serializer-yaml.ts
+var serializeOrbitYAML = (doc) => {
+  const out = {};
+  const opts = doc.options;
+  if (opts.title) {
+    out.title = opts.title;
+  }
+  if (opts.theme) {
+    out.theme = opts.theme;
+  }
+  if (opts.viewMode) {
+    out.view = opts.viewMode;
+  }
+  if (opts.showRings !== undefined) {
+    out.showRings = opts.showRings;
+  }
+  if (opts.interactive !== undefined) {
+    out.interactive = opts.interactive;
+  }
+  if (opts.orbitAnimation !== undefined) {
+    out.animation = opts.orbitAnimation;
+  }
+  if (opts.orbitSpeed !== undefined) {
+    out.speed = opts.orbitSpeed;
+  }
+  if (opts.palette) {
+    out.palette = opts.palette;
+  }
+  if (opts.height !== undefined) {
+    out.height = opts.height;
+  }
+  if (opts.maxDepth !== undefined) {
+    out.maxDepth = opts.maxDepth;
+  }
+  if (opts.className) {
+    out.className = opts.className;
+  }
+  if (opts.baseUrl) {
+    out.baseUrl = opts.baseUrl;
+  }
+  if (opts.schemaVersion !== undefined) {
+    out.schemaVersion = opts.schemaVersion;
+  }
+  for (const [key, value] of Object.entries(doc.extra ?? {})) {
+    if (!Object.prototype.hasOwnProperty.call(out, key) && key !== "nodes") {
+      assignKey(out, key, value);
+    }
+  }
+  out.nodes = [serializeNode(doc.root, nodesWithExplicitIds(doc.root))];
+  return emitYaml(out);
+};
+var serializeNode = (n, explicitIds) => {
+  const obj = { text: n.text };
+  if (explicitIds.has(n)) {
+    obj.id = n.id;
+  }
+  if (n.icon) {
+    obj.icon = n.icon;
+  }
+  if (n.color) {
+    obj.color = n.color;
+  }
+  if (n.paletteColor !== undefined) {
+    obj.paletteColor = n.paletteColor;
+  }
+  if (n.type) {
+    obj.type = n.typeVersion === undefined ? n.type : `${n.type}@${n.typeVersion}`;
+  }
+  if (n.link) {
+    obj.link = n.link;
+  }
+  if (n.tags) {
+    obj.tags = n.tags;
+  }
+  if (n.status) {
+    obj.status = n.status;
+  }
+  if (n.priority !== undefined) {
+    obj.priority = n.priority;
+  }
+  if (n.collapsed !== undefined) {
+    obj.collapsed = n.collapsed;
+  }
+  if (n.image) {
+    obj.image = { ...mediaExtras(n.image), ...n.image };
+  }
+  if (n.video) {
+    obj.video = { ...mediaExtras(n.video), ...n.video };
+  }
+  if (n.embed) {
+    obj.embed = { ...mediaExtras(n.embed), ...n.embed };
+  }
+  if (n.note) {
+    obj.note = n.note;
+    if (n.noteFormat && n.noteFormat !== "markdown") {
+      obj.noteFormat = n.noteFormat;
+    }
+  }
+  if (n.attrs) {
+    for (const [k, v] of Object.entries(n.attrs)) {
+      if (!RESERVED_NODE_KEYS.has(k) && !Object.prototype.hasOwnProperty.call(obj, k)) {
+        assignKey(obj, k, v);
+      }
+    }
+  }
+  if (n.children.length) {
+    obj.children = n.children.map((child) => serializeNode(child, explicitIds));
+  }
+  return obj;
+};
+var RESERVED_NODE_KEYS = new Set(["text", "children"]);
+// src/core/create.ts
+var createOrbitMap = (target, source, options = {}) => {
+  const { strict, ...rendererOptions } = options;
+  const renderer = new OrbitSVGRenderer2(target, rendererOptions);
+  if (typeof source === "string") {
+    const doc = parseOrbit2(source, { strict, untitled: wordsFor(rendererOptions.language, target, rendererOptions.strings).text("untitledMap") });
+    reportParseDiagnostics(doc);
+    renderer.render(doc);
+  } else {
+    renderer.render(source);
+  }
+  return renderer;
+};
+// src/core/print-layout.ts
+var PRINT_THEMES = {
+  auto: "paper",
+  night: "paper",
+  "glass-night": "glass",
+  cosmos: "paper",
+  blueprint: "ink",
+  "flat-night": "flat",
+  "material-night": "material",
+  "liquid-night": "liquid"
+};
+var PALETTE_TOKENS = ["color-root", "color-1", "color-2", "color-3", "color-4", "color-5", "color-6", "color-7"];
+var PICTURE_SIZE = 720;
+var printTheme = (theme) => {
+  const expanded = expandTheme(theme);
+  const preset = themeName(expanded);
+  const light = PRINT_THEMES[preset] ?? (preset === "auto" ? "paper" : preset);
+  const own = typeof expanded === "object" ? expanded.tokens ?? {} : {};
+  const kept = light === preset ? own : Object.fromEntries(Object.entries(own).filter(([token]) => PALETTE_TOKENS.includes(token)));
+  return { preset: light, tokens: { ...kept, surface: "transparent", "surface-pattern": "none" } };
+};
+var renderPrintLayout = (container, input, options = {}) => {
+  const words = new OrbitWords(options.language, options.strings);
+  const map = typeof input === "string" ? parseOrbit2(input, { untitled: words.text("untitledMap") }) : input;
+  const fromDocument = documentToRendererOptions2(map.options);
+  const theme = printTheme(mergeThemes(fromDocument.theme, options.theme));
+  const tokens = resolveThemeTokens(themeName(theme), theme);
+  const extensions = new MapExtensions({ nodeTypes: options.nodeTypes, statuses: options.statuses, nodeTypeFor: options.nodeTypeFor });
+  const palette = options.palette ?? fromDocument.palette;
+  const colors = assignNodeColors(map.root, resolvePalette(palette), (node) => extensions.color(node));
+  const nodes = indexNodes(map.root);
+  const layout = {
+    words,
+    tokens,
+    extensions,
+    colors,
+    baseUrl: options.baseUrl ?? fromDocument.baseUrl,
+    linked: (href) => findIndexedLinkedNode(nodes, href)
+  };
+  const title = options.title ?? (map.options.title || map.root.text || words.text("untitledMap"));
+  const article = element("article", "orbit-print");
+  article.lang = words.locale;
+  article.style.cssText = themeProperties(tokens);
+  const heading = element("h1", "orbit-print__title");
+  appendName(heading, map.root, title, layout);
+  article.append(heading, ...entryParts(map.root, layout));
+  if (options.picture !== false) {
+    const figure = element("figure", "orbit-print__picture");
+    const svg = renderToSVGString2(map, {
+      width: PICTURE_SIZE,
+      height: PICTURE_SIZE,
+      viewMode: options.viewMode,
+      focus: options.focus,
+      theme,
+      palette,
+      title,
+      language: options.language,
+      strings: options.strings,
+      baseUrl: layout.baseUrl,
+      idPrefix: options.idPrefix ?? "orbit-print",
+      nodeTypes: options.nodeTypes,
+      statuses: options.statuses,
+      nodeTypeFor: options.nodeTypeFor
+    });
+    figure.appendChild(document.importNode(new DOMParser().parseFromString(svg, "image/svg+xml").documentElement, true));
+    article.appendChild(figure);
+  }
+  if (map.root.children.length > 0) {
+    const outline = element("div", "orbit-print__outline");
+    outline.append(...map.root.children.map((child) => idea(child, 1, layout)));
+    article.appendChild(outline);
+  }
+  container.replaceChildren(article);
+  ensureStyles(article);
+  return article;
+};
+var idea = (node, depth, layout) => {
+  const section = element("section", "orbit-print__idea");
+  section.dataset.depth = String(depth);
+  const entry = element("div", node.children.length > 0 ? "orbit-print__entry orbit-print__entry--parent" : "orbit-print__entry");
+  const level = `h${Math.min(depth + 1, 6)}`;
+  const name = element(level, `orbit-print__name orbit-print__name--depth-${Math.min(depth, 3)}`);
+  const dot = element("span", "orbit-print__dot");
+  dot.setAttribute("aria-hidden", "true");
+  dot.style.setProperty("--orbit-print-dot", resolveColor(layout.colors.get(node.id) ?? layout.tokens["color-1"] ?? "#888888", layout.tokens));
+  name.appendChild(dot);
+  appendName(name, node, node.text || layout.words.text("untitled"), layout);
+  entry.append(name, ...entryParts(node, layout));
+  section.appendChild(entry);
+  if (node.children.length > 0) {
+    const children = element("div", "orbit-print__children");
+    children.append(...node.children.map((child) => idea(child, depth + 1, layout)));
+    section.appendChild(children);
+  }
+  return section;
+};
+var appendName = (heading, node, text, layout) => {
+  const icon = layout.extensions.icon(node);
+  if (icon) {
+    const glyph = element("span", "orbit-print__icon");
+    glyph.textContent = icon;
+    heading.append(glyph, document.createTextNode(" "));
+  }
+  heading.appendChild(document.createTextNode(text));
+};
+var entryParts = (node, layout) => {
+  const parts = [];
+  const chips = chipsOf(node, layout);
+  if (chips) {
+    parts.push(chips);
+  }
+  const link = linkOf(node, layout);
+  if (link) {
+    parts.push(link);
+  }
+  const details = layout.extensions.nodeType(node)?.details;
+  if (details) {
+    const section = element("div", "orbit-print__details");
+    guarded("A node type’s details", undefined, () => details(node, section));
+    if (section.childNodes.length > 0) {
+      parts.push(section);
+    }
+  }
+  if (node.note?.trim()) {
+    const note = element("div", "orbit-print__note");
+    if (node.noteFormat === "plain") {
+      note.classList.add("orbit-print__note--plain");
+      note.textContent = node.note;
+    } else {
+      note.appendChild(renderNoteMarkdown2(node.note, { baseUrl: layout.baseUrl, resolveLink: layout.linked }));
+    }
+    parts.push(note);
+  }
+  parts.push(...mediaOf(node, layout));
+  return parts;
+};
+var chipsOf = (node, layout) => {
+  const chips = [];
+  const typeLabel = layout.extensions.nodeType(node)?.label;
+  if (typeLabel) {
+    chips.push(chip(typeLabel));
+  }
+  if (node.status) {
+    const status = chip(node.status, "orbit-print__chip--status");
+    const look = layout.extensions.status(node.status);
+    status.style.setProperty("--orbit-print-status", resolveColor(look.color ?? `var(--_orbit-status-${look.tone})`, layout.tokens));
+    chips.push(status);
+  }
+  if (node.priority !== undefined) {
+    chips.push(chip(layout.words.text("priority", { priority: node.priority })));
+  }
+  for (const tag of node.tags ?? []) {
+    chips.push(chip(`#${tag}`));
+  }
+  if (chips.length === 0) {
+    return null;
+  }
+  const container = element("p", "orbit-print__chips");
+  container.append(...chips);
+  return container;
+};
+var chip = (text, modifier) => {
+  const span = element("span", modifier ? `orbit-print__chip ${modifier}` : "orbit-print__chip");
+  span.textContent = text;
+  return span;
+};
+var linkOf = (node, layout) => {
+  if (!node.link) {
+    return null;
+  }
+  const paragraph = element("p", "orbit-print__link");
+  if (isNodeLink(node.link)) {
+    const target = layout.linked(node.link);
+    if (!target) {
+      return null;
+    }
+    paragraph.textContent = `→ ${layout.words.text("seeIdea", { name: target.text || layout.words.text("theIdea") })}`;
+    return paragraph;
+  }
+  const address = guardUrl(node.link, "link");
+  if (!address) {
+    return null;
+  }
+  paragraph.appendChild(addressLink(resolveUrl(address, layout.baseUrl)));
+  return paragraph;
+};
+var addressLink = (href) => {
+  const anchor = element("a", "orbit-print__address");
+  anchor.href = href;
+  anchor.textContent = href;
+  return anchor;
+};
+var mediaOf = (node, layout) => {
+  const figures = [];
+  if (hasMediaSource(node.image)) {
+    const source = guardUrl(node.image.src, "image");
+    if (source) {
+      const figure = element("figure", "orbit-print__media");
+      const image = element("img", "orbit-print__image");
+      image.src = resolveUrl(source, layout.baseUrl);
+      image.alt = node.image.alt ?? "";
+      figure.appendChild(image);
+      appendCaption(figure, node.image.caption ?? node.image.alt);
+      figures.push(figure);
+    }
+  }
+  if (hasMediaSource(node.video)) {
+    const source = guardUrl(node.video.src, "video");
+    if (source) {
+      const resolved = resolveUrl(source, layout.baseUrl);
+      const figure = element("figure", "orbit-print__media orbit-print__media--video");
+      const thumbnail = node.video.thumbnail ? guardUrl(node.video.thumbnail, "image") : youtubeThumbnailUrl(resolved);
+      if (thumbnail) {
+        const image = element("img", "orbit-print__image");
+        image.src = resolveUrl(thumbnail, layout.baseUrl);
+        image.alt = "";
+        figure.appendChild(image);
+      }
+      const caption = element("figcaption", "orbit-print__caption");
+      caption.append(document.createTextNode(`${node.video.caption ?? layout.words.text("video")}: `), addressLink(videoPageUrl(resolved, node.video.provider)));
+      figure.appendChild(caption);
+      figures.push(figure);
+    }
+  }
+  if (hasMediaSource(node.embed) && !hasMediaSource(node.video)) {
+    const source = guardUrl(node.embed.src, "embed");
+    if (source) {
+      const figure = element("figure", "orbit-print__media orbit-print__media--embed");
+      const caption = element("figcaption", "orbit-print__caption");
+      if (node.embed.caption) {
+        caption.append(document.createTextNode(`${node.embed.caption}: `));
+      }
+      caption.appendChild(addressLink(resolveUrl(source, layout.baseUrl)));
+      figure.appendChild(caption);
+      figures.push(figure);
+    }
+  }
+  return figures;
+};
+var appendCaption = (figure, text) => {
+  if (text?.trim()) {
+    const caption = element("figcaption", "orbit-print__caption");
+    caption.textContent = text;
+    figure.appendChild(caption);
+  }
+};
+var themeProperties = (tokens) => {
+  const value = (token, fallback) => resolveColor(tokens[token] ?? fallback, tokens);
+  const font = (token, fallback) => resolveFont(tokens[token] ?? fallback, tokens);
+  return [
+    `--_orbit-print-text: ${value("text", "#1F2733")};`,
+    `--_orbit-print-muted-text: ${value("muted-text", "#5B6474")};`,
+    `--_orbit-print-link-text: ${value("link-text", value("text", "#1F2733"))};`,
+    `--_orbit-print-chip-background: ${value("chip-background", "#EEF0F4")};`,
+    `--_orbit-print-chip-text: ${value("chip-text", value("text", "#1F2733"))};`,
+    `--_orbit-print-border: ${value("sheet-border", "#D9DDE3")};`,
+    `--_orbit-print-font: ${font("font-family", "sans-serif")};`,
+    `--_orbit-print-display-font: ${font("display-font", font("font-family", "sans-serif"))};`
+  ].join(" ");
+};
+var resolveFont = (value, tokens) => {
+  let font = value;
+  for (let depth = 0;depth < 4 && font.includes("var("); depth += 1) {
+    font = font.replace(/var\(--_?orbit-([a-z0-9-]+)(?:\s*,\s*([^()]+))?\)/gi, (whole, token, fallback) => tokens[token] ?? fallback?.trim() ?? whole);
+  }
+  return font.includes("var(") || /[;{}]/.test(font) ? "sans-serif" : font;
+};
+var element = (name, className) => {
+  const created = document.createElement(name);
+  created.className = className;
+  return created;
+};
+// src/core/web-page/page.ts
+var ORBIT_ICON = "data:image/svg+xml,%3Csvg xmlns='http://www.w3.org/2000/svg' viewBox='18 18 72 72'%3E%3Cdefs%3E%3CradialGradient id='d' gradientUnits='userSpaceOnUse' cx='32.4' cy='23.76' r='102.6'%3E%3Cstop offset='0' stop-color='%234A35A8'/%3E%3Cstop offset='1' stop-color='%2318134A'/%3E%3C/radialGradient%3E%3C/defs%3E%3Crect x='18' y='18' width='72' height='72' rx='16' fill='url(%23d)'/%3E%3Cpath d='M67.53,35.36 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M69.84,37.38 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M71.86,39.69 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M76.52,57.07 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M75.92,60.08 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M74.93,62.99 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M62.21,75.71 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M59.3,76.7 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M56.29,77.3 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M38.91,72.64 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M36.6,70.62 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M34.58,68.31 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M29.92,50.93 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M30.52,47.92 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M31.51,45.01 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M44.23,32.29 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M47.14,31.3 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z M50.15,30.7 a0.78,0.78 0 1,0 1.56,0 a0.78,0.78 0 1,0 -1.56,0 Z' fill='%23E2E6FF' fill-opacity='.5'/%3E%3Ccircle cx='54' cy='54' r='11' fill='%23FAD86F'/%3E%3Ccircle cx='60.08' cy='31.3' r='6.4' fill='%23FF9E96'/%3E%3Ccircle cx='76.7' cy='47.92' r='6.4' fill='%23F8B478'/%3E%3Ccircle cx='70.62' cy='70.62' r='6.4' fill='%237FDAAB'/%3E%3Ccircle cx='47.92' cy='76.7' r='6.4' fill='%2386CDFF'/%3E%3Ccircle cx='31.3' cy='60.08' r='6.4' fill='%23C9B1FE'/%3E%3Ccircle cx='37.38' cy='37.38' r='6.4' fill='%23F7A3D4'/%3E%3C/svg%3E";
+var exportWebPage = (input, options) => {
+  const document2 = typeof input === "string" ? parseOrbit2(input) : input;
+  const source = typeof input === "string" ? input : serializeOrbitMarkdown2(input);
+  const words = new OrbitWords(options.language, options.strings);
+  const title = options.title ?? (document2.options.title || document2.root.text || "Orbit");
+  const data = {
+    source,
+    theme: options.theme,
+    viewMode: options.viewMode,
+    focus: options.focus,
+    language: options.language,
+    strings: options.strings,
+    media: options.media ?? {}
+  };
+  const theme = options.theme ?? document2.options.theme;
+  return `<!doctype html>
+<html lang="${escapeAttribute(words.locale)}">
+<head>
+<meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1, viewport-fit=cover">
+<meta name="generator" content="Orbit">
+<link rel="icon" href="${ORBIT_ICON}">
+<title>${escapeText(title)}</title>
+<style>
+${pageStyles(theme)}
+</style>
+</head>
+<body>
+<div class="page" id="page">
+  <div class="page__map" id="page-map" aria-label="${escapeAttribute(title)}"></div>
+  <button class="page__present" type="button" data-present><span aria-hidden="true">▶</span> ${escapeText(words.text("present"))}</button>
+  <section class="page__caption" id="page-caption" aria-live="polite" hidden>
+    <h1 class="page__title" id="page-title"></h1>
+    <div class="page__note" id="page-note"></div>
+  </section>
+  <nav class="page__controls" id="page-controls" hidden>
+    <button class="page__button" type="button" data-step="-1" aria-label="${escapeAttribute(words.text("previous"))}">‹</button>
+    <span class="page__count" id="page-count"></span>
+    <button class="page__button" type="button" data-step="1" aria-label="${escapeAttribute(words.text("next"))}">›</button>
+    <button class="page__button" type="button" data-close aria-label="${escapeAttribute(words.text("close"))}">✕</button>
+  </nav>
+</div>
+<div class="page__print" id="page-print"></div>
+<script type="application/json" id="orbit-page">${scriptJson(data)}</script>
+<script type="application/json" id="orbit-script">${scriptJson(options.script)}</script>
+<script>
+  // Orbit runs from a script element made here: text inside one is never read as HTML.
+  (function () {
+    var script = document.createElement('script');
+    script.textContent = JSON.parse(document.getElementById('orbit-script').textContent);
+    document.body.appendChild(script);
+  })();
+</script>
+</body>
+</html>
+`;
+};
+var pageColors = (tokens) => {
+  const surface = tokens.surface === "transparent" ? "#ffffff" : tokens.surface;
+  return [
+    `--page-background: ${surface};`,
+    `--page-card: ${tokens["sheet-background"]};`,
+    `--page-text: ${tokens["sheet-text"]};`,
+    `--page-muted: ${tokens["sheet-muted-text"]};`,
+    `--page-border: ${tokens["sheet-border"]};`,
+    `--page-shadow: ${tokens["sheet-shadow"]};`
+  ].join(" ");
+};
+var tokensOf = (theme) => {
+  const expanded = expandTheme(theme);
+  const preset = typeof expanded === "string" ? expanded : expanded?.preset;
+  const base = themeTokens2(isOrbitThemePreset2(preset) ? preset : "paper");
+  return typeof expanded === "object" && expanded?.tokens ? { ...base, ...expanded.tokens } : base;
+};
+var pageStyles = (theme) => {
+  const automatic = (typeof theme === "string" ? theme : theme?.preset) === "auto";
+  const colors = automatic ? `:root { ${pageColors(themeTokens2("paper"))} }
+@media (prefers-color-scheme: dark) { :root { ${pageColors(themeTokens2("night"))} } }` : `:root { ${pageColors(tokensOf(theme))} }`;
+  return `${colors}
+html, body { margin: 0; height: 100%; background: var(--page-background); }
+body { font: 16px/1.5 system-ui, -apple-system, "Segoe UI", Roboto, sans-serif; color: var(--page-text); }
+.page__map { position: fixed; inset: 0; }
+.page__present, .page__controls {
+  position: fixed; left: 50%; bottom: max(16px, env(safe-area-inset-bottom)); transform: translateX(-50%);
+  display: inline-flex; align-items: center; gap: 8px; min-height: 44px; padding: 0 18px; border: 1px solid var(--page-border);
+  border-radius: 22px; background: var(--page-card); color: var(--page-text); box-shadow: var(--page-shadow); font: inherit; font-weight: 600;
+}
+.page__present { cursor: pointer; }
+.page__controls { padding: 0 6px; transition: opacity 200ms ease; }
+.page__button { min-width: 44px; min-height: 44px; border: 0; border-radius: 22px; background: none; color: inherit; font: inherit; font-size: 20px; cursor: pointer; }
+.page__button:focus-visible, .page__present:focus-visible { outline: 2px solid currentColor; outline-offset: 2px; }
+.page__count { min-width: 4em; text-align: center; color: var(--page-muted); font-variant-numeric: tabular-nums; }
+.page__caption {
+  position: fixed; left: 50%; bottom: calc(max(16px, env(safe-area-inset-bottom)) + 60px); transform: translateX(-50%);
+  box-sizing: border-box; width: min(720px, calc(100% - 32px)); max-height: 40vh; overflow: auto; padding: 16px 20px;
+  border: 1px solid var(--page-border); border-radius: 16px; background: var(--page-card); color: var(--page-text); box-shadow: var(--page-shadow);
+}
+.page__title { margin: 0; font-size: 20px; line-height: 1.3; }
+.page__note:not(:empty) { margin-top: 8px; }
+.page__note p { margin: 0 0 8px; }
+.page__note img { max-width: 100%; border-radius: 8px; }
+.page__note a { color: inherit; }
+.page--presenting .page__present { display: none; }
+.page--presenting:not(.page--controls) .page__controls { opacity: 0; }
+.page--presenting:not(.page--controls) { cursor: none; }
+[hidden] { display: none !important; }
+.page__print { display: none; }
+@media print {
+  @page { margin: 16mm 14mm; }
+  html, body { height: auto; background: #ffffff; }
+  .page { display: none; }
+  .page__print { display: block; }
+}`;
+};
+var scriptJson = (value) => {
+  return JSON.stringify(value).replace(/</g, "\\u003c").replace(/\u2028/g, "\\u2028").replace(/\u2029/g, "\\u2029");
+};
+var escapeText = (text) => {
+  return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+};
+var escapeAttribute = (text) => {
+  return escapeText(text).replace(/"/g, "&quot;");
+};
+// src/core/map-tools/input.ts
+var schemaOf = (fields) => {
+  const required = Object.keys(fields).filter((name) => fields[name].required);
+  return {
+    type: "object",
+    properties: Object.fromEntries(Object.entries(fields).map(([name, field]) => [name, propertyOf(field)])),
+    ...required.length > 0 ? { required } : {}
+  };
+};
+var propertyOf = (field) => {
+  if (field.type === "list") {
+    return { type: "array", description: field.description, items: field.values ? { type: "string", enum: [...field.values] } : { type: "string" } };
+  }
+  if (field.type === "record") {
+    return { ...schemaOf(field.fields ?? {}), description: field.description };
+  }
+  return { type: field.type, description: field.description, ...field.minimum === undefined ? {} : { minimum: field.minimum } };
+};
+
+class InputError extends Error {
+}
+var readInput = (tool, fields, input, synonyms = {}) => {
+  const record = inputRecord(tool, fields, input);
+  const values = {};
+  const ignored = [];
+  const names = Object.keys(fields);
+  for (const [given, value] of Object.entries(record)) {
+    if (value === null || value === undefined) {
+      continue;
+    }
+    const name = owns(fields, given) ? given : synonymOf(given, names, synonyms);
+    if (name === undefined) {
+      const near = suggest(given, names);
+      if (near !== undefined) {
+        throw new InputError(`${tool} has no field "${given}". Did you mean "${near}"? It takes ${list(names)}.`);
+      }
+      ignored.push(given);
+      continue;
+    }
+    if (owns(values, name)) {
+      throw new InputError(`${tool} got ${name} twice, as "${name}" and as "${given}": give it once.`);
+    }
+    values[name] = readValue(name, fields[name], value);
+  }
+  for (const name of names) {
+    if (fields[name].required && !owns(values, name)) {
+      throw new InputError(`${tool} needs ${name}: ${lowerFirst(fields[name].description)}`);
+    }
+  }
+  return { values, ignored };
+};
+var inputRecord = (tool, fields, input) => {
+  let value = input;
+  if (typeof value === "string") {
+    if (value.trim() === "") {
+      return {};
+    }
+    try {
+      value = JSON.parse(value);
+    } catch (error) {
+      throw new InputError(`${tool}'s input isn't valid JSON (${error.message}). Send an object, like ${example(fields)}.`);
+    }
+  }
+  if (value === null || value === undefined) {
+    return {};
+  }
+  if (typeof value !== "object" || Array.isArray(value)) {
+    throw new InputError(`${tool} takes an object, like ${example(fields)}, not ${describe(value)}.`);
+  }
+  return value;
+};
+var synonymOf = (given, names, synonyms) => {
+  const lowered = given.toLowerCase();
+  return names.find((name) => name.toLowerCase() === lowered) ?? (owns(synonyms, lowered) ? synonyms[lowered] : undefined);
+};
+var owns = (record, key) => {
+  return Object.prototype.hasOwnProperty.call(record, key);
+};
+var readValue = (name, field, value) => {
+  switch (field.type) {
+    case "string":
+      if (typeof value === "string") {
+        return value;
+      }
+      if (typeof value === "number" || typeof value === "boolean") {
+        return String(value);
+      }
+      throw new InputError(`${name} takes text, not ${describe(value)}.`);
+    case "integer":
+    case "number": {
+      const number = typeof value === "number" ? value : typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
+      if (!Number.isFinite(number) || field.type === "integer" && !Number.isInteger(number)) {
+        throw new InputError(`${name} takes ${field.type === "integer" ? "a whole number" : "a number"}, like ${field.minimum ?? 1}, not ${describe(value)}.`);
+      }
+      if (field.minimum !== undefined && number < field.minimum) {
+        throw new InputError(`${name} takes ${field.minimum} or more, not ${number}. ${field.description}`);
+      }
+      return number;
+    }
+    case "boolean": {
+      const word = typeof value === "string" ? value.trim().toLowerCase() : value;
+      if (word === true || word === "true" || word === "yes") {
+        return true;
+      }
+      if (word === false || word === "false" || word === "no") {
+        return false;
+      }
+      throw new InputError(`${name} takes true or false, not ${describe(value)}.`);
+    }
+    case "list": {
+      const items = Array.isArray(value) ? value : typeof value === "string" ? value.trim() === "" ? [] : value.split(",") : null;
+      if (!items || items.some((item) => typeof item !== "string" && typeof item !== "number")) {
+        throw new InputError(`${name} takes a list of words, like ["${field.values?.[0] ?? "design"}"], not ${describe(value)}.`);
+      }
+      const words = items.map((item) => String(item).trim()).filter((item) => item !== "");
+      for (const word of words) {
+        if (field.values && !field.values.includes(word)) {
+          const near = suggest(word, field.values);
+          throw new InputError(`${name} can't take "${word}".${near === undefined ? "" : ` Did you mean "${near}"?`} It takes ${list(field.values)}.`);
+        }
+      }
+      return words;
+    }
+    case "record": {
+      const fields = field.fields ?? {};
+      const first = Object.keys(fields)[0];
+      if (typeof value === "string") {
+        return { [first]: value };
+      }
+      if (typeof value !== "object" || value === null || Array.isArray(value)) {
+        throw new InputError(`${name} takes an object, like {"${first}": "…"}, not ${describe(value)}.`);
+      }
+      return readInput(name, fields, value).values;
+    }
+  }
+};
+var describe = (value) => {
+  if (value === null) {
+    return "null";
+  }
+  if (Array.isArray(value)) {
+    return "a list";
+  }
+  if (typeof value === "string") {
+    return JSON.stringify(value.length > 40 ? `${value.slice(0, 40)}…` : value);
+  }
+  if (typeof value === "object") {
+    return "an object";
+  }
+  return String(value);
+};
+var list = (words) => {
+  return words.length <= 1 ? words.join("") : `${words.slice(0, -1).join(", ")} and ${words[words.length - 1]}`;
+};
+var example = (fields) => {
+  const name = Object.keys(fields).find((key) => fields[key].required) ?? Object.keys(fields)[0];
+  return name === undefined ? "{}" : `{"${name}": "…"}`;
+};
+var lowerFirst = (text) => {
+  return text.charAt(0).toLowerCase() + text.slice(1);
+};
+
+// src/core/map-tools/definitions.ts
+var PROVIDERS = ["anthropic", "openai", "openai-chat", "gemini"];
+var ATTRIBUTES = ["note", "status", "priority", "tags", "icon", "color", "link", "image", "video", "embed", "collapsed"];
+var NODE_ID = "node_id";
+var NODE_SYNONYMS = { id: NODE_ID, node: NODE_ID, nodeid: NODE_ID };
+var TOOL_SPECS = [
+  {
+    name: "read_map",
+    description: "Read the mind map as an outline: a line for each node (an idea), indented under its parent, with its id after a #, its attributes in parentheses, and the start of its note on the next line after >. Read it before changing the map: the other tools take these ids. A big map is cut short: read a branch with node_id, or search with find_nodes.",
+    fields: {
+      node_id: { type: "string", description: "Read only this node and the nodes under it. Leave out to read the whole map." },
+      depth: { type: "integer", minimum: 1, description: "How many levels under it to read: 1 for its children only. Leave out to read them all." }
+    },
+    synonyms: NODE_SYNONYMS,
+    readOnly: true,
+    destructive: false
+  },
+  {
+    name: "find_nodes",
+    description: "Search the map for nodes by the words in their titles, notes and tags, by status or by tag. Returns each match with its id and where it is in the map.",
+    fields: {
+      query: { type: "string", description: "Words to look for, in any case, with or without accents. A node matches when it has every word." },
+      status: { type: "string", description: "Only nodes with this status. todo, active, done and blocked also find the words that mean the same, such as planned, in progress, shipped or stuck." },
+      tag: { type: "string", description: "Only nodes with this tag." }
+    },
+    synonyms: { text: "query", search: "query", words: "query", tags: "tag" },
+    readOnly: true,
+    destructive: false
+  },
+  {
+    name: "read_node",
+    description: "Read everything about one node: its title, its whole note, its attributes, its picture, video or embedded page, where it is in the map, its children, and the nodes that link to it.",
+    fields: {
+      node_id: { type: "string", required: true, description: "The node to read, by the id read_map or find_nodes gave." }
+    },
+    synonyms: NODE_SYNONYMS,
+    readOnly: true,
+    destructive: false
+  },
+  {
+    name: "add_nodes",
+    description: "Add nodes under a node: one, several, or whole branches at once, written as a markdown list. Each item is a node, items indented under it are its children, at any depth, and indented lines under an item that aren't items are its note. On an item's line, [ ], [/] or [x] first sets its status to todo, active or done, an emoji first sets its icon, words after a # at the end are its tags, and <!-- orbit color: tomato, priority: 1 --> at the end sets other attributes. Returns the new nodes with their ids.",
+    fields: {
+      parent_id: { type: "string", required: true, description: "The node to add them under." },
+      outline: { type: "string", required: true, description: 'The nodes, as a markdown list: "- Social media\\n  - Instagram\\n- Newsletter".' },
+      index: { type: "integer", minimum: 0, description: "Where they go among the children of parent_id: 0 puts them first. Leave out to put them last." }
+    },
+    synonyms: { parent: "parent_id", parentid: "parent_id", under: "parent_id", markdown: "outline", nodes: "outline", items: "outline", children: "outline", text: "outline", position: "index" },
+    readOnly: false,
+    destructive: false
+  },
+  {
+    name: "update_node",
+    description: "Change a node's title or attributes. Only the fields you give change; to remove an attribute, name it in clear. A new title can give the node a new id, which the result says.",
+    fields: {
+      node_id: { type: "string", required: true, description: "The node to change." },
+      text: { type: "string", description: "Its title: plain text, a few words." },
+      note: { type: "string", description: "Its note, in markdown, for details and longer text. Replaces the note it has." },
+      status: { type: "string", description: "todo, active, done or blocked, which show a colored dot, or any other word." },
+      priority: { type: "number", description: "A number, such as 1 for the most important." },
+      tags: { type: "list", description: "All its tags, as words: they replace the ones it has." },
+      icon: { type: "string", description: "An emoji shown before its title." },
+      color: { type: "string", description: "A CSS color, such as #E8A33D or tomato: its children take shades of it. Nodes without one take the theme's colors, so set it only when asked." },
+      link: { type: "string", description: "A web address it links to, or #id to link to another node of the map." },
+      image: {
+        type: "record",
+        description: "A picture shown in the node.",
+        fields: {
+          src: { type: "string", required: true, description: "The picture's address." },
+          alt: { type: "string", description: "What the picture shows, for people who can't see it." },
+          caption: { type: "string", description: "A caption." }
+        }
+      },
+      video: {
+        type: "record",
+        description: "A video the node plays.",
+        fields: {
+          src: { type: "string", required: true, description: "The video's address: YouTube, Vimeo or a video file." },
+          caption: { type: "string", description: "A caption." }
+        }
+      },
+      embed: {
+        type: "record",
+        description: "A web page shown in a frame in the node's details.",
+        fields: {
+          src: { type: "string", required: true, description: "The page's address." },
+          caption: { type: "string", description: "A caption." }
+        }
+      },
+      collapsed: { type: "boolean", description: "true hides its children until the reader opens it." },
+      clear: { type: "list", values: ATTRIBUTES, description: 'Attributes to remove, such as ["status", "color"].' }
+    },
+    synonyms: {
+      ...NODE_SYNONYMS,
+      title: "text",
+      name: "text",
+      label: "text",
+      notes: "note",
+      description: "note",
+      details: "note",
+      state: "status",
+      tag: "tags",
+      labels: "tags",
+      emoji: "icon",
+      colour: "color",
+      url: "link",
+      href: "link",
+      picture: "image",
+      photo: "image",
+      remove: "clear",
+      unset: "clear",
+      delete: "clear"
+    },
+    readOnly: false,
+    destructive: true
+  },
+  {
+    name: "move_node",
+    description: "Move a node, with everything under it, under another node, or to another place among its siblings.",
+    fields: {
+      node_id: { type: "string", required: true, description: "The node to move." },
+      parent_id: { type: "string", description: "The node to move it under. Leave out to keep its parent and change only its place." },
+      index: { type: "integer", minimum: 0, description: "Its place among the children of its new parent: 0 puts it first. Leave out to put it last." }
+    },
+    synonyms: { ...NODE_SYNONYMS, parent: "parent_id", parentid: "parent_id", under: "parent_id", to: "parent_id", position: "index" },
+    readOnly: false,
+    destructive: false
+  },
+  {
+    name: "reorder_children",
+    description: "Put the children of a node in a new order, all at once: to sort them, or to group the ones that go together.",
+    fields: {
+      parent_id: { type: "string", required: true, description: "The node whose children to reorder." },
+      order: { type: "list", required: true, description: "The ids of all its children, in their new order." }
+    },
+    synonyms: { parent: "parent_id", parentid: "parent_id", node_id: "parent_id", id: "parent_id", ids: "order", children: "order", child_ids: "order" },
+    readOnly: false,
+    destructive: false
+  },
+  {
+    name: "remove_node",
+    description: "Remove a node and everything under it. Remove nodes only when asked to.",
+    fields: {
+      node_id: { type: "string", required: true, description: "The node to remove. The root can't be removed." }
+    },
+    synonyms: NODE_SYNONYMS,
+    readOnly: false,
+    destructive: true
+  },
+  {
+    name: "show_node",
+    description: "Show the reader a node: the map flies to it, with its children around it. Use it when they ask to see or go to something, or to show them what you changed.",
+    fields: {
+      node_id: { type: "string", required: true, description: "The node to show." }
+    },
+    synonyms: NODE_SYNONYMS,
+    readOnly: true,
+    destructive: false
+  }
+];
+var definitionOf = (spec) => {
+  return {
+    name: spec.name,
+    description: spec.description,
+    inputSchema: schemaOf(spec.fields),
+    annotations: { readOnlyHint: spec.readOnly, destructiveHint: spec.destructive }
+  };
+};
+var formatDefinitions = (definitions, provider) => {
+  const tools = definitions.map(({ name, description, inputSchema }) => ({ name, description, schema: structuredCopy(inputSchema) }));
+  switch (provider) {
+    case "anthropic":
+      return tools.map(({ name, description, schema }) => ({ name, description, input_schema: schema }));
+    case "openai":
+      return tools.map(({ name, description, schema }) => ({ type: "function", name, description, parameters: schema, strict: false }));
+    case "openai-chat":
+      return tools.map(({ name, description, schema }) => ({ type: "function", function: { name, description, parameters: schema } }));
+    case "gemini":
+      return [{ functionDeclarations: tools.map(({ name, description, schema }) => ({ name, description, parametersJsonSchema: schema })) }];
+    default:
+      throw new TypeError(`Map tools come in the shapes of ${PROVIDERS.map((name) => `"${name}"`).join(", ")}, not ${JSON.stringify(provider)}. For any other, build them from tools.definitions: each has a name, a description and an inputSchema (JSON Schema).`);
+  }
+};
+var structuredCopy = (value) => {
+  return JSON.parse(JSON.stringify(value));
+};
+
+// src/core/map-tools/reading.ts
+var NOTE_PREVIEW = 100;
+var MATCH_LIMIT = 50;
+var nameOf = (node) => {
+  return `"${node.text}" #${node.id}`;
+};
+var outlineLine = (node, depth) => {
+  const details = attributesOf(node);
+  return `${"  ".repeat(depth)}- ${node.text}  #${node.id}${details.length > 0 ? `  (${details.join("; ")})` : ""}`;
+};
+var attributesOf = (node) => {
+  const details = [];
+  if (node.icon) {
+    details.push(`icon: ${node.icon}`);
+  }
+  if (node.status) {
+    details.push(`status: ${node.status}`);
+  }
+  if (node.priority !== undefined) {
+    details.push(`priority: ${node.priority}`);
+  }
+  if (node.tags && node.tags.length > 0) {
+    details.push(`tags: ${node.tags.join(", ")}`);
+  }
+  if (node.color) {
+    details.push(`color: ${node.color}`);
+  }
+  if (node.link) {
+    details.push(`link: ${node.link}`);
+  }
+  for (const media of ["image", "video", "embed"]) {
+    if (node[media]) {
+      details.push(media);
+    }
+  }
+  if (node.type) {
+    details.push(`type: ${node.type}`);
+  }
+  if (node.collapsed) {
+    details.push("collapsed");
+  }
+  return details;
+};
+var notePreview = (note) => {
+  const text = note.trim().replace(/\s+/g, " ");
+  return text.length > NOTE_PREVIEW ? `${text.slice(0, NOTE_PREVIEW - 1).trimEnd()}…` : text;
+};
+var headOf = (node, depth) => {
+  const lines = [outlineLine(node, depth)];
+  if (node.note?.trim()) {
+    lines.push(`${"  ".repeat(depth + 1)}> ${notePreview(node.note)}`);
+  }
+  return lines;
+};
+var outlineOf = (node, depth = 0, levels = Infinity) => {
+  const lines = headOf(node, depth);
+  if (levels > 0) {
+    for (const child of node.children) {
+      lines.push(...outlineOf(child, depth + 1, levels - 1));
+    }
+  } else if (node.children.length > 0) {
+    lines.push(`${"  ".repeat(depth + 1)}- … ${count(node.children.length, "child", "children")}, ${count(descendants(node), "node")} in all under it`);
+  }
+  return lines;
+};
+var readOutline = (start, levels, limit) => {
+  let shown = 0;
+  let total = 1;
+  let level = [start];
+  while (shown < levels) {
+    const next = level.flatMap((node) => node.children);
+    if (next.length === 0 || total + next.length > limit) {
+      break;
+    }
+    total += next.length;
+    level = next;
+    shown += 1;
+  }
+  const complete = shown === levels || level.every((node) => node.children.length === 0);
+  if (shown === 0 && !complete) {
+    const children = start.children.slice(0, Math.max(1, limit - 1));
+    return {
+      lines: [
+        ...headOf(start, 0),
+        ...children.flatMap((child) => outlineOf(child, 1, 0)),
+        `  - … ${count(start.children.length - children.length, "more child", "more children")} of ${nameOf(start)}`
+      ],
+      complete
+    };
+  }
+  return { lines: outlineOf(start, 0, shown), complete };
+};
+var descendants = (node) => {
+  return node.children.reduce((sum, child) => sum + 1 + descendants(child), 0);
+};
+var count = (amount, one, many = `${one}s`) => {
+  return `${amount} ${amount === 1 ? one : many}`;
+};
+var nodeDetails = (root, node, path) => {
+  const lines = [nameOf(node)];
+  lines.push(path.length > 1 ? `Where: ${path.map((step) => step.text).join(" › ")}` : "Where: the root of the map");
+  const fields = [
+    ["Icon", node.icon],
+    ["Status", node.status],
+    ["Priority", node.priority],
+    ["Tags", node.tags && node.tags.length > 0 ? node.tags.join(", ") : undefined],
+    ["Color", node.color],
+    ["Link", node.link],
+    ["Picture", node.image && mediaLine(node.image.src, { alt: node.image.alt, caption: node.image.caption })],
+    ["Video", node.video && mediaLine(node.video.src, { caption: node.video.caption })],
+    ["Embedded page", node.embed && mediaLine(node.embed.src, { caption: node.embed.caption })],
+    ["Type", node.type],
+    ["Collapsed", node.collapsed ? "yes: its children are hidden until the reader opens it" : undefined]
+  ];
+  for (const [label, value] of fields) {
+    if (value !== undefined && value !== "") {
+      lines.push(`${label}: ${String(value)}`);
+    }
+  }
+  const custom = Object.entries(node.attrs ?? {});
+  if (custom.length > 0) {
+    lines.push(`Other attributes: ${custom.map(([key, value]) => `${key}: ${typeof value === "string" ? value : JSON.stringify(value)}`).join("; ")}`);
+  }
+  lines.push(node.note?.trim() ? `Note${node.noteFormat === "plain" ? " (plain text)" : ""}:
+${node.note.trim()}` : "Note: none");
+  lines.push(node.children.length > 0 ? `Children (${node.children.length}): ${node.children.map(nameOf).join(", ")}` : "Children: none");
+  const linking = nodesLinkingTo(root, node);
+  if (linking.length > 0) {
+    lines.push(`Linked from: ${linking.map(nameOf).join(", ")}`);
+  }
+  return lines.join(`
+`);
+};
+var mediaLine = (src, extras) => {
+  const described = Object.entries(extras).filter(([, value]) => value).map(([key, value]) => `${key}: ${value}`);
+  return described.length > 0 ? `${src} (${described.join("; ")})` : src;
+};
+var nodesLinkingTo = (root, target) => {
+  const nodes = indexNodes(root);
+  const linking = [];
+  const visit = (node) => {
+    if (nodeLinksOf(node).some((href) => findIndexedLinkedNode(nodes, href) === target)) {
+      linking.push(node);
+    }
+    node.children.forEach(visit);
+  };
+  visit(root);
+  return linking;
+};
+var searchable = (text) => {
+  return text.normalize("NFKD").replace(/\p{M}+/gu, "").toLowerCase();
+};
+var findNodes = (root, search) => {
+  const words = searchable(search.query ?? "").split(/\s+/).filter((word) => word !== "");
+  const status = search.status === undefined ? undefined : searchable(search.status.trim());
+  const tag = search.tag === undefined ? undefined : searchable(search.tag.trim().replace(/^#/, ""));
+  const statusMatches = (node) => {
+    if (status === undefined) {
+      return true;
+    }
+    if (!node.status) {
+      return false;
+    }
+    const own = searchable(node.status.trim());
+    const tone = statusTone(status);
+    return own === status || tone !== "neutral" && statusTone(own) === tone;
+  };
+  const matches = [];
+  const visit = (node, path) => {
+    const title = searchable([node.text, ...node.tags ?? []].join(" "));
+    const everything = `${title} ${searchable(node.note ?? "")}`;
+    if (words.every((word) => everything.includes(word)) && statusMatches(node) && (tag === undefined || (node.tags ?? []).some((own) => searchable(own) === tag))) {
+      matches.push({ node, path, inTitle: words.every((word) => title.includes(word)) });
+    }
+    node.children.forEach((child) => visit(child, [...path, node]));
+  };
+  visit(root, []);
+  if (matches.length === 0) {
+    return "No node matches. Try fewer or other words, or read the map with read_map.";
+  }
+  matches.sort((first, second) => Number(second.inTitle) - Number(first.inTitle));
+  const shown = matches.slice(0, MATCH_LIMIT);
+  const lines = [`${count(matches.length, "node matches", "nodes match")}${matches.length > shown.length ? `; the first ${shown.length}` : ""}:`];
+  for (const { node, path } of shown) {
+    lines.push(`${outlineLine(node, 0)}${path.length > 0 ? `  in ${path.map((step) => step.text).join(" › ")}` : "  (the root)"}`);
+  }
+  if (matches.length > shown.length) {
+    lines.push("Narrow the search to see the others.");
+  }
+  return lines.join(`
+`);
+};
+
+// src/core/map-tools/tools.ts
+var READ_LIMIT = 250;
+var LONG_TITLE = 60;
+var COLOR_SYNTAX = /^(?:#(?:[\da-f]{3,4}|[\da-f]{6}|[\da-f]{8})|[a-z]+|(?:rgba?|hsla?|hwb|lab|lch|oklab|oklch|color|color-mix|light-dark|var)\(.+\))$/i;
+var OUTLINE_CODES_LEFT_OUT = new Set(["synthetic-root", "no-structure", "unknown-link-target"]);
+
+class CallError extends Error {
+}
+var createMapTools = (map, options = {}) => {
+  const target = targetOf(map);
+  const readLimit = typeof options.readLimit === "number" && Number.isFinite(options.readLimit) ? Math.max(10, Math.trunc(options.readLimit)) : READ_LIMIT;
+  const specs = TOOL_SPECS.filter((spec) => (spec.name !== "show_node" || target.live !== null) && (spec.readOnly || !options.readOnly));
+  const definitions = specs.map(definitionOf);
+  const renamed = new Map;
+  const removed = new Map;
+  const notes = [];
+  const resolve = (root, given, field) => {
+    const id = given.trim().replace(/^#/, "");
+    const direct = findNodeById2(root, id);
+    if (direct) {
+      return direct;
+    }
+    let current = id;
+    const seen = new Set;
+    while (renamed.has(current) && !seen.has(current)) {
+      seen.add(current);
+      current = renamed.get(current);
+    }
+    const followed = current === id ? null : findNodeById2(root, current);
+    if (followed) {
+      notes.push(`#${id} is ${nameOf(followed)} now.`);
+      return followed;
+    }
+    if (removed.has(id)) {
+      throw new CallError(`${field} names #${id}, but "${removed.get(id)}" was removed.`);
+    }
+    const wanted = searchable(id);
+    const titled = allNodes(root).filter((node) => searchable(node.text.trim()) === wanted || node.id === nodeSlug(id));
+    if (titled.length === 1) {
+      notes.push(`${field} takes ids: the id of "${titled[0].text}" is #${titled[0].id}.`);
+      return titled[0];
+    }
+    if (titled.length > 1) {
+      throw new CallError(`${titled.length} nodes are called "${given}": ${titled.map((node) => `${nameOf(node)}${node.parent ? ` under "${node.parent.text}"` : ""}`).join(", ")}. Give ${field} one of their ids.`);
+    }
+    const near = suggest(id, allNodes(root).map((node) => node.id));
+    const nearNode = near === undefined ? null : findNodeById2(root, near);
+    throw new CallError(`No node has the id "${id}".${nearNode ? ` Did you mean ${nameOf(nearNode)}?` : ""} read_map and find_nodes give every node's id.`);
+  };
+  const calls = {
+    read_map: (values, root, document2) => {
+      const start = typeof values.node_id === "string" ? resolve(root, values.node_id, "node_id") : root;
+      const levels = typeof values.depth === "number" ? values.depth : Infinity;
+      const { lines, complete } = readOutline(start, levels, readLimit);
+      const header = [];
+      if (start === root) {
+        const title = document2.options.title ?? root.text;
+        header.push(`The map "${title}" has ${count(1 + descendants(root), "node")}.`);
+      } else {
+        const path = getNodePath2(root, start.id);
+        header.push(`${nameOf(start)}, in ${path.slice(0, -1).map((node) => node.text).join(" › ")}, has ${count(descendants(start), "node")} under it.`);
+      }
+      const live = target.live;
+      if (live) {
+        const focused = live.getFocusedNode();
+        header.push(live.getViewMode() === "all" || !focused ? "The reader is looking at the whole map." : `The reader is looking at ${nameOf(focused)}.`);
+      }
+      const footer = complete ? [] : ["Nodes further down aren't shown: read a branch with read_map and its node_id, or search with find_nodes."];
+      return { text: [header.join(" "), ...lines, ...footer].join(`
+`), changed: false };
+    },
+    find_nodes: (values, root) => {
+      if (values.query === undefined && values.status === undefined && values.tag === undefined) {
+        throw new CallError("find_nodes needs something to look for: query, status, tag, or more than one.");
+      }
+      return { text: findNodes(root, values), changed: false };
+    },
+    read_node: (values, root) => {
+      const node = resolve(root, values.node_id, "node_id");
+      return { text: nodeDetails(root, node, getNodePath2(root, node.id)), changed: false };
+    },
+    add_nodes: (values, root) => {
+      const parent = resolve(root, values.parent_id, "parent_id");
+      const nodes = readNewNodes(values.outline);
+      const index = values.index;
+      const added = [];
+      nodes.forEach((input, offset) => {
+        const node = target.add(parent.id, input, index === undefined ? undefined : index + offset);
+        if (node) {
+          added.push(node);
+        }
+      });
+      if (added.length === 0) {
+        throw new CallError(`Nothing could be added under ${nameOf(parent)}.`);
+      }
+      for (const node of added) {
+        const twin = parent.children.find((sibling) => sibling !== node && !added.includes(sibling) && searchable(sibling.text) === searchable(node.text));
+        if (twin) {
+          notes.push(`${nameOf(node)} has the same title as ${nameOf(twin)} beside it. If it's there twice by mistake, remove one with remove_node.`);
+        }
+      }
+      const all = added.flatMap(allNodes);
+      const long = all.filter((node) => node.text.length > LONG_TITLE);
+      if (long.length > 0) {
+        notes.push(`${long.map(nameOf).join(", ")} ${long.length === 1 ? "has a long title" : "have long titles"}: a few words read best on the map, with the rest in the note.`);
+      }
+      notes.push(...brokenLinks(target.document()?.root ?? root, all));
+      return {
+        text: [`Added ${count(all.length, "node")} under ${nameOf(parent)}${placeOf(added, parent)}:`, ...added.flatMap((node) => outlineOf(node))].join(`
+`),
+        changed: added.length > 0
+      };
+    },
+    update_node: (values, root) => {
+      const node = resolve(root, values.node_id, "node_id");
+      const previousId = node.id;
+      const { changes, set, cleared, absent } = readChanges(values, root, node);
+      if (set.length === 0 && cleared.length === 0) {
+        if (absent.length === 0) {
+          throw new CallError(`update_node needs something to change: ${list(["text", ...ATTRIBUTES])}, or clear to remove attributes.`);
+        }
+        return { text: `${nameOf(node)} has no ${list(absent)} to remove: nothing changed.`, changed: false };
+      }
+      const updated = target.update(node.id, changes);
+      if (!updated) {
+        throw new CallError(`${nameOf(node)} couldn't be changed.`);
+      }
+      if (changes.note !== undefined) {
+        notes.push(...brokenLinks(root, [updated]));
+      }
+      const described = [set.length > 0 ? `set its ${list(set)}` : "", cleared.length > 0 ? `removed its ${list(cleared)}` : ""].filter((part) => part !== "").join("; ");
+      let text = `Changed ${nameOf(updated)}: ${described}.`;
+      if (updated.id !== previousId) {
+        renamed.set(previousId, updated.id);
+        text += ` Its id is #${updated.id} now: it was #${previousId}.`;
+      }
+      return { text, changed: true };
+    },
+    move_node: (values, root) => {
+      const node = resolve(root, values.node_id, "node_id");
+      if (values.parent_id === undefined && values.index === undefined) {
+        throw new CallError("move_node needs where to move the node: parent_id, index, or both.");
+      }
+      const path = getNodePath2(root, node.id);
+      if (path.length < 2) {
+        throw new CallError(`${nameOf(node)} is the root: it can't move, as every other node is under it.`);
+      }
+      const parent = values.parent_id === undefined ? path[path.length - 2] : resolve(root, values.parent_id, "parent_id");
+      if (parent === node) {
+        throw new CallError(`${nameOf(node)} can't go under itself. Give parent_id another node.`);
+      }
+      if (getNodePath2(root, parent.id).includes(node)) {
+        throw new CallError(`${nameOf(node)} can't go under ${nameOf(parent)}, which is inside it. Move ${nameOf(parent)} out of it first, or choose another parent.`);
+      }
+      const under = descendants(node);
+      const moved = target.move(node.id, parent.id, values.index);
+      if (!moved) {
+        throw new CallError(`${nameOf(node)} couldn't be moved.`);
+      }
+      return { text: `Moved ${nameOf(moved)}${under > 0 ? `, with the ${count(under, "node")} under it,` : ""} under ${nameOf(parent)}${placeOf([moved], parent)}.`, changed: true };
+    },
+    reorder_children: (values, root) => {
+      const parent = resolve(root, values.parent_id, "parent_id");
+      const children = [...parent.children];
+      if (children.length === 0) {
+        throw new CallError(`${nameOf(parent)} has no children to reorder.`);
+      }
+      const order = values.order.map((given) => childNamed(parent, given));
+      const twice = order.find((child, position) => order.indexOf(child) !== position);
+      if (twice) {
+        throw new CallError(`order lists ${nameOf(twice)} twice: list each child once.`);
+      }
+      const missing = children.filter((child) => !order.includes(child));
+      if (missing.length > 0) {
+        throw new CallError(`order needs all ${children.length} children of ${nameOf(parent)}, and leaves out ${missing.map(nameOf).join(", ")}.`);
+      }
+      if (order.every((child, position) => children[position] === child)) {
+        return { text: `The children of ${nameOf(parent)} are in that order already.`, changed: false };
+      }
+      order.forEach((child, position) => {
+        const current = findNodeById2(target.document()?.root ?? root, parent.id) ?? parent;
+        if (current.children[position]?.id !== child.id) {
+          target.move(child.id, parent.id, position);
+        }
+      });
+      return { text: `The children of ${nameOf(parent)} are in this order now: ${order.map(nameOf).join(", ")}.`, changed: true };
+    },
+    remove_node: (values, root) => {
+      const node = resolve(root, values.node_id, "node_id");
+      if (node === root) {
+        throw new CallError(`${nameOf(node)} is the root, and the map is all under it: it can't be removed. Remove the nodes under it one by one, or give it a new title with update_node.`);
+      }
+      const gone = allNodes(node);
+      if (!target.remove(node.id)) {
+        throw new CallError(`${nameOf(node)} couldn't be removed.`);
+      }
+      for (const each of gone) {
+        removed.set(each.id, each.text);
+      }
+      return { text: `Removed ${nameOf(node)}${gone.length > 1 ? ` and the ${count(gone.length - 1, "node")} under it` : ""}.`, changed: true };
+    },
+    show_node: (values, root) => {
+      const node = resolve(root, values.node_id, "node_id");
+      target.live?.flyTo(node.id);
+      return { text: `The map shows ${nameOf(node)} now, with its children around it.`, changed: false };
+    }
+  };
+  const childNamed = (parent, given) => {
+    const id = given.trim().replace(/^#/, "");
+    const child = parent.children.find((each) => each.id === id || each.id === renamed.get(id)) ?? parent.children.find((each) => searchable(each.text.trim()) === searchable(id));
+    if (!child) {
+      throw new CallError(`${given} isn't a child of ${nameOf(parent)}. Its children: ${parent.children.map(nameOf).join(", ")}.`);
+    }
+    return child;
+  };
+  const run = (name, input) => {
+    notes.length = 0;
+    const spec = TOOL_SPECS.find((each) => each.name === name);
+    const offered = specs.find((each) => each.name === name);
+    if (!offered) {
+      if (spec?.name === "show_node") {
+        return failure("show_node only works on a map on screen.");
+      }
+      if (spec) {
+        return failure(`${name} isn't available: this map can only be read.`);
+      }
+      const near = suggest(String(name), specs.map((each) => each.name));
+      return failure(`There's no tool "${String(name)}".${near === undefined ? "" : ` Did you mean ${near}?`} The tools are ${list(specs.map((each) => each.name))}.`);
+    }
+    const document2 = target.document();
+    if (!document2) {
+      return failure("There's no map to read yet: it hasn't been drawn.");
+    }
+    if (!offered.readOnly && target.newer) {
+      return failure("This map was written for a newer version of Orbit, and changing it here could lose what this version doesn't read. It can be read, but not changed.");
+    }
+    try {
+      const { values, ignored } = readInput(offered.name, offered.fields, input, offered.synonyms);
+      const outcome = calls[offered.name](values, document2.root, document2);
+      if (ignored.length > 0) {
+        notes.push(`${offered.name} doesn't take ${list(ignored.map((key) => `"${key}"`))}, so ${ignored.length === 1 ? "it was" : "they were"} left out. It takes ${list(Object.keys(offered.fields))}.`);
+      }
+      return { ok: true, text: [outcome.text, ...notes.map((note) => `Note: ${note}`)].join(`
+`), changed: outcome.changed };
+    } catch (error) {
+      if (error instanceof CallError || error instanceof InputError) {
+        return failure(error.message, offered);
+      }
+      throw error;
+    }
+  };
+  return {
+    definitions,
+    instructions: instructionsFor(target.live !== null, options.readOnly === true),
+    for: (provider) => formatDefinitions(definitions, provider),
+    run,
+    get document() {
+      return target.document();
+    }
+  };
+};
+var failure = (message, spec) => {
+  return { ok: false, text: spec && !spec.readOnly ? `${message} Nothing changed.` : message, changed: false };
+};
+var targetOf = (map) => {
+  if (isLiveMap(map)) {
+    return {
+      document: () => map.getDocument(),
+      add: (parentId, input, index) => map.addNode(parentId, input, index),
+      update: (id, changes) => map.updateNode(id, changes),
+      move: (id, parentId, index) => map.moveNode(id, parentId, index),
+      remove: (id) => map.removeNode(id),
+      live: map,
+      newer: false
+    };
+  }
+  const document2 = typeof map === "string" ? parseOrbit2(map) : map;
+  if (!document2 || typeof document2 !== "object" || !document2.root || !Array.isArray(document2.root.children)) {
+    throw new TypeError(`createMapTools() takes a map on screen (createOrbitMap's result, or <orbit-map>'s renderer), a parsed document, or a map's markdown or YAML, but got ${map === null ? "null" : typeof map}.`);
+  }
+  const extensions = new MapExtensions;
+  const colors = () => ({ count: branchPalette(resolvePalette(document2.options?.palette)).length, ownColor: (node) => extensions.color(node) });
+  return {
+    document: () => document2,
+    add: (parentId, input, index) => addToTree(document2.root, parentId, input, index, colors())?.node ?? null,
+    update: (id, changes) => updateInTree(document2.root, id, changes, colors())?.node ?? null,
+    move: (id, parentId, index) => moveInTree(document2.root, id, parentId, index, colors())?.node ?? null,
+    remove: (id) => removeFromTree(document2.root, id, colors())?.node ?? null,
+    live: null,
+    newer: (document2.diagnostics ?? []).some((diagnostic) => diagnostic.code === "unsupported-schema-version")
+  };
+};
+var isLiveMap = (map) => {
+  const candidate = map;
+  return typeof candidate === "object" && candidate !== null && typeof candidate.getDocument === "function" && typeof candidate.addNode === "function";
+};
+var instructionsFor = (live, readOnly) => {
+  const lines = readOnly ? [
+    "You can read the mind map with the map tools. Each node is an idea, with an id.",
+    "- read_map shows the map as an outline, with every node's id; find_nodes searches a big one, and read_node shows everything about one node, its whole note included.",
+    "- Answer from what the map says, and say when it doesn't say."
+  ] : [
+    "You can read and change the mind map with the map tools. Each node is an idea, with an id.",
+    "- Read the map before you change it: read_map shows it as an outline with every node's id, and find_nodes searches a big one. The other tools take those ids.",
+    "- Keep titles to a few words, and put details and longer text in the note.",
+    "- Write in the language the map is written in.",
+    "- Add several nodes, or whole branches, with one add_nodes call.",
+    "- A new title can give a node a new id: use the ids the latest results give.",
+    "- Remove nodes only when asked to."
+  ];
+  if (live) {
+    lines.push(readOnly ? "- show_node takes the reader to a node." : "- The reader sees each change on the map as you make it, and show_node takes them to a node.");
+  }
+  return lines.join(`
+`);
+};
+var allNodes = (root) => {
+  return [root, ...root.children.flatMap(allNodes)];
+};
+var placeOf = (nodes, parent) => {
+  const first = parent.children.indexOf(nodes[0]);
+  const last = parent.children.indexOf(nodes[nodes.length - 1]);
+  if (first > 0) {
+    return `, after ${nameOf(parent.children[first - 1])}`;
+  }
+  if (first === 0 && last < parent.children.length - 1) {
+    return `, first, before ${nameOf(parent.children[last + 1])}`;
+  }
+  return "";
+};
+var brokenLinks = (root, nodes) => {
+  const index = indexNodes(root);
+  const ids = [...index.keys()];
+  return nodes.flatMap((node) => nodeLinksOf(node).filter((href) => !findIndexedLinkedNode(index, href)).map((href) => {
+    const near = suggest(href.slice(1), ids);
+    return `${nameOf(node)} links to ${href}, but no node has that id.${near === undefined ? "" : ` Did you mean #${near}?`}`;
+  }));
+};
+var readNewNodes = (outline) => {
+  let source = outline.replace(/\r\n?/g, `
+`);
+  if (/^\s*---\s*\n/.test(source)) {
+    throw new CallError("outline takes the nodes to add as a markdown list, without frontmatter.");
+  }
+  let document2 = parseOrbitMarkdown2(source);
+  if (document2.diagnostics.some((diagnostic) => diagnostic.code === "no-structure")) {
+    source = source.split(`
+`).map((line) => line.trim()).filter((line) => line !== "").map((line) => `- ${line}`).join(`
+`);
+    document2 = parseOrbitMarkdown2(source);
+  }
+  const roots = document2.diagnostics.some((diagnostic) => diagnostic.code === "synthetic-root") ? document2.root.children : [document2.root];
+  const untitled = roots.flatMap(allNodes).find((node) => node.text.trim() === "");
+  if (roots.length === 0 || untitled) {
+    throw new CallError(untitled?.source ? `Line ${untitled.source.line} of outline has an item without a title.` : 'outline has no nodes: write them as a markdown list, like "- Social media\\n- Newsletter".');
+  }
+  const problems = document2.diagnostics.filter((diagnostic) => !OUTLINE_CODES_LEFT_OUT.has(diagnostic.code)).map((diagnostic) => formatDiagnostic2(diagnostic).replace(/[,;] kept as (?:a custom attribute|written)(?:, but not used)?/, ""));
+  if (problems.length > 0) {
+    throw new CallError(`outline doesn't read cleanly. Fix ${problems.length === 1 ? "this" : "these"}, and send it again:
+${problems.map((problem) => `- ${problem}`).join(`
+`)}
+Lines count from the outline's first line.`);
+  }
+  return roots.map(newNodeFrom);
+};
+var readChanges = (values, root, node) => {
+  const changes = {};
+  const set = [];
+  const clear = new Set(values.clear ?? []);
+  const cleared = [];
+  const absent = [];
+  const remove = (name) => {
+    if (node[name] === undefined) {
+      absent.push(name);
+      return;
+    }
+    changes[name] = undefined;
+    cleared.push(name);
+  };
+  for (const name of clear) {
+    if (values[name] !== undefined) {
+      throw new CallError(`${name} is both given and in clear: give it a value, or clear it.`);
+    }
+    remove(name);
+  }
+  if (values.text !== undefined) {
+    let text = String(values.text).replace(/\s+/g, " ").trim();
+    if (text === "") {
+      throw new CallError("text can't be empty: every node has a title. To take the node out of the map, use remove_node.");
+    }
+    const emoji = leadingEmoji(text);
+    if (emoji && values.icon === undefined && !clear.has("icon")) {
+      changes.icon = emoji.icon;
+      text = emoji.text;
+      set.push("icon");
+    }
+    changes.text = text;
+    set.push("title");
+  }
+  const text = (name) => {
+    const value = values[name];
+    if (value === undefined) {
+      return;
+    }
+    const written = name === "note" ? String(value).trim() : String(value).replace(/\s+/g, " ").trim();
+    if (written === "") {
+      remove(name);
+      return;
+    }
+    set.push(name);
+    return written;
+  };
+  const note = text("note");
+  if (note !== undefined) {
+    changes.note = note;
+  }
+  const status = text("status");
+  if (status !== undefined) {
+    changes.status = status;
+  }
+  if (values.priority !== undefined) {
+    changes.priority = values.priority;
+    set.push("priority");
+  }
+  if (values.tags !== undefined) {
+    const tags = [...new Set(values.tags.map((tag) => tag.replace(/^#/, "").trim()).filter((tag) => tag !== ""))];
+    if (tags.length === 0) {
+      remove("tags");
+    } else {
+      changes.tags = tags;
+      set.push("tags");
+    }
+  }
+  const icon = text("icon");
+  if (icon !== undefined) {
+    if (/^[\p{L}\p{N}][\p{L}\p{N}\s'-]+$/u.test(icon) || Array.from(icon).length > 8) {
+      throw new CallError(`icon takes an emoji, such as \uD83D\uDE80, not ${JSON.stringify(icon)}.`);
+    }
+    changes.icon = icon;
+  }
+  const color = text("color");
+  if (color !== undefined) {
+    const supports = typeof CSS !== "undefined" && typeof CSS.supports === "function" ? CSS.supports("color", color) : true;
+    if (!COLOR_SYNTAX.test(color) || !supports) {
+      throw new CallError(`"${color}" isn't a CSS color. Use a color name, such as tomato, or a code, such as #E8A33D.`);
+    }
+    changes.color = color;
+  }
+  const link = text("link");
+  if (link !== undefined) {
+    if (isNodeLink(link)) {
+      if (!findLinkedNode(root, link)) {
+        const near = suggest(link.slice(1), allNodes(root).map((each) => each.id));
+        throw new CallError(`link ${link} points at no node.${near === undefined ? "" : ` Did you mean #${near}?`} Node links are # and a node's id.`);
+      }
+    } else if (guardUrl(link, "link", false) === null) {
+      throw new CallError(`"${link}" isn't an address the map can open: use a web address, such as https://example.com.`);
+    }
+    changes.link = link;
+  }
+  for (const name of ["image", "video", "embed"]) {
+    const media = values[name];
+    if (media === undefined) {
+      continue;
+    }
+    const src = media.src.trim();
+    if (src === "") {
+      remove(name);
+      continue;
+    }
+    if (guardUrl(src, name, false) === null) {
+      throw new CallError(`${name} can't show "${src}": use a web address, such as https://example.com/${name === "image" ? "photo.jpg" : name === "video" ? "video.mp4" : "page"}.`);
+    }
+    const extras = Object.fromEntries(Object.entries(media).filter(([key, value]) => key !== "src" && value.trim() !== "").map(([key, value]) => [key, value.trim()]));
+    changes[name] = { src, ...extras };
+    set.push(name === "image" ? "picture" : name === "embed" ? "embedded page" : "video");
+  }
+  if (values.collapsed !== undefined) {
+    if (values.collapsed === true) {
+      changes.collapsed = true;
+      set.push("collapsed");
+    } else {
+      remove("collapsed");
+    }
+  }
+  return { changes, set, cleared, absent };
+};
+// src/core/other-apps/icons.ts
+var FREEMIND_ICONS = new Map(Object.entries({
+  idea: "\uD83D\uDCA1",
+  help: "❓",
+  yes: "❗",
+  messagebox_warning: "⚠️",
+  info: "ℹ️",
+  "stop-sign": "\uD83D\uDED1",
+  closed: "⛔",
+  button_ok: "✅",
+  button_cancel: "❌",
+  stop: "\uD83D\uDD34",
+  prepare: "\uD83D\uDFE1",
+  go: "\uD83D\uDFE2",
+  back: "⬅️",
+  forward: "➡️",
+  up: "⬆️",
+  down: "⬇️",
+  attach: "\uD83D\uDCCE",
+  ksmiletris: "\uD83D\uDE42",
+  "smiley-neutral": "\uD83D\uDE10",
+  "smiley-oh": "\uD83D\uDE2E",
+  "smiley-angry": "\uD83D\uDE20",
+  smily_bad: "\uD83D\uDE1E",
+  clanbomber: "\uD83D\uDCA3",
+  desktop_new: "\uD83D\uDCCC",
+  flag: "\uD83D\uDEA9",
+  "flag-black": "\uD83C\uDFF4",
+  "flag-blue": "\uD83D\uDEA9",
+  "flag-green": "\uD83D\uDEA9",
+  "flag-orange": "\uD83D\uDEA9",
+  "flag-pink": "\uD83D\uDEA9",
+  "flag-yellow": "\uD83D\uDEA9",
+  gohome: "\uD83C\uDFE0",
+  folder: "\uD83D\uDCC1",
+  korn: "\uD83D\uDCEB",
+  Mail: "✉️",
+  kmail: "\uD83D\uDCE7",
+  list: "\uD83D\uDCCB",
+  edit: "✏️",
+  pencil: "✏️",
+  kaddressbook: "☎️",
+  knotify: "\uD83C\uDFB5",
+  password: "\uD83D\uDD11",
+  encrypted: "\uD83D\uDD12",
+  decrypted: "\uD83D\uDD13",
+  wizard: "\uD83E\uDE84",
+  xmag: "\uD83D\uDD0D",
+  bell: "\uD83D\uDD14",
+  bookmark: "\uD83D\uDD16",
+  penguin: "\uD83D\uDC27",
+  licq: "\uD83C\uDF38",
+  freemind_butterfly: "\uD83E\uDD8B",
+  "broken-line": "\uD83D\uDC94",
+  calendar: "\uD83D\uDCC5",
+  clock: "⏰",
+  hourglass: "⏳",
+  launch: "\uD83D\uDE80",
+  family: "\uD83D\uDC6A",
+  female1: "\uD83D\uDC69",
+  female2: "\uD83D\uDC69",
+  male1: "\uD83D\uDC68",
+  male2: "\uD83D\uDC68",
+  fema: "\uD83D\uDC6B",
+  group: "\uD83D\uDC65",
+  bee: "\uD83D\uDC1D",
+  mindmap: "\uD83D\uDDFA️",
+  unchecked: "⬜",
+  checked: "✅"
+}));
+var FREEMIND_PROGRESS = new Map(Object.entries({ "0%": "todo", "25%": "active", "50%": "active", "75%": "active", "100%": "done", checked: "done", unchecked: "todo" }));
+var freeMindIcon = (name) => {
+  const priority = /^full-(\d)$/.exec(name);
+  if (priority) {
+    return { priority: Number(priority[1]) };
+  }
+  const progress = FREEMIND_PROGRESS.get(name);
+  if (progress) {
+    return { status: progress };
+  }
+  const emoji = /^emoji-([0-9A-Fa-f]{2,6}(?:-[0-9A-Fa-f]{2,6})*)$/.exec(name);
+  if (emoji) {
+    const codes = emoji[1].split("-").map((code) => parseInt(code, 16));
+    if (codes.every((code) => code > 0 && code <= 1114111)) {
+      return { icon: String.fromCodePoint(...codes) };
+    }
+  }
+  const icon = FREEMIND_ICONS.get(name);
+  return icon ? { icon } : null;
+};
+var XMIND_MARKERS = new Map(Object.entries({
+  "smiley-smile": "\uD83D\uDE42",
+  "smiley-laugh": "\uD83D\uDE04",
+  "smiley-angry": "\uD83D\uDE20",
+  "smiley-cry": "\uD83D\uDE22",
+  "smiley-surprise": "\uD83D\uDE2E",
+  "smiley-boring": "\uD83D\uDE10",
+  "arrow-up": "⬆️",
+  "arrow-down": "⬇️",
+  "arrow-left": "⬅️",
+  "arrow-right": "➡️",
+  "arrow-up-right": "↗️",
+  "arrow-down-right": "↘️",
+  "arrow-down-left": "↙️",
+  "arrow-up-left": "↖️",
+  "arrow-refresh": "\uD83D\uDD04",
+  "symbol-plus": "➕",
+  "symbol-minus": "➖",
+  "symbol-question": "❓",
+  "symbol-exclam": "❗",
+  "symbol-info": "ℹ️",
+  "symbol-wrong": "❌",
+  "symbol-right": "✅",
+  "symbol-attention": "⚠️",
+  "symbol-code": "\uD83D\uDCBB",
+  "symbol-pin": "\uD83D\uDCCC",
+  "symbol-heart": "❤️",
+  "symbol-star": "⭐",
+  "other-calendar": "\uD83D\uDCC5",
+  "other-email": "✉️",
+  "other-phone": "☎️",
+  "other-question": "❓",
+  "other-exclam": "❗",
+  "other-lightbulb": "\uD83D\uDCA1",
+  "other-clock": "⏰",
+  "other-people": "\uD83D\uDC65",
+  "other-money": "\uD83D\uDCB0",
+  "other-books": "\uD83D\uDCDA",
+  "other-music": "\uD83C\uDFB5",
+  "other-yes": "\uD83D\uDC4D",
+  "other-no": "\uD83D\uDC4E",
+  "other-hourglass": "⏳",
+  "other-flag": "\uD83D\uDEA9",
+  "other-star": "⭐",
+  "other-coffee-cup": "☕",
+  "other-bomb": "\uD83D\uDCA3",
+  "other-mic": "\uD83C\uDFA4",
+  "other-phone-call": "\uD83D\uDCDE",
+  "other-map": "\uD83D\uDDFA️",
+  "other-code": "\uD83D\uDCBB",
+  "other-search": "\uD83D\uDD0D",
+  "other-dollar": "\uD83D\uDCB5",
+  "other-heart": "❤️",
+  c_symbol_like: "\uD83D\uDC4D",
+  c_symbol_dislike: "\uD83D\uDC4E",
+  c_symbol_heart: "❤️",
+  c_symbol_star: "⭐",
+  c_symbol_question: "❓",
+  c_symbol_exclam: "❗",
+  c_symbol_pin: "\uD83D\uDCCC",
+  c_symbol_idea: "\uD83D\uDCA1",
+  c_symbol_check: "✅",
+  c_symbol_cross: "❌",
+  c_symbol_fire: "\uD83D\uDD25",
+  c_symbol_trophy: "\uD83C\uDFC6"
+}));
+var XMIND_FAMILIES = new Map(Object.entries({
+  flag: "\uD83D\uDEA9",
+  star: "⭐",
+  people: "\uD83D\uDC64",
+  tag: "\uD83C\uDFF7️",
+  month: "\uD83D\uDCC5",
+  week: "\uD83D\uDCC5",
+  "half-star": "⭐"
+}));
+var XMIND_TASKS = new Map(Object.entries({
+  "task-start": "todo",
+  "task-oct": "active",
+  "task-quarter": "active",
+  "task-3oct": "active",
+  "task-half": "active",
+  "task-5oct": "active",
+  "task-3quar": "active",
+  "task-7oct": "active",
+  "task-done": "done",
+  "task-pause": "paused"
+}));
+var xmindMarker = (markerId) => {
+  const priority = /^priority-(\d)$/.exec(markerId);
+  if (priority) {
+    return { priority: Number(priority[1]) };
+  }
+  const status = XMIND_TASKS.get(markerId);
+  if (status) {
+    return { status };
+  }
+  const icon = XMIND_MARKERS.get(markerId);
+  if (icon) {
+    return { icon };
+  }
+  const family = [...XMIND_FAMILIES.keys()].sort((first, second) => second.length - first.length).find((name) => markerId.startsWith(`${name}-`));
+  return family ? { icon: XMIND_FAMILIES.get(family) } : null;
+};
+
+// src/core/other-apps/markup.ts
+class MarkupError extends Error {
+  line;
+  constructor(message, line) {
+    super(`${message} (line ${line})`);
+    this.name = "MarkupError";
+    this.line = line;
+  }
+}
+var MAX_MARKUP_LENGTH = 64 * 1024 * 1024;
+var MAX_MARKUP_DEPTH = 1000;
+var XML_ENTITIES = { lt: "<", gt: ">", amp: "&", quot: '"', apos: "'" };
+var HTML_ENTITIES = {
+  ...XML_ENTITIES,
+  nbsp: " ",
+  copy: "©",
+  reg: "®",
+  trade: "™",
+  hellip: "…",
+  mdash: "—",
+  ndash: "–",
+  lsquo: "‘",
+  rsquo: "’",
+  ldquo: "“",
+  rdquo: "”",
+  laquo: "«",
+  raquo: "»",
+  bull: "•",
+  middot: "·",
+  deg: "°",
+  plusmn: "±",
+  times: "×",
+  divide: "÷",
+  euro: "€",
+  pound: "£",
+  yen: "¥",
+  cent: "¢",
+  sect: "§",
+  para: "¶",
+  iexcl: "¡",
+  iquest: "¿",
+  ordf: "ª",
+  ordm: "º",
+  acute: "´",
+  uml: "¨",
+  shy: "­",
+  frac12: "½",
+  frac14: "¼",
+  frac34: "¾",
+  sup1: "¹",
+  sup2: "²",
+  sup3: "³",
+  micro: "µ",
+  larr: "←",
+  rarr: "→",
+  uarr: "↑",
+  darr: "↓",
+  harr: "↔",
+  rArr: "⇒",
+  lArr: "⇐",
+  hArr: "⇔",
+  aacute: "á",
+  eacute: "é",
+  iacute: "í",
+  oacute: "ó",
+  uacute: "ú",
+  yacute: "ý",
+  Aacute: "Á",
+  Eacute: "É",
+  Iacute: "Í",
+  Oacute: "Ó",
+  Uacute: "Ú",
+  Yacute: "Ý",
+  agrave: "à",
+  egrave: "è",
+  igrave: "ì",
+  ograve: "ò",
+  ugrave: "ù",
+  Agrave: "À",
+  Egrave: "È",
+  Igrave: "Ì",
+  Ograve: "Ò",
+  Ugrave: "Ù",
+  acirc: "â",
+  ecirc: "ê",
+  icirc: "î",
+  ocirc: "ô",
+  ucirc: "û",
+  Acirc: "Â",
+  Ecirc: "Ê",
+  Icirc: "Î",
+  Ocirc: "Ô",
+  Ucirc: "Û",
+  auml: "ä",
+  euml: "ë",
+  iuml: "ï",
+  ouml: "ö",
+  uuml: "ü",
+  yuml: "ÿ",
+  Auml: "Ä",
+  Euml: "Ë",
+  Iuml: "Ï",
+  Ouml: "Ö",
+  Uuml: "Ü",
+  atilde: "ã",
+  otilde: "õ",
+  ntilde: "ñ",
+  Atilde: "Ã",
+  Otilde: "Õ",
+  Ntilde: "Ñ",
+  ccedil: "ç",
+  Ccedil: "Ç",
+  aring: "å",
+  Aring: "Å",
+  aelig: "æ",
+  AElig: "Æ",
+  oslash: "ø",
+  Oslash: "Ø",
+  szlig: "ß",
+  thorn: "þ",
+  THORN: "Þ",
+  eth: "ð",
+  ETH: "Ð",
+  oelig: "œ",
+  OElig: "Œ"
+};
+var VOID_ELEMENTS = new Set(["area", "base", "br", "col", "embed", "hr", "img", "input", "link", "meta", "param", "source", "track", "wbr"]);
+var RAW_TEXT_ELEMENTS = new Set(["script", "style"]);
+var NAME = /^[^\s/>=]+/;
+var ATTRIBUTE = /([^\s=/>]+)(?:\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s"'>]+)))?/y;
+var decodeMarkup = (bytes) => {
+  if (bytes[0] === 239 && bytes[1] === 187 && bytes[2] === 191) {
+    return new TextDecoder("utf-8").decode(bytes.subarray(3));
+  }
+  if (bytes[0] === 255 && bytes[1] === 254) {
+    return new TextDecoder("utf-16le").decode(bytes.subarray(2));
+  }
+  if (bytes[0] === 254 && bytes[1] === 255) {
+    return new TextDecoder("utf-16be").decode(bytes.subarray(2));
+  }
+  if (bytes[0] === 60 && bytes[1] === 0) {
+    return new TextDecoder("utf-16le").decode(bytes);
+  }
+  if (bytes[0] === 0 && bytes[1] === 60) {
+    return new TextDecoder("utf-16be").decode(bytes);
+  }
+  const start = String.fromCharCode(...bytes.subarray(0, 200));
+  const declared = /^\s*<\?xml[^>]*\bencoding\s*=\s*["']([A-Za-z0-9._:-]+)["']/.exec(start)?.[1];
+  if (declared && !/^utf-?8$/i.test(declared)) {
+    try {
+      return new TextDecoder(declared).decode(bytes);
+    } catch {}
+  }
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return new TextDecoder(declared ? "utf-8" : "windows-1252").decode(bytes);
+  }
+};
+var parseXml = (text) => {
+  const root = readMarkup(text, { html: false });
+  const elements = root.children.filter(isElement);
+  if (elements.length !== 1) {
+    throw new MarkupError(elements.length === 0 ? "No element in the file" : "More than one top element", 1);
+  }
+  return elements[0];
+};
+var parseHtml = (text) => {
+  return readMarkup(text, { html: true });
+};
+var isElement = (node) => {
+  return typeof node !== "string";
+};
+var childElements = (element, localName) => {
+  return element.children.filter((child) => isElement(child) && (localName === undefined || child.localName === localName));
+};
+var childElement = (element, localName) => {
+  return element.children.find((child) => isElement(child) && child.localName === localName);
+};
+var attributeOf = (element, localName) => {
+  if (Object.prototype.hasOwnProperty.call(element.attributes, localName)) {
+    return element.attributes[localName];
+  }
+  for (const [name, value] of Object.entries(element.attributes)) {
+    if (localPart(name) === localName) {
+      return value;
+    }
+  }
+  return;
+};
+var textContent = (node) => {
+  if (!isElement(node)) {
+    return node;
+  }
+  let text = "";
+  const pending = [node];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    if (isElement(next)) {
+      for (let index = next.children.length - 1;index >= 0; index--) {
+        pending.push(next.children[index]);
+      }
+    } else {
+      text += next;
+    }
+  }
+  return text;
+};
+var localPart = (name) => {
+  const colon = name.indexOf(":");
+  return colon === -1 ? name : name.slice(colon + 1);
+};
+var lineAt = (text, index) => {
+  let line = 1;
+  for (let position = text.indexOf(`
+`);position !== -1 && position < index; position = text.indexOf(`
+`, position + 1)) {
+    line += 1;
+  }
+  return line;
+};
+var readMarkup = (input, mode) => {
+  if (input.length > MAX_MARKUP_LENGTH) {
+    throw new MarkupError(`The file is larger than ${MAX_MARKUP_LENGTH / 1024 / 1024} MB of text`, 1);
+  }
+  const text = input.replace(/^\ufeff/, "").replace(/\r\n?/g, `
+`);
+  const fragment = { name: "#fragment", localName: "#fragment", attributes: {}, children: [] };
+  const open = [fragment];
+  const entities = mode.html ? HTML_ENTITIES : XML_ENTITIES;
+  let index = 0;
+  const fail = (message, at) => {
+    throw new MarkupError(message, lineAt(text, at));
+  };
+  const current = () => open[open.length - 1];
+  const addText = (value) => {
+    if (value === "") {
+      return;
+    }
+    const children = current().children;
+    const last = children.length - 1;
+    if (last >= 0 && typeof children[last] === "string") {
+      children[last] = children[last] + value;
+    } else {
+      children.push(value);
+    }
+  };
+  while (index < text.length) {
+    const tag = text.indexOf("<", index);
+    if (tag === -1) {
+      addText(decodeEntities(text.slice(index), entities));
+      break;
+    }
+    if (tag > index) {
+      addText(decodeEntities(text.slice(index, tag), entities));
+    }
+    index = tag;
+    if (text.startsWith("<!--", index)) {
+      const end = text.indexOf("-->", index + 4);
+      if (end === -1) {
+        if (mode.html) {
+          break;
+        }
+        fail("A comment that never ends", index);
+      }
+      index = end + 3;
+      continue;
+    }
+    if (text.startsWith("<![CDATA[", index)) {
+      const end = text.indexOf("]]>", index + 9);
+      if (end === -1) {
+        fail("A CDATA section that never ends", index);
+      }
+      addText(text.slice(index + 9, end));
+      index = end + 3;
+      continue;
+    }
+    if (text.startsWith("<?", index)) {
+      const end = text.indexOf("?>", index + 2);
+      if (end === -1) {
+        fail("A processing instruction that never ends", index);
+      }
+      index = end + 2;
+      continue;
+    }
+    if (text.startsWith("<!", index)) {
+      index = skipDeclaration(text, index, fail);
+      continue;
+    }
+    if (text.startsWith("</", index)) {
+      const end = text.indexOf(">", index + 2);
+      if (end === -1) {
+        fail("An end tag that never closes", index);
+      }
+      const name = text.slice(index + 2, end).trim();
+      closeElement(open, name, mode, () => fail(`</${name}> doesn't match <${current().name}>`, index));
+      index = end + 1;
+      continue;
+    }
+    const nameMatch = NAME.exec(text.slice(index + 1, index + 257));
+    if (!nameMatch || !/^[\p{L}_:]/u.test(nameMatch[0])) {
+      if (mode.html) {
+        addText("<");
+        index += 1;
+        continue;
+      }
+      fail('A "<" that starts no tag', index);
+    }
+    const name = nameMatch[0];
+    const [attributes, afterAttributes, selfClosing] = readAttributes(text, index + 1 + name.length, entities, mode, fail);
+    const localName = mode.html ? localPart(name).toLowerCase() : localPart(name);
+    const element = { name, localName, attributes, children: [] };
+    current().children.push(element);
+    index = afterAttributes;
+    if (mode.html && RAW_TEXT_ELEMENTS.has(localName)) {
+      const end = text.toLowerCase().indexOf(`</${localName}`, index);
+      index = end === -1 ? text.length : text.indexOf(">", end) + 1 || text.length;
+      continue;
+    }
+    if (selfClosing || mode.html && VOID_ELEMENTS.has(localName)) {
+      continue;
+    }
+    if (open.length > MAX_MARKUP_DEPTH) {
+      fail(`Elements nested more than ${MAX_MARKUP_DEPTH} deep`, index);
+    }
+    open.push(element);
+  }
+  if (!mode.html && open.length > 1) {
+    fail(`<${current().name}> is never closed`, text.length);
+  }
+  return fragment;
+};
+var readAttributes = (text, start, entities, mode, fail) => {
+  const attributes = {};
+  let index = start;
+  while (index < text.length) {
+    while (index < text.length && /\s/.test(text[index])) {
+      index += 1;
+    }
+    if (text[index] === ">") {
+      return [attributes, index + 1, false];
+    }
+    if (text.startsWith("/>", index)) {
+      return [attributes, index + 2, true];
+    }
+    if (text[index] === "/") {
+      index += 1;
+      continue;
+    }
+    ATTRIBUTE.lastIndex = index;
+    const match = ATTRIBUTE.exec(text);
+    if (!match || match[0].length === 0) {
+      fail("A tag that never closes", start);
+    }
+    const [whole, name, doubleQuoted, singleQuoted, unquoted] = match;
+    if (unquoted !== undefined && !mode.html) {
+      fail(`The value of ${name} has no quotes`, index);
+    }
+    const raw = doubleQuoted ?? singleQuoted ?? unquoted ?? "";
+    attributes[name] = decodeEntities(mode.html ? raw : raw.replace(/[\t\n]/g, " "), entities);
+    index += whole.length;
+  }
+  return fail("A tag that never closes", start);
+};
+var skipDeclaration = (text, start, fail) => {
+  let depth = 0;
+  let quote = null;
+  for (let index = start + 2;index < text.length; index++) {
+    const character = text[index];
+    if (quote) {
+      if (character === quote) {
+        quote = null;
+      }
+    } else if (character === '"' || character === "'") {
+      quote = character;
+    } else if (character === "[") {
+      depth += 1;
+    } else if (character === "]") {
+      depth -= 1;
+    } else if (character === ">" && depth <= 0) {
+      return index + 1;
+    }
+  }
+  return fail("A declaration that never ends", start);
+};
+var closeElement = (open, name, mode, mismatch) => {
+  const top = open[open.length - 1];
+  if (open.length > 1 && (top.name === name || mode.html && top.localName === localPart(name).toLowerCase())) {
+    open.pop();
+    return;
+  }
+  if (!mode.html) {
+    mismatch();
+  }
+  const wanted = localPart(name).toLowerCase();
+  for (let depth = open.length - 1;depth > 0; depth--) {
+    if (open[depth].localName === wanted) {
+      open.length = depth;
+      return;
+    }
+  }
+};
+var decodeEntities = (text, entities) => {
+  if (!text.includes("&")) {
+    return text;
+  }
+  return text.replace(/&(#[xX][0-9a-fA-F]{1,6}|#[0-9]{1,7}|[A-Za-z][A-Za-z0-9]{1,31});/g, (whole, reference) => {
+    if (reference.startsWith("#")) {
+      const code = reference[1] === "x" || reference[1] === "X" ? parseInt(reference.slice(2), 16) : parseInt(reference.slice(1), 10);
+      return code > 0 && code <= 1114111 && !(code >= 55296 && code <= 57343) ? String.fromCodePoint(code) : whole;
+    }
+    return Object.prototype.hasOwnProperty.call(entities, reference) ? entities[reference] : whole;
+  });
+};
+
+// src/core/other-apps/notes.ts
+var BLOCK_CONTAINERS = new Set([
+  "html",
+  "body",
+  "div",
+  "p",
+  "section",
+  "article",
+  "header",
+  "footer",
+  "main",
+  "aside",
+  "nav",
+  "center",
+  "figure",
+  "figcaption",
+  "address",
+  "details",
+  "summary",
+  "dl",
+  "dt",
+  "dd",
+  "form",
+  "fieldset",
+  "tbody",
+  "thead",
+  "tfoot",
+  "caption",
+  "#fragment"
+]);
+var SKIPPED = new Set(["head", "title", "script", "style", "meta", "link", "template", "object", "iframe", "svg", "math"]);
+var HEADINGS = new Map([["h1", 1], ["h2", 2], ["h3", 3], ["h4", 4], ["h5", 5], ["h6", 6]]);
+var INLINE_KINDS = new Map([
+  ["strong", "strong"],
+  ["b", "strong"],
+  ["em", "emphasis"],
+  ["i", "emphasis"],
+  ["cite", "emphasis"],
+  ["s", "strike"],
+  ["strike", "strike"],
+  ["del", "strike"]
+]);
+var CODE_ELEMENTS = new Set(["code", "tt", "kbd", "samp", "var"]);
+var isKeptLink = (href) => {
+  return /^(https?:\/\/|mailto:)\S+$/i.test(href) || /^#\S+$/.test(href);
+};
+var keptAddress = (href) => {
+  const address = href.trim();
+  if (/^www\.[^\s/]+\.\S+$/i.test(address)) {
+    return `https://${address}`;
+  }
+  return isKeptLink(address) ? address : null;
+};
+var isWebAddress = (src) => {
+  return /^https?:\/\/\S+$/i.test(src);
+};
+var noteFromHtml = (html, addresses = {}) => {
+  const element = typeof html === "string" ? parseHtml(html) : html;
+  return noteFromBlocks(readBlocks(element.children, addresses), addresses);
+};
+var noteFromPlainText = (text) => {
+  const cleaned = (text ?? "").replace(/\r\n?/g, `
+`).split(`
+`).map((line) => line.replace(/[ \t]+$/, "")).join(`
+`).replace(/^\n+|\n+$/g, "");
+  if (cleaned.trim() === "") {
+    return;
+  }
+  const paragraphs = cleaned.split(/\n{2,}/);
+  const readsTheSame = paragraphs.every((paragraph) => !paragraph.includes(`
+`) && isInertText(paragraph) && isInertLineStart(paragraph));
+  return { text: cleaned, format: readsTheSame ? "markdown" : "plain" };
+};
+var noteFromBlocks = (blocks, addresses = {}) => {
+  const kept = blocks.filter((block) => !isEmptyBlock(block));
+  if (kept.length === 0) {
+    return;
+  }
+  const writer = new MarkdownWriter(addresses);
+  const markdown = writer.blocks(kept);
+  if (writer.inert && markdown.trim() !== "") {
+    return { text: markdown, format: "markdown" };
+  }
+  const plain = plainBlocks(kept).trim();
+  return plain === "" ? undefined : { text: plain, format: "plain" };
+};
+var joinNotes = (notes) => {
+  const present = notes.filter((note) => note !== undefined && note.text.trim() !== "");
+  if (present.length <= 1) {
+    return present[0];
+  }
+  return {
+    text: present.map((note) => note.text).join(`
+
+`),
+    format: present.every((note) => note.format === "markdown") ? "markdown" : "plain"
+  };
+};
+var titleFromHtml = (html) => {
+  const element = typeof html === "string" ? parseHtml(html) : html;
+  const pieces = inlineFrom(element.children, {});
+  const link = firstLink(pieces);
+  return { text: plainInline(pieces, false, false).replace(/\s+/g, " ").trim(), ...link ? { link } : {} };
+};
+var firstLink = (pieces) => {
+  for (const piece of pieces) {
+    if (piece.kind === "link") {
+      return piece.href;
+    }
+    if (piece.kind === "strong" || piece.kind === "emphasis" || piece.kind === "strike") {
+      const inner = firstLink(piece.children);
+      if (inner) {
+        return inner;
+      }
+    }
+  }
+  return;
+};
+var readBlocks = (nodes, addresses) => {
+  const blocks = [];
+  let inline = [];
+  const flush = () => {
+    const trimmed = trimInline(inline);
+    if (trimmed.length > 0) {
+      blocks.push({ kind: "paragraph", inline: trimmed });
+    }
+    inline = [];
+  };
+  for (const node of nodes) {
+    if (!isElement(node)) {
+      inline.push(...inlineFrom([node], addresses));
+      continue;
+    }
+    const name = node.localName.toLowerCase();
+    if (SKIPPED.has(name)) {
+      continue;
+    }
+    const headingLevel = HEADINGS.get(name);
+    if (headingLevel !== undefined) {
+      flush();
+      const content = trimInline(inlineFrom(node.children, addresses).map((piece) => piece.kind === "break" ? { kind: "text", text: " " } : piece));
+      if (content.length > 0) {
+        blocks.push({ kind: "heading", level: headingLevel, inline: content });
+      }
+    } else if (name === "ul" || name === "ol" || name === "menu" || name === "dir") {
+      flush();
+      const items = node.children.filter((child) => isElement(child) || child.trim() !== "").map((child) => readBlocks(isElement(child) && child.localName.toLowerCase() === "li" ? child.children : [child], addresses)).filter((item) => item.some((block) => !isEmptyBlock(block)));
+      if (items.length > 0) {
+        blocks.push({ kind: "list", ordered: name === "ol", items });
+      }
+    } else if (name === "li") {
+      flush();
+      blocks.push({ kind: "list", ordered: false, items: [readBlocks(node.children, addresses)] });
+    } else if (name === "blockquote") {
+      flush();
+      const quoted = readBlocks(node.children, addresses);
+      if (quoted.length > 0) {
+        blocks.push({ kind: "quote", blocks: quoted });
+      }
+    } else if (name === "pre") {
+      flush();
+      const code = textContent(node).replace(/^\n/, "").replace(/\s+$/, "");
+      if (code !== "") {
+        blocks.push({ kind: "code", text: code });
+      }
+    } else if (name === "table") {
+      flush();
+      blocks.push(...tableRows(node, addresses));
+    } else if (name === "hr") {
+      flush();
+    } else if (BLOCK_CONTAINERS.has(name)) {
+      flush();
+      blocks.push(...readBlocks(node.children, addresses));
+    } else {
+      inline.push(...inlineFrom([node], addresses));
+    }
+  }
+  flush();
+  return blocks;
+};
+var tableRows = (table, addresses) => {
+  const rows = [];
+  const pending = [table];
+  while (pending.length > 0) {
+    const element = pending.shift();
+    for (const child of childElements(element)) {
+      const name = child.localName.toLowerCase();
+      if (name === "tr") {
+        const cells = childElements(child).filter((cell) => /^t[dh]$/.test(cell.localName.toLowerCase()));
+        const inline = [];
+        for (const cell of cells) {
+          const content = trimInline(inlineFrom(cell.children, addresses).map((piece) => piece.kind === "break" ? { kind: "text", text: " " } : piece));
+          if (content.length > 0) {
+            if (inline.length > 0) {
+              inline.push({ kind: "text", text: " · " });
+            }
+            inline.push(...content);
+          }
+        }
+        if (inline.length > 0) {
+          rows.push({ kind: "paragraph", inline });
+        }
+      } else if (name !== "td" && name !== "th") {
+        pending.push(child);
+      }
+    }
+  }
+  return rows;
+};
+var inlineFrom = (nodes, addresses) => {
+  const pieces = [];
+  for (const node of nodes) {
+    if (!isElement(node)) {
+      const text = node.replace(/[ \t\n\r\f]+/g, " ");
+      if (text !== "") {
+        pieces.push({ kind: "text", text });
+      }
+      continue;
+    }
+    const name = node.localName.toLowerCase();
+    if (SKIPPED.has(name)) {
+      continue;
+    }
+    if (name === "br") {
+      pieces.push({ kind: "break" });
+    } else if (name === "img") {
+      const src = node.attributes.src ?? Object.entries(node.attributes).find(([key]) => key.endsWith(":src"))?.[1] ?? "";
+      pieces.push({ kind: "image", src, alt: (node.attributes.alt ?? node.attributes.title ?? "").trim() });
+    } else if (INLINE_KINDS.has(name)) {
+      pieces.push({ kind: INLINE_KINDS.get(name), children: inlineFrom(node.children, addresses) });
+    } else if (CODE_ELEMENTS.has(name)) {
+      pieces.push({ kind: "code", text: textContent(node).replace(/\s+/g, " ") });
+    } else if (name === "a") {
+      const href = (node.attributes.href ?? Object.entries(node.attributes).find(([key]) => key.endsWith(":href"))?.[1] ?? "").trim();
+      const children = inlineFrom(node.children, addresses);
+      if (href) {
+        pieces.push({ kind: "link", href, children });
+      } else {
+        pieces.push(...children);
+      }
+    } else {
+      const block = BLOCK_CONTAINERS.has(name) || HEADINGS.has(name) || name === "li" || name === "tr";
+      const content = inlineFrom(node.children, addresses);
+      if (block && pieces.length > 0) {
+        pieces.push({ kind: "break" });
+      }
+      pieces.push(...content);
+    }
+  }
+  return pieces;
+};
+var trimInline = (pieces) => {
+  const result = [...pieces];
+  while (result.length > 0 && isBlankPiece(result[0])) {
+    result.shift();
+  }
+  while (result.length > 0 && isBlankPiece(result[result.length - 1])) {
+    result.pop();
+  }
+  if (result.length > 0 && result[0].kind === "text") {
+    result[0] = { kind: "text", text: result[0].text.replace(/^ +/, "") };
+  }
+  const last = result.length - 1;
+  if (last >= 0 && result[last].kind === "text") {
+    result[last] = { kind: "text", text: result[last].text.replace(/ +$/, "") };
+  }
+  return result;
+};
+var isBlankPiece = (piece) => {
+  return piece.kind === "break" || piece.kind === "text" && piece.text.trim() === "";
+};
+var isEmptyBlock = (block) => {
+  switch (block.kind) {
+    case "paragraph":
+    case "heading":
+      return plainInline(block.inline, false).trim() === "" && !block.inline.some((piece) => piece.kind === "image" && piece.src !== "");
+    case "list":
+      return block.items.every((item) => item.every(isEmptyBlock));
+    case "quote":
+      return block.blocks.every(isEmptyBlock);
+    case "code":
+      return block.text.trim() === "";
+  }
+};
+var ACTIVE_CHARACTERS = /[`*_~[\]<\\]|&#?[A-Za-z0-9]+;/;
+var ACTIVE_LINE_START = /^(\s{4,}|\s*(#{1,6}(\s|$)|>|[-*+](\s|$)|\d{1,9}[.)](\s|$)|```|~~~|[-=_]{3,}\s*$))/;
+var isInertText = (text) => {
+  return !ACTIVE_CHARACTERS.test(text);
+};
+var isInertLineStart = (line) => {
+  return !ACTIVE_LINE_START.test(line);
+};
+
+class MarkdownWriter {
+  inert = true;
+  addresses;
+  constructor(addresses) {
+    this.addresses = addresses;
+  }
+  blocks(blocks) {
+    return blocks.map((block) => this.block(block)).filter((text) => text !== "").join(`
+
+`);
+  }
+  block(block) {
+    switch (block.kind) {
+      case "paragraph": {
+        const lines = this.inlineLines(block.inline);
+        return lines.map((line) => this.lineStart(line)).filter((line) => line !== "").join(`
+
+`);
+      }
+      case "heading": {
+        const text = this.inlineLines(block.inline).join(" ").trim();
+        return text === "" ? "" : `${"#".repeat(block.level)} ${text}`;
+      }
+      case "list":
+        return this.list(block, 0);
+      case "quote": {
+        const inner = this.blocks(block.blocks);
+        return inner.split(`
+`).map((line) => line === "" ? ">" : `> ${line}`).join(`
+`);
+      }
+      case "code": {
+        if (/^\s*(```|~~~)/m.test(block.text)) {
+          this.inert = false;
+        }
+        return `\`\`\`
+${block.text}
+\`\`\``;
+      }
+    }
+  }
+  list(list, indent) {
+    const lines = [];
+    list.items.forEach((item, index) => {
+      const marker = list.ordered ? `${index + 1}.` : "-";
+      const nested = [];
+      const words = [];
+      for (const block of item) {
+        if (block.kind === "list") {
+          nested.push(this.list(block, indent + marker.length + 1));
+        } else {
+          words.push(this.flatText(block));
+        }
+      }
+      const text = words.filter((word) => word !== "").join(" ");
+      lines.push(`${" ".repeat(indent)}${marker} ${text}`.trimEnd());
+      lines.push(...nested);
+    });
+    return lines.join(`
+`);
+  }
+  flatText(block) {
+    switch (block.kind) {
+      case "paragraph":
+      case "heading":
+        return this.inlineLines(block.inline).join(" ").trim();
+      case "quote":
+        return block.blocks.map((inner) => this.flatText(inner)).join(" ");
+      case "code":
+        return this.code(block.text.replace(/\s+/g, " "));
+      case "list":
+        return this.list(block, 0);
+    }
+  }
+  lineStart(line) {
+    if (!isInertLineStart(line)) {
+      this.inert = false;
+    }
+    return line.trim();
+  }
+  inlineLines(pieces) {
+    return this.inlineText(pieces).split(`
+`).map((line) => line.replace(/ {2,}/g, " ").trim());
+  }
+  inlineText(pieces) {
+    return mergeNeighbors(pieces).map((piece) => piece.kind === "break" ? `
+` : this.inline(piece)).join("");
+  }
+  inline(piece) {
+    switch (piece.kind) {
+      case "text":
+        if (!isInertText(piece.text)) {
+          this.inert = false;
+        }
+        return piece.text;
+      case "break":
+        return " ";
+      case "strong":
+      case "emphasis":
+      case "strike": {
+        const inner = this.inlineText(piece.children).replace(/\n/g, " ").replace(/ {2,}/g, " ");
+        const [, before, middle, after] = /^(\s*)([\s\S]*?)(\s*)$/.exec(inner);
+        if (middle === "") {
+          return inner;
+        }
+        const mark = piece.kind === "strong" ? "**" : piece.kind === "emphasis" ? "*" : "~~";
+        return `${before}${mark}${middle}${mark}${after}`;
+      }
+      case "code":
+        return this.code(piece.text);
+      case "link": {
+        const label = this.inlineLines(piece.children).join(" ").trim();
+        const href = (this.addresses.link ?? defaultLink)(piece.href);
+        if (!href) {
+          return label;
+        }
+        return label === "" || label === href ? `<${encodeAddress(href)}>` : `[${label}](${encodeAddress(href)})`;
+      }
+      case "image": {
+        const src = piece.src ? (this.addresses.picture ?? defaultPicture)(piece.src) : null;
+        if (!src) {
+          if (!isInertText(piece.alt)) {
+            this.inert = false;
+          }
+          return piece.alt;
+        }
+        if (!isInertText(piece.alt)) {
+          this.inert = false;
+        }
+        return `![${piece.alt}](${encodeAddress(src)})`;
+      }
+    }
+  }
+  code(text) {
+    const trimmed = text.trim();
+    if (trimmed === "") {
+      return "";
+    }
+    if (trimmed.includes("`")) {
+      this.inert = false;
+    }
+    return `\`${trimmed}\``;
+  }
+}
+var mergeNeighbors = (pieces) => {
+  const merged = [];
+  for (const piece of pieces) {
+    const last = merged[merged.length - 1];
+    if (last && last.kind === piece.kind && (piece.kind === "strong" || piece.kind === "emphasis" || piece.kind === "strike")) {
+      merged[merged.length - 1] = { kind: piece.kind, children: [...last.children, ...piece.children] };
+    } else {
+      merged.push(piece);
+    }
+  }
+  return merged;
+};
+var defaultLink = (href) => {
+  return keptAddress(href);
+};
+var defaultPicture = (src) => {
+  return isWebAddress(src) ? src : null;
+};
+var encodeAddress = (address) => {
+  return address.replace(/ /g, "%20").replace(/\(/g, "%28").replace(/\)/g, "%29").replace(/</g, "%3C").replace(/>/g, "%3E");
+};
+var plainBlocks = (blocks, indent = "") => {
+  return blocks.map((block) => plainBlock(block, indent)).filter((text) => text.trim() !== "").join(`
+
+`);
+};
+var plainBlock = (block, indent) => {
+  switch (block.kind) {
+    case "paragraph":
+      return prefixLines(plainInline(block.inline, true), indent);
+    case "heading":
+      return prefixLines(plainInline(block.inline, false).trim(), indent);
+    case "list":
+      return block.items.map((item, index) => {
+        const marker = block.ordered ? `${index + 1}. ` : "- ";
+        const text = plainBlocks(item.filter((inner) => inner.kind !== "list"), "").replace(/\n+/g, " ").trim();
+        const nested = item.filter((inner) => inner.kind === "list").map((inner) => plainBlock(inner, `${indent}${" ".repeat(marker.length)}`));
+        return [`${indent}${marker}${text}`.trimEnd(), ...nested].join(`
+`);
+      }).join(`
+`);
+    case "quote":
+      return prefixLines(plainBlocks(block.blocks), `${indent}> `);
+    case "code":
+      return prefixLines(block.text, indent);
+  }
+};
+var prefixLines = (text, prefix) => {
+  return prefix === "" ? text : text.split(`
+`).map((line) => `${prefix}${line}`).join(`
+`);
+};
+var plainInline = (pieces, breaks, addresses = true) => {
+  let text = "";
+  for (const piece of pieces) {
+    switch (piece.kind) {
+      case "text":
+        text += piece.text;
+        break;
+      case "break":
+        text += breaks ? `
+` : " ";
+        break;
+      case "strong":
+      case "emphasis":
+      case "strike":
+        text += plainInline(piece.children, breaks, addresses);
+        break;
+      case "code":
+        text += piece.text;
+        break;
+      case "link": {
+        const label = plainInline(piece.children, breaks, addresses).trim();
+        const href = addresses && isKeptLink(piece.href) && !piece.href.startsWith("#") ? piece.href : "";
+        text += href && label && label !== href ? `${label} (${href})` : label || href;
+        break;
+      }
+      case "image":
+        text += piece.alt;
+        break;
+    }
+  }
+  return text.split(`
+`).map((line) => line.replace(/ {2,}/g, " ").trim()).join(`
+`);
+};
+
+// src/core/other-apps/ideas.ts
+var IMPORT_WARNING_CODES = [
+  "floating-ideas-moved",
+  "summaries-moved",
+  "callouts-moved",
+  "boundaries-in-notes",
+  "links-in-notes",
+  "missing-link-targets",
+  "icons-not-kept",
+  "pictures-not-kept",
+  "attachments-not-kept",
+  "local-links-not-kept",
+  "encrypted-branches-not-read",
+  "formatting-not-kept"
+];
+var IMPORT_ERROR_CODES = ["unknown-format", "unreadable", "empty", "password-protected", "too-large"];
+
+class OrbitImportError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "OrbitImportError";
+    this.code = code;
+  }
+}
+var MAX_IMPORTED_IDEAS = 1e5;
+var MAX_IMPORTED_DEPTH = 500;
+var newIdea = (text) => {
+  return { text, notes: [], ideaLinks: [], tags: [], icons: [], children: [] };
+};
+var MESSAGES = {
+  "floating-ideas-moved": (count, examples) => `${plural(count, "floating topic")}${examples} had no place in the tree: ${count === 1 ? "it's" : "they're"} now under the center.`,
+  "summaries-moved": (count, examples) => `${plural(count, "summary")}${examples} became ${count === 1 ? "an idea" : "ideas"} beside the ideas ${count === 1 ? "it sums" : "they sum"} up.`,
+  "callouts-moved": (count, examples) => `${plural(count, "callout")}${examples} became ${count === 1 ? "an idea" : "ideas"} under the topic ${count === 1 ? "it points" : "they point"} at.`,
+  "boundaries-in-notes": (count, examples) => `${plural(count, "boundary title")}${examples} ${count === 1 ? "is" : "are"} now in the note of the idea whose ideas ${count === 1 ? "it surrounds" : "they surround"}.`,
+  "links-in-notes": (count, examples) => `${plural(count, "link")}${examples} beyond an idea's first ${count === 1 ? "is" : "are"} now in its note.`,
+  "missing-link-targets": (count, examples) => `${plural(count, "link")}${examples} ${count === 1 ? "points" : "point"} at an idea that isn't in this map, so ${count === 1 ? "it was" : "they were"} left out.`,
+  "icons-not-kept": (count, examples) => `${plural(count, "icon")}${examples} ${count === 1 ? "was" : "were"} left out: an idea in Orbit has one icon, an emoji.`,
+  "pictures-not-kept": (count, examples) => `${plural(count, "picture")}${examples} ${count === 1 ? "isn't" : "aren't"} in the file, so ${count === 1 ? "it was" : "they were"} left out.`,
+  "attachments-not-kept": (count, examples) => `${plural(count, "attached file")}${examples} ${count === 1 ? "was" : "were"} left out; the ideas keep their names.`,
+  "local-links-not-kept": (count, examples) => `${plural(count, "link")}${examples} to files on the computer the map was made on ${count === 1 ? "was" : "were"} left out.`,
+  "encrypted-branches-not-read": (count, examples) => `${plural(count, "encrypted branch")}${examples} couldn't be read: the ideas in ${count === 1 ? "it" : "them"} were left out.`,
+  "formatting-not-kept": (count, examples) => `${plural(count, "note")}${examples} ${count === 1 ? "is" : "are"} kept as plain text, without bold, italics or lists: markdown would have shown ${count === 1 ? "it" : "them"} differently.`
+};
+var plural = (count, noun) => {
+  const word = count === 1 ? noun : noun.endsWith("y") ? `${noun.slice(0, -1)}ies` : /(ch|sh|s|x)$/.test(noun) ? `${noun}es` : `${noun}s`;
+  return `${count === 1 ? "One" : count} ${word}`;
+};
+
+class ImportReport {
+  found = new Map;
+  add(code, example) {
+    const entry = this.found.get(code) ?? { count: 0, examples: [] };
+    const shown = example === undefined ? "" : oneLine(example);
+    entry.count += 1;
+    if (shown !== "" && entry.examples.length < 3 && !entry.examples.includes(shown)) {
+      entry.examples.push(shown);
+    }
+    this.found.set(code, entry);
+  }
+  get warnings() {
+    const order = (code) => IMPORT_WARNING_CODES.indexOf(code);
+    return [...this.found.entries()].sort(([first], [second]) => order(first) - order(second)).map(([code, { count, examples }]) => {
+      const shown = examples.map((example) => `“${example.length > 40 ? `${example.slice(0, 39)}…` : example}”`);
+      const more = count > examples.length && examples.length > 0 ? ", …" : "";
+      return { code, count, message: MESSAGES[code](count, shown.length > 0 ? ` (${shown.join(", ")}${more})` : "") };
+    });
+  }
+}
+var oneLine = (text) => {
+  return text.replace(/[\t\n\v\f\r\u2028\u2029 ]+/g, " ").replace(/^ | $/g, "");
+};
+var SOURCE_LINK = "#orbit-source:";
+var sourceLink = (sourceId) => {
+  return `${SOURCE_LINK}${encodeURIComponent(sourceId)}`;
+};
+var buildDocument = (rootIdea, report) => {
+  let count = 0;
+  const bySource = new Map;
+  const pending = [];
+  const build = (idea, level) => {
+    count += 1;
+    if (count > MAX_IMPORTED_IDEAS) {
+      throw new OrbitImportError("too-large", `The map has more than ${MAX_IMPORTED_IDEAS.toLocaleString("en")} ideas.`);
+    }
+    if (level > MAX_IMPORTED_DEPTH) {
+      throw new OrbitImportError("too-large", `The map goes more than ${MAX_IMPORTED_DEPTH} levels deep.`);
+    }
+    let text = oneLine(idea.text);
+    const icons = idea.icons.filter((icon) => icon !== "");
+    let icon = icons[0];
+    const emoji = icon === undefined ? leadingEmoji(text) : null;
+    if (emoji) {
+      icon = emoji.icon;
+      text = emoji.text;
+    }
+    for (const extra of icons.slice(1)) {
+      report.add("icons-not-kept", extra);
+    }
+    const node = { id: nodeSlug(text), text, level, children: [] };
+    if (icon) {
+      node.icon = icon;
+    }
+    if (idea.collapsed && idea.children.length > 0) {
+      node.collapsed = true;
+    }
+    if (idea.status) {
+      node.status = idea.status;
+    }
+    if (idea.priority !== undefined && Number.isFinite(idea.priority)) {
+      node.priority = idea.priority;
+    }
+    const tags = [...new Set(idea.tags.map((tag) => oneLine(tag)).filter((tag) => tag !== ""))];
+    if (tags.length > 0) {
+      node.tags = tags;
+    }
+    if (idea.color) {
+      node.color = idea.color;
+    }
+    if (idea.link) {
+      node.link = idea.link;
+    }
+    if (idea.image) {
+      node.image = { src: idea.image };
+    }
+    if (idea.sourceId !== undefined && !bySource.has(idea.sourceId)) {
+      bySource.set(idea.sourceId, node);
+    }
+    pending.push([idea, node]);
+    for (const child of idea.children) {
+      const childNode = build(child, level + 1);
+      setParent(childNode, node);
+      node.children.push(childNode);
+    }
+    return node;
+  };
+  const root = build(rootIdea, 0);
+  ensureUniqueNodeIds(root);
+  for (const [idea, node] of pending) {
+    const extraLines = [];
+    for (const link of idea.ideaLinks) {
+      const target = bySource.get(link.target);
+      if (!target) {
+        report.add("missing-link-targets", link.label ?? node.text);
+        continue;
+      }
+      if (!node.link && !link.label) {
+        node.link = `#${target.id}`;
+      } else {
+        report.add("links-in-notes", link.label ?? target.text);
+        extraLines.push({ label: link.label ?? target.text, target });
+      }
+    }
+    const note = joinNotes([...idea.notes, linkNote(extraLines, idea.notes)]);
+    if (note) {
+      node.note = resolveSourceLinks(note.text, bySource, note.format);
+      if (note.format === "plain") {
+        node.noteFormat = "plain";
+      }
+    }
+  }
+  const nodes = indexNodes(root);
+  for (const [, node] of pending) {
+    if (isNodeLink(node.link) && !findIndexedLinkedNode(nodes, node.link)) {
+      report.add("missing-link-targets", node.link);
+      delete node.link;
+    }
+  }
+  return { root, options: {}, warnings: [], diagnostics: [] };
+};
+var linkNote = (lines, notes) => {
+  if (lines.length === 0) {
+    return;
+  }
+  const plain = notes.some((note) => note.format === "plain") || lines.some(({ label }) => /[[\]`*_~<\\]/.test(label));
+  if (plain) {
+    return { text: lines.map(({ label, target }) => label === target.text ? `→ ${label}` : `→ ${label}: ${target.text}`).join(`
+`), format: "plain" };
+  }
+  return { text: lines.map(({ label, target }) => `→ [${label || target.text}](#${target.id})`).join(`
+
+`), format: "markdown" };
+};
+var resolveSourceLinks = (text, bySource, format) => {
+  if (format !== "markdown" || !text.includes(SOURCE_LINK)) {
+    return text;
+  }
+  const target = (encoded) => {
+    try {
+      return bySource.get(decodeURIComponent(encoded));
+    } catch {
+      return;
+    }
+  };
+  return text.replace(/\[([^\]]*)\]\(#orbit-source:([^)\s]+)\)/g, (_, label, encoded) => {
+    const node = target(encoded);
+    return node ? `[${label || node.text}](#${node.id})` : label;
+  }).replace(/<#orbit-source:([^>\s]+)>/g, (_, encoded) => {
+    const node = target(encoded);
+    return node ? `[${node.text}](#${node.id})` : "";
+  });
+};
+
+// src/core/other-apps/reading.ts
+var readXmlFile = (data, rootName, what) => {
+  const text = typeof data === "string" ? data : decodeMarkup(data);
+  let root;
+  try {
+    root = parseXml(text);
+  } catch (error) {
+    if (error instanceof MarkupError) {
+      throw new OrbitImportError("unreadable", `The file isn't ${what} Orbit can read: ${error.message}.`);
+    }
+    throw error;
+  }
+  if (root.localName !== rootName) {
+    throw new OrbitImportError("unreadable", `The file isn't ${what}: it starts with <${root.name}>, not <${rootName}>.`);
+  }
+  return root;
+};
+var baseName = (name) => {
+  return (name ?? "").replace(/^.*[/\\]/, "").replace(/\.(opml|xml|mm|xmind|txt|md)$/i, "").trim();
+};
+
+// src/core/other-apps/freemind.ts
+var importFreeMind = (data, options = {}) => {
+  const map = readXmlFile(data, "map", "a FreeMind or Freeplane map");
+  const nodes = childElements(map, "node");
+  if (nodes.length === 0) {
+    throw new OrbitImportError("empty", "The map has no nodes.");
+  }
+  const report = new ImportReport;
+  let root;
+  if (nodes.length === 1) {
+    root = readNode(nodes[0], report);
+  } else {
+    root = newIdea(baseName(options.name) || options.untitled || "Untitled map");
+    root.children = nodes.map((node) => readNode(node, report));
+  }
+  return { format: "freemind", maps: [{ document: buildDocument(root, report), media: {}, warnings: report.warnings }] };
+};
+var readNode = (node, report) => {
+  const idea = newIdea("");
+  const id = node.attributes.ID;
+  if (id) {
+    idea.sourceId = id;
+  }
+  readTitle(node, idea, report);
+  const addresses = noteAddresses(report);
+  const details = [];
+  const notes = [];
+  for (const content of childElements(node, "richcontent")) {
+    const type = (content.attributes.TYPE ?? "").toUpperCase();
+    if (type === "NOTE" || type === "DETAILS") {
+      const note = richContentNote(content, addresses, report, idea.text);
+      if (note) {
+        (type === "DETAILS" ? details : notes).push(note);
+      }
+    }
+  }
+  for (const hook of childElements(node, "hook")) {
+    if (/NodeNote/.test(hook.attributes.NAME ?? "")) {
+      const text = childElement(hook, "text");
+      const note = noteFromPlainText(text ? textContent(text) : undefined);
+      if (note) {
+        notes.push(note);
+      }
+    }
+  }
+  idea.notes.push(...details, ...notes);
+  const attributes = attributeNote(node);
+  if (attributes) {
+    idea.notes.push(attributes);
+  }
+  readLink(node.attributes.LINK, idea, report);
+  for (const arrow of childElements(node, "arrowlink")) {
+    const target = arrow.attributes.DESTINATION;
+    if (target) {
+      const label = oneLine(arrow.attributes.MIDDLE_LABEL || arrow.attributes.SOURCE_LABEL || arrow.attributes.TARGET_LABEL || "");
+      idea.ideaLinks.push(label ? { target, label } : { target });
+    }
+  }
+  if (node.attributes.FOLDED === "true") {
+    idea.collapsed = true;
+  }
+  const background = node.attributes.BACKGROUND_COLOR;
+  if (background && /^#[0-9A-Fa-f]{6}$/.test(background)) {
+    idea.color = background.toUpperCase();
+  }
+  for (const icon of childElements(node, "icon")) {
+    const name = icon.attributes.BUILTIN ?? "";
+    const meaning = freeMindIcon(name);
+    if (!meaning) {
+      report.add("icons-not-kept", name.replace(/^.*\//, ""));
+    } else if ("icon" in meaning) {
+      idea.icons.push(meaning.icon);
+    } else if ("priority" in meaning) {
+      idea.priority ??= meaning.priority;
+    } else {
+      idea.status ??= meaning.status;
+    }
+  }
+  for (const hook of childElements(node, "hook")) {
+    if (hook.attributes.NAME === "ExternalObject" && hook.attributes.URI) {
+      readPicture(hook.attributes.URI, idea, report);
+    }
+  }
+  if (node.attributes.ENCRYPTED_CONTENT) {
+    report.add("encrypted-branches-not-read", idea.text || undefined);
+  }
+  idea.children = childElements(node, "node").map((child) => readNode(child, report));
+  return idea;
+};
+var readTitle = (node, idea, report) => {
+  const rich = childElements(node, "richcontent").find((content) => (content.attributes.TYPE ?? "").toUpperCase() === "NODE");
+  const text = node.attributes.TEXT ?? node.attributes.LOCALIZED_TEXT;
+  if (rich) {
+    const html = childElement(rich, "html");
+    const plain = childElement(rich, "text");
+    if (html) {
+      const title = titleFromHtml(html);
+      idea.text = title.text;
+      readLink(title.link, idea, report);
+      for (const image of findElements(html, "img")) {
+        readPicture(image.attributes.src ?? "", idea, report);
+      }
+    } else {
+      idea.text = plain ? textContent(plain) : textContent(rich);
+    }
+    return;
+  }
+  if (text !== undefined && /^\s*<html>/i.test(text)) {
+    const title = titleFromHtml(text);
+    idea.text = title.text;
+    readLink(title.link, idea, report);
+    return;
+  }
+  idea.text = text ?? "";
+};
+var readLink = (link, idea, report) => {
+  const address = link?.trim();
+  if (!address || idea.link) {
+    return;
+  }
+  const kept = keptAddress(address);
+  if (address.startsWith("#") || /^(ID_\d+|_?Freemind_Link_\d+)$/.test(address)) {
+    idea.ideaLinks.push({ target: address.replace(/^#/, "") });
+  } else if (kept) {
+    idea.link = kept;
+  } else {
+    report.add("local-links-not-kept", address);
+  }
+};
+var readPicture = (address, idea, report) => {
+  if (/^https?:\/\/\S+$/i.test(address)) {
+    idea.image ??= address;
+  } else if (address !== "") {
+    report.add("pictures-not-kept", address.replace(/^.*[/\\]/, ""));
+  }
+};
+var noteAddresses = (report) => {
+  return {
+    link: (href) => {
+      if (href.startsWith("#")) {
+        return sourceLink(href.slice(1));
+      }
+      const kept = keptAddress(href);
+      if (kept) {
+        return kept;
+      }
+      report.add("local-links-not-kept", href);
+      return null;
+    },
+    picture: (src) => {
+      if (/^https?:\/\/\S+$/i.test(src)) {
+        return src;
+      }
+      report.add("pictures-not-kept", src.replace(/^.*[/\\]/, ""));
+      return null;
+    }
+  };
+};
+var richContentNote = (content, addresses, report, title) => {
+  const html = childElement(content, "html");
+  if (html) {
+    const note = noteFromHtml(html, addresses);
+    if (note?.format === "plain") {
+      report.add("formatting-not-kept", title || undefined);
+    }
+    return note;
+  }
+  const plain = childElement(content, "text");
+  const text = plain ? textContent(plain) : textContent(content);
+  if (/\/markdown$/i.test(content.attributes["CONTENT-TYPE"] ?? "") && text.trim() !== "") {
+    return { text: text.replace(/\r\n?/g, `
+`).trim(), format: "markdown" };
+  }
+  return noteFromPlainText(text);
+};
+var attributeNote = (node) => {
+  const items = [];
+  for (const attribute of childElements(node, "attribute")) {
+    const name = (attributeOf(attribute, "NAME") ?? "").trim();
+    const value = (attributeOf(attribute, "VALUE") ?? "").trim();
+    if (name !== "" || value !== "") {
+      items.push([{ kind: "paragraph", inline: name === "" ? [{ kind: "text", text: value }] : [{ kind: "strong", children: [{ kind: "text", text: `${name}:` }] }, { kind: "text", text: ` ${value}` }] }]);
+    }
+  }
+  return items.length === 0 ? undefined : noteFromBlocks([{ kind: "list", ordered: false, items }]);
+};
+var findElements = (element, localName) => {
+  const found = [];
+  const pending = [element];
+  while (pending.length > 0) {
+    const next = pending.pop();
+    for (const child of childElements(next)) {
+      if (child.localName.toLowerCase() === localName) {
+        found.push(child);
+      }
+      pending.push(child);
+    }
+  }
+  return found;
+};
+
+// src/core/other-apps/opml.ts
+var HTML_TAGS = /<\/?(b|i|u|s|em|strong|a|span|br|code|mark|strike|del|sup|sub|font|p|div|ul|ol|li)\b[^>]*>/i;
+var importOPML = (data, options = {}) => {
+  const opml = readXmlFile(data, "opml", "an OPML file");
+  const head = childElement(opml, "head");
+  const titleElement = head ? childElement(head, "title") : undefined;
+  const title = titleElement ? baseName(textContent(titleElement).replace(/\s+/g, " ").trim()) : "";
+  const body = childElement(opml, "body");
+  const outlines = body ? childElements(body, "outline") : [];
+  if (outlines.length === 0) {
+    throw new OrbitImportError("empty", "The OPML file has no outlines.");
+  }
+  const report = new ImportReport;
+  let root;
+  if (outlines.length === 1) {
+    root = readOutline2(outlines[0], report);
+  } else {
+    root = newIdea(title || baseName(options.name) || options.untitled || "Untitled map");
+    root.children = outlines.map((outline) => readOutline2(outline, report));
+  }
+  return { format: "opml", maps: [{ document: buildDocument(root, report), media: {}, warnings: report.warnings }] };
+};
+var readOutline2 = (outline, report) => {
+  const text = attributeOf(outline, "text") ?? attributeOf(outline, "title") ?? "";
+  const idea = newIdea(text);
+  if (HTML_TAGS.test(text) && outline.attributes._textFormat !== "plain") {
+    const title = titleFromHtml(text);
+    idea.text = title.text;
+    if (title.link && isKeptLink(title.link) && !title.link.startsWith("#")) {
+      idea.link = title.link;
+    }
+  }
+  const note = readNote(outline, idea, report);
+  if (note) {
+    idea.notes.push(note);
+  }
+  idea.status = readStatus(outline);
+  const link = readLink2(outline);
+  const kept = link ? keptAddress(link) : null;
+  if (kept) {
+    idea.link = kept;
+  } else if (link) {
+    report.add("local-links-not-kept", link);
+  }
+  const categories = attributeOf(outline, "category");
+  if (categories) {
+    idea.tags.push(...categories.split(",").map((category) => category.trim().replace(/^\/+/, "")).filter((category) => category !== ""));
+  }
+  idea.children = childElements(outline, "outline").map((child) => readOutline2(child, report));
+  return idea;
+};
+var readNote = (outline, idea, report) => {
+  const text = attributeOf(outline, "_note") ?? outline.attributes.note ?? attributeOf(outline, "description");
+  if (text === undefined || text.trim() === "") {
+    return;
+  }
+  const format = outline.attributes._noteFormat;
+  if (format === "markdown" || format === "plain") {
+    return { text: text.replace(/\r\n?/g, `
+`).trim(), format };
+  }
+  if (HTML_TAGS.test(text)) {
+    const note = noteFromHtml(text.replace(/\r\n?|\n/g, "<br>"));
+    if (note?.format === "plain") {
+      report.add("formatting-not-kept", idea.text || undefined);
+    }
+    return note;
+  }
+  return noteFromPlainText(text);
+};
+var readStatus = (outline) => {
+  const status = attributeOf(outline, "_status")?.trim();
+  if (status) {
+    return CHECKBOX_STATUSES.get(status.toLowerCase()) ?? status;
+  }
+  const complete = (outline.attributes._complete ?? outline.attributes.complete ?? outline.attributes.checked ?? outline.attributes._checked)?.trim().toLowerCase();
+  if (complete === "true") {
+    return "done";
+  }
+  return outline.attributes.checkbox === "true" ? "todo" : undefined;
+};
+var readLink2 = (outline) => {
+  const url = outline.attributes.url ?? outline.attributes.htmlUrl ?? outline.attributes.xmlUrl;
+  return url?.trim() || undefined;
+};
+var STATUS_CHECKBOXES = new Map([["done", "checked"], ["todo", "unchecked"], ["active", "indeterminate"]]);
+var CHECKBOX_STATUSES = new Map([...STATUS_CHECKBOXES].map(([status, checkbox]) => [checkbox, status]));
+var DONE_WORDS = new Set(["done", "complete", "completed", "shipped"]);
+var exportOPML = (input, options = {}) => {
+  const document2 = typeof input === "string" ? parseOrbit2(input) : input;
+  const title = options.title ?? (document2.options.title || document2.root.text);
+  const lines = [
+    '<?xml version="1.0" encoding="UTF-8"?>',
+    '<opml version="2.0">',
+    "  <head>",
+    `    <title>${escapeXml(title)}</title>`,
+    "  </head>",
+    "  <body>"
+  ];
+  const write = (node, depth) => {
+    const indent = "  ".repeat(depth + 2);
+    const attributes = outlineAttributes(node).map(([name, value]) => ` ${name}="${escapeXml(value, true)}"`).join("");
+    if (node.children.length === 0) {
+      lines.push(`${indent}<outline${attributes}/>`);
+      return;
+    }
+    lines.push(`${indent}<outline${attributes}>`);
+    for (const child of node.children) {
+      write(child, depth + 1);
+    }
+    lines.push(`${indent}</outline>`);
+  };
+  write(document2.root, 0);
+  lines.push("  </body>", "</opml>", "");
+  return lines.join(`
+`);
+};
+var outlineAttributes = (node) => {
+  const text = node.icon ? `${node.icon} ${node.text}` : node.text;
+  const attributes = [["text", text]];
+  if (HTML_TAGS.test(text)) {
+    attributes.push(["_textFormat", "plain"]);
+  }
+  if (node.note) {
+    attributes.push(["_note", node.note]);
+    const format = node.noteFormat ?? "markdown";
+    if (noteFromPlainText(node.note)?.format !== format) {
+      attributes.push(["_noteFormat", format]);
+    }
+  }
+  const status = node.status?.trim();
+  if (status) {
+    attributes.push(["_status", STATUS_CHECKBOXES.get(status) ?? status]);
+    if (DONE_WORDS.has(status.toLowerCase())) {
+      attributes.push(["_complete", "true"]);
+    }
+  }
+  if (node.link && (isKeptLink(node.link) || isNodeLink(node.link))) {
+    attributes.push(["type", "link"], ["url", node.link]);
+  }
+  if (node.tags && node.tags.length > 0) {
+    attributes.push(["category", node.tags.map((tag) => tag.replace(/,/g, " ")).join(",")]);
+  }
+  return attributes;
+};
+var escapeXml = (text, attribute = false) => {
+  const escaped = text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
+  return attribute ? escaped.replace(/"/g, "&quot;").replace(/\n/g, "&#10;").replace(/\r/g, "&#13;").replace(/\t/g, "&#9;") : escaped;
+};
+
+// src/core/other-apps/inflate.ts
+class InflateError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "InflateError";
+  }
+}
+var LENGTH_BASES = [3, 4, 5, 6, 7, 8, 9, 10, 11, 13, 15, 17, 19, 23, 27, 31, 35, 43, 51, 59, 67, 83, 99, 115, 131, 163, 195, 227, 258];
+var LENGTH_EXTRA_BITS = [0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5, 5, 0];
+var DISTANCE_BASES = [1, 2, 3, 4, 5, 7, 9, 13, 17, 25, 33, 49, 65, 97, 129, 193, 257, 385, 513, 769, 1025, 1537, 2049, 3073, 4097, 6145, 8193, 12289, 16385, 24577];
+var DISTANCE_EXTRA_BITS = [0, 0, 0, 0, 1, 1, 2, 2, 3, 3, 4, 4, 5, 5, 6, 6, 7, 7, 8, 8, 9, 9, 10, 10, 11, 11, 12, 12, 13, 13];
+var CODE_LENGTH_ORDER = [16, 17, 18, 0, 8, 7, 9, 6, 10, 5, 11, 4, 12, 3, 13, 2, 14, 1, 15];
+var MAX_BITS = 15;
+var buildCode = (lengths) => {
+  const counts = new Uint16Array(MAX_BITS + 1);
+  for (const length of lengths) {
+    counts[length] += 1;
+  }
+  counts[0] = 0;
+  let left = 1;
+  for (let length = 1;length <= MAX_BITS; length++) {
+    left = left * 2 - counts[length];
+    if (left < 0) {
+      throw new InflateError("A Huffman code with more codes than its lengths allow");
+    }
+  }
+  const offsets = new Uint16Array(MAX_BITS + 2);
+  for (let length = 1;length <= MAX_BITS; length++) {
+    offsets[length + 1] = offsets[length] + counts[length];
+  }
+  const symbols = new Uint16Array(lengths.length);
+  for (let symbol = 0;symbol < lengths.length; symbol++) {
+    if (lengths[symbol] !== 0) {
+      symbols[offsets[lengths[symbol]]++] = symbol;
+    }
+  }
+  return { counts, symbols };
+};
+var fixedLengths = new Uint8Array(288);
+fixedLengths.fill(8, 0, 144);
+fixedLengths.fill(9, 144, 256);
+fixedLengths.fill(7, 256, 280);
+fixedLengths.fill(8, 280, 288);
+var FIXED_LITERALS = buildCode(fixedLengths);
+var FIXED_DISTANCES = buildCode(new Uint8Array(30).fill(5));
+
+class BitReader {
+  data;
+  position;
+  buffer = 0;
+  count = 0;
+  constructor(data, start) {
+    this.data = data;
+    this.position = start;
+  }
+  bits(needed) {
+    while (this.count < needed) {
+      if (this.position >= this.data.length) {
+        throw new InflateError("The data ends in the middle of a block");
+      }
+      this.buffer |= this.data[this.position++] << this.count;
+      this.count += 8;
+    }
+    const value = this.buffer & (1 << needed) - 1;
+    this.buffer >>>= needed;
+    this.count -= needed;
+    return value;
+  }
+  bytes(length) {
+    this.buffer = 0;
+    this.count = 0;
+    if (this.position + length > this.data.length) {
+      throw new InflateError("The data ends in the middle of a stored block");
+    }
+    const bytes = this.data.subarray(this.position, this.position + length);
+    this.position += length;
+    return bytes;
+  }
+  word() {
+    const [low, high] = this.bytes(2);
+    return low | high << 8;
+  }
+  decode(code) {
+    let value = 0;
+    let first = 0;
+    let index = 0;
+    for (let length = 1;length <= MAX_BITS; length++) {
+      value |= this.bits(1);
+      const count = code.counts[length];
+      if (value - first < count) {
+        return code.symbols[index + value - first];
+      }
+      index += count;
+      first = first + count << 1;
+      value <<= 1;
+    }
+    throw new InflateError("A code that no Huffman table has");
+  }
+}
+
+class Output {
+  bytes;
+  length = 0;
+  limit;
+  constructor(expected, limit) {
+    this.limit = limit;
+    this.bytes = new Uint8Array(Math.max(16, Math.min(expected ?? 65536, limit)));
+  }
+  room(extra) {
+    const needed = this.length + extra;
+    if (needed > this.limit) {
+      throw new InflateError(`The data holds more than the ${this.limit} bytes it may`);
+    }
+    if (needed > this.bytes.length) {
+      const grown = new Uint8Array(Math.min(this.limit, Math.max(needed, this.bytes.length * 2)));
+      grown.set(this.bytes.subarray(0, this.length));
+      this.bytes = grown;
+    }
+  }
+  push(byte) {
+    this.room(1);
+    this.bytes[this.length++] = byte;
+  }
+  append(bytes) {
+    this.room(bytes.length);
+    this.bytes.set(bytes, this.length);
+    this.length += bytes.length;
+  }
+  copy(distance, length) {
+    if (distance > this.length) {
+      throw new InflateError("A back reference to before the start of the data");
+    }
+    this.room(length);
+    for (let index = 0;index < length; index++) {
+      this.bytes[this.length] = this.bytes[this.length - distance];
+      this.length += 1;
+    }
+  }
+}
+var inflate = (data, options = {}) => {
+  const limit = options.limit ?? Math.max(options.expected ?? 0, 64 * 1024 * 1024);
+  const reader = new BitReader(data, 0);
+  const output = new Output(options.expected, limit);
+  let last = 0;
+  while (last === 0) {
+    last = reader.bits(1);
+    const type = reader.bits(2);
+    if (type === 0) {
+      const length = reader.word();
+      const complement = reader.word();
+      if ((length ^ 65535) !== complement) {
+        throw new InflateError("A stored block whose length doesn't match its complement");
+      }
+      output.append(reader.bytes(length));
+    } else if (type === 1) {
+      inflateBlock(reader, output, FIXED_LITERALS, FIXED_DISTANCES);
+    } else if (type === 2) {
+      const [literals, distances] = readDynamicCodes(reader);
+      inflateBlock(reader, output, literals, distances);
+    } else {
+      throw new InflateError("A block of an unknown type");
+    }
+  }
+  return output.bytes.subarray(0, output.length);
+};
+var readDynamicCodes = (reader) => {
+  const literalCount = reader.bits(5) + 257;
+  const distanceCount = reader.bits(5) + 1;
+  const codeLengthCount = reader.bits(4) + 4;
+  if (literalCount > 286 || distanceCount > 30) {
+    throw new InflateError("A block with more codes than deflate has");
+  }
+  const codeLengths = new Uint8Array(19);
+  for (let index = 0;index < codeLengthCount; index++) {
+    codeLengths[CODE_LENGTH_ORDER[index]] = reader.bits(3);
+  }
+  const codeLengthCode = buildCode(codeLengths);
+  const lengths = new Uint8Array(literalCount + distanceCount);
+  let index = 0;
+  while (index < lengths.length) {
+    const symbol = reader.decode(codeLengthCode);
+    if (symbol < 16) {
+      lengths[index++] = symbol;
+      continue;
+    }
+    let repeat;
+    let value = 0;
+    if (symbol === 16) {
+      if (index === 0) {
+        throw new InflateError("A repeat with nothing before it");
+      }
+      value = lengths[index - 1];
+      repeat = 3 + reader.bits(2);
+    } else if (symbol === 17) {
+      repeat = 3 + reader.bits(3);
+    } else {
+      repeat = 11 + reader.bits(7);
+    }
+    if (index + repeat > lengths.length) {
+      throw new InflateError("Code lengths that run past their table");
+    }
+    lengths.fill(value, index, index + repeat);
+    index += repeat;
+  }
+  if (lengths[256] === 0) {
+    throw new InflateError("A block with no code for its end");
+  }
+  return [buildCode(lengths.subarray(0, literalCount)), buildCode(lengths.subarray(literalCount))];
+};
+var inflateBlock = (reader, output, literals, distances) => {
+  for (;; ) {
+    const symbol = reader.decode(literals);
+    if (symbol < 256) {
+      output.push(symbol);
+    } else if (symbol === 256) {
+      return;
+    } else {
+      const lengthIndex = symbol - 257;
+      if (lengthIndex >= LENGTH_BASES.length) {
+        throw new InflateError("A length code deflate has no length for");
+      }
+      const length = LENGTH_BASES[lengthIndex] + reader.bits(LENGTH_EXTRA_BITS[lengthIndex]);
+      const distanceSymbol = reader.decode(distances);
+      if (distanceSymbol >= DISTANCE_BASES.length) {
+        throw new InflateError("A distance code deflate has no distance for");
+      }
+      output.copy(DISTANCE_BASES[distanceSymbol] + reader.bits(DISTANCE_EXTRA_BITS[distanceSymbol]), length);
+    }
+  }
+};
+var crcTable = null;
+var crc32 = (bytes) => {
+  if (!crcTable) {
+    crcTable = new Uint32Array(256);
+    for (let index = 0;index < 256; index++) {
+      let value = index;
+      for (let bit = 0;bit < 8; bit++) {
+        value = value & 1 ? 3988292384 ^ value >>> 1 : value >>> 1;
+      }
+      crcTable[index] = value >>> 0;
+    }
+  }
+  let crc = 4294967295;
+  for (const byte of bytes) {
+    crc = crcTable[(crc ^ byte) & 255] ^ crc >>> 8;
+  }
+  return (crc ^ 4294967295) >>> 0;
+};
+
+// src/core/other-apps/zip.ts
+class ZipError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ZipError";
+  }
+}
+var DEFAULT_ZIP_LIMITS = {
+  entries: 20000,
+  entrySize: 64 * 1024 * 1024,
+  totalSize: 256 * 1024 * 1024
+};
+var END_OF_DIRECTORY = 101010256;
+var DIRECTORY_ENTRY = 33639248;
+var LOCAL_HEADER = 67324752;
+var isZip = (bytes) => {
+  return bytes.length >= 4 && bytes[0] === 80 && bytes[1] === 75 && bytes[2] === 3 && bytes[3] === 4;
+};
+
+class ZipArchive {
+  bytes;
+  view;
+  limits;
+  entries = new Map;
+  unpacked = 0;
+  constructor(bytes, limits = {}) {
+    this.bytes = bytes;
+    this.view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
+    this.limits = { ...DEFAULT_ZIP_LIMITS, ...limits };
+    this.readDirectory();
+  }
+  get names() {
+    return [...this.entries.keys()].filter((name) => !name.endsWith("/"));
+  }
+  has(name) {
+    return this.entries.has(name);
+  }
+  read(name) {
+    const entry = this.entries.get(name);
+    if (!entry) {
+      return null;
+    }
+    if (entry.flags & 1) {
+      throw new ZipError(`${name} is encrypted`);
+    }
+    if (entry.size > this.limits.entrySize || this.unpacked + entry.size > this.limits.totalSize) {
+      throw new ZipError(`${name} is too large to unpack`);
+    }
+    const offset = entry.headerOffset;
+    if (offset + 30 > this.bytes.length || this.view.getUint32(offset, true) !== LOCAL_HEADER) {
+      throw new ZipError(`The archive has no data where ${name} should start`);
+    }
+    const start = offset + 30 + this.view.getUint16(offset + 26, true) + this.view.getUint16(offset + 28, true);
+    const end = start + entry.compressedSize;
+    if (end > this.bytes.length) {
+      throw new ZipError(`${name} runs past the end of the archive`);
+    }
+    const stored = this.bytes.subarray(start, end);
+    let data;
+    if (entry.method === 0) {
+      data = stored;
+    } else if (entry.method === 8) {
+      try {
+        data = inflate(stored, { expected: entry.size, limit: entry.size });
+      } catch (error) {
+        throw new ZipError(`${name} can't be unpacked: ${error instanceof InflateError ? error.message : String(error)}`);
+      }
+    } else {
+      throw new ZipError(`${name} is compressed a way Orbit can't read (method ${entry.method})`);
+    }
+    if (data.length !== entry.size || crc32(data) !== entry.crc) {
+      throw new ZipError(`${name} is damaged: its contents don't match its checksum`);
+    }
+    this.unpacked += data.length;
+    return data;
+  }
+  text(name) {
+    const data = this.read(name);
+    return data === null ? null : new TextDecoder("utf-8").decode(data);
+  }
+  readDirectory() {
+    const bytes = this.bytes;
+    const view = this.view;
+    let end = -1;
+    for (let index = bytes.length - 22;index >= Math.max(0, bytes.length - 22 - 65535); index--) {
+      if (view.getUint32(index, true) === END_OF_DIRECTORY) {
+        end = index;
+        break;
+      }
+    }
+    if (end === -1) {
+      throw new ZipError("The file is not a zip archive, or its end is missing");
+    }
+    const disk = view.getUint16(end + 4, true);
+    const count = view.getUint16(end + 10, true);
+    const size = view.getUint32(end + 12, true);
+    const offset = view.getUint32(end + 16, true);
+    if (disk !== 0) {
+      throw new ZipError("The archive spans several disks");
+    }
+    if (count === 65535 || size === 4294967295 || offset === 4294967295) {
+      throw new ZipError("The archive needs ZIP64, which Orbit reads no map from");
+    }
+    if (count > this.limits.entries) {
+      throw new ZipError(`The archive lists more than ${this.limits.entries} files`);
+    }
+    if (offset + size > end) {
+      throw new ZipError("The archive's directory runs past its end");
+    }
+    const decoder = new TextDecoder("utf-8");
+    let position = offset;
+    for (let index = 0;index < count; index++) {
+      if (position + 46 > end || view.getUint32(position, true) !== DIRECTORY_ENTRY) {
+        throw new ZipError("The archive's directory is damaged");
+      }
+      const nameLength = view.getUint16(position + 28, true);
+      const extraLength = view.getUint16(position + 30, true);
+      const commentLength = view.getUint16(position + 32, true);
+      if (position + 46 + nameLength > end) {
+        throw new ZipError("The archive's directory is damaged");
+      }
+      const name = decoder.decode(bytes.subarray(position + 46, position + 46 + nameLength));
+      const entry = {
+        name,
+        flags: view.getUint16(position + 8, true),
+        method: view.getUint16(position + 10, true),
+        crc: view.getUint32(position + 16, true),
+        compressedSize: view.getUint32(position + 20, true),
+        size: view.getUint32(position + 24, true),
+        headerOffset: view.getUint32(position + 42, true)
+      };
+      if (!this.entries.has(name)) {
+        this.entries.set(name, entry);
+      }
+      position += 46 + nameLength + extraLength + commentLength;
+    }
+  }
+}
+
+// src/core/other-apps/xmind.ts
+var PICTURE_EXTENSIONS = new Set(["png", "jpg", "jpeg", "gif", "webp", "svg", "bmp", "avif", "heic", "heif"]);
+var importXMind = (data, options = {}) => {
+  const workbook = openWorkbook(data);
+  const maps = [];
+  if (workbook.json !== undefined) {
+    for (const sheet of workbook.json) {
+      if (isObject(sheet) && isObject(sheet.rootTopic)) {
+        maps.push(new JsonSheetReader(workbook.archive).read(sheet));
+      }
+    }
+  } else if (workbook.xml) {
+    const styles = workbook.archive ? readStyles(workbook.archive) : new Map;
+    const comments = workbook.archive ? readComments(workbook.archive) : new Map;
+    for (const sheet of childElements(workbook.xml, "sheet")) {
+      const topic = childElement(sheet, "topic");
+      if (topic) {
+        maps.push(new XmlSheetReader(workbook.archive, styles, comments).read(sheet, topic));
+      }
+    }
+  }
+  if (maps.length === 0) {
+    throw new OrbitImportError("empty", `The workbook${options.name ? ` ${options.name}` : ""} has no sheet with a topic.`);
+  }
+  return { format: "xmind", maps };
+};
+var openWorkbook = (data) => {
+  if (typeof data === "string") {
+    return readContent(data, null, data.trimStart().startsWith("[") ? "json" : "xml");
+  }
+  if (!isZip(data)) {
+    return readContent(new TextDecoder("utf-8").decode(data), null, "xml");
+  }
+  let archive;
+  try {
+    archive = new ZipArchive(data);
+  } catch (error) {
+    throw unreadable(error);
+  }
+  if (isEncrypted(archive)) {
+    throw new OrbitImportError("password-protected", "The workbook is protected with a password: open it in XMind and save it without one first.");
+  }
+  try {
+    if (archive.has("content.json")) {
+      return readContent(archive.text("content.json") ?? "", archive, "json");
+    }
+    if (archive.has("content.xml")) {
+      return readContent(archive.text("content.xml") ?? "", archive, "xml");
+    }
+  } catch (error) {
+    throw unreadable(error);
+  }
+  throw new OrbitImportError("unreadable", "The file is a zip archive, but not an XMind workbook: it has no content.json or content.xml.");
+};
+var readContent = (text, archive, kind) => {
+  if (kind === "json") {
+    let json;
+    try {
+      json = JSON.parse(text);
+    } catch (error) {
+      throw new OrbitImportError("unreadable", `The workbook's content.json can't be read: ${error.message}.`);
+    }
+    if (!Array.isArray(json)) {
+      throw new OrbitImportError("unreadable", "The workbook's content.json isn't a list of sheets.");
+    }
+    return { archive, json };
+  }
+  let xml;
+  try {
+    xml = parseXml(text);
+  } catch (error) {
+    throw unreadable(error);
+  }
+  if (xml.localName !== "xmap-content") {
+    throw new OrbitImportError("unreadable", `The file isn't an XMind workbook: it starts with <${xml.name}>, not <xmap-content>.`);
+  }
+  return { archive, xml };
+};
+var unreadable = (error) => {
+  if (error instanceof ZipError && /encrypted/.test(error.message)) {
+    return new OrbitImportError("password-protected", "The workbook is protected with a password: open it in XMind and save it without one first.");
+  }
+  if (error instanceof ZipError || error instanceof MarkupError) {
+    return new OrbitImportError("unreadable", `The workbook can't be read: ${error.message}.`);
+  }
+  return error instanceof OrbitImportError ? error : new OrbitImportError("unreadable", `The workbook can't be read: ${error.message}.`);
+};
+var isEncrypted = (archive) => {
+  try {
+    const manifest = archive.has("META-INF/manifest.xml") ? archive.text("META-INF/manifest.xml") ?? "" : "";
+    const json = archive.has("manifest.json") ? archive.text("manifest.json") ?? "" : "";
+    return /<encryption-data/.test(manifest) || /"encryption/.test(json);
+  } catch {
+    return false;
+  }
+};
+var isObject = (value) => {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+};
+var asString = (value) => {
+  return typeof value === "string" ? value : undefined;
+};
+
+class SheetReader {
+  archive;
+  report = new ImportReport;
+  media = {};
+  topics = new Map;
+  pictureNames = new Map;
+  constructor(archive) {
+    this.archive = archive;
+  }
+  finish(root) {
+    return { document: buildDocument(root, this.report), media: this.media, warnings: this.report.warnings };
+  }
+  readLink(href, idea) {
+    const address = href?.trim();
+    if (!address) {
+      return;
+    }
+    const topic = /^xmind:#(.+)$/.exec(address);
+    const kept = address.startsWith("#") ? null : keptAddress(address);
+    if (topic) {
+      idea.ideaLinks.push({ target: topic[1] });
+    } else if (kept) {
+      idea.link = kept;
+    } else if (/^xap:/.test(address)) {
+      if (PICTURE_EXTENSIONS.has(extensionOf(address)) && !idea.image) {
+        idea.image = this.picture(address, idea.text) ?? undefined;
+      } else {
+        this.report.add("attachments-not-kept", idea.text || address.replace(/^.*\//, ""));
+      }
+    } else {
+      this.report.add("local-links-not-kept", address);
+    }
+  }
+  picture(src, example) {
+    if (/^https?:\/\/\S+$/i.test(src)) {
+      return src;
+    }
+    const inside = /^xap:(.+)$/.exec(src)?.[1];
+    if (!inside || !this.archive) {
+      this.report.add("pictures-not-kept", example || src.replace(/^.*[/\\]/, ""));
+      return null;
+    }
+    if (!this.pictureNames.has(inside)) {
+      this.pictureNames.set(inside, this.unpackPicture(inside));
+    }
+    const name = this.pictureNames.get(inside) ?? null;
+    if (!name) {
+      this.report.add("pictures-not-kept", example || inside.replace(/^.*\//, ""));
+    }
+    return name;
+  }
+  unpackPicture(path) {
+    const extension = extensionOf(path);
+    if (!PICTURE_EXTENSIONS.has(extension)) {
+      return null;
+    }
+    let bytes;
+    try {
+      bytes = this.archive?.read(path) ?? null;
+    } catch {
+      bytes = null;
+    }
+    if (!bytes) {
+      return null;
+    }
+    const base = path.replace(/^.*\//, "").replace(/\.[^.]*$/, "").replace(/[^A-Za-z0-9._-]+/g, "-").replace(/^[^A-Za-z0-9]+/, "") || "picture";
+    let name = `media/${base}.${extension}`;
+    for (let suffix = 2;this.media[name] !== undefined; suffix++) {
+      name = `media/${base}-${suffix}.${extension}`;
+    }
+    this.media[name] = bytes;
+    return name;
+  }
+  noteAddresses(example) {
+    return {
+      link: (href) => {
+        const topic = /^xmind:#(.+)$/.exec(href);
+        if (topic) {
+          return sourceLink(topic[1]);
+        }
+        const kept = href.startsWith("#") ? null : keptAddress(href);
+        if (kept) {
+          return kept;
+        }
+        this.report.add("local-links-not-kept", href);
+        return null;
+      },
+      picture: (src) => this.picture(src, example)
+    };
+  }
+  htmlNote(html, idea) {
+    const note = noteFromHtml(html, this.noteAddresses(idea.text));
+    if (note?.format === "plain") {
+      this.report.add("formatting-not-kept", idea.text || undefined);
+    }
+    return note;
+  }
+  readMarker(markerId, idea) {
+    const meaning = xmindMarker(markerId);
+    if (!meaning) {
+      this.report.add("icons-not-kept", markerId);
+    } else if ("icon" in meaning) {
+      idea.icons.push(meaning.icon);
+    } else if ("priority" in meaning) {
+      idea.priority ??= meaning.priority;
+    } else {
+      idea.status ??= meaning.status;
+    }
+  }
+  relate(fromId, toId, title) {
+    const from = fromId ? this.topics.get(fromId) : undefined;
+    if (!from || !toId) {
+      this.report.add("missing-link-targets", title || undefined);
+      return;
+    }
+    const label = title?.trim();
+    from.ideaLinks.push(label ? { target: toId, label } : { target: toId });
+  }
+  adopt(idea, children, code) {
+    for (const child of children) {
+      this.report.add(code, child.text || undefined);
+      idea.children.push(child);
+    }
+  }
+  boundaryNote(titles, idea) {
+    for (const title of titles) {
+      const text = title.trim();
+      if (text !== "") {
+        this.report.add("boundaries-in-notes", text);
+        const note = noteFromPlainText(text);
+        if (note) {
+          idea.notes.push(note);
+        }
+      }
+    }
+  }
+}
+var extensionOf = (path) => {
+  return /\.([A-Za-z0-9]+)$/.exec(path)?.[1].toLowerCase() ?? "";
+};
+
+class JsonSheetReader extends SheetReader {
+  read(sheet) {
+    const root = this.topic(sheet.rootTopic, 0);
+    for (const relationship of Array.isArray(sheet.relationships) ? sheet.relationships : []) {
+      if (isObject(relationship)) {
+        this.relate(asString(relationship.end1Id), asString(relationship.end2Id), asString(relationship.title));
+      }
+    }
+    return this.finish(root);
+  }
+  topic(topic, depth) {
+    if (depth > 500) {
+      throw new OrbitImportError("too-large", "The sheet goes more than 500 levels deep.");
+    }
+    const idea = newIdea(asString(topic.title) ?? "");
+    const id = asString(topic.id);
+    if (id) {
+      idea.sourceId = id;
+      this.topics.set(id, idea);
+    }
+    const note = this.note(topic.notes, idea);
+    if (note) {
+      idea.notes.push(note);
+    }
+    if (Array.isArray(topic.labels)) {
+      idea.tags.push(...topic.labels.filter((label) => typeof label === "string"));
+    }
+    for (const marker of Array.isArray(topic.markers) ? topic.markers : []) {
+      const markerId = isObject(marker) ? asString(marker.markerId) : undefined;
+      if (markerId) {
+        this.readMarker(markerId, idea);
+      }
+    }
+    this.readLink(asString(topic.href), idea);
+    if (isObject(topic.image)) {
+      const src = asString(topic.image.src);
+      if (src) {
+        idea.image ??= this.picture(src, idea.text) ?? undefined;
+      }
+    }
+    if (topic.branch === "folded") {
+      idea.collapsed = true;
+    }
+    const style = isObject(topic.style) && isObject(topic.style.properties) ? topic.style.properties : {};
+    const fill = asString(style["svg:fill"]);
+    if (fill && /^#[0-9A-Fa-f]{6}$/.test(fill)) {
+      idea.color = fill.toUpperCase();
+    }
+    const children = isObject(topic.children) ? topic.children : {};
+    const kind = (name) => (Array.isArray(children[name]) ? children[name] : []).filter(isObject).map((child) => this.topic(child, depth + 1));
+    idea.children.push(...kind("attached"));
+    this.adopt(idea, kind("summary"), "summaries-moved");
+    this.adopt(idea, kind("callout"), "callouts-moved");
+    this.adopt(idea, kind("detached"), "floating-ideas-moved");
+    const boundaries = Array.isArray(topic.boundaries) ? topic.boundaries.filter(isObject).map((boundary) => asString(boundary.title) ?? "") : [];
+    this.boundaryNote(boundaries, idea);
+    return idea;
+  }
+  note(notes, idea) {
+    if (!isObject(notes)) {
+      return;
+    }
+    const html = isObject(notes.realHTML) ? asString(notes.realHTML.content) : undefined;
+    if (html) {
+      return this.htmlNote(html, idea);
+    }
+    const paragraphs = isObject(notes.html) && isObject(notes.html.content) && Array.isArray(notes.html.content.paragraphs) ? notes.html.content.paragraphs : null;
+    if (paragraphs) {
+      const blocks = paragraphs.filter(isObject).map((paragraph) => ({
+        kind: "paragraph",
+        inline: (Array.isArray(paragraph.spans) ? paragraph.spans : []).filter(isObject).map((span) => styledSpan(span))
+      }));
+      const note = noteFromBlocks(blocks);
+      if (note?.format === "plain") {
+        this.report.add("formatting-not-kept", idea.text || undefined);
+      }
+      return note;
+    }
+    return noteFromPlainText(isObject(notes.plain) ? asString(notes.plain.content) : undefined);
+  }
+}
+var styledSpan = (span) => {
+  const properties = isObject(span.style) && isObject(span.style.properties) ? span.style.properties : {};
+  let piece = { kind: "text", text: (asString(span.text) ?? "").replace(/\s+/g, " ") };
+  if (/line-through/.test(asString(properties["fo:text-decoration"]) ?? "")) {
+    piece = { kind: "strike", children: [piece] };
+  }
+  if (asString(properties["fo:font-style"]) === "italic") {
+    piece = { kind: "emphasis", children: [piece] };
+  }
+  if (/^(bold|[6-9]00)$/.test(asString(properties["fo:font-weight"]) ?? "")) {
+    piece = { kind: "strong", children: [piece] };
+  }
+  return piece;
+};
+
+class XmlSheetReader extends SheetReader {
+  styles;
+  comments;
+  constructor(archive, styles, comments) {
+    super(archive);
+    this.styles = styles;
+    this.comments = comments;
+  }
+  read(sheet, topic) {
+    const root = this.topic(topic);
+    for (const relationships of childElements(sheet, "relationships")) {
+      for (const relationship of childElements(relationships, "relationship")) {
+        const title = childElement(relationship, "title");
+        this.relate(relationship.attributes.end1, relationship.attributes.end2, title ? textContent(title) : undefined);
+      }
+    }
+    return this.finish(root);
+  }
+  topic(topic) {
+    const title = childElement(topic, "title");
+    const idea = newIdea(title ? textContent(title) : "");
+    const id = topic.attributes.id;
+    if (id) {
+      idea.sourceId = id;
+      this.topics.set(id, idea);
+    }
+    const notes = childElement(topic, "notes");
+    if (notes) {
+      const html = childElement(notes, "html");
+      const plain = childElement(notes, "plain");
+      const note = html ? this.htmlNote(html, idea) : noteFromPlainText(plain ? textContent(plain) : undefined);
+      if (note) {
+        idea.notes.push(note);
+      }
+    }
+    for (const comment of id ? this.comments.get(id) ?? [] : []) {
+      const note = noteFromPlainText(comment);
+      if (note) {
+        idea.notes.push(note);
+      }
+    }
+    for (const labels of childElements(topic, "labels")) {
+      idea.tags.push(...childElements(labels, "label").map((label) => textContent(label)));
+    }
+    for (const markers of childElements(topic, "marker-refs")) {
+      for (const marker of childElements(markers, "marker-ref")) {
+        const markerId = marker.attributes["marker-id"];
+        if (markerId) {
+          this.readMarker(markerId, idea);
+        }
+      }
+    }
+    this.readLink(attributeOf(topic, "href"), idea);
+    const image = childElement(topic, "img");
+    const src = image ? attributeOf(image, "src") : undefined;
+    if (src) {
+      idea.image ??= this.picture(src, idea.text) ?? undefined;
+    }
+    if (topic.attributes.branch === "folded") {
+      idea.collapsed = true;
+    }
+    const fill = this.styles.get(topic.attributes["style-id"] ?? "");
+    if (fill) {
+      idea.color = fill;
+    }
+    const children = childElement(topic, "children");
+    const kind = (type) => (children ? childElements(children, "topics") : []).filter((topics) => (topics.attributes.type ?? "attached") === type).flatMap((topics) => childElements(topics, "topic").map((child) => this.topic(child)));
+    idea.children.push(...kind("attached"));
+    this.adopt(idea, kind("summary"), "summaries-moved");
+    this.adopt(idea, kind("callout"), "callouts-moved");
+    this.adopt(idea, kind("detached"), "floating-ideas-moved");
+    const boundaries = childElements(topic, "boundaries").flatMap((list) => childElements(list, "boundary")).map((boundary) => {
+      const boundaryTitle = childElement(boundary, "title");
+      return boundaryTitle ? textContent(boundaryTitle) : "";
+    });
+    this.boundaryNote(boundaries, idea);
+    return idea;
+  }
+}
+var readStyles = (archive) => {
+  const fills = new Map;
+  try {
+    const text = archive.has("styles.xml") ? archive.text("styles.xml") : null;
+    if (!text) {
+      return fills;
+    }
+    const pending = [parseXml(text)];
+    while (pending.length > 0) {
+      const element = pending.pop();
+      for (const child of element.children) {
+        if (!isElement(child)) {
+          continue;
+        }
+        if (child.localName === "style" && child.attributes.type === "topic" && child.attributes.id) {
+          const properties = childElement(child, "topic-properties");
+          const fill = properties ? attributeOf(properties, "fill") : undefined;
+          if (fill && /^#[0-9A-Fa-f]{6}$/.test(fill)) {
+            fills.set(child.attributes.id, fill.toUpperCase());
+          }
+        }
+        pending.push(child);
+      }
+    }
+  } catch {}
+  return fills;
+};
+var readComments = (archive) => {
+  const comments = new Map;
+  try {
+    const text = archive.has("comments.xml") ? archive.text("comments.xml") : null;
+    if (!text) {
+      return comments;
+    }
+    for (const comment of childElements(parseXml(text), "comment")) {
+      const topic = comment.attributes["object-id"];
+      const content = childElement(comment, "content");
+      const words = content ? textContent(content).replace(/\r\n?/g, `
+`).trim() : "";
+      if (topic && words !== "") {
+        const author = (comment.attributes.author ?? "").trim();
+        comments.set(topic, [...comments.get(topic) ?? [], author ? `${author}: ${words}` : words]);
+      }
+    }
+  } catch {}
+  return comments;
+};
+
+// src/core/other-apps/import.ts
+var EXTENSIONS = { opml: "opml", mm: "freemind", xmind: "xmind" };
+var detectImportFormat = (data, name) => {
+  const extension = /\.([A-Za-z0-9]+)$/.exec(name ?? "")?.[1].toLowerCase() ?? "";
+  return formatInside(data) ?? (Object.prototype.hasOwnProperty.call(EXTENSIONS, extension) ? EXTENSIONS[extension] : null);
+};
+var formatInside = (data) => {
+  if (typeof data !== "string" && isZip(data)) {
+    try {
+      const archive = new ZipArchive(data);
+      return archive.has("content.json") || archive.has("content.xml") ? "xmind" : null;
+    } catch {
+      return null;
+    }
+  }
+  const text = typeof data === "string" ? data.slice(0, 4096) : decodeMarkup(data.subarray(0, 4096));
+  const root = /^(?:\s|<\?[\s\S]*?\?>|<!--[\s\S]*?-->|<!DOCTYPE[^>]*>)*<([A-Za-z_][\w.:-]*)/.exec(text.replace(/^\ufeff/, ""))?.[1];
+  const formats = { opml: "opml", map: "freemind", "xmap-content": "xmind" };
+  return root && Object.prototype.hasOwnProperty.call(formats, root) ? formats[root] : null;
+};
+var importMap = (data, options = {}) => {
+  const format = options.format ?? detectImportFormat(data, options.name);
+  switch (format) {
+    case "opml":
+      return importOPML(data, options);
+    case "freemind":
+      return importFreeMind(data, options);
+    case "xmind":
+      return importXMind(data, options);
+    default:
+      throw new OrbitImportError("unknown-format", `${options.name ? `${options.name} isn't` : "The file isn't"} a map Orbit can bring in from another app: it reads OPML, FreeMind and Freeplane (.mm), and XMind (.xmind).`);
+  }
+};
+// src/core/material.ts
+var MATERIAL_SEED = "#6750A4";
+var BRANCH_HUES = [0, 3, 6, 2, 5, 1, 4].map((step) => step * 360 / 7);
+var MOST_CHROMA = 0.16;
+var BRANCH_CHROMA = 0.11;
+var ERROR = { hue: 25, chroma: 0.19 };
+var SUCCESS = { hue: 145, chroma: 0.13 };
+var materialTheme = (seed, options = {}) => {
+  const dark = options.dark === true;
+  return { preset: dark ? "material-night" : "material", tokens: materialColors(seed, dark) };
+};
+var materialColors = (seed, dark) => {
+  const parsed = parseColor(seed);
+  if (!parsed) {
+    throw new Error(`A Material theme needs a color Orbit can read, such as "#0B57D0" or "oklch(0.55 0.15 260)": got "${seed}".`);
+  }
+  const { hue, chroma } = toOklch(parsed);
+  const primaryChroma = Math.min(chroma, MOST_CHROMA);
+  const palette = (paletteHue, paletteChroma) => (tone) => toHex(toneColor(paletteHue, paletteChroma, tone));
+  const primary = palette(hue, primaryChroma);
+  const secondary = palette(hue, Math.min(primaryChroma / 3, 0.05));
+  const neutral = palette(hue, Math.min(primaryChroma / 10, 0.012));
+  const neutralVariant = palette(hue, Math.min(primaryChroma / 5, 0.024));
+  const error = palette(ERROR.hue, ERROR.chroma);
+  const success = palette(SUCCESS.hue, SUCCESS.chroma);
+  const branches = BRANCH_HUES.map((offset) => palette((hue + offset) % 360, BRANCH_CHROMA));
+  const [accent, container, onContainer] = dark ? [80, 30, 90] : [40, 90, 10];
+  const branchTone = dark ? 32 : 88;
+  const [colorRoot, ...colors] = [primary(accent), ...branches.map((branch) => branch(branchTone))];
+  return {
+    surface: neutral(dark ? 6 : 98),
+    text: neutral(dark ? 90 : 10),
+    "muted-text": neutralVariant(dark ? 80 : 30),
+    "root-text": neutral(10),
+    "node-text": neutral(10),
+    "node-text-inverse": neutral(dark ? 90 : 100),
+    "color-root": colorRoot,
+    "color-1": colors[0],
+    "color-2": colors[1],
+    "color-3": colors[2],
+    "color-4": colors[3],
+    "color-5": colors[4],
+    "color-6": colors[5],
+    "color-7": colors[6],
+    "shade-light": dark ? neutral(40) : neutralVariant(80),
+    "shade-dark": dark ? neutral(12) : neutralVariant(50),
+    "node-stroke": neutralVariant(dark ? 30 : 80),
+    "badge-stroke": neutral(dark ? 6 : 98),
+    "sun-halo": primary(accent),
+    "ring-stroke": neutralVariant(dark ? 30 : 80),
+    "link-stroke": neutralVariant(dark ? 60 : 50),
+    "focus-ring": primary(accent),
+    "note-indicator": primary(accent),
+    "control-background": neutral(dark ? 12 : 94),
+    "control-text": neutral(dark ? 90 : 10),
+    "control-muted-text": neutralVariant(dark ? 80 : 30),
+    "control-active-background": secondary(container),
+    "control-active-text": secondary(onContainer),
+    "tooltip-background": neutral(dark ? 90 : 20),
+    "tooltip-text": neutral(dark ? 20 : 95),
+    "action-background": neutral(dark ? 17 : 92),
+    "action-text": neutral(dark ? 90 : 10),
+    "sheet-background": neutral(dark ? 10 : 96),
+    "sheet-text": neutral(dark ? 90 : 10),
+    "sheet-muted-text": neutralVariant(dark ? 80 : 30),
+    "sheet-border": neutralVariant(dark ? 30 : 80),
+    "chip-background": secondary(container),
+    "chip-text": secondary(onContainer),
+    "link-text": primary(accent),
+    "status-active": primary(accent),
+    "status-done": success(accent),
+    "status-blocked": error(accent),
+    "status-todo": neutralVariant(60),
+    "status-neutral": neutralVariant(dark ? 70 : 50),
+    "error-background": error(container),
+    "error-border": error(accent),
+    "error-text": error(onContainer)
+  };
+};
+export {
+  DIAGNOSTIC_CODES2 as DIAGNOSTIC_CODES,
+  IMPORT_ERROR_CODES,
+  IMPORT_WARNING_CODES,
+  MATERIAL_SEED,
+  ORBIT_THEME_PRESETS2 as ORBIT_THEME_PRESETS,
+  OrbitImportError,
+  OrbitParseError2 as OrbitParseError,
+  OrbitSVGRenderer2 as OrbitSVGRenderer,
+  PRINT_THEMES,
+  SUPPORTED_SCHEMA_VERSION2 as SUPPORTED_SCHEMA_VERSION,
+  THEME_TOKENS2 as THEME_TOKENS,
+  createMapTools,
+  createOrbitMap,
+  defineOrbitMapElement2 as defineOrbitMapElement,
+  detectImportFormat,
+  documentToRendererOptions2 as documentToRendererOptions,
+  exportOPML,
+  exportWebPage,
+  findNodeById2 as findNodeById,
+  formatDiagnostic2 as formatDiagnostic,
+  getNodePath2 as getNodePath,
+  importFreeMind,
+  importMap,
+  importOPML,
+  importXMind,
+  isOrbitThemePreset2 as isOrbitThemePreset,
+  isThemeName2 as isThemeName,
+  languageTags2 as languageTags,
+  materialTheme,
+  parseOrbit2 as parseOrbit,
+  parseOrbitMarkdown2 as parseOrbitMarkdown,
+  parseOrbitYAML2 as parseOrbitYAML,
+  printTheme,
+  registerAction2 as registerAction,
+  registerLanguage2 as registerLanguage,
+  registerNodeType2 as registerNodeType,
+  registerStatus2 as registerStatus,
+  registerTheme2 as registerTheme,
+  renderNoteMarkdown2 as renderNoteMarkdown,
+  renderOrbitElement2 as renderOrbitElement,
+  renderOrbitMarkdownBlocks2 as renderOrbitMarkdownBlocks,
+  renderPrintLayout,
+  renderToSVGString2 as renderToSVGString,
+  serializeOrbitMarkdown2 as serializeOrbitMarkdown,
+  serializeOrbitYAML,
+  themeNames2 as themeNames,
+  themeTokens2 as themeTokens,
+  upgradeNodeTypes2 as upgradeNodeTypes
+};
+
+//# debugId=0EF60DBE164EC11364756E2164756E21
+//# sourceMappingURL=index.js.map