docxodus 9.2.0 → 9.4.0

package/dist/embed.bundle.js

@@ -1,3 +1,118 @@
+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() {
+  try {
+    return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+  } catch (e) {
+    throw mod = 0, e;
+  }
+};
+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
+));
+
+// node_modules/bind-event-listener/dist/bind.js
+var require_bind = __commonJS({
+  "node_modules/bind-event-listener/dist/bind.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.bind = void 0;
+    function bind3(target, _a) {
+      var type = _a.type, listener = _a.listener, options = _a.options;
+      target.addEventListener(type, listener, options);
+      return function unbind() {
+        target.removeEventListener(type, listener, options);
+      };
+    }
+    exports.bind = bind3;
+  }
+});
+
+// node_modules/bind-event-listener/dist/bind-all.js
+var require_bind_all = __commonJS({
+  "node_modules/bind-event-listener/dist/bind-all.js"(exports) {
+    "use strict";
+    var __assign = exports && exports.__assign || function() {
+      __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+          s = arguments[i];
+          for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+            t[p] = s[p];
+        }
+        return t;
+      };
+      return __assign.apply(this, arguments);
+    };
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.bindAll = void 0;
+    var bind_1 = require_bind();
+    function toOptions(value) {
+      if (typeof value === "undefined") {
+        return void 0;
+      }
+      if (typeof value === "boolean") {
+        return {
+          capture: value
+        };
+      }
+      return value;
+    }
+    function getBinding(original, sharedOptions) {
+      if (sharedOptions == null) {
+        return original;
+      }
+      var binding = __assign(__assign({}, original), { options: __assign(__assign({}, toOptions(sharedOptions)), toOptions(original.options)) });
+      return binding;
+    }
+    function bindAll4(target, bindings, sharedOptions) {
+      var unbinds = bindings.map(function(original) {
+        var binding = getBinding(original, sharedOptions);
+        return (0, bind_1.bind)(target, binding);
+      });
+      return function unbindAll() {
+        unbinds.forEach(function(unbind) {
+          return unbind();
+        });
+      };
+    }
+    exports.bindAll = bindAll4;
+  }
+});
+
+// node_modules/bind-event-listener/dist/index.js
+var require_dist = __commonJS({
+  "node_modules/bind-event-listener/dist/index.js"(exports) {
+    "use strict";
+    Object.defineProperty(exports, "__esModule", { value: true });
+    exports.bindAll = exports.bind = void 0;
+    var bind_1 = require_bind();
+    Object.defineProperty(exports, "bind", { enumerable: true, get: function() {
+      return bind_1.bind;
+    } });
+    var bind_all_1 = require_bind_all();
+    Object.defineProperty(exports, "bindAll", { enumerable: true, get: function() {
+      return bind_all_1.bindAll;
+    } });
+  }
+});
+
 // src/types.ts
 var ProjectionScopes = /* @__PURE__ */ ((ProjectionScopes2) => {
   ProjectionScopes2[ProjectionScopes2["Body"] = 1] = "Body";
@@ -310,6 +425,12 @@ var DocxSession = class {
   deleteBlock(anchorId) {
     return JSON.parse(this.wasm.DeleteBlock(this.handle, anchorId));
   }
+  /** Reorder one top-level paragraph/heading/list/table block relative to another. */
+  moveBlock(sourceAnchorId, targetAnchorId, position) {
+    return JSON.parse(
+      this.wasm.MoveBlock(this.handle, sourceAnchorId, targetAnchorId, position)
+    );
+  }
   /**
    * Delete every top-level block-level sibling between `fromAnchorId` (inclusive)
    * and `toAnchorIdExclusive` (exclusive). Both anchors must share a direct
@@ -370,7 +491,9 @@ var DocxSession = class {
    * Table row/column editing, addressed by a cell-paragraph anchor (e.g. one returned from
    * {@link insertTable}'s `created`). Insert clones the reference row/column's widths and starts
    * empty (`created` lists the new cell-paragraph anchors); delete of the last row/column removes
-   * the whole table. v1 assumes a rectangular grid (no horizontal cell merges).
+   * the whole table. All four are grid-aware: inserting across a merge extends it, deleting
+   * through one narrows it, and deleting a vertical merge's lead row promotes the next row to
+   * carry it — the grid is never left ragged.
    */
   insertTableRow(cellAnchorId, position) {
     return JSON.parse(this.wasm.InsertTableRow(this.handle, cellAnchorId, position));
@@ -384,6 +507,28 @@ var DocxSession = class {
   deleteTableColumn(cellAnchorId) {
     return JSON.parse(this.wasm.DeleteTableColumn(this.handle, cellAnchorId));
   }
+  /**
+   * Merge the rectangle of cells anchored at `cellAnchorId` running `rowSpan` rows down ×
+   * `colSpan` cells right (Word's *Merge Cells*): `w:gridSpan` for the horizontal extent,
+   * `w:vMerge` restart/continue for the vertical one. The rectangle must tile the same whole grid
+   * columns in every row it covers and must not clip a vertical merge entering from above or
+   * continuing below — a partial overlap fails with `invalid_table_merge` instead of tearing the
+   * grid. `content` decides what happens to the absorbed cells' content (default `"append"`).
+   */
+  mergeCells(cellAnchorId, rowSpan, colSpan, content = "append") {
+    return JSON.parse(
+      this.wasm.MergeCells(this.handle, cellAnchorId, rowSpan, colSpan, content)
+    );
+  }
+  /**
+   * Split the merged cell at `cellAnchorId` back into unit cells, dropping its `w:gridSpan` and
+   * `w:vMerge` markup and restoring one cell per grid column (each taking its `w:tblGrid` width).
+   * Addressing a vertical-merge continuation unmerges the whole run. A cell with no merge markup
+   * fails with `invalid_table_merge`.
+   */
+  unmergeCells(cellAnchorId) {
+    return JSON.parse(this.wasm.UnmergeCells(this.handle, cellAnchorId));
+  }
   /**
    * Table styling, addressed by a cell-paragraph anchor — the post-insert counterpart of
    * {@link insertTable}'s options (issue #315 Stage A). `setColumnWidths` retunes `w:tblGrid` +
@@ -1286,9 +1431,9 @@ var PaginationEngine = class {
     for (const section of Array.from(sections)) {
       const index = parseInt(section.dataset.sectionIndex || "0", 10);
       const rawStart = section.dataset.pageNumStart;
-      const start = rawStart === void 0 ? void 0 : parseInt(rawStart, 10);
+      const start2 = rawStart === void 0 ? void 0 : parseInt(rawStart, 10);
       map.set(index, {
-        start: start !== void 0 && Number.isFinite(start) ? start : void 0,
+        start: start2 !== void 0 && Number.isFinite(start2) ? start2 : void 0,
         format: section.dataset.pageNumFmt
       });
     }
@@ -1513,16 +1658,16 @@ var PaginationEngine = class {
       return null;
     }
     const groups = [];
-    let start = 0;
-    while (start < rows.length) {
-      let end = start;
+    let start2 = 0;
+    while (start2 < rows.length) {
+      let end = start2;
       while (end < rows.length) {
         const candidate = this.createSimpleTableFragment(
           wrapper,
           table,
           body,
-          rows.slice(start, end + 1),
-          start === 0
+          rows.slice(start2, end + 1),
+          start2 === 0
         );
         const measured = this.measureElement(candidate, dims);
         if (measured.heightPt > maximumFragmentHeight) {
@@ -1530,11 +1675,11 @@ var PaginationEngine = class {
         }
         end++;
       }
-      if (end === start) {
+      if (end === start2) {
         return null;
       }
-      groups.push(rows.slice(start, end));
-      start = end;
+      groups.push(rows.slice(start2, end));
+      start2 = end;
     }
     if (groups.length < 2) {
       return null;
@@ -2849,9 +2994,9 @@ var HeaderFooterRegion = class {
     const commitStart = () => {
       const raw = pageStart.value.trim();
       if (raw === "") return;
-      const start = Number(raw);
-      if (!Number.isInteger(start) || start < 0) return;
-      this.setPageNumbering({ start });
+      const start2 = Number(raw);
+      if (!Number.isInteger(start2) || start2 < 0) return;
+      this.setPageNumbering({ start: start2 });
     };
     pageStart.addEventListener("blur", commitStart);
     pageStart.addEventListener("keydown", (e) => {
@@ -2902,8 +3047,8 @@ var HeaderFooterRegion = class {
     if (pageFmt) pageFmt.value = this.sectionInfo?.pageNumberFormat ?? "";
     const pageStart = band.querySelector("[data-hf-pagestart]");
     if (pageStart && document.activeElement !== pageStart) {
-      const start = this.sectionInfo?.pageNumberStart;
-      pageStart.value = start === void 0 ? "" : String(start);
+      const start2 = this.sectionInfo?.pageNumberStart;
+      pageStart.value = start2 === void 0 ? "" : String(start2);
     }
     const inherited = this.refFor(which, kind)?.inherited === true;
     band.toggleAttribute("data-hf-inherited", inherited);
@@ -2951,65 +3096,2466 @@ var HeaderFooterRegion = class {
       el.setAttribute("data-hf-focused", "true");
     });
   }
-  renderStoryBlock(anchorId) {
-    const html = this.bridge.RenderBlockHtml(
-      this.handle,
-      anchorId,
-      this.options.cssPrefix,
-      this.options.fabricateClasses
-    );
-    if (html.charCodeAt(0) === 123) return null;
-    return new DOMParser().parseFromString(html, "text/html").body.firstElementChild;
+  renderStoryBlock(anchorId) {
+    const html = this.bridge.RenderBlockHtml(
+      this.handle,
+      anchorId,
+      this.options.cssPrefix,
+      this.options.fabricateClasses
+    );
+    if (html.charCodeAt(0) === 123) return null;
+    return new DOMParser().parseFromString(html, "text/html").body.firstElementChild;
+  }
+  placeholder(which, kind) {
+    const el = document.createElement("div");
+    el.className = "docx-hf-placeholder";
+    el.setAttribute("data-hf-placeholder", "");
+    const label = KIND_LABELS.find((k) => k.value === kind)?.label ?? kind;
+    el.textContent = `No ${label.toLowerCase()} ${which} \u2014 pick a kind to create one.`;
+    return el;
+  }
+  /**
+   * Surface the caveat that comes with the selected kind. Turning on first/even means those pages
+   * stop using the Default stories entirely, which bites hardest on the OTHER band: enabling an
+   * even header with no even footer leaves even pages footer-less, and enabling a first-page
+   * header with an empty first-page footer leaves page 1 footer-less. The note is shown whenever
+   * first/even is selected (the behavior change is real either way); the fix button appears only
+   * when the counterpart story is missing entirely, which is what a user almost always wants next.
+   */
+  renderKindWarning(which) {
+    const band = this.bandFor(which);
+    const warning = band.querySelector("[data-hf-warning]");
+    if (!warning) return;
+    const kind = this.kinds[which];
+    if (kind === "default") {
+      warning.hidden = true;
+      warning.textContent = "";
+      return;
+    }
+    const other = which === "header" ? "footer" : "header";
+    warning.hidden = false;
+    warning.textContent = `${kind === "even" ? EVEN_WARNING : FIRST_WARNING} `;
+    if (this.partUriFor(other, kind)) return;
+    const fix = document.createElement("button");
+    fix.type = "button";
+    fix.setAttribute("data-hf-fix-counterpart", "");
+    fix.textContent = `Also create a ${kind === "even" ? "matching even" : "first-page"} ${other}`;
+    fix.addEventListener("click", () => {
+      this.setKind(other, kind);
+      this.renderKindWarning(which);
+    });
+    warning.appendChild(fix);
+  }
+};
+function parseResult(json) {
+  try {
+    return JSON.parse(json);
+  } catch {
+    return { success: false };
+  }
+}
+
+// node_modules/@babel/runtime/helpers/esm/arrayWithHoles.js
+function _arrayWithHoles(r) {
+  if (Array.isArray(r)) return r;
+}
+
+// node_modules/@babel/runtime/helpers/esm/iterableToArrayLimit.js
+function _iterableToArrayLimit(r, l) {
+  var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (null != t) {
+    var e, n, i, u, a = [], f = true, o = false;
+    try {
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = false;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = true) ;
+    } catch (r2) {
+      o = true, n = r2;
+    } finally {
+      try {
+        if (!f && null != t["return"] && (u = t["return"](), Object(u) !== u)) return;
+      } finally {
+        if (o) throw n;
+      }
+    }
+    return a;
+  }
+}
+
+// node_modules/@babel/runtime/helpers/esm/arrayLikeToArray.js
+function _arrayLikeToArray(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+
+// node_modules/@babel/runtime/helpers/esm/unsupportedIterableToArray.js
+function _unsupportedIterableToArray(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
+  }
+}
+
+// node_modules/@babel/runtime/helpers/esm/nonIterableRest.js
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+// node_modules/@babel/runtime/helpers/esm/slicedToArray.js
+function _slicedToArray(r, e) {
+  return _arrayWithHoles(r) || _iterableToArrayLimit(r, e) || _unsupportedIterableToArray(r, e) || _nonIterableRest();
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/adapter/element-adapter.js
+var import_bind_event_listener4 = __toESM(require_dist());
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/honey-pot-fix/honey-pot-data-attribute.js
+var honeyPotDataAttribute = "data-pdnd-honey-pot";
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/honey-pot-fix/is-honey-pot-element.js
+function isHoneyPotElement(target) {
+  return target instanceof Element && target.hasAttribute(honeyPotDataAttribute);
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/honey-pot-fix/get-element-from-point-without-honey-pot.js
+function getElementFromPointWithoutHoneypot(client) {
+  var _document$elementsFro = document.elementsFromPoint(client.x, client.y), _document$elementsFro2 = _slicedToArray(_document$elementsFro, 2), top2 = _document$elementsFro2[0], second = _document$elementsFro2[1];
+  if (!top2) {
+    return null;
+  }
+  if (isHoneyPotElement(top2)) {
+    return second !== null && second !== void 0 ? second : null;
+  }
+  return top2;
+}
+
+// node_modules/@babel/runtime/helpers/esm/typeof.js
+function _typeof(o) {
+  "@babel/helpers - typeof";
+  return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o2) {
+    return typeof o2;
+  } : function(o2) {
+    return o2 && "function" == typeof Symbol && o2.constructor === Symbol && o2 !== Symbol.prototype ? "symbol" : typeof o2;
+  }, _typeof(o);
+}
+
+// node_modules/@babel/runtime/helpers/esm/toPrimitive.js
+function toPrimitive(t, r) {
+  if ("object" != _typeof(t) || !t) return t;
+  var e = t[Symbol.toPrimitive];
+  if (void 0 !== e) {
+    var i = e.call(t, r || "default");
+    if ("object" != _typeof(i)) return i;
+    throw new TypeError("@@toPrimitive must return a primitive value.");
+  }
+  return ("string" === r ? String : Number)(t);
+}
+
+// node_modules/@babel/runtime/helpers/esm/toPropertyKey.js
+function toPropertyKey(t) {
+  var i = toPrimitive(t, "string");
+  return "symbol" == _typeof(i) ? i : i + "";
+}
+
+// node_modules/@babel/runtime/helpers/esm/defineProperty.js
+function _defineProperty(e, r, t) {
+  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
+    value: t,
+    enumerable: true,
+    configurable: true,
+    writable: true
+  }) : e[r] = t, e;
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/honey-pot-fix/make-honey-pot-fix.js
+var import_bind_event_listener = __toESM(require_dist());
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/max-z-index.js
+var maxZIndex = 2147483647;
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/popover-reset-styles.js
+var popoverResetUserAgentStyles = {
+  inset: "unset",
+  border: "none",
+  padding: 0,
+  margin: 0,
+  overflow: "visible",
+  color: "inherit",
+  background: "transparent",
+  width: "auto",
+  height: "auto"
+};
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/public-utils/once.js
+function once(fn) {
+  var cache = null;
+  return function wrapped() {
+    if (!cache) {
+      for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+        args[_key] = arguments[_key];
+      }
+      var result = fn.apply(this, args);
+      cache = {
+        result
+      };
+    }
+    return cache.result;
+  };
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/supports-popover.js
+var supportsPopover = once(function supportsPopover2() {
+  return typeof HTMLElement !== "undefined" && typeof HTMLElement.prototype.showPopover === "function";
+});
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/honey-pot-fix/make-honey-pot-fix.js
+function ownKeys(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+var honeyPotSize = 2;
+var halfHoneyPotSize = honeyPotSize / 2;
+function floorToClosestPixel(point) {
+  return {
+    x: Math.floor(point.x),
+    y: Math.floor(point.y)
+  };
+}
+function pullBackByHalfHoneyPotSize(point) {
+  return {
+    x: point.x - halfHoneyPotSize,
+    y: point.y - halfHoneyPotSize
+  };
+}
+function preventGoingBackwardsOffScreen(point) {
+  return {
+    x: Math.max(point.x, 0),
+    y: Math.max(point.y, 0)
+  };
+}
+function preventGoingForwardsOffScreen(point) {
+  return {
+    x: Math.min(point.x, window.innerWidth - honeyPotSize),
+    y: Math.min(point.y, window.innerHeight - honeyPotSize)
+  };
+}
+function getHoneyPotRectFor(_ref) {
+  var client = _ref.client;
+  var point = preventGoingForwardsOffScreen(preventGoingBackwardsOffScreen(pullBackByHalfHoneyPotSize(floorToClosestPixel(client))));
+  return DOMRect.fromRect({
+    x: point.x,
+    y: point.y,
+    width: honeyPotSize,
+    height: honeyPotSize
+  });
+}
+function getRectStyles(_ref2) {
+  var clientRect = _ref2.clientRect;
+  return {
+    left: "".concat(clientRect.left, "px"),
+    top: "".concat(clientRect.top, "px"),
+    width: "".concat(clientRect.width, "px"),
+    height: "".concat(clientRect.height, "px")
+  };
+}
+function isWithin(_ref3) {
+  var client = _ref3.client, clientRect = _ref3.clientRect;
+  return (
+    // is within horizontal bounds
+    client.x >= clientRect.x && client.x <= clientRect.x + clientRect.width && // is within vertical bounds
+    client.y >= clientRect.y && client.y <= clientRect.y + clientRect.height
+  );
+}
+function mountHoneyPot(_ref4) {
+  var initial = _ref4.initial;
+  var element = document.createElement("div");
+  element.setAttribute(honeyPotDataAttribute, "true");
+  if (supportsPopover()) {
+    element.setAttribute("popover", "manual");
+  }
+  var clientRect = getHoneyPotRectFor({
+    client: initial
+  });
+  Object.assign(element.style, _objectSpread(_objectSpread({
+    position: "fixed"
+  }, supportsPopover() ? (
+    // needs to come first as it has 'inset: unset' which
+    // needs to be overridden by our top / left values
+    popoverResetUserAgentStyles
+  ) : {
+    // Fallback: using maximum possible z-index so that this element
+    // will always be on top of other positioned content.
+    zIndex: maxZIndex
+  }), {}, {
+    // Setting a background color explicitly to avoid any inherited styles.
+    // Looks like this could be `opacity: 0`, but worried that _might_
+    // cause the element to be ignored on some platforms.
+    // When debugging, set backgroundColor to something like "red".
+    backgroundColor: "transparent",
+    // Being explicit to avoid inheriting styles
+    padding: 0,
+    margin: 0,
+    boxSizing: "border-box",
+    // We want this element to absorb pointer events,
+    // it's kind of the whole point 😉
+    pointerEvents: "auto"
+  }, getRectStyles({
+    clientRect
+  })));
+  document.body.appendChild(element);
+  if (supportsPopover()) {
+    element.showPopover();
+  }
+  var unbindPointerMove = (0, import_bind_event_listener.bind)(window, {
+    type: "pointermove",
+    listener: function listener(event) {
+      var client = {
+        x: event.clientX,
+        y: event.clientY
+      };
+      clientRect = getHoneyPotRectFor({
+        client
+      });
+      Object.assign(element.style, getRectStyles({
+        clientRect
+      }));
+    },
+    // using capture so we are less likely to be impacted by event stopping
+    options: {
+      capture: true
+    }
+  });
+  return function finish(_ref5) {
+    var current = _ref5.current;
+    unbindPointerMove();
+    if (isWithin({
+      client: current,
+      clientRect
+    })) {
+      element.remove();
+      return;
+    }
+    function cleanup() {
+      unbindPostDragEvents();
+      element.remove();
+    }
+    var unbindPostDragEvents = (0, import_bind_event_listener.bindAll)(window, [
+      {
+        type: "pointerdown",
+        listener: cleanup
+      },
+      {
+        type: "pointermove",
+        listener: cleanup
+      },
+      {
+        type: "focusin",
+        listener: cleanup
+      },
+      {
+        type: "focusout",
+        listener: cleanup
+      },
+      // a 'pointerdown' should happen before 'dragstart', but just being super safe
+      {
+        type: "dragstart",
+        listener: cleanup
+      },
+      // if the user has dragged something out of the window
+      // and then is dragging something back into the window
+      // the first events we will see are "dragenter" (and then "dragover").
+      // So if we see any of these we need to clear the post drag fix.
+      {
+        type: "dragenter",
+        listener: cleanup
+      },
+      {
+        type: "dragover",
+        listener: cleanup
+      }
+      // Not adding a "wheel" event listener, as "wheel" by itself does not
+      // resolve the bug.
+    ], {
+      // Using `capture` so less likely to be impacted by other code stopping events
+      capture: true
+    });
+  };
+}
+function makeHoneyPotFix() {
+  var latestPointerMove = null;
+  function bindEvents() {
+    latestPointerMove = null;
+    return (0, import_bind_event_listener.bind)(window, {
+      type: "pointermove",
+      listener: function listener(event) {
+        latestPointerMove = {
+          x: event.clientX,
+          y: event.clientY
+        };
+      },
+      // listening for pointer move in capture phase
+      // so we are less likely to be impacted by events being stopped.
+      options: {
+        capture: true
+      }
+    });
+  }
+  function getOnPostDispatch() {
+    var finish = null;
+    return function onPostEvent(_ref6) {
+      var eventName = _ref6.eventName, payload = _ref6.payload;
+      if (eventName === "onDragStart") {
+        var input = payload.location.initial.input;
+        var initial = latestPointerMove !== null && latestPointerMove !== void 0 ? latestPointerMove : {
+          x: input.clientX,
+          y: input.clientY
+        };
+        finish = mountHoneyPot({
+          initial
+        });
+      }
+      if (eventName === "onDrop") {
+        var _finish;
+        var _input = payload.location.current.input;
+        (_finish = finish) === null || _finish === void 0 || _finish({
+          current: {
+            x: _input.clientX,
+            y: _input.clientY
+          }
+        });
+        finish = null;
+        latestPointerMove = null;
+      }
+    };
+  }
+  return {
+    bindEvents,
+    getOnPostDispatch
+  };
+}
+
+// node_modules/@babel/runtime/helpers/esm/arrayWithoutHoles.js
+function _arrayWithoutHoles(r) {
+  if (Array.isArray(r)) return _arrayLikeToArray(r);
+}
+
+// node_modules/@babel/runtime/helpers/esm/iterableToArray.js
+function _iterableToArray(r) {
+  if ("undefined" != typeof Symbol && null != r[Symbol.iterator] || null != r["@@iterator"]) return Array.from(r);
+}
+
+// node_modules/@babel/runtime/helpers/esm/nonIterableSpread.js
+function _nonIterableSpread() {
+  throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+}
+
+// node_modules/@babel/runtime/helpers/esm/toConsumableArray.js
+function _toConsumableArray(r) {
+  return _arrayWithoutHoles(r) || _iterableToArray(r) || _unsupportedIterableToArray(r) || _nonIterableSpread();
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/ledger/lifecycle-manager.js
+var import_bind_event_listener3 = __toESM(require_dist());
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/is-firefox.js
+var isFirefox = once(function isFirefox2() {
+  if (false) {
+    return false;
+  }
+  return navigator.userAgent.includes("Firefox");
+});
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/is-safari.js
+var isSafari = once(function isSafari2() {
+  if (false) {
+    return false;
+  }
+  var _navigator = navigator, userAgent = _navigator.userAgent;
+  return userAgent.includes("AppleWebKit") && !userAgent.includes("Chrome");
+});
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/changing-window/count-events-for-safari.js
+var import_bind_event_listener2 = __toESM(require_dist());
+var symbols = {
+  isLeavingWindow: /* @__PURE__ */ Symbol("leaving"),
+  isEnteringWindow: /* @__PURE__ */ Symbol("entering")
+};
+function isLeavingWindowInSafari(_ref2) {
+  var dragLeave = _ref2.dragLeave;
+  if (!isSafari()) {
+    return false;
+  }
+  return dragLeave.hasOwnProperty(symbols.isLeavingWindow);
+}
+(function fixSafari() {
+  if (typeof window === "undefined") {
+    return;
+  }
+  if (false) {
+    return;
+  }
+  if (!isSafari()) {
+    return;
+  }
+  function getInitialState() {
+    return {
+      enterCount: 0,
+      isOverWindow: false
+    };
+  }
+  var state = getInitialState();
+  function resetState() {
+    state = getInitialState();
+  }
+  (0, import_bind_event_listener2.bindAll)(
+    window,
+    [{
+      type: "dragstart",
+      listener: function listener() {
+        state.enterCount = 0;
+        state.isOverWindow = true;
+      }
+    }, {
+      type: "drop",
+      listener: resetState
+    }, {
+      type: "dragend",
+      listener: resetState
+    }, {
+      type: "dragenter",
+      listener: function listener(event) {
+        if (!state.isOverWindow && state.enterCount === 0) {
+          event[symbols.isEnteringWindow] = true;
+        }
+        state.isOverWindow = true;
+        state.enterCount++;
+      }
+    }, {
+      type: "dragleave",
+      listener: function listener(event) {
+        state.enterCount--;
+        if (state.isOverWindow && state.enterCount === 0) {
+          event[symbols.isLeavingWindow] = true;
+          state.isOverWindow = false;
+        }
+      }
+    }],
+    // using `capture: true` so that adding event listeners
+    // in bubble phase will have the correct symbols
+    {
+      capture: true
+    }
+  );
+})();
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/changing-window/is-from-another-window.js
+function isNodeLike(target) {
+  return "nodeName" in target;
+}
+function isFromAnotherWindow(eventTarget) {
+  return isNodeLike(eventTarget) && eventTarget.ownerDocument !== document;
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/changing-window/is-leaving-window.js
+function isLeavingWindow(_ref) {
+  var dragLeave = _ref.dragLeave;
+  var type = dragLeave.type, relatedTarget = dragLeave.relatedTarget;
+  if (type !== "dragleave") {
+    return false;
+  }
+  if (isSafari()) {
+    return isLeavingWindowInSafari({
+      dragLeave
+    });
+  }
+  if (relatedTarget == null) {
+    return true;
+  }
+  if (isFirefox()) {
+    return isFromAnotherWindow(relatedTarget);
+  }
+  return relatedTarget instanceof HTMLIFrameElement;
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/detect-broken-drag.js
+function getBindingsForBrokenDrags(_ref) {
+  var onDragEnd = _ref.onDragEnd;
+  return [
+    // ## Detecting drag ending for removed draggables
+    //
+    // If a draggable element is removed during a drag and the user drops:
+    // 1. if over a valid drop target: we get a "drop" event to know the drag is finished
+    // 2. if not over a valid drop target (or cancelled): we get nothing
+    // The "dragend" event will not fire on the source draggable if it has been
+    // removed from the DOM.
+    // So we need to figure out if a drag operation has finished by looking at other events
+    // We can do this by looking at other events
+    // ### First detection: "pointermove" events
+    // 1. "pointermove" events cannot fire during a drag and drop operation
+    // according to the spec. So if we get a "pointermove" it means that
+    // the drag and drop operations has finished. So if we get a "pointermove"
+    // we know that the drag is over
+    // 2. 🦊😤 Drag and drop operations are _supposed_ to suppress
+    // other pointer events. However, firefox will allow a few
+    // pointer event to get through after a drag starts.
+    // The most I've seen is 3
+    {
+      type: "pointermove",
+      listener: /* @__PURE__ */ (function() {
+        var callCount = 0;
+        return function listener() {
+          if (callCount < 20) {
+            callCount++;
+            return;
+          }
+          onDragEnd();
+        };
+      })()
+    },
+    // ### Second detection: "pointerdown" events
+    // If we receive this event then we know that a drag operation has finished
+    // and potentially another one is about to start.
+    // Note: `pointerdown` fires on all browsers / platforms before "dragstart"
+    {
+      type: "pointerdown",
+      listener: onDragEnd
+    }
+  ];
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/get-input.js
+function getInput(event) {
+  return {
+    altKey: event.altKey,
+    button: event.button,
+    buttons: event.buttons,
+    ctrlKey: event.ctrlKey,
+    metaKey: event.metaKey,
+    shiftKey: event.shiftKey,
+    clientX: event.clientX,
+    clientY: event.clientY,
+    pageX: event.pageX,
+    pageY: event.pageY
+  };
+}
+
+// node_modules/raf-schd/dist/raf-schd.esm.js
+var rafSchd = function rafSchd2(fn) {
+  var lastArgs = [];
+  var frameId = null;
+  var wrapperFn = function wrapperFn2() {
+    for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) {
+      args[_key] = arguments[_key];
+    }
+    lastArgs = args;
+    if (frameId) {
+      return;
+    }
+    frameId = requestAnimationFrame(function() {
+      frameId = null;
+      fn.apply(void 0, lastArgs);
+    });
+  };
+  wrapperFn.cancel = function() {
+    if (!frameId) {
+      return;
+    }
+    cancelAnimationFrame(frameId);
+    frameId = null;
+  };
+  return wrapperFn;
+};
+var raf_schd_esm_default = rafSchd;
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/ledger/dispatch-consumer-event.js
+var scheduleOnDrag = raf_schd_esm_default(function(fn) {
+  return fn();
+});
+var dragStart = /* @__PURE__ */ (function() {
+  var scheduled = null;
+  function schedule(fn) {
+    var frameId = requestAnimationFrame(function() {
+      scheduled = null;
+      fn();
+    });
+    scheduled = {
+      frameId,
+      fn
+    };
+  }
+  function flush() {
+    if (scheduled) {
+      cancelAnimationFrame(scheduled.frameId);
+      scheduled.fn();
+      scheduled = null;
+    }
+  }
+  return {
+    schedule,
+    flush
+  };
+})();
+function makeDispatch(_ref) {
+  var source = _ref.source, initial = _ref.initial, dispatchEvent = _ref.dispatchEvent;
+  var previous = {
+    dropTargets: []
+  };
+  function safeDispatch(args) {
+    dispatchEvent(args);
+    previous = {
+      dropTargets: args.payload.location.current.dropTargets
+    };
+  }
+  var dispatch = {
+    start: function start2(_ref2) {
+      var nativeSetDragImage = _ref2.nativeSetDragImage;
+      var location2 = {
+        current: initial,
+        previous,
+        initial
+      };
+      safeDispatch({
+        eventName: "onGenerateDragPreview",
+        payload: {
+          source,
+          location: location2,
+          nativeSetDragImage
+        }
+      });
+      dragStart.schedule(function() {
+        safeDispatch({
+          eventName: "onDragStart",
+          payload: {
+            source,
+            location: location2
+          }
+        });
+      });
+    },
+    dragUpdate: function dragUpdate(_ref3) {
+      var current = _ref3.current;
+      dragStart.flush();
+      scheduleOnDrag.cancel();
+      safeDispatch({
+        eventName: "onDropTargetChange",
+        payload: {
+          source,
+          location: {
+            initial,
+            previous,
+            current
+          }
+        }
+      });
+    },
+    drag: function drag(_ref4) {
+      var current = _ref4.current;
+      scheduleOnDrag(function() {
+        dragStart.flush();
+        var location2 = {
+          initial,
+          previous,
+          current
+        };
+        safeDispatch({
+          eventName: "onDrag",
+          payload: {
+            source,
+            location: location2
+          }
+        });
+      });
+    },
+    drop: function drop(_ref5) {
+      var current = _ref5.current, updatedSourcePayload = _ref5.updatedSourcePayload;
+      dragStart.flush();
+      scheduleOnDrag.cancel();
+      safeDispatch({
+        eventName: "onDrop",
+        payload: {
+          source: updatedSourcePayload !== null && updatedSourcePayload !== void 0 ? updatedSourcePayload : source,
+          location: {
+            current,
+            previous,
+            initial
+          }
+        }
+      });
+    }
+  };
+  return dispatch;
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/ledger/lifecycle-manager.js
+var globalState = {
+  isActive: false
+};
+function canStart() {
+  return !globalState.isActive;
+}
+function getNativeSetDragImage(event) {
+  if (event.dataTransfer) {
+    return event.dataTransfer.setDragImage.bind(event.dataTransfer);
+  }
+  return null;
+}
+function hasHierarchyChanged(_ref) {
+  var current = _ref.current, next = _ref.next;
+  if (current.length !== next.length) {
+    return true;
+  }
+  for (var i = 0; i < current.length; i++) {
+    if (current[i].element !== next[i].element) {
+      return true;
+    }
+  }
+  return false;
+}
+function start(_ref2) {
+  var event = _ref2.event, dragType = _ref2.dragType, getDropTargetsOver = _ref2.getDropTargetsOver, dispatchEvent = _ref2.dispatchEvent;
+  if (!canStart()) {
+    return;
+  }
+  var initial = getStartLocation({
+    event,
+    dragType,
+    getDropTargetsOver
+  });
+  globalState.isActive = true;
+  var state = {
+    current: initial
+  };
+  setDropEffectOnEvent({
+    event,
+    current: initial.dropTargets
+  });
+  var dispatch = makeDispatch({
+    source: dragType.payload,
+    dispatchEvent,
+    initial
+  });
+  function updateState(next) {
+    var hasChanged = hasHierarchyChanged({
+      current: state.current.dropTargets,
+      next: next.dropTargets
+    });
+    state.current = next;
+    if (hasChanged) {
+      dispatch.dragUpdate({
+        current: state.current
+      });
+    }
+  }
+  function onUpdateEvent(event2) {
+    var input = getInput(event2);
+    var target = isHoneyPotElement(event2.target) ? getElementFromPointWithoutHoneypot({
+      x: input.clientX,
+      y: input.clientY
+    }) : event2.target;
+    var nextDropTargets = getDropTargetsOver({
+      target,
+      input,
+      source: dragType.payload,
+      current: state.current.dropTargets
+    });
+    if (nextDropTargets.length) {
+      event2.preventDefault();
+      setDropEffectOnEvent({
+        event: event2,
+        current: nextDropTargets
+      });
+    }
+    updateState({
+      dropTargets: nextDropTargets,
+      input
+    });
+  }
+  function cancel() {
+    if (state.current.dropTargets.length) {
+      updateState({
+        dropTargets: [],
+        input: state.current.input
+      });
+    }
+    dispatch.drop({
+      current: state.current,
+      updatedSourcePayload: null
+    });
+    finish();
+  }
+  function finish() {
+    globalState.isActive = false;
+    unbindEvents();
+  }
+  var unbindEvents = (0, import_bind_event_listener3.bindAll)(
+    window,
+    [{
+      // 👋 Note: we are repurposing the `dragover` event as our `drag` event
+      // this is because firefox does not publish pointer coordinates during
+      // a `drag` event, but does for every other type of drag event
+      // `dragover` fires on all elements that are being dragged over
+      // Because we are binding to `window` - our `dragover` is effectively the same as a `drag`
+      // 🦊😤
+      type: "dragover",
+      listener: function listener(event2) {
+        onUpdateEvent(event2);
+        dispatch.drag({
+          current: state.current
+        });
+      }
+    }, {
+      type: "dragenter",
+      listener: onUpdateEvent
+    }, {
+      type: "dragleave",
+      listener: function listener(event2) {
+        if (!isLeavingWindow({
+          dragLeave: event2
+        })) {
+          return;
+        }
+        updateState({
+          input: state.current.input,
+          dropTargets: []
+        });
+        if (dragType.startedFrom === "external") {
+          cancel();
+        }
+      }
+    }, {
+      // A "drop" can only happen if the browser allowed the drop
+      type: "drop",
+      listener: function listener(event2) {
+        state.current = {
+          dropTargets: state.current.dropTargets,
+          input: getInput(event2)
+        };
+        if (!state.current.dropTargets.length) {
+          cancel();
+          return;
+        }
+        event2.preventDefault();
+        setDropEffectOnEvent({
+          event: event2,
+          current: state.current.dropTargets
+        });
+        dispatch.drop({
+          current: state.current,
+          // When dropping something native, we need to extract the latest
+          // `.items` from the "drop" event as it is now accessible
+          updatedSourcePayload: dragType.type === "external" ? dragType.getDropPayload(event2) : null
+        });
+        finish();
+      }
+    }, {
+      // "dragend" fires when on the drag source (eg a draggable element)
+      // when the drag is finished.
+      // "dragend" will fire after "drop" (if there was a successful drop)
+      // "dragend" does not fire if the draggable source has been removed during the drag
+      // or for external drag sources (eg files)
+      // This "dragend" listener will not fire if there was a successful drop
+      // as we will have already removed the event listener
+      type: "dragend",
+      listener: function listener(event2) {
+        state.current = {
+          dropTargets: state.current.dropTargets,
+          input: getInput(event2)
+        };
+        cancel();
+      }
+    }].concat(_toConsumableArray(getBindingsForBrokenDrags({
+      onDragEnd: cancel
+    }))),
+    // Once we have started a managed drag operation it is important that we see / own all drag events
+    // We got one adoption bug pop up where some code was stopping (`event.stopPropagation()`)
+    // all "drop" events in the bubble phase on the `document.body`.
+    // This meant that we never saw the "drop" event.
+    {
+      capture: true
+    }
+  );
+  dispatch.start({
+    nativeSetDragImage: getNativeSetDragImage(event)
+  });
+}
+function setDropEffectOnEvent(_ref3) {
+  var _current$;
+  var event = _ref3.event, current = _ref3.current;
+  var innerMost = (_current$ = current[0]) === null || _current$ === void 0 ? void 0 : _current$.dropEffect;
+  if (innerMost != null && event.dataTransfer) {
+    event.dataTransfer.dropEffect = innerMost;
+  }
+}
+function getStartLocation(_ref4) {
+  var event = _ref4.event, dragType = _ref4.dragType, getDropTargetsOver = _ref4.getDropTargetsOver;
+  var input = getInput(event);
+  if (dragType.startedFrom === "external") {
+    return {
+      input,
+      dropTargets: []
+    };
+  }
+  var dropTargets = getDropTargetsOver({
+    input,
+    source: dragType.payload,
+    target: event.target,
+    current: []
+  });
+  return {
+    input,
+    dropTargets
+  };
+}
+var lifecycle = {
+  canStart,
+  start
+};
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/ledger/usage-ledger.js
+var ledger = /* @__PURE__ */ new Map();
+function registerUsage(_ref) {
+  var typeKey = _ref.typeKey, mount2 = _ref.mount;
+  var entry = ledger.get(typeKey);
+  if (entry) {
+    entry.usageCount++;
+    return entry;
+  }
+  var initial = {
+    typeKey,
+    unmount: mount2(),
+    usageCount: 1
+  };
+  ledger.set(typeKey, initial);
+  return initial;
+}
+function register(args) {
+  var entry = registerUsage(args);
+  return function unregister() {
+    entry.usageCount--;
+    if (entry.usageCount > 0) {
+      return;
+    }
+    entry.unmount();
+    ledger.delete(args.typeKey);
+  };
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/public-utils/combine.js
+function combine() {
+  for (var _len = arguments.length, fns = new Array(_len), _key = 0; _key < _len; _key++) {
+    fns[_key] = arguments[_key];
+  }
+  return function cleanup() {
+    fns.forEach(function(fn) {
+      return fn();
+    });
+  };
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/add-attribute.js
+function addAttribute(element, _ref) {
+  var attribute = _ref.attribute, value = _ref.value;
+  element.setAttribute(attribute, value);
+  return function() {
+    return element.removeAttribute(attribute);
+  };
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/make-adapter/make-drop-target.js
+function ownKeys2(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread2(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys2(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys2(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray2(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var _n = 0, F = function F2() {
+      };
+      return { s: F, n: function n() {
+        return _n >= r.length ? { done: true } : { done: false, value: r[_n++] };
+      }, e: function e2(r2) {
+        throw r2;
+      }, f: F };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o, a = true, u = false;
+  return { s: function s() {
+    t = t.call(r);
+  }, n: function n() {
+    var r2 = t.next();
+    return a = r2.done, r2;
+  }, e: function e2(r2) {
+    u = true, o = r2;
+  }, f: function f() {
+    try {
+      a || null == t.return || t.return();
+    } finally {
+      if (u) throw o;
+    }
+  } };
+}
+function _unsupportedIterableToArray2(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray2(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray2(r, a) : void 0;
+  }
+}
+function _arrayLikeToArray2(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function copyReverse(array) {
+  return array.slice(0).reverse();
+}
+function makeDropTarget(_ref) {
+  var typeKey = _ref.typeKey, defaultDropEffect = _ref.defaultDropEffect;
+  var registry = /* @__PURE__ */ new WeakMap();
+  var dropTargetDataAtt = "data-drop-target-for-".concat(typeKey);
+  var dropTargetSelector = "[".concat(dropTargetDataAtt, "]");
+  function addToRegistry2(args) {
+    registry.set(args.element, args);
+    return function() {
+      return registry.delete(args.element);
+    };
+  }
+  function dropTargetForConsumers(args) {
+    if (true) {
+      var existing = registry.get(args.element);
+      if (existing) {
+        console.warn("You have already registered a [".concat(typeKey, "] dropTarget on the same element"), {
+          existing,
+          proposed: args
+        });
+      }
+      if (args.element instanceof HTMLIFrameElement) {
+        console.warn("\n            We recommend not registering <iframe> elements as drop targets\n            as it can result in some strange browser event ordering.\n          ".replace(/\s{2,}/g, " ").trim());
+      }
+    }
+    var cleanup = combine(addAttribute(args.element, {
+      attribute: dropTargetDataAtt,
+      value: "true"
+    }), addToRegistry2(args));
+    return once(cleanup);
+  }
+  function getActualDropTargets(_ref2) {
+    var _args$getData, _args$getData2, _args$getDropEffect, _args$getDropEffect2;
+    var source = _ref2.source, target = _ref2.target, input = _ref2.input, _ref2$result = _ref2.result, result = _ref2$result === void 0 ? [] : _ref2$result;
+    if (target == null) {
+      return result;
+    }
+    if (!(target instanceof Element)) {
+      if (target instanceof Node) {
+        return getActualDropTargets({
+          source,
+          target: target.parentElement,
+          input,
+          result
+        });
+      }
+      return result;
+    }
+    var closest = target.closest(dropTargetSelector);
+    if (closest == null) {
+      return result;
+    }
+    var args = registry.get(closest);
+    if (args == null) {
+      return result;
+    }
+    var feedback = {
+      input,
+      source,
+      element: args.element
+    };
+    if (args.canDrop && !args.canDrop(feedback)) {
+      return getActualDropTargets({
+        source,
+        target: args.element.parentElement,
+        input,
+        result
+      });
+    }
+    var data = (_args$getData = (_args$getData2 = args.getData) === null || _args$getData2 === void 0 ? void 0 : _args$getData2.call(args, feedback)) !== null && _args$getData !== void 0 ? _args$getData : {};
+    var dropEffect = (_args$getDropEffect = (_args$getDropEffect2 = args.getDropEffect) === null || _args$getDropEffect2 === void 0 ? void 0 : _args$getDropEffect2.call(args, feedback)) !== null && _args$getDropEffect !== void 0 ? _args$getDropEffect : defaultDropEffect;
+    var record = {
+      data,
+      element: args.element,
+      dropEffect,
+      // we are collecting _actual_ drop targets, so these are
+      // being applied _not_ due to stickiness
+      isActiveDueToStickiness: false
+    };
+    return getActualDropTargets({
+      source,
+      target: args.element.parentElement,
+      input,
+      // Using bubble ordering. Same ordering as `event.getPath()`
+      result: [].concat(_toConsumableArray(result), [record])
+    });
+  }
+  function notifyCurrent(_ref3) {
+    var eventName = _ref3.eventName, payload = _ref3.payload;
+    var _iterator = _createForOfIteratorHelper(payload.location.current.dropTargets), _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+        var _entry$eventName;
+        var record = _step.value;
+        var entry = registry.get(record.element);
+        var args = _objectSpread2(_objectSpread2({}, payload), {}, {
+          self: record
+        });
+        entry === null || entry === void 0 || (_entry$eventName = entry[eventName]) === null || _entry$eventName === void 0 || _entry$eventName.call(
+          entry,
+          // I cannot seem to get the types right here.
+          // TS doesn't seem to like that one event can need `nativeSetDragImage`
+          // @ts-expect-error
+          args
+        );
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+  }
+  var actions = {
+    onGenerateDragPreview: notifyCurrent,
+    onDrag: notifyCurrent,
+    onDragStart: notifyCurrent,
+    onDrop: notifyCurrent,
+    onDropTargetChange: function onDropTargetChange(_ref4) {
+      var payload = _ref4.payload;
+      var isCurrent = new Set(payload.location.current.dropTargets.map(function(record2) {
+        return record2.element;
+      }));
+      var visited = /* @__PURE__ */ new Set();
+      var _iterator2 = _createForOfIteratorHelper(payload.location.previous.dropTargets), _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done; ) {
+          var _entry$onDropTargetCh;
+          var record = _step2.value;
+          visited.add(record.element);
+          var entry = registry.get(record.element);
+          var isOver = isCurrent.has(record.element);
+          var args = _objectSpread2(_objectSpread2({}, payload), {}, {
+            self: record
+          });
+          entry === null || entry === void 0 || (_entry$onDropTargetCh = entry.onDropTargetChange) === null || _entry$onDropTargetCh === void 0 || _entry$onDropTargetCh.call(entry, args);
+          if (!isOver) {
+            var _entry$onDragLeave;
+            entry === null || entry === void 0 || (_entry$onDragLeave = entry.onDragLeave) === null || _entry$onDragLeave === void 0 || _entry$onDragLeave.call(entry, args);
+          }
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      var _iterator3 = _createForOfIteratorHelper(payload.location.current.dropTargets), _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done; ) {
+          var _entry$onDropTargetCh2, _entry$onDragEnter;
+          var _record = _step3.value;
+          if (visited.has(_record.element)) {
+            continue;
+          }
+          var _args = _objectSpread2(_objectSpread2({}, payload), {}, {
+            self: _record
+          });
+          var _entry = registry.get(_record.element);
+          _entry === null || _entry === void 0 || (_entry$onDropTargetCh2 = _entry.onDropTargetChange) === null || _entry$onDropTargetCh2 === void 0 || _entry$onDropTargetCh2.call(_entry, _args);
+          _entry === null || _entry === void 0 || (_entry$onDragEnter = _entry.onDragEnter) === null || _entry$onDragEnter === void 0 || _entry$onDragEnter.call(_entry, _args);
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+    }
+  };
+  function dispatchEvent(args) {
+    actions[args.eventName](args);
+  }
+  function getIsOver(_ref5) {
+    var source = _ref5.source, target = _ref5.target, input = _ref5.input, current = _ref5.current;
+    var actual = getActualDropTargets({
+      source,
+      target,
+      input
+    });
+    if (actual.length >= current.length) {
+      return actual;
+    }
+    var lastCaptureOrdered = copyReverse(current);
+    var actualCaptureOrdered = copyReverse(actual);
+    var resultCaptureOrdered = [];
+    for (var index = 0; index < lastCaptureOrdered.length; index++) {
+      var _argsForLast$getIsSti;
+      var last = lastCaptureOrdered[index];
+      var fresh = actualCaptureOrdered[index];
+      if (fresh != null) {
+        resultCaptureOrdered.push(fresh);
+        continue;
+      }
+      var parent = resultCaptureOrdered[index - 1];
+      var lastParent = lastCaptureOrdered[index - 1];
+      if ((parent === null || parent === void 0 ? void 0 : parent.element) !== (lastParent === null || lastParent === void 0 ? void 0 : lastParent.element)) {
+        break;
+      }
+      var argsForLast = registry.get(last.element);
+      if (!argsForLast) {
+        break;
+      }
+      var feedback = {
+        input,
+        source,
+        element: argsForLast.element
+      };
+      if (argsForLast.canDrop && !argsForLast.canDrop(feedback)) {
+        break;
+      }
+      if (!((_argsForLast$getIsSti = argsForLast.getIsSticky) !== null && _argsForLast$getIsSti !== void 0 && _argsForLast$getIsSti.call(argsForLast, feedback))) {
+        break;
+      }
+      resultCaptureOrdered.push(_objectSpread2(_objectSpread2({}, last), {}, {
+        // making it clear to consumers this drop target is active due to stickiness
+        isActiveDueToStickiness: true
+      }));
+    }
+    return copyReverse(resultCaptureOrdered);
+  }
+  return {
+    dropTargetForConsumers,
+    getIsOver,
+    dispatchEvent
+  };
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/make-adapter/make-monitor.js
+function _createForOfIteratorHelper2(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray3(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var _n = 0, F = function F2() {
+      };
+      return { s: F, n: function n() {
+        return _n >= r.length ? { done: true } : { done: false, value: r[_n++] };
+      }, e: function e2(r2) {
+        throw r2;
+      }, f: F };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o, a = true, u = false;
+  return { s: function s() {
+    t = t.call(r);
+  }, n: function n() {
+    var r2 = t.next();
+    return a = r2.done, r2;
+  }, e: function e2(r2) {
+    u = true, o = r2;
+  }, f: function f() {
+    try {
+      a || null == t.return || t.return();
+    } finally {
+      if (u) throw o;
+    }
+  } };
+}
+function _unsupportedIterableToArray3(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray3(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray3(r, a) : void 0;
+  }
+}
+function _arrayLikeToArray3(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function ownKeys3(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread3(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys3(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys3(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+function makeMonitor() {
+  var registry = /* @__PURE__ */ new Set();
+  var dragging = null;
+  function tryAddToActive(monitor) {
+    if (!dragging) {
+      return;
+    }
+    if (!monitor.canMonitor || monitor.canMonitor(dragging.canMonitorArgs)) {
+      dragging.active.add(monitor);
+    }
+  }
+  function monitorForConsumers(args) {
+    var entry = _objectSpread3({}, args);
+    registry.add(entry);
+    tryAddToActive(entry);
+    function cleanup() {
+      registry.delete(entry);
+      if (dragging) {
+        dragging.active.delete(entry);
+      }
+    }
+    return once(cleanup);
+  }
+  function dispatchEvent(_ref) {
+    var eventName = _ref.eventName, payload = _ref.payload;
+    if (eventName === "onGenerateDragPreview") {
+      dragging = {
+        canMonitorArgs: {
+          initial: payload.location.initial,
+          source: payload.source
+        },
+        active: /* @__PURE__ */ new Set()
+      };
+      var _iterator = _createForOfIteratorHelper2(registry), _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+          var monitor = _step.value;
+          tryAddToActive(monitor);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+    }
+    if (!dragging) {
+      return;
+    }
+    var active = Array.from(dragging.active);
+    for (var _i = 0, _active = active; _i < _active.length; _i++) {
+      var _monitor = _active[_i];
+      if (dragging.active.has(_monitor)) {
+        var _monitor$eventName;
+        (_monitor$eventName = _monitor[eventName]) === null || _monitor$eventName === void 0 || _monitor$eventName.call(_monitor, payload);
+      }
+    }
+    if (eventName === "onDrop") {
+      dragging.active.clear();
+      dragging = null;
+    }
+  }
+  return {
+    dispatchEvent,
+    monitorForConsumers
+  };
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/make-adapter/make-adapter.js
+function makeAdapter(_ref) {
+  var typeKey = _ref.typeKey, mount2 = _ref.mount, dispatchEventToSource2 = _ref.dispatchEventToSource, onPostDispatch = _ref.onPostDispatch, defaultDropEffect = _ref.defaultDropEffect;
+  var monitorAPI = makeMonitor();
+  var dropTargetAPI = makeDropTarget({
+    typeKey,
+    defaultDropEffect
+  });
+  function dispatchEvent(args) {
+    dispatchEventToSource2 === null || dispatchEventToSource2 === void 0 || dispatchEventToSource2(args);
+    dropTargetAPI.dispatchEvent(args);
+    monitorAPI.dispatchEvent(args);
+    onPostDispatch === null || onPostDispatch === void 0 || onPostDispatch(args);
+  }
+  function start2(_ref2) {
+    var event = _ref2.event, dragType = _ref2.dragType;
+    lifecycle.start({
+      event,
+      dragType,
+      getDropTargetsOver: dropTargetAPI.getIsOver,
+      dispatchEvent
+    });
+  }
+  function registerUsage2() {
+    function mountAdapter() {
+      var api2 = {
+        canStart: lifecycle.canStart,
+        start: start2
+      };
+      return mount2(api2);
+    }
+    return register({
+      typeKey,
+      mount: mountAdapter
+    });
+  }
+  return {
+    registerUsage: registerUsage2,
+    dropTarget: dropTargetAPI.dropTargetForConsumers,
+    monitor: monitorAPI.monitorForConsumers
+  };
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/android.js
+var isAndroid = once(function isAndroid2() {
+  return navigator.userAgent.toLocaleLowerCase().includes("android");
+});
+var androidFallbackText = "pdnd:android-fallback";
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/media-types/text-media-type.js
+var textMediaType = "text/plain";
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/util/media-types/url-media-type.js
+var URLMediaType = "text/uri-list";
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/adapter/element-adapter-native-data-key.js
+var elementAdapterNativeDataKey = "application/vnd.pdnd";
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop/dist/esm/adapter/element-adapter.js
+var draggableRegistry = /* @__PURE__ */ new WeakMap();
+function addToRegistry(args) {
+  draggableRegistry.set(args.element, args);
+  return function cleanup() {
+    draggableRegistry.delete(args.element);
+  };
+}
+var honeyPotFix = makeHoneyPotFix();
+var adapter = makeAdapter({
+  typeKey: "element",
+  defaultDropEffect: "move",
+  mount: function mount(api2) {
+    return combine(honeyPotFix.bindEvents(), (0, import_bind_event_listener4.bind)(document, {
+      type: "dragstart",
+      listener: function listener(event) {
+        var _entry$dragHandle, _entry$getInitialData, _entry$getInitialData2, _entry$dragHandle2, _entry$getInitialData3, _entry$getInitialData4;
+        if (!api2.canStart(event)) {
+          return;
+        }
+        if (event.defaultPrevented) {
+          return;
+        }
+        if (!event.dataTransfer) {
+          if (true) {
+            console.warn("\n              It appears as though you have are not testing DragEvents correctly.\n\n              - If you are unit testing, ensure you have polyfilled DragEvent.\n              - If you are browser testing, ensure you are dispatching drag events correctly.\n\n              Please see our testing guides for more information:\n              https://atlassian.design/components/pragmatic-drag-and-drop/core-package/testing\n            ".replace(/ {2}/g, ""));
+          }
+          return;
+        }
+        var target = event.target;
+        if (!(target instanceof HTMLElement)) {
+          return;
+        }
+        var entry = draggableRegistry.get(target);
+        if (!entry) {
+          return;
+        }
+        var input = getInput(event);
+        var feedback = {
+          element: entry.element,
+          dragHandle: (_entry$dragHandle = entry.dragHandle) !== null && _entry$dragHandle !== void 0 ? _entry$dragHandle : null,
+          input
+        };
+        if (entry.canDrag && !entry.canDrag(feedback)) {
+          event.preventDefault();
+          return;
+        }
+        if (entry.dragHandle) {
+          var over = getElementFromPointWithoutHoneypot({
+            x: input.clientX,
+            y: input.clientY
+          });
+          if (!entry.dragHandle.contains(over)) {
+            event.preventDefault();
+            return;
+          }
+        }
+        var nativeData = (_entry$getInitialData = (_entry$getInitialData2 = entry.getInitialDataForExternal) === null || _entry$getInitialData2 === void 0 ? void 0 : _entry$getInitialData2.call(entry, feedback)) !== null && _entry$getInitialData !== void 0 ? _entry$getInitialData : null;
+        if (nativeData) {
+          for (var _i = 0, _Object$entries = Object.entries(nativeData); _i < _Object$entries.length; _i++) {
+            var _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), key = _Object$entries$_i[0], data = _Object$entries$_i[1];
+            event.dataTransfer.setData(key, data !== null && data !== void 0 ? data : "");
+          }
+        }
+        if (isAndroid() && !event.dataTransfer.types.includes(textMediaType) && !event.dataTransfer.types.includes(URLMediaType)) {
+          event.dataTransfer.setData(textMediaType, androidFallbackText);
+        }
+        event.dataTransfer.setData(elementAdapterNativeDataKey, "");
+        var payload = {
+          element: entry.element,
+          dragHandle: (_entry$dragHandle2 = entry.dragHandle) !== null && _entry$dragHandle2 !== void 0 ? _entry$dragHandle2 : null,
+          data: (_entry$getInitialData3 = (_entry$getInitialData4 = entry.getInitialData) === null || _entry$getInitialData4 === void 0 ? void 0 : _entry$getInitialData4.call(entry, feedback)) !== null && _entry$getInitialData3 !== void 0 ? _entry$getInitialData3 : {}
+        };
+        var dragType = {
+          type: "element",
+          payload,
+          startedFrom: "internal"
+        };
+        api2.start({
+          event,
+          dragType
+        });
+      }
+    }));
+  },
+  dispatchEventToSource: function dispatchEventToSource(_ref) {
+    var _draggableRegistry$ge, _draggableRegistry$ge2;
+    var eventName = _ref.eventName, payload = _ref.payload;
+    (_draggableRegistry$ge = draggableRegistry.get(payload.source.element)) === null || _draggableRegistry$ge === void 0 || (_draggableRegistry$ge2 = _draggableRegistry$ge[eventName]) === null || _draggableRegistry$ge2 === void 0 || _draggableRegistry$ge2.call(
+      _draggableRegistry$ge,
+      // I cannot seem to get the types right here.
+      // TS doesn't seem to like that one event can need `nativeSetDragImage`
+      // @ts-expect-error
+      payload
+    );
+  },
+  onPostDispatch: honeyPotFix.getOnPostDispatch()
+});
+var dropTargetForElements = adapter.dropTarget;
+var monitorForElements = adapter.monitor;
+function draggable(args) {
+  if (true) {
+    if (args.dragHandle && !args.element.contains(args.dragHandle)) {
+      console.warn("Drag handle element must be contained in draggable element", {
+        element: args.element,
+        dragHandle: args.dragHandle
+      });
+    }
+  }
+  if (true) {
+    var existing = draggableRegistry.get(args.element);
+    if (existing) {
+      console.warn("You have already registered a `draggable` on the same element", {
+        existing,
+        proposed: args
+      });
+    }
+  }
+  var cleanup = combine(
+    // making the draggable register the adapter rather than drop targets
+    // this is because you *must* have a draggable element to start a drag
+    // but you _might_ not have any drop targets immediately
+    // (You might create drop targets async)
+    adapter.registerUsage(),
+    addToRegistry(args),
+    addAttribute(args.element, {
+      attribute: "draggable",
+      value: "true"
+    })
+  );
+  return once(cleanup);
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/engagement-history.js
+var ledger2 = /* @__PURE__ */ new Map();
+var requested = /* @__PURE__ */ new Set();
+function markAndGetEngagement(element) {
+  markEngagement(element);
+  var entry = ledger2.get(element);
+  if (entry) {
+    return entry;
+  }
+  var fresh = {
+    timeOfEngagementStart: Date.now()
+  };
+  ledger2.set(element, fresh);
+  return fresh;
+}
+function markEngagement(element) {
+  requested.add(element);
+}
+function clearUnusedEngagements(fn) {
+  requested.clear();
+  fn();
+  ledger2.forEach(function(_, element) {
+    if (!requested.has(element)) {
+      ledger2.delete(element);
+    }
+  });
+  requested.clear();
+}
+function clearEngagementHistory() {
+  ledger2.clear();
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/scheduler.js
+var schedulers = /* @__PURE__ */ new Map();
+function getScheduler(monitor) {
+  var scheduler = schedulers.get(monitor);
+  if (scheduler) {
+    return scheduler;
+  }
+  var created = makeScheduler(monitor);
+  schedulers.set(monitor, created);
+  return created;
+}
+function makeScheduler(monitor) {
+  var state = {
+    type: "idle"
+  };
+  var callbacks = [];
+  function loop(timeLastFrameFinished) {
+    if (state.type !== "running") {
+      return;
+    }
+    var timeSinceLastFrame = timeLastFrameFinished - state.timeLastFrameFinished;
+    var _state = state, latestArgs = _state.latestArgs;
+    var underUsersPointer = getElementFromPointWithoutHoneypot({
+      x: latestArgs.location.current.input.clientX,
+      y: latestArgs.location.current.input.clientY
+    });
+    clearUnusedEngagements(function() {
+      callbacks.forEach(function(onFrame) {
+        return onFrame({
+          underUsersPointer,
+          latestArgs,
+          timeSinceLastFrame
+        });
+      });
+    });
+    state.timeLastFrameFinished = timeLastFrameFinished;
+    state.frameId = requestAnimationFrame(loop);
+  }
+  function reset() {
+    if (state.type === "idle") {
+      return;
+    }
+    cancelAnimationFrame(state.frameId);
+    clearEngagementHistory();
+    state = {
+      type: "idle"
+    };
+  }
+  function start2(args) {
+    if (state.type !== "idle") {
+      return;
+    }
+    state = {
+      // Waiting a frame so we can accurately determine `timeSinceLastFrame`.
+      type: "initializing",
+      latestArgs: args,
+      frameId: requestAnimationFrame(function(timeLastFrameFinished) {
+        if (state.type !== "initializing") {
+          return;
+        }
+        state = {
+          type: "running",
+          timeLastFrameFinished,
+          latestArgs: state.latestArgs,
+          frameId: requestAnimationFrame(loop)
+        };
+      })
+    };
+  }
+  function update(args) {
+    if (state.type === "idle") {
+      start2(args);
+      return;
+    }
+    state.latestArgs = args;
+  }
+  monitor({
+    onDragStart: start2,
+    onDropTargetChange: update,
+    onDrag: update,
+    onDrop: reset
+  });
+  var api2 = {
+    onFrame: function onFrame(fn) {
+      callbacks.push(fn);
+    }
+  };
+  return api2;
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/over-element/data-attributes.js
+var dataAttribute = "data-auto-scrollable";
+var selector = "[".concat(dataAttribute, '="true"]');
+function addScrollableAttribute(element) {
+  element.setAttribute(dataAttribute, "true");
+  return function() {
+    return element.removeAttribute(dataAttribute);
+  };
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/configuration.js
+function ownKeys4(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread4(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys4(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys4(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
+    });
+  }
+  return e;
+}
+var baseConfig = {
+  startHitboxAtPercentageRemainingOfElement: {
+    top: 0.25,
+    right: 0.25,
+    bottom: 0.25,
+    left: 0.25
+  },
+  maxScrollAtPercentageRemainingOfHitbox: {
+    top: 0.5,
+    right: 0.5,
+    bottom: 0.5,
+    left: 0.5
+  },
+  timeDampeningDurationMs: 400,
+  // Too big and it's too easy to trigger auto scrolling
+  // Too small and it's too hard 😅
+  maxMainAxisHitboxSize: 180
+};
+var maxPixelScrollPerSecond = {
+  // What the value would be if we were scrolling at 15px per frame at 60fps.
+  // This is the default as it works well for most experiences.
+  // In certain scenarios though it can feel a bit slow.
+  standard: 15 * 60,
+  // What the value would be if we were scrolling at 25px per frame at 60fps.
+  // This is not the default as it feels too fast for a lot of experiences.
+  fast: 25 * 60
+};
+function getInternalConfig(provided) {
+  var _provided$maxScrollSp;
+  return _objectSpread4(_objectSpread4({}, baseConfig), {}, {
+    // only allowing limited control over the config at this stage
+    maxPixelScrollPerSecond: maxPixelScrollPerSecond[(_provided$maxScrollSp = provided === null || provided === void 0 ? void 0 : provided.maxScrollSpeed) !== null && _provided$maxScrollSp !== void 0 ? _provided$maxScrollSp : "standard"]
+  });
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/can-scroll-on-edge.js
+var canScrollOnEdge = {
+  // Notes:
+  //
+  // 🌏 Chrome 115.0: uses fractional units for `scrollLeft` and `scrollTop`
+  //    (and fractional units don't reach true integer maximum when zoomed in / out)
+  // 🍎 Safari 16.5.2: no fractional units
+  // 🦊 Firefox 115.0: no fractional units
+  // we have some scroll we can move backwards into
+  top: function top(element) {
+    return element.scrollTop > 0;
+  },
+  // We have some scroll we can move forward into
+  right: function right(element) {
+    return Math.ceil(element.scrollLeft) + element.clientWidth < element.scrollWidth;
+  },
+  // We have some scroll we can move forwards into
+  bottom: function bottom(element) {
+    return Math.ceil(element.scrollTop) + element.clientHeight < element.scrollHeight;
+  },
+  // we have some scroll we can move back into.
+  left: function left(element) {
+    return element.scrollLeft > 0;
+  }
+};
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/edges.js
+var edges = ["top", "right", "bottom", "left"];
+var edgeAxisLookup = {
+  top: "vertical",
+  right: "horizontal",
+  bottom: "vertical",
+  left: "horizontal"
+};
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/axis.js
+var vertical = {
+  start: "top",
+  end: "bottom",
+  point: "y",
+  size: "height"
+};
+var horizontal = {
+  start: "left",
+  end: "right",
+  point: "x",
+  size: "width"
+};
+var axisLookup = {
+  vertical: {
+    mainAxis: vertical,
+    crossAxis: horizontal
+  },
+  horizontal: {
+    mainAxis: horizontal,
+    crossAxis: vertical
+  }
+};
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/side.js
+var mainAxisSideLookup = {
+  top: "start",
+  right: "end",
+  bottom: "end",
+  left: "start"
+};
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/get-over-element-hitbox.js
+function makeGetHitbox(_ref) {
+  var edge = _ref.edge, axis = _ref.axis;
+  return function hitbox(_ref2) {
+    var clientRect = _ref2.clientRect, config = _ref2.config;
+    var _axisLookup$axis = axisLookup[axis], mainAxis = _axisLookup$axis.mainAxis, crossAxis = _axisLookup$axis.crossAxis;
+    var side = mainAxisSideLookup[edge];
+    var mainAxisHitboxSize = Math.min(
+      // scale the size of the hitbox down for smaller elements
+      config.startHitboxAtPercentageRemainingOfElement[edge] * clientRect[mainAxis.size],
+      // Don't let the hitbox grow too big for big elements
+      config.maxMainAxisHitboxSize
+    );
+    return DOMRect.fromRect(_defineProperty(_defineProperty(_defineProperty(_defineProperty({}, mainAxis.point, side === "start" ? (
+      // begin from the start edge and grow inwards
+      clientRect[mainAxis.point]
+    ) : (
+      // begin from inside the end edge and grow towards the end edge
+      clientRect[mainAxis.point] + clientRect[mainAxis.size] - mainAxisHitboxSize
+    )), crossAxis.point, clientRect[crossAxis.point]), mainAxis.size, mainAxisHitboxSize), crossAxis.size, clientRect[crossAxis.size]));
+  };
+}
+var getOverElementHitbox = {
+  top: makeGetHitbox({
+    axis: "vertical",
+    edge: "top"
+  }),
+  right: makeGetHitbox({
+    axis: "horizontal",
+    edge: "right"
+  }),
+  bottom: makeGetHitbox({
+    axis: "vertical",
+    edge: "bottom"
+  }),
+  left: makeGetHitbox({
+    axis: "horizontal",
+    edge: "left"
+  })
+};
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/get-percentage-in-range.js
+function getPercentageInRange(_ref) {
+  var startOfRange = _ref.startOfRange, endOfRange = _ref.endOfRange, value = _ref.value;
+  var isValid = startOfRange < endOfRange;
+  if (!isValid) {
+    return 0;
+  }
+  if (value < startOfRange) {
+    return 0;
+  }
+  if (value > endOfRange) {
+    return 1;
+  }
+  var range = endOfRange - startOfRange;
+  return (value - startOfRange) / range;
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/get-scroll-change.js
+function getMaxScrollChange(_ref) {
+  var timeSinceLastFrame = _ref.timeSinceLastFrame, config = _ref.config;
+  var targetScrollPerMs = config.maxPixelScrollPerSecond / 1e3;
+  var proposed = Math.ceil(targetScrollPerMs * timeSinceLastFrame);
+  var maximum = config.maxPixelScrollPerSecond / 60;
+  return Math.min(proposed, maximum);
+}
+function getDistanceDampening(_ref2) {
+  var client = _ref2.client, axis = _ref2.axis, edge = _ref2.edge, hitbox = _ref2.hitbox, config = _ref2.config;
+  var mainAxis = axisLookup[axis].mainAxis;
+  var side = mainAxisSideLookup[edge];
+  var maxSpeedBuffer = hitbox[mainAxis.size] * config.maxScrollAtPercentageRemainingOfHitbox[edge];
+  if (side === "end") {
+    return getPercentageInRange({
+      startOfRange: hitbox[mainAxis.start],
+      endOfRange: hitbox[mainAxis.end] - maxSpeedBuffer,
+      value: client[mainAxis.point]
+    });
+  }
+  var raw = getPercentageInRange({
+    startOfRange: hitbox[mainAxis.start] + maxSpeedBuffer,
+    endOfRange: hitbox[mainAxis.end],
+    value: client[mainAxis.point]
+  });
+  return 1 - raw;
+}
+function getScrollChange(_ref3) {
+  var client = _ref3.client, timeSinceLastFrame = _ref3.timeSinceLastFrame, engagement = _ref3.engagement, axis = _ref3.axis, hitbox = _ref3.hitbox, edge = _ref3.edge, isDistanceDampeningEnabled = _ref3.isDistanceDampeningEnabled, config = _ref3.config;
+  var maxScroll = getMaxScrollChange({
+    timeSinceLastFrame,
+    config
+  });
+  var percentageDistanceDampening = isDistanceDampeningEnabled ? getDistanceDampening({
+    client,
+    edge,
+    hitbox,
+    axis,
+    config
+  }) : 1;
+  var percentageThroughTimeDampening = getPercentageInRange({
+    startOfRange: engagement.timeOfEngagementStart,
+    endOfRange: engagement.timeOfEngagementStart + config.timeDampeningDurationMs,
+    value: Date.now()
+  });
+  var percentageOfMaxScroll = percentageDistanceDampening * percentageThroughTimeDampening;
+  var scroll = Math.max(maxScroll * percentageOfMaxScroll, 1);
+  var side = mainAxisSideLookup[edge];
+  return side === "end" ? scroll : -1 * scroll;
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/is-axis-allowed.js
+function isAxisAllowed(axis, allowedAxis) {
+  return allowedAxis === "all" || axis === allowedAxis;
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/shared/is-within.js
+function isWithin2(_ref) {
+  var client = _ref.client, clientRect = _ref.clientRect;
+  return (
+    // is within horizontal bounds
+    client.x >= clientRect.x && client.x <= clientRect.x + clientRect.width && // is within vertical bounds
+    client.y >= clientRect.y && client.y <= clientRect.y + clientRect.height
+  );
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/over-element/get-scroll-by.js
+function getRectDefault(element) {
+  return element.getBoundingClientRect();
+}
+function getScrollBy(_ref) {
+  var element = _ref.element, input = _ref.input, timeSinceLastFrame = _ref.timeSinceLastFrame, engagement = _ref.engagement, config = _ref.config, allowedAxis = _ref.allowedAxis, _ref$getRect = _ref.getRect, getRect = _ref$getRect === void 0 ? getRectDefault : _ref$getRect;
+  var client = {
+    x: input.clientX,
+    y: input.clientY
+  };
+  var clientRect = getRect(element);
+  var scrollableEdges = edges.reduce(function(map, edge) {
+    var hitbox = getOverElementHitbox[edge]({
+      clientRect,
+      config
+    });
+    var axis = edgeAxisLookup[edge];
+    if (!isAxisAllowed(axis, allowedAxis)) {
+      return map;
+    }
+    if (!isWithin2({
+      client,
+      clientRect: hitbox
+    })) {
+      return map;
+    }
+    if (!canScrollOnEdge[edge](element)) {
+      return map;
+    }
+    map.set(edge, {
+      edge,
+      hitbox
+    });
+    return map;
+  }, /* @__PURE__ */ new Map());
+  var left2 = (function() {
+    var axis = "horizontal";
+    var leftEdge = scrollableEdges.get("left");
+    if (leftEdge) {
+      return getScrollChange({
+        client,
+        edge: leftEdge.edge,
+        hitbox: leftEdge.hitbox,
+        axis,
+        timeSinceLastFrame,
+        engagement,
+        isDistanceDampeningEnabled: true,
+        config
+      });
+    }
+    var rightEdge = scrollableEdges.get("right");
+    if (rightEdge) {
+      return getScrollChange({
+        client,
+        edge: rightEdge.edge,
+        hitbox: rightEdge.hitbox,
+        axis,
+        timeSinceLastFrame,
+        engagement,
+        isDistanceDampeningEnabled: true,
+        config
+      });
+    }
+    return 0;
+  })();
+  var top2 = (function() {
+    var axis = "vertical";
+    var bottomEdge = scrollableEdges.get("bottom");
+    if (bottomEdge) {
+      return getScrollChange({
+        client,
+        edge: bottomEdge.edge,
+        hitbox: bottomEdge.hitbox,
+        axis,
+        timeSinceLastFrame,
+        engagement,
+        isDistanceDampeningEnabled: true,
+        config
+      });
+    }
+    var topEdge = scrollableEdges.get("top");
+    if (topEdge) {
+      return getScrollChange({
+        client,
+        edge: topEdge.edge,
+        hitbox: topEdge.hitbox,
+        axis,
+        timeSinceLastFrame,
+        engagement,
+        isDistanceDampeningEnabled: true,
+        config
+      });
+    }
+    return 0;
+  })();
+  return {
+    left: left2,
+    top: top2
+  };
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/over-element/try-scroll.js
+function _createForOfIteratorHelper3(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray4(r)) || e && r && "number" == typeof r.length) {
+      t && (r = t);
+      var _n = 0, F = function F2() {
+      };
+      return { s: F, n: function n() {
+        return _n >= r.length ? { done: true } : { done: false, value: r[_n++] };
+      }, e: function e2(r2) {
+        throw r2;
+      }, f: F };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o, a = true, u = false;
+  return { s: function s() {
+    t = t.call(r);
+  }, n: function n() {
+    var r2 = t.next();
+    return a = r2.done, r2;
+  }, e: function e2(r2) {
+    u = true, o = r2;
+  }, f: function f() {
+    try {
+      a || null == t.return || t.return();
+    } finally {
+      if (u) throw o;
+    }
+  } };
+}
+function _unsupportedIterableToArray4(r, a) {
+  if (r) {
+    if ("string" == typeof r) return _arrayLikeToArray4(r, a);
+    var t = {}.toString.call(r).slice(8, -1);
+    return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray4(r, a) : void 0;
+  }
+}
+function _arrayLikeToArray4(r, a) {
+  (null == a || a > r.length) && (a = r.length);
+  for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
+  return n;
+}
+function isScrollingAvailable(value) {
+  return Boolean(value.top || value.left);
+}
+function tryScrollElements(_ref) {
+  var _container$getConfigu, _container$getAllowed, _container$getAllowed2;
+  var target = _ref.target, input = _ref.input, source = _ref.source, findEntry = _ref.findEntry, timeSinceLastFrame = _ref.timeSinceLastFrame, _ref$available = _ref.available, available = _ref$available === void 0 ? {
+    top: true,
+    left: true
+  } : _ref$available;
+  if (!isScrollingAvailable(available)) {
+    return available;
+  }
+  if (!target) {
+    return available;
+  }
+  var element = target.closest(selector);
+  if (!element) {
+    return available;
+  }
+  var container = findEntry(element);
+  if (!container) {
+    return available;
+  }
+  function continueSearchUp() {
+    var _element$parentElemen;
+    return tryScrollElements({
+      target: (_element$parentElemen = element === null || element === void 0 ? void 0 : element.parentElement) !== null && _element$parentElemen !== void 0 ? _element$parentElemen : null,
+      findEntry,
+      source,
+      timeSinceLastFrame,
+      input,
+      available
+    });
+  }
+  var feedback = {
+    input,
+    source,
+    element
+  };
+  if (container.canScroll && !container.canScroll(feedback)) {
+    return continueSearchUp();
+  }
+  var engagement = markAndGetEngagement(element);
+  var config = getInternalConfig((_container$getConfigu = container.getConfiguration) === null || _container$getConfigu === void 0 ? void 0 : _container$getConfigu.call(container, feedback));
+  var allowedAxis = (_container$getAllowed = (_container$getAllowed2 = container.getAllowedAxis) === null || _container$getAllowed2 === void 0 ? void 0 : _container$getAllowed2.call(container, feedback)) !== null && _container$getAllowed !== void 0 ? _container$getAllowed : "all";
+  var scrollBy = getScrollBy({
+    element,
+    engagement,
+    input,
+    timeSinceLastFrame,
+    allowedAxis,
+    config
+  });
+  var scroll = {
+    top: 0,
+    left: 0
+  };
+  if (available.top && scrollBy.top !== 0) {
+    scroll.top = scrollBy.top;
+    available.top = false;
+  }
+  if (available.left && scrollBy.left !== 0) {
+    scroll.left = scrollBy.left;
+    available.left = false;
+  }
+  if (scroll.top !== 0 || scroll.left !== 0) {
+    element.scrollBy(scroll);
+  }
+  return continueSearchUp();
+}
+function tryScrollWindow(_ref2) {
+  var input = _ref2.input, timeSinceLastFrame = _ref2.timeSinceLastFrame, available = _ref2.available, source = _ref2.source, entries = _ref2.entries;
+  var element = document.documentElement;
+  var feedback = {
+    input,
+    source,
+    element
+  };
+  var _iterator = _createForOfIteratorHelper3(entries), _step;
+  try {
+    for (_iterator.s(); !(_step = _iterator.n()).done; ) {
+      var _entry$getConfigurati, _entry$getAllowedAxis, _entry$getAllowedAxis2;
+      var entry = _step.value;
+      if (entry.canScroll && !entry.canScroll(feedback)) {
+        continue;
+      }
+      var engagement = markAndGetEngagement(element);
+      var config = getInternalConfig((_entry$getConfigurati = entry.getConfiguration) === null || _entry$getConfigurati === void 0 ? void 0 : _entry$getConfigurati.call(entry, feedback));
+      var allowedAxis = (_entry$getAllowedAxis = (_entry$getAllowedAxis2 = entry.getAllowedAxis) === null || _entry$getAllowedAxis2 === void 0 ? void 0 : _entry$getAllowedAxis2.call(entry, feedback)) !== null && _entry$getAllowedAxis !== void 0 ? _entry$getAllowedAxis : "all";
+      var scrollBy = getScrollBy({
+        element,
+        engagement,
+        input,
+        config,
+        allowedAxis,
+        getRect: function getRect(element2) {
+          return DOMRect.fromRect({
+            y: 0,
+            x: 0,
+            width: element2.clientWidth,
+            height: element2.clientHeight
+          });
+        },
+        timeSinceLastFrame
+      });
+      var scroll = {
+        top: available.top ? scrollBy.top : 0,
+        left: available.left ? scrollBy.left : 0
+      };
+      if (scroll.top !== 0 || scroll.left !== 0) {
+        element.scrollBy(scroll);
+      }
+      break;
+    }
+  } catch (err) {
+    _iterator.e(err);
+  } finally {
+    _iterator.f();
   }
-  placeholder(which, kind) {
-    const el = document.createElement("div");
-    el.className = "docx-hf-placeholder";
-    el.setAttribute("data-hf-placeholder", "");
-    const label = KIND_LABELS.find((k) => k.value === kind)?.label ?? kind;
-    el.textContent = `No ${label.toLowerCase()} ${which} \u2014 pick a kind to create one.`;
-    return el;
+}
+function tryScroll(_ref3) {
+  var input = _ref3.input, findEntry = _ref3.findEntry, timeSinceLastFrame = _ref3.timeSinceLastFrame, source = _ref3.source, getWindowScrollEntries = _ref3.getWindowScrollEntries, underUsersPointer = _ref3.underUsersPointer;
+  var remainder = tryScrollElements({
+    target: underUsersPointer,
+    timeSinceLastFrame,
+    input,
+    source,
+    findEntry
+  });
+  if (!isScrollingAvailable(remainder)) {
+    return;
   }
-  /**
-   * Surface the caveat that comes with the selected kind. Turning on first/even means those pages
-   * stop using the Default stories entirely, which bites hardest on the OTHER band: enabling an
-   * even header with no even footer leaves even pages footer-less, and enabling a first-page
-   * header with an empty first-page footer leaves page 1 footer-less. The note is shown whenever
-   * first/even is selected (the behavior change is real either way); the fix button appears only
-   * when the counterpart story is missing entirely, which is what a user almost always wants next.
-   */
-  renderKindWarning(which) {
-    const band = this.bandFor(which);
-    const warning = band.querySelector("[data-hf-warning]");
-    if (!warning) return;
-    const kind = this.kinds[which];
-    if (kind === "default") {
-      warning.hidden = true;
-      warning.textContent = "";
-      return;
-    }
-    const other = which === "header" ? "footer" : "header";
-    warning.hidden = false;
-    warning.textContent = `${kind === "even" ? EVEN_WARNING : FIRST_WARNING} `;
-    if (this.partUriFor(other, kind)) return;
-    const fix = document.createElement("button");
-    fix.type = "button";
-    fix.setAttribute("data-hf-fix-counterpart", "");
-    fix.textContent = `Also create a ${kind === "even" ? "matching even" : "first-page"} ${other}`;
-    fix.addEventListener("click", () => {
-      this.setKind(other, kind);
-      this.renderKindWarning(which);
+  tryScrollWindow({
+    input,
+    source,
+    entries: getWindowScrollEntries(),
+    timeSinceLastFrame,
+    available: remainder
+  });
+}
+
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/over-element/make-api.js
+function ownKeys5(e, r) {
+  var t = Object.keys(e);
+  if (Object.getOwnPropertySymbols) {
+    var o = Object.getOwnPropertySymbols(e);
+    r && (o = o.filter(function(r2) {
+      return Object.getOwnPropertyDescriptor(e, r2).enumerable;
+    })), t.push.apply(t, o);
+  }
+  return t;
+}
+function _objectSpread5(e) {
+  for (var r = 1; r < arguments.length; r++) {
+    var t = null != arguments[r] ? arguments[r] : {};
+    r % 2 ? ownKeys5(Object(t), true).forEach(function(r2) {
+      _defineProperty(e, r2, t[r2]);
+    }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys5(Object(t)).forEach(function(r2) {
+      Object.defineProperty(e, r2, Object.getOwnPropertyDescriptor(t, r2));
     });
-    warning.appendChild(fix);
   }
-};
-function parseResult(json) {
-  try {
-    return JSON.parse(json);
-  } catch {
-    return { success: false };
+  return e;
+}
+function makeApi(_ref) {
+  var monitor = _ref.monitor;
+  var elementRegistry = /* @__PURE__ */ new Map();
+  var windowRegistry = /* @__PURE__ */ new Set();
+  function autoScroll(args) {
+    if (true) {
+      var _window$getComputedSt = window.getComputedStyle(args.element), overflowX = _window$getComputedSt.overflowX, overflowY = _window$getComputedSt.overflowY;
+      var isScrollable = overflowX === "auto" || overflowX === "scroll" || overflowY === "auto" || overflowY === "scroll";
+      if (!isScrollable) {
+        console.warn("Auto scrolling has been attached to an element that appears not to be scrollable", {
+          element: args.element,
+          overflowX,
+          overflowY
+        });
+      }
+    }
+    if (true) {
+      var existing = elementRegistry.get(args.element);
+      if (existing) {
+        console.warn("You have already registered autoScrolling on the same element", {
+          existing,
+          proposed: args
+        });
+      }
+    }
+    elementRegistry.set(args.element, args);
+    var cleanup = combine(addScrollableAttribute(args.element), function() {
+      return elementRegistry.delete(args.element);
+    });
+    return once(cleanup);
+  }
+  function autoScrollWindow() {
+    var args = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : {};
+    var unique = _objectSpread5({}, args);
+    windowRegistry.add(unique);
+    function cleanup() {
+      windowRegistry.delete(unique);
+    }
+    return once(cleanup);
+  }
+  function findEntry(element) {
+    var _elementRegistry$get;
+    return (_elementRegistry$get = elementRegistry.get(element)) !== null && _elementRegistry$get !== void 0 ? _elementRegistry$get : null;
+  }
+  function getWindowScrollEntries() {
+    return Array.from(windowRegistry);
+  }
+  function onFrame(_ref2) {
+    var latestArgs = _ref2.latestArgs, underUsersPointer = _ref2.underUsersPointer, timeSinceLastFrame = _ref2.timeSinceLastFrame;
+    tryScroll({
+      input: latestArgs.location.current.input,
+      source: latestArgs.source,
+      findEntry,
+      underUsersPointer,
+      timeSinceLastFrame,
+      getWindowScrollEntries
+    });
   }
+  getScheduler(monitor).onFrame(onFrame);
+  return {
+    autoScroll,
+    autoScrollWindow
+  };
 }
 
+// node_modules/@atlaskit/pragmatic-drag-and-drop-auto-scroll/dist/esm/entry-point/element.js
+var api = makeApi({
+  monitor: monitorForElements
+});
+var autoScrollForElements = api.autoScroll;
+var autoScrollWindowForElements = api.autoScrollWindow;
+
 // src/editor-reconcile.ts
 function tokenOf(unit) {
   return unidOf(unit.id) + (unit.sig ? "|" + unit.sig : "");
@@ -3049,15 +5595,32 @@ function diffUnits(oldUnids, newUnits) {
     const bar = token.indexOf("|");
     return bar < 0 ? token : token.slice(0, bar);
   };
-  const substituted = [];
+  const moved = [];
   const usedRemoved = /* @__PURE__ */ new Set();
+  const usedAdded = /* @__PURE__ */ new Set();
+  const removedByToken = /* @__PURE__ */ new Map();
+  for (const oi of removed) {
+    (removedByToken.get(oldUnids[oi]) ?? removedByToken.set(oldUnids[oi], []).get(oldUnids[oi])).push(oi);
+  }
+  for (const nj of added) {
+    const candidates = removedByToken.get(newUnids[nj]);
+    const oi = candidates?.find((i2) => !usedRemoved.has(i2));
+    if (oi !== void 0) {
+      moved.push({ oldIndex: oi, newIndex: nj });
+      usedRemoved.add(oi);
+      usedAdded.add(nj);
+    }
+  }
+  const substituted = [];
   const removedByUnid = /* @__PURE__ */ new Map();
   for (const oi of removed) {
+    if (usedRemoved.has(oi)) continue;
     const u = bareUnid(oldUnids[oi]);
     (removedByUnid.get(u) ?? removedByUnid.set(u, []).get(u)).push(oi);
   }
   const unmatchedAdded = [];
   for (const nj of added) {
+    if (usedAdded.has(nj)) continue;
     const candidates = removedByUnid.get(bareUnid(newUnids[nj]));
     const oi = candidates?.find((i2) => !usedRemoved.has(i2));
     if (oi !== void 0) {
@@ -3088,7 +5651,7 @@ function diffUnits(oldUnids, newUnits) {
       }
     }
   }
-  return { keep, removed, added, substituted };
+  return { keep, removed, added, substituted, moved };
 }
 function needsRemount(diff, newUnits, oldKinds, threshold = 40) {
   if (diff.added.length + diff.removed.length > threshold) return true;
@@ -3105,6 +5668,46 @@ function needsRemount(diff, newUnits, oldKinds, threshold = 40) {
 
 // src/editor.ts
 var EDITABLE_TAGS = /* @__PURE__ */ new Set(["P", "H1", "H2", "H3", "H4", "H5", "H6"]);
+var BLOCK_DRAG_TYPE = "docxodus-block";
+var blockDragStyledDocuments = /* @__PURE__ */ new WeakSet();
+function ensureBlockDragStyles(doc) {
+  if (blockDragStyledDocuments.has(doc)) return;
+  blockDragStyledDocuments.add(doc);
+  const style = doc.createElement("style");
+  style.dataset.docxodusBlockDrag = "true";
+  style.textContent = `
+.docx-block-handle {
+  position: fixed; z-index: 2147483000; display: none; width: 26px; height: 28px;
+  align-items: center; justify-content: center; padding: 0; border: 1px solid #d0d5dd;
+  border-radius: 6px; background: #fff; color: #667085; box-shadow: 0 1px 3px rgba(16,24,40,.12);
+  cursor: grab; font: 700 17px/1 system-ui, sans-serif; user-select: none; touch-action: none;
+}
+.docx-block-handle:hover, .docx-block-handle:focus-visible { color: #344054; border-color: #98a2b3; outline: none; }
+.docx-block-handle[aria-pressed="true"] { color: #175cd3; border-color: #84adff; background: #eff8ff; }
+.docx-block-handle.docx-block-dragging { cursor: grabbing; opacity: .78; }
+.docx-block-drop-indicator {
+  position: fixed; z-index: 2147482999; display: none; height: 3px; pointer-events: none;
+  border-radius: 999px; background: #2e90fa; box-shadow: 0 0 0 1px rgba(255,255,255,.85);
+}
+.docx-block-move-menu {
+  position: fixed; z-index: 2147483001; display: none; min-width: 150px; padding: 5px;
+  border: 1px solid #d0d5dd; border-radius: 8px; background: #fff;
+  box-shadow: 0 8px 24px rgba(16,24,40,.18); font: 13px/1.35 system-ui, sans-serif;
+}
+.docx-block-move-menu button { display: block; width: 100%; padding: 7px 9px; border: 0; border-radius: 5px; background: transparent; color: #344054; text-align: left; }
+.docx-block-move-menu button:hover, .docx-block-move-menu button:focus-visible { background: #f2f4f7; outline: none; }
+.docx-block-move-menu button:disabled { color: #98a2b3; background: transparent; }
+.docx-block-move-flash { animation: docx-block-move-flash 800ms ease-out; }
+@keyframes docx-block-move-flash { from { box-shadow: 0 0 0 3px rgba(46,144,250,.55); } to { box-shadow: none; } }
+.docx-block-live-region { position: fixed; width: 1px; height: 1px; overflow: hidden; clip-path: inset(50%); white-space: nowrap; }
+`;
+  (doc.head ?? doc.documentElement).appendChild(style);
+}
+function trackedChangeWireName(mode) {
+  if (mode === 1 /* RenderInline */) return "render_inline";
+  if (mode === 2 /* StripDeletions */) return "strip_deletions";
+  return "accept";
+}
 function fontWeightIsBold(w) {
   if (w === "bold" || w === "bolder") return true;
   const n = parseInt(w, 10);
@@ -3252,9 +5855,9 @@ function trimBounds(block) {
 }
 function trimmedSpan(block, span) {
   const { leading, trimmedLen } = trimBounds(block);
-  const start = Math.max(0, Math.min(span.start - Math.min(span.start, leading), trimmedLen));
-  const end = Math.max(start, Math.min(span.start + span.length - leading, trimmedLen));
-  return { start, length: end - start };
+  const start2 = Math.max(0, Math.min(span.start - Math.min(span.start, leading), trimmedLen));
+  const end = Math.max(start2, Math.min(span.start + span.length - leading, trimmedLen));
+  return { start: start2, length: end - start2 };
 }
 function contentPositionIn(el, offset) {
   let remaining = offset;
@@ -3297,9 +5900,9 @@ function setSelectionBetween(anchor, focus) {
     probe.collapse(true);
     const focusIsBefore = probe.comparePoint(focus.node, focus.offset) < 0;
     const range = document.createRange();
-    const start = focusIsBefore ? focus : anchor;
+    const start2 = focusIsBefore ? focus : anchor;
     const end = focusIsBefore ? anchor : focus;
-    range.setStart(start.node, start.offset);
+    range.setStart(start2.node, start2.offset);
     range.setEnd(end.node, end.offset);
     sel.removeAllRanges();
     sel.addRange(range);
@@ -3347,17 +5950,17 @@ function selectionSpanIn(block) {
   const range = sel.getRangeAt(0);
   if (range.collapsed) return null;
   if (!block.contains(range.startContainer) || !block.contains(range.endContainer)) return null;
-  const start = contentOffsetOf(block, range.startContainer, range.startOffset);
+  const start2 = contentOffsetOf(block, range.startContainer, range.startOffset);
   const end = contentOffsetOf(block, range.endContainer, range.endOffset);
-  const span = trimmedSpan(block, { start: Math.min(start, end), length: Math.abs(end - start) });
+  const span = trimmedSpan(block, { start: Math.min(start2, end), length: Math.abs(end - start2) });
   return span.length > 0 ? span : null;
 }
-function selectRange(el, start, length) {
+function selectRange(el, start2, length) {
   const sel = typeof window !== "undefined" ? window.getSelection() : null;
   if (!sel || !el.isConnected) return;
   el.focus();
   const range = document.createRange();
-  const end = start + length;
+  const end = start2 + length;
   let pos = 0;
   let startSet = false;
   const walk = (node) => {
@@ -3366,8 +5969,8 @@ function selectRange(el, start, length) {
         if (isInMarker(child)) continue;
         const raw = child.textContent ?? "";
         const len = stripBidi(raw).length;
-        if (!startSet && pos + len >= start) {
-          range.setStart(child, domOffsetForContentOffset(raw, start - pos));
+        if (!startSet && pos + len >= start2) {
+          range.setStart(child, domOffsetForContentOffset(raw, start2 - pos));
           startSet = true;
         }
         if (startSet && pos + len >= end) {
@@ -3418,7 +6021,7 @@ function selectionHasFormat(key, fallback) {
       return false;
   }
 }
-function completeArgs(bytes, cssPrefix, fabricate, paginated, scale) {
+function completeArgs(bytes, cssPrefix, fabricate, paginated, scale, renderTrackedChanges) {
   return [
     bytes,
     "Document",
@@ -3442,7 +6045,7 @@ function completeArgs(bytes, cssPrefix, fabricate, paginated, scale) {
     true,
     /* renderHeadersAndFooters */
     paginated,
-    false,
+    renderTrackedChanges,
     true,
     true,
     false,
@@ -3465,6 +6068,27 @@ var DocxEditor = class _DocxEditor {
      * structural edit (split/merge/format) is lost. While this flag is set, commitBlock no-ops.
      */
     this.replacing = false;
+    /** Editor-owned block-move chrome. It is deliberately outside the rendered unit tree. */
+    this.blockDragHandle = null;
+    this.blockDropIndicator = null;
+    this.blockMoveMenu = null;
+    this.blockMoveLive = null;
+    this.blockDragSource = null;
+    this.blockDragCleanup = [];
+    this.blockDragTargetCleanup = [];
+    this.blockDragging = false;
+    this.blockDragPointerDown = false;
+    /** Anchors the current drag source may legally move next to, per the engine's own rules.
+     *  Null when the bridge predates ValidMoveTargets — then every block is offered, as before. */
+    this.blockMoveTargets = null;
+    /** Memoized `ValidMoveTargets` answers, keyed by source anchor and dropped whenever an edit
+     *  lands. The legal-target set is a property of the document, so hovering back and forth over
+     *  the same blocks between edits must not re-ask the engine. */
+    this.blockMoveTargetCache = /* @__PURE__ */ new Map();
+    /** Cancels the pending idle prefetch of the hovered block's targets — see `showBlockHandle`. */
+    this.blockMoveTargetPrefetch = null;
+    /** Why the last move was refused, verbatim from the engine — diagnostics, not announcement copy. */
+    this.lastMoveError = null;
     /**
      * The last real (non-collapsed) text selection inside an editable block. A toolbar control that
      * must take focus to be used — the font-size combobox — blurs the block and collapses the live
@@ -3621,8 +6245,8 @@ var DocxEditor = class _DocxEditor {
    *  body edit root by design — also register. The fence still rejects other editors on the page. */
   editableBlockOf(node) {
     if (!node) return null;
-    const start = node.nodeType === 1 ? node : node.parentElement;
-    const block = start?.closest('[data-anchor][contenteditable="true"]') ?? null;
+    const start2 = node.nodeType === 1 ? node : node.parentElement;
+    const block = start2?.closest('[data-anchor][contenteditable="true"]') ?? null;
     return block && this.container.contains(block) ? block : null;
   }
   /**
@@ -3663,18 +6287,34 @@ var DocxEditor = class _DocxEditor {
       paginated: options.paginated ?? false,
       scale: options.scale ?? 1,
       headerFooter: options.headerFooter ?? false,
-      onEdit: options.onEdit
+      blockDrag: options.blockDrag ?? false,
+      trackedChanges: options.trackedChanges ?? 0 /* Accept */,
+      revisionAuthor: options.revisionAuthor ?? "docxodus",
+      onEdit: options.onEdit,
+      onMove: options.onMove
     };
-    const handle = exports.DocxSessionBridge.OpenSession(bytes, '{"emitMarkdownPatch":false}');
+    const handle = exports.DocxSessionBridge.OpenSession(bytes, JSON.stringify({
+      emitMarkdownPatch: false,
+      trackedChanges: trackedChangeWireName(opts.trackedChanges),
+      revisionAuthor: opts.revisionAuthor
+    }));
     const editor = new _DocxEditor(container, exports, handle, opts);
     editor.refreshAnchorMap();
     if (opts.headerFooter) editor.createRegion();
     const fullHtml = exports.DocumentConverter.ConvertDocxToHtmlComplete(
-      ...completeArgs(bytes, opts.cssPrefix, opts.fabricateClasses, opts.paginated, opts.scale)
+      ...completeArgs(
+        bytes,
+        opts.cssPrefix,
+        opts.fabricateClasses,
+        opts.paginated,
+        opts.scale,
+        opts.trackedChanges === 1 /* RenderInline */
+      )
     );
     if (opts.paginated) editor.mountPaginated(fullHtml);
     else editor.mountHtml(fullHtml);
     editor.syncRegionToBody();
+    editor.setupBlockDrag();
     return editor;
   }
   /**
@@ -3701,6 +6341,7 @@ var DocxEditor = class _DocxEditor {
       document.removeEventListener("mouseup", this.onMouseUp, true);
     }
     this.clearDragSelection();
+    this.teardownBlockDrag();
     this.exports.DocxSessionBridge.CloseSession(this.handle);
   }
   /**
@@ -3728,6 +6369,457 @@ var DocxEditor = class _DocxEditor {
   get sessionHandle() {
     return this.handle;
   }
+  /** Move one top-level body block relative to another and repaint from the live session. */
+  moveBlock(sourceAnchorId, targetAnchorId, position) {
+    this.assertOpen();
+    const bridge = this.exports.DocxSessionBridge;
+    if (typeof bridge.MoveBlock !== "function") return false;
+    const res = this.parseEdit(
+      bridge.MoveBlock(this.handle, sourceAnchorId, targetAnchorId, position)
+    );
+    if (!res.success) {
+      this.lastMoveError = res.error?.message ?? null;
+      this.announceBlockMove("This block cannot be moved there.");
+      return false;
+    }
+    if ((res.created?.length ?? 0) === 0 && (res.modified?.length ?? 0) === 0 && (res.removed?.length ?? 0) === 0) {
+      this.announceBlockMove("The block is already in that position.");
+      return true;
+    }
+    const destination = res.created?.[0] ?? res.modified?.[0];
+    this.reconcile();
+    const moved = destination ? this.bodyUnitNodes().find((el) => el.getAttribute("data-anchor") === destination.unid) : null;
+    if (moved) {
+      moved.classList.add("docx-block-move-flash");
+      moved.addEventListener("animationend", () => moved.classList.remove("docx-block-move-flash"), {
+        once: true
+      });
+      const focusTarget = EDITABLE_TAGS.has(moved.tagName) ? moved : moved.querySelector('[data-anchor][contenteditable="true"]');
+      if (focusTarget) {
+        this.activeBlock = focusTarget;
+        focusTarget.focus({ preventScroll: true });
+      }
+    }
+    this.options.onMove?.({
+      sourceAnchorId,
+      destinationAnchorId: destination?.id ?? sourceAnchorId
+    });
+    this.announceBlockMove("Block moved.");
+    return true;
+  }
+  /** Resolve any rendered descendant to its top-level body move unit (tables stay whole). */
+  blockUnitOf(target) {
+    const node = target instanceof Node ? target : null;
+    const el = node?.nodeType === Node.ELEMENT_NODE ? node : node?.parentElement;
+    if (!el || !this.editRoot.contains(el)) return null;
+    let unit = null;
+    for (let candidate = el.closest("[data-anchor]"); candidate && this.editRoot.contains(candidate); candidate = candidate.parentElement?.closest("[data-anchor]") ?? null) {
+      unit = candidate;
+    }
+    if (!unit || unit.closest("section.footnotes, section.endnotes")) return null;
+    return unit;
+  }
+  isMovableBlockUnit(unit) {
+    if (!unit || !this.anchorIdOf(unit)) return false;
+    if (unit.matches("[class$='row-del'], [class*='row-del ']") || unit.querySelector("tr[class$='row-del'], tr[class*='row-del '], del[class$='move-from'], del[class*='move-from ']")) return false;
+    return unit.tagName === "TABLE" || EDITABLE_TAGS.has(unit.tagName);
+  }
+  currentBlockDragSource() {
+    if (this.isMovableBlockUnit(this.blockDragSource) && this.blockDragSource.isConnected)
+      return this.blockDragSource;
+    const fromActive = this.blockUnitOf(this.activeBlock);
+    if (this.isMovableBlockUnit(fromActive)) {
+      this.blockDragSource = fromActive;
+      return fromActive;
+    }
+    return null;
+  }
+  showBlockHandle(unit) {
+    const handle = this.blockDragHandle;
+    if (!handle || !this.isMovableBlockUnit(unit)) return;
+    const changed = unit !== this.blockDragSource;
+    this.blockDragSource = unit;
+    const known = this.blockMoveTargetsFor(unit, { cachedOnly: true });
+    if (known?.size === 0) {
+      handle.style.display = "none";
+      return;
+    }
+    if (changed && known === void 0) this.prefetchBlockMoveTargets(unit);
+    const rect = unit.getBoundingClientRect();
+    handle.style.display = "flex";
+    handle.style.left = `${Math.max(4, rect.left - 32)}px`;
+    handle.style.top = `${Math.max(4, rect.top + (unit.tagName === "TABLE" ? 6 : Math.max(0, (rect.height - 28) / 2)))}px`;
+    const preview = (unit.textContent ?? "").trim().replace(/\s+/g, " ").slice(0, 48);
+    handle.setAttribute("aria-label", preview ? `Move block: ${preview}` : "Move block");
+  }
+  hideBlockHandle() {
+    if (this.blockDragging || this.blockMoveMenu?.style.display === "block") return;
+    if (this.blockDragHandle) this.blockDragHandle.style.display = "none";
+  }
+  positionBlockHandle() {
+    const source = this.currentBlockDragSource();
+    if (source && this.blockDragHandle?.style.display !== "none") this.showBlockHandle(source);
+  }
+  showDropIndicator(target, position) {
+    const indicator = this.blockDropIndicator;
+    if (!indicator) return;
+    const rect = this.unitWrapperOf(target).getBoundingClientRect();
+    indicator.style.display = "block";
+    indicator.style.left = `${rect.left}px`;
+    indicator.style.top = `${position === "before" ? rect.top - 1 : rect.bottom - 1}px`;
+    indicator.style.width = `${Math.max(24, rect.width)}px`;
+  }
+  hideDropIndicator() {
+    if (this.blockDropIndicator) this.blockDropIndicator.style.display = "none";
+  }
+  announceBlockMove(message) {
+    const live = this.blockMoveLive;
+    if (!live) return;
+    live.textContent = "";
+    this.container.ownerDocument.defaultView?.setTimeout(() => {
+      live.textContent = message;
+    }, 0);
+  }
+  /**
+   * Ask the engine which anchors the current source may move next to. One call per drag source,
+   * so the UI offers only drops MoveBlock will accept — a document with section breaks is
+   * partitioned into regions, and drawing an indicator across one only to fail the drop was the
+   * behaviour this replaces. Null (no bridge support) keeps the previous offer-everything path.
+   */
+  refreshBlockMoveTargets(source) {
+    this.blockMoveTargets = source ? this.blockMoveTargetsFor(source) ?? null : null;
+  }
+  /**
+   * This block's legal destinations, from the memo when it is there. Returns `undefined` — not
+   * `null` — for "not asked yet", so a caller can tell an unknown answer from the engine's
+   * "no bridge support, offer everything" one.
+   */
+  blockMoveTargetsFor(source, options = {}) {
+    const bridge = this.exports.DocxSessionBridge;
+    const sourceId = this.anchorIdOf(source);
+    if (!sourceId || typeof bridge.ValidMoveTargets !== "function") return null;
+    if (this.blockMoveTargetCache.has(sourceId)) return this.blockMoveTargetCache.get(sourceId);
+    if (options.cachedOnly) return void 0;
+    let targets;
+    try {
+      const parsed = JSON.parse(bridge.ValidMoveTargets(this.handle, sourceId));
+      targets = new Map(parsed.map((t) => [t.anchorId, { before: t.before, after: t.after }]));
+    } catch {
+      targets = null;
+    }
+    this.blockMoveTargetCache.set(sourceId, targets);
+    return targets;
+  }
+  /**
+   * Ask for the hovered block's destinations off the interaction path, and hide the handle if
+   * the answer comes back empty and that block is still the one under the pointer. The handle
+   * therefore appears immediately on hover and withdraws a beat later on the rare immovable
+   * block, instead of every hover paying for the query up front.
+   */
+  prefetchBlockMoveTargets(source) {
+    const view = this.container.ownerDocument.defaultView;
+    if (!view) return;
+    this.blockMoveTargetPrefetch?.();
+    const run = () => {
+      this.blockMoveTargetPrefetch = null;
+      if (this.closed || !source.isConnected || this.blockDragSource !== source) return;
+      if (this.blockMoveTargetsFor(source)?.size === 0 && this.blockDragHandle)
+        this.blockDragHandle.style.display = "none";
+    };
+    const idle = view;
+    if (idle.requestIdleCallback && idle.cancelIdleCallback) {
+      const id = idle.requestIdleCallback(run, { timeout: 500 });
+      this.blockMoveTargetPrefetch = () => idle.cancelIdleCallback(id);
+    } else {
+      const id = view.setTimeout(run, 0);
+      this.blockMoveTargetPrefetch = () => view.clearTimeout(id);
+    }
+  }
+  /**
+   * Whether `unit` is a legal destination for the current drag source — for a SPECIFIC side when
+   * one is given. A cross-block range or a section break between the blocks can make one side
+   * legal and the other not, so "this target is reachable" is not enough to pick a position.
+   */
+  isValidMoveTarget(unit, position) {
+    if (!this.blockMoveTargets) return true;
+    const id = this.anchorIdOf(unit);
+    const sides = id ? this.blockMoveTargets.get(id) : void 0;
+    if (!sides) return false;
+    return position ? sides[position] : sides.before || sides.after;
+  }
+  /**
+   * The side of `unit` a drop at `clientY` should land on: the half the pointer is in, snapped to
+   * the other side when only that one is legal. Snapping rather than refusing keeps a reachable
+   * target usable — the illegal side is usually illegal only because a section break or a
+   * cross-block range sits between the two blocks on that side.
+   */
+  dropPositionFor(unit, clientY) {
+    const rect = unit.getBoundingClientRect();
+    const preferred = clientY < rect.top + rect.height / 2 ? "before" : "after";
+    if (this.isValidMoveTarget(unit, preferred)) return preferred;
+    const other = preferred === "before" ? "after" : "before";
+    return this.isValidMoveTarget(unit, other) ? other : preferred;
+  }
+  refreshBlockDropTargets() {
+    for (const cleanup of this.blockDragTargetCleanup.splice(0)) cleanup();
+    if (!this.blockDragHandle || this.options.paginated) return;
+    for (const unit of this.bodyUnitNodes().filter((el) => this.isMovableBlockUnit(el))) {
+      this.blockDragTargetCleanup.push(dropTargetForElements({
+        element: unit,
+        // A target the engine would refuse is not a drop target at all, so Pragmatic never
+        // fires onDragEnter for it and no indicator is drawn over it.
+        canDrop: ({ source }) => source.data.type === BLOCK_DRAG_TYPE && source.data.sourceAnchorId !== this.anchorIdOf(unit) && this.isValidMoveTarget(unit),
+        getData: ({ input }) => ({
+          type: BLOCK_DRAG_TYPE,
+          targetAnchorId: this.anchorIdOf(unit),
+          position: this.dropPositionFor(unit, input.clientY),
+          targetElement: unit
+        }),
+        onDragEnter: ({ self }) => {
+          const pos = self.data.position === "after" ? "after" : "before";
+          this.showDropIndicator(unit, pos);
+        },
+        onDrag: ({ self }) => {
+          const pos = self.data.position === "after" ? "after" : "before";
+          this.showDropIndicator(unit, pos);
+        },
+        onDragLeave: () => this.hideDropIndicator()
+      }));
+    }
+  }
+  closeBlockMoveMenu(restoreFocus = false) {
+    if (!this.blockMoveMenu || !this.blockDragHandle) return;
+    this.blockMoveMenu.style.display = "none";
+    this.blockDragHandle.setAttribute("aria-expanded", "false");
+    this.blockDragHandle.setAttribute("aria-pressed", "false");
+    if (restoreFocus) this.blockDragHandle.focus({ preventScroll: true });
+  }
+  openBlockMoveMenu() {
+    const menu = this.blockMoveMenu;
+    const handle = this.blockDragHandle;
+    const source = this.currentBlockDragSource();
+    if (!menu || !handle || !source) return;
+    this.refreshBlockMoveTargets(source);
+    menu.querySelectorAll("button[data-move]").forEach((button) => {
+      button.disabled = !this.blockMoveDestination(source, button.dataset.move ?? "");
+    });
+    const rect = handle.getBoundingClientRect();
+    menu.style.display = "block";
+    menu.style.left = `${Math.max(4, rect.right + 6)}px`;
+    menu.style.top = `${Math.max(4, rect.top)}px`;
+    handle.setAttribute("aria-expanded", "true");
+    handle.setAttribute("aria-pressed", "true");
+    menu.querySelector("button:not(:disabled)")?.focus({ preventScroll: true });
+  }
+  /**
+   * Resolve a move-menu action to the block it should land against, considering only destinations
+   * the engine accepts. "Top"/"bottom" therefore mean the ends of the source's own movable region
+   * — on a document with section breaks that is the section, not the document, which is what makes
+   * the commands work at all there instead of always failing.
+   */
+  blockMoveDestination(source, action) {
+    const units = this.bodyUnitNodes().filter((el) => this.isMovableBlockUnit(el));
+    const index = units.indexOf(source);
+    if (index < 0) return null;
+    const position = action === "up" || action === "top" ? "before" : "after";
+    const side = position === "before" ? units.slice(0, index) : units.slice(index + 1);
+    const candidates = side.filter((el) => this.isValidMoveTarget(el, position));
+    if (candidates.length === 0) return null;
+    if (action === "up") return { target: candidates[candidates.length - 1], position };
+    if (action === "down") return { target: candidates[0], position };
+    if (action === "top") return { target: candidates[0], position };
+    if (action === "bottom") return { target: candidates[candidates.length - 1], position };
+    return null;
+  }
+  runBlockMoveMenuAction(action) {
+    const source = this.currentBlockDragSource();
+    if (!source) return;
+    const destination = this.blockMoveDestination(source, action);
+    this.closeBlockMoveMenu();
+    if (!destination) return;
+    const sourceId = this.anchorIdOf(source);
+    const targetId = this.anchorIdOf(destination.target);
+    if (sourceId && targetId) this.moveBlock(sourceId, targetId, destination.position);
+  }
+  /** The nearest ancestor that actually scrolls the document flow, for drag autoscroll. */
+  scrollContainer() {
+    const view = this.container.ownerDocument.defaultView;
+    for (let el = this.editRoot; el; el = el.parentElement) {
+      const overflowY = view?.getComputedStyle(el).overflowY ?? "visible";
+      if ((overflowY === "auto" || overflowY === "scroll") && el.scrollHeight > el.clientHeight)
+        return el;
+    }
+    return null;
+  }
+  /** Mount one floating handle; PDD owns pointer dragging while the menu owns keyboard moves. */
+  setupBlockDrag() {
+    if (!this.options.blockDrag || this.options.paginated || this.closed || this.blockDragHandle)
+      return;
+    const doc = this.container.ownerDocument;
+    ensureBlockDragStyles(doc);
+    const handle = doc.createElement("div");
+    handle.className = "docx-block-handle";
+    handle.textContent = "\u283F";
+    handle.tabIndex = 0;
+    handle.setAttribute("role", "button");
+    handle.setAttribute("contenteditable", "false");
+    handle.setAttribute("aria-haspopup", "menu");
+    handle.setAttribute("aria-expanded", "false");
+    handle.setAttribute("aria-pressed", "false");
+    const indicator = doc.createElement("div");
+    indicator.className = "docx-block-drop-indicator";
+    const menu = doc.createElement("div");
+    menu.className = "docx-block-move-menu";
+    menu.setAttribute("role", "menu");
+    menu.innerHTML = `
+      <button type="button" role="menuitem" data-move="up">Move up</button>
+      <button type="button" role="menuitem" data-move="down">Move down</button>
+      <button type="button" role="menuitem" data-move="top">Move to top</button>
+      <button type="button" role="menuitem" data-move="bottom">Move to bottom</button>`;
+    const live = doc.createElement("div");
+    live.className = "docx-block-live-region";
+    live.setAttribute("role", "status");
+    live.setAttribute("aria-live", "polite");
+    this.container.append(handle, indicator, menu, live);
+    this.blockDragHandle = handle;
+    this.blockDropIndicator = indicator;
+    this.blockMoveMenu = menu;
+    this.blockMoveLive = live;
+    const onPointerMove = (event) => {
+      if (this.blockDragging || this.blockDragPointerDown) return;
+      const unit = this.blockUnitOf(event.target);
+      if (this.isMovableBlockUnit(unit)) this.showBlockHandle(unit);
+    };
+    const onFocusIn = (event) => {
+      const unit = this.blockUnitOf(event.target);
+      if (this.isMovableBlockUnit(unit)) this.showBlockHandle(unit);
+    };
+    const onPointerLeave = (event) => {
+      const next = event.relatedTarget instanceof Node ? event.relatedTarget : null;
+      if (next && (handle.contains(next) || menu.contains(next))) return;
+      this.hideBlockHandle();
+    };
+    const onViewportChange = () => this.positionBlockHandle();
+    this.container.addEventListener("pointermove", onPointerMove);
+    this.container.addEventListener("focusin", onFocusIn);
+    this.container.addEventListener("pointerleave", onPointerLeave);
+    doc.addEventListener("scroll", onViewportChange, true);
+    doc.defaultView?.addEventListener("resize", onViewportChange);
+    this.blockDragCleanup.push(
+      () => this.container.removeEventListener("pointermove", onPointerMove),
+      () => this.container.removeEventListener("focusin", onFocusIn),
+      () => this.container.removeEventListener("pointerleave", onPointerLeave),
+      () => doc.removeEventListener("scroll", onViewportChange, true),
+      () => doc.defaultView?.removeEventListener("resize", onViewportChange)
+    );
+    const onHandleClick = () => {
+      if (menu.style.display === "block") this.closeBlockMoveMenu();
+      else this.openBlockMoveMenu();
+    };
+    const onHandlePointerDown = () => {
+      this.blockDragPointerDown = true;
+    };
+    const onPointerUp = () => {
+      this.blockDragPointerDown = false;
+    };
+    const onHandleKeydown = (event) => {
+      if (event.key !== "Enter" && event.key !== " ") return;
+      event.preventDefault();
+      onHandleClick();
+    };
+    const onMenuClick = (event) => {
+      const button = event.target?.closest("button[data-move]");
+      if (button && !button.disabled) this.runBlockMoveMenuAction(button.dataset.move ?? "");
+    };
+    const onMenuKeydown = (event) => {
+      if (event.key === "Escape") {
+        event.preventDefault();
+        this.closeBlockMoveMenu(true);
+      }
+    };
+    handle.addEventListener("click", onHandleClick);
+    handle.addEventListener("pointerdown", onHandlePointerDown);
+    handle.addEventListener("keydown", onHandleKeydown);
+    menu.addEventListener("click", onMenuClick);
+    menu.addEventListener("keydown", onMenuKeydown);
+    doc.addEventListener("pointerup", onPointerUp, true);
+    doc.addEventListener("pointercancel", onPointerUp, true);
+    this.blockDragCleanup.push(
+      () => handle.removeEventListener("click", onHandleClick),
+      () => handle.removeEventListener("pointerdown", onHandlePointerDown),
+      () => handle.removeEventListener("keydown", onHandleKeydown),
+      () => menu.removeEventListener("click", onMenuClick),
+      () => menu.removeEventListener("keydown", onMenuKeydown),
+      () => doc.removeEventListener("pointerup", onPointerUp, true),
+      () => doc.removeEventListener("pointercancel", onPointerUp, true)
+    );
+    this.blockDragCleanup.push(draggable({
+      element: handle,
+      canDrag: () => !!this.currentBlockDragSource(),
+      getInitialData: () => {
+        const source = this.currentBlockDragSource();
+        return { type: BLOCK_DRAG_TYPE, sourceAnchorId: source ? this.anchorIdOf(source) : void 0 };
+      },
+      onDragStart: () => {
+        this.blockDragging = true;
+        handle.classList.add("docx-block-dragging");
+        this.closeBlockMoveMenu();
+        this.refreshBlockMoveTargets(this.currentBlockDragSource());
+        this.refreshBlockDropTargets();
+      },
+      onDrop: () => {
+        this.blockDragging = false;
+        this.blockDragPointerDown = false;
+        handle.classList.remove("docx-block-dragging");
+        this.hideDropIndicator();
+      }
+    }));
+    this.blockDragCleanup.push(monitorForElements({
+      canMonitor: ({ source }) => source.data.type === BLOCK_DRAG_TYPE,
+      onDrop: ({ source, location: location2 }) => {
+        this.hideDropIndicator();
+        const drop = location2.current.dropTargets[0]?.data;
+        const sourceId = source.data.sourceAnchorId;
+        const targetId = drop?.targetAnchorId;
+        const position = drop?.position === "after" ? "after" : "before";
+        if (typeof sourceId === "string" && typeof targetId === "string")
+          this.moveBlock(sourceId, targetId, position);
+        else
+          this.announceBlockMove("Move cancelled \u2014 the block was not dropped on a valid position.");
+      }
+    }));
+    const scroller = this.scrollContainer();
+    if (scroller) {
+      this.blockDragCleanup.push(autoScrollForElements({
+        element: scroller,
+        canScroll: ({ source }) => source.data.type === BLOCK_DRAG_TYPE,
+        getAllowedAxis: () => "vertical"
+      }));
+    }
+    this.blockDragCleanup.push(autoScrollWindowForElements({
+      canScroll: ({ source }) => source.data.type === BLOCK_DRAG_TYPE,
+      getAllowedAxis: () => "vertical"
+    }));
+    this.refreshBlockDropTargets();
+  }
+  teardownBlockDrag() {
+    this.blockMoveTargetPrefetch?.();
+    this.blockMoveTargetPrefetch = null;
+    this.blockMoveTargetCache.clear();
+    for (const cleanup of this.blockDragTargetCleanup.splice(0)) cleanup();
+    for (const cleanup of this.blockDragCleanup.splice(0)) cleanup();
+    this.blockDragHandle?.remove();
+    this.blockDropIndicator?.remove();
+    this.blockMoveMenu?.remove();
+    this.blockMoveLive?.remove();
+    this.blockDragHandle = null;
+    this.blockDropIndicator = null;
+    this.blockMoveMenu = null;
+    this.blockMoveLive = null;
+    this.blockDragSource = null;
+    this.blockDragging = false;
+    this.blockDragPointerDown = false;
+  }
   // ─── internals ───────────────────────────────────────────────────────
   assertOpen() {
     if (this.closed) throw new Error("DocxEditor is closed");
@@ -3849,6 +6941,10 @@ var DocxEditor = class _DocxEditor {
   }
   wireBlock(el) {
     if (!EDITABLE_TAGS.has(el.tagName)) return;
+    if (el.closest("tr[class$='row-del'], tr[class*='row-del ']") || el.querySelector(":scope > del[class$='move-from'], :scope > del[class*='move-from ']")) {
+      el.setAttribute("contenteditable", "false");
+      return;
+    }
     const unid = el.getAttribute("data-anchor");
     if (!unid || !this.anchorIdOf(el)) return;
     el.setAttribute("contenteditable", "true");
@@ -3910,12 +7006,7 @@ var DocxEditor = class _DocxEditor {
       this.options.onEdit?.({ anchorId: newAnchor, unid: newUnid });
       return;
     }
-    const html = this.exports.DocxSessionBridge.RenderBlockHtml(
-      this.handle,
-      newAnchor,
-      this.options.cssPrefix,
-      this.options.fabricateClasses
-    );
+    const html = this.renderBlockHtml(newAnchor);
     if (html.charCodeAt(0) !== 123) {
       const fresh = new DOMParser().parseFromString(html, "text/html").body.firstElementChild;
       const inBand = this.isBandBlock(el);
@@ -3956,9 +7047,10 @@ var DocxEditor = class _DocxEditor {
       }
     }
     const inTableCell = !!el.closest("table");
-    if (ev.key === "Tab") {
+    if (ev.key === "Tab" && !ev.ctrlKey && !ev.metaKey && !ev.altKey && !ev.isComposing) {
       if (inTableCell) {
         ev.preventDefault();
+        this.navigateTableCell(el, ev.shiftKey);
         return;
       }
       if (isListBlock(el)) {
@@ -3987,6 +7079,42 @@ var DocxEditor = class _DocxEditor {
       }
     }
   }
+  /** Editable cells in visual document order, excluding cells from any nested table. */
+  tableCellsFor(el) {
+    const cell = el.closest("td, th");
+    const table = cell?.closest("table");
+    if (!cell || !table) return null;
+    const cells = Array.from(table.querySelectorAll("td, th")).filter((candidate) => candidate.closest("table") === table);
+    const index = cells.indexOf(cell);
+    return index >= 0 ? { cells, index } : null;
+  }
+  /** First addressable paragraph in a cell, fenced against nested-table descendants. */
+  editableInCell(cell) {
+    return Array.from(
+      cell.querySelectorAll('[data-anchor][contenteditable="true"]')
+    ).find((block) => block.closest("td, th") === cell) ?? null;
+  }
+  /** Word-style cell navigation: Shift+Tab goes back, Tab goes forward, and Tab at the
+   *  final cell appends a row before entering its first cell. The first cell is a hard
+   *  boundary for Shift+Tab so focus never leaks out of the editor table. */
+  navigateTableCell(el, backwards) {
+    const state = this.tableCellsFor(el);
+    if (!state) return;
+    const adjacent = state.cells[state.index + (backwards ? -1 : 1)];
+    if (adjacent) {
+      const target2 = this.editableInCell(adjacent);
+      if (target2) placeCaretAtOffset(target2, 0);
+      return;
+    }
+    if (backwards) return;
+    this.activeBlock = el;
+    this.insertTableRow("below");
+    const fresh = this.activeBlock ? this.tableCellsFor(this.activeBlock) : null;
+    if (!fresh) return;
+    const target = fresh.cells[fresh.index + 1];
+    const block = target ? this.editableInCell(target) : null;
+    if (block) placeCaretAtOffset(block, 0);
+  }
   /** Shift+Enter: insert an intra-paragraph line break at the caret. Delegates to the
    *  native `insertLineBreak` command, which inserts a <br> AND positions the caret
    *  after it correctly (handling the browser's bogus trailing-<br> rule) so typing
@@ -4096,21 +7224,21 @@ var DocxEditor = class _DocxEditor {
     while (p < minLen && old[p] === next[p]) p++;
     let s = 0;
     while (s < minLen - p && old[old.length - 1 - s] === next[next.length - 1 - s]) s++;
-    let start = p;
+    let start2 = p;
     let len = old.length - p - s;
     let middle = next.slice(p, next.length - s);
     if (len === 0) {
-      if (start > 0) {
-        start -= 1;
+      if (start2 > 0) {
+        start2 -= 1;
         len = 1;
-        middle = old[start] + middle;
+        middle = old[start2] + middle;
       } else {
         len = 1;
         middle = middle + old[0];
       }
     }
     return this.parseEdit(
-      this.exports.DocxSessionBridge.ReplaceTextAtSpan(this.handle, fullId, start, len, middle)
+      this.exports.DocxSessionBridge.ReplaceTextAtSpan(this.handle, fullId, start2, len, middle)
     );
   }
   /** Flush a block's current (uncommitted) text to the session; returns the live full id. */
@@ -4122,14 +7250,34 @@ var DocxEditor = class _DocxEditor {
   }
   /** Render a block by anchor and parse it into a detached element (null on error). */
   renderInto(anchorId) {
-    const html = this.exports.DocxSessionBridge.RenderBlockHtml(
+    const html = this.renderBlockHtml(anchorId);
+    if (html.charCodeAt(0) === 123) return null;
+    return new DOMParser().parseFromString(html, "text/html").body.firstElementChild;
+  }
+  get renderTrackedChanges() {
+    return this.options.trackedChanges === 1 /* RenderInline */;
+  }
+  renderBlockHtml(anchorId) {
+    const bridge = this.exports.DocxSessionBridge;
+    if (typeof bridge.RenderBlockHtmlForReview === "function") {
+      return bridge.RenderBlockHtmlForReview(
+        this.handle,
+        anchorId,
+        this.options.cssPrefix,
+        this.options.fabricateClasses,
+        this.renderTrackedChanges
+      );
+    }
+    return bridge.RenderBlockHtml(
       this.handle,
       anchorId,
       this.options.cssPrefix,
       this.options.fabricateClasses
     );
-    if (html.charCodeAt(0) === 123) return null;
-    return new DOMParser().parseFromString(html, "text/html").body.firstElementChild;
+  }
+  renderPlanJson() {
+    const bridge = this.exports.DocxSessionBridge;
+    return typeof bridge.ListRenderedBlocks === "function" ? bridge.ListRenderedBlocks(this.handle, this.renderTrackedChanges) : bridge.ListBlocks(this.handle);
   }
   /** Render two blocks in ONE batched bridge call when the bundle carries RenderBlocksHtml —
    *  the per-render shell/converter setup is paid once instead of twice, which matters on the
@@ -4140,14 +7288,20 @@ var DocxEditor = class _DocxEditor {
     const bridge = this.exports.DocxSessionBridge;
     if (typeof bridge.RenderBlocksHtml === "function") {
       try {
-        const map = JSON.parse(
-          bridge.RenderBlocksHtml(
-            this.handle,
-            JSON.stringify([a, b]),
-            this.options.cssPrefix,
-            this.options.fabricateClasses
-          )
+        const idsJson = JSON.stringify([a, b]);
+        const json = typeof bridge.RenderBlocksHtmlForReview === "function" ? bridge.RenderBlocksHtmlForReview(
+          this.handle,
+          idsJson,
+          this.options.cssPrefix,
+          this.options.fabricateClasses,
+          this.renderTrackedChanges
+        ) : bridge.RenderBlocksHtml(
+          this.handle,
+          idsJson,
+          this.options.cssPrefix,
+          this.options.fabricateClasses
         );
+        const map = JSON.parse(json);
         if (!map.error) {
           const parse = (h) => h ? new DOMParser().parseFromString(h, "text/html").body.firstElementChild : null;
           const fa = parse(map[a]);
@@ -4169,11 +7323,22 @@ var DocxEditor = class _DocxEditor {
   }
   parseEdit(json) {
     try {
-      return JSON.parse(json);
+      const result = JSON.parse(json);
+      if (result.success) this.invalidateBlockMoveTargets();
+      return result;
     } catch {
       return { success: false };
     }
   }
+  /**
+   * Drop the memoized `ValidMoveTargets` answers. Which blocks a block may move next to is a
+   * fact about the DOCUMENT, so it survives hovering but not editing — and the two places a
+   * document changes are `parseEdit` (every mutation that returns an `EditResult`) and
+   * undo/redo, which return a bare boolean and so cannot go through it.
+   */
+  invalidateBlockMoveTargets() {
+    this.blockMoveTargetCache.clear();
+  }
   // ─── M5: formatting commands (ribbon) ────────────────────────────────
   // ─── Multi-block selection helpers (format a whole stack of paragraphs at once) ──────
   /**
@@ -4190,9 +7355,9 @@ var DocxEditor = class _DocxEditor {
     const first = all.find((block) => block.getAttribute("data-anchor") === bookmark.startUnid);
     const last = all.find((block) => block.getAttribute("data-anchor") === bookmark.endUnid);
     if (!first || !last || first === last || all.indexOf(first) > all.indexOf(last)) return false;
-    const start = contentPositionIn(first, bookmark.startOffset);
+    const start2 = contentPositionIn(first, bookmark.startOffset);
     const end = contentPositionIn(last, bookmark.endOffset);
-    return setSelectionBetween(start, end);
+    return setSelectionBetween(start2, end);
   }
   /** Editable blocks the current selection covers, in document order. Uses Range.comparePoint
    *  (robust to a selection boundary that normalized onto a wrapper element rather than a block
@@ -4235,8 +7400,8 @@ var DocxEditor = class _DocxEditor {
     if (hasStart && hasEnd) return selectionSpanIn(block);
     const contentLen = blockContentText(block).length;
     if (hasStart) {
-      const start = contentOffsetOf(block, range.startContainer, range.startOffset);
-      return trimmedSpan(block, { start, length: Math.max(0, contentLen - start) });
+      const start2 = contentOffsetOf(block, range.startContainer, range.startOffset);
+      return trimmedSpan(block, { start: start2, length: Math.max(0, contentLen - start2) });
     }
     if (hasEnd) {
       const end = contentOffsetOf(block, range.endContainer, range.endOffset);
@@ -4727,12 +7892,16 @@ var DocxEditor = class _DocxEditor {
   /** Undo the last edit (incremental repaint; falls back to a full re-render). */
   undo() {
     if (this.closed) return;
-    if (this.exports.DocxSessionBridge.Undo(this.handle)) this.reconcile();
+    if (!this.exports.DocxSessionBridge.Undo(this.handle)) return;
+    this.invalidateBlockMoveTargets();
+    this.reconcile();
   }
   /** Redo the last undone edit (incremental repaint; falls back to a full re-render). */
   redo() {
     if (this.closed) return;
-    if (this.exports.DocxSessionBridge.Redo(this.handle)) this.reconcile();
+    if (!this.exports.DocxSessionBridge.Redo(this.handle)) return;
+    this.invalidateBlockMoveTargets();
+    this.reconcile();
   }
   // ─── Header/footer region commands (no-ops unless `headerFooter` is on) ───────────────
   /**
@@ -4831,6 +8000,17 @@ var DocxEditor = class _DocxEditor {
    */
   renderFullHtml() {
     const bridge = this.exports.DocxSessionBridge;
+    if (typeof bridge.RenderHtmlForReview === "function") {
+      const html = bridge.RenderHtmlForReview(
+        this.handle,
+        this.options.cssPrefix,
+        this.options.fabricateClasses,
+        this.options.paginated,
+        this.options.scale,
+        this.renderTrackedChanges
+      );
+      if (html.charCodeAt(0) !== 123) return html;
+    }
     if (typeof bridge.RenderHtml === "function") {
       const html = bridge.RenderHtml(
         this.handle,
@@ -4843,7 +8023,14 @@ var DocxEditor = class _DocxEditor {
     }
     const bytes = typeof bridge.SaveWithAnchorIds === "function" ? bridge.SaveWithAnchorIds(this.handle) : bridge.Save(this.handle);
     return this.exports.DocumentConverter.ConvertDocxToHtmlComplete(
-      ...completeArgs(bytes, this.options.cssPrefix, this.options.fabricateClasses, this.options.paginated, this.options.scale)
+      ...completeArgs(
+        bytes,
+        this.options.cssPrefix,
+        this.options.fabricateClasses,
+        this.options.paginated,
+        this.options.scale,
+        this.renderTrackedChanges
+      )
     );
   }
   /** Editable BODY blocks in document order (band blocks are enumerated by `ownerRoot`). */
@@ -4937,29 +8124,40 @@ var DocxEditor = class _DocxEditor {
   reconcileCore() {
     const bridge = this.exports.DocxSessionBridge;
     this.refreshAnchorMap();
-    const plan = JSON.parse(bridge.ListBlocks(this.handle));
+    const plan = JSON.parse(this.renderPlanJson());
     if (plan.error) return this.bail(`plan error: ${plan.error}`);
     const oldNodes = this.bodyUnitNodes();
     const oldTokens = oldNodes.map(_DocxEditor.domTokenOf);
     const oldKinds = oldNodes.map(_DocxEditor.domKindOf);
     const bodyDiff = diffUnits(oldTokens, plan.body);
-    if (needsRemount(bodyDiff, plan.body, oldKinds)) return this.bail("needsRemount (li change or churn)");
+    if (needsRemount(bodyDiff, plan.body, oldKinds)) {
+      return this.bail(
+        `needsRemount (li change or churn): +${bodyDiff.added.length} -${bodyDiff.removed.length} ~${bodyDiff.substituted.length} moved=${bodyDiff.moved.length} of ${plan.body.length}`
+      );
+    }
     const fnState = this.notesDiff("footnotes", plan.footnotes);
     const enState = this.notesDiff("endnotes", plan.endnotes);
     if (fnState === null || enState === null) return this.bail("notes container unstampable/missing");
-    const addedBodyIds = bodyDiff.added.map((j) => plan.body[j].id);
+    const movedBodyNew = new Set(bodyDiff.moved.map((m) => m.newIndex));
+    const addedBodyIds = bodyDiff.added.filter((j) => !movedBodyNew.has(j)).map((j) => plan.body[j].id);
     const addedNoteIds = fnState.diff.added.map((j) => plan.footnotes[j].id).concat(enState.diff.added.map((j) => plan.endnotes[j].id));
     const allIds = addedBodyIds.concat(addedNoteIds);
     let rendered = {};
     if (allIds.length > 0) {
-      rendered = JSON.parse(
-        bridge.RenderBlocksHtml(
-          this.handle,
-          JSON.stringify(allIds),
-          this.options.cssPrefix,
-          this.options.fabricateClasses
-        )
+      const idsJson = JSON.stringify(allIds);
+      const renderedJson = typeof bridge.RenderBlocksHtmlForReview === "function" ? bridge.RenderBlocksHtmlForReview(
+        this.handle,
+        idsJson,
+        this.options.cssPrefix,
+        this.options.fabricateClasses,
+        this.renderTrackedChanges
+      ) : bridge.RenderBlocksHtml(
+        this.handle,
+        idsJson,
+        this.options.cssPrefix,
+        this.options.fabricateClasses
       );
+      rendered = JSON.parse(renderedJson);
       if (rendered.error) return this.bail(`render error: ${rendered.error}`);
       for (const id of allIds) if (!rendered[id]) return this.bail(`unrenderable: ${id}`);
     }
@@ -4969,7 +8167,7 @@ var DocxEditor = class _DocxEditor {
       return el;
     };
     const freshBody = /* @__PURE__ */ new Map();
-    for (const j of bodyDiff.added) {
+    for (const j of bodyDiff.added.filter((j2) => !movedBodyNew.has(j2))) {
       const el = parse(rendered[plan.body[j].id]);
       if (!el) return this.bail(`unparseable render: ${plan.body[j].id}`);
       freshBody.set(j, el);
@@ -5019,13 +8217,6 @@ var DocxEditor = class _DocxEditor {
    *  bail-reason string (parent ambiguity, order violation, wrapper semantics) — the
    *  session is already correct, so bailing just means a full repaint. */
   applyBodyDiff(oldNodes, units, diff, fresh) {
-    let lastOld = -1;
-    for (let j = 0; j < units.length; j++) {
-      const oi = diff.keep.get(j);
-      if (oi === void 0) continue;
-      if (oi < lastOld) return "kept order violation";
-      lastOld = oi;
-    }
     const subOldByNew = new Map(diff.substituted.map((s) => [s.newIndex, s.oldIndex]));
     for (const [nj, oi] of subOldByNew) {
       const freshRoot = fresh.get(nj);
@@ -5041,13 +8232,18 @@ var DocxEditor = class _DocxEditor {
       }
       this.wireUnit(freshRoot, units[nj]);
     }
-    const pureAdded = diff.added.filter((j) => !subOldByNew.has(j));
+    const movedOldByNew = new Map(diff.moved.map((m) => [m.newIndex, m.oldIndex]));
+    const movedNew = new Set(diff.moved.map((m) => m.newIndex));
+    const movedOld = new Set(diff.moved.map((m) => m.oldIndex));
+    const pureAdded = diff.added.filter((j) => !subOldByNew.has(j) && !movedNew.has(j));
     const pureRemoved = diff.removed.filter(
-      (i) => !diff.substituted.some((s) => s.oldIndex === i)
+      (i) => !diff.substituted.some((s) => s.oldIndex === i) && !movedOld.has(i)
     );
     const nodeAt = (j) => {
       const oi = diff.keep.get(j);
       if (oi !== void 0) return oldNodes[oi];
+      const movedOi = movedOldByNew.get(j);
+      if (movedOi !== void 0) return oldNodes[movedOi];
       if (subOldByNew.has(j)) return fresh.get(j);
       const f = fresh.get(j);
       return f && f.isConnected ? f : null;
@@ -5057,11 +8253,7 @@ var DocxEditor = class _DocxEditor {
       let prev = null;
       for (let k = j - 1; k >= 0 && !prev; k--) prev = nodeAt(k);
       let next = null;
-      for (let k = j + 1; k < units.length && !next; k++) {
-        const oi = diff.keep.get(k);
-        if (oi !== void 0) next = oldNodes[oi];
-        else if (subOldByNew.has(k)) next = fresh.get(k);
-      }
+      for (let k = j + 1; k < units.length && !next; k++) next = nodeAt(k);
       const prevW = prev ? this.unitWrapperOf(prev) : null;
       const nextW = next ? this.unitWrapperOf(next) : null;
       if (prevW && nextW && prevW.parentElement !== nextW.parentElement)
@@ -5072,8 +8264,29 @@ var DocxEditor = class _DocxEditor {
       this.wireUnit(el, units[j]);
     }
     for (const i of pureRemoved) {
-      const wrapper = this.unitWrapperOf(oldNodes[i]);
-      wrapper.remove();
+      this.unitWrapperOf(oldNodes[i]).remove();
+    }
+    for (const { newIndex } of [...diff.moved].sort((a, b) => a.newIndex - b.newIndex)) {
+      const moving = nodeAt(newIndex);
+      if (!moving?.isConnected) return "move source is not connected";
+      const movingW = this.unitWrapperOf(moving);
+      let prevW = null;
+      for (let k = newIndex - 1; k >= 0 && !prevW; k--) {
+        const n = nodeAt(k);
+        if (n?.isConnected) prevW = this.unitWrapperOf(n);
+      }
+      let nextW = null;
+      for (let k = newIndex + 1; k < units.length && !nextW; k++) {
+        const n = nodeAt(k);
+        if (n?.isConnected) nextW = this.unitWrapperOf(n);
+      }
+      if (prevW && prevW !== movingW && prevW.parentElement === movingW.parentElement) {
+        prevW.after(movingW);
+      } else if (nextW && nextW !== movingW && nextW.parentElement === movingW.parentElement) {
+        nextW.before(movingW);
+      } else {
+        return "move neighbors in different parents";
+      }
     }
     return true;
   }
@@ -5197,7 +8410,7 @@ var DocxEditor = class _DocxEditor {
     const bridge = this.exports.DocxSessionBridge;
     if (typeof bridge.ListBlocks !== "function") return;
     try {
-      const plan = JSON.parse(bridge.ListBlocks(this.handle));
+      const plan = JSON.parse(this.renderPlanJson());
       if (plan.error) return;
       const nodes = this.bodyUnitNodes();
       if (nodes.length === plan.body.length) {
@@ -5226,6 +8439,7 @@ var DocxEditor = class _DocxEditor {
    * block's content-hashed unid changes across the save/reproject a remount performs.
    */
   remount(focusIndex = -1, caretAtEnd = false) {
+    this.teardownBlockDrag();
     this.refreshAnchorMap();
     const fullHtml = this.renderFullHtml();
     this.activeBlock = null;
@@ -5240,6 +8454,7 @@ var DocxEditor = class _DocxEditor {
       }
     }
     this.syncRegionToBody(this.activeBlock ?? void 0);
+    this.setupBlockDrag();
   }
 };
 
@@ -6448,8 +9663,12 @@ var RibbonSurface = class {
       editable: this.options.editable,
       scale: this.options.scale,
       onEdit: this.options.onEdit,
+      onMove: this.options.onMove,
       paginated,
-      headerFooter: this.headerFooter
+      headerFooter: this.headerFooter,
+      blockDrag: this.options.blockDrag ?? true,
+      trackedChanges: this.options.trackedChanges,
+      revisionAuthor: this.options.revisionAuthor
     });
     this.require("save").disabled = false;
     this.require("ribbon").setAttribute("aria-disabled", "false");
@@ -6537,8 +9756,8 @@ var RibbonSurface = class {
       this.keepSelection(tab);
       tab.addEventListener("click", () => this.selectTab(tab.dataset.tab ?? "home"));
     }
-    const delegate = (selector, label, fn) => {
-      for (const el of Array.from(ribbon.querySelectorAll(selector))) {
+    const delegate = (selector2, label, fn) => {
+      for (const el of Array.from(ribbon.querySelectorAll(selector2))) {
         this.keepSelection(el);
         el.addEventListener("click", () => this.run(label(el), () => fn(el)));
       }
@@ -7253,10 +10472,10 @@ async function getRevisions(document2, options) {
 function docxDiffSettingsJson(settings) {
   return settings ? JSON.stringify(settings) : "";
 }
-async function docxDiffCompare(left, right, settings) {
+async function docxDiffCompare(left2, right2, settings) {
   const exports = ensureInitialized();
-  const leftBytes = await toBytes(left);
-  const rightBytes = await toBytes(right);
+  const leftBytes = await toBytes(left2);
+  const rightBytes = await toBytes(right2);
   await yieldToMain();
   const result = exports.DocxDiffBridge.Compare(
     leftBytes,
@@ -7268,10 +10487,10 @@ async function docxDiffCompare(left, right, settings) {
   }
   return result;
 }
-async function docxDiffGetRevisions(left, right, settings) {
+async function docxDiffGetRevisions(left2, right2, settings) {
   const exports = ensureInitialized();
-  const leftBytes = await toBytes(left);
-  const rightBytes = await toBytes(right);
+  const leftBytes = await toBytes(left2);
+  const rightBytes = await toBytes(right2);
   await yieldToMain();
   const result = exports.DocxDiffBridge.GetRevisionsJson(
     leftBytes,
@@ -7299,10 +10518,10 @@ async function docxDiffGetRevisions(left, right, settings) {
     rightAnchor: r.rightAnchor ?? r.RightAnchor ?? void 0
   }));
 }
-async function docxDiffGetEditScript(left, right, settings) {
+async function docxDiffGetEditScript(left2, right2, settings) {
   const exports = ensureInitialized();
-  const leftBytes = await toBytes(left);
-  const rightBytes = await toBytes(right);
+  const leftBytes = await toBytes(left2);
+  const rightBytes = await toBytes(right2);
   await yieldToMain();
   const result = exports.DocxDiffBridge.GetEditScriptJson(
     leftBytes,
@@ -7930,8 +11149,8 @@ function createAnnotationFromSearch(id, labelId, documentText, searchText, occur
   if (occurrence > offsets.length) {
     return null;
   }
-  const { start, end } = offsets[occurrence - 1];
-  return createAnnotation(id, labelId, documentText, start, end);
+  const { start: start2, end } = offsets[occurrence - 1];
+  return createAnnotation(id, labelId, documentText, start2, end);
 }
 function findTextOccurrences(documentText, searchText, maxResults = 100) {
   if (!searchText) return [];
@@ -8173,7 +11392,7 @@ function createScopedMount(container) {
 }
 function splitSelectorList(selectorText) {
   const selectors = [];
-  let start = 0;
+  let start2 = 0;
   let parentheses = 0;
   let brackets = 0;
   let quote = "";
@@ -8201,15 +11420,15 @@ function splitSelectorList(selectorText) {
     else if (ch === "[") brackets++;
     else if (ch === "]") brackets--;
     else if (ch === "," && parentheses === 0 && brackets === 0) {
-      selectors.push(selectorText.slice(start, i).trim());
-      start = i + 1;
+      selectors.push(selectorText.slice(start2, i).trim());
+      start2 = i + 1;
     }
   }
-  selectors.push(selectorText.slice(start).trim());
+  selectors.push(selectorText.slice(start2).trim());
   return selectors.filter(Boolean);
 }
-function scopeSelector(selector, rootSelector) {
-  let remaining = selector.trim();
+function scopeSelector(selector2, rootSelector) {
+  let remaining = selector2.trim();
   let consumedRoot = false;
   let separated = false;
   for (; ; ) {
@@ -8240,7 +11459,7 @@ function scopeCssRules(container, rootSelector) {
     }
     if (rule.type === CSSRule.STYLE_RULE) {
       const styleRule = rule;
-      styleRule.selectorText = splitSelectorList(styleRule.selectorText).map((selector) => scopeSelector(selector, rootSelector)).join(", ");
+      styleRule.selectorText = splitSelectorList(styleRule.selectorText).map((selector2) => scopeSelector(selector2, rootSelector)).join(", ");
       continue;
     }
     const grouping = rule;
@@ -8280,6 +11499,10 @@ function createScopedEditorExports(exports, rootSelector) {
   if (renderHtml) {
     bridge.RenderHtml = (...args) => scopeDocumentStyles(renderHtml(...args), rootSelector);
   }
+  const renderHtmlForReview = bridge.RenderHtmlForReview;
+  if (renderHtmlForReview) {
+    bridge.RenderHtmlForReview = (...args) => scopeDocumentStyles(renderHtmlForReview(...args), rootSelector);
+  }
   return {
     DocxSessionBridge: bridge,
     DocumentConverter: {
@@ -8308,7 +11531,7 @@ async function createViewer(container, source, options = {}) {
   const el = resolveContainer2(container);
   const { wasmBasePath: wasmBasePath2, ...conversion } = options;
   await ensureWasm(wasmBasePath2);
-  const mount = createScopedMount(el);
+  const mount2 = createScopedMount(el);
   let lastHtml = "";
   const render = async (src, opts) => {
     const bytes = await toDocumentBytes(src);
@@ -8321,13 +11544,13 @@ async function createViewer(container, source, options = {}) {
     parsed.querySelectorAll("style").forEach((sourceStyle) => {
       const style = document.createElement("style");
       style.textContent = sourceStyle.textContent;
-      scopeStyleElement(style, mount.selector);
+      scopeStyleElement(style, mount2.selector);
       fragment.appendChild(style);
     });
     const body = document.createElement("template");
     body.innerHTML = parsed.body.innerHTML;
     fragment.appendChild(body.content);
-    mount.root.replaceChildren(fragment);
+    mount2.root.replaceChildren(fragment);
   };
   await render(source, conversion);
   return {
@@ -8345,13 +11568,13 @@ async function createEditor(container, source, options = {}) {
   const el = resolveContainer2(container);
   const { wasmBasePath: wasmBasePath2, ...editorOptions } = options;
   await ensureWasm(wasmBasePath2);
-  const mount = createScopedMount(el);
+  const mount2 = createScopedMount(el);
   const exports = createScopedEditorExports(
     getWasmExports(),
-    mount.selector
+    mount2.selector
   );
   try {
-    return source == null ? DocxEditor.openBlank(mount.root, exports, editorOptions) : DocxEditor.open(mount.root, await toDocumentBytes(source), exports, editorOptions);
+    return source == null ? DocxEditor.openBlank(mount2.root, exports, editorOptions) : DocxEditor.open(mount2.root, await toDocumentBytes(source), exports, editorOptions);
   } catch (error) {
     el.replaceChildren();
     throw error;
@@ -8369,10 +11592,10 @@ function nameFromSource(source) {
 async function createRibbonEditor(container, source, options = {}) {
   const el = resolveContainer2(container);
   const { wasmBasePath: wasmBasePath2, ...ribbonOptions } = options;
-  const mount = createScopedMount(el);
-  mount.root.style.height = "100%";
-  mount.root.style.minHeight = "0";
-  const ribbon = mountRibbon(mount.root, {
+  const mount2 = createScopedMount(el);
+  mount2.root.style.height = "100%";
+  mount2.root.style.minHeight = "0";
+  const ribbon = mountRibbon(mount2.root, {
     documentName: ribbonOptions.documentName ?? nameFromSource(source),
     ...ribbonOptions,
     // Exports arrive after the runtime boots; the loader covers that gap.
@@ -8384,7 +11607,7 @@ async function createRibbonEditor(container, source, options = {}) {
     ribbon.setExports(
       createScopedEditorExports(
         getWasmExports(),
-        `${mount.selector} [data-dxr-surface]`
+        `${mount2.selector} [data-dxr-surface]`
       )
     );
     ribbon.loader.stage(1);