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

package/dist/measurement.cjs

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginMeasurement = require("@embedpdf/plugin-measurement");
+const vue = require("vue");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function useMeasurement() {
+  return capabilities.useCapability(pluginMeasurement.MeasurementToken);
+}
+function useMeasurementEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginMeasurement.MeasurementToken, select, handler);
+}
+const useMeasurementState = state.stateComposable(pluginMeasurement.measurementState);
+const useMeasurementSettings = state.settingsComposable(pluginMeasurement.MeasurementToken);
+function usePageScale(page) {
+  const scope = capabilities.useDocumentScope();
+  return capabilities.useKernelValue((kernel) => {
+    var _a;
+    const wanted = vue.toValue(page);
+    if (wanted === null) return null;
+    return ((_a = kernel.tryCapability(pluginMeasurement.MeasurementToken, scope.value ?? void 0)) == null ? void 0 : _a.getPageScale(wanted)) ?? pluginMeasurement.NO_PAGE_SCALE;
+  });
+}
+function useMeasurementReadout(ref) {
+  return capabilities.useOptionalSelector(
+    pluginMeasurement.MeasurementToken,
+    (measurement) => measurement.getReadout(vue.toValue(ref)),
+    pluginMeasurement.NO_READOUT
+  );
+}
+exports.useMeasurement = useMeasurement;
+exports.useMeasurementEvent = useMeasurementEvent;
+exports.useMeasurementReadout = useMeasurementReadout;
+exports.useMeasurementSettings = useMeasurementSettings;
+exports.useMeasurementState = useMeasurementState;
+exports.usePageScale = usePageScale;
+Object.keys(pluginMeasurement).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginMeasurement[k]
+  });
+});
+//# sourceMappingURL=measurement.cjs.map

package/dist/measurement.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"measurement.cjs","sources":["../src/measurement.ts"],"sourcesContent":["/**\n * @embedpdf/vue/measurement: the Vue view of `@embedpdf/plugin-measurement`.\n * The four composables every plugin has, plus one per page scale and one per\n * measurement, so a template updates only for its own page or measurement.\n * Every one works before a document opens.\n *\n *   const measurement = useMeasurement();\n *   const scale = usePageScale(0); // the cover's, as a ref\n *   const readout = useMeasurementReadout(() => props.annotation); // { kind, value, label }\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-measurement';\nimport { toValue } from 'vue';\nimport type { MaybeRefOrGetter, Ref } from 'vue';\nimport type { EventHook, PageRef } from '@embedpdf/core';\nimport {\n  MeasurementToken,\n  measurementState,\n  NO_PAGE_SCALE,\n  NO_READOUT,\n} from '@embedpdf/plugin-measurement';\nimport type {\n  AnnotationRef,\n  MeasurementCapability,\n  MeasurementReadout,\n  MeasurementUnavailable,\n  PageScale,\n} from '@embedpdf/plugin-measurement';\nimport { useCapability, useCapabilityEvent, useOptionalSelector } from './runtime/capabilities';\nimport { useDocumentScope, useKernelValue } from './runtime/kernel';\nimport { settingsComposable, stateComposable } from './state';\n\n/**\n * The measurement API (scales, calibration, readouts, creating measurements)\n * of the nearest `<DocumentScope>`'s document, else the active one. The object\n * never changes; outside a document every method throws `not-ready`.\n */\nexport function useMeasurement(): MeasurementCapability {\n  return useCapability(MeasurementToken);\n}\n\n/** Subscribe to one measurement event while the component lives: `useMeasurementEvent((measurement) => measurement.onScaleChanged, handler)`. */\nexport function useMeasurementEvent<Event>(\n  select: (measurement: MeasurementCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(MeasurementToken, select, handler);\n}\n\n/**\n * The measurement state as refs: whether a scale change runs, the\n * calibration request waiting for its length, and the last change's reports\n * (the page's State table, declared once in `measurementState`). With a\n * selector, one ref that updates only when the value it picks changes.\n */\nexport const useMeasurementState = stateComposable(measurementState);\n\n/** The measurement settings (`defaultScale`, `presets`), with or without a document, as refs. Takes a selector. */\nexport const useMeasurementSettings = settingsComposable(MeasurementToken);\n\n/**\n * A page's measurement scale (its ref or its index; a getter to follow a\n * prop), as a ref: for a scale bar or a \"1:100\" badge. Accepts `null` (no\n * current page) and answers `null` then, so chrome can stay mounted without\n * inventing a page.\n */\nexport function usePageScale(page: MaybeRefOrGetter<PageRef | number>): Readonly<Ref<PageScale>>;\nexport function usePageScale(\n  page: MaybeRefOrGetter<PageRef | number | null>,\n): Readonly<Ref<PageScale | null>>;\nexport function usePageScale(\n  page: MaybeRefOrGetter<PageRef | number | null>,\n): Readonly<Ref<PageScale | null>> {\n  const scope = useDocumentScope();\n  // Scales are reference-stable in the plugin, so the ref updates only when this page's changes.\n  return useKernelValue((kernel) => {\n    const wanted = toValue(page);\n    if (wanted === null) return null;\n    return (\n      kernel.tryCapability(MeasurementToken, scope.value ?? undefined)?.getPageScale(wanted) ??\n      NO_PAGE_SCALE\n    );\n  });\n}\n\n/**\n * A measurement's `{ kind, value, label }` as a ref, or `{ unavailable }`\n * with why there's none. Pass a getter to follow a prop:\n * `useMeasurementReadout(() => props.annotation)`. Readouts are\n * reference-stable in the plugin, so the ref updates only when the\n * measurement's changes.\n */\nexport function useMeasurementReadout(\n  ref: MaybeRefOrGetter<AnnotationRef>,\n): Readonly<Ref<MeasurementReadout | MeasurementUnavailable>> {\n  return useOptionalSelector(\n    MeasurementToken,\n    (measurement) => measurement.getReadout(toValue(ref)),\n    NO_READOUT as MeasurementReadout | MeasurementUnavailable,\n  );\n}\n"],"names":["useCapability","MeasurementToken","useCapabilityEvent","stateComposable","measurementState","settingsComposable","useDocumentScope","useKernelValue","toValue","NO_PAGE_SCALE","useOptionalSelector","NO_READOUT"],"mappings":";;;;;;AAsCO,SAAS,iBAAwC;AACtD,SAAOA,aAAAA,cAAcC,kBAAAA,gBAAgB;AACvC;AAGO,SAAS,oBACd,QACA,SACM;AACNC,kCAAmBD,kBAAAA,kBAAkB,QAAQ,OAAO;AACtD;AAQO,MAAM,sBAAsBE,MAAAA,gBAAgBC,kBAAAA,gBAAgB;AAG5D,MAAM,yBAAyBC,MAAAA,mBAAmBJ,kBAAAA,gBAAgB;AAYlE,SAAS,aACd,MACiC;AACjC,QAAM,QAAQK,aAAAA,iBAAA;AAEd,SAAOC,aAAAA,eAAe,CAAC,WAAW;;AAChC,UAAM,SAASC,IAAAA,QAAQ,IAAI;AAC3B,QAAI,WAAW,KAAM,QAAO;AAC5B,aACE,YAAO,cAAcP,kBAAAA,kBAAkB,MAAM,SAAS,MAAS,MAA/D,mBAAkE,aAAa,YAC/EQ,kBAAAA;AAAAA,EAEJ,CAAC;AACH;AASO,SAAS,sBACd,KAC4D;AAC5D,SAAOC,aAAAA;AAAAA,IACLT,kBAAAA;AAAAA,IACA,CAAC,gBAAgB,YAAY,WAAWO,IAAAA,QAAQ,GAAG,CAAC;AAAA,IACpDG,kBAAAA;AAAAA,EAAA;AAEJ;;;;;;;;;;;;;"}

package/dist/measurement.d.cts

@@ -0,0 +1,51 @@
+/**
+ * @embedpdf/vue/measurement: the Vue view of `@embedpdf/plugin-measurement`.
+ * The four composables every plugin has, plus one per page scale and one per
+ * measurement, so a template updates only for its own page or measurement.
+ * Every one works before a document opens.
+ *
+ *   const measurement = useMeasurement();
+ *   const scale = usePageScale(0); // the cover's, as a ref
+ *   const readout = useMeasurementReadout(() => props.annotation); // { kind, value, label }
+ */
+export * from '@embedpdf/plugin-measurement';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { EventHook, PageRef } from '@embedpdf/core';
+import type { AnnotationRef, MeasurementCapability, MeasurementReadout, MeasurementUnavailable, PageScale } from '@embedpdf/plugin-measurement';
+/**
+ * The measurement API (scales, calibration, readouts, creating measurements)
+ * of the nearest `<DocumentScope>`'s document, else the active one. The object
+ * never changes; outside a document every method throws `not-ready`.
+ */
+export declare function useMeasurement(): MeasurementCapability;
+/** Subscribe to one measurement event while the component lives: `useMeasurementEvent((measurement) => measurement.onScaleChanged, handler)`. */
+export declare function useMeasurementEvent<Event>(select: (measurement: MeasurementCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The measurement state as refs: whether a scale change runs, the
+ * calibration request waiting for its length, and the last change's reports
+ * (the page's State table, declared once in `measurementState`). With a
+ * selector, one ref that updates only when the value it picks changes.
+ */
+export declare const useMeasurementState: import("./state.cjs").StateComposable<{
+    busy: boolean;
+    calibrationRequest: import("@embedpdf/plugin-measurement").CalibrationRequest | null;
+    lastReports: readonly import("@embedpdf/plugin-measurement").ScaleChangeReport[];
+}>;
+/** The measurement settings (`defaultScale`, `presets`), with or without a document, as refs. Takes a selector. */
+export declare const useMeasurementSettings: import("./state.cjs").SettingsComposable<import("@embedpdf/plugin-measurement").MeasurementSettings & object>;
+/**
+ * A page's measurement scale (its ref or its index; a getter to follow a
+ * prop), as a ref: for a scale bar or a "1:100" badge. Accepts `null` (no
+ * current page) and answers `null` then, so chrome can stay mounted without
+ * inventing a page.
+ */
+export declare function usePageScale(page: MaybeRefOrGetter<PageRef | number>): Readonly<Ref<PageScale>>;
+export declare function usePageScale(page: MaybeRefOrGetter<PageRef | number | null>): Readonly<Ref<PageScale | null>>;
+/**
+ * A measurement's `{ kind, value, label }` as a ref, or `{ unavailable }`
+ * with why there's none. Pass a getter to follow a prop:
+ * `useMeasurementReadout(() => props.annotation)`. Readouts are
+ * reference-stable in the plugin, so the ref updates only when the
+ * measurement's changes.
+ */
+export declare function useMeasurementReadout(ref: MaybeRefOrGetter<AnnotationRef>): Readonly<Ref<MeasurementReadout | MeasurementUnavailable>>;

package/dist/measurement.d.ts

@@ -0,0 +1,51 @@
+/**
+ * @embedpdf/vue/measurement: the Vue view of `@embedpdf/plugin-measurement`.
+ * The four composables every plugin has, plus one per page scale and one per
+ * measurement, so a template updates only for its own page or measurement.
+ * Every one works before a document opens.
+ *
+ *   const measurement = useMeasurement();
+ *   const scale = usePageScale(0); // the cover's, as a ref
+ *   const readout = useMeasurementReadout(() => props.annotation); // { kind, value, label }
+ */
+export * from '@embedpdf/plugin-measurement';
+import type { MaybeRefOrGetter, Ref } from 'vue';
+import type { EventHook, PageRef } from '@embedpdf/core';
+import type { AnnotationRef, MeasurementCapability, MeasurementReadout, MeasurementUnavailable, PageScale } from '@embedpdf/plugin-measurement';
+/**
+ * The measurement API (scales, calibration, readouts, creating measurements)
+ * of the nearest `<DocumentScope>`'s document, else the active one. The object
+ * never changes; outside a document every method throws `not-ready`.
+ */
+export declare function useMeasurement(): MeasurementCapability;
+/** Subscribe to one measurement event while the component lives: `useMeasurementEvent((measurement) => measurement.onScaleChanged, handler)`. */
+export declare function useMeasurementEvent<Event>(select: (measurement: MeasurementCapability) => EventHook<Event>, handler: (event: Event) => void): void;
+/**
+ * The measurement state as refs: whether a scale change runs, the
+ * calibration request waiting for its length, and the last change's reports
+ * (the page's State table, declared once in `measurementState`). With a
+ * selector, one ref that updates only when the value it picks changes.
+ */
+export declare const useMeasurementState: import("./state.js").StateComposable<{
+    busy: boolean;
+    calibrationRequest: import("@embedpdf/plugin-measurement").CalibrationRequest | null;
+    lastReports: readonly import("@embedpdf/plugin-measurement").ScaleChangeReport[];
+}>;
+/** The measurement settings (`defaultScale`, `presets`), with or without a document, as refs. Takes a selector. */
+export declare const useMeasurementSettings: import("./state.js").SettingsComposable<import("@embedpdf/plugin-measurement").MeasurementSettings & object>;
+/**
+ * A page's measurement scale (its ref or its index; a getter to follow a
+ * prop), as a ref: for a scale bar or a "1:100" badge. Accepts `null` (no
+ * current page) and answers `null` then, so chrome can stay mounted without
+ * inventing a page.
+ */
+export declare function usePageScale(page: MaybeRefOrGetter<PageRef | number>): Readonly<Ref<PageScale>>;
+export declare function usePageScale(page: MaybeRefOrGetter<PageRef | number | null>): Readonly<Ref<PageScale | null>>;
+/**
+ * A measurement's `{ kind, value, label }` as a ref, or `{ unavailable }`
+ * with why there's none. Pass a getter to follow a prop:
+ * `useMeasurementReadout(() => props.annotation)`. Readouts are
+ * reference-stable in the plugin, so the ref updates only when the
+ * measurement's changes.
+ */
+export declare function useMeasurementReadout(ref: MaybeRefOrGetter<AnnotationRef>): Readonly<Ref<MeasurementReadout | MeasurementUnavailable>>;

package/dist/measurement.js

@@ -0,0 +1,38 @@
+import { MeasurementToken, NO_PAGE_SCALE, measurementState, NO_READOUT } from "@embedpdf/plugin-measurement";
+export * from "@embedpdf/plugin-measurement";
+import { toValue } from "vue";
+import { a as useCapability, b as useCapabilityEvent, i as useOptionalSelector, e as useDocumentScope, g as useKernelValue } from "./capabilities-C7YzgPCX.js";
+import { s as settingsComposable, a as stateComposable } from "./state-DZg8q3v6.js";
+function useMeasurement() {
+  return useCapability(MeasurementToken);
+}
+function useMeasurementEvent(select, handler) {
+  useCapabilityEvent(MeasurementToken, select, handler);
+}
+const useMeasurementState = stateComposable(measurementState);
+const useMeasurementSettings = settingsComposable(MeasurementToken);
+function usePageScale(page) {
+  const scope = useDocumentScope();
+  return useKernelValue((kernel) => {
+    var _a;
+    const wanted = toValue(page);
+    if (wanted === null) return null;
+    return ((_a = kernel.tryCapability(MeasurementToken, scope.value ?? void 0)) == null ? void 0 : _a.getPageScale(wanted)) ?? NO_PAGE_SCALE;
+  });
+}
+function useMeasurementReadout(ref) {
+  return useOptionalSelector(
+    MeasurementToken,
+    (measurement) => measurement.getReadout(toValue(ref)),
+    NO_READOUT
+  );
+}
+export {
+  useMeasurement,
+  useMeasurementEvent,
+  useMeasurementReadout,
+  useMeasurementSettings,
+  useMeasurementState,
+  usePageScale
+};
+//# sourceMappingURL=measurement.js.map

package/dist/measurement.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"measurement.js","sources":["../src/measurement.ts"],"sourcesContent":["/**\n * @embedpdf/vue/measurement: the Vue view of `@embedpdf/plugin-measurement`.\n * The four composables every plugin has, plus one per page scale and one per\n * measurement, so a template updates only for its own page or measurement.\n * Every one works before a document opens.\n *\n *   const measurement = useMeasurement();\n *   const scale = usePageScale(0); // the cover's, as a ref\n *   const readout = useMeasurementReadout(() => props.annotation); // { kind, value, label }\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-measurement';\nimport { toValue } from 'vue';\nimport type { MaybeRefOrGetter, Ref } from 'vue';\nimport type { EventHook, PageRef } from '@embedpdf/core';\nimport {\n  MeasurementToken,\n  measurementState,\n  NO_PAGE_SCALE,\n  NO_READOUT,\n} from '@embedpdf/plugin-measurement';\nimport type {\n  AnnotationRef,\n  MeasurementCapability,\n  MeasurementReadout,\n  MeasurementUnavailable,\n  PageScale,\n} from '@embedpdf/plugin-measurement';\nimport { useCapability, useCapabilityEvent, useOptionalSelector } from './runtime/capabilities';\nimport { useDocumentScope, useKernelValue } from './runtime/kernel';\nimport { settingsComposable, stateComposable } from './state';\n\n/**\n * The measurement API (scales, calibration, readouts, creating measurements)\n * of the nearest `<DocumentScope>`'s document, else the active one. The object\n * never changes; outside a document every method throws `not-ready`.\n */\nexport function useMeasurement(): MeasurementCapability {\n  return useCapability(MeasurementToken);\n}\n\n/** Subscribe to one measurement event while the component lives: `useMeasurementEvent((measurement) => measurement.onScaleChanged, handler)`. */\nexport function useMeasurementEvent<Event>(\n  select: (measurement: MeasurementCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(MeasurementToken, select, handler);\n}\n\n/**\n * The measurement state as refs: whether a scale change runs, the\n * calibration request waiting for its length, and the last change's reports\n * (the page's State table, declared once in `measurementState`). With a\n * selector, one ref that updates only when the value it picks changes.\n */\nexport const useMeasurementState = stateComposable(measurementState);\n\n/** The measurement settings (`defaultScale`, `presets`), with or without a document, as refs. Takes a selector. */\nexport const useMeasurementSettings = settingsComposable(MeasurementToken);\n\n/**\n * A page's measurement scale (its ref or its index; a getter to follow a\n * prop), as a ref: for a scale bar or a \"1:100\" badge. Accepts `null` (no\n * current page) and answers `null` then, so chrome can stay mounted without\n * inventing a page.\n */\nexport function usePageScale(page: MaybeRefOrGetter<PageRef | number>): Readonly<Ref<PageScale>>;\nexport function usePageScale(\n  page: MaybeRefOrGetter<PageRef | number | null>,\n): Readonly<Ref<PageScale | null>>;\nexport function usePageScale(\n  page: MaybeRefOrGetter<PageRef | number | null>,\n): Readonly<Ref<PageScale | null>> {\n  const scope = useDocumentScope();\n  // Scales are reference-stable in the plugin, so the ref updates only when this page's changes.\n  return useKernelValue((kernel) => {\n    const wanted = toValue(page);\n    if (wanted === null) return null;\n    return (\n      kernel.tryCapability(MeasurementToken, scope.value ?? undefined)?.getPageScale(wanted) ??\n      NO_PAGE_SCALE\n    );\n  });\n}\n\n/**\n * A measurement's `{ kind, value, label }` as a ref, or `{ unavailable }`\n * with why there's none. Pass a getter to follow a prop:\n * `useMeasurementReadout(() => props.annotation)`. Readouts are\n * reference-stable in the plugin, so the ref updates only when the\n * measurement's changes.\n */\nexport function useMeasurementReadout(\n  ref: MaybeRefOrGetter<AnnotationRef>,\n): Readonly<Ref<MeasurementReadout | MeasurementUnavailable>> {\n  return useOptionalSelector(\n    MeasurementToken,\n    (measurement) => measurement.getReadout(toValue(ref)),\n    NO_READOUT as MeasurementReadout | MeasurementUnavailable,\n  );\n}\n"],"names":[],"mappings":";;;;;AAsCO,SAAS,iBAAwC;AACtD,SAAO,cAAc,gBAAgB;AACvC;AAGO,SAAS,oBACd,QACA,SACM;AACN,qBAAmB,kBAAkB,QAAQ,OAAO;AACtD;AAQO,MAAM,sBAAsB,gBAAgB,gBAAgB;AAG5D,MAAM,yBAAyB,mBAAmB,gBAAgB;AAYlE,SAAS,aACd,MACiC;AACjC,QAAM,QAAQ,iBAAA;AAEd,SAAO,eAAe,CAAC,WAAW;;AAChC,UAAM,SAAS,QAAQ,IAAI;AAC3B,QAAI,WAAW,KAAM,QAAO;AAC5B,aACE,YAAO,cAAc,kBAAkB,MAAM,SAAS,MAAS,MAA/D,mBAAkE,aAAa,YAC/E;AAAA,EAEJ,CAAC;AACH;AASO,SAAS,sBACd,KAC4D;AAC5D,SAAO;AAAA,IACL;AAAA,IACA,CAAC,gBAAgB,YAAY,WAAW,QAAQ,GAAG,CAAC;AAAA,IACpD;AAAA,EAAA;AAEJ;"}

package/dist/metadata.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginMetadata = require("@embedpdf/plugin-metadata");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function useMetadata() {
+  return capabilities.useCapability(pluginMetadata.MetadataToken);
+}
+const useMetadataState = state.stateComposable(pluginMetadata.metadataState);
+function useMetadataEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginMetadata.MetadataToken, select, handler);
+}
+exports.useMetadata = useMetadata;
+exports.useMetadataEvent = useMetadataEvent;
+exports.useMetadataState = useMetadataState;
+Object.keys(pluginMetadata).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginMetadata[k]
+  });
+});
+//# sourceMappingURL=metadata.cjs.map

package/dist/metadata.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.cjs","sources":["../src/metadata.ts"],"sourcesContent":["/**\n * @embedpdf/vue/metadata: the Vue view of `@embedpdf/plugin-metadata`. The\n * plugin keeps the metadata live off the document's event stream, so the state\n * follows your own edits and other sessions' alike.\n *\n *   const metadata = useMetadata();\n *   const { metadata: fields, custom, status } = useMetadataState();\n *   await metadata.update({ title: 'New title' }); // resolves once the state shows it\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-metadata';\nimport { MetadataToken, metadataState } from '@embedpdf/plugin-metadata';\nimport type { MetadataCapability } from '@embedpdf/plugin-metadata';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent } from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/**\n * The metadata API (`update`, `custom.update`, `refresh`, `canUpdate`) of the\n * nearest `<DocumentScope>`'s document, else the active one. The object never\n * changes; outside a document every method throws `not-ready`.\n */\nexport function useMetadata(): MetadataCapability {\n  return useCapability(MetadataToken);\n}\n\n/**\n * The metadata's state as refs: the standard fields, your own fields and the\n * load state (the page's State table, declared once in `metadataState`). With\n * a selector, one ref for the value it picks, which updates only when that\n * value changes.\n */\nexport const useMetadataState = stateComposable(metadataState);\n\n/** Subscribe to one metadata event while the component lives: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */\nexport function useMetadataEvent<Event>(\n  select: (metadata: MetadataCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(MetadataToken, select, handler);\n}\n"],"names":["useCapability","MetadataToken","stateComposable","metadataState","useCapabilityEvent"],"mappings":";;;;;AAuBO,SAAS,cAAkC;AAChD,SAAOA,aAAAA,cAAcC,eAAAA,aAAa;AACpC;AAQO,MAAM,mBAAmBC,MAAAA,gBAAgBC,eAAAA,aAAa;AAGtD,SAAS,iBACd,QACA,SACM;AACNC,kCAAmBH,eAAAA,eAAe,QAAQ,OAAO;AACnD;;;;;;;;;;"}

package/dist/metadata.d.cts

@@ -0,0 +1,31 @@
+/**
+ * @embedpdf/vue/metadata: the Vue view of `@embedpdf/plugin-metadata`. The
+ * plugin keeps the metadata live off the document's event stream, so the state
+ * follows your own edits and other sessions' alike.
+ *
+ *   const metadata = useMetadata();
+ *   const { metadata: fields, custom, status } = useMetadataState();
+ *   await metadata.update({ title: 'New title' }); // resolves once the state shows it
+ */
+export * from '@embedpdf/plugin-metadata';
+import type { MetadataCapability } from '@embedpdf/plugin-metadata';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The metadata API (`update`, `custom.update`, `refresh`, `canUpdate`) of the
+ * nearest `<DocumentScope>`'s document, else the active one. The object never
+ * changes; outside a document every method throws `not-ready`.
+ */
+export declare function useMetadata(): MetadataCapability;
+/**
+ * The metadata's state as refs: the standard fields, your own fields and the
+ * load state (the page's State table, declared once in `metadataState`). With
+ * a selector, one ref for the value it picks, which updates only when that
+ * value changes.
+ */
+export declare const useMetadataState: import("./state.cjs").StateComposable<{
+    metadata: import("@embedpdf/core").DocumentMetadata | null;
+    custom: import("@embedpdf/core").CustomMetadata | null;
+    status: import("@embedpdf/core").ResourceStatus;
+}>;
+/** Subscribe to one metadata event while the component lives: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */
+export declare function useMetadataEvent<Event>(select: (metadata: MetadataCapability) => EventHook<Event>, handler: (event: Event) => void): void;

package/dist/metadata.d.ts

@@ -0,0 +1,31 @@
+/**
+ * @embedpdf/vue/metadata: the Vue view of `@embedpdf/plugin-metadata`. The
+ * plugin keeps the metadata live off the document's event stream, so the state
+ * follows your own edits and other sessions' alike.
+ *
+ *   const metadata = useMetadata();
+ *   const { metadata: fields, custom, status } = useMetadataState();
+ *   await metadata.update({ title: 'New title' }); // resolves once the state shows it
+ */
+export * from '@embedpdf/plugin-metadata';
+import type { MetadataCapability } from '@embedpdf/plugin-metadata';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The metadata API (`update`, `custom.update`, `refresh`, `canUpdate`) of the
+ * nearest `<DocumentScope>`'s document, else the active one. The object never
+ * changes; outside a document every method throws `not-ready`.
+ */
+export declare function useMetadata(): MetadataCapability;
+/**
+ * The metadata's state as refs: the standard fields, your own fields and the
+ * load state (the page's State table, declared once in `metadataState`). With
+ * a selector, one ref for the value it picks, which updates only when that
+ * value changes.
+ */
+export declare const useMetadataState: import("./state.js").StateComposable<{
+    metadata: import("@embedpdf/core").DocumentMetadata | null;
+    custom: import("@embedpdf/core").CustomMetadata | null;
+    status: import("@embedpdf/core").ResourceStatus;
+}>;
+/** Subscribe to one metadata event while the component lives: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */
+export declare function useMetadataEvent<Event>(select: (metadata: MetadataCapability) => EventHook<Event>, handler: (event: Event) => void): void;

package/dist/metadata.js

@@ -0,0 +1,17 @@
+import { MetadataToken, metadataState } from "@embedpdf/plugin-metadata";
+export * from "@embedpdf/plugin-metadata";
+import { a as useCapability, b as useCapabilityEvent } from "./capabilities-C7YzgPCX.js";
+import { a as stateComposable } from "./state-DZg8q3v6.js";
+function useMetadata() {
+  return useCapability(MetadataToken);
+}
+const useMetadataState = stateComposable(metadataState);
+function useMetadataEvent(select, handler) {
+  useCapabilityEvent(MetadataToken, select, handler);
+}
+export {
+  useMetadata,
+  useMetadataEvent,
+  useMetadataState
+};
+//# sourceMappingURL=metadata.js.map

package/dist/metadata.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"metadata.js","sources":["../src/metadata.ts"],"sourcesContent":["/**\n * @embedpdf/vue/metadata: the Vue view of `@embedpdf/plugin-metadata`. The\n * plugin keeps the metadata live off the document's event stream, so the state\n * follows your own edits and other sessions' alike.\n *\n *   const metadata = useMetadata();\n *   const { metadata: fields, custom, status } = useMetadataState();\n *   await metadata.update({ title: 'New title' }); // resolves once the state shows it\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-metadata';\nimport { MetadataToken, metadataState } from '@embedpdf/plugin-metadata';\nimport type { MetadataCapability } from '@embedpdf/plugin-metadata';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent } from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/**\n * The metadata API (`update`, `custom.update`, `refresh`, `canUpdate`) of the\n * nearest `<DocumentScope>`'s document, else the active one. The object never\n * changes; outside a document every method throws `not-ready`.\n */\nexport function useMetadata(): MetadataCapability {\n  return useCapability(MetadataToken);\n}\n\n/**\n * The metadata's state as refs: the standard fields, your own fields and the\n * load state (the page's State table, declared once in `metadataState`). With\n * a selector, one ref for the value it picks, which updates only when that\n * value changes.\n */\nexport const useMetadataState = stateComposable(metadataState);\n\n/** Subscribe to one metadata event while the component lives: `useMetadataEvent((metadata) => metadata.onUpdated, handler)`. */\nexport function useMetadataEvent<Event>(\n  select: (metadata: MetadataCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(MetadataToken, select, handler);\n}\n"],"names":[],"mappings":";;;;AAuBO,SAAS,cAAkC;AAChD,SAAO,cAAc,aAAa;AACpC;AAQO,MAAM,mBAAmB,gBAAgB,aAAa;AAGtD,SAAS,iBACd,QACA,SACM;AACN,qBAAmB,eAAe,QAAQ,OAAO;AACnD;"}

package/dist/outline.cjs

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginOutline = require("@embedpdf/plugin-outline");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function useOutline() {
+  return capabilities.useCapability(pluginOutline.OutlineToken);
+}
+const useOutlineState = state.stateComposable(pluginOutline.outlineState);
+function useOutlineEvent(select, handler) {
+  capabilities.useCapabilityEvent(pluginOutline.OutlineToken, select, handler);
+}
+exports.useOutline = useOutline;
+exports.useOutlineEvent = useOutlineEvent;
+exports.useOutlineState = useOutlineState;
+Object.keys(pluginOutline).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginOutline[k]
+  });
+});
+//# sourceMappingURL=outline.cjs.map

package/dist/outline.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"outline.cjs","sources":["../src/outline.ts"],"sourcesContent":["/**\n * @embedpdf/vue/outline: the Vue view of `@embedpdf/plugin-outline`. Reading\n * the state reads the outline; the plugin keeps it live off the document's\n * event stream, and shows your own edits at once.\n *\n *   const outline = useOutline();\n *   const { rows, current, canEdit } = useOutlineState();\n *   outline.activate(row.item.ref); // goes where the item goes, as a click does\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-outline';\nimport { OutlineToken, outlineState } from '@embedpdf/plugin-outline';\nimport type { OutlineCapability } from '@embedpdf/plugin-outline';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent } from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/**\n * The outline API (expand, select, activate, create, update, move, delete) of\n * the nearest `<DocumentScope>`'s document, else the active one. The object\n * never changes; outside a document every method throws `not-ready`.\n */\nexport function useOutline(): OutlineCapability {\n  return useCapability(OutlineToken);\n}\n\n/**\n * The outline's state as refs: its items, the rows a tree view shows, the item\n * for where the view is reading, the selection, the load state and whether you\n * may edit it (the page's State table, declared once in `outlineState`). With\n * a selector, one ref for the value it picks, which updates only when that\n * value changes.\n */\nexport const useOutlineState = stateComposable(outlineState);\n\n/** Subscribe to one outline event while the component lives: `useOutlineEvent((outline) => outline.onChanged, handler)`. */\nexport function useOutlineEvent<Event>(\n  select: (outline: OutlineCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(OutlineToken, select, handler);\n}\n"],"names":["useCapability","OutlineToken","stateComposable","outlineState","useCapabilityEvent"],"mappings":";;;;;AAuBO,SAAS,aAAgC;AAC9C,SAAOA,aAAAA,cAAcC,cAAAA,YAAY;AACnC;AASO,MAAM,kBAAkBC,MAAAA,gBAAgBC,cAAAA,YAAY;AAGpD,SAAS,gBACd,QACA,SACM;AACNC,kCAAmBH,cAAAA,cAAc,QAAQ,OAAO;AAClD;;;;;;;;;;"}

package/dist/outline.d.cts

@@ -0,0 +1,36 @@
+/**
+ * @embedpdf/vue/outline: the Vue view of `@embedpdf/plugin-outline`. Reading
+ * the state reads the outline; the plugin keeps it live off the document's
+ * event stream, and shows your own edits at once.
+ *
+ *   const outline = useOutline();
+ *   const { rows, current, canEdit } = useOutlineState();
+ *   outline.activate(row.item.ref); // goes where the item goes, as a click does
+ */
+export * from '@embedpdf/plugin-outline';
+import type { OutlineCapability } from '@embedpdf/plugin-outline';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The outline API (expand, select, activate, create, update, move, delete) of
+ * the nearest `<DocumentScope>`'s document, else the active one. The object
+ * never changes; outside a document every method throws `not-ready`.
+ */
+export declare function useOutline(): OutlineCapability;
+/**
+ * The outline's state as refs: its items, the rows a tree view shows, the item
+ * for where the view is reading, the selection, the load state and whether you
+ * may edit it (the page's State table, declared once in `outlineState`). With
+ * a selector, one ref for the value it picks, which updates only when that
+ * value changes.
+ */
+export declare const useOutlineState: import("./state.cjs").StateComposable<{
+    items: readonly import("@embedpdf/plugin-outline").OutlineItem<import("@embedpdf/core").PageDestination>[];
+    rows: readonly import("@embedpdf/plugin-outline").OutlineRow[];
+    current: import("@embedpdf/plugin-outline").OutlineItemRef | null;
+    selected: readonly import("@embedpdf/plugin-outline").OutlineItemRef[];
+    status: import("@embedpdf/core").ResourceStatus;
+    incomplete: boolean;
+    canEdit: boolean;
+}>;
+/** Subscribe to one outline event while the component lives: `useOutlineEvent((outline) => outline.onChanged, handler)`. */
+export declare function useOutlineEvent<Event>(select: (outline: OutlineCapability) => EventHook<Event>, handler: (event: Event) => void): void;

package/dist/outline.d.ts

@@ -0,0 +1,36 @@
+/**
+ * @embedpdf/vue/outline: the Vue view of `@embedpdf/plugin-outline`. Reading
+ * the state reads the outline; the plugin keeps it live off the document's
+ * event stream, and shows your own edits at once.
+ *
+ *   const outline = useOutline();
+ *   const { rows, current, canEdit } = useOutlineState();
+ *   outline.activate(row.item.ref); // goes where the item goes, as a click does
+ */
+export * from '@embedpdf/plugin-outline';
+import type { OutlineCapability } from '@embedpdf/plugin-outline';
+import type { EventHook } from '@embedpdf/core';
+/**
+ * The outline API (expand, select, activate, create, update, move, delete) of
+ * the nearest `<DocumentScope>`'s document, else the active one. The object
+ * never changes; outside a document every method throws `not-ready`.
+ */
+export declare function useOutline(): OutlineCapability;
+/**
+ * The outline's state as refs: its items, the rows a tree view shows, the item
+ * for where the view is reading, the selection, the load state and whether you
+ * may edit it (the page's State table, declared once in `outlineState`). With
+ * a selector, one ref for the value it picks, which updates only when that
+ * value changes.
+ */
+export declare const useOutlineState: import("./state.js").StateComposable<{
+    items: readonly import("@embedpdf/plugin-outline").OutlineItem<import("@embedpdf/core").PageDestination>[];
+    rows: readonly import("@embedpdf/plugin-outline").OutlineRow[];
+    current: import("@embedpdf/plugin-outline").OutlineItemRef | null;
+    selected: readonly import("@embedpdf/plugin-outline").OutlineItemRef[];
+    status: import("@embedpdf/core").ResourceStatus;
+    incomplete: boolean;
+    canEdit: boolean;
+}>;
+/** Subscribe to one outline event while the component lives: `useOutlineEvent((outline) => outline.onChanged, handler)`. */
+export declare function useOutlineEvent<Event>(select: (outline: OutlineCapability) => EventHook<Event>, handler: (event: Event) => void): void;

package/dist/outline.js

@@ -0,0 +1,17 @@
+import { OutlineToken, outlineState } from "@embedpdf/plugin-outline";
+export * from "@embedpdf/plugin-outline";
+import { a as useCapability, b as useCapabilityEvent } from "./capabilities-C7YzgPCX.js";
+import { a as stateComposable } from "./state-DZg8q3v6.js";
+function useOutline() {
+  return useCapability(OutlineToken);
+}
+const useOutlineState = stateComposable(outlineState);
+function useOutlineEvent(select, handler) {
+  useCapabilityEvent(OutlineToken, select, handler);
+}
+export {
+  useOutline,
+  useOutlineEvent,
+  useOutlineState
+};
+//# sourceMappingURL=outline.js.map

package/dist/outline.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"outline.js","sources":["../src/outline.ts"],"sourcesContent":["/**\n * @embedpdf/vue/outline: the Vue view of `@embedpdf/plugin-outline`. Reading\n * the state reads the outline; the plugin keeps it live off the document's\n * event stream, and shows your own edits at once.\n *\n *   const outline = useOutline();\n *   const { rows, current, canEdit } = useOutlineState();\n *   outline.activate(row.item.ref); // goes where the item goes, as a click does\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-outline';\nimport { OutlineToken, outlineState } from '@embedpdf/plugin-outline';\nimport type { OutlineCapability } from '@embedpdf/plugin-outline';\nimport type { EventHook } from '@embedpdf/core';\nimport { useCapability, useCapabilityEvent } from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/**\n * The outline API (expand, select, activate, create, update, move, delete) of\n * the nearest `<DocumentScope>`'s document, else the active one. The object\n * never changes; outside a document every method throws `not-ready`.\n */\nexport function useOutline(): OutlineCapability {\n  return useCapability(OutlineToken);\n}\n\n/**\n * The outline's state as refs: its items, the rows a tree view shows, the item\n * for where the view is reading, the selection, the load state and whether you\n * may edit it (the page's State table, declared once in `outlineState`). With\n * a selector, one ref for the value it picks, which updates only when that\n * value changes.\n */\nexport const useOutlineState = stateComposable(outlineState);\n\n/** Subscribe to one outline event while the component lives: `useOutlineEvent((outline) => outline.onChanged, handler)`. */\nexport function useOutlineEvent<Event>(\n  select: (outline: OutlineCapability) => EventHook<Event>,\n  handler: (event: Event) => void,\n): void {\n  useCapabilityEvent(OutlineToken, select, handler);\n}\n"],"names":[],"mappings":";;;;AAuBO,SAAS,aAAgC;AAC9C,SAAO,cAAc,YAAY;AACnC;AASO,MAAM,kBAAkB,gBAAgB,YAAY;AAGpD,SAAS,gBACd,QACA,SACM;AACN,qBAAmB,cAAc,QAAQ,OAAO;AAClD;"}

package/dist/page-D9XIuLSj.js

@@ -0,0 +1,16 @@
+import { inject, provide } from "vue";
+import "@embedpdf/web";
+const PageKey = Symbol("embedpdf page");
+function providePage(page) {
+  provide(PageKey, page);
+}
+function usePage() {
+  const page = inject(PageKey, null);
+  if (!page) throw new Error("usePage must be used inside a <Stage> page");
+  return page;
+}
+export {
+  providePage as p,
+  usePage as u
+};
+//# sourceMappingURL=page-D9XIuLSj.js.map

package/dist/page-D9XIuLSj.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-D9XIuLSj.js","sources":["../src/runtime/page.ts"],"sourcesContent":["/**\n * The page context: the seam between a page surface and its layers. A layer\n * depends only on this, never on the Stage, so the same layer works inside a\n * virtualized `<Stage>` page and on a standalone page surface. The surface\n * provides it as a ref that changes when the page's geometry does.\n */\nimport { inject, provide } from 'vue';\nimport type { InjectionKey, Ref } from 'vue';\n// Pure coordinate math from the geometry base, not from stage-core: the page\n// context stays stage-agnostic.\nimport type { PageTransform } from '@embedpdf/core-geometry';\nimport type { PageViewDemand } from '@embedpdf/plugin-render/contract';\nimport type { PageContext } from '@embedpdf/web';\n\n// Built by `makePageContext` from `@embedpdf/web`, shared with every framework.\nexport { makePageContext } from '@embedpdf/web';\n\n/** The page context. Its members are documented on `PageContext` in `@embedpdf/web`. */\nexport type PageContextValue = PageContext<PageTransform, PageViewDemand>;\n\nconst PageKey: InjectionKey<Readonly<Ref<PageContextValue>>> = Symbol('embedpdf page');\n\n/** Installed by page surfaces (`<Stage>` pages), not by app code. */\nexport function providePage(page: Readonly<Ref<PageContextValue>>): void {\n  provide(PageKey, page);\n}\n\n/**\n * The page this component is drawn on, as a ref: inside a `<Stage>`'s\n * `#page` or `#page-chrome` slot. The ref is the same for the page's life;\n * its value changes when the page's geometry does (a zoom, a rotation).\n */\nexport function usePage(): Readonly<Ref<PageContextValue>> {\n  const page = inject(PageKey, null);\n  if (!page) throw new Error('usePage must be used inside a <Stage> page');\n  return page;\n}\n"],"names":[],"mappings":";;AAoBA,MAAM,UAAyD,OAAO,eAAe;AAG9E,SAAS,YAAY,MAA6C;AACvE,UAAQ,SAAS,IAAI;AACvB;AAOO,SAAS,UAA2C;AACzD,QAAM,OAAO,OAAO,SAAS,IAAI;AACjC,MAAI,CAAC,KAAM,OAAM,IAAI,MAAM,4CAA4C;AACvE,SAAO;AACT;"}

package/dist/page-Doy4_Sdz.cjs

@@ -0,0 +1,15 @@
+"use strict";
+const vue = require("vue");
+require("@embedpdf/web");
+const PageKey = Symbol("embedpdf page");
+function providePage(page) {
+  vue.provide(PageKey, page);
+}
+function usePage() {
+  const page = vue.inject(PageKey, null);
+  if (!page) throw new Error("usePage must be used inside a <Stage> page");
+  return page;
+}
+exports.providePage = providePage;
+exports.usePage = usePage;
+//# sourceMappingURL=page-Doy4_Sdz.cjs.map

package/dist/page-Doy4_Sdz.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-Doy4_Sdz.cjs","sources":["../src/runtime/page.ts"],"sourcesContent":["/**\n * The page context: the seam between a page surface and its layers. A layer\n * depends only on this, never on the Stage, so the same layer works inside a\n * virtualized `<Stage>` page and on a standalone page surface. The surface\n * provides it as a ref that changes when the page's geometry does.\n */\nimport { inject, provide } from 'vue';\nimport type { InjectionKey, Ref } from 'vue';\n// Pure coordinate math from the geometry base, not from stage-core: the page\n// context stays stage-agnostic.\nimport type { PageTransform } from '@embedpdf/core-geometry';\nimport type { PageViewDemand } from '@embedpdf/plugin-render/contract';\nimport type { PageContext } from '@embedpdf/web';\n\n// Built by `makePageContext` from `@embedpdf/web`, shared with every framework.\nexport { makePageContext } from '@embedpdf/web';\n\n/** The page context. Its members are documented on `PageContext` in `@embedpdf/web`. */\nexport type PageContextValue = PageContext<PageTransform, PageViewDemand>;\n\nconst PageKey: InjectionKey<Readonly<Ref<PageContextValue>>> = Symbol('embedpdf page');\n\n/** Installed by page surfaces (`<Stage>` pages), not by app code. */\nexport function providePage(page: Readonly<Ref<PageContextValue>>): void {\n  provide(PageKey, page);\n}\n\n/**\n * The page this component is drawn on, as a ref: inside a `<Stage>`'s\n * `#page` or `#page-chrome` slot. The ref is the same for the page's life;\n * its value changes when the page's geometry does (a zoom, a rotation).\n */\nexport function usePage(): Readonly<Ref<PageContextValue>> {\n  const page = inject(PageKey, null);\n  if (!page) throw new Error('usePage must be used inside a <Stage> page');\n  return page;\n}\n"],"names":["provide","inject"],"mappings":";;;AAoBA,MAAM,UAAyD,OAAO,eAAe;AAG9E,SAAS,YAAY,MAA6C;AACvEA,MAAAA,QAAQ,SAAS,IAAI;AACvB;AAOO,SAAS,UAA2C;AACzD,QAAM,OAAOC,IAAAA,OAAO,SAAS,IAAI;AACjC,MAAI,CAAC,KAAM,OAAM,IAAI,MAAM,4CAA4C;AACvE,SAAO;AACT;;;"}

package/dist/page-edit.cjs

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const pluginPageEdit = require("@embedpdf/plugin-page-edit");
+const capabilities = require("./capabilities-DVNJmgy7.cjs");
+const state = require("./state-M22NDJQo.cjs");
+function usePageEdit() {
+  return capabilities.useCapability(pluginPageEdit.PageEditToken);
+}
+const usePageEditState = state.stateComposable(pluginPageEdit.pageEditState);
+exports.usePageEdit = usePageEdit;
+exports.usePageEditState = usePageEditState;
+Object.keys(pluginPageEdit).forEach((k) => {
+  if (k !== "default" && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: () => pluginPageEdit[k]
+  });
+});
+//# sourceMappingURL=page-edit.cjs.map

package/dist/page-edit.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-edit.cjs","sources":["../src/page-edit.ts"],"sourcesContent":["/**\n * @embedpdf/vue/page-edit: the Vue view of `@embedpdf/plugin-page-edit`. The\n * plugin turns a page relative to its rotation and resolves positions, so\n * this entry is the binding only:\n *\n *   const pageEdit = usePageEdit();\n *   const { selected, canEdit } = usePageEditState();\n *   await pageEdit.rotateBy(selected.value, 90);\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-page-edit';\nimport { PageEditToken, pageEditState } from '@embedpdf/plugin-page-edit';\nimport type { PageEditCapability } from '@embedpdf/plugin-page-edit';\nimport { useCapability } from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/**\n * The page edits of the nearest `<DocumentScope>`'s document, else the active\n * one. The object never changes; outside a document every method throws\n * `not-ready`. The pages themselves come from `usePageList()`.\n */\nexport function usePageEdit(): PageEditCapability {\n  return useCapability(PageEditToken);\n}\n\n/**\n * The page edits' state as refs: the selected pages and whether you may edit\n * and copy pages (the page's State table, declared once in `pageEditState`).\n * With a selector, one ref for the value it picks, which updates only when\n * that value changes.\n */\nexport const usePageEditState = stateComposable(pageEditState);\n"],"names":["useCapability","PageEditToken","stateComposable","pageEditState"],"mappings":";;;;;AAsBO,SAAS,cAAkC;AAChD,SAAOA,aAAAA,cAAcC,eAAAA,aAAa;AACpC;AAQO,MAAM,mBAAmBC,MAAAA,gBAAgBC,eAAAA,aAAa;;;;;;;;;"}

package/dist/page-edit.d.cts

@@ -0,0 +1,28 @@
+/**
+ * @embedpdf/vue/page-edit: the Vue view of `@embedpdf/plugin-page-edit`. The
+ * plugin turns a page relative to its rotation and resolves positions, so
+ * this entry is the binding only:
+ *
+ *   const pageEdit = usePageEdit();
+ *   const { selected, canEdit } = usePageEditState();
+ *   await pageEdit.rotateBy(selected.value, 90);
+ */
+export * from '@embedpdf/plugin-page-edit';
+import type { PageEditCapability } from '@embedpdf/plugin-page-edit';
+/**
+ * The page edits of the nearest `<DocumentScope>`'s document, else the active
+ * one. The object never changes; outside a document every method throws
+ * `not-ready`. The pages themselves come from `usePageList()`.
+ */
+export declare function usePageEdit(): PageEditCapability;
+/**
+ * The page edits' state as refs: the selected pages and whether you may edit
+ * and copy pages (the page's State table, declared once in `pageEditState`).
+ * With a selector, one ref for the value it picks, which updates only when
+ * that value changes.
+ */
+export declare const usePageEditState: import("./state.cjs").StateComposable<{
+    selected: readonly import("@embedpdf/core").PageRef[];
+    canEdit: boolean;
+    canExtract: boolean;
+}>;

package/dist/page-edit.d.ts

@@ -0,0 +1,28 @@
+/**
+ * @embedpdf/vue/page-edit: the Vue view of `@embedpdf/plugin-page-edit`. The
+ * plugin turns a page relative to its rotation and resolves positions, so
+ * this entry is the binding only:
+ *
+ *   const pageEdit = usePageEdit();
+ *   const { selected, canEdit } = usePageEditState();
+ *   await pageEdit.rotateBy(selected.value, 90);
+ */
+export * from '@embedpdf/plugin-page-edit';
+import type { PageEditCapability } from '@embedpdf/plugin-page-edit';
+/**
+ * The page edits of the nearest `<DocumentScope>`'s document, else the active
+ * one. The object never changes; outside a document every method throws
+ * `not-ready`. The pages themselves come from `usePageList()`.
+ */
+export declare function usePageEdit(): PageEditCapability;
+/**
+ * The page edits' state as refs: the selected pages and whether you may edit
+ * and copy pages (the page's State table, declared once in `pageEditState`).
+ * With a selector, one ref for the value it picks, which updates only when
+ * that value changes.
+ */
+export declare const usePageEditState: import("./state.js").StateComposable<{
+    selected: readonly import("@embedpdf/core").PageRef[];
+    canEdit: boolean;
+    canExtract: boolean;
+}>;

package/dist/page-edit.js

@@ -0,0 +1,13 @@
+import { PageEditToken, pageEditState } from "@embedpdf/plugin-page-edit";
+export * from "@embedpdf/plugin-page-edit";
+import { a as useCapability } from "./capabilities-C7YzgPCX.js";
+import { a as stateComposable } from "./state-DZg8q3v6.js";
+function usePageEdit() {
+  return useCapability(PageEditToken);
+}
+const usePageEditState = stateComposable(pageEditState);
+export {
+  usePageEdit,
+  usePageEditState
+};
+//# sourceMappingURL=page-edit.js.map

package/dist/page-edit.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"page-edit.js","sources":["../src/page-edit.ts"],"sourcesContent":["/**\n * @embedpdf/vue/page-edit: the Vue view of `@embedpdf/plugin-page-edit`. The\n * plugin turns a page relative to its rotation and resolves positions, so\n * this entry is the binding only:\n *\n *   const pageEdit = usePageEdit();\n *   const { selected, canEdit } = usePageEditState();\n *   await pageEdit.rotateBy(selected.value, 90);\n */\n\n// One line per feature: registration travels with the UI.\nexport * from '@embedpdf/plugin-page-edit';\nimport { PageEditToken, pageEditState } from '@embedpdf/plugin-page-edit';\nimport type { PageEditCapability } from '@embedpdf/plugin-page-edit';\nimport { useCapability } from './runtime/capabilities';\nimport { stateComposable } from './state';\n\n/**\n * The page edits of the nearest `<DocumentScope>`'s document, else the active\n * one. The object never changes; outside a document every method throws\n * `not-ready`. The pages themselves come from `usePageList()`.\n */\nexport function usePageEdit(): PageEditCapability {\n  return useCapability(PageEditToken);\n}\n\n/**\n * The page edits' state as refs: the selected pages and whether you may edit\n * and copy pages (the page's State table, declared once in `pageEditState`).\n * With a selector, one ref for the value it picks, which updates only when\n * that value changes.\n */\nexport const usePageEditState = stateComposable(pageEditState);\n"],"names":[],"mappings":";;;;AAsBO,SAAS,cAAkC;AAChD,SAAO,cAAc,aAAa;AACpC;AAQO,MAAM,mBAAmB,gBAAgB,aAAa;"}