@mce/bigesj 0.18.4 → 0.19.0

package/dist/convert/image.d.ts

@@ -1 +1,2 @@
+export declare function cachedFetchImageBitmap(url: string): Promise<ImageBitmap>;
 export declare function convertImageElementToUrl(el: Record<string, any>): Promise<string>;

package/dist/index.js

@@ -1,6 +1,6 @@
 import { definePlugin, useEditor } from "mce";
 import { onBeforeMount, onScopeDispose, ref } from "vue";
-import { clearUndef, idGenerator, isGradient, isGradientFill, normalizeCRLF, normalizeGradientFill } from "modern-idoc";
+import { clearUndef, idGenerator, isGradient, isGradientFill, normalizeCRLF, normalizeGradientFill, normalizeNumber } from "modern-idoc";
 import { OoxmlNode, parsePresetShapeDefinition } from "modern-openxml";
 import { assets } from "modern-canvas";
 import { gunzipSync } from "fflate";
@@ -16,6 +16,17 @@ function levenshteinDistance(a, b) {
 	}
 	return matrix[b.length][a.length];
 }
+var indexedFonts;
+var idIndexMap = /* @__PURE__ */ new Map();
+var nameIndexMap = /* @__PURE__ */ new Map();
+var searchCache = /* @__PURE__ */ new Map();
+function ensureFontIndex(fonts) {
+	if (indexedFonts === fonts) return;
+	indexedFonts = fonts;
+	idIndexMap = new Map(fonts.map((item, index) => [item.id, index]));
+	nameIndexMap = new Map(fonts.flatMap((item, index) => [...item.en_name.split(","), ...item.name.split(",")].map((name) => [name, index])));
+	searchCache.clear();
+}
 function useFonts(editor) {
 	const { http, loadFont: baseLoadFont } = editor ?? useEditor();
 	async function loadBigeFonts(url, init = false) {
@@ -30,12 +41,8 @@ function useFonts(editor) {
 		return result;
 	}
 	function searchBigeFont(keyword, fonts = bigeFonts.value) {
-		const idIndexMap = new Map(fonts.map((item, index) => [item.id, index]));
-		const nameIndexMap = new Map(fonts.flatMap((item, index) => {
-			return [...item.en_name.split(","), ...item.name.split(",")].map((name) => {
-				return [name, index];
-			});
-		}));
+		ensureFontIndex(fonts);
+		if (searchCache.has(keyword)) return searchCache.get(keyword);
 		const fontFamilies = keyword.replace(/"/g, "").split(",");
 		let index;
 		fontFamilies.forEach((fontFamily) => {
@@ -50,6 +57,7 @@ function useFonts(editor) {
 				else if (a.endsWith(" B")) a = `${a.substring(0, a.length - 2)}粗体`;
 				const aLen = a.length;
 				nameIndexMap.forEach((i, b) => {
+					if (Math.abs(aLen - b.length) >= aLen) return;
 					const dist = levenshteinDistance(a, b);
 					if (aLen <= dist) return;
 					const weight = -(dist * .9 + (b.endsWith("常规") ? 0 : 1) * .1);
@@ -60,7 +68,9 @@ function useFonts(editor) {
 				});
 			});
 		}
-		return index !== void 0 ? fonts[index] : void 0;
+		const result = index !== void 0 ? fonts[index] : void 0;
+		searchCache.set(keyword, result);
+		return result;
 	}
 	async function loadFont(name) {
 		const names = typeof name === "string" ? [name] : name;
@@ -1138,6 +1148,23 @@ function parseAnimations(el) {
 }
 //#endregion
 //#region src/convert/style.ts
+var NUMERIC_STYLE_KEYS = [
+	"textIndent",
+	"lineHeight",
+	"letterSpacing",
+	"wordSpacing",
+	"fontSize",
+	"textStrokeWidth",
+	"borderRadius",
+	"opacity",
+	"rotate",
+	"scaleX",
+	"scaleY",
+	"skewX",
+	"skewY",
+	"translateX",
+	"translateY"
+];
 function getStyle(el, clone = false) {
 	let style = el.style ?? el;
 	if (clone) {
@@ -1154,6 +1181,11 @@ function getStyle(el, clone = false) {
 		delete style.backgroundUrl;
 		delete style.elements;
 		delete style.imageTransform;
+		for (const key of NUMERIC_STYLE_KEYS) if (key in style) {
+			const value = normalizeNumber(style[key]);
+			if (value === void 0) delete style[key];
+			else style[key] = value;
+		}
 	}
 	return style;
 }
@@ -1626,7 +1658,7 @@ function signedArea(data, start, end, dim) {
 	return sum;
 }
 //#endregion
-//#region ../../node_modules/.pnpm/modern-path2d@1.6.0/node_modules/modern-path2d/dist/index.mjs
+//#region ../../node_modules/.pnpm/modern-path2d@1.7.0/node_modules/modern-path2d/dist/index.mjs
 function drawPoint(ctx, x, y, options = {}) {
 	const { radius = 1 } = options;
 	ctx.moveTo(x, y);
@@ -1732,7 +1764,7 @@ var Vector2 = class Vector2 {
 		return this.set(this._x * x, this._y * y);
 	}
 	divide(x = 0, y = x) {
-		return this.set(this._x / x, this._y / y);
+		return this.set(x === 0 ? this._x : this._x / x, y === 0 ? this._y : this._y / y);
 	}
 	cross(p) {
 		return this._x * p.y - this._y * p.x;
@@ -1910,9 +1942,9 @@ function getIntersectionPoint(p1, p2, q1, q2) {
 	const s = q2.clone().sub(q1);
 	const q1p1 = q1.clone().sub(p1);
 	const crossRS = r.cross(s);
-	if (crossRS === 0) return new Vector2((p1.x + q1.x) / 2, (p1.y + q1.y) / 2);
+	if (crossRS === 0) return null;
 	const t = q1p1.cross(s) / crossRS;
-	if (Math.abs(t) > 1) return new Vector2((p1.x + q1.x) / 2, (p1.y + q1.y) / 2);
+	if (Math.abs(t) > 1) return null;
 	return new Vector2(p1.x + t * r.x, p1.y + t * r.y);
 }
 var FUNCTIONS_RE = /([\w-]+)\((.+?)\)/g;
@@ -2118,7 +2150,7 @@ function recursive(points, x1, y1, x2, y2, x3, y3, distanceTolerance, level) {
 function cross(ax, ay, bx, by, cx, cy) {
 	return (bx - ax) * (cy - ay) - (by - ay) * (cx - ax);
 }
-function windingNumber(px, py, polygon) {
+function windingNumber$1(px, py, polygon) {
 	const polygonLen = polygon.length;
 	let wn = 0;
 	for (let i = 0, j = polygonLen - 2; i < polygonLen; j = i, i += 2) {
@@ -2137,11 +2169,18 @@ function distance(p1, p2) {
 	const dy = p2[1] - p1[1];
 	return Math.sqrt(dx * dx + dy * dy);
 }
+function aabbIntersects(a, b) {
+	return a.minX <= b.maxX && a.maxX >= b.minX && a.minY <= b.maxY && a.maxY >= b.minY;
+}
 function nonzeroFillRule(paths) {
 	const results = paths.map((_, i) => ({ index: i }));
-	const testPointsGroups = paths.map((path) => {
+	const bboxes = [];
+	const testPointsGroups = paths.map((path, pathIndex) => {
 		const len = path.length;
-		if (!len) return [];
+		if (!len) {
+			bboxes[pathIndex] = null;
+			return [];
+		}
 		let xMinYAuto = [Number.MAX_SAFE_INTEGER, 0];
 		let xAutoYMin = [0, Number.MAX_SAFE_INTEGER];
 		let xMaxYAuto = [Number.MIN_SAFE_INTEGER, 0];
@@ -2154,6 +2193,12 @@ function nonzeroFillRule(paths) {
 			if (xMaxYAuto[0] < x) xMaxYAuto = [x, y];
 			if (xAutoYMax[1] < y) xAutoYMax = [x, y];
 		}
+		bboxes[pathIndex] = {
+			minX: xMinYAuto[0],
+			minY: xAutoYMin[1],
+			maxX: xMaxYAuto[0],
+			maxY: xAutoYMax[1]
+		};
 		const mid = [(xMinYAuto[0] + xMaxYAuto[0]) / 2, (xAutoYMin[1] + xAutoYMax[1]) / 2];
 		let xMidYMinDx;
 		let xMidYMaxDx;
@@ -2199,13 +2244,16 @@ function nonzeroFillRule(paths) {
 	for (let i = 0, len = paths.length; i < len; i++) {
 		const _results = [];
 		const testPoints = testPointsGroups[i];
+		const boxI = bboxes[i];
 		for (let j = 0; j < len; j++) {
 			if (i === j) continue;
+			const boxJ = bboxes[j];
+			if (!boxI || !boxJ || !aabbIntersects(boxI, boxJ)) continue;
 			const wnMap = {};
 			const wnList = [];
 			for (let p = 0, pLen = testPoints.length; p < pLen; p++) {
 				const [x, y] = testPoints[p];
-				const winding = windingNumber(x, y, paths[j]);
+				const winding = windingNumber$1(x, y, paths[j]);
 				wnMap[winding] = (wnMap[winding] ?? 0) + 1;
 				wnList.push(winding);
 			}
@@ -2223,6 +2271,88 @@ function nonzeroFillRule(paths) {
 	}
 	return results;
 }
+function isLeft(ax, ay, bx, by, px, py) {
+	return (bx - ax) * (py - ay) - (px - ax) * (by - ay);
+}
+function windingNumber(px, py, vertices) {
+	const len = vertices.length;
+	let wn = 0;
+	for (let i = 0; i < len; i += 2) {
+		const ax = vertices[i];
+		const ay = vertices[i + 1];
+		const k = (i + 2) % len;
+		const bx = vertices[k];
+		const by = vertices[k + 1];
+		if (ay <= py) {
+			if (by > py && isLeft(ax, ay, bx, by, px, py) > 0) wn++;
+		} else if (by <= py && isLeft(ax, ay, bx, by, px, py) < 0) wn--;
+	}
+	return wn;
+}
+function crossingNumber(px, py, vertices) {
+	const len = vertices.length;
+	let cn = 0;
+	for (let i = 0; i < len; i += 2) {
+		const ax = vertices[i];
+		const ay = vertices[i + 1];
+		const k = (i + 2) % len;
+		const bx = vertices[k];
+		const by = vertices[k + 1];
+		if (ay <= py && by > py || ay > py && by <= py) {
+			if (px < ax + (py - ay) / (by - ay) * (bx - ax)) cn++;
+		}
+	}
+	return cn;
+}
+function segmentDistance(px, py, ax, ay, bx, by) {
+	const dx = bx - ax;
+	const dy = by - ay;
+	const lenSq = dx * dx + dy * dy;
+	let t = lenSq === 0 ? 0 : ((px - ax) * dx + (py - ay) * dy) / lenSq;
+	if (t < 0) t = 0;
+	else if (t > 1) t = 1;
+	const cx = ax + t * dx;
+	const cy = ay + t * dy;
+	return Math.hypot(px - cx, py - cy);
+}
+function pointInPolygon(point, vertices, fillRule = "nonzero") {
+	if (vertices.length < 6) return false;
+	if (fillRule === "evenodd") return (crossingNumber(point.x, point.y, vertices) & 1) === 1;
+	return windingNumber(point.x, point.y, vertices) !== 0;
+}
+function pointInPolygons(point, polygons, fillRule = "nonzero") {
+	const { x, y } = point;
+	if (fillRule === "evenodd") {
+		let cn = 0;
+		for (let i = 0, len = polygons.length; i < len; i++) {
+			const ring = polygons[i];
+			if (ring.length >= 6) cn += crossingNumber(x, y, ring);
+		}
+		return (cn & 1) === 1;
+	}
+	let wn = 0;
+	for (let i = 0, len = polygons.length; i < len; i++) {
+		const ring = polygons[i];
+		if (ring.length >= 6) wn += windingNumber(x, y, ring);
+	}
+	return wn !== 0;
+}
+function pointToPolylineDistance(point, vertices, closed = false) {
+	const len = vertices.length;
+	if (len < 2) return Infinity;
+	const { x: px, y: py } = point;
+	if (len === 2) return Math.hypot(px - vertices[0], py - vertices[1]);
+	let min = Infinity;
+	for (let i = 0; i < len - 2; i += 2) {
+		const d = segmentDistance(px, py, vertices[i], vertices[i + 1], vertices[i + 2], vertices[i + 3]);
+		if (d < min) min = d;
+	}
+	if (closed && len >= 6) {
+		const d = segmentDistance(px, py, vertices[len - 2], vertices[len - 1], vertices[0], vertices[1]);
+		if (d < min) min = d;
+	}
+	return min;
+}
 function quadraticBezierP0(t, p) {
 	const k = 1 - t;
 	return k * k * p;
@@ -3728,6 +3858,39 @@ function svgToPath2DSet(svg) {
 var Curve = class {
 	arcLengthDivision = 200;
 	_lengths = [];
+	_adaptiveCache;
+	/**
+	* Parent composite, set lazily when a composite caches its children. Lets
+	* {@link invalidate} propagate up so an ancestor's caches refresh too.
+	*/
+	_owner;
+	_invalidating = false;
+	/**
+	* Drop cached arc lengths and the cached sampled outline used by hit testing, then
+	* bubble up to {@link _owner}. Called automatically by {@link applyTransform} and the
+	* `Path2D` mutators; call it manually after mutating control-point coordinates in place —
+	* the caches cannot observe such mutations.
+	*/
+	invalidate() {
+		if (this._invalidating) return this;
+		this._invalidating = true;
+		this._invalidateSelf();
+		this._owner?.invalidate();
+		this._invalidating = false;
+		return this;
+	}
+	/** Clears this curve's own caches. Composites also clear their children (see override). */
+	_invalidateSelf() {
+		this._lengths.length = 0;
+		this._adaptiveCache = void 0;
+	}
+	/**
+	* Sampled outline cached for repeated hit tests (read-only — do not mutate the result).
+	* Invalidated by {@link invalidate}.
+	*/
+	_getCachedAdaptiveVertices() {
+		return this._adaptiveCache ??= this.getAdaptiveVertices();
+	}
 	getPointAt(u, output = new Vector2()) {
 		return this.getPoint(this.getUToTMapping(u), output);
 	}
@@ -3743,6 +3906,7 @@ var Curve = class {
 			if (isFunction) transform(p);
 			else transform.apply(p, p);
 		});
+		this.invalidate();
 		return this;
 	}
 	getUnevenVertices(count = 5, output = []) {
@@ -3869,12 +4033,21 @@ var Curve = class {
 		return mid;
 	}
 	getMinMax(min = Vector2.MAX, max = Vector2.MIN) {
-		const potins = this.getPoints();
-		for (let i = 0, len = potins.length; i < len; i++) {
-			const p = potins[i];
-			min.clampMin(p);
-			max.clampMax(p);
+		const vertices = this.getAdaptiveVertices();
+		let minX = min.x;
+		let minY = min.y;
+		let maxX = max.x;
+		let maxY = max.y;
+		for (let i = 0, len = vertices.length; i < len; i += 2) {
+			const x = vertices[i];
+			const y = vertices[i + 1];
+			if (x < minX) minX = x;
+			if (y < minY) minY = y;
+			if (x > maxX) maxX = x;
+			if (y > maxY) maxY = y;
 		}
+		min.set(minX, minY);
+		max.set(maxX, maxY);
 		return {
 			min: min.finite(),
 			max: max.finite()
@@ -3884,6 +4057,42 @@ var Curve = class {
 		const { min, max } = this.getMinMax();
 		return new BoundingBox(min.x, min.y, max.x - min.x, max.y - min.y);
 	}
+	/**
+	* Test whether a point lies inside the area enclosed by this curve.
+	*
+	* The curve is sampled via {@link getAdaptiveVertices} into a single implicitly closed
+	* ring. This is purely geometric (it ignores any `fill`/`stroke` style), mirroring
+	* `CanvasRenderingContext2D.isPointInPath`.
+	*
+	* Composites that hold multiple sub-paths (e.g. {@link Path2D}) override this so holes
+	* are honored — a single `Curve` is always one ring.
+	*/
+	isPointInFill(point, options = {}) {
+		return pointInPolygon(point, this._getCachedAdaptiveVertices(), options.fillRule);
+	}
+	/**
+	* Test whether a point lies on this curve's stroke, i.e. within `strokeWidth / 2 + tolerance`
+	* of the sampled outline. The point must be in the same coordinate space as the curve.
+	*
+	* Options: `strokeWidth` (path units, default `1`), `tolerance` (extra hit slack in path
+	* units, default `0` — useful for thin strokes; no coordinate scaling is assumed, so convert
+	* pixel tolerance to path units upstream if your path is normalized), and `closed` (whether
+	* to include the closing edge from the last vertex back to the first).
+	*/
+	isPointInStroke(point, options = {}) {
+		const { strokeWidth = 1, tolerance = 0, closed = false } = options;
+		return pointToPolylineDistance(point, this._getCachedAdaptiveVertices(), closed) <= strokeWidth / 2 + tolerance;
+	}
+	/**
+	* Concise PathKit-style fill containment test: `contains(x, y)` is shorthand for
+	* {@link isPointInFill} with a `{ x, y }` point.
+	*/
+	contains(x, y, options = {}) {
+		return this.isPointInFill({
+			x,
+			y
+		}, options);
+	}
 	getFillVertices(_options) {
 		return this.getAdaptiveVertices();
 	}
@@ -4013,6 +4222,64 @@ var RoundCurve = class extends Curve {
 		}
 		return output.set(_x, _y);
 	}
+	/**
+	* Point on the ellipse at an absolute angle (mirrors {@link getPoint}'s parameterization,
+	* ignoring `_diff`).
+	*/
+	_pointAtAngle(angle, output) {
+		let x = this.cx + this.rx * Math.cos(angle);
+		let y = this.cy + this.ry * Math.sin(angle);
+		if (this.rotate !== 0) {
+			const cos = Math.cos(this.rotate);
+			const sin = Math.sin(this.rotate);
+			const tx = x - this.cx;
+			const ty = y - this.cy;
+			x = tx * cos - ty * sin + this.cx;
+			y = tx * sin + ty * cos + this.cy;
+		}
+		return output.set(x, y);
+	}
+	/**
+	* Analytical bounds of the (elliptical) arc: the start/end points plus the per-axis
+	* extrema angles that fall within the swept interval. Matches {@link getPoint}, so it is
+	* exact for `ArcCurve`/`EllipseCurve`. The `_diff` offset (used only by the legacy
+	* `_getAdaptiveVerticesByCircle` path) is intentionally ignored here.
+	*/
+	getMinMax(min = Vector2.MAX, max = Vector2.MIN) {
+		const { startAngle, rotate } = this;
+		const delta = this._getDeltaAngle();
+		const cosT = Math.cos(rotate);
+		const sinT = Math.sin(rotate);
+		const p = tempV2;
+		let minX = min.x;
+		let minY = min.y;
+		let maxX = max.x;
+		let maxY = max.y;
+		const consider = (angle) => {
+			this._pointAtAngle(angle, p);
+			if (p.x < minX) minX = p.x;
+			if (p.y < minY) minY = p.y;
+			if (p.x > maxX) maxX = p.x;
+			if (p.y > maxY) maxY = p.y;
+		};
+		consider(startAngle);
+		consider(startAngle + delta);
+		const ax = Math.atan2(-this.ry * sinT, this.rx * cosT);
+		const ay = Math.atan2(this.ry * cosT, this.rx * sinT);
+		const bases = [
+			ax,
+			ax + Math.PI,
+			ay,
+			ay + Math.PI
+		];
+		for (let i = 0; i < 4; i++) if (angleInSweep(bases[i], startAngle, delta)) consider(bases[i]);
+		min.set(minX, minY);
+		max.set(maxX, maxY);
+		return {
+			min: min.finite(),
+			max: max.finite()
+		};
+	}
 	toCommands() {
 		const { cx, cy, rx, ry, startAngle, endAngle, clockwise, rotate } = this;
 		const startX = cx + rx * Math.cos(startAngle) * Math.cos(rotate) - ry * Math.sin(startAngle) * Math.sin(rotate);
@@ -4083,6 +4350,7 @@ var RoundCurve = class extends Curve {
 		this.cy = tempV2.y;
 		if (isTransformSkewed(transform)) transfEllipseGeneric(this, transform);
 		else transfEllipseNoSkew(this, transform);
+		this.invalidate();
 		return this;
 	}
 	getControlPointRefs() {
@@ -4212,6 +4480,18 @@ var RoundCurve = class extends Curve {
 		return this;
 	}
 };
+function angleInSweep(a, start, delta) {
+	const PI_2 = Math.PI * 2;
+	const eps = 1e-9;
+	if (Math.abs(delta) >= PI_2 - eps) return true;
+	let off = (a - start) % PI_2;
+	if (delta >= 0) {
+		if (off < -1e-9) off += PI_2;
+		return off >= -1e-9 && off <= delta + eps;
+	}
+	if (off > eps) off -= PI_2;
+	return off <= eps && off >= delta - eps;
+}
 function transfEllipseGeneric(curve, m) {
 	const a = curve.rx;
 	const b = curve.ry;
@@ -4412,6 +4692,22 @@ var CompositeCurve = class CompositeCurve extends Curve {
 		super();
 		this.curves = curves;
 	}
+	_adaptiveCacheLen = -1;
+	_invalidateSelf() {
+		super._invalidateSelf();
+		this._adaptiveCacheLen = -1;
+		this.curves.forEach((curve) => curve.invalidate());
+	}
+	_getCachedAdaptiveVertices() {
+		if (!this._adaptiveCache || this._adaptiveCacheLen !== this.curves.length) {
+			this.curves.forEach((curve) => {
+				curve._owner = this;
+			});
+			this._adaptiveCache = this.getAdaptiveVertices();
+			this._adaptiveCacheLen = this.curves.length;
+		}
+		return this._adaptiveCache;
+	}
 	getFlatCurves() {
 		return this.curves.flatMap((curve) => {
 			if (curve instanceof CompositeCurve) return curve.getFlatCurves();
@@ -4446,6 +4742,7 @@ var CompositeCurve = class CompositeCurve extends Curve {
 	updateLengths() {
 		const lengths = [];
 		for (let i = 0, sum = 0, len = this.curves.length; i < len; i++) {
+			this.curves[i]._owner = this;
 			sum += this.curves[i].getLength();
 			lengths.push(sum);
 		}
@@ -4499,7 +4796,10 @@ var CompositeCurve = class CompositeCurve extends Curve {
 		}
 	}
 	applyTransform(transform) {
+		this._invalidating = true;
 		this.curves.forEach((curve) => curve.applyTransform(transform));
+		this._invalidating = false;
+		this.invalidate();
 		return this;
 	}
 	getMinMax(min = Vector2.MAX, max = Vector2.MIN) {
@@ -4756,7 +5056,7 @@ var RectangleCurve = class extends PolygonCurve {
 		return this;
 	}
 };
-var RoundRectangleCurve = class extends RoundCurve {
+var RoundRectangleCurve = class extends CompositeCurve {
 	constructor(x = 0, y = 0, width = 1, height = 1, radius = 1) {
 		super();
 		this.x = x;
@@ -4767,25 +5067,44 @@ var RoundRectangleCurve = class extends RoundCurve {
 		this.update();
 	}
 	update() {
-		const { x, y, width, height, radius } = this;
-		const halfWidth = width / 2;
-		const halfHeight = height / 2;
-		const cx = x + halfWidth;
-		const cy = y + halfHeight;
-		const rx = Math.max(0, Math.min(radius, Math.min(halfWidth, halfHeight)));
-		const ry = rx;
-		this._center = new Vector2(cx, cy);
-		this._radius = new Vector2(rx, ry);
-		this._diff = new Vector2(halfWidth - rx, halfHeight - ry);
+		const { x, y, width, height } = this;
+		const r = Math.max(0, Math.min(this.radius, Math.abs(width) / 2, Math.abs(height) / 2));
+		const x0 = x;
+		const x1 = x + r;
+		const x2 = x + width - r;
+		const x3 = x + width;
+		const y0 = y;
+		const y1 = y + r;
+		const y2 = y + height - r;
+		const y3 = y + height;
+		if (r <= 0) this.curves = [
+			LineCurve.from(x0, y0, x3, y0),
+			LineCurve.from(x3, y0, x3, y3),
+			LineCurve.from(x3, y3, x0, y3),
+			LineCurve.from(x0, y3, x0, y0)
+		];
+		else {
+			const HALF_PI = Math.PI / 2;
+			this.curves = [
+				LineCurve.from(x1, y0, x2, y0),
+				new ArcCurve(x2, y1, r, -HALF_PI, 0, true),
+				LineCurve.from(x3, y1, x3, y2),
+				new ArcCurve(x2, y2, r, 0, HALF_PI, true),
+				LineCurve.from(x2, y3, x1, y3),
+				new ArcCurve(x1, y2, r, HALF_PI, Math.PI, true),
+				LineCurve.from(x0, y2, x0, y1),
+				new ArcCurve(x1, y1, r, Math.PI, Math.PI * 1.5, true)
+			];
+		}
+		this.invalidate();
 		return this;
 	}
 	drawTo(ctx) {
-		const { x, y, width, height, radius } = this;
-		ctx.roundRect(x, y, width, height, radius);
+		ctx.roundRect(this.x, this.y, this.width, this.height, this.radius);
 		return this;
 	}
 	copyFrom(source) {
-		super.copyFrom(source);
+		this.arcLengthDivision = source.arcLengthDivision;
 		this.x = source.x;
 		this.y = source.y;
 		this.width = source.width;
@@ -4862,6 +5181,16 @@ var CurvePath = class extends CompositeCurve {
 	getFillVertices(options) {
 		return this._closeVertices(super.getFillVertices(options));
 	}
+	/**
+	* Same as {@link Curve.isPointInStroke}, but `closed` defaults to this sub-path's actual
+	* closed-ness: explicitly `autoClose`, or geometrically closed (first vertex === last).
+	*/
+	isPointInStroke(point, options = {}) {
+		const { strokeWidth = 1, tolerance = 0 } = options;
+		const vertices = this._getCachedAdaptiveVertices();
+		const len = vertices.length;
+		return pointToPolylineDistance(point, vertices, options.closed ?? (this.autoClose || len >= 6 && vertices[0] === vertices[len - 2] && vertices[1] === vertices[len - 1])) <= strokeWidth / 2 + tolerance;
+	}
 	_setCurrentPoint(point) {
 		this.currentPoint = new Vector2(point.x, point.y);
 		if (!this.startPoint) this.startPoint = this.currentPoint.clone();
@@ -4999,6 +5328,8 @@ var CurvePath = class extends CompositeCurve {
 };
 var Path2D = class Path2D extends CompositeCurve {
 	_meta;
+	_ringsCache;
+	_ringsCacheLen = -1;
 	currentCurve = new CurvePath();
 	style;
 	get startPoint() {
@@ -5110,6 +5441,7 @@ var Path2D = class Path2D extends CompositeCurve {
 		this.getControlPointRefs().forEach((point) => {
 			point.scale(sx, sy, target);
 		});
+		this.invalidate();
 		return this;
 	}
 	skew(ax, ay = 0, target = {
@@ -5119,6 +5451,7 @@ var Path2D = class Path2D extends CompositeCurve {
 		this.getControlPointRefs().forEach((point) => {
 			point.skew(ax, ay, target);
 		});
+		this.invalidate();
 		return this;
 	}
 	rotate(rad, target = {
@@ -5128,6 +5461,7 @@ var Path2D = class Path2D extends CompositeCurve {
 		this.getControlPointRefs().forEach((point) => {
 			point.rotate(rad, target);
 		});
+		this.invalidate();
 		return this;
 	}
 	bold(b) {
@@ -5173,47 +5507,67 @@ var Path2D = class Path2D extends CompositeCurve {
 				}
 			});
 		});
+		this.invalidate();
 		return this;
 	}
+	/**
+	* Test whether a point lies inside the filled area of this path.
+	*
+	* Each sub-path ({@link CurvePath}) is sampled into its own ring and all rings are
+	* evaluated together via {@link pointInPolygons}, so holes (donut / hollow shapes) are
+	* honored. This is purely geometric and ignores `style.fill` — for the `fill: 'none'`
+	* fallback, gate the call upstream (see {@link Path2DSet.hitTest}).
+	*
+	* Defaults `fillRule` to `style.fillRule`, then `'nonzero'` (matching SVG/Canvas).
+	*/
+	_invalidateSelf() {
+		super._invalidateSelf();
+		this._ringsCache = void 0;
+		this._ringsCacheLen = -1;
+	}
+	/** Per-sub-path sampled rings, cached for repeated hit tests. */
+	_getRings() {
+		if (!this._ringsCache || this._ringsCacheLen !== this.curves.length) {
+			this._ringsCache = this.curves.map((curve) => {
+				curve._owner = this;
+				return curve.getAdaptiveVertices();
+			});
+			this._ringsCacheLen = this.curves.length;
+		}
+		return this._ringsCache;
+	}
+	isPointInFill(point, options = {}) {
+		const fillRule = options.fillRule ?? this.style.fillRule ?? "nonzero";
+		return pointInPolygons(point, this._getRings(), fillRule);
+	}
+	/**
+	* Test whether a point lies on this path's stroke. A hit on any sub-path counts.
+	*
+	* Defaults `strokeWidth` to this path's own {@link strokeWidth} (which is `0` when
+	* `style.stroke` is `'none'`). Each sub-path infers its own closed-ness unless `closed`
+	* is given explicitly.
+	*/
+	isPointInStroke(point, options = {}) {
+		const strokeWidth = options.strokeWidth ?? this.strokeWidth;
+		const { tolerance = 0, closed } = options;
+		return this.curves.some((curve) => curve.isPointInStroke(point, {
+			strokeWidth,
+			tolerance,
+			closed
+		}));
+	}
 	getMinMax(min = Vector2.MAX, max = Vector2.MIN, withStyle = true) {
-		const strokeWidth = this.strokeWidth;
 		this.curves.forEach((curve) => {
 			curve.getMinMax(min, max);
-			if (withStyle) {
-				if (strokeWidth > 1) {
-					const halfStrokeWidth = strokeWidth / 2;
-					const isClockwise = curve.isClockwise();
-					const points = [];
-					for (let t = 0; t <= 1; t += 1 / curve.arcLengthDivision) {
-						const point = curve.getPoint(t);
-						const normal = curve.getNormal(t);
-						const dist1 = normal.clone().scale(isClockwise ? halfStrokeWidth : -halfStrokeWidth);
-						const dist2 = normal.clone().scale(isClockwise ? -halfStrokeWidth : halfStrokeWidth);
-						points.push(point.clone().add(dist1), point.clone().add(dist2), point.clone().add({
-							x: halfStrokeWidth,
-							y: 0
-						}), point.clone().add({
-							x: -halfStrokeWidth,
-							y: 0
-						}), point.clone().add({
-							x: 0,
-							y: halfStrokeWidth
-						}), point.clone().add({
-							x: 0,
-							y: -halfStrokeWidth
-						}), point.clone().add({
-							x: halfStrokeWidth,
-							y: halfStrokeWidth
-						}), point.clone().add({
-							x: -halfStrokeWidth,
-							y: -halfStrokeWidth
-						}));
-					}
-					min.clampMin(...points);
-					max.clampMax(...points);
-				}
-			}
 		});
+		if (withStyle) {
+			const strokeWidth = this.strokeWidth;
+			if (strokeWidth > 1 && Number.isFinite(min.x)) {
+				const half = strokeWidth / 2;
+				min.set(min.x - half, min.y - half);
+				max.set(max.x + half, max.y + half);
+			}
+		}
 		return {
 			min: min.finite(),
 			max: max.finite()
@@ -5352,6 +5706,42 @@ var Path2DSet = class {
 		this.paths = paths;
 		this.viewBox = viewBox;
 	}
+	/**
+	* Test whether a point lies inside the filled area of any path in this set.
+	* Purely geometric (ignores `fill: 'none'`); use {@link hitTest} for style-aware hits.
+	*/
+	isPointInFill(point, options = {}) {
+		return this.paths.some((path) => path.isPointInFill(point, options));
+	}
+	/**
+	* Concise PathKit-style fill containment test across the whole set; shorthand for
+	* {@link isPointInFill} with a `{ x, y }` point.
+	*/
+	contains(x, y, options = {}) {
+		return this.isPointInFill({
+			x,
+			y
+		}, options);
+	}
+	/**
+	* Find the topmost path hit by a point, or `undefined` if none.
+	*
+	* Paths are tested top-to-bottom (last drawn first). For each path a fill hit is checked
+	* first (skipped when `style.fill` is `'none'`), then — if `stroke` is enabled — a stroke
+	* hit (skipped when `style.stroke` is `'none'`). This honors the "fill: none falls back to
+	* stroke" rule; the coordinate space of `point` must match the paths (no scaling assumed).
+	*
+	* Options: `stroke` (also test strokes, default `true`), `tolerance` (extra stroke hit slack
+	* in path units, default `0`), and `fillRule` (overrides each path's own fill rule).
+	*/
+	hitTest(point, options = {}) {
+		const { stroke = true, tolerance, fillRule } = options;
+		for (let i = this.paths.length - 1; i >= 0; i--) {
+			const path = this.paths[i];
+			if ((path.style.fill ?? "#000") !== "none" && path.isPointInFill(point, { fillRule })) return path;
+			if (stroke && (path.style.stroke ?? "none") !== "none" && path.isPointInStroke(point, { tolerance })) return path;
+		}
+	}
 	getBoundingBox(withStyle = true) {
 		if (!this.paths.length) return;
 		const min = Vector2.MAX;
@@ -5655,7 +6045,7 @@ function _createPresetShape(node, options) {
 var root;
 async function getRoot() {
 	if (!root) {
-		const presetShapeDefinitions = await import("./presetShapeDefinitions-C0rBrGs4.js").then((rep) => rep.default);
+		const presetShapeDefinitions = await import("./presetShapeDefinitions-NAoQKZ6z.js").then((rep) => rep.default);
 		root = OoxmlNode.fromXML(presetShapeDefinitions);
 	}
 	return root;
@@ -5716,6 +6106,221 @@ function convertSvgLinearGradient(value) {
 	}
 }
 //#endregion
+//#region src/convert/image.ts
+function cachedFetchImageBitmap(url) {
+	if (typeof url === "string" && url.startsWith("http")) return assets.loadBy(url).then((blob) => assets.fetchImageBitmap(blob));
+	return assets.fetchImageBitmap(url);
+}
+async function convertImageElementToUrl(el) {
+	const { cropping = {}, transform = {}, style = {}, maskUrl, imageEffects = [], imageEffectsRatio = 1 } = el;
+	const url = el.clipUrl || el.url;
+	const { translateX = 0, translateY = 0, zoom = 1 } = transform ?? {};
+	const { scaleX = 1, scaleY = 1, filter } = style;
+	if (translateX === 0 && translateY === 0 && zoom === 1 && scaleX === 1 && scaleY === 1 && !maskUrl && !filter && !imageEffects.length) return url;
+	const img = await cachedFetchImageBitmap(url);
+	const { originWidth = img.width, originHeight = img.height, imageWidth = originWidth, imageHeight = originHeight } = transform;
+	const { width = originWidth, height = originHeight } = style;
+	const dpr = window.devicePixelRatio || 1;
+	const [canvas, ctx] = createCanvas(width, height, dpr);
+	if (filter) ctx.filter = filter;
+	ctx.scale(scaleX, scaleY);
+	ctx.translate(scaleX < 0 ? -width : 0, scaleY < 0 ? -height : 0);
+	if (maskUrl) {
+		const mask = await cachedFetchImageBitmap(maskUrl);
+		ctx.drawImage(mask, 0, 0, cropping?.maskWidth ?? width, cropping?.maskHeight ?? height);
+		ctx.globalCompositeOperation = "source-in";
+		mask.close();
+	}
+	const dw = imageWidth * zoom;
+	const dh = imageHeight * zoom;
+	const dx = -(dw / 2 - imageWidth / 2) + translateX;
+	const dy = -(dh / 2 - imageHeight / 2) + translateY;
+	ctx.drawImage(img, 0, 0, img.width, img.height, dx, dy, dw, dh);
+	img.close();
+	ctx.globalCompositeOperation = "source-over";
+	if (imageEffects.length > 0) {
+		const scale = .9;
+		const center = {
+			x: (width - width * scale) / 2,
+			y: (height - height * scale) / 2
+		};
+		const canvasBitmap = await createImageBitmap(canvas);
+		ctx.clearRect(0, 0, canvas.width, canvas.height);
+		ctx.scale(scale, scale);
+		for (let i = imageEffects.length - 1; i >= 0; i--) {
+			const { filling, offset, stroke } = imageEffects[i];
+			let effectCanvas = canvasBitmap;
+			if (filling) {
+				const [canvas1, ctx1] = createCanvas(width, height, dpr);
+				ctx1.drawImage(effectCanvas, 0, 0, width, height);
+				ctx1.globalCompositeOperation = "source-in";
+				if (filling.color) {
+					const [canvas2, ctx2] = createCanvas(width, height, dpr);
+					ctx2.fillStyle = filling.color;
+					ctx2.fillRect(0, 0, width, height);
+					ctx1.drawImage(canvas2, 0, 0, width, height);
+				} else if (filling.imageContent?.image) {
+					const img2 = await cachedFetchImageBitmap(filling.imageContent.image);
+					ctx1.drawImage(img2, 0, 0, width, height);
+					img2.close();
+				}
+				effectCanvas = canvas1;
+			}
+			stroke?.forEach(({ width, color }) => {
+				effectCanvas = new ImageStroke().use((ctx, image, options) => {
+					const [, ctx1] = createCanvas(image.width, image.height);
+					ctx1.drawImage(image, 0, 0);
+					const paths = getContours(ctx1);
+					const x = options.thickness;
+					const y = options.thickness;
+					ctx.strokeStyle = options.color;
+					ctx.lineWidth = options.thickness * 2;
+					ctx.lineJoin = "round";
+					paths.forEach((path) => {
+						ctx.beginPath();
+						ctx.moveTo(x + path[0].x, y + path[1].y);
+						for (let i = 1; i < path.length; i++) ctx.lineTo(x + path[i].x, y + path[i].y);
+						ctx.closePath();
+					});
+					ctx.stroke();
+				}).make(effectCanvas, {
+					color,
+					thickness: width / 50 * imageEffectsRatio
+				});
+			});
+			if (offset) {
+				let { x, y } = offset;
+				x = x / 50 * imageEffectsRatio * 200;
+				y = y / 50 * imageEffectsRatio * 200;
+				ctx.drawImage(effectCanvas, x + center.x, y + center.y, width, height);
+			} else ctx.drawImage(effectCanvas, center.x, center.y, width, height);
+		}
+		canvasBitmap.close();
+	}
+	return await new Promise((resolve) => {
+		canvas.toBlob((blob) => {
+			try {
+				resolve(URL.createObjectURL(blob));
+			} catch (e) {
+				console.error(`Failed to URL.createObjectURL, url: ${url}`, e);
+				resolve(url);
+			}
+		});
+	});
+}
+function createCanvas(width, height, ratio = 1) {
+	const canvas = document.createElement("canvas");
+	canvas.width = width * ratio;
+	canvas.height = height * ratio;
+	canvas.style.width = `${width}px`;
+	canvas.style.height = `${height}px`;
+	const ctx = canvas.getContext("2d");
+	ctx.scale(ratio, ratio);
+	return [canvas, ctx];
+}
+var ImageStroke = class {
+	canvas = document.createElement("canvas");
+	method;
+	use(method) {
+		this.method = method;
+		return this;
+	}
+	make(image, options) {
+		const { canvas } = this;
+		const ctx = this.canvas.getContext("2d");
+		const strokeSize = options.thickness * 2;
+		const [resultWidth, resultHeight] = [image.width, image.height].map((val) => val + strokeSize);
+		if (resultWidth !== canvas.width || resultHeight !== canvas.height) {
+			canvas.width = resultWidth;
+			canvas.height = resultHeight;
+		}
+		ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
+		this.method(ctx, image, options);
+		ctx.drawImage(image, options.thickness, options.thickness);
+		return canvas;
+	}
+};
+function getContours(ctx) {
+	const cx = 0;
+	const cy = 0;
+	const canvasWidth = ctx.canvas.width;
+	const canvasHeight = ctx.canvas.height;
+	const paths = [];
+	let lastPos = 3;
+	const alpha = 100;
+	const trace = () => {
+		const path = [];
+		const data = new Uint32Array(ctx.getImageData(cx, cy, canvasWidth, canvasHeight).data.buffer);
+		let x;
+		let y;
+		let startX;
+		let startY;
+		let startPos = -1;
+		let step;
+		let prevStep = 9;
+		const steps = [
+			9,
+			0,
+			3,
+			3,
+			2,
+			0,
+			9,
+			3,
+			1,
+			9,
+			1,
+			1,
+			2,
+			0,
+			2,
+			9
+		];
+		let time = 50;
+		function getState(x, y) {
+			return x >= 0 && y >= 0 && x < canvasWidth && y < canvasHeight ? data[y * canvasWidth + x] >>> 24 > alpha : false;
+		}
+		function getNextStep(x, y) {
+			let v = 0;
+			if (getState(x - 1, y - 1)) v += 1;
+			if (getState(x, y - 1)) v += 2;
+			if (getState(x - 1, y)) v += 4;
+			if (getState(x, y)) v += 8;
+			if (time > 50) time += 10;
+			else time += 10;
+			if (v === 6) return prevStep === 0 ? 2 : 3;
+			else if (v === 9) return prevStep === 3 ? 0 : 1;
+			else return steps[v];
+		}
+		for (let i = lastPos; i < data.length; i++) if (data[i] >>> 24 > alpha) {
+			startPos = lastPos = i;
+			break;
+		}
+		if (startPos >= 0) {
+			x = startX = startPos % canvasWidth;
+			y = startY = Math.floor(startPos / canvasWidth);
+			do {
+				step = getNextStep(x, y);
+				if (step === 0) y--;
+				else if (step === 1) y++;
+				else if (step === 2) x--;
+				else if (step === 3) x++;
+				if (step !== prevStep) {
+					path.push({
+						x: x + cx,
+						y: y + cy
+					});
+					prevStep = step;
+				}
+			} while (x !== startX || y !== startY);
+		}
+		paths.push(path);
+		return path;
+	};
+	trace();
+	return paths;
+}
+//#endregion
 //#region src/convert/svg.ts
 async function convertSvgElementToUrl(el) {
 	const { id, doc, url, style = {}, background = {} } = el;
@@ -5724,25 +6329,23 @@ async function convertSvgElementToUrl(el) {
 	const svg = new DOMParser().parseFromString(xml.replace(new RegExp(`#el-${id} `, "gi"), "").replace(/data-colors\s/, " ").replace(/[a-z-]+="([^\s<]*<\S*)"/gi, ""), "image/svg+xml").documentElement;
 	if (!(svg instanceof SVGElement)) throw new TypeError(`Failed to DOMParser, parse svg to DOM error: ${xml}`);
 	const images = svg.querySelectorAll("image");
-	for (let i = 0; i < images.length; i++) {
-		const image = images[i];
+	await Promise.all(Array.from(images).map(async (image) => {
 		const url = image.href.baseVal;
-		if (!url.startsWith("http")) continue;
-		image?.setAttribute("href", await assets.fetchImageBitmap(url).then((bitmap) => {
-			const canvas = document.createElement("canvas");
-			canvas.width = bitmap.width;
-			canvas.height = bitmap.height;
-			canvas.getContext("2d")?.drawImage(bitmap, 0, 0);
-			bitmap.close();
-			return canvas.toDataURL("image/png");
-		}));
-	}
+		if (!url.startsWith("http")) return;
+		const bitmap = await cachedFetchImageBitmap(url);
+		const canvas = document.createElement("canvas");
+		canvas.width = bitmap.width;
+		canvas.height = bitmap.height;
+		canvas.getContext("2d")?.drawImage(bitmap, 0, 0);
+		bitmap.close();
+		image.setAttribute("href", canvas.toDataURL("image/png"));
+	}));
 	if (background.src) {
 		const fillId = `#${id}-fill-blip`;
 		const fillPattern = svg.querySelector(fillId);
 		const fillImage = fillPattern?.querySelector("image");
 		if (fillPattern && fillImage) try {
-			const base64Url = await assets.fetchImageBitmap(background.src).then((bitmap) => {
+			const base64Url = await cachedFetchImageBitmap(background.src).then((bitmap) => {
 				const canvas = document.createElement("canvas");
 				canvas.width = bitmap.width;
 				canvas.height = bitmap.height;
@@ -6142,217 +6745,6 @@ async function convertDoc(doc, options = {}) {
 	};
 }
 //#endregion
-//#region src/convert/image.ts
-async function convertImageElementToUrl(el) {
-	const { cropping = {}, transform = {}, style = {}, maskUrl, imageEffects = [], imageEffectsRatio = 1 } = el;
-	const url = el.clipUrl || el.url;
-	const { translateX = 0, translateY = 0, zoom = 1 } = transform ?? {};
-	const { scaleX = 1, scaleY = 1, filter } = style;
-	if (translateX === 0 && translateY === 0 && zoom === 1 && scaleX === 1 && scaleY === 1 && !maskUrl && !filter && !imageEffects.length) return url;
-	const img = await assets.fetchImageBitmap(url);
-	const { originWidth = img.width, originHeight = img.height, imageWidth = originWidth, imageHeight = originHeight } = transform;
-	const { width = originWidth, height = originHeight } = style;
-	const dpr = window.devicePixelRatio || 1;
-	const [canvas, ctx] = createCanvas(width, height, dpr);
-	if (filter) ctx.filter = filter;
-	ctx.scale(scaleX, scaleY);
-	ctx.translate(scaleX < 0 ? -width : 0, scaleY < 0 ? -height : 0);
-	if (maskUrl) {
-		const mask = await assets.fetchImageBitmap(maskUrl);
-		ctx.drawImage(mask, 0, 0, cropping?.maskWidth ?? width, cropping?.maskHeight ?? height);
-		ctx.globalCompositeOperation = "source-in";
-		mask.close();
-	}
-	const dw = imageWidth * zoom;
-	const dh = imageHeight * zoom;
-	const dx = -(dw / 2 - imageWidth / 2) + translateX;
-	const dy = -(dh / 2 - imageHeight / 2) + translateY;
-	ctx.drawImage(img, 0, 0, img.width, img.height, dx, dy, dw, dh);
-	img.close();
-	ctx.globalCompositeOperation = "source-over";
-	if (imageEffects.length > 0) {
-		const scale = .9;
-		const center = {
-			x: (width - width * scale) / 2,
-			y: (height - height * scale) / 2
-		};
-		const canvasBitmap = await createImageBitmap(canvas);
-		ctx.clearRect(0, 0, canvas.width, canvas.height);
-		ctx.scale(scale, scale);
-		for (let i = imageEffects.length - 1; i >= 0; i--) {
-			const { filling, offset, stroke } = imageEffects[i];
-			let effectCanvas = canvasBitmap;
-			if (filling) {
-				const [canvas1, ctx1] = createCanvas(width, height, dpr);
-				ctx1.drawImage(effectCanvas, 0, 0, width, height);
-				ctx1.globalCompositeOperation = "source-in";
-				if (filling.color) {
-					const [canvas2, ctx2] = createCanvas(width, height, dpr);
-					ctx2.fillStyle = filling.color;
-					ctx2.fillRect(0, 0, width, height);
-					ctx1.drawImage(canvas2, 0, 0, width, height);
-				} else if (filling.imageContent?.image) {
-					const img2 = await assets.fetchImageBitmap(filling.imageContent.image);
-					ctx1.drawImage(img2, 0, 0, width, height);
-					img2.close();
-				}
-				effectCanvas = canvas1;
-			}
-			stroke?.forEach(({ width, color }) => {
-				effectCanvas = new ImageStroke().use((ctx, image, options) => {
-					const [, ctx1] = createCanvas(image.width, image.height);
-					ctx1.drawImage(image, 0, 0);
-					const paths = getContours(ctx1);
-					const x = options.thickness;
-					const y = options.thickness;
-					ctx.strokeStyle = options.color;
-					ctx.lineWidth = options.thickness * 2;
-					ctx.lineJoin = "round";
-					paths.forEach((path) => {
-						ctx.beginPath();
-						ctx.moveTo(x + path[0].x, y + path[1].y);
-						for (let i = 1; i < path.length; i++) ctx.lineTo(x + path[i].x, y + path[i].y);
-						ctx.closePath();
-					});
-					ctx.stroke();
-				}).make(effectCanvas, {
-					color,
-					thickness: width / 50 * imageEffectsRatio
-				});
-			});
-			if (offset) {
-				let { x, y } = offset;
-				x = x / 50 * imageEffectsRatio * 200;
-				y = y / 50 * imageEffectsRatio * 200;
-				ctx.drawImage(effectCanvas, x + center.x, y + center.y, width, height);
-			} else ctx.drawImage(effectCanvas, center.x, center.y, width, height);
-		}
-		canvasBitmap.close();
-	}
-	return await new Promise((resolve) => {
-		canvas.toBlob((blob) => {
-			try {
-				resolve(URL.createObjectURL(blob));
-			} catch (e) {
-				console.error(`Failed to URL.createObjectURL, url: ${url}`, e);
-				resolve(url);
-			}
-		});
-	});
-}
-function createCanvas(width, height, ratio = 1) {
-	const canvas = document.createElement("canvas");
-	canvas.width = width * ratio;
-	canvas.height = height * ratio;
-	canvas.style.width = `${width}px`;
-	canvas.style.height = `${height}px`;
-	const ctx = canvas.getContext("2d");
-	ctx.scale(ratio, ratio);
-	return [canvas, ctx];
-}
-var ImageStroke = class {
-	canvas = document.createElement("canvas");
-	method;
-	use(method) {
-		this.method = method;
-		return this;
-	}
-	make(image, options) {
-		const { canvas } = this;
-		const ctx = this.canvas.getContext("2d");
-		const strokeSize = options.thickness * 2;
-		const [resultWidth, resultHeight] = [image.width, image.height].map((val) => val + strokeSize);
-		if (resultWidth !== canvas.width || resultHeight !== canvas.height) {
-			canvas.width = resultWidth;
-			canvas.height = resultHeight;
-		}
-		ctx.clearRect(0, 0, ctx.canvas.width, ctx.canvas.height);
-		this.method(ctx, image, options);
-		ctx.drawImage(image, options.thickness, options.thickness);
-		return canvas;
-	}
-};
-function getContours(ctx) {
-	const cx = 0;
-	const cy = 0;
-	const canvasWidth = ctx.canvas.width;
-	const canvasHeight = ctx.canvas.height;
-	const paths = [];
-	let lastPos = 3;
-	const alpha = 100;
-	const trace = () => {
-		const path = [];
-		const data = new Uint32Array(ctx.getImageData(cx, cy, canvasWidth, canvasHeight).data.buffer);
-		let x;
-		let y;
-		let startX;
-		let startY;
-		let startPos = -1;
-		let step;
-		let prevStep = 9;
-		const steps = [
-			9,
-			0,
-			3,
-			3,
-			2,
-			0,
-			9,
-			3,
-			1,
-			9,
-			1,
-			1,
-			2,
-			0,
-			2,
-			9
-		];
-		let time = 50;
-		function getState(x, y) {
-			return x >= 0 && y >= 0 && x < canvasWidth && y < canvasHeight ? data[y * canvasWidth + x] >>> 24 > alpha : false;
-		}
-		function getNextStep(x, y) {
-			let v = 0;
-			if (getState(x - 1, y - 1)) v += 1;
-			if (getState(x, y - 1)) v += 2;
-			if (getState(x - 1, y)) v += 4;
-			if (getState(x, y)) v += 8;
-			if (time > 50) time += 10;
-			else time += 10;
-			if (v === 6) return prevStep === 0 ? 2 : 3;
-			else if (v === 9) return prevStep === 3 ? 0 : 1;
-			else return steps[v];
-		}
-		for (let i = lastPos; i < data.length; i++) if (data[i] >>> 24 > alpha) {
-			startPos = lastPos = i;
-			break;
-		}
-		if (startPos >= 0) {
-			x = startX = startPos % canvasWidth;
-			y = startY = Math.floor(startPos / canvasWidth);
-			do {
-				step = getNextStep(x, y);
-				if (step === 0) y--;
-				else if (step === 1) y++;
-				else if (step === 2) x--;
-				else if (step === 3) x++;
-				if (step !== prevStep) {
-					path.push({
-						x: x + cx,
-						y: y + cy
-					});
-					prevStep = step;
-				}
-			} while (x !== startX || y !== startY);
-		}
-		paths.push(path);
-		return path;
-	};
-	trace();
-	return paths;
-}
-//#endregion
 //#region src/loaders/bidTid.ts
 function bidTidLoader(editor, api) {
 	const { config, http } = editor;
@@ -6572,4 +6964,4 @@ var options = {
 //#region src/index.ts
 var src_default = plugin;
 //#endregion
-export { bidTidLoader, bigeLoader, clipboardLoader, convertAnimation, convertBackground, convertDoc, convertElement, convertImageElementToUrl, convertLayout, convertSvgElementToUrl, convertTextContent, convertTextEffects, convertTextStyle, croppingToCropRect, src_default as default, getStyle, getTextContents, options, parseAnimations, plugin, transformToCropRect, useFonts };
+export { bidTidLoader, bigeLoader, cachedFetchImageBitmap, clipboardLoader, convertAnimation, convertBackground, convertDoc, convertElement, convertImageElementToUrl, convertLayout, convertSvgElementToUrl, convertTextContent, convertTextEffects, convertTextStyle, croppingToCropRect, src_default as default, getStyle, getTextContents, options, parseAnimations, plugin, transformToCropRect, useFonts };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@mce/bigesj",
   "type": "module",
-  "version": "0.18.4",
+  "version": "0.19.0",
   "description": "Plugin for mce",
   "author": "wxm",
   "license": "MIT",
@@ -46,10 +46,10 @@
   ],
   "dependencies": {
     "fflate": "^0.8.3",
-    "modern-openxml": "^1.10.1"
+    "modern-openxml": "^1.12.3"
   },
   "devDependencies": {
-    "mce": "0.18.4"
+    "mce": "0.19.0"
   },
   "peerDependencies": {
     "mce": "^0"