@restless-dreams/orbit 0.1.0 → 0.2.0

package/dist/bin/orbit.js

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 
 // bin/orbit.ts
-import { readFileSync, writeFileSync } from "node:fs";
-import { basename, dirname, extname, relative, resolve, sep } from "node:path";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
 import { fileURLToPath, pathToFileURL } from "node:url";
 
 // src/core/yaml-mini.ts
@@ -1258,6 +1258,42 @@ var lineOfKey = (lines, key, fromIndex = 0, toIndex = lines.length) => {
   return;
 };
 
+// src/core/branch-colors.ts
+var branchPalette = (palette) => {
+  return palette.length > 1 ? palette.slice(1) : [...palette];
+};
+var isPaletteNumber = (value) => {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 1;
+};
+var paletteColorOf = (colors, paletteNumber) => {
+  return colors[(paletteNumber - 1) % colors.length];
+};
+var wrapped = (paletteNumber, count) => {
+  return (paletteNumber - 1) % count + 1;
+};
+var branchNumbers = (branches, count) => {
+  const numbers = new Map;
+  const taken = new Set;
+  for (const branch of branches) {
+    if (isPaletteNumber(branch.paletteColor)) {
+      taken.add(wrapped(branch.paletteColor, count));
+    }
+  }
+  const all = Array.from({ length: count }, (_, index) => index + 1);
+  const free = all.filter((paletteNumber) => !taken.has(paletteNumber));
+  const turns = free.length > 0 ? free : all;
+  let turn = 0;
+  for (const branch of branches) {
+    if (isPaletteNumber(branch.paletteColor)) {
+      numbers.set(branch, wrapped(branch.paletteColor, count));
+    } else {
+      numbers.set(branch, turns[turn % turns.length]);
+      turn += 1;
+    }
+  }
+  return numbers;
+};
+
 // src/core/suggest.ts
 var suggest = (input, candidates, synonyms = {}) => {
   const lowered = input.toLowerCase();
@@ -1387,6 +1423,7 @@ var readEmbed = (value) => {
 };
 var NODE_ATTRIBUTE_KEYS = [
   "color",
+  "paletteColor",
   "icon",
   "status",
   "priority",
@@ -1444,6 +1481,15 @@ var assignNodeAttribute = (node, key, value, diagnostics, line, vocabulary = { k
       }
       return;
     }
+    case "paletteColor": {
+      const paletteNumber = typeof value === "number" || typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
+      if (isPaletteNumber(paletteNumber)) {
+        node.paletteColor = paletteNumber;
+      } else {
+        keepUnread(node, key, value, diagnostics, line, "a whole number from 1");
+      }
+      return;
+    }
     case "priority": {
       const priority = typeof value === "number" || typeof value === "string" && value.trim() !== "" ? Number(value) : Number.NaN;
       if (Number.isFinite(priority)) {
@@ -3095,6 +3141,7 @@ var nodeFields = (node) => {
     status: node.status,
     tags: copy(node.tags),
     color: node.color,
+    paletteColor: node.paletteColor,
     priority: node.priority,
     collapsed: node.collapsed,
     type: node.type,
@@ -3289,6 +3336,10 @@ var ONLY_EMOJI = new RegExp(String.raw`^(?:${EMOJI})+$`, "u");
 var isTitleIcon = (icon) => {
   return ONLY_EMOJI.test(icon);
 };
+var leadingEmoji = (title) => {
+  const match = LEADING_EMOJI.exec(title);
+  return match ? { icon: match[1], text: match[2].trim() } : null;
+};
 var TASK_MARKER = /^\[( |x|X|\/)\]\s+(.*)$/;
 var TASK_STATUSES = { " ": "todo", x: "done", X: "done", "/": "active" };
 var ESCAPE = /\\([!-/:-@[-`{-~])/g;
@@ -4742,6 +4793,9 @@ var collectAttrs = (node, explicitIds) => {
   if (node.color) {
     r.color = node.color;
   }
+  if (node.paletteColor !== undefined) {
+    r.paletteColor = node.paletteColor;
+  }
   if (node.status) {
     r.status = node.status;
   }
@@ -5508,6 +5562,9 @@ var serializeNode = (n, explicitIds) => {
   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}`;
   }
@@ -5613,6 +5670,7 @@ var ENGLISH = {
   readNote: "Read note",
   openLink: "Open link",
   goTo: "Go to {name}",
+  seeIdea: "See {name}",
   details: "Details",
   close: "Close",
   previous: "Previous",
@@ -5689,6 +5747,7 @@ var SPANISH = {
   readNote: "Leer nota",
   openLink: "Abrir enlace",
   goTo: "Ir a {name}",
+  seeIdea: "Ver {name}",
   details: "Detalles",
   close: "Cerrar",
   previous: "Anterior",
@@ -5953,10 +6012,10 @@ var MIN_SUN_RADIUS = 34;
 var MIN_PLANET_RADIUS = 18;
 var MAX_SUN_RADIUS = 76;
 var MAX_PLANET_RADIUS = 48;
-var MAX_FOCUS_RING_COUNT = 7;
+var ROOMY_RING_LIMIT = 7;
 var FOCUS_RING_GAP_FACTOR = 2.15;
 var COMPACT_RING_GAP = 8;
-var MAX_COMPACT_RING_COUNT = 12;
+var COMPACT_RING_LIMIT = 12;
 var CROWDED_RING_COUNT = 4;
 var MOON_LIMIT = 6;
 var MOON_CLEARANCE = 2;
@@ -6128,23 +6187,28 @@ var calculateFocusRingPlan = (childCount, sunRadius, planetRadius, baseDim, comp
   if (childCount === 0) {
     return { rings: [], counts: [], ringGap: 0 };
   }
-  const roomy = ringPlan(childCount, planetRadius, Math.max(baseDim * 0.26, sunRadius + planetRadius + NODE_GAP * 1.3), planetRadius * FOCUS_RING_GAP_FACTOR + NODE_GAP, MAX_FOCUS_RING_COUNT);
+  const roomy = ringPlan(childCount, planetRadius, Math.max(baseDim * 0.26, sunRadius + planetRadius + NODE_GAP * 1.3), planetRadius * FOCUS_RING_GAP_FACTOR + NODE_GAP, ROOMY_RING_LIMIT);
   if (!compact || roomy.rings.length <= 1) {
     return roomy;
   }
-  const close = ringPlan(childCount, planetRadius, sunRadius + planetRadius + NODE_GAP, planetRadius * 2 + COMPACT_RING_GAP, MAX_COMPACT_RING_COUNT);
+  const close = ringPlan(childCount, planetRadius, sunRadius + planetRadius + NODE_GAP, planetRadius * 2 + COMPACT_RING_GAP, COMPACT_RING_LIMIT);
   return (close.rings.at(-1) ?? 0) < (roomy.rings.at(-1) ?? 0) ? close : roomy;
 };
-var ringPlan = (childCount, planetRadius, innerRingRadius, ringGap, maximumRings) => {
+var ringPlan = (childCount, planetRadius, innerRingRadius, ringGap, ringLimit) => {
   const rings = [];
   let totalCapacity = 0;
-  while (totalCapacity < childCount && rings.length < maximumRings) {
+  while (totalCapacity < childCount) {
     const radius = innerRingRadius + ringGap * rings.length;
     rings.push(radius);
     totalCapacity += focusRingCapacity(radius, planetRadius);
   }
-  const counts = distributeAcrossRings(childCount, rings, planetRadius);
-  return { rings, counts, ringGap };
+  const fewer = rings.slice(0, ringLimit);
+  const stretched = { rings: fewer, counts: distributeAcrossRings(childCount, fewer, planetRadius), ringGap };
+  if (rings.length <= ringLimit) {
+    return stretched;
+  }
+  const all = { rings, counts: distributeAcrossRings(childCount, rings, planetRadius), ringGap };
+  return (all.rings.at(-1) ?? 0) < (stretched.rings.at(-1) ?? 0) ? all : stretched;
 };
 var ringStartAngle = (ringIndex, count) => {
   return ringIndex % 2 === 0 ? -90 : -90 + 360 / count / 2;
@@ -6355,20 +6419,22 @@ var fitExtent = (kind, extent, viewport, insets, below = 0) => {
 var RING_GAP_PADDING = 7;
 var assignNodeColors = (tree, palette, ownColor = (node) => node.color) => {
   const colors = new Map;
-  const branchColors = palette.length > 1 ? palette.slice(1) : palette;
-  colors.set(tree.id, ownColor(tree) ?? palette[0]);
-  tree.children.forEach((branch, branchIndex) => {
-    const branchColor = ownColor(branch) ?? branchColors[branchIndex % branchColors.length];
+  const branchColors = branchPalette(palette);
+  const numbers = branchNumbers(tree.children, branchColors.length);
+  const chosen = (node) => ownColor(node) ?? (isPaletteNumber(node.paletteColor) ? paletteColorOf(branchColors, node.paletteColor) : undefined);
+  colors.set(tree.id, chosen(tree) ?? palette[0]);
+  for (const branch of tree.children) {
+    const branchColor = ownColor(branch) ?? paletteColorOf(branchColors, numbers.get(branch));
     colors.set(branch.id, branchColor);
     const visit = (node, inherited) => {
       node.children.forEach((child, siblingIndex) => {
-        const own = ownColor(child);
+        const own = chosen(child);
         colors.set(child.id, own ?? shade(inherited, siblingIndex));
         visit(child, own ?? inherited);
       });
     };
     visit(branch, branchColor);
-  });
+  }
   return colors;
 };
 var SHADES = [
@@ -8332,6 +8398,7 @@ ${pageStyles(theme)}
     <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>
@@ -8394,7 +8461,14 @@ body { font: 16px/1.5 system-ui, -apple-system, "Segoe UI", Roboto, sans-serif;
 .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; }`;
+[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");
@@ -8406,222 +8480,2804 @@ var escapeAttribute = (text) => {
   return escapeText(text).replace(/"/g, "&quot;");
 };
 
-// bin/example.ts
-var EXAMPLE_MAP = `---
-title: Product roadmap
-theme: paper
----
-# \uD83D\uDE80 Product roadmap
-What ships this year. Click a planet to fly into it; flick the orbit to spin it.
-
-## \uD83D\uDD2D Discovery <!-- orbit status: done -->
-Six weeks of research before we commit to scope.
-- [x] User interviews
-- [x] Pricing survey
-- Competitor teardown #research
-
-## \uD83C\uDFA8 Design
-<!-- orbit
-status: active
-color: "#C6B4F2"
--->
-![Color tokens of the design system](images/tokens.png)
-
-- [/] Design system refresh
-- Onboarding flow
-  Three screens, one decision each.
-- Dark mode
-
-## \uD83D\uDEE0 Build <!-- orbit status: active -->
-### Frontend
-- App shell
-- Offline sync <!-- orbit status: blocked -->
-  Waits on the [search index](#search-index).
-### Backend
-- Auth service <!-- orbit priority: 1, status: active -->
-- Search index
-
-## \uD83D\uDCC8 [Growth](https://example.com/growth-plan)
-- SEO content #marketing
-- Referral program <!-- orbit owner: Ana -->
-
-## \uD83C\uDFAC Launch
-[Launch trailer](https://www.youtube.com/watch?v=aqz-KE-bpKQ)
-
-- [ ] Launch event
-- [ ] Press kit
-`;
-
-// bin/orbit.ts
-var USAGE = `orbit: check, render and convert Orbit mind maps
-
-Usage:
-  orbit validate [--json] [--loose] [--tree] <file|->
-                                               Check a map and list every problem, with its line
-  orbit render [options] <file|->              Render a map to a standalone SVG
-  orbit export --html [options] <file|->       One web page with Orbit, the map and its pictures inside,
-                                               to explore it or present it in any browser, offline
-  orbit convert --to <md|yaml> <file|->        Convert between the markdown and YAML flavors
-  orbit example [--yaml]                       Print a map with the main features, to copy
-  orbit help                                   Show this message (so does --help after any command)
-  orbit --version                              Print the version of Orbit
-
-Validate options:
-  --json                Print the result as JSON: valid, flavor, root, nodes, depth (the
-                        levels below the root) and diagnostics
-  --loose               Exit 0 even when there are problems the map can work around
-  --tree                Print the map as Orbit reads it, a node a line with its #id
-                        (with --json, as "tree"), to see what became a node and find ids
-
-Render options:
-  --out <file>          Write the SVG to a file instead of stdout
-  --width <px>          Width of the drawing (default 1200)
-  --height <px>         Height of the drawing (default 800)
-  --theme <name>        paper, night, glass, glass-night, cosmos, blueprint, ink, contrast,
-                        flat, flat-night, material, material-night, liquid, liquid-night,
-                        or auto, which draws paper: a picture can't follow the reader's
-                        light or dark mode (default: the document's, or paper)
-  --view <focus|all>    focus draws the map as it opens, where only the node at the center
-                        and its children have labels; all draws the whole map (default:
-                        the document's, or focus)
-  --focus <node-id>     The node at the center in focus mode (default: the root)
-  --language <tag>      The language of the drawing's few words, such as an untitled
-                        map's name: en or es (default: en)
-
-Export options:
-  --out <file>          Write the page to a file instead of stdout
-  --title <text>        The page's title (default: the map's title, or its root's text)
-  --theme, --view, --focus, --language
-                        As for render; the page follows the reader's light or dark mode
-                        with --theme auto, and speaks the language's words
-
-Use "-" as the file to read from stdin. Output goes to stdout; problems go
-to stderr as file:line: severity: message [code].
-
-Exit codes: 0 when it worked (for validate, when the map is valid), 1 when the
-map has problems or can't be read, and 2 for a mistake in the command itself.
+// 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;
+};
 
-The whole format and API, for people and coding agents: llms-full.txt in this
-package, or https://cdn.jsdelivr.net/npm/@restless-dreams/orbit/llms-full.txt
-`;
-var packageVersion = () => {
-  for (const path of ["../package.json", "../../package.json"]) {
+// 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 {
-      const manifest = JSON.parse(readFileSync(new URL(path, import.meta.url), "utf8"));
-      if (manifest.name === "@restless-dreams/orbit" && manifest.version) {
-        return manifest.version;
-      }
+      return new TextDecoder(declared).decode(bytes);
     } catch {}
   }
-  return "unknown";
+  try {
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes);
+  } catch {
+    return new TextDecoder(declared ? "utf-8" : "windows-1252").decode(bytes);
+  }
 };
-var isYamlFile = (file) => {
-  return /\.ya?ml$/i.test(file);
+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 parseFile = (file, source, options = {}) => {
-  return isYamlFile(file) ? parseOrbitYAML(source, options) : parseOrbit(source, options);
+var parseHtml = (text) => {
+  return readMarkup(text, { html: true });
 };
-var readInput = (path) => {
-  return readFileSync(path === "-" ? 0 : path, "utf8");
+var isElement = (node) => {
+  return typeof node !== "string";
 };
-var runCli = (argv) => {
-  const [command, ...rest] = argv;
-  if (command === undefined || command === "help" || command === "-h" || command === "--help" || rest.includes("--help") || rest.includes("-h")) {
-    process.stdout.write(USAGE);
-    return command === undefined ? 2 : 0;
+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];
   }
-  if (command === "--version" || command === "-v" || command === "version") {
-    process.stdout.write(`${packageVersion()}
-`);
-    return 0;
+  for (const [name, value] of Object.entries(element.attributes)) {
+    if (localPart(name) === localName) {
+      return value;
+    }
   }
-  try {
-    if (command === "convert") {
-      let to = "";
-      let file = "";
-      for (let i = 0;i < rest.length; i++) {
-        if (rest[i] === "--to" || rest[i] === "-t") {
-          to = rest[++i] ?? "";
-        } else if (rest[i].startsWith("-") && rest[i] !== "-") {
-          process.stderr.write(`orbit convert: unknown option ${rest[i]}
-${USAGE}`);
-          return 2;
-        } else {
-          file = rest[i];
-        }
+  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]);
       }
-      if (!file || !/^(md|markdown|yaml|yml)$/.test(to)) {
-        process.stderr.write(`orbit convert: expected --to <md|yaml> <file|->
-${USAGE}`);
-        return 2;
+    } 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);
       }
-      const doc = parseFile(file, readInput(file));
-      printDiagnostics(file, doc.diagnostics ?? []);
-      process.stdout.write(/^(md|markdown)$/.test(to) ? serializeOrbitMarkdown(doc, { keepSource: false }) : serializeOrbitYAML(doc));
-      return 0;
+      index = end + 3;
+      continue;
     }
-    if (command === "example") {
-      const yaml = rest.includes("--yaml");
-      if (rest.some((argument) => argument !== "--yaml")) {
-        process.stderr.write(`orbit example: the only option is --yaml
-${USAGE}`);
-        return 2;
+    if (text.startsWith("<![CDATA[", index)) {
+      const end = text.indexOf("]]>", index + 9);
+      if (end === -1) {
+        fail("A CDATA section that never ends", index);
       }
-      process.stdout.write(yaml ? serializeOrbitYAML(parseOrbit(EXAMPLE_MAP)) : EXAMPLE_MAP);
-      return 0;
+      addText(text.slice(index + 9, end));
+      index = end + 3;
+      continue;
     }
-    if (command === "export") {
-      return exportCommand(rest);
+    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 (command === "render") {
-      return renderCommand(rest);
+    if (text.startsWith("<!", index)) {
+      index = skipDeclaration(text, index, fail);
+      continue;
     }
-    if (command === "validate") {
-      return validateCommand(rest);
+    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;
     }
-    process.stderr.write(`orbit: unknown command "${command}"
-${USAGE}`);
-    return 2;
-  } catch (err) {
-    process.stderr.write(`error: ${err.message}
-`);
-    return 1;
-  }
-};
-var readOptions = (command, argumentsList, names) => {
-  const values = {};
-  let file = "";
-  for (let index = 0;index < argumentsList.length; index++) {
-    const argument = argumentsList[index];
-    const name = argument.startsWith("--") ? argument.slice(2) : "";
-    if (names.includes(name)) {
-      const value = argumentsList[++index];
-      if (value === undefined) {
-        process.stderr.write(`orbit ${command}: ${argument} needs a value
-`);
-        return 2;
+    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;
       }
-      values[name] = value;
-    } else if (argument === "-" || !argument.startsWith("--")) {
-      file = argument;
-    } else {
-      process.stderr.write(`orbit ${command}: unknown option ${argument}
-${USAGE}`);
-      return 2;
+      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 (!file) {
-    process.stderr.write(`orbit ${command}: missing <file>
-${USAGE}`);
-    return 2;
+  if (!mode.html && open.length > 1) {
+    fail(`<${current().name}> is never closed`, text.length);
   }
-  return { values, file };
+  return fragment;
 };
-var checkLook = (command, values) => {
-  if (values.theme !== undefined && !isOrbitThemePreset(values.theme)) {
-    process.stderr.write(`orbit ${command}: unknown theme "${values.theme}". Themes: ${themeNames().join(", ")}.${didYouMean(values.theme, themeNames(), THEME_SYNONYMS)}
-`);
-    return 2;
+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"
+];
+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 = readOutline(outlines[0], report);
+  } else {
+    root = newIdea(title || baseName(options.name) || options.untitled || "Untitled map");
+    root.children = outlines.map((outline) => readOutline(outline, report));
+  }
+  return { format: "opml", maps: [{ document: buildDocument(root, report), media: {}, warnings: report.warnings }] };
+};
+var readOutline = (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) => readOutline(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" ? parseOrbit(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>${escapeXml3(title)}</title>`,
+    "  </head>",
+    "  <body>"
+  ];
+  const write = (node, depth) => {
+    const indent = "  ".repeat(depth + 2);
+    const attributes = outlineAttributes(node).map(([name, value]) => ` ${name}="${escapeXml3(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 escapeXml3 = (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).`);
+  }
+};
+
+// bin/example.ts
+var EXAMPLE_MAP = `---
+title: Product roadmap
+theme: paper
+---
+# \uD83D\uDE80 Product roadmap
+What ships this year. Click a planet to fly into it; flick the orbit to spin it.
+
+## \uD83D\uDD2D Discovery <!-- orbit status: done -->
+Six weeks of research before we commit to scope.
+- [x] User interviews
+- [x] Pricing survey
+- Competitor teardown #research
+
+## \uD83C\uDFA8 Design
+<!-- orbit
+status: active
+color: "#C6B4F2"
+-->
+![Color tokens of the design system](images/tokens.png)
+
+- [/] Design system refresh
+- Onboarding flow
+  Three screens, one decision each.
+- Dark mode
+
+## \uD83D\uDEE0 Build <!-- orbit status: active -->
+### Frontend
+- App shell
+- Offline sync <!-- orbit status: blocked -->
+  Waits on the [search index](#search-index).
+### Backend
+- Auth service <!-- orbit priority: 1, status: active -->
+- Search index
+
+## \uD83D\uDCC8 [Growth](https://example.com/growth-plan)
+- SEO content #marketing
+- Referral program <!-- orbit owner: Ana -->
+
+## \uD83C\uDFAC Launch
+[Launch trailer](https://www.youtube.com/watch?v=aqz-KE-bpKQ)
+
+- [ ] Launch event
+- [ ] Press kit
+`;
+
+// bin/orbit.ts
+var USAGE = `orbit: check, render and convert Orbit mind maps
+
+Usage:
+  orbit validate [--json] [--loose] [--tree] <file|->
+                                               Check a map and list every problem, with its line
+  orbit render [options] <file|->              Render a map to a standalone SVG
+  orbit export --html [options] <file|->       One web page with Orbit, the map and its pictures inside,
+                                               to explore it or present it in any browser, offline
+  orbit convert --to <md|yaml|opml> [--out <file>] <file|->
+                                               Convert between the markdown and YAML flavors and OPML, and
+                                               bring in maps from other apps: OPML, FreeMind and Freeplane
+                                               (.mm) and XMind (.xmind)
+  orbit example [--yaml]                       Print a map with the main features, to copy
+  orbit help                                   Show this message (so does --help after any command)
+  orbit --version                              Print the version of Orbit
+
+Validate options:
+  --json                Print the result as JSON: valid, flavor, root, nodes, depth (the
+                        levels below the root) and diagnostics
+  --loose               Exit 0 even when there are problems the map can work around
+  --tree                Print the map as Orbit reads it, a node a line with its #id
+                        (with --json, as "tree"), to see what became a node and find ids
+
+Render options:
+  --out <file>          Write the SVG to a file instead of stdout
+  --width <px>          Width of the drawing (default 1200)
+  --height <px>         Height of the drawing (default 800)
+  --theme <name>        paper, night, glass, glass-night, cosmos, blueprint, ink, contrast,
+                        flat, flat-night, material, material-night, liquid, liquid-night,
+                        or auto, which draws paper: a picture can't follow the reader's
+                        light or dark mode (default: the document's, or paper)
+  --view <focus|all>    focus draws the map as it opens, where only the node at the center
+                        and its children have labels; all draws the whole map (default:
+                        the document's, or focus)
+  --focus <node-id>     The node at the center in focus mode (default: the root)
+  --language <tag>      The language of the drawing's few words, such as an untitled
+                        map's name: en or es (default: en)
+
+Export options:
+  --out <file>          Write the page to a file instead of stdout
+  --title <text>        The page's title (default: the map's title, or its root's text)
+  --theme, --view, --focus, --language
+                        As for render; the page follows the reader's light or dark mode
+                        with --theme auto, and speaks the language's words
+
+Convert options:
+  --to <md|yaml|opml>   The flavor or format to write
+  --out <file>          Write to a file instead of stdout. An XMind workbook's pictures go
+                        in media/ next to it, and its other sheets in <file>-2, -3 and on
+
+Use "-" as the file to read from stdin. Output goes to stdout; problems go
+to stderr as file:line: severity: message [code].
+
+Exit codes: 0 when it worked (for validate, when the map is valid), 1 when the
+map has problems or can't be read, and 2 for a mistake in the command itself.
+
+The whole format and API, for people and coding agents: llms-full.txt in this
+package, or https://cdn.jsdelivr.net/npm/@restless-dreams/orbit/llms-full.txt
+`;
+var packageVersion = () => {
+  for (const path of ["../package.json", "../../package.json"]) {
+    try {
+      const manifest = JSON.parse(readFileSync(new URL(path, import.meta.url), "utf8"));
+      if (manifest.name === "@restless-dreams/orbit" && manifest.version) {
+        return manifest.version;
+      }
+    } catch {}
+  }
+  return "unknown";
+};
+var isYamlFile = (file) => {
+  return /\.ya?ml$/i.test(file);
+};
+var parseFile = (file, source, options = {}) => {
+  return isYamlFile(file) ? parseOrbitYAML(source, options) : parseOrbit(source, options);
+};
+var readInput = (path) => {
+  return readFileSync(path === "-" ? 0 : path, "utf8");
+};
+var runCli = (argv) => {
+  const [command, ...rest] = argv;
+  if (command === undefined || command === "help" || command === "-h" || command === "--help" || rest.includes("--help") || rest.includes("-h")) {
+    process.stdout.write(USAGE);
+    return command === undefined ? 2 : 0;
+  }
+  if (command === "--version" || command === "-v" || command === "version") {
+    process.stdout.write(`${packageVersion()}
+`);
+    return 0;
+  }
+  try {
+    if (command === "convert") {
+      return convertCommand(rest.map((argument) => argument === "-t" ? "--to" : argument));
+    }
+    if (command === "example") {
+      const yaml = rest.includes("--yaml");
+      if (rest.some((argument) => argument !== "--yaml")) {
+        process.stderr.write(`orbit example: the only option is --yaml
+${USAGE}`);
+        return 2;
+      }
+      process.stdout.write(yaml ? serializeOrbitYAML(parseOrbit(EXAMPLE_MAP)) : EXAMPLE_MAP);
+      return 0;
+    }
+    if (command === "export") {
+      return exportCommand(rest);
+    }
+    if (command === "render") {
+      return renderCommand(rest);
+    }
+    if (command === "validate") {
+      return validateCommand(rest);
+    }
+    process.stderr.write(`orbit: unknown command "${command}"
+${USAGE}`);
+    return 2;
+  } catch (err) {
+    process.stderr.write(`error: ${err.message}
+`);
+    return 1;
+  }
+};
+var readOptions = (command, argumentsList, names) => {
+  const values = {};
+  let file = "";
+  for (let index = 0;index < argumentsList.length; index++) {
+    const argument = argumentsList[index];
+    const name = argument.startsWith("--") ? argument.slice(2) : "";
+    if (names.includes(name)) {
+      const value = argumentsList[++index];
+      if (value === undefined) {
+        process.stderr.write(`orbit ${command}: ${argument} needs a value
+`);
+        return 2;
+      }
+      values[name] = value;
+    } else if (argument === "-" || !argument.startsWith("--")) {
+      file = argument;
+    } else {
+      process.stderr.write(`orbit ${command}: unknown option ${argument}
+${USAGE}`);
+      return 2;
+    }
+  }
+  if (!file) {
+    process.stderr.write(`orbit ${command}: missing <file>
+${USAGE}`);
+    return 2;
+  }
+  return { values, file };
+};
+var checkLook = (command, values) => {
+  if (values.theme !== undefined && !isOrbitThemePreset(values.theme)) {
+    process.stderr.write(`orbit ${command}: unknown theme "${values.theme}". Themes: ${themeNames().join(", ")}.${didYouMean(values.theme, themeNames(), THEME_SYNONYMS)}
+`);
+    return 2;
   }
   if (values.view !== undefined && values.view !== "focus" && values.view !== "all") {
     process.stderr.write(`orbit ${command}: --view must be focus or all
@@ -8641,6 +11297,109 @@ var checkFocus = (command, values, doc) => {
   }
   return null;
 };
+var writeAs = (to, doc) => {
+  if (to === "opml") {
+    return exportOPML(doc);
+  }
+  return /^(md|markdown)$/.test(to) ? serializeOrbitMarkdown(doc, { keepSource: false }) : serializeOrbitYAML(doc);
+};
+var convertCommand = (argumentsList) => {
+  const values = {};
+  let file = "";
+  for (let index = 0;index < argumentsList.length; index++) {
+    const argument = argumentsList[index];
+    if (argument === "--to" || argument === "--out") {
+      values[argument.slice(2)] = argumentsList[++index] ?? "";
+    } else if (argument.startsWith("-") && argument !== "-") {
+      process.stderr.write(`orbit convert: unknown option ${argument}
+${USAGE}`);
+      return 2;
+    } else {
+      file = argument;
+    }
+  }
+  const to = values.to ?? "";
+  if (!file || !/^(md|markdown|yaml|yml|opml)$/.test(to)) {
+    process.stderr.write(`orbit convert: expected --to <md|yaml|opml> <file|->
+${USAGE}`);
+    return 2;
+  }
+  const bytes = new Uint8Array(readFileSync(file === "-" ? 0 : file));
+  const format = detectImportFormat(bytes, file === "-" ? undefined : basename(file));
+  const name = file === "-" ? "<stdin>" : file;
+  if (format === null) {
+    const doc = parseFile(file, new TextDecoder().decode(bytes));
+    printDiagnostics(file, doc.diagnostics ?? []);
+    writeOutput(values.out, writeAs(to, doc));
+    return 0;
+  }
+  let imported;
+  try {
+    imported = importMap(bytes, { name: file === "-" ? undefined : basename(file), format });
+  } catch (error) {
+    if (error instanceof OrbitImportError) {
+      process.stderr.write(`${name}: error: ${error.message} [${error.code}]
+`);
+      return 1;
+    }
+    throw error;
+  }
+  const { maps } = imported;
+  maps.forEach((map, index) => {
+    const sheet = maps.length > 1 ? ` (sheet ${index + 1}, ${map.document.root.text || "untitled"})` : "";
+    for (const warning of map.warnings) {
+      process.stderr.write(`${name}${sheet}: warning: ${warning.message} [${warning.code}]
+`);
+    }
+  });
+  if (!values.out) {
+    const pictures = maps.reduce((count, map) => count + Object.keys(map.media).length, 0);
+    if (maps.length > 1) {
+      process.stderr.write(`${name}: the workbook has ${maps.length} sheets: this is the first. Write them all with --out.
+`);
+    }
+    if (pictures > 0) {
+      process.stderr.write(`${name}: ${pictures === 1 ? "one picture" : `${pictures} pictures`} inside the file ${pictures === 1 ? "was" : "were"} left out: write the map with --out to save them in media/ next to it.
+`);
+    }
+    process.stdout.write(writeAs(to, maps[0].document));
+    return 0;
+  }
+  const folder = dirname(values.out);
+  const extension = extname(values.out);
+  const stem = values.out.slice(0, values.out.length - extension.length);
+  maps.forEach((map, index) => {
+    const renamed = new Map;
+    for (const [path, data] of Object.entries(map.media)) {
+      let target = path;
+      for (let suffix = 2;existsSync(join(folder, target)) && !sameBytes(join(folder, target), data); suffix++) {
+        target = path.replace(/(\.[^.]+)$/, `-${index + 1}-${suffix}$1`);
+      }
+      mkdirSync(dirname(join(folder, target)), { recursive: true });
+      writeFileSync(join(folder, target), data);
+      renamed.set(path, target);
+    }
+    const out = index === 0 ? values.out : `${stem}-${index + 1}${extension}`;
+    let text = writeAs(to, map.document);
+    for (const [from, target] of renamed) {
+      if (from !== target) {
+        text = text.split(from).join(target);
+      }
+    }
+    writeFileSync(out, text);
+  });
+  return 0;
+};
+var sameBytes = (path, data) => {
+  return Buffer.from(readFileSync(path)).equals(Buffer.from(data));
+};
+var writeOutput = (out, text) => {
+  if (out) {
+    writeFileSync(out, text);
+  } else {
+    process.stdout.write(text);
+  }
+};
 var renderCommand = (argumentsList) => {
   const read = readOptions("render", argumentsList, ["out", "width", "height", "theme", "view", "focus", "language"]);
   if (typeof read === "number") {
@@ -8875,7 +11634,7 @@ ${USAGE}`);
     return 1;
   }
   const warnings = report.diagnostics.length;
-  process.stdout.write(`OK: ${plural(report.nodes, "node")}, ${plural(report.depth + 1, "level")}, ${plural(warnings, "warning")}
+  process.stdout.write(`OK: ${plural2(report.nodes, "node")}, ${plural2(report.depth + 1, "level")}, ${plural2(warnings, "warning")}
 `);
   return 0;
 };
@@ -8887,7 +11646,7 @@ var printDiagnostics = (file, diagnostics) => {
 `);
   }
 };
-var plural = (count, word) => {
+var plural2 = (count, word) => {
   return `${count} ${word}${count === 1 ? "" : "s"}`;
 };
 var countNodes = (node) => {
@@ -8903,5 +11662,5 @@ export {
   runCli
 };
 
-//# debugId=AC982841BE43EBFE64756E2164756E21
+//# debugId=7AC091CE99A9461164756E2164756E21
 //# sourceMappingURL=orbit.js.map