@embedpdf/vue 0.0.0-stage → 3.0.0-next.16

package/dist/strip-BSDB39Xh.cjs

@@ -0,0 +1,743 @@
+"use strict";
+const vue = require("vue");
+const coreUi = require("@embedpdf/core-ui");
+const host = require("@embedpdf/plugin-commands/contract/host");
+const contract = require("@embedpdf/plugin-commands/contract");
+const web = require("@embedpdf/web");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const SURFACE = web.paintDefault("toolbar-surface");
+const BORDER = web.paintDefault("toolbar-border");
+const ACTIVE = web.paintDefault("toolbar-active");
+const _hoisted_1$5 = ["role", "aria-checked", "disabled", "onClick"];
+const _hoisted_2$2 = { key: 0 };
+const _sfc_main$8 = /* @__PURE__ */ vue.defineComponent({
+  __name: "DefaultOverflowMenu",
+  props: {
+    view: {},
+    orientation: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const menu = vue.ref(null);
+    vue.watch(
+      [menu, () => props.view.isOpen],
+      ([element, isOpen], _previous, onCleanup) => {
+        if (!isOpen || !element) return;
+        const container = element.parentElement ?? element;
+        const trigger = web.focusablesIn(container).find((candidate) => !element.contains(candidate)) ?? null;
+        const close = () => props.view.close();
+        const stopOutside = web.observeOutsidePress(container, close);
+        const detachKeys = web.attachMenuKeys(element, { trigger, close });
+        onCleanup(() => {
+          stopOutside();
+          detachKeys();
+        });
+      },
+      { immediate: true, flush: "post" }
+    );
+    const placement = vue.computed(
+      () => props.orientation === "vertical" ? { top: 0, insetInlineStart: "100%" } : { top: "100%", insetInlineEnd: 0 }
+    );
+    const sections = vue.computed(
+      () => props.view.sections.map((section) => ({
+        radio: section.role === "radio",
+        rows: section.rows.flatMap((row) => {
+          const command = props.view.resolve(row.command);
+          return command ? [{ row, command }] : [];
+        })
+      }))
+    );
+    function choose(row) {
+      props.view.execute(row.command);
+      if (row.type !== "submenu") props.view.close();
+    }
+    return (_ctx, _cache) => {
+      return __props.view.isOpen ? (vue.openBlock(), vue.createElementBlock("div", {
+        key: 0,
+        ref_key: "menu",
+        ref: menu,
+        role: "menu",
+        style: vue.normalizeStyle({
+          position: "absolute",
+          ...placement.value,
+          zIndex: 41,
+          minWidth: "200px",
+          padding: "4px",
+          background: vue.unref(SURFACE),
+          border: `1px solid ${vue.unref(BORDER)}`,
+          borderRadius: "6px",
+          boxShadow: "0 4px 16px rgba(0,0,0,0.15)"
+        })
+      }, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(sections.value, (section, index) => {
+          return vue.openBlock(), vue.createElementBlock(vue.Fragment, { key: index }, [
+            index > 0 ? (vue.openBlock(), vue.createElementBlock("div", {
+              key: 0,
+              style: vue.normalizeStyle({ height: "1px", background: vue.unref(BORDER), margin: "4px 0" })
+            }, null, 4)) : vue.createCommentVNode("", true),
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(section.rows, ({ row, command }) => {
+              return vue.openBlock(), vue.createElementBlock("button", {
+                key: row.command,
+                type: "button",
+                role: section.radio ? "menuitemradio" : "menuitem",
+                "aria-checked": section.radio ? command.active : void 0,
+                disabled: !command.enabled,
+                tabindex: "-1",
+                style: vue.normalizeStyle({
+                  display: "flex",
+                  width: "100%",
+                  alignItems: "center",
+                  justifyContent: "space-between",
+                  gap: "16px",
+                  padding: "6px 8px",
+                  border: "none",
+                  color: "inherit",
+                  font: "inherit",
+                  background: "transparent",
+                  cursor: command.enabled ? "pointer" : "default",
+                  opacity: command.enabled ? 1 : 0.4,
+                  whiteSpace: "nowrap"
+                }),
+                onClick: ($event) => choose(row)
+              }, [
+                vue.createElementVNode("span", null, vue.toDisplayString(command.active && section.radio ? "• " : "") + vue.toDisplayString(command.label), 1),
+                row.type === "submenu" ? (vue.openBlock(), vue.createElementBlock("span", _hoisted_2$2, "▸")) : vue.createCommentVNode("", true)
+              ], 12, _hoisted_1$5);
+            }), 128))
+          ], 64);
+        }), 128))
+      ], 4)) : vue.createCommentVNode("", true);
+    };
+  }
+});
+const _hoisted_1$4 = ["aria-expanded"];
+const _sfc_main$7 = /* @__PURE__ */ vue.defineComponent({
+  __name: "DefaultOverflowTrigger",
+  props: {
+    isOpen: { type: Boolean }
+  },
+  emits: ["toggle"],
+  setup(__props, { emit: __emit }) {
+    const emit = __emit;
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("button", {
+        type: "button",
+        "aria-haspopup": "menu",
+        "aria-expanded": __props.isOpen,
+        title: "More",
+        style: vue.normalizeStyle({
+          display: "inline-flex",
+          alignItems: "center",
+          padding: "4px 8px",
+          color: "inherit",
+          font: "inherit",
+          border: `1px solid ${vue.unref(BORDER)}`,
+          borderRadius: "4px",
+          background: __props.isOpen ? vue.unref(ACTIVE) : "transparent",
+          cursor: "pointer"
+        }),
+        onClick: _cache[0] || (_cache[0] = ($event) => emit("toggle"))
+      }, " ⋯ ", 12, _hoisted_1$4);
+    };
+  }
+});
+const _sfc_main$6 = /* @__PURE__ */ vue.defineComponent({
+  __name: "Measured",
+  props: {
+    measureKey: {},
+    orientation: {}
+  },
+  emits: ["length"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const element = vue.ref(null);
+    vue.watch(
+      [element, () => props.measureKey, () => props.orientation],
+      ([measured, key, orientation], _previous, onCleanup) => {
+        if (measured) {
+          onCleanup(web.observeLength(measured, orientation, (length) => emit("length", key, length)));
+        }
+      },
+      { immediate: true, flush: "post" }
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("span", {
+        ref_key: "element",
+        ref: element,
+        style: { display: "inline-flex", flexShrink: 0 }
+      }, [
+        vue.renderSlot(_ctx.$slots, "default")
+      ], 512);
+    };
+  }
+});
+const _hoisted_1$3 = ["value"];
+const _hoisted_2$1 = ["value", "disabled"];
+const _hoisted_3 = {
+  key: 1,
+  style: { position: "relative", display: "inline-flex" }
+};
+const _sfc_main$5 = /* @__PURE__ */ vue.defineComponent({
+  __name: "DefaultCollapsed",
+  props: {
+    view: {},
+    orientation: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const active = vue.computed(() => {
+      var _a;
+      return ((_a = props.view.commands.find((command) => command.active)) == null ? void 0 : _a.id) ?? "";
+    });
+    const isOpen = vue.ref(false);
+    const menu = vue.computed(() => coreUi.groupMenuView(props.view, isOpen.value, () => isOpen.value = false));
+    function onChange(event) {
+      props.view.execute(event.target.value);
+    }
+    return (_ctx, _cache) => {
+      return __props.view.collapse === "select" ? (vue.openBlock(), vue.createElementBlock("select", {
+        key: 0,
+        value: active.value,
+        style: vue.normalizeStyle({
+          padding: "4px 6px",
+          font: "inherit",
+          borderRadius: "4px",
+          border: `1px solid ${vue.unref(BORDER)}`,
+          background: vue.unref(SURFACE)
+        }),
+        onChange
+      }, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(__props.view.commands, (command) => {
+          return vue.openBlock(), vue.createElementBlock("option", {
+            key: command.id,
+            value: command.id,
+            disabled: !command.enabled
+          }, vue.toDisplayString(command.label), 9, _hoisted_2$1);
+        }), 128))
+      ], 44, _hoisted_1$3)) : (vue.openBlock(), vue.createElementBlock("span", _hoisted_3, [
+        vue.createVNode(_sfc_main$7, {
+          "is-open": isOpen.value,
+          onToggle: _cache[0] || (_cache[0] = ($event) => isOpen.value = !isOpen.value)
+        }, null, 8, ["is-open"]),
+        vue.createVNode(_sfc_main$8, {
+          view: menu.value,
+          orientation: __props.orientation
+        }, null, 8, ["view", "orientation"])
+      ]));
+    };
+  }
+});
+const _hoisted_1$2 = ["disabled", "aria-pressed", "aria-haspopup", "title"];
+const _sfc_main$4 = /* @__PURE__ */ vue.defineComponent({
+  __name: "DefaultCommand",
+  props: {
+    command: {},
+    run: { type: Function }
+  },
+  setup(__props) {
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("button", {
+        type: "button",
+        disabled: !__props.command.enabled,
+        "aria-pressed": __props.command.active || void 0,
+        "aria-haspopup": __props.command.menu ? "menu" : void 0,
+        title: __props.command.label,
+        style: vue.normalizeStyle({
+          display: "inline-flex",
+          alignItems: "center",
+          gap: "4px",
+          padding: "4px 8px",
+          whiteSpace: "nowrap",
+          color: "inherit",
+          font: "inherit",
+          background: __props.command.active ? vue.unref(ACTIVE) : "transparent",
+          border: `1px solid ${vue.unref(BORDER)}`,
+          borderRadius: "4px",
+          cursor: __props.command.enabled ? "pointer" : "default",
+          opacity: __props.command.enabled ? 1 : 0.4
+        }),
+        onClick: _cache[0] || (_cache[0] = ($event) => __props.run())
+      }, vue.toDisplayString(__props.command.label), 13, _hoisted_1$2);
+    };
+  }
+});
+const _hoisted_1$1 = { style: { position: "relative", display: "inline-flex" } };
+const _hoisted_2 = ["aria-expanded"];
+const _sfc_main$3 = /* @__PURE__ */ vue.defineComponent({
+  __name: "DefaultGroupTrigger",
+  props: {
+    view: {},
+    orientation: {}
+  },
+  setup(__props) {
+    const props = __props;
+    const isOpen = vue.ref(false);
+    const someActive = vue.computed(() => props.view.commands.some((command) => command.active));
+    const menu = vue.computed(() => coreUi.groupMenuView(props.view, isOpen.value, () => isOpen.value = false));
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("span", _hoisted_1$1, [
+        vue.createElementVNode("button", {
+          type: "button",
+          "aria-haspopup": "menu",
+          "aria-expanded": isOpen.value,
+          title: "More",
+          style: vue.normalizeStyle({
+            display: "inline-flex",
+            alignItems: "center",
+            padding: "4px 6px",
+            color: "inherit",
+            font: "inherit",
+            border: `1px solid ${vue.unref(BORDER)}`,
+            borderRadius: "4px",
+            background: isOpen.value || someActive.value ? vue.unref(ACTIVE) : "transparent",
+            cursor: "pointer"
+          }),
+          onClick: _cache[0] || (_cache[0] = ($event) => isOpen.value = !isOpen.value)
+        }, " ▾ ", 12, _hoisted_2),
+        vue.createVNode(_sfc_main$8, {
+          view: menu.value,
+          orientation: __props.orientation
+        }, null, 8, ["view", "orientation"])
+      ]);
+    };
+  }
+});
+const _sfc_main$2 = /* @__PURE__ */ vue.defineComponent({
+  __name: "NativeSlotSocket",
+  props: {
+    name: {},
+    measureKey: {},
+    orientation: {}
+  },
+  emits: ["length"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const socket = vue.ref(null);
+    vue.watch(
+      [socket, () => props.measureKey, () => props.orientation],
+      ([element, key, orientation], _previous, onCleanup) => {
+        if (element) {
+          onCleanup(web.observeLength(element, orientation, (length) => emit("length", key, length)));
+        }
+      },
+      { immediate: true, flush: "post" }
+    );
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createBlock(vue.resolveDynamicComponent("slot"), {
+        ref_key: "socket",
+        ref: socket,
+        name: __props.name,
+        style: { display: "inline-flex", alignItems: "center", flexShrink: 0 }
+      }, {
+        default: vue.withCtx(() => [
+          vue.renderSlot(_ctx.$slots, "default")
+        ]),
+        _: 3
+      }, 8, ["name"]);
+    };
+  }
+});
+const _sfc_main$1 = /* @__PURE__ */ vue.defineComponent({
+  __name: "ToolbarPart",
+  props: {
+    part: {},
+    layer: {},
+    orientation: {}
+  },
+  emits: ["length"],
+  setup(__props, { emit: __emit }) {
+    const props = __props;
+    const emit = __emit;
+    const measure = (length) => {
+      if (props.part.kind === "custom") emit("length", props.part.measureKey, length);
+    };
+    return (_ctx, _cache) => {
+      return __props.part.kind === "command" ? vue.renderSlot(_ctx.$slots, "command", {
+        command: __props.part.command,
+        variant: __props.part.variant,
+        run: __props.part.run
+      }, () => [
+        vue.createVNode(_sfc_main$4, {
+          command: __props.part.command,
+          run: __props.part.run
+        }, null, 8, ["command", "run"])
+      ], void 0, 0) : __props.part.kind === "custom" && _ctx.$slots.custom ? vue.renderSlot(_ctx.$slots, "custom", vue.normalizeProps(vue.guardReactiveProps({ name: __props.part.name, variant: __props.part.variant, layer: __props.layer, measure })), () => [
+        __props.part.terminal ? vue.renderSlot(_ctx.$slots, "command", {
+          command: __props.part.terminal,
+          variant: "icon",
+          run: __props.part.runTerminal
+        }, () => [
+          vue.createVNode(_sfc_main$4, {
+            command: __props.part.terminal,
+            run: __props.part.runTerminal
+          }, null, 8, ["command", "run"])
+        ], void 0, 0) : vue.createCommentVNode("", true)
+      ], void 0, 1) : __props.part.kind === "custom" ? (vue.openBlock(), vue.createBlock(_sfc_main$2, {
+        key: 2,
+        name: __props.part.name,
+        "measure-key": __props.part.measureKey,
+        orientation: __props.orientation,
+        onLength: _cache[0] || (_cache[0] = (key, length) => emit("length", key, length))
+      }, {
+        default: vue.withCtx(() => [
+          __props.part.terminal ? vue.renderSlot(_ctx.$slots, "command", {
+            command: __props.part.terminal,
+            variant: "icon",
+            run: __props.part.runTerminal
+          }, () => [
+            vue.createVNode(_sfc_main$4, {
+              command: __props.part.terminal,
+              run: __props.part.runTerminal
+            }, null, 8, ["command", "run"])
+          ], void 0, 0) : vue.createCommentVNode("", true)
+        ]),
+        _: 3
+      }, 8, ["name", "measure-key", "orientation"])) : __props.part.kind === "collapsed" ? vue.renderSlot(_ctx.$slots, "collapsed", {
+        view: __props.part.view
+      }, () => [
+        vue.createVNode(_sfc_main$5, {
+          view: __props.part.view,
+          orientation: __props.orientation
+        }, null, 8, ["view", "orientation"])
+      ], void 0, 3) : vue.renderSlot(_ctx.$slots, "group-trigger", {
+        view: __props.part.view
+      }, () => [
+        vue.createVNode(_sfc_main$3, {
+          view: __props.part.view,
+          orientation: __props.orientation
+        }, null, 8, ["view", "orientation"])
+      ], void 0, 4);
+    };
+  }
+});
+const _hoisted_1 = ["aria-orientation", "aria-label"];
+const _sfc_main = /* @__PURE__ */ vue.defineComponent({
+  __name: "Toolbar",
+  props: {
+    bar: {},
+    orientation: { default: "horizontal" },
+    gap: { default: 8 },
+    separatorWidth: { default: 1 },
+    "aria-label": {}
+  },
+  setup(__props) {
+    const props = __props;
+    const slots = vue.useSlots();
+    const { track } = capabilities.useViewerBinding();
+    const commands = capabilities.useCapability(host.CommandsToken);
+    const documentId = capabilities.useDocumentId();
+    const vertical = vue.computed(() => props.orientation === "vertical");
+    const ariaLabel = vue.computed(
+      () => props.ariaLabel
+    );
+    const container = vue.ref(null);
+    const containerLength = vue.ref(0);
+    vue.watch(
+      [container, () => props.orientation],
+      ([element, orientation], _previous, onCleanup) => {
+        if (element) {
+          onCleanup(
+            web.observeContentLength(element, orientation, (length) => containerLength.value = length)
+          );
+        }
+      },
+      { immediate: true, flush: "post" }
+    );
+    const lengths = web.createToolbarLengths();
+    const measured = vue.ref(0);
+    function onLength(key, length) {
+      if (lengths.report(props.orientation, key, length)) measured.value += 1;
+    }
+    let roving = null;
+    vue.watch(
+      [container, () => props.orientation],
+      ([element, orientation], _previous, onCleanup) => {
+        if (!element) return;
+        const focus = web.attachToolbarFocus(element, orientation);
+        roving = focus;
+        onCleanup(() => {
+          focus.detach();
+          roving = null;
+        });
+      },
+      { immediate: true, flush: "post" }
+    );
+    vue.onUpdated(() => roving == null ? void 0 : roving.refresh());
+    const normalized = vue.computed(() => coreUi.normalizeBar(props.bar));
+    const resolve = (id) => commands.resolveCommand(id, documentId.value ?? void 0);
+    const execute = (id) => void commands.execute(id, { documentId: documentId.value ?? void 0 });
+    const layout = vue.computed(() => {
+      track();
+      void measured.value;
+      return coreUi.layoutToolbar({
+        bar: normalized.value,
+        resolve,
+        unregistered: contract.unregisteredCommand,
+        execute,
+        menuTarget: (id) => commands.getMenuTarget(id),
+        metrics: lengths.metrics(props.orientation, props.gap, props.separatorWidth),
+        measureKey: web.toolbarMeasureKey,
+        containerLength: containerLength.value,
+        orientation: props.orientation
+      });
+    });
+    const overflowOpen = vue.ref(false);
+    const toggleOverflow = () => overflowOpen.value = !overflowOpen.value;
+    const noop = () => {
+    };
+    vue.watch(
+      () => layout.value.hasOverflow,
+      (hasOverflow) => {
+        if (!hasOverflow) overflowOpen.value = false;
+      }
+    );
+    const overflowView = vue.computed(
+      () => ({
+        sections: layout.value.overflow,
+        isOpen: overflowOpen.value,
+        close: () => overflowOpen.value = false,
+        resolve,
+        execute
+      })
+    );
+    const sectionStyle = (name) => ({
+      display: "flex",
+      flexDirection: vertical.value ? "column" : "row",
+      alignItems: "center",
+      gap: `${props.gap}px`,
+      flex: "0 0 auto",
+      ...name !== "center" ? null : vertical.value ? { marginTop: "auto", marginBottom: "auto" } : { marginLeft: "auto", marginRight: "auto" }
+    });
+    const separatorStyle = vue.computed(() => ({
+      ...vertical.value ? { height: "1px" } : { width: "1px" },
+      alignSelf: "stretch",
+      background: "currentColor",
+      opacity: 0.2
+    }));
+    const TOOLBAR_ITEM = { [web.TOOLBAR_ITEM_ATTRIBUTE]: "" };
+    const ITEM_STYLE = { display: "contents" };
+    function draws(content) {
+      return (Array.isArray(content) ? content : [content]).some((node) => {
+        if (node === null || node === void 0 || typeof node === "boolean") return false;
+        if (!vue.isVNode(node)) return true;
+        if (node.type === vue.Comment) return false;
+        if (node.type === vue.Fragment) return draws(node.children);
+        return true;
+      });
+    }
+    function measuredHere(part) {
+      if (part.kind !== "custom") return true;
+      const custom = slots.custom;
+      if (!custom) return false;
+      const scope = { name: part.name, variant: part.variant, measure: noop };
+      return draws(custom({ ...scope, layer: "measure" })) || !draws(custom({ ...scope, layer: "live" }));
+    }
+    const measureLayerStyle = vue.computed(() => ({
+      position: "absolute",
+      left: 0,
+      top: 0,
+      height: 0,
+      overflow: "hidden",
+      visibility: "hidden",
+      pointerEvents: "none",
+      display: "flex",
+      whiteSpace: "nowrap",
+      ...vertical.value ? { flexDirection: "column", alignItems: "flex-start" } : null
+    }));
+    return (_ctx, _cache) => {
+      return vue.openBlock(), vue.createElementBlock("div", {
+        ref_key: "container",
+        ref: container,
+        role: "toolbar",
+        "aria-orientation": __props.orientation,
+        "aria-label": ariaLabel.value,
+        style: vue.normalizeStyle({
+          position: "relative",
+          display: "flex",
+          flexDirection: vertical.value ? "column" : "row",
+          alignItems: "center"
+        })
+      }, [
+        (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(layout.value.sections, (section) => {
+          return vue.openBlock(), vue.createElementBlock("div", {
+            key: section.name,
+            style: vue.normalizeStyle(sectionStyle(section.name))
+          }, [
+            (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(section.groups, (group, index) => {
+              return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+                key: group.id
+              }, [
+                index > 0 ? vue.renderSlot(_ctx.$slots, "separator", {}, () => [
+                  vue.createElementVNode("span", {
+                    style: vue.normalizeStyle(separatorStyle.value)
+                  }, null, 4)
+                ], void 0, 0) : vue.createCommentVNode("", true),
+                (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(group.parts, (part) => {
+                  return vue.openBlock(), vue.createElementBlock("span", vue.mergeProps({
+                    key: part.key
+                  }, { ref_for: true }, TOOLBAR_ITEM, { style: ITEM_STYLE }), [
+                    vue.createVNode(_sfc_main$1, {
+                      part,
+                      layer: "live",
+                      orientation: __props.orientation,
+                      onLength
+                    }, vue.createSlots({ _: 2 }, [
+                      _ctx.$slots.command ? {
+                        name: "command",
+                        fn: vue.withCtx((scope) => [
+                          vue.renderSlot(_ctx.$slots, "command", vue.mergeProps({ ref_for: true }, scope))
+                        ]),
+                        key: "0"
+                      } : void 0,
+                      _ctx.$slots.custom ? {
+                        name: "custom",
+                        fn: vue.withCtx((scope) => [
+                          vue.renderSlot(_ctx.$slots, "custom", vue.mergeProps({ ref_for: true }, scope))
+                        ]),
+                        key: "1"
+                      } : void 0,
+                      _ctx.$slots.collapsed ? {
+                        name: "collapsed",
+                        fn: vue.withCtx((scope) => [
+                          vue.renderSlot(_ctx.$slots, "collapsed", vue.mergeProps({ ref_for: true }, scope))
+                        ]),
+                        key: "2"
+                      } : void 0,
+                      _ctx.$slots["group-trigger"] ? {
+                        name: "group-trigger",
+                        fn: vue.withCtx((scope) => [
+                          vue.renderSlot(_ctx.$slots, "group-trigger", vue.mergeProps({ ref_for: true }, scope))
+                        ]),
+                        key: "3"
+                      } : void 0
+                    ]), 1032, ["part", "orientation"])
+                  ], 16);
+                }), 128))
+              ], 64);
+            }), 128)),
+            section.name === "end" && layout.value.hasOverflow ? (vue.openBlock(), vue.createElementBlock("span", vue.mergeProps({
+              key: 0,
+              ref_for: true
+            }, TOOLBAR_ITEM, { style: { position: "relative", display: "inline-flex" } }), [
+              vue.renderSlot(_ctx.$slots, "overflow-trigger", {
+                isOpen: overflowOpen.value,
+                toggle: toggleOverflow
+              }, () => [
+                vue.createVNode(_sfc_main$7, {
+                  "is-open": overflowOpen.value,
+                  onToggle: toggleOverflow
+                }, null, 8, ["is-open"])
+              ]),
+              vue.renderSlot(_ctx.$slots, "overflow-menu", { view: overflowView.value }, () => [
+                vue.createVNode(_sfc_main$8, {
+                  view: overflowView.value,
+                  orientation: __props.orientation
+                }, null, 8, ["view", "orientation"])
+              ])
+            ], 16)) : vue.createCommentVNode("", true)
+          ], 4);
+        }), 128)),
+        vue.createElementVNode("div", {
+          "aria-hidden": "true",
+          inert: "",
+          style: vue.normalizeStyle(measureLayerStyle.value)
+        }, [
+          (vue.openBlock(true), vue.createElementBlock(vue.Fragment, null, vue.renderList(layout.value.measured, (part) => {
+            return vue.openBlock(), vue.createElementBlock(vue.Fragment, {
+              key: part.measureKey
+            }, [
+              measuredHere(part) ? (vue.openBlock(), vue.createBlock(_sfc_main$6, {
+                key: 0,
+                "measure-key": part.measureKey,
+                orientation: __props.orientation,
+                onLength
+              }, {
+                default: vue.withCtx(() => [
+                  vue.createVNode(_sfc_main$1, {
+                    part,
+                    layer: "measure",
+                    orientation: __props.orientation,
+                    onLength
+                  }, vue.createSlots({ _: 2 }, [
+                    _ctx.$slots.command ? {
+                      name: "command",
+                      fn: vue.withCtx((scope) => [
+                        vue.renderSlot(_ctx.$slots, "command", vue.mergeProps({ ref_for: true }, scope))
+                      ]),
+                      key: "0"
+                    } : void 0,
+                    _ctx.$slots.custom ? {
+                      name: "custom",
+                      fn: vue.withCtx((scope) => [
+                        vue.renderSlot(_ctx.$slots, "custom", vue.mergeProps({ ref_for: true }, scope))
+                      ]),
+                      key: "1"
+                    } : void 0,
+                    _ctx.$slots.collapsed ? {
+                      name: "collapsed",
+                      fn: vue.withCtx((scope) => [
+                        vue.renderSlot(_ctx.$slots, "collapsed", vue.mergeProps({ ref_for: true }, scope))
+                      ]),
+                      key: "2"
+                    } : void 0,
+                    _ctx.$slots["group-trigger"] ? {
+                      name: "group-trigger",
+                      fn: vue.withCtx((scope) => [
+                        vue.renderSlot(_ctx.$slots, "group-trigger", vue.mergeProps({ ref_for: true }, scope))
+                      ]),
+                      key: "3"
+                    } : void 0
+                  ]), 1032, ["part", "orientation"])
+                ]),
+                _: 2
+              }, 1032, ["measure-key", "orientation"])) : vue.createCommentVNode("", true)
+            ], 64);
+          }), 128)),
+          vue.createVNode(_sfc_main$6, {
+            "measure-key": vue.unref(web.toolbarMeasureKey).overflowTrigger,
+            orientation: __props.orientation,
+            onLength
+          }, {
+            default: vue.withCtx(() => [
+              vue.renderSlot(_ctx.$slots, "overflow-trigger", {
+                isOpen: false,
+                toggle: noop
+              }, () => [
+                vue.createVNode(_sfc_main$7, { "is-open": false })
+              ])
+            ]),
+            _: 3
+          }, 8, ["measure-key", "orientation"])
+        ], 4)
+      ], 12, _hoisted_1);
+    };
+  }
+});
+const sameGroups = (left, right) => coreUi.sameStripGroups(left, right, contract.resolvedCommandsEqual);
+const NO_GROUPS = Object.freeze([]);
+function useStripView(bar) {
+  const commands = capabilities.useCapability(host.CommandsToken);
+  const documentId = capabilities.useDocumentId();
+  const normalized = vue.computed(() => {
+    const schema = vue.toValue(bar);
+    return schema ? coreUi.normalizeBar(schema) : null;
+  });
+  const groups = capabilities.useKernelValue(
+    () => normalized.value ? coreUi.stripGroupsOf(
+      normalized.value,
+      (id) => commands.resolveCommand(id, documentId.value ?? void 0)
+    ) : NO_GROUPS,
+    sameGroups
+  );
+  return vue.computed(
+    () => groups.value.length === 0 ? null : {
+      groups: groups.value,
+      execute: (id) => void commands.execute(id, { documentId: documentId.value ?? void 0 })
+    }
+  );
+}
+exports._sfc_main = _sfc_main;
+exports.useStripView = useStripView;
+//# sourceMappingURL=strip-BSDB39Xh.cjs.map