@xtctwins/tctwins-pdf-core 0.1.0

package/dist/pdf-core.js

@@ -0,0 +1,1308 @@
+import * as e from "pdfjs-dist";
+import { computed as t, createElementBlock as n, createElementVNode as r, defineComponent as i, nextTick as a, normalizeStyle as o, onBeforeUnmount as s, onMounted as c, openBlock as l, ref as u, shallowRef as d, unref as f, watch as p } from "vue";
+//#region src/core/PDFLoader.ts
+function m(t) {
+	t && (e.GlobalWorkerOptions.workerSrc = t);
+}
+function h(t = "/pdf.worker.min.mjs") {
+	e.GlobalWorkerOptions.workerSrc = t, fetch(t, { method: "HEAD" }).catch(() => {
+		e.GlobalWorkerOptions.workerSrc = "https://unpkg.com/pdfjs-dist@5.7.284/legacy/build/pdf.worker.min.mjs";
+	});
+}
+async function g(t, n = {}) {
+	let r = t instanceof File ? await t.arrayBuffer() : t, i = r.slice(0);
+	n.workerSrc && m(n.workerSrc);
+	let a = await e.getDocument({ data: i }).promise;
+	return {
+		arrayBuffer: r,
+		doc: a,
+		pageCount: a.numPages
+	};
+}
+//#endregion
+//#region src/core/TileCache.ts
+var _ = class e {
+	constructor(e = 100) {
+		this.cache = /* @__PURE__ */ new Map(), this.capacity = e;
+	}
+	static quantizeScale(e) {
+		return Math.round(e * 4) / 4;
+	}
+	static makeKey(t, n, r, i) {
+		return `${t}-${e.quantizeScale(n)}-${r}-${i}`;
+	}
+	get(e) {
+		if (!this.cache.has(e)) return null;
+		let t = this.cache.get(e);
+		return this.cache.delete(e), this.cache.set(e, t), t;
+	}
+	set(e, t) {
+		if (this.cache.has(e)) this.cache.delete(e);
+		else if (this.cache.size >= this.capacity) {
+			let e = this.cache.keys().next().value;
+			if (e === void 0) return;
+			let t = this.cache.get(e);
+			t.width = 0, t.height = 0, this.cache.delete(e);
+		}
+		this.cache.set(e, t);
+	}
+	has(e) {
+		return this.cache.has(e);
+	}
+	clear() {
+		this.cache.forEach((e) => {
+			e.width = 0, e.height = 0;
+		}), this.cache.clear();
+	}
+	get size() {
+		return this.cache.size;
+	}
+};
+//#endregion
+//#region src/core/TileRenderer.ts
+function v(e) {
+	return e >= 32 ? 1 : e >= 8 ? Math.min(window.devicePixelRatio, 1.5) : window.devicePixelRatio;
+}
+var y = 16384, b = 256;
+async function x(e, t = {}) {
+	let n = t.scale ?? 1.5, r = t.tileSize ?? 4096;
+	t.cache;
+	let i = t.backgroundColor ?? "rgb(255,255,255)", a = v(n), o = e.getViewport({ scale: n * a }), s = o.width, c = o.height, l = Math.ceil(s / r), u = Math.ceil(c / r), d = l * u;
+	d > b && console.warn(`[PDF-CORE] 缩放比例较大 (scale=${n})，共 ${d} 个 tile（${l}×${u}），IntersectionObserver 将仅渲染可见区域。建议降低缩放比例以获得更好体验。`);
+	let f = Math.round(Math.min(r, Math.max(s, c)));
+	if (f > y) {
+		console.warn(`[PDF-CORE] 缩放比例过大 (scale=${n})，单个 tile canvas 将达到 ${f}px，超过浏览器安全上限 ${y}px。已自动将 tileSize 缩小至安全范围。`);
+		let i = Math.min(r, Math.floor(y * .9));
+		return x(e, {
+			...t,
+			tileSize: i
+		});
+	}
+	let p = document.createElement("div");
+	p.style.cssText = `position:relative; width:${s / a}px; height:${c / a}px; overflow:hidden; background:${i};`;
+	let m = /* @__PURE__ */ new Set(), h = /* @__PURE__ */ new Set(), g = new IntersectionObserver((t) => {
+		t.forEach((t) => {
+			let o = t.target;
+			if (t.isIntersecting) {
+				let t = o.dataset.tileKey;
+				if (m.has(t) || h.has(t)) return;
+				h.add(t);
+				let [s, c] = t.split(",").map(Number), l = s * r, u = c * r, d = e.getViewport({ scale: n * a }), f = o.getContext("2d");
+				f.setTransform(1, 0, 0, 1, 0, 0), f.translate(-l, -u), e.render({
+					canvas: o,
+					canvasContext: f,
+					viewport: d,
+					background: i
+				}).promise.then(() => {
+					m.add(t), h.delete(t);
+				}).catch(() => {
+					h.delete(t);
+				});
+			} else {
+				let e = o.dataset.tileKey;
+				n > 8 && m.has(e) && (o.getContext("2d").clearRect(0, 0, o.width, o.height), m.delete(e));
+			}
+		});
+	}, {
+		root: null,
+		rootMargin: "512px",
+		threshold: 0
+	}), _ = [];
+	for (let e = 0; e < u; e++) for (let t = 0; t < l; t++) {
+		let n = t * r, o = e * r, l = Math.min(r, s - n), u = Math.min(r, c - o), d = document.createElement("canvas");
+		d.width = Math.round(l), d.height = Math.round(u), d.style.cssText = `position:absolute; left:${n / a}px; top:${o / a}px; width:${l / a}px; height:${u / a}px; background:${i};`, d.dataset.tileKey = `${t},${e}`, p.appendChild(d), g.observe(d), _.push({
+			canvas: d,
+			col: t,
+			row: e,
+			x: n,
+			y: o,
+			cssWidth: l,
+			cssHeight: u
+		});
+	}
+	return {
+		tiledPage: {
+			container: p,
+			pageWidth: s / a,
+			pageHeight: c / a,
+			tiles: _
+		},
+		observer: g
+	};
+}
+//#endregion
+//#region src/core/coords/CoordTransformer.ts
+var S = class {
+	constructor(e, t, n) {
+		if (this.viewport = e, this.scale = t, this.pageSizePt = n, t <= 0) throw RangeError(`scale 必须大于 0，收到: ${t}`);
+	}
+	pageToScreen(e, t) {
+		let [n, r] = typeof e == "object" ? [e.x, e.y] : [e, t], [i, a] = this.viewport.convertToViewportPoint(n, r);
+		return {
+			x: i * this.scale,
+			y: a * this.scale
+		};
+	}
+	screenToPage(e, t) {
+		let [n, r] = typeof e == "object" ? [e.x, e.y] : [e, t], [i, a] = this.viewport.convertToPdfPoint(n / this.scale, r / this.scale);
+		return {
+			x: i,
+			y: a
+		};
+	}
+	pagePointToPdfLib(e) {
+		return {
+			x: e.x,
+			y: e.y
+		};
+	}
+	pdfLibToPagePoint(e) {
+		return {
+			x: e.x,
+			y: e.y
+		};
+	}
+	screenToPdfLib(e, t) {
+		let n = typeof e == "object" ? e : {
+			x: e,
+			y: t
+		};
+		return this.pagePointToPdfLib(this.screenToPage(n));
+	}
+	pdfLibToScreen(e) {
+		return this.pageToScreen(this.pdfLibToPagePoint(e));
+	}
+	get currentScale() {
+		return this.scale;
+	}
+	get pageSize() {
+		return this.pageSizePt;
+	}
+}, C = [
+	5,
+	10,
+	25,
+	33,
+	50,
+	67,
+	75,
+	100,
+	125,
+	150,
+	200,
+	300,
+	400,
+	600,
+	800,
+	1200,
+	1600,
+	2400,
+	3200
+];
+function w(e, t) {
+	return t === "in" ? C.find((t) => t > e) ?? C[C.length - 1] : [...C].reverse().find((t) => t < e) ?? C[0];
+}
+var T = class {
+	constructor() {
+		this.interaction = null, this.toolManager = null, this.drawCallback = null, this.domContainerId = null, this.zoomCtrl = null, this.initialScale = 1.5;
+	}
+	register(e, t, n, r) {
+		this.interaction = e, this.drawCallback = t, this.zoomCtrl = n ?? null, this.domContainerId = r ?? null, n && (this.initialScale = n.getScale());
+	}
+	registerWithToolManager(e, t, n, r) {
+		this.toolManager = e, this.drawCallback = t, this.zoomCtrl = n ?? null, this.domContainerId = r ?? null, n && (this.initialScale = n.getScale());
+	}
+	unregister() {
+		this.interaction = null, this.toolManager = null, this.drawCallback = null, this.zoomCtrl = null, this.domContainerId = null;
+	}
+	setMeasureMode() {
+		if (this.toolManager) {
+			this.toolManager.setMode("measure"), this.drawCallback?.();
+			return;
+		}
+		this.interaction?.setMode("measure"), this.drawCallback?.();
+	}
+	setMeasureSubType(e) {
+		this.toolManager?.measureTool.setSubType(e);
+	}
+	setRectangleMode() {
+		this.interaction?.setMode("rectangle"), this.drawCallback?.();
+	}
+	cancelTool() {
+		if (this.toolManager) {
+			this.toolManager.setMode("none"), this.drawCallback?.();
+			return;
+		}
+		this.interaction?.setMode("none"), this.drawCallback?.();
+	}
+	getMode() {
+		return this.toolManager?.activeMode ?? this.interaction?.mode ?? "none";
+	}
+	zoomIn() {
+		if (!this.zoomCtrl) return;
+		let e = this.zoomCtrl.getScale(), t = w(Math.round(e * 100), "in");
+		this.zoomCtrl.setScale(t / 100);
+	}
+	zoomOut() {
+		if (!this.zoomCtrl) return;
+		let e = this.zoomCtrl.getScale(), t = w(Math.round(e * 100), "out");
+		this.zoomCtrl.setScale(t / 100);
+	}
+	setScale(e) {
+		this.zoomCtrl?.setScale(e);
+	}
+	getScale() {
+		return this.zoomCtrl?.getScale() ?? 1;
+	}
+	getScalePercent() {
+		return Math.round((this.zoomCtrl?.getScale() ?? 1) * 100);
+	}
+	resetView() {
+		this.zoomCtrl && this.zoomCtrl.setScale(this.initialScale);
+		let e = this.zoomCtrl?.getContainerEl();
+		e && (e.scrollTop = 0, e.scrollLeft = 0);
+	}
+	getAnnotations() {
+		return this.toolManager ? this.toolManager.measureTool.getResults().map((e) => ({
+			id: e.id,
+			kind: "measure",
+			points: e.points.map((e) => ({
+				x: e.x,
+				y: e.y
+			})),
+			value: e.value,
+			unit: e.unit,
+			label: e.label,
+			color: "#10b981",
+			strokeWidth: 2,
+			createdAt: e.createdAt
+		})) : this.interaction?.annotations ?? [];
+	}
+	clearAnnotations() {
+		this.toolManager?.measureTool.clearResults(), this.interaction?.clear(), this.drawCallback?.();
+	}
+	deleteSelectedAnnotation() {
+		this.interaction?.deleteSelectedAnnotation(), this.drawCallback?.();
+	}
+	selectAnnotation(e) {
+		this.interaction?.selectAnnotation(e), this.drawCallback?.();
+	}
+	getSelectedAnnotationId() {
+		return this.interaction?.selectedAnnotationId ?? null;
+	}
+	getToolManager() {
+		return this.toolManager;
+	}
+	getMeasureTool() {
+		return this.toolManager?.measureTool ?? null;
+	}
+	closeAll() {
+		this.toolManager?.setMode("none"), this.toolManager?.measureTool.clearResults(), this.interaction?.clear(), this.drawCallback?.();
+	}
+	getContainerId() {
+		return this.domContainerId;
+	}
+};
+//#endregion
+//#region src/annotations/utils.ts
+function E(e, t = 0, n = "px") {
+	return {
+		id: `measure-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+		kind: "measure",
+		points: e,
+		value: t,
+		unit: n,
+		color: "#3b82f6",
+		strokeWidth: 2,
+		createdAt: Date.now()
+	};
+}
+function D(e, t = "rectangle") {
+	return {
+		id: `shape-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`,
+		kind: "shape",
+		points: e,
+		shapeType: t,
+		color: "#ef4444",
+		strokeWidth: 2,
+		createdAt: Date.now()
+	};
+}
+function O(e) {
+	return JSON.parse(JSON.stringify(e));
+}
+//#endregion
+//#region src/utils/EventTrigger.ts
+var k = class {
+	constructor() {
+		this._events = /* @__PURE__ */ new Map();
+	}
+	on(e, t) {
+		let n = this._events.get(e);
+		return n ? n.push(t) : this._events.set(e, [t]), t;
+	}
+	once(e, t) {
+		let n = ((...r) => {
+			this.off(e, n), t(...r);
+		});
+		this.on(e, n);
+	}
+	off(e, t) {
+		let n = this._events.get(e);
+		if (n) {
+			let r = n.filter((e) => e !== t);
+			r.length === 0 ? this._events.delete(e) : this._events.set(e, r);
+		}
+	}
+	emit(e, ...t) {
+		let n = this._events.get(e);
+		if (n) for (let r of n) try {
+			r(...t);
+		} catch (t) {
+			console.error(`[EventTrigger] Error in event "${e}":`, t);
+		}
+	}
+	removeAllListeners(e) {
+		e ? this._events.delete(e) : this._events.clear();
+	}
+	listenerCount(e) {
+		return this._events.get(e)?.length ?? 0;
+	}
+	destroy() {
+		this._events.clear();
+	}
+};
+//#endregion
+//#region src/vue/usePdfCore.ts
+function A(e = {}) {
+	let t = u(null), n = d(null), r = d(null), i = u(0), a = u(1), o = u(e.scale ?? 1.5), s = e.backgroundColor ?? "rgb(255,255,255)", c = u(!1), l = u(null), f = new k(), p = new _(100), m = !1, h = null, v = null, y = null, b = null, S = async (e) => {
+		c.value = !0, l.value = null;
+		try {
+			let t = await g(e);
+			n.value = t.doc, i.value = t.pageCount, a.value = 1, await C(), f.emit("loaded", {
+				pageCount: t.pageCount,
+				currentPage: 1
+			});
+		} catch (e) {
+			let t = e instanceof Error ? e.message : "Failed to load PDF";
+			l.value = t, f.emit("error_occurred", { message: t });
+		} finally {
+			c.value = !1;
+		}
+	}, C = async () => {
+		if (!(!n.value || !t.value) && !m) {
+			m = !0;
+			try {
+				h &&= (h.disconnect(), null);
+				let e = await n.value.getPage(a.value);
+				r.value = e;
+				let { tiledPage: i, observer: c } = await x(e, {
+					scale: o.value,
+					cache: p,
+					backgroundColor: s
+				});
+				h = c, t.value.replaceChildren(i.container), f.emit("render_complete", {
+					pageNum: a.value,
+					scale: o.value
+				});
+			} catch (e) {
+				console.error("[PDF-CORE] renderCurrentPage failed:", e), f.emit("error_occurred", { message: e instanceof Error ? e.message : "Render failed" });
+			} finally {
+				m = !1;
+			}
+		}
+	};
+	return e.autoLoad, {
+		containerRef: t,
+		doc: n,
+		page: r,
+		pageCount: i,
+		currentPageNum: a,
+		currentScale: o,
+		isLoading: c,
+		error: l,
+		events: f,
+		loadFile: S,
+		renderCurrentPage: C,
+		setScale: (e) => new Promise((t) => {
+			if (e <= 0) {
+				t();
+				return;
+			}
+			y = e, v !== null && (clearTimeout(v), b?.()), b = t, v = setTimeout(async () => {
+				v = null;
+				let e = y, t = b;
+				if (y = null, b = null, e === null || e === o.value) {
+					t?.();
+					return;
+				}
+				o.value = e, n.value && await C(), t?.(), f.emit("scale_changed", {
+					scale: e,
+					previousScale: o.value
+				});
+			}, 60);
+		}),
+		reset: () => {
+			n.value = null, r.value = null, i.value = 0, a.value = 1, l.value = null, c.value = !1, t.value && t.value.replaceChildren(), f.emit("cleared");
+		}
+	};
+}
+//#endregion
+//#region src/vue/useAnnotations.ts
+function j() {
+	let e = u([]);
+	return {
+		annotations: e,
+		addMeasureAnnotation: (t, n = 0, r = "px") => {
+			e.value = [...e.value, E(t, n, r)];
+		},
+		addShapeAnnotation: (t, n = "rectangle") => {
+			e.value = [...e.value, D(t, n)];
+		},
+		removeAnnotation: (t) => {
+			e.value = e.value.filter((e) => e.id !== t);
+		},
+		clearAnnotations: () => {
+			e.value = [];
+		},
+		replaceAnnotations: (t) => {
+			e.value = t.map(O);
+		}
+	};
+}
+//#endregion
+//#region src/vue/useMeasurement.ts
+function M() {
+	let e = u([]);
+	return {
+		points: e,
+		addPoint: (t) => {
+			e.value = [...e.value, t];
+		},
+		clearPoints: () => {
+			e.value = [];
+		},
+		distance: t(() => {
+			if (e.value.length < 2) return 0;
+			let [t, n] = e.value.slice(-2);
+			return Math.hypot(n.x - t.x, n.y - t.y);
+		})
+	};
+}
+//#endregion
+//#region src/vue/useInteraction.ts
+function N() {
+	let { annotations: e, addMeasureAnnotation: t, clearAnnotations: n } = j(), { points: r, addPoint: i, clearPoints: a, distance: o } = M(), s = u(!1);
+	return {
+		points: r,
+		annotations: e,
+		isMeasuring: s,
+		startMeasure: () => {
+			s.value = !0, a();
+		},
+		addPoint: (e) => {
+			i(e), s.value && r.value.length >= 2 && t(r.value, o.value);
+		},
+		finishMeasure: (e) => {
+			r.value.length >= 2 && t(r.value, o.value, e || "px"), s.value = !1, a();
+		},
+		clear: () => {
+			n(), a(), s.value = !1;
+		}
+	};
+}
+//#endregion
+//#region src/components/interaction.ts
+function P() {
+	let e = [], t = [], n = "none", r = null;
+	return {
+		get points() {
+			return e;
+		},
+		get annotations() {
+			return t;
+		},
+		get mode() {
+			return n;
+		},
+		get selectedAnnotationId() {
+			return r;
+		},
+		setMode(t) {
+			n = t, t === "none" && (e = []);
+		},
+		addPoint(i) {
+			if (e = [...e, i], n === "measure" && e.length >= 2) {
+				let n = E([e[e.length - 2], e[e.length - 1]], Math.hypot(e[e.length - 1].x - e[e.length - 2].x, e[e.length - 1].y - e[e.length - 2].y));
+				return t = [...t, n], r = n.id, e = [], n;
+			}
+			if (n === "rectangle" && e.length >= 2) {
+				let n = D([e[e.length - 2], e[e.length - 1]], "rectangle");
+				return t = [...t, n], r = n.id, e = [], n;
+			}
+			return null;
+		},
+		selectAnnotation(e) {
+			r = e;
+		},
+		deleteAnnotation(e) {
+			let n = t.find((t) => t.id === e);
+			return n ? (t = t.filter((t) => t.id !== e), r === e && (r = null), n) : null;
+		},
+		deleteSelectedAnnotation() {
+			return r ? this.deleteAnnotation(r) : null;
+		},
+		clear() {
+			e = [], t = [], n = "none", r = null;
+		}
+	};
+}
+//#endregion
+//#region src/components/useAnnotationCanvas.ts
+function F(e) {
+	let { annotationCanvas: t, rootRef: n, interaction: r, previewPoint: i } = e, a = (e) => {
+		let t = e.currentTarget.getBoundingClientRect();
+		return {
+			x: e.clientX - t.left,
+			y: e.clientY - t.top
+		};
+	}, o = (e, t, n) => {
+		let r = n.x - t.x, i = n.y - t.y, a = r * r + i * i;
+		if (a === 0) return Math.hypot(e.x - t.x, e.y - t.y);
+		let o = Math.max(0, Math.min(1, ((e.x - t.x) * r + (e.y - t.y) * i) / a)), s = t.x + o * r, c = t.y + o * i;
+		return Math.hypot(e.x - s, e.y - c);
+	}, s = (e, t) => {
+		if (t.kind === "measure") {
+			let [n, r] = t.points;
+			return o(e, n, r) <= 8;
+		}
+		if (t.kind === "shape" && t.shapeType === "rectangle") {
+			let [n, r] = t.points, i = Math.min(n.x, r.x), a = Math.min(n.y, r.y), o = Math.abs(n.x - r.x), s = Math.abs(n.y - r.y);
+			return e.x >= i - 4 && e.x <= i + o + 4 && e.y >= a - 4 && e.y <= a + s + 4;
+		}
+		return !1;
+	}, c = () => {
+		if (!t.value) return;
+		let e = t.value.getContext("2d");
+		e && (e.clearRect(0, 0, t.value.width, t.value.height), r.annotations.forEach((t) => {
+			let n = t.id === r.selectedAnnotationId, i = t.color ?? (t.kind === "measure" ? "#10b981" : "#3b82f6"), a = (t.strokeWidth ?? 2) + (n ? 2 : 0);
+			t.kind === "measure" && l(e, t, n, i, a), t.kind === "shape" && t.shapeType === "rectangle" && u(e, t, n, i, a);
+		}), i.value && r.points.length === 1 && d(e));
+	}, l = (e, t, n, r, i) => {
+		let [a, o] = t.points;
+		e.save(), e.strokeStyle = n ? "#ef4444" : r, e.lineWidth = i, e.setLineDash(n ? [6, 4] : []), e.beginPath(), e.moveTo(a.x, a.y), e.lineTo(o.x, o.y), e.stroke(), e.setLineDash([]), e.fillStyle = n ? "#ef4444" : r, e.beginPath(), e.arc(a.x, a.y, n ? 4 : 3, 0, Math.PI * 2), e.arc(o.x, o.y, n ? 4 : 3, 0, Math.PI * 2), e.fill(), e.font = "12px sans-serif", e.fillText(t.label ?? `${t.value?.toFixed(1) ?? 0}`, o.x + 6, o.y - 6), e.restore();
+	}, u = (e, t, n, r, i) => {
+		let [a, o] = t.points, s = Math.min(a.x, o.x), c = Math.min(a.y, o.y), l = Math.abs(a.x - o.x), u = Math.abs(a.y - o.y);
+		e.save(), e.strokeStyle = n ? "#ef4444" : r, e.lineWidth = i, e.setLineDash(n ? [6, 4] : []), e.strokeRect(s, c, l, u), e.fillStyle = n ? "rgba(239, 68, 68, 0.12)" : "rgba(59, 130, 246, 0.12)", e.fillRect(s, c, l, u), e.setLineDash([]), e.fillStyle = n ? "#ef4444" : r, e.font = "12px sans-serif", e.fillText(t.label ?? "", s + 6, c + 16), e.restore();
+	}, d = (e) => {
+		let t = r.points[0], n = i.value;
+		if (e.save(), e.strokeStyle = r.mode === "measure" ? "#8b5cf6" : "#2563eb", e.lineWidth = 2, e.setLineDash([6, 4]), r.mode === "measure") e.beginPath(), e.moveTo(t.x, t.y), e.lineTo(n.x, n.y), e.stroke(), e.beginPath(), e.arc(t.x, t.y, 3, 0, Math.PI * 2), e.arc(n.x, n.y, 3, 0, Math.PI * 2), e.fillStyle = "#8b5cf6", e.fill();
+		else if (r.mode === "rectangle") {
+			let r = Math.min(t.x, n.x), i = Math.min(t.y, n.y), a = Math.abs(t.x - n.x), o = Math.abs(t.y - n.y);
+			e.strokeRect(r, i, a, o);
+		}
+		e.restore();
+	};
+	return {
+		getCanvasPoint: a,
+		getDistanceToSegment: o,
+		hitTestAnnotation: s,
+		drawAnnotations: c,
+		syncCanvasSize: () => {
+			if (!n.value || !t.value) return;
+			let e = n.value.getBoundingClientRect(), r = t.value;
+			r.width = e.width * window.devicePixelRatio, r.height = e.height * window.devicePixelRatio, r.style.width = `${e.width}px`, r.style.height = `${e.height}px`;
+			let i = r.getContext("2d");
+			i && i.setTransform(window.devicePixelRatio, 0, 0, window.devicePixelRatio, 0, 0);
+		}
+	};
+}
+//#endregion
+//#region src/components/usePointerInteraction.ts
+function I(e) {
+	let { annotationCanvas: t, interaction: n, previewPoint: r, isRectangleDragging: i, getCanvasPoint: a, hitTestAnnotation: o, drawAnnotations: s, deleteSelectedAnnotation: c, emit: l } = e;
+	return {
+		handlePointerDown: (e) => {
+			if (!t.value) return;
+			let c = a(e);
+			if (n.mode === "measure") {
+				if (n.points.length === 0) {
+					n.addPoint(c), r.value = c, s(), e.preventDefault();
+					return;
+				}
+				if (n.points.length === 1) {
+					let t = n.addPoint(c);
+					r.value = null, s(), t && l("annotation-added", {
+						id: t.id,
+						kind: t.kind
+					}), e.preventDefault();
+					return;
+				}
+			}
+			if (n.mode === "rectangle" && n.points.length === 0) {
+				n.addPoint(c), r.value = c, i.value = !0, s(), e.preventDefault();
+				return;
+			}
+			if (n.mode === "none") {
+				let e = n.annotations.find((e) => o(c, e));
+				if (e) {
+					n.selectAnnotation(e.id), s();
+					return;
+				}
+				n.selectAnnotation(null), s();
+			}
+		},
+		handlePointerMove: (e) => {
+			if (n.mode === "none" || !t.value || n.points.length !== 1) return;
+			let i = a(e);
+			r.value = i, s();
+		},
+		handlePointerUp: (e) => {
+			if (!t.value) return;
+			let c = a(e);
+			if (n.mode === "rectangle" && i.value && n.points.length === 1) {
+				let e = n.addPoint(c);
+				r.value = null, i.value = !1, s(), e && l("annotation-added", {
+					id: e.id,
+					kind: e.kind
+				});
+				return;
+			}
+			if (n.mode === "none") {
+				let e = n.annotations.find((e) => o(c, e));
+				if (e) {
+					n.selectAnnotation(e.id), s();
+					return;
+				}
+				n.selectAnnotation(null), s();
+			}
+		},
+		handleKeydown: (e) => {
+			(e.key === "Delete" || e.key === "Backspace") && n.selectedAnnotationId && (e.preventDefault(), c(), s());
+		}
+	};
+}
+//#endregion
+//#region src/components/useViewerLayout.ts
+var L = (e) => {
+	if (e.length < 2) return 0;
+	let t = e[0].clientX - e[1].clientX, n = e[0].clientY - e[1].clientY;
+	return Math.hypot(t, n);
+}, R = (e) => ({
+	x: (e[0].clientX + e[1].clientX) / 2,
+	y: (e[0].clientY + e[1].clientY) / 2
+}), z = (e) => {
+	let t = C[0], n = Math.abs(e - t);
+	for (let r = 1; r < C.length; r++) {
+		let i = Math.abs(e - C[r]);
+		i < n && (n = i, t = C[r]);
+	}
+	return t;
+};
+function B(e) {
+	let { viewerRef: n, rootRef: r, pdfLayerRef: i, currentScale: a, setScale: o, zoomSpeed: s, theme: c, syncCanvasSize: l, drawAnnotations: u } = e, d = 0, f = 1, p = null, m = 0;
+	return {
+		containerStyle: t(() => ({
+			width: "100%",
+			height: "100%",
+			background: c === "dark" ? "#1e1e1e" : "#ffffff",
+			overflow: "auto",
+			borderRadius: "8px",
+			border: c === "dark" ? "1px solid #374151" : "1px solid #e2e8f0",
+			position: "relative",
+			touchAction: "pan-x pan-y",
+			display: "flex"
+		})),
+		adjustLayout: (e = !1) => {
+			let t = n.value, a = r.value, o = i.value;
+			if (!t || !a || !o) return;
+			let s = t.clientWidth, c = t.clientHeight, d = o.scrollWidth || s, f = o.scrollHeight || c, p = Math.max(d, s * 1.5), m = Math.max(f, c * 1.5);
+			a.style.width = `${p}px`, a.style.height = `${m}px`, e && (t.scrollLeft = p - s, t.scrollTop = (m - c) / 2), l(), u();
+		},
+		handleWheel: (e) => {
+			e.preventDefault();
+			let t = n.value, c = r.value, l = i.value;
+			if (!t || !c || !l) return;
+			let u = e.deltaY < 0 ? "in" : "out", d = Math.max(1, s ?? 1), f = Math.round(a.value * 100);
+			for (let e = 0; e < d; e++) {
+				let e = w(f, u);
+				if (e === f) break;
+				f = e;
+			}
+			let p = f / 100;
+			if (p === a.value) return;
+			let m = a.value, h = p / m, g = t.getBoundingClientRect(), _ = e.clientX - g.left, v = e.clientY - g.top, y = _ + t.scrollLeft, b = v + t.scrollTop, x = l.scrollWidth, S = l.scrollHeight, C = x / m, T = S / m, E = C * p, D = T * p, O = t.clientWidth, k = t.clientHeight, A = y * h - _, j = b * h - v;
+			c.style.width = `${Math.max(E, A + O, O * 1.5)}px`, c.style.height = `${Math.max(D, j + k, k * 1.5)}px`, c.offsetWidth, t.scrollLeft = A, t.scrollTop = j, o(p);
+		},
+		handleTouchStart: (e) => {
+			e.touches.length === 2 && (d = L(e.touches), f = a.value, p = R(e.touches), m = a.value);
+		},
+		handleTouchMove: (e) => {
+			if (e.touches.length !== 2 || d === 0) return;
+			e.preventDefault();
+			let t = L(e.touches);
+			if (Math.abs(t - d) < 5) return;
+			let s = t / d, c = f * s, l = z(Math.round(Math.max(.05, Math.min(128, c)) * 100)) / 100;
+			if (l === m) return;
+			m = l;
+			let u = n.value;
+			if (u && p) {
+				let e = u.getBoundingClientRect(), t = p.x - e.left, n = p.y - e.top, s = t + u.scrollLeft, c = n + u.scrollTop, d = l / a.value, f = r.value, m = i.value;
+				if (f && m) {
+					let e = u.clientWidth, r = u.clientHeight, i = a.value, o = m.scrollWidth / i, p = m.scrollHeight / i, h = o * l, g = p * l, _ = s * d - t, v = c * d - n;
+					f.style.width = `${Math.max(h, _ + e, e * 1.5)}px`, f.style.height = `${Math.max(g, v + r, r * 1.5)}px`, f.offsetWidth;
+				}
+				u.scrollLeft = s * d - t, u.scrollTop = c * d - n, o(l);
+			}
+		},
+		handleTouchEnd: () => {
+			d = 0, p = null, m = 0;
+		}
+	};
+}
+//#endregion
+//#region src/types/tools.ts
+var V = {
+	mode: "none",
+	measureSubType: "distance"
+}, H = class {
+	constructor(e) {
+		this.TOOLNAME = "measure", this._active = !1, this._isStart = !1, this._isEnd = !1, this._isMeasuring = !1, this._isDragging = !1, this._startPoint = null, this._endPoint = null, this._points = [], this._measureList = /* @__PURE__ */ new Map(), this._dragStart = null, this._dragThreshold = 3, this.coordProvider = e.coordProvider, this.calibration = e.calibration ?? {
+			scale: 1,
+			unit: "px",
+			precision: 2
+		}, this.eventTrigger = e.eventTrigger;
+	}
+	getActive() {
+		return this._active;
+	}
+	setActive(e) {
+		this._active !== e && (this._active = e, !e && this._isStart && this.interrupt());
+	}
+	getScenePoint(e) {
+		return this.coordProvider.screenToScene(e);
+	}
+	distance(e, t) {
+		return Math.hypot(t.x - e.x, t.y - e.y);
+	}
+	calibrate(e) {
+		let { scale: t, unit: n, precision: r } = this.calibration, i = e * t, a = parseFloat(i.toFixed(typeof r == "number" ? r : 2));
+		return {
+			value: a,
+			label: `${a} ${n}`
+		};
+	}
+	generateId() {
+		return `${this.currentType}-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+	}
+	buildResult(e, t) {
+		let { value: n, label: r } = this.calibrate(t);
+		return {
+			id: this.generateId(),
+			type: this.currentType,
+			points: e,
+			value: n,
+			unit: this.calibration.unit,
+			label: r,
+			createdAt: Date.now()
+		};
+	}
+	isDrag(e) {
+		if (!this._dragStart) return !1;
+		let t = e.clientX - this._dragStart.x, n = e.clientY - this._dragStart.y;
+		return Math.hypot(t, n) > this._dragThreshold;
+	}
+	emitMeasureStart() {
+		let e = { type: this.currentType };
+		this.eventTrigger.emit("measure_start", e);
+	}
+	emitMeasureCreated(e) {
+		let t = {
+			id: e.id,
+			type: this.currentType,
+			points: e.points,
+			value: e.value,
+			unit: e.unit,
+			label: e.label,
+			result: e
+		};
+		this.eventTrigger.emit("measure_created", t);
+	}
+	emitMeasureCancel() {
+		let e = { type: this.currentType };
+		this.eventTrigger.emit("measure_cancel", e);
+	}
+	interrupt() {
+		let e = this._isStart;
+		this.resetState(), e && this.emitMeasureCancel();
+	}
+	finalize(e) {
+		if (this._points.length < 2) return null;
+		let t = this.buildResult([...this._points], e);
+		return this._measureList.set(t.id, {
+			points: [...this._points],
+			result: t
+		}), this.emitMeasureCreated(t), this.resetState(), t;
+	}
+	resetState() {
+		this._startPoint = null, this._endPoint = null, this._points = [], this._dragStart = null, this._isStart = !1, this._isEnd = !1, this._isMeasuring = !1, this._isDragging = !1;
+	}
+	destroy() {
+		this._measureList.clear(), this.resetState(), this._active = !1;
+	}
+}, U = class extends H {
+	constructor(e) {
+		super(e), this.currentType = "distance", this._previewEnd = null;
+	}
+	get previewEnd() {
+		return this._previewEnd;
+	}
+	onPointerDown(e) {
+		if (!this._active) return;
+		this._dragStart = {
+			x: e.clientX,
+			y: e.clientY
+		};
+		let t = this.getScenePoint(e);
+		if (!this._isStart) {
+			this._isStart = !0, this._startPoint = t, this._points = [t], this._previewEnd = null;
+			return;
+		}
+		this._isStart && !this._isEnd && (this._endPoint = t, this._points = [...this._points, t], this._isEnd = !0, this._isMeasuring = !0);
+	}
+	onPointerMove(e) {
+		if (this._active && !this._isEnd) {
+			if (this._isStart && !this._isMeasuring) {
+				if (this.isDrag(e)) {
+					this._isDragging = !0, this.interrupt();
+					return;
+				}
+				return;
+			}
+			this._isStart && this._isMeasuring && (this._previewEnd = this.getScenePoint(e));
+		}
+	}
+	onPointerUp(e) {
+		if (this._active) {
+			if (this._dragStart = null, this._isStart && !this._isMeasuring) {
+				this._isDragging || (this._isMeasuring = !0, this.emitMeasureStart()), this._isDragging = !1;
+				return;
+			}
+			if (this._isEnd && this._isMeasuring) {
+				let e = this._startPoint, t = this._endPoint;
+				if (Math.abs(t.x - e.x) < .01 && Math.abs(t.y - e.y) < .01) {
+					this.interrupt();
+					return;
+				}
+				let n = this.distance(e, t);
+				this.finalize(n), this._previewEnd = null;
+			}
+		}
+	}
+	interrupt() {
+		this._previewEnd = null, super.interrupt();
+	}
+}, W = class extends H {
+	constructor(e) {
+		super(e), this.currentType = "angle", this._secondPoint = null, this._thirdPoint = null;
+	}
+	onPointerDown(e) {
+		if (!this._active) return;
+		let t = this.getScenePoint(e);
+		if (!this._isStart) {
+			this._isStart = !0, this._startPoint = t, this._points = [t];
+			return;
+		}
+		if (this._points.length === 1) {
+			this._secondPoint = t, this._points = [...this._points, t];
+			return;
+		}
+		this._points.length === 2 && (this._thirdPoint = t, this._points = [...this._points, t], this._endPoint = t, this._isEnd = !0);
+	}
+	onPointerMove(e) {}
+	onPointerUp(e) {
+		if (this._active && this._isEnd && this._points.length >= 3) {
+			let e = this._points[0], t = this._points[1], n = this._points[2], r = this.calcAngle(e, t, n);
+			this.finalize(r);
+		}
+	}
+	calcAngle(e, t, n) {
+		let r = t.x - e.x, i = t.y - e.y, a = n.x - e.x, o = n.y - e.y, s = r * a + i * o, c = Math.hypot(r, i), l = Math.hypot(a, o);
+		if (c === 0 || l === 0) return 0;
+		let u = Math.max(-1, Math.min(1, s / (c * l)));
+		return parseFloat((Math.acos(u) * 180 / Math.PI).toFixed(2));
+	}
+}, G = class extends H {
+	constructor(e) {
+		super(e), this.currentType = "area";
+	}
+	onPointerDown(e) {
+		if (!this._active) return;
+		let t = this.getScenePoint(e);
+		if (!this._isStart) {
+			this._isStart = !0, this._startPoint = t, this._points = [t];
+			return;
+		}
+		this._points = [...this._points, t];
+	}
+	onPointerMove(e) {}
+	onPointerUp(e) {}
+	finish() {
+		if (this._points.length < 3) return;
+		let e = this.calcPolygonArea(this._points);
+		this.finalize(e);
+	}
+	calcPolygonArea(e) {
+		let t = 0, n = e.length;
+		for (let r = 0; r < n; r++) {
+			let i = (r + 1) % n;
+			t += e[r].x * e[i].y, t -= e[i].x * e[r].y;
+		}
+		return Math.abs(t) / 2;
+	}
+}, K = class {
+	get currentType() {
+		return this._currentSubType;
+	}
+	constructor(e) {
+		this.TOOLNAME = "measure", this._currentSubType = "distance", this._active = !1, this._isCreating = !1, this._resultList = /* @__PURE__ */ new Map(), this._onMeasureStart = () => {
+			this._isCreating = !0;
+		}, this._onMeasureCreated = (e) => {
+			this._isCreating = !1, this._resultList.set(e.result.id, e.result);
+		}, this.events = e.eventTrigger ?? new k();
+		let t = {
+			coordProvider: e.coordProvider,
+			calibration: e.calibration ?? {
+				scale: 1,
+				unit: "px",
+				precision: 2
+			},
+			eventTrigger: this.events
+		};
+		this.distanceMeasure = new U(t), this.angleMeasure = new W(t), this.areaMeasure = new G(t), this._subTools = /* @__PURE__ */ new Map([
+			["distance", this.distanceMeasure],
+			["angle", this.angleMeasure],
+			["area", this.areaMeasure]
+		]), this.events.on("measure_start", this._onMeasureStart), this.events.on("measure_created", this._onMeasureCreated);
+	}
+	get subType() {
+		return this._currentSubType;
+	}
+	setSubType(e) {
+		if (this._currentSubType === e) return;
+		this._currentSubType, this._subTools.get(this._currentSubType)?.setActive(!1), this._currentSubType = e;
+		let t = {
+			previous: this.TOOLNAME,
+			current: this.TOOLNAME,
+			subType: e
+		};
+		this.events.emit("tool_mode_changed", t), this._active && this._subTools.get(e)?.setActive(!0);
+	}
+	getActive() {
+		return this._active;
+	}
+	get isCreating() {
+		return this._isCreating;
+	}
+	setActive(e) {
+		if (this._active === e) return;
+		if (this._active = e, e) this._subTools.get(this._currentSubType)?.setActive(e);
+		else for (let e of this._subTools.values()) e.setActive(!1);
+		let t = {
+			active: e,
+			toolName: this.TOOLNAME
+		};
+		this.events.emit("tool_active", t);
+	}
+	onPointerDown(e) {
+		this._active && this._subTools.get(this._currentSubType)?.onPointerDown(e);
+	}
+	onPointerMove(e) {
+		this._active && this._subTools.get(this._currentSubType)?.onPointerMove(e);
+	}
+	onPointerUp(e) {
+		this._active && this._subTools.get(this._currentSubType)?.onPointerUp(e);
+	}
+	getResults() {
+		return Array.from(this._resultList.values());
+	}
+	getResult(e) {
+		return this._resultList.get(e);
+	}
+	removeResult(e) {
+		return this._resultList.delete(e);
+	}
+	clearResults() {
+		this._resultList.clear();
+	}
+	get previewDistanceEnd() {
+		return this.distanceMeasure.previewEnd;
+	}
+	get currentPoints() {
+		return this._subTools.get(this._currentSubType)?._points ?? [];
+	}
+	interrupt() {
+		this._subTools.get(this._currentSubType)?.interrupt();
+	}
+	destroy() {
+		this.events.off("measure_start", this._onMeasureStart), this.events.off("measure_created", this._onMeasureCreated);
+		for (let e of this._subTools.values()) e.destroy();
+		this._subTools.clear(), this._resultList.clear(), this._active = !1;
+	}
+}, q = class {
+	constructor(e) {
+		this._activeTool = null, this._activeMode = "none", this._tools = /* @__PURE__ */ new Map(), this.events = new k(), this.measureTool = new K({
+			coordProvider: e.coordProvider,
+			calibration: e.calibration,
+			eventTrigger: this.events
+		}), this._tools.set("measure", this.measureTool);
+	}
+	get activeMode() {
+		return this._activeMode;
+	}
+	setMode(e) {
+		if (this._activeMode === e) return;
+		let t = this._activeMode;
+		if (this._activeTool && this._activeTool.setActive(!1), this._activeMode = e, e === "none") this._activeTool = null;
+		else {
+			let t = this._tools.get(e);
+			t ? (this._activeTool = t, t.setActive(!0)) : (console.warn(`[ToolManager] 未注册的工具模式: ${e}`), this._activeTool = null);
+		}
+		let n = {
+			previous: t,
+			current: e
+		};
+		this.events.emit("tool_mode_changed", n);
+	}
+	getActiveTool() {
+		return this._activeTool;
+	}
+	registerTool(e, t) {
+		this._tools.set(e, t);
+	}
+	onPointerDown(e) {
+		this._activeTool?.onPointerDown(e);
+	}
+	onPointerMove(e) {
+		this._activeTool?.onPointerMove(e);
+	}
+	onPointerUp(e) {
+		this._activeTool?.onPointerUp(e);
+	}
+	interrupt() {
+		this._activeTool?.interrupt();
+	}
+	destroy() {
+		for (let e of this._tools.values()) e.destroy();
+		this._tools.clear(), this.events.destroy(), this._activeTool = null, this._activeMode = "none";
+	}
+};
+//#endregion
+//#region src/components/useViewerManager.ts
+function ee(e) {
+	let { drawAnnotations: t, currentScale: n, setScale: r, viewerRef: i, adjustLayout: o, screenToScene: s } = e, c = new q({ coordProvider: {
+		screenToScene: s,
+		sceneToScreen: (e) => ({
+			x: 0,
+			y: 0
+		})
+	} }), l = d([]), u = d(null), f = () => {
+		let e = c.measureTool.getResults().map((e) => ({
+			id: e.id,
+			kind: "measure",
+			points: e.points.map((e) => ({
+				x: e.x,
+				y: e.y
+			})),
+			value: e.value,
+			unit: e.unit,
+			label: e.label,
+			color: "#10b981",
+			strokeWidth: 2,
+			createdAt: e.createdAt
+		}));
+		l.value = e, t();
+	};
+	c.events.on("measure_created", (e) => {
+		f();
+	}), c.events.on("measure_cancel", () => {
+		t();
+	});
+	let p = d("none");
+	return {
+		toolManager: c,
+		mode: p,
+		annotations: l,
+		selectedAnnotationId: u,
+		setMode: (e) => {
+			let n = {
+				measure: "measure",
+				rectangle: "none",
+				none: "none"
+			}[e] ?? "none";
+			p.value = e, c.setMode(n), t();
+		},
+		setMeasureSubType: (e) => {
+			c.measureTool.setSubType(e);
+		},
+		clearInteraction: () => {
+			c.interrupt(), c.measureTool.clearResults(), l.value = [], u.value = null, t();
+		},
+		deleteSelectedAnnotation: () => {
+			u.value && (c.measureTool.removeResult(u.value), u.value = null, f());
+		},
+		selectAnnotation: (e) => {
+			u.value = e, t();
+		},
+		registerManager: () => {
+			let e = {
+				setScale: async (e) => {
+					await r(e), await a(), o(!1);
+				},
+				getScale: () => n.value,
+				getContainerEl: () => i.value
+			}, s = new T();
+			s.registerWithToolManager(c, t, e), window.pdfViewer = s;
+		},
+		unregisterManager: () => {
+			window.pdfViewer?.unregister(), window.pdfViewer = null, c.destroy();
+		}
+	};
+}
+//#endregion
+//#region src/components/PdfViewer.vue
+var J = /*#__PURE__*/ ((e, t) => {
+	let n = e.__vccOpts || e;
+	for (let [e, r] of t) n[e] = r;
+	return n;
+})(/* @__PURE__ */ i({
+	__name: "PdfViewer",
+	props: {
+		modelValue: { default: null },
+		scale: { default: 1.5 },
+		width: { default: "100%" },
+		height: { default: "100%" },
+		theme: { default: "light" },
+		toolbar: {
+			type: Boolean,
+			default: !1
+		},
+		zoomSpeed: { default: 1 }
+	},
+	emits: [
+		"loaded",
+		"error",
+		"annotation-added"
+	],
+	setup(e, { expose: t, emit: i }) {
+		let d = e, m = i, h = u(null), g = u(null), _ = u(null), v = u(null), { containerRef: y, loadFile: b, doc: x, pageCount: S, currentPageNum: C, error: w, currentScale: T, setScale: E, reset: D, events: O } = A({
+			autoLoad: !1,
+			scale: d.scale,
+			backgroundColor: d.theme === "dark" ? "#1e1e1e" : "rgb(255,255,255)"
+		}), k = P(), j = u(null), M = u(!1), { drawAnnotations: N, syncCanvasSize: L, getCanvasPoint: R, hitTestAnnotation: z } = F({
+			annotationCanvas: v,
+			rootRef: g,
+			interaction: k,
+			previewPoint: j
+		}), { containerStyle: V, adjustLayout: H, handleWheel: U, handleTouchStart: W, handleTouchMove: G, handleTouchEnd: K } = B({
+			viewerRef: h,
+			rootRef: g,
+			pdfLayerRef: _,
+			currentScale: T,
+			setScale: E,
+			zoomSpeed: d.zoomSpeed ?? 1,
+			theme: d.theme,
+			syncCanvasSize: L,
+			drawAnnotations: N
+		}), { setMode: q, clearInteraction: J, deleteSelectedAnnotation: Y, selectAnnotation: te, registerManager: ne, unregisterManager: re } = ee({
+			drawAnnotations: N,
+			currentScale: T,
+			setScale: E,
+			viewerRef: h,
+			adjustLayout: H,
+			screenToScene: (e) => {
+				let t = R(e);
+				return {
+					x: t.x,
+					y: t.y
+				};
+			}
+		}), { handlePointerDown: X, handlePointerMove: Z, handlePointerUp: Q, handleKeydown: $ } = I({
+			annotationCanvas: v,
+			interaction: k,
+			previewPoint: j,
+			isRectangleDragging: M,
+			getCanvasPoint: R,
+			hitTestAnnotation: z,
+			drawAnnotations: N,
+			deleteSelectedAnnotation: Y,
+			emit: m
+		});
+		return O.on("loaded", (e) => {
+			m("loaded", {
+				pageCount: e.pageCount,
+				currentPage: e.currentPage
+			});
+		}), O.on("error_occurred", (e) => {
+			m("error", { message: e.message });
+		}), p(() => k.annotations.length, () => {
+			N();
+		}), p(() => d.scale, async (e) => {
+			e && e !== T.value && (await E(e), await a(), H());
+		}), p(() => d.modelValue, async (e) => {
+			e && (await b(e), await a(), H(!0));
+		}, {
+			immediate: !0,
+			flush: "post"
+		}), c(() => {
+			y.value = _.value, L(), N(), window.addEventListener("keydown", $), ne(), h.value && (h.value.addEventListener("touchstart", W, { passive: !0 }), h.value.addEventListener("touchmove", G, { passive: !1 }), h.value.addEventListener("touchend", K));
+		}), s(() => {
+			window.removeEventListener("keydown", $), h.value && (h.value.removeEventListener("touchstart", W), h.value.removeEventListener("touchmove", G), h.value.removeEventListener("touchend", K)), re();
+		}), t({
+			load: async (e) => {
+				await b(e);
+			},
+			clear: () => {
+				D();
+			},
+			setMode: q,
+			clearInteraction: J,
+			deleteSelectedAnnotation: Y,
+			selectAnnotation: te
+		}), (e, t) => (l(), n("div", {
+			ref_key: "viewerRef",
+			ref: h,
+			class: "pdf-core-viewer",
+			style: o(f(V)),
+			onWheel: t[3] ||= (...e) => f(U) && f(U)(...e)
+		}, [r("div", {
+			ref_key: "rootRef",
+			ref: g,
+			class: "pdf-core-canvas-wrapper"
+		}, [
+			r("div", {
+				ref_key: "pdfLayerRef",
+				ref: _,
+				class: "pdf-core-pdf-layer"
+			}, null, 512),
+			r("canvas", {
+				ref_key: "annotationCanvas",
+				ref: v,
+				class: "pdf-core-annotation-canvas"
+			}, null, 512),
+			r("div", {
+				class: "pdf-core-overlay",
+				onPointerdown: t[0] ||= (...e) => f(X) && f(X)(...e),
+				onPointerup: t[1] ||= (...e) => f(Q) && f(Q)(...e),
+				onPointermove: t[2] ||= (...e) => f(Z) && f(Z)(...e)
+			}, null, 32)
+		], 512)], 36));
+	}
+}), [["__scopeId", "data-v-0e4941dc"]]);
+//#endregion
+//#region src/vue/plugin.ts
+function Y(e) {
+	e.component("PdfViewer", J);
+}
+//#endregion
+export { W as AngleMeasure, G as AreaMeasure, S as CoordTransformer, V as DEFAULT_TOOL_STATE, U as DistanceMeasure, k as EventTrigger, H as MeasureBase, K as MeasureTool, J as PdfViewer, T as PdfViewerCore, _ as TileLRUCache, q as ToolManager, C as ZOOM_LEVELS, E as createMeasureAnnotation, D as createShapeAnnotation, w as getNextZoom, Y as installPdfCore, g as loadPDF, x as renderPageTiledVirtual, m as setPDFWorkerSrc, j as useAnnotations, h as useDefaultWorker, N as useInteraction, M as useMeasurement, A as usePdfCore };