docxodus 9.2.0 → 9.4.0

package/dist/embed.iife.js

@@ -1,9 +1,18 @@
 "use strict";
 var Docxodus = (() => {
+  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 __export = (target, all) => {
     for (var name in all)
       __defProp(target, name, { get: all[name], enumerable: true });
@@ -16,8 +25,101 @@ var Docxodus = (() => {
     }
     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
+  ));
   var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), 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/embed.ts
   var embed_exports = {};
   __export(embed_exports, {
@@ -433,6 +535,12 @@ var Docxodus = (() => {
     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
@@ -493,7 +601,9 @@ var Docxodus = (() => {
      * 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));
@@ -507,6 +617,28 @@ var Docxodus = (() => {
     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` +
@@ -1409,9 +1541,9 @@ var Docxodus = (() => {
       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
         });
       }
@@ -1636,16 +1768,16 @@ var Docxodus = (() => {
         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) {
@@ -1653,11 +1785,11 @@ var Docxodus = (() => {
           }
           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;
@@ -2972,9 +3104,9 @@ var Docxodus = (() => {
       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) => {
@@ -3025,8 +3157,8 @@ var Docxodus = (() => {
       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);
@@ -3074,65 +3206,2466 @@ var Docxodus = (() => {
         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 : "");
@@ -3172,15 +5705,32 @@ var Docxodus = (() => {
       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) {
@@ -3211,7 +5761,7 @@ var Docxodus = (() => {
         }
       }
     }
-    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;
@@ -3228,6 +5778,46 @@ var Docxodus = (() => {
 
   // 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);
@@ -3375,9 +5965,9 @@ var Docxodus = (() => {
   }
   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;
@@ -3420,9 +6010,9 @@ var Docxodus = (() => {
       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);
@@ -3470,17 +6060,17 @@ var Docxodus = (() => {
     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) => {
@@ -3489,8 +6079,8 @@ var Docxodus = (() => {
           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) {
@@ -3541,7 +6131,7 @@ var Docxodus = (() => {
         return false;
     }
   }
-  function completeArgs(bytes, cssPrefix, fabricate, paginated, scale) {
+  function completeArgs(bytes, cssPrefix, fabricate, paginated, scale, renderTrackedChanges) {
     return [
       bytes,
       "Document",
@@ -3565,7 +6155,7 @@ var Docxodus = (() => {
       true,
       /* renderHeadersAndFooters */
       paginated,
-      false,
+      renderTrackedChanges,
       true,
       true,
       false,
@@ -3588,6 +6178,27 @@ var Docxodus = (() => {
        * 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
@@ -3744,8 +6355,8 @@ var Docxodus = (() => {
      *  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;
     }
     /**
@@ -3786,18 +6397,34 @@ var Docxodus = (() => {
         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;
     }
     /**
@@ -3824,6 +6451,7 @@ var Docxodus = (() => {
         document.removeEventListener("mouseup", this.onMouseUp, true);
       }
       this.clearDragSelection();
+      this.teardownBlockDrag();
       this.exports.DocxSessionBridge.CloseSession(this.handle);
     }
     /**
@@ -3851,6 +6479,457 @@ var Docxodus = (() => {
     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");
@@ -3972,6 +7051,10 @@ var Docxodus = (() => {
     }
     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");
@@ -4033,12 +7116,7 @@ var Docxodus = (() => {
         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);
@@ -4079,9 +7157,10 @@ var Docxodus = (() => {
         }
       }
       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)) {
@@ -4110,6 +7189,42 @@ var Docxodus = (() => {
         }
       }
     }
+    /** 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
@@ -4219,21 +7334,21 @@ var Docxodus = (() => {
       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. */
@@ -4245,14 +7360,34 @@ var Docxodus = (() => {
     }
     /** 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
@@ -4263,14 +7398,20 @@ var Docxodus = (() => {
       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]);
@@ -4292,11 +7433,22 @@ var Docxodus = (() => {
     }
     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) ──────
     /**
@@ -4313,9 +7465,9 @@ var Docxodus = (() => {
       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
@@ -4358,8 +7510,8 @@ var Docxodus = (() => {
       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);
@@ -4850,12 +8002,16 @@ var Docxodus = (() => {
     /** 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) ───────────────
     /**
@@ -4954,6 +8110,17 @@ var Docxodus = (() => {
      */
     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,
@@ -4966,7 +8133,14 @@ var Docxodus = (() => {
       }
       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`). */
@@ -5060,29 +8234,40 @@ var Docxodus = (() => {
     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}`);
       }
@@ -5092,7 +8277,7 @@ var Docxodus = (() => {
         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);
@@ -5142,13 +8327,6 @@ var Docxodus = (() => {
      *  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);
@@ -5164,13 +8342,18 @@ var Docxodus = (() => {
         }
         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;
@@ -5180,11 +8363,7 @@ var Docxodus = (() => {
         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)
@@ -5195,8 +8374,29 @@ var Docxodus = (() => {
         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;
     }
@@ -5320,7 +8520,7 @@ var Docxodus = (() => {
       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) {
@@ -5349,6 +8549,7 @@ var Docxodus = (() => {
      * 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;
@@ -5363,6 +8564,7 @@ var Docxodus = (() => {
         }
       }
       this.syncRegionToBody(this.activeBlock ?? void 0);
+      this.setupBlockDrag();
     }
   };
 
@@ -6571,8 +9773,12 @@ var Docxodus = (() => {
         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");
@@ -6660,8 +9866,8 @@ var Docxodus = (() => {
         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)));
         }
@@ -7377,10 +10583,10 @@ var Docxodus = (() => {
   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,
@@ -7392,10 +10598,10 @@ var Docxodus = (() => {
     }
     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,
@@ -7423,10 +10629,10 @@ var Docxodus = (() => {
       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,
@@ -8054,8 +11260,8 @@ var Docxodus = (() => {
     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 [];
@@ -8298,7 +11504,7 @@ var Docxodus = (() => {
   }
   function splitSelectorList(selectorText) {
     const selectors = [];
-    let start = 0;
+    let start2 = 0;
     let parentheses = 0;
     let brackets = 0;
     let quote = "";
@@ -8326,15 +11532,15 @@ var Docxodus = (() => {
       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 (; ; ) {
@@ -8365,7 +11571,7 @@ var Docxodus = (() => {
       }
       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;
@@ -8405,6 +11611,10 @@ ${parsed.documentElement.outerHTML}`;
     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: {
@@ -8433,7 +11643,7 @@ ${parsed.documentElement.outerHTML}`;
     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);
@@ -8446,13 +11656,13 @@ ${parsed.documentElement.outerHTML}`;
       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 {
@@ -8470,13 +11680,13 @@ ${parsed.documentElement.outerHTML}`;
     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;
@@ -8494,10 +11704,10 @@ ${parsed.documentElement.outerHTML}`;
   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.
@@ -8509,7 +11719,7 @@ ${parsed.documentElement.outerHTML}`;
       ribbon.setExports(
         createScopedEditorExports(
           getWasmExports(),
-          `${mount.selector} [data-dxr-surface]`
+          `${mount2.selector} [data-dxr-surface]`
         )
       );
       ribbon.loader.stage(1);