@diagrammo/dgmo 0.46.0 → 0.47.0

package/dist/chunk-5QXL4NYS.js

@@ -0,0 +1,553 @@
+import {
+  extractDatePrefix,
+  parseTimelineDate
+} from "./chunk-GMR5MFHJ.js";
+import {
+  AUTO_TAG_COLOR_SENTINEL,
+  finalizeAutoTagColors,
+  injectDefaultTagMetadata,
+  matchTagBlockHeading,
+  stripDefaultModifier,
+  tagAttrKey,
+  validateTagGroupNames,
+  validateTagValues
+} from "./chunk-QLCCJEJI.js";
+import {
+  EVENT_LINE_REGISTRY,
+  extractColor,
+  measureIndent,
+  parseFirstLine,
+  splitNameAndMeta,
+  tryParseSharedOption,
+  warnUnknownMetaKeys,
+  withTagAliases
+} from "./chunk-Y3J7VR52.js";
+import {
+  emit,
+  formatDgmoError,
+  makeDgmoError,
+  makeFail,
+  suggest
+} from "./chunk-CXK4DZH3.js";
+
+// src/event-line/diagnostics.ts
+var EVENT_LINE_DX = {
+  // parser.ts: 'event-line has no events.'
+  NO_EVENTS: {
+    code: "E_EVENT_LINE_NO_EVENTS",
+    severity: "error",
+    chartType: "event-line",
+    title: "No events",
+    message: "event-line has no events.",
+    hint: "Add at least one event line (e.g. `2020 Something happened`) below the header.",
+    example: `event-line Empty`
+  },
+  // parser.ts parseEventHeader:
+  //   `Use ISO dates (YYYY, YYYY-MM, or YYYY-MM-DD). Got '${firstToken}'.`
+  BAD_DATE: {
+    code: "E_EVENT_LINE_BAD_DATE",
+    // Runtime: emitted at `warning` despite the E_ prefix (see registry allowlist).
+    severity: "warning",
+    chartType: "event-line",
+    title: "Non-ISO date",
+    message: (p) => `Use ISO dates (YYYY, YYYY-MM, or YYYY-MM-DD). Got '${p.token ?? "7/16/1969"}'.`,
+    hint: "Write dates as YYYY, YYYY-MM, or YYYY-MM-DD \u2014 slash and dot separators are not parsed.",
+    example: `event-line X
+
+7/16/1969 Liftoff
+  Departs.`
+  },
+  // parser.ts emits three wordings under this one code (each passes the full
+  // wording as `reason`):
+  //   directive handler: `event-line is horizontal-only in v1; \`direction ${dir}\`
+  //                        (vertical orientation) is a fast-follow.`
+  //   `section` seam:     'Group events with `[Name]` era brackets (§28.6a), not `section`.'
+  //   parseEventHeader:   'event-line events are points; a date range (`->`) is not
+  //                        supported — using the start date.'
+  UNSUPPORTED: {
+    code: "E_EVENT_LINE_UNSUPPORTED",
+    // Runtime: emitted at `warning` despite the E_ prefix (see registry allowlist).
+    severity: "warning",
+    chartType: "event-line",
+    title: "Unsupported construct",
+    message: (p) => typeof p.reason === "string" && p.reason ? p.reason : "event-line is horizontal-only in v1; `direction TB` (vertical orientation) is a fast-follow.",
+    hint: "Only horizontal (`direction LR`) is supported; use `[Name]` era brackets (not `section`); events are single points, not date ranges (`->`).",
+    example: `event-line X
+direction TB
+
+2020 A
+  one`
+  },
+  // parser.ts validateEraDateOrder, two wordings switched by `rel`/`edge`:
+  //   `… but dated after era "${ahead.era}" begins (${ahead.date}). …`   rel=after,  edge=begins
+  //   `… but dated before era "${behind.era}" ends (${behind.date}). …`  rel=before, edge=ends
+  ERA_DATE_ORDER: {
+    code: "E_EVENT_LINE_ERA_DATE_ORDER",
+    // Runtime: emitted at `warning` despite the E_ prefix (see registry allowlist).
+    severity: "warning",
+    chartType: "event-line",
+    title: "Event breaks era chronology",
+    message: (p) => `"${p.label ?? "Sean Curtis CTO"}" (${p.date ?? "2025-04-15"}) is in era "${p.era ?? "Curtis"}" but dated ${p.rel ?? "after"} era "${p.otherEra ?? "Vasanth"}" ${p.edge ?? "begins"} (${p.otherDate ?? "2025-05-09"}). event-line eras run left-to-right by date \u2014 fix the date or move it to the right era, or their brackets will overlap.`,
+    hint: "Eras render as date-spanning brackets; keep every event dated within its era, or move it to the era that covers its date.",
+    example: `event-line X
+
+[Vasanth]
+  2025-04-01 Opening Day Outage
+  2025-05-09 Fire Kevin C
+
+[Curtis]
+  2025-04-15 Sean Curtis CTO
+  2025-09-01 The incident`
+  },
+  // parser.ts validateEventDateOrder:
+  //   `"${ev.label}" (${ev.date}) is out of order — it is dated before
+  //    "${prev.label}" (${prev.date}) listed above it. event-line reads
+  //    left-to-right by date; list events chronologically.`
+  DATE_ORDER: {
+    code: "E_EVENT_LINE_DATE_ORDER",
+    // Runtime: emitted at `warning` despite the E_ prefix (see registry allowlist).
+    severity: "warning",
+    chartType: "event-line",
+    title: "Events out of chronological order",
+    message: (p) => `"${p.label ?? "C"}" (${p.date ?? "2022"}) is out of order \u2014 it is dated before "${p.prevLabel ?? "B"}" (${p.prevDate ?? "2024"}) listed above it. event-line reads left-to-right by date; list events chronologically.`,
+    hint: "List dated events chronologically top-to-bottom; a later-listed event dated before the one above it is almost always a slip.",
+    example: `event-line X
+
+2020 A
+2024 B
+2022 C`
+  }
+};
+var EVENT_LINE_DIAGNOSTICS = Object.values(EVENT_LINE_DX);
+
+// src/event-line/parser.ts
+var NON_ISO_DATE_RE = /^\d{1,4}[/.]\d/;
+var TBD_RE = /^TBD\b/i;
+var SIDE_RE = /^side\s+(above|below|alternate)\b/i;
+var ERA_RE = /^\[([^\]]+)\]\s*(.*)$/;
+var ERA_COLLAPSED_RE = /\bcollapsed:\s*(true|false)\b/i;
+var SECTION_SEAM_RE = /^section\b/i;
+var DIRECTION_RE = /^direction\s+(\w+)/i;
+function parseEventLine(content, palette) {
+  const options = {
+    scale: true,
+    side: "alternate",
+    noTitle: false,
+    noBox: false,
+    noLegend: false
+  };
+  const result = {
+    type: "event-line",
+    title: null,
+    titleLineNumber: null,
+    events: [],
+    eras: [],
+    tagGroups: [],
+    options,
+    diagnostics: [],
+    error: null
+  };
+  const fail = makeFail(result);
+  const pushWarning = (line, message, code) => {
+    result.diagnostics.push(makeDgmoError(line, message, "warning", code));
+  };
+  const pushError = (line, message, code) => {
+    const diag = makeDgmoError(line, message, "error", code);
+    result.diagnostics.push(diag);
+    if (!result.error) result.error = formatDgmoError(diag);
+  };
+  if (!content?.trim()) return fail(0, "No content provided");
+  const lines = content.split("\n");
+  let contentStarted = false;
+  let headerParsed = false;
+  const sharedOptions = {};
+  let currentTagGroup = null;
+  let currentEvent = null;
+  let currentEra = null;
+  let eraIndent = -1;
+  let currentEventIndent = 0;
+  const aliasMap = /* @__PURE__ */ new Map();
+  for (let i = 0; i < lines.length; i++) {
+    const line = lines[i];
+    const lineNumber = i + 1;
+    const trimmed = line.trim();
+    if (!trimmed) {
+      currentTagGroup = null;
+      continue;
+    }
+    if (trimmed.startsWith("//")) continue;
+    const indent = measureIndent(line);
+    if (!headerParsed) {
+      const firstLine = parseFirstLine(trimmed);
+      if (firstLine?.chartType === "event-line") {
+        result.title = firstLine.title ?? null;
+        result.titleLineNumber = lineNumber;
+        headerParsed = true;
+        continue;
+      }
+      let msg = 'Expected "event-line [Title]" as the first line.';
+      const hint = suggest(firstLine?.chartType ?? trimmed, ["event-line"]);
+      if (hint) msg += ` ${hint}`;
+      return fail(lineNumber, msg);
+    }
+    const tagBlockMatch = matchTagBlockHeading(trimmed);
+    if (tagBlockMatch) {
+      if (contentStarted) {
+        pushError(
+          lineNumber,
+          "Tag groups must appear before event-line content",
+          "E_TAG_DECLARED_AFTER_CONTENT"
+        );
+        continue;
+      }
+      currentTagGroup = {
+        name: tagBlockMatch.name,
+        ...tagBlockMatch.alias !== void 0 && {
+          alias: tagBlockMatch.alias
+        },
+        entries: [],
+        lineNumber
+      };
+      if (tagBlockMatch.alias) {
+        aliasMap.set(
+          tagBlockMatch.alias.toLowerCase(),
+          tagAttrKey(tagBlockMatch.name)
+        );
+      }
+      aliasMap.set(
+        tagAttrKey(tagBlockMatch.name),
+        tagAttrKey(tagBlockMatch.name)
+      );
+      result.tagGroups.push(currentTagGroup);
+      continue;
+    }
+    if (currentTagGroup && !contentStarted && indent > 0) {
+      const { text: cleanEntry, isDefault } = stripDefaultModifier(trimmed);
+      const { label, color } = extractColor(
+        cleanEntry,
+        palette,
+        result.diagnostics,
+        lineNumber
+      );
+      if (isDefault || currentTagGroup.entries.length === 0) {
+        currentTagGroup.defaultValue = label;
+      }
+      currentTagGroup.entries.push({
+        value: label,
+        color: color ?? AUTO_TAG_COLOR_SENTINEL,
+        lineNumber
+      });
+      continue;
+    }
+    if (currentEvent && indent > currentEventIndent) {
+      const descLine = trimmed.startsWith("- ") ? `\u2022 ${trimmed.substring(2)}` : trimmed;
+      currentEvent.description.push(descLine);
+      continue;
+    }
+    const eraMatch = trimmed.match(ERA_RE);
+    if (eraMatch) {
+      contentStarted = true;
+      currentTagGroup = null;
+      currentEvent = null;
+      const name = eraMatch[1].trim();
+      let rest = (eraMatch[2] ?? "").trim();
+      let collapsed = false;
+      const cm = rest.match(ERA_COLLAPSED_RE);
+      if (cm) {
+        collapsed = cm[1].toLowerCase() === "true";
+        rest = (rest.slice(0, cm.index) + rest.slice(cm.index + cm[0].length)).trim();
+      }
+      let color = null;
+      if (rest) {
+        const token = rest.split(/\s+/).pop();
+        const ex = extractColor(
+          `x ${token}`,
+          palette,
+          result.diagnostics,
+          lineNumber
+        );
+        if (ex.color !== void 0) color = token;
+      }
+      const era = { name, color, collapsed, lineNumber };
+      result.eras.push(era);
+      currentEra = name;
+      eraIndent = indent;
+      continue;
+    }
+    if (indent === 0) {
+      currentTagGroup = null;
+      if (trimmed.toLowerCase() === "no-scale") {
+        options.scale = false;
+        continue;
+      }
+      const sideMatch = trimmed.match(SIDE_RE);
+      if (sideMatch) {
+        options.side = sideMatch[1].toLowerCase();
+        continue;
+      }
+      if (trimmed.toLowerCase() === "no-box") {
+        options.noBox = true;
+        continue;
+      }
+      if (trimmed.toLowerCase() === "no-legend") {
+        options.noLegend = true;
+        continue;
+      }
+      const dirMatch = trimmed.match(DIRECTION_RE);
+      if (dirMatch) {
+        const dir = dirMatch[1].toUpperCase();
+        if (dir !== "LR") {
+          result.diagnostics.push(
+            emit(EVENT_LINE_DX.UNSUPPORTED, lineNumber, {
+              reason: `event-line is horizontal-only in v1; \`direction ${dir}\` (vertical orientation) is a fast-follow.`
+            })
+          );
+        }
+        continue;
+      }
+      if (tryParseSharedOption(trimmed, sharedOptions)) continue;
+      if (SECTION_SEAM_RE.test(trimmed)) {
+        result.diagnostics.push(
+          emit(EVENT_LINE_DX.UNSUPPORTED, lineNumber, {
+            reason: "Group events with `[Name]` era brackets (\xA728.6a), not `section`."
+          })
+        );
+        continue;
+      }
+    }
+    const inEra = currentEra !== null && indent > eraIndent;
+    if (!inEra) currentEra = null;
+    contentStarted = true;
+    const event = parseEventHeader(
+      trimmed,
+      lineNumber,
+      currentEra,
+      aliasMap,
+      result.diagnostics,
+      pushWarning
+    );
+    result.events.push(event);
+    currentEvent = event;
+    currentEventIndent = indent;
+  }
+  options.noTitle = sharedOptions["no-title"] === "on";
+  resolveFutureEvents(result.events);
+  finalizeAutoTagColors(result.tagGroups, palette);
+  if (result.tagGroups.length > 0) {
+    validateTagValues(result.events, result.tagGroups, pushWarning, suggest);
+    validateTagGroupNames(result.tagGroups, pushWarning);
+    injectDefaultTagMetadata(result.events, result.tagGroups);
+  }
+  if (result.events.length === 0 && !result.error) {
+    const diag = emit(EVENT_LINE_DX.NO_EVENTS, result.titleLineNumber ?? 1);
+    result.diagnostics.push(diag);
+    result.error = formatDgmoError(diag);
+  }
+  const eraFlaggedLines = /* @__PURE__ */ new Set();
+  if (options.scale) {
+    validateEraDateOrder(result.events, result.eras, (err) => {
+      eraFlaggedLines.add(err.line);
+      result.diagnostics.push(err);
+    });
+  }
+  validateEventDateOrder(result.events, eraFlaggedLines, result.diagnostics);
+  return result;
+}
+function resolveFutureEvents(events) {
+  const realVals = events.filter((e) => !e.future && e.dateValue !== null).map((e) => e.dateValue);
+  if (realVals.length === 0) return;
+  const hiAll = Math.max(...realVals);
+  const loAll = Math.min(...realVals);
+  const pad = hiAll > loAll ? (hiAll - loAll) * 0.15 : 1;
+  const prevReal = [];
+  let carry = null;
+  for (const e of events) {
+    prevReal.push(carry);
+    if (!e.future && e.dateValue !== null) carry = e.dateValue;
+  }
+  const nextReal = new Array(events.length).fill(null);
+  carry = null;
+  for (let i2 = events.length - 1; i2 >= 0; i2--) {
+    nextReal[i2] = carry;
+    const e = events[i2];
+    if (!e.future && e.dateValue !== null) carry = e.dateValue;
+  }
+  let i = 0;
+  while (i < events.length) {
+    if (!events[i].future) {
+      i++;
+      continue;
+    }
+    const lo = prevReal[i];
+    const hi = nextReal[i];
+    let j = i;
+    while (j < events.length && events[j].future && prevReal[j] === lo && nextReal[j] === hi)
+      j++;
+    const group = events.slice(i, j);
+    const g = group.length;
+    if (lo !== null && hi !== null) {
+      group.forEach((e, k) => {
+        e.dateValue = lo + (hi - lo) * (k + 1) / (g + 1);
+        e.futureSpan = [lo, hi];
+      });
+    } else if (lo === null && hi !== null) {
+      const left = hi - pad;
+      group.forEach((e, k) => {
+        e.dateValue = left + (hi - left) * (k + 1) / (g + 1);
+        e.futureSpan = [left, hi];
+      });
+    } else {
+      group.forEach((e, k) => {
+        e.dateValue = hiAll + pad * (k + 1);
+        e.futureSpan = null;
+      });
+    }
+    i = j;
+  }
+}
+function validateEventDateOrder(events, skipLines, diagnostics) {
+  let prev = null;
+  for (const ev of events) {
+    if (ev.future || ev.dateValue === null) continue;
+    if (prev && ev.dateValue < prev.dateValue && !skipLines.has(ev.lineNumber)) {
+      diagnostics.push(
+        emit(EVENT_LINE_DX.DATE_ORDER, ev.lineNumber, {
+          label: ev.label,
+          date: ev.date,
+          prevLabel: prev.label,
+          prevDate: prev.date
+        })
+      );
+    }
+    prev = ev;
+  }
+}
+function validateEraDateOrder(events, eras, emitWarn) {
+  if (eras.length < 2) return;
+  const order = new Map(eras.map((e, i) => [e.name, i]));
+  const dated = events.filter(
+    (e) => !e.future && e.dateValue !== null && e.era !== null && order.has(e.era)
+  );
+  if (dated.length === 0) return;
+  const perEra = /* @__PURE__ */ new Map();
+  for (const ev of dated) {
+    const idx = order.get(ev.era);
+    const cur = perEra.get(idx);
+    if (!cur) {
+      perEra.set(idx, { min: ev, max: ev });
+    } else {
+      if (ev.dateValue < cur.min.dateValue) cur.min = ev;
+      if (ev.dateValue > cur.max.dateValue) cur.max = ev;
+    }
+  }
+  const n = eras.length;
+  const prefixMax = new Array(n).fill(null);
+  const suffixMin = new Array(n).fill(null);
+  for (let k = 1; k < n; k++) {
+    const prev = perEra.get(k - 1)?.max ?? null;
+    const carried = prefixMax[k - 1] ?? null;
+    prefixMax[k] = prev && (!carried || prev.dateValue > carried.dateValue) ? prev : carried;
+  }
+  for (let k = n - 2; k >= 0; k--) {
+    const next = perEra.get(k + 1)?.min ?? null;
+    const carried = suffixMin[k + 1] ?? null;
+    suffixMin[k] = next && (!carried || next.dateValue < carried.dateValue) ? next : carried;
+  }
+  for (const ev of dated) {
+    const k = order.get(ev.era);
+    const ahead = suffixMin[k];
+    const behind = prefixMax[k];
+    if (ahead && ev.dateValue > ahead.dateValue) {
+      emitWarn(
+        emit(EVENT_LINE_DX.ERA_DATE_ORDER, ev.lineNumber, {
+          label: ev.label,
+          date: ev.date,
+          era: ev.era,
+          rel: "after",
+          otherEra: ahead.era,
+          edge: "begins",
+          otherDate: ahead.date
+        })
+      );
+    } else if (behind && ev.dateValue < behind.dateValue) {
+      emitWarn(
+        emit(EVENT_LINE_DX.ERA_DATE_ORDER, ev.lineNumber, {
+          label: ev.label,
+          date: ev.date,
+          era: ev.era,
+          rel: "before",
+          otherEra: behind.era,
+          edge: "ends",
+          otherDate: behind.date
+        })
+      );
+    }
+  }
+}
+function parseEventHeader(trimmed, lineNumber, era, aliasMap, diagnostics, pushWarning) {
+  let date = null;
+  let dateValue = null;
+  let future = false;
+  let remainder = trimmed;
+  const tbdMatch = trimmed.match(TBD_RE);
+  if (tbdMatch) {
+    date = "TBD";
+    future = true;
+    remainder = trimmed.slice(tbdMatch[0].length).trimStart();
+  }
+  const prefix = future ? null : extractDatePrefix(trimmed);
+  if (prefix) {
+    date = prefix.startDate;
+    dateValue = parseTimelineDate(prefix.startDate);
+    remainder = prefix.remainder || "";
+    if (prefix.endDate) {
+      diagnostics.push(
+        emit(EVENT_LINE_DX.UNSUPPORTED, lineNumber, {
+          reason: "event-line events are points; a date range (`->`) is not supported \u2014 using the start date."
+        })
+      );
+    }
+  } else if (!future && NON_ISO_DATE_RE.test(trimmed)) {
+    const firstToken = trimmed.split(/\s+/)[0];
+    diagnostics.push(
+      emit(EVENT_LINE_DX.BAD_DATE, lineNumber, { token: firstToken })
+    );
+  }
+  const registry = withTagAliases(
+    EVENT_LINE_REGISTRY,
+    new Set(aliasMap.keys())
+  );
+  const split = splitNameAndMeta(
+    remainder,
+    registry,
+    aliasMap,
+    void 0,
+    diagnostics,
+    lineNumber
+  );
+  warnUnknownMetaKeys(
+    split.meta,
+    registry,
+    (msg) => pushWarning(lineNumber, msg),
+    split.name
+  );
+  const metadata = { ...split.meta };
+  if (split.color !== void 0) metadata["color"] = split.color;
+  return {
+    label: split.name || remainder.trim(),
+    lineNumber,
+    date,
+    dateValue,
+    future,
+    futureSpan: null,
+    metadata,
+    description: [],
+    era
+  };
+}
+
+export {
+  EVENT_LINE_DIAGNOSTICS,
+  parseEventLine
+};
+//# sourceMappingURL=chunk-5QXL4NYS.js.map

package/dist/chunk-5WRI5ZAA.js

@@ -0,0 +1,31 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+export {
+  __commonJS,
+  __toESM
+};
+//# sourceMappingURL=chunk-5WRI5ZAA.js.map

package/dist/chunk-6EK55ART.js

@@ -0,0 +1,117 @@
+import {
+  NOTE_GAP
+} from "./chunk-5DH3KYFH.js";
+
+// src/utils/notes/place.ts
+var NOTE_CLEAR = 14;
+var intersects = (a, b, pad) => !(a.right + pad <= b.left || b.right + pad <= a.left || a.bottom + pad <= b.top || b.bottom + pad <= a.top);
+function placeNotes(obstacles, requests, direction) {
+  const placements = /* @__PURE__ */ new Map();
+  const occupied = obstacles.map((p) => ({
+    left: p.x - p.width / 2,
+    top: p.y - p.height / 2,
+    right: p.x + p.width / 2,
+    bottom: p.y + p.height / 2
+  }));
+  for (const req of requests) {
+    if (req.collapsed) {
+      placements.set(req.key, {
+        collapsed: true,
+        side: "right",
+        x: 0,
+        y: 0
+      });
+      continue;
+    }
+    const p = req.node;
+    const cx = p.x;
+    const cy = p.y;
+    const nodeLeft = cx - p.width / 2;
+    const nodeRight = cx + p.width / 2;
+    const nodeTop = cy - p.height / 2;
+    const nodeBottom = cy + p.height / 2;
+    const { noteW, noteH } = req;
+    const rectFor = (side) => {
+      switch (side) {
+        case "right": {
+          const left = nodeRight + NOTE_GAP;
+          const top = cy - noteH / 2;
+          return { left, top, right: left + noteW, bottom: top + noteH };
+        }
+        case "left": {
+          const right = nodeLeft - NOTE_GAP;
+          const top = cy - noteH / 2;
+          return { left: right - noteW, top, right, bottom: top + noteH };
+        }
+        case "below": {
+          const left = cx - noteW / 2;
+          const top = nodeBottom + NOTE_GAP;
+          return { left, top, right: left + noteW, bottom: top + noteH };
+        }
+        case "above":
+        default: {
+          const left = cx - noteW / 2;
+          const bottom = nodeTop - NOTE_GAP;
+          return { left, top: bottom - noteH, right: left + noteW, bottom };
+        }
+      }
+    };
+    const order = direction === "LR" ? ["below", "above"] : ["right", "left"];
+    let chosen = null;
+    for (const side of order) {
+      const rect = rectFor(side);
+      if (!occupied.some((o) => intersects(rect, o, NOTE_CLEAR))) {
+        chosen = { rect, side };
+        break;
+      }
+    }
+    if (!chosen) {
+      const side = order[0];
+      let rect = rectFor(side);
+      const axisIsY = side === "above" || side === "below";
+      const outward = side === "below" || side === "right" ? 1 : -1;
+      for (let guard = 0; guard < 50; guard++) {
+        const blockers = occupied.filter(
+          (o) => intersects(rect, o, NOTE_CLEAR)
+        );
+        if (blockers.length === 0) break;
+        if (axisIsY && outward > 0) {
+          const top = Math.max(...blockers.map((b) => b.bottom)) + NOTE_CLEAR;
+          rect = { ...rect, top, bottom: top + noteH };
+        } else if (axisIsY) {
+          const bottom = Math.min(...blockers.map((b) => b.top)) - NOTE_CLEAR;
+          rect = { ...rect, bottom, top: bottom - noteH };
+        } else if (outward > 0) {
+          const left = Math.max(...blockers.map((b) => b.right)) + NOTE_CLEAR;
+          rect = { ...rect, left, right: left + noteW };
+        } else {
+          const right = Math.min(...blockers.map((b) => b.left)) - NOTE_CLEAR;
+          rect = { ...rect, right, left: right - noteW };
+        }
+      }
+      chosen = { rect, side };
+    }
+    occupied.push(chosen.rect);
+    placements.set(req.key, {
+      collapsed: false,
+      side: chosen.side,
+      x: chosen.rect.left - p.x,
+      y: chosen.rect.top - p.y
+    });
+  }
+  return placements;
+}
+
+// src/utils/notes/bounds.ts
+function noteCanvasShift(minX, minY, margin = 20) {
+  return {
+    shiftX: minX < 0 ? margin - minX : 0,
+    shiftY: minY < 0 ? margin - minY : 0
+  };
+}
+
+export {
+  placeNotes,
+  noteCanvasShift
+};
+//# sourceMappingURL=chunk-6EK55ART.js.map