@harbour-enterprises/superdoc 1.5.0-next.7 → 1.5.0-next.9

package/dist/chunks/{index-LpMObyDy.cjs → index-3B3UnhZ-.cjs}

@@ -1,7 +1,7 @@
 "use strict";
 const jszip = require("./jszip-C8_CqJxM.cjs");
 const helpers$1 = require("./helpers-nOdwpmwb.cjs");
-const superEditor_converter = require("./SuperConverter-CIjArITT.cjs");
+const superEditor_converter = require("./SuperConverter-Ck9J4dUw.cjs");
 const vue = require("./vue-De9wkgLl.cjs");
 require("./jszip.min-BPh2MMAa.cjs");
 const eventemitter3 = require("./eventemitter3-BQuRcMPI.cjs");
@@ -15524,7 +15524,7 @@ const canUseDOM = () => {
     return false;
   }
 };
-const summaryVersion = "1.5.0-next.7";
+const summaryVersion = "1.5.0-next.9";
 const nodeKeys = ["group", "content", "marks", "inline", "atom", "defining", "code", "tableRole", "summary"];
 const markKeys = ["group", "inclusive", "excludes", "spanning", "code"];
 function mapAttributes(attrs) {
@@ -18181,7 +18181,7 @@ class Editor extends EventEmitter {
    * Process collaboration migrations
    */
   processCollaborationMigrations() {
-    console.debug("[checkVersionMigrations] Current editor version", "1.5.0-next.7");
+    console.debug("[checkVersionMigrations] Current editor version", "1.5.0-next.9");
     if (!this.options.ydoc) return;
     const metaMap = this.options.ydoc.getMap("meta");
     let docVersion = metaMap.get("version");
@@ -23469,7 +23469,8 @@ const lineStyles = (lineHeight2) => ({
   // The primary fix uses accurate font metrics from Canvas API, but this
   // provides defense-in-depth against any remaining sub-pixel rendering
   // differences between measurement and display.
-  overflow: "visible"
+  overflow: "visible",
+  zIndex: "10"
 });
 const PRINT_STYLES = `
 @media print {
@@ -23775,6 +23776,7 @@ const SDT_CONTAINER_STYLES = `
   border: 1px solid #629be7;
   position: relative;
   display: inline;
+  z-index: 10;
 }
 
 /* Hover effect for inline structured content */
@@ -28962,11 +28964,6 @@ class DomPainter {
       } else {
         delete el.dataset.pmEnd;
       }
-      if (fragment.pmStart != null && fragment.pmEnd != null) {
-        el.title = `PM ${fragment.pmStart}–${fragment.pmEnd}`;
-      } else {
-        el.removeAttribute("title");
-      }
       if (fragment.continuesFromPrev) {
         el.dataset.continuesFromPrev = "true";
       } else {
@@ -49108,8 +49105,6 @@ class EditorOverlayManager {
   #activeRegion = null;
   /** Full-width border line element (MS Word style) */
   #borderLine = null;
-  /** Dimming overlay element (for dimming body content during editing) */
-  #dimmingOverlay = null;
   /**
    * Creates a new EditorOverlayManager instance.
    *
@@ -49403,17 +49398,6 @@ class EditorOverlayManager {
       }
     }
   }
-  /**
-   * Hides and removes the dimming overlay.
-   * @internal Reserved for future implementation of body dimming during header/footer editing.
-   */
-  // eslint-disable-next-line no-unused-private-class-members
-  #hideDimmingOverlay() {
-    if (this.#dimmingOverlay) {
-      this.#dimmingOverlay.remove();
-      this.#dimmingOverlay = null;
-    }
-  }
   /**
    * Shows a full-width border line at the bottom of the header or top of the footer.
    * This creates the MS Word style visual indicator spanning edge-to-edge of the page.
@@ -51586,6 +51570,7 @@ class PresentationEditor extends EventEmitter {
   #viewportHost;
   #painterHost;
   #selectionOverlay;
+  #permissionOverlay = null;
   #hiddenHost;
   #layoutOptions;
   #layoutState = { blocks: [], measures: [], layout: null, bookmarks: /* @__PURE__ */ new Map() };
@@ -51745,6 +51730,16 @@ class PresentationEditor extends EventEmitter {
     });
     this.#domIndexObserverManager.setup();
     this.#selectionSync.on("render", () => this.#updateSelection());
+    this.#selectionSync.on("render", () => this.#updatePermissionOverlay());
+    this.#permissionOverlay = doc2.createElement("div");
+    this.#permissionOverlay.className = "presentation-editor__permission-overlay";
+    Object.assign(this.#permissionOverlay.style, {
+      position: "absolute",
+      inset: "0",
+      pointerEvents: "none",
+      zIndex: "5"
+    });
+    this.#viewportHost.appendChild(this.#permissionOverlay);
     this.#selectionOverlay = doc2.createElement("div");
     this.#selectionOverlay.className = "presentation-editor__selection-overlay";
     this.#selectionOverlay.id = `presentation-overlay-${options.documentId || "default"}`;
@@ -51830,7 +51825,7 @@ class PresentationEditor extends EventEmitter {
     const normalizedEditorProps = {
       ...editorOptions.editorProps ?? {},
       editable: () => {
-        return this.#documentMode !== "viewing";
+        return !this.#isViewLocked();
       }
     };
     try {
@@ -52272,6 +52267,7 @@ class PresentationEditor extends EventEmitter {
       this.#pendingDocChange = true;
       this.#scheduleRerender();
     }
+    this.#updatePermissionOverlay();
   }
   #syncDocumentModeClass() {
     if (!this.#visibleHost) return;
@@ -53661,7 +53657,7 @@ class PresentationEditor extends EventEmitter {
       win,
       this.#visibleHost,
       () => this.#getActiveDomTarget(),
-      () => this.#documentMode !== "viewing"
+      () => !this.#isViewLocked()
     );
     this.#inputBridge.bind();
   }
@@ -54586,7 +54582,7 @@ class PresentationEditor extends EventEmitter {
       this.#dragUsedPageNotMountedFallback = false;
       return;
     }
-    if (this.#session.mode !== "body" || this.#documentMode === "viewing") {
+    if (this.#session.mode !== "body" || this.#isViewLocked()) {
       this.#dragLastPointer = null;
       this.#dragLastRawHit = null;
       this.#dragUsedPageNotMountedFallback = false;
@@ -54936,6 +54932,7 @@ class PresentationEditor extends EventEmitter {
       this.#epochMapper.onLayoutComplete(layoutEpoch);
       this.#selectionSync.onLayoutComplete(layoutEpoch);
       layoutCompleted = true;
+      this.#updatePermissionOverlay();
       this.#layoutError = null;
       this.#layoutErrorState = "healthy";
       this.#dismissErrorBanner();
@@ -55024,7 +55021,7 @@ class PresentationEditor extends EventEmitter {
     if (!this.#localSelectionLayer) {
       return;
     }
-    if (this.#documentMode === "viewing") {
+    if (this.#isViewLocked()) {
       try {
         this.#localSelectionLayer.innerHTML = "";
       } catch (error) {
@@ -55106,6 +55103,76 @@ class PresentationEditor extends EventEmitter {
       }
     }
   }
+  /**
+   * Updates the permission overlay (w:permStart/w:permEnd) to match the current editor permission ranges.
+   *
+   * This method is called after layout completes to ensure permission overlay
+   * is based on stable permission ranges data.
+   */
+  #updatePermissionOverlay() {
+    const overlay2 = this.#permissionOverlay;
+    if (!overlay2) {
+      return;
+    }
+    if (this.#session.mode !== "body") {
+      overlay2.innerHTML = "";
+      return;
+    }
+    const permissionStorage = this.#editor?.storage?.permissionRanges;
+    const ranges = permissionStorage?.ranges ?? [];
+    const shouldRender = ranges.length > 0;
+    if (!shouldRender) {
+      overlay2.innerHTML = "";
+      return;
+    }
+    const layout = this.#layoutState.layout;
+    if (!layout) {
+      overlay2.innerHTML = "";
+      return;
+    }
+    const docEpoch = this.#epochMapper.getCurrentEpoch();
+    if (this.#layoutEpoch < docEpoch) {
+      return;
+    }
+    const pageHeight = this.#getBodyPageHeight();
+    const pageGap = layout.pageGap ?? this.#getEffectivePageGap();
+    const fragment = overlay2.ownerDocument?.createDocumentFragment();
+    if (!fragment) {
+      overlay2.innerHTML = "";
+      return;
+    }
+    ranges.forEach(({ from: from3, to }) => {
+      const rects = this.#computeSelectionRectsFromDom(from3, to);
+      if (!rects?.length) {
+        return;
+      }
+      rects.forEach((rect) => {
+        const pageLocalY = rect.y - rect.pageIndex * (pageHeight + pageGap);
+        const coords = this.#convertPageLocalToOverlayCoords(rect.pageIndex, rect.x, pageLocalY);
+        if (!coords) {
+          return;
+        }
+        const highlight = overlay2.ownerDocument?.createElement("div");
+        if (!highlight) {
+          return;
+        }
+        highlight.className = "presentation-editor__permission-highlight";
+        Object.assign(highlight.style, {
+          position: "absolute",
+          left: `${coords.x}px`,
+          top: `${coords.y}px`,
+          width: `${Math.max(1, rect.width)}px`,
+          height: `${Math.max(1, rect.height)}px`,
+          borderRadius: "2px",
+          pointerEvents: "none",
+          zIndex: 1
+        });
+        fragment.appendChild(highlight);
+      });
+    });
+    overlay2.innerHTML = "";
+    overlay2.appendChild(fragment);
+  }
   #resolveLayoutOptions(blocks, sectionMetadata) {
     const defaults = this.#computeDefaultLayoutDefaults();
     const firstSection = blocks?.find(
@@ -55851,7 +55918,7 @@ class PresentationEditor extends EventEmitter {
     this.#announce(announcement.message);
   }
   #validateHeaderFooterEditPermission() {
-    if (this.#documentMode === "viewing") {
+    if (this.#isViewLocked()) {
       return { allowed: false, reason: "documentMode" };
     }
     if (!this.#editor.isEditable) {
@@ -56714,6 +56781,17 @@ class PresentationEditor extends EventEmitter {
     this.#errorBanner = null;
     this.#errorBannerMessage = null;
   }
+  /**
+   * Determines whether the current viewing mode should block edits.
+   * When documentMode is viewing but the active editor has been toggled
+   * back to editable (e.g. permission ranges), we treat the view as editable.
+   */
+  #isViewLocked() {
+    if (this.#documentMode !== "viewing") return false;
+    const hasPermissionOverride = !!this.#editor?.storage?.permissionRanges?.hasAllowedRanges;
+    if (hasPermissionOverride) return false;
+    return this.#documentMode === "viewing";
+  }
   /**
    * Applies vertical alignment and font scaling to layout DOM elements for subscript/superscript rendering.
    *
@@ -58593,6 +58671,11 @@ const structuredContentHelpers = /* @__PURE__ */ Object.freeze(/* @__PURE__ */ O
   parseTagObject
 }, Symbol.toStringTag, { value: "Module" }));
 const STRUCTURED_CONTENT_NAMES = ["structuredContent", "structuredContentBlock"];
+function isValidIntegerId(id) {
+  if (id === null || id === void 0) return true;
+  const str = String(id);
+  return /^-?\d+$/.test(str);
+}
 const findFirstTextNode = (node) => {
   let firstTextNode = null;
   node.descendants((child) => {
@@ -58634,6 +58717,9 @@ const StructuredContentCommands = Extension.create({
        * });
        */
       insertStructuredContentInline: (options = {}) => ({ editor, dispatch, state, tr }) => {
+        if (options.attrs?.id !== void 0 && !isValidIntegerId(options.attrs.id)) {
+          throw new Error("Invalid structured content id - must be an integer, got: " + options.attrs.id);
+        }
         const { schema } = editor;
         let { from: from3, to } = state.selection;
         if (dispatch) {
@@ -58696,6 +58782,9 @@ const StructuredContentCommands = Extension.create({
        * });
        */
       insertStructuredContentBlock: (options = {}) => ({ editor, dispatch, state, tr }) => {
+        if (options.attrs?.id !== void 0 && !isValidIntegerId(options.attrs.id)) {
+          throw new Error("Invalid structured content id - must be an integer, got: " + options.attrs.id);
+        }
         const { schema } = editor;
         let { from: from3, to } = state.selection;
         if (dispatch) {
@@ -58753,6 +58842,9 @@ const StructuredContentCommands = Extension.create({
        * });
        */
       updateStructuredContentById: (id, options = {}) => ({ editor, dispatch, state, tr }) => {
+        if (options.attrs?.id !== void 0 && !isValidIntegerId(options.attrs.id)) {
+          throw new Error("Invalid structured content id - must be an integer, got: " + options.attrs.id);
+        }
         const structuredContentTags = getStructuredContentTagsById(id, state);
         if (!structuredContentTags.length) {
           return true;
@@ -58880,6 +58972,9 @@ const StructuredContentCommands = Extension.create({
        * });
        */
       updateStructuredContentByGroup: (group, options = {}) => ({ editor, dispatch, state, tr }) => {
+        if (options.attrs?.id !== void 0 && !isValidIntegerId(options.attrs.id)) {
+          throw new Error("Invalid structured content id - must be an integer, got: " + options.attrs.id);
+        }
         const structuredContentTags = getStructuredContentByGroup(group, state);
         if (!structuredContentTags.length) {
           return true;
@@ -59557,7 +59652,7 @@ const mergeRanges$2 = (ranges, docSize) => {
   }
   return merged;
 };
-const collectChangedRanges = (trs, docSize) => {
+const collectChangedRanges$1 = (trs, docSize) => {
   const ranges = [];
   trs.forEach((tr) => {
     if (!tr.docChanged) return;
@@ -59760,7 +59855,7 @@ const wrapTextInRunsPlugin = (editor) => {
       const runType = newState.schema.nodes.run;
       if (!runType) return null;
       pendingRanges = mapRangesThroughTransactions(pendingRanges, transactions, docSize);
-      const changedRanges = collectChangedRanges(transactions, docSize);
+      const changedRanges = collectChangedRanges$1(transactions, docSize);
       pendingRanges = mergeRanges$2([...pendingRanges, ...changedRanges], docSize);
       if (view?.composing) {
         return null;
@@ -74635,6 +74730,283 @@ const NodeResizer = Extension.create({
     return [nodeResizer(["image"], this.editor)];
   }
 });
+const PERMISSION_PLUGIN_KEY = new superEditor_converter.PluginKey("permissionRanges");
+const EVERYONE_GROUP = "everyone";
+const EMPTY_IDENTIFIER_SET = Object.freeze(/* @__PURE__ */ new Set());
+const normalizeIdentifier = (value) => typeof value === "string" ? value.trim().toLowerCase() : "";
+const buildAllowedIdentifierSet = (editor) => {
+  const email = normalizeIdentifier(editor?.options?.user?.email);
+  if (!email) {
+    return EMPTY_IDENTIFIER_SET;
+  }
+  const [localPart, domain] = email.split("@");
+  if (!localPart || !domain) {
+    return EMPTY_IDENTIFIER_SET;
+  }
+  const formatted = `${domain}\\${localPart}`;
+  return formatted ? /* @__PURE__ */ new Set([formatted]) : EMPTY_IDENTIFIER_SET;
+};
+const isEveryoneGroup = (value) => normalizeIdentifier(value) === EVERYONE_GROUP;
+const isRangeAllowedForUser = (attrs, allowedIdentifiers) => {
+  if (!attrs) return false;
+  if (isEveryoneGroup(attrs.edGrp)) {
+    return true;
+  }
+  if (!allowedIdentifiers?.size) {
+    return false;
+  }
+  const normalizedEd = normalizeIdentifier(attrs.ed);
+  return normalizedEd && allowedIdentifiers.has(normalizedEd);
+};
+const getPermissionNodeId = (node, pos, fallbackPrefix) => String(node.attrs?.id ?? `${fallbackPrefix}-${pos}`);
+const buildPermissionState = (doc2, allowedIdentifiers = EMPTY_IDENTIFIER_SET) => {
+  const ranges = [];
+  const openRanges = /* @__PURE__ */ new Map();
+  doc2.descendants((node, pos) => {
+    if (node.type?.name === "permStart") {
+      const id = getPermissionNodeId(node, pos, "permStart");
+      openRanges.set(id, {
+        from: pos + node.nodeSize,
+        attrs: node.attrs ?? {}
+      });
+      return false;
+    }
+    if (node.type?.name === "permEnd") {
+      const id = getPermissionNodeId(node, pos, "permEnd");
+      const start2 = openRanges.get(id);
+      if (start2 && isRangeAllowedForUser(start2.attrs, allowedIdentifiers)) {
+        const to = Math.max(pos, start2.from);
+        if (to > start2.from) {
+          ranges.push({
+            id,
+            from: start2.from,
+            to
+          });
+        }
+      }
+      if (start2) {
+        openRanges.delete(id);
+      }
+      return false;
+    }
+  });
+  return {
+    ranges,
+    hasAllowedRanges: ranges.length > 0
+  };
+};
+const collectPermissionTags = (doc2, permStartType, permEndType) => {
+  const tags = /* @__PURE__ */ new Map();
+  doc2.descendants((node, pos) => {
+    if (node.type !== permStartType && node.type !== permEndType) {
+      return;
+    }
+    const id = node.attrs?.id;
+    if (!id) {
+      return;
+    }
+    const entry = tags.get(id) ?? {};
+    if (node.type === permStartType) {
+      entry.start = { pos, attrs: node.attrs ?? {} };
+    } else if (node.type === permEndType) {
+      entry.end = { pos, attrs: node.attrs ?? {} };
+    }
+    tags.set(id, entry);
+  });
+  return tags;
+};
+const clampPosition = (pos, size2) => {
+  if (Number.isNaN(pos) || !Number.isFinite(pos)) {
+    return 0;
+  }
+  return Math.max(0, Math.min(pos, size2));
+};
+const trimPermissionTagsFromRange = (doc2, range, permStartType, permEndType) => {
+  let from3 = range.from;
+  let to = range.to;
+  while (from3 < to) {
+    const node = doc2.nodeAt(from3);
+    if (!node || node.type !== permStartType && node.type !== permEndType) {
+      break;
+    }
+    from3 += node.nodeSize;
+  }
+  while (to > from3) {
+    const $pos = doc2.resolve(to);
+    const nodeBefore = $pos.nodeBefore;
+    if (!nodeBefore || nodeBefore.type !== permStartType && nodeBefore.type !== permEndType) {
+      break;
+    }
+    to -= nodeBefore.nodeSize;
+  }
+  return { from: from3, to };
+};
+const collectChangedRanges = (tr) => {
+  const ranges = [];
+  tr.mapping.maps.forEach((map3) => {
+    map3.forEach((oldStart, oldEnd) => {
+      const from3 = Math.min(oldStart, oldEnd);
+      const to = Math.max(oldStart, oldEnd);
+      ranges.push({ from: from3, to });
+    });
+  });
+  return ranges;
+};
+const isRangeAllowed = (range, allowedRanges) => {
+  if (!allowedRanges?.length) return false;
+  return allowedRanges.some((allowed) => range.from >= allowed.from && range.to <= allowed.to);
+};
+const PermissionRanges = Extension.create({
+  name: "permissionRanges",
+  addStorage() {
+    return {
+      ranges: [],
+      hasAllowedRanges: false
+    };
+  },
+  addPmPlugins() {
+    const editor = this.editor;
+    const storage = this.storage;
+    let originalSetDocumentMode = null;
+    const getAllowedIdentifiers = () => buildAllowedIdentifierSet(editor);
+    const toggleEditableIfAllowed = (hasAllowedRanges) => {
+      if (!editor || editor.isDestroyed) return;
+      if (editor.options.documentMode !== "viewing") return;
+      if (hasAllowedRanges && !editor.isEditable) {
+        editor.setEditable(true, false);
+      } else if (!hasAllowedRanges && editor.isEditable) {
+        editor.setEditable(false, false);
+      }
+    };
+    const updateEditableState = (hasAllowedRanges) => {
+      const nextValue = Boolean(hasAllowedRanges);
+      const previousValue = storage.hasAllowedRanges;
+      storage.hasAllowedRanges = nextValue;
+      if (previousValue === nextValue) {
+        return;
+      }
+      toggleEditableIfAllowed(nextValue);
+    };
+    if (editor && typeof editor.setDocumentMode === "function") {
+      originalSetDocumentMode = editor.setDocumentMode.bind(editor);
+      editor.setDocumentMode = (mode, caller) => {
+        originalSetDocumentMode(mode, caller);
+        const state = editor.state;
+        if (!state) return;
+        const pluginState = PERMISSION_PLUGIN_KEY.getState(state);
+        if (pluginState) {
+          toggleEditableIfAllowed(pluginState.hasAllowedRanges);
+        }
+      };
+    }
+    return [
+      new superEditor_converter.Plugin({
+        key: PERMISSION_PLUGIN_KEY,
+        state: {
+          init(_2, state) {
+            const permissionState = buildPermissionState(state.doc, getAllowedIdentifiers());
+            storage.ranges = permissionState.ranges;
+            updateEditableState(permissionState.hasAllowedRanges);
+            return permissionState;
+          },
+          apply(tr, value, _oldState, newState) {
+            let permissionState = value;
+            if (tr.docChanged) {
+              permissionState = buildPermissionState(newState.doc, getAllowedIdentifiers());
+              storage.ranges = permissionState.ranges;
+              updateEditableState(permissionState.hasAllowedRanges);
+            }
+            return permissionState;
+          }
+        },
+        view() {
+          return {
+            destroy() {
+              if (editor && originalSetDocumentMode) {
+                editor.setDocumentMode = originalSetDocumentMode;
+              }
+            }
+          };
+        },
+        // Appends transactions to the document to ensure permission ranges are updated.
+        appendTransaction(transactions, oldState, newState) {
+          if (!transactions.some((tr2) => tr2.docChanged)) return null;
+          const permStartType = newState.schema.nodes["permStart"];
+          const permEndType = newState.schema.nodes["permEnd"];
+          if (!permStartType || !permEndType) return null;
+          const oldTags = collectPermissionTags(oldState.doc, permStartType, permEndType);
+          if (!oldTags.size) {
+            return null;
+          }
+          const newTags = collectPermissionTags(newState.doc, permStartType, permEndType);
+          const mappingToNew = new superEditor_converter.Mapping();
+          transactions.forEach((tr2) => {
+            mappingToNew.appendMapping(tr2.mapping);
+          });
+          const pendingInsertions = [];
+          oldTags.forEach((tag, id) => {
+            const current = newTags.get(id);
+            if (tag.start && !current?.start) {
+              const mapped = mappingToNew.mapResult(tag.start.pos, -1);
+              pendingInsertions.push({
+                pos: mapped.pos,
+                nodeType: permStartType,
+                attrs: tag.start.attrs,
+                priority: 0
+              });
+            }
+            if (tag.end && !current?.end) {
+              const mapped = mappingToNew.mapResult(tag.end.pos, 1);
+              pendingInsertions.push({
+                pos: mapped.pos,
+                nodeType: permEndType,
+                attrs: tag.end.attrs,
+                priority: 1
+              });
+            }
+          });
+          if (!pendingInsertions.length) {
+            return null;
+          }
+          pendingInsertions.sort((a, b2) => {
+            if (a.pos === b2.pos) {
+              return a.priority - b2.priority;
+            }
+            return a.pos - b2.pos;
+          });
+          const tr = newState.tr;
+          let offset2 = 0;
+          pendingInsertions.forEach((item) => {
+            const node = item.nodeType.create(item.attrs);
+            const insertPos = clampPosition(item.pos + offset2, tr.doc.content.size);
+            tr.insert(insertPos, node);
+            offset2 += node.nodeSize;
+          });
+          return tr.docChanged ? tr : null;
+        },
+        // Filters transactions to ensure only allowed edits are applied.
+        filterTransaction(tr, state) {
+          if (!tr.docChanged) return true;
+          if (!editor || editor.options.documentMode !== "viewing") return true;
+          const pluginState = PERMISSION_PLUGIN_KEY.getState(state);
+          if (!pluginState?.hasAllowedRanges) {
+            return true;
+          }
+          const changedRanges = collectChangedRanges(tr);
+          if (!changedRanges.length) return true;
+          const permStartType = state.schema.nodes["permStart"];
+          const permEndType = state.schema.nodes["permEnd"];
+          if (!permStartType || !permEndType) return true;
+          const allRangesAllowed = changedRanges.every((range) => {
+            const trimmed = trimPermissionTagsFromRange(state.doc, range, permStartType, permEndType);
+            return isRangeAllowed(trimmed, pluginState.ranges);
+          });
+          return allRangesAllowed;
+        }
+      })
+    ];
+  }
+});
 const PermStart = Node$1.create({
   name: "permStart",
   group: "inline",
@@ -74794,6 +75166,7 @@ const getStarterExtensions = () => {
     ShapeGroup,
     PermStart,
     PermEnd,
+    PermissionRanges,
     PassthroughInline,
     PassthroughBlock
   ];