pa_font 0.2.3 → 0.2.5

package/dist/paFont.cjs

@@ -7,52 +7,127 @@ let opentype_js = require("opentype.js");
 function toScreenPoint(point, scale) {
 	return [point.x * scale, -point.y * scale];
 }
-function cloneRawPoint(point) {
-	return {
-		x: point.x,
-		y: point.y
-	};
-}
 function pushUniquePoint(points, point) {
-	if (points.length === 0 || !pointsEqual2D(points[points.length - 1], point)) points.push(point);
-}
-function flattenQuadratic(p0, p1, p2, tolerance, out, depth = 0) {
-	if (depth >= 12 || quadFlatness(p0, p1, p2) <= tolerance) {
-		pushUniquePoint(out, p2);
-		return;
-	}
-	const p01 = midpoint(p0, p1);
-	const p12 = midpoint(p1, p2);
-	const p012 = midpoint(p01, p12);
-	flattenQuadratic(p0, p01, p012, tolerance, out, depth + 1);
-	flattenQuadratic(p012, p12, p2, tolerance, out, depth + 1);
-}
-function flattenCubic(p0, p1, p2, p3, tolerance, out, depth = 0) {
-	if (depth >= 12 || cubicFlatness(p0, p1, p2, p3) <= tolerance) {
-		pushUniquePoint(out, p3);
-		return;
-	}
-	const p01 = midpoint(p0, p1);
-	const p12 = midpoint(p1, p2);
-	const p23 = midpoint(p2, p3);
-	const p012 = midpoint(p01, p12);
-	const p123 = midpoint(p12, p23);
-	const p0123 = midpoint(p012, p123);
-	flattenCubic(p0, p01, p012, p0123, tolerance, out, depth + 1);
-	flattenCubic(p0123, p123, p23, p3, tolerance, out, depth + 1);
-}
-function quadFlatness(p0, p1, p2) {
-	return pointToLineDistance(p1, p0, p2);
-}
-function cubicFlatness(p0, p1, p2, p3) {
-	return Math.max(pointToLineDistance(p1, p0, p3), pointToLineDistance(p2, p0, p3));
-}
-function pointToLineDistance(point, lineStart, lineEnd) {
-	const dx = lineEnd[0] - lineStart[0];
-	const dy = lineEnd[1] - lineStart[1];
-	const lengthSq = dx * dx + dy * dy;
-	if (lengthSq === 0) return distance(point, lineStart);
-	return Math.abs(dx * (lineStart[1] - point[1]) - (lineStart[0] - point[0]) * dy) / Math.sqrt(lengthSq);
+	if (points.length === 0 || !pointsEqual2D$1(points[points.length - 1], point)) points.push(point);
+}
+function flattenQuadratic(p0, p1, p2, tolerance, out) {
+	let sp = 0;
+	const stack = _quadStack;
+	stack[sp++] = p0[0];
+	stack[sp++] = p0[1];
+	stack[sp++] = p1[0];
+	stack[sp++] = p1[1];
+	stack[sp++] = p2[0];
+	stack[sp++] = p2[1];
+	stack[sp++] = 0;
+	while (sp > 0) {
+		const depth = stack[--sp];
+		const ax2 = stack[--sp];
+		const ay2 = stack[--sp];
+		const ax1 = stack[--sp];
+		const ay1 = stack[--sp];
+		const ax0 = stack[--sp];
+		const ay0 = stack[--sp];
+		if (depth >= 12 || _quadFlatnessInline(ax0, ay0, ax1, ay1, ax2, ay2) <= tolerance) {
+			pushUniquePoint(out, [ax2, ay2]);
+			continue;
+		}
+		const m01x = (ax0 + ax1) * .5, m01y = (ay0 + ay1) * .5;
+		const m12x = (ax1 + ax2) * .5, m12y = (ay1 + ay2) * .5;
+		const mx = (m01x + m12x) * .5, my = (m01y + m12y) * .5;
+		const d1 = depth + 1;
+		stack[sp++] = mx;
+		stack[sp++] = my;
+		stack[sp++] = m12x;
+		stack[sp++] = m12y;
+		stack[sp++] = ax2;
+		stack[sp++] = ay2;
+		stack[sp++] = d1;
+		stack[sp++] = ax0;
+		stack[sp++] = ay0;
+		stack[sp++] = m01x;
+		stack[sp++] = m01y;
+		stack[sp++] = mx;
+		stack[sp++] = my;
+		stack[sp++] = d1;
+	}
+}
+function flattenCubic(p0, p1, p2, p3, tolerance, out) {
+	let sp = 0;
+	const stack = _cubicStack;
+	stack[sp++] = p0[0];
+	stack[sp++] = p0[1];
+	stack[sp++] = p1[0];
+	stack[sp++] = p1[1];
+	stack[sp++] = p2[0];
+	stack[sp++] = p2[1];
+	stack[sp++] = p3[0];
+	stack[sp++] = p3[1];
+	stack[sp++] = 0;
+	while (sp > 0) {
+		const depth = stack[--sp];
+		const bx3 = stack[--sp];
+		const by3 = stack[--sp];
+		const bx2 = stack[--sp];
+		const by2 = stack[--sp];
+		const bx1 = stack[--sp];
+		const by1 = stack[--sp];
+		const bx0 = stack[--sp];
+		const by0 = stack[--sp];
+		if (depth >= 12 || _cubicFlatnessInline(bx0, by0, bx1, by1, bx2, by2, bx3, by3) <= tolerance) {
+			pushUniquePoint(out, [bx3, by3]);
+			continue;
+		}
+		const m01x = (bx0 + bx1) * .5, m01y = (by0 + by1) * .5;
+		const m12x = (bx1 + bx2) * .5, m12y = (by1 + by2) * .5;
+		const m23x = (bx2 + bx3) * .5, m23y = (by2 + by3) * .5;
+		const m012x = (m01x + m12x) * .5, m012y = (m01y + m12y) * .5;
+		const m123x = (m12x + m23x) * .5, m123y = (m12y + m23y) * .5;
+		const mx = (m012x + m123x) * .5, my = (m012y + m123y) * .5;
+		const d1 = depth + 1;
+		stack[sp++] = mx;
+		stack[sp++] = my;
+		stack[sp++] = m123x;
+		stack[sp++] = m123y;
+		stack[sp++] = m23x;
+		stack[sp++] = m23y;
+		stack[sp++] = bx3;
+		stack[sp++] = by3;
+		stack[sp++] = d1;
+		stack[sp++] = bx0;
+		stack[sp++] = by0;
+		stack[sp++] = m01x;
+		stack[sp++] = m01y;
+		stack[sp++] = m012x;
+		stack[sp++] = m012y;
+		stack[sp++] = mx;
+		stack[sp++] = my;
+		stack[sp++] = d1;
+	}
+}
+var _quadStack = new Float64Array(896);
+var _cubicStack = new Float64Array(1152);
+function _quadFlatnessInline(x0, y0, x1, y1, x2, y2) {
+	const dx = x2 - x0, dy = y2 - y0;
+	const lenSq = dx * dx + dy * dy;
+	if (lenSq === 0) {
+		const ex = x1 - x0, ey = y1 - y0;
+		return Math.sqrt(ex * ex + ey * ey);
+	}
+	return Math.abs(dx * (y0 - y1) - (x0 - x1) * dy) / Math.sqrt(lenSq);
+}
+function _cubicFlatnessInline(x0, y0, x1, y1, x2, y2, x3, y3) {
+	const dx = x3 - x0, dy = y3 - y0;
+	const lenSq = dx * dx + dy * dy;
+	if (lenSq === 0) {
+		const e1x = x1 - x0, e1y = y1 - y0;
+		const e2x = x2 - x0, e2y = y2 - y0;
+		return Math.max(Math.sqrt(e1x * e1x + e1y * e1y), Math.sqrt(e2x * e2x + e2y * e2y));
+	}
+	const invLen = 1 / Math.sqrt(lenSq);
+	const a1 = Math.abs(dx * (y0 - y1) - (x0 - x1) * dy);
+	const a2 = Math.abs(dx * (y0 - y2) - (x0 - x2) * dy);
+	return Math.max(a1, a2) * invLen;
 }
 function midpoint(a, b) {
 	return [(a[0] + b[0]) * .5, (a[1] + b[1]) * .5];
@@ -110,28 +185,37 @@ function distance(a, b) {
 	return Math.sqrt(dx * dx + dy * dy);
 }
 function sampleRing(ring, step, callback) {
-	for (let index = 0; index < ring.length; index += 1) {
+	const len = ring.length;
+	for (let index = 0; index < len; index++) {
 		const a = ring[index];
-		const b = ring[(index + 1) % ring.length];
-		const segmentLength = distance(a, b);
+		const b = ring[(index + 1) % len];
+		const dx = b[0] - a[0], dy = b[1] - a[1];
+		const segmentLength = Math.sqrt(dx * dx + dy * dy);
 		const divisions = Math.max(1, Math.ceil(segmentLength / step));
-		for (let offset = 0; offset < divisions; offset += 1) if (index > 0 || offset > 0) {
+		if (index === 0) {
+			callback([a[0], a[1]]);
+			for (let offset = 1; offset < divisions; offset++) {
+				const t = offset / divisions;
+				callback([a[0] + dx * t, a[1] + dy * t]);
+			}
+		} else for (let offset = 0; offset < divisions; offset++) {
 			const t = offset / divisions;
-			callback([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
-		} else callback([a[0], a[1]]);
+			callback([a[0] + dx * t, a[1] + dy * t]);
+		}
 	}
 }
 function ringBounds(ring) {
-	let minX = Number.POSITIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	ring.forEach((point) => {
-		minX = Math.min(minX, point[0]);
-		minY = Math.min(minY, point[1]);
-		maxX = Math.max(maxX, point[0]);
-		maxY = Math.max(maxY, point[1]);
-	});
+	let minX = ring[0][0];
+	let minY = ring[0][1];
+	let maxX = minX;
+	let maxY = minY;
+	for (let i = 1, len = ring.length; i < len; i++) {
+		const x = ring[i][0], y = ring[i][1];
+		if (x < minX) minX = x;
+		else if (x > maxX) maxX = x;
+		if (y < minY) minY = y;
+		else if (y > maxY) maxY = y;
+	}
 	return {
 		x: minX,
 		y: minY,
@@ -140,7 +224,10 @@ function ringBounds(ring) {
 	};
 }
 function translateRing(ring, tx, ty) {
-	return ring.map((point) => [point[0] + tx, point[1] + ty]);
+	const len = ring.length;
+	const result = new Array(len);
+	for (let i = 0; i < len; i++) result[i] = [ring[i][0] + tx, ring[i][1] + ty];
+	return result;
 }
 function translateRect(rect, tx, ty) {
 	return {
@@ -150,21 +237,29 @@ function translateRect(rect, tx, ty) {
 		h: rect.h
 	};
 }
-function copyRing(ring) {
-	return ring.map((point) => [point[0], point[1]]);
+function copyRing$1(ring) {
+	const len = ring.length;
+	const result = new Array(len);
+	for (let i = 0; i < len; i++) result[i] = [ring[i][0], ring[i][1]];
+	return result;
 }
 function combineRects(rects) {
-	if (rects.length === 0) return null;
-	let minX = Number.POSITIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	rects.forEach((rect) => {
-		minX = Math.min(minX, rect.x);
-		minY = Math.min(minY, rect.y);
-		maxX = Math.max(maxX, rect.x + rect.w);
-		maxY = Math.max(maxY, rect.y + rect.h);
-	});
+	const len = rects.length;
+	if (len === 0) return null;
+	const first = rects[0];
+	let minX = first.x;
+	let minY = first.y;
+	let maxX = first.x + first.w;
+	let maxY = first.y + first.h;
+	for (let i = 1; i < len; i++) {
+		const r = rects[i];
+		const rx = r.x, ry = r.y;
+		const rx2 = rx + r.w, ry2 = ry + r.h;
+		if (rx < minX) minX = rx;
+		if (ry < minY) minY = ry;
+		if (rx2 > maxX) maxX = rx2;
+		if (ry2 > maxY) maxY = ry2;
+	}
 	return {
 		x: minX,
 		y: minY,
@@ -195,7 +290,7 @@ function normalizePositive(value, fallback) {
 function samePoint(a, b) {
 	return a.x === b.x && a.y === b.y;
 }
-function pointsEqual2D(a, b) {
+function pointsEqual2D$1(a, b) {
 	return a[0] === b[0] && a[1] === b[1];
 }
 function pointsAlmostEqual2D(a, b, epsilon = 1e-6) {
@@ -206,43 +301,64 @@ function ringPerimeter(ring) {
 	for (let index = 0; index < ring.length; index += 1) total += distance(ring[index], ring[(index + 1) % ring.length]);
 	return total;
 }
-function polylineLength(path) {
+function buildCumulativeDistances(ring) {
+	const len = ring.length;
+	const cumulative = new Float64Array(len + 1);
 	let total = 0;
-	for (let index = 0; index < path.length - 1; index += 1) total += distance(path[index], path[index + 1]);
-	return total;
-}
-function pointAtClosedPathDistance(ring, distanceAlong) {
-	const perimeter = ringPerimeter(ring);
+	for (let i = 0; i < len; i++) {
+		cumulative[i] = total;
+		const next = (i + 1) % len;
+		const dx = ring[next][0] - ring[i][0];
+		const dy = ring[next][1] - ring[i][1];
+		total += Math.sqrt(dx * dx + dy * dy);
+	}
+	cumulative[len] = total;
+	return cumulative;
+}
+function buildOpenCumulativeDistances(path) {
+	const len = path.length;
+	const cumulative = new Float64Array(len);
+	let total = 0;
+	cumulative[0] = 0;
+	for (let i = 1; i < len; i++) {
+		const dx = path[i][0] - path[i - 1][0];
+		const dy = path[i][1] - path[i - 1][1];
+		total += Math.sqrt(dx * dx + dy * dy);
+		cumulative[i] = total;
+	}
+	return cumulative;
+}
+function binarySearchSegment(cumulative, d) {
+	let lo = 0, hi = cumulative.length - 2;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >>> 1;
+		if (cumulative[mid] <= d) lo = mid;
+		else hi = mid - 1;
+	}
+	return lo;
+}
+function pointAtClosedPathDistanceFast(ring, cumulative, distanceAlong) {
+	const perimeter = cumulative[ring.length];
 	if (perimeter <= 1e-9) return [ring[0][0], ring[0][1]];
-	let remaining = mod(distanceAlong, perimeter);
-	for (let index = 0; index < ring.length; index += 1) {
-		const start = ring[index];
-		const end = ring[(index + 1) % ring.length];
-		const segmentLength = distance(start, end);
-		if (segmentLength <= 1e-9) continue;
-		if (remaining <= segmentLength) {
-			const t = remaining / segmentLength;
-			return [start[0] + (end[0] - start[0]) * t, start[1] + (end[1] - start[1]) * t];
-		}
-		remaining -= segmentLength;
-	}
-	return [ring[ring.length - 1][0], ring[ring.length - 1][1]];
-}
-function pointAtOpenPathDistance(path, distanceAlong) {
+	const d = mod(distanceAlong, perimeter);
+	const idx = binarySearchSegment(cumulative, d);
+	const segLen = cumulative[idx + 1] - cumulative[idx];
+	if (segLen <= 1e-9) return [ring[idx][0], ring[idx][1]];
+	const t = (d - cumulative[idx]) / segLen;
+	const start = ring[idx];
+	const end = ring[(idx + 1) % ring.length];
+	return [start[0] + (end[0] - start[0]) * t, start[1] + (end[1] - start[1]) * t];
+}
+function pointAtOpenPathDistanceFast(path, cumulative, distanceAlong) {
 	if (distanceAlong <= 0) return [path[0][0], path[0][1]];
-	let remaining = distanceAlong;
-	for (let index = 0; index < path.length - 1; index += 1) {
-		const start = path[index];
-		const end = path[index + 1];
-		const segmentLength = distance(start, end);
-		if (segmentLength <= 1e-9) continue;
-		if (remaining <= segmentLength) {
-			const t = remaining / segmentLength;
-			return [start[0] + (end[0] - start[0]) * t, start[1] + (end[1] - start[1]) * t];
-		}
-		remaining -= segmentLength;
-	}
-	return [path[path.length - 1][0], path[path.length - 1][1]];
+	if (distanceAlong >= cumulative[path.length - 1]) return [path[path.length - 1][0], path[path.length - 1][1]];
+	const idx = binarySearchSegment(cumulative, distanceAlong);
+	const segLen = cumulative[idx + 1] - cumulative[idx];
+	if (segLen <= 1e-9) return [path[idx][0], path[idx][1]];
+	const t = (distanceAlong - cumulative[idx]) / segLen;
+	const start = path[idx];
+	const end = path[idx + 1];
+	return [start[0] + (end[0] - start[0]) * t, start[1] + (end[1] - start[1]) * t];
 }
 function segmentIntersectsRing(a, b, ring, ignoredEdges, epsilon) {
 	for (let index = 0; index < ring.length; index += 1) {
@@ -324,23 +440,28 @@ function buildGlyphTopology(glyph, fallbackUnitsPerEm) {
 			current = null;
 			return;
 		}
-		if (!samePoint(current.cursor, current.start)) {
-			current.segments.push({
-				type: "L",
-				from: cloneRawPoint(current.cursor),
-				to: cloneRawPoint(current.start)
-			});
-			current.cursor = cloneRawPoint(current.start);
-		}
+		if (!samePoint(current.cursor, current.start)) current.segments.push({
+			type: "L",
+			from: {
+				x: current.cursor.x,
+				y: current.cursor.y
+			},
+			to: {
+				x: current.start.x,
+				y: current.start.y
+			}
+		});
 		contours.push({
 			id: contourId++,
-			start: cloneRawPoint(current.start),
+			start: current.start,
 			segments: current.segments
 		});
 		current = null;
 	};
-	commands.forEach((cmd) => {
-		if (cmd.type === "M") {
+	for (let i = 0, len = commands.length; i < len; i++) {
+		const cmd = commands[i];
+		const type = cmd.type;
+		if (type === "M") {
 			finishCurrentContour();
 			current = {
 				start: {
@@ -353,47 +474,49 @@ function buildGlyphTopology(glyph, fallbackUnitsPerEm) {
 				},
 				segments: []
 			};
-			return;
+			continue;
 		}
-		if (!current) return;
-		if (cmd.type === "L") {
+		if (!current) continue;
+		if (type === "L") {
 			const to = {
 				x: cmd.x,
 				y: cmd.y
 			};
 			current.segments.push({
 				type: "L",
-				from: cloneRawPoint(current.cursor),
+				from: current.cursor,
 				to
 			});
-			current.cursor = cloneRawPoint(to);
-			return;
+			current.cursor = to;
+			continue;
 		}
-		if (cmd.type === "Q") {
+		if (type === "Q") {
+			const from = current.cursor;
 			const to = {
 				x: cmd.x,
 				y: cmd.y
 			};
 			current.segments.push({
 				type: "Q",
-				from: cloneRawPoint(current.cursor),
+				from,
 				c1: {
 					x: cmd.x1,
 					y: cmd.y1
 				},
 				to
 			});
-			current.cursor = cloneRawPoint(to);
-			return;
+			current.cursor = to;
+			continue;
 		}
-		if (cmd.type === "C") {
+		if (type === "C") {
+			const from = current.cursor;
 			const to = {
 				x: cmd.x,
 				y: cmd.y
 			};
 			current.segments.push({
 				type: "C",
-				from: cloneRawPoint(current.cursor),
+				from,
 				c1: {
 					x: cmd.x1,
 					y: cmd.y1
@@ -404,11 +527,11 @@ function buildGlyphTopology(glyph, fallbackUnitsPerEm) {
 				},
 				to
 			});
-			current.cursor = cloneRawPoint(to);
-			return;
+			current.cursor = to;
+			continue;
 		}
-		if (cmd.type === "Z") finishCurrentContour();
-	});
+		if (type === "Z") finishCurrentContour();
+	}
 	finishCurrentContour();
 	return {
 		glyphIndex: glyph.index,
@@ -432,18 +555,25 @@ function flattenGlyphTopology(topology, options) {
 }
 function flattenContour(contour, scale, tolerance) {
 	const ring = [];
-	pushUniquePoint(ring, toScreenPoint(contour.start, scale));
-	contour.segments.forEach((segment) => {
-		if (segment.type === "L") {
-			pushUniquePoint(ring, toScreenPoint(segment.to, scale));
-			return;
+	let cursor = toScreenPoint(contour.start, scale);
+	pushUniquePoint(ring, cursor);
+	const segments = contour.segments;
+	for (let i = 0, len = segments.length; i < len; i++) {
+		const segment = segments[i];
+		const type = segment.type;
+		if (type === "L") {
+			cursor = toScreenPoint(segment.to, scale);
+			pushUniquePoint(ring, cursor);
+		} else if (type === "Q") {
+			const to = toScreenPoint(segment.to, scale);
+			flattenQuadratic(cursor, toScreenPoint(segment.c1, scale), to, tolerance, ring);
+			cursor = to;
+		} else if (type === "C") {
+			const to = toScreenPoint(segment.to, scale);
+			flattenCubic(cursor, toScreenPoint(segment.c1, scale), toScreenPoint(segment.c2, scale), to, tolerance, ring);
+			cursor = to;
 		}
-		if (segment.type === "Q") {
-			flattenQuadratic(toScreenPoint(segment.from, scale), toScreenPoint(segment.c1, scale), toScreenPoint(segment.to, scale), tolerance, ring);
-			return;
-		}
-		if (segment.type === "C") flattenCubic(toScreenPoint(segment.from, scale), toScreenPoint(segment.c1, scale), toScreenPoint(segment.c2, scale), toScreenPoint(segment.to, scale), tolerance, ring);
-	});
+	}
 	if (ring.length > 1 && pointsEqual2D(ring[0], ring[ring.length - 1])) ring.pop();
 	if (ring.length < 3) return null;
 	const bbox = ringBounds(ring);
@@ -456,37 +586,45 @@ function flattenContour(contour, scale, tolerance) {
 	};
 }
 function classifyContours(contours) {
-	const result = contours.map((contour) => ({
-		...contour,
+	const len = contours.length;
+	const result = new Array(len);
+	for (let i = 0; i < len; i++) result[i] = {
+		...contours[i],
 		parentId: null,
 		depth: 0,
 		role: "outer"
-	}));
-	result.forEach((child) => {
+	};
+	const sortedByArea = result.slice().sort((a, b) => Math.abs(b.area) - Math.abs(a.area));
+	for (let ci = 0; ci < len; ci++) {
+		const child = result[ci];
+		const childAbsArea = Math.abs(child.area);
 		let parent = null;
 		let parentArea = Number.POSITIVE_INFINITY;
-		result.forEach((candidate) => {
-			if (candidate.id === child.id) return;
-			if (Math.abs(candidate.area) <= Math.abs(child.area)) return;
-			if (!rectContainsRect(candidate.bbox, child.bbox)) return;
-			if (!pointInRing(child.ring[0], candidate.ring)) return;
-			const candidateArea = Math.abs(candidate.area);
-			if (candidateArea < parentArea) {
-				parent = candidate;
-				parentArea = candidateArea;
-			}
-		});
+		for (let si = 0; si < len; si++) {
+			const candidate = sortedByArea[si];
+			const candidateAbsArea = Math.abs(candidate.area);
+			if (candidateAbsArea <= childAbsArea) break;
+			if (candidate.id === child.id) continue;
+			if (candidateAbsArea >= parentArea) continue;
+			if (!rectContainsRect(candidate.bbox, child.bbox)) continue;
+			if (!pointInRing(child.ring[0], candidate.ring)) continue;
+			parent = candidate;
+			parentArea = candidateAbsArea;
+		}
 		if (parent) child.parentId = parent.id;
-	});
+	}
 	const byId = new Map(result.map((contour) => [contour.id, contour]));
-	const resolveDepth = (contour) => {
-		if (contour.parentId == null) return 0;
-		return resolveDepth(byId.get(contour.parentId)) + 1;
-	};
-	result.forEach((contour) => {
-		contour.depth = resolveDepth(contour);
-		contour.role = contour.depth % 2 === 0 ? "outer" : "hole";
-	});
+	for (let i = 0; i < len; i++) {
+		const contour = result[i];
+		let depth = 0;
+		let current = contour;
+		while (current.parentId != null) {
+			depth++;
+			current = byId.get(current.parentId);
+		}
+		contour.depth = depth;
+		contour.role = depth % 2 === 0 ? "outer" : "hole";
+	}
 	return result;
 }
 function buildParts(contours) {
@@ -501,16 +639,26 @@ function buildParts(contours) {
 	});
 }
 function translateGlyphGeometry(geometry, tx, ty, glyphPosition) {
-	return {
-		parts: geometry.parts.map((part, partIndex) => ({
+	const srcParts = geometry.parts;
+	const srcContours = geometry.contours;
+	const partsLen = srcParts.length;
+	const contoursLen = srcContours.length;
+	const parts = new Array(partsLen);
+	const contours = new Array(contoursLen);
+	for (let i = 0; i < partsLen; i++) {
+		const part = srcParts[i];
+		parts[i] = {
 			outer: translateRing(part.outer, tx, ty),
 			holes: part.holes.map((hole) => translateRing(hole, tx, ty)),
 			bbox: translateRect(part.bbox, tx, ty),
 			area: part.area,
 			glyphPosition,
-			partIndex
-		})),
-		contours: geometry.contours.map((contour) => ({
+			partIndex: i
+		};
+	}
+	for (let i = 0; i < contoursLen; i++) {
+		const contour = srcContours[i];
+		contours[i] = {
 			id: `${glyphPosition}:${contour.id}`,
 			sourceId: contour.id,
 			glyphPosition,
@@ -520,7 +668,11 @@ function translateGlyphGeometry(geometry, tx, ty, glyphPosition) {
 			area: contour.area,
 			bbox: translateRect(contour.bbox, tx, ty),
 			ring: translateRing(contour.ring, tx, ty)
-		})),
+		};
+	}
+	return {
+		parts,
+		contours,
 		bbox: translateRect(geometry.bbox, tx, ty)
 	};
 }
@@ -560,13 +712,14 @@ function toArrayBuffer(value) {
 //#endregion
 //#region src/paFont/shape.js
 var PAShape = class {
-	constructor({ text, parts, contours, glyphs, bbox, metrics, edgeEpsilon }) {
+	constructor({ text, parts, contours, glyphs, bbox, metrics, edgeEpsilon, rawData }) {
 		this.text = text;
 		this.parts = parts;
 		this.bbox = bbox;
 		this.metrics = metrics;
 		this.edgeEpsilon = edgeEpsilon;
 		this.raw = {
+			...rawData ?? {},
 			contours,
 			glyphs
 		};
@@ -599,12 +752,23 @@ var PAShape = class {
 	toRegions(options = {}) {
 		return createRegionCollection(this.toShape(options));
 	}
+	toRegionViews(options = {}) {
+		return this.toShape(options)._getRegionViews();
+	}
 	openHoles(width) {
 		const slitWidth = normalizePositive(width, 0);
 		if (slitWidth <= 0 || !this.parts.some((part) => part.holes.length > 0)) return this;
 		const cacheKey = toCacheKey(slitWidth);
 		const cached = this._cache.openHoles.get(cacheKey);
 		if (cached) return cached;
+		const glyphVariant = createGlyphDerivedShape(this, {
+			openWidth: slitWidth,
+			step: 0
+		});
+		if (glyphVariant) {
+			this._cache.openHoles.set(cacheKey, glyphVariant);
+			return glyphVariant;
+		}
 		const geometryEpsilon = resolveGeometryEpsilon(slitWidth);
 		const shape = createDerivedShape(this, this.parts.map((part) => openPartWithSlit(part, slitWidth, geometryEpsilon)));
 		this._cache.openHoles.set(cacheKey, shape);
@@ -616,6 +780,14 @@ var PAShape = class {
 		const cacheKey = toCacheKey(spacing);
 		const cached = this._cache.resample.get(cacheKey);
 		if (cached) return cached;
+		const glyphVariant = createGlyphDerivedShape(this, {
+			openWidth: 0,
+			step: spacing
+		});
+		if (glyphVariant) {
+			this._cache.resample.set(cacheKey, glyphVariant);
+			return glyphVariant;
+		}
 		const shape = createDerivedShape(this, this.parts.map((part) => resamplePart(part, spacing)));
 		this._cache.resample.set(cacheKey, shape);
 		return shape;
@@ -676,21 +848,31 @@ var PAShape = class {
 function createTextShape(layout, opts, fontInstance) {
 	const parts = [];
 	const contours = [];
-	const glyphs = [];
-	layout.glyphs.forEach((item, glyphPosition) => {
-		const translated = translateGlyphGeometry(fontInstance._getFlattenedGlyph(item.glyph, opts), item.x, item.y, glyphPosition);
-		parts.push(...translated.parts);
-		contours.push(...translated.contours);
-		glyphs.push({
+	const layoutGlyphs = layout.glyphs;
+	const glyphCount = layoutGlyphs.length;
+	const glyphs = new Array(glyphCount);
+	const sourceLayoutGlyphs = Array.isArray(layoutGlyphs) ? layoutGlyphs.slice() : [];
+	const variantOptions = {
+		openWidth: normalizePositive(opts.openWidth, 0),
+		step: normalizePositive(opts.step, 0)
+	};
+	for (let glyphPosition = 0; glyphPosition < glyphCount; glyphPosition++) {
+		const item = layoutGlyphs[glyphPosition];
+		const translated = translateGlyphGeometry(fontInstance._getGlyphGeometryVariant(item.glyph, opts), item.x, item.y, glyphPosition);
+		const tParts = translated.parts;
+		const tContours = translated.contours;
+		for (let j = 0; j < tParts.length; j++) parts.push(tParts[j]);
+		for (let j = 0; j < tContours.length; j++) contours.push(tContours[j]);
+		glyphs[glyphPosition] = {
 			position: glyphPosition,
 			glyphIndex: item.glyph.index,
 			x: item.x,
 			y: item.y,
 			size: item.size,
 			bbox: translated.bbox,
-			partCount: translated.parts.length
-		});
-	});
+			partCount: tParts.length
+		};
+	}
 	const bbox = combineRects(parts.map((part) => part.bbox)) ?? emptyRect();
 	return new PAShape({
 		text: layout.text,
@@ -702,11 +884,21 @@ function createTextShape(layout, opts, fontInstance) {
 			...layout.metrics,
 			bbox
 		},
-		edgeEpsilon: opts.edgeEpsilon
+		edgeEpsilon: opts.edgeEpsilon,
+		rawData: {
+			fontInstance,
+			sourceLayout: {
+				glyphs: sourceLayoutGlyphs,
+				metrics: { ...layout.metrics }
+			},
+			sourceOptions: extractShapeSourceOptions(opts),
+			variantOptions
+		}
 	});
 }
 function createGlyphShape(shape, glyphPosition) {
 	const glyphMeta = shape.raw.glyphs?.[glyphPosition] ?? null;
+	const sourceGlyph = shape.raw.sourceLayout?.glyphs?.[glyphPosition] ?? null;
 	const parts = copyParts(shape.parts.filter((part) => part.glyphPosition === glyphPosition));
 	const contours = copyContours((shape.raw.contours ?? []).filter((contour) => contour.glyphPosition === glyphPosition));
 	const bbox = combineRects(parts.map((part) => part.bbox)) ?? (glyphMeta?.bbox ? { ...glyphMeta.bbox } : emptyRect());
@@ -727,14 +919,28 @@ function createGlyphShape(shape, glyphPosition) {
 			width: bbox.w,
 			bbox
 		},
-		edgeEpsilon: shape.edgeEpsilon
+		edgeEpsilon: shape.edgeEpsilon,
+		rawData: sourceGlyph && shape.raw.fontInstance ? {
+			fontInstance: shape.raw.fontInstance,
+			sourceLayout: {
+				glyphs: [sourceGlyph],
+				metrics: {
+					x: glyphMeta?.x ?? shape.metrics?.x ?? 0,
+					y: glyphMeta?.y ?? shape.metrics?.y ?? 0,
+					size: glyphMeta?.size ?? shape.metrics?.size ?? 0,
+					width: glyphMeta?.bbox?.w ?? bbox.w
+				}
+			},
+			sourceOptions: shape.raw.sourceOptions ?? null,
+			variantOptions: { ...shape.raw.variantOptions ?? zeroShapeVariant() }
+		} : void 0
 	});
 }
 function createDerivedShape(shape, parts) {
-	const copiedParts = copyParts(parts);
-	const bbox = combineRects(copiedParts.map((part) => part.bbox)) ?? emptyRect();
+	const bbox = combineRects(parts.map((part) => part.bbox)) ?? emptyRect();
+	const partsByGlyphPosition = groupPartsByGlyphPosition(parts);
 	const glyphs = (shape.raw.glyphs ?? []).map((glyph, glyphPosition) => {
-		const glyphParts = copiedParts.filter((part) => part.glyphPosition === glyphPosition);
+		const glyphParts = partsByGlyphPosition.get(glyphPosition) ?? [];
 		return {
 			...glyph,
 			bbox: combineRects(glyphParts.map((part) => part.bbox)) ?? (glyph.bbox ? { ...glyph.bbox } : emptyRect()),
@@ -743,7 +949,7 @@ function createDerivedShape(shape, parts) {
 	});
 	return new PAShape({
 		text: shape.text,
-		parts: copiedParts,
+		parts,
 		contours: [],
 		glyphs,
 		bbox,
@@ -751,13 +957,17 @@ function createDerivedShape(shape, parts) {
 			...shape.metrics,
 			bbox
 		},
-		edgeEpsilon: shape.edgeEpsilon
+		edgeEpsilon: shape.edgeEpsilon,
+		rawData: {
+			...shape.raw,
+			variantOptions: { ...shape.raw.variantOptions ?? zeroShapeVariant() }
+		}
 	});
 }
 function createRegionCollection(shape) {
 	return shape.parts.map((part) => ({
-		outer: copyRing(part.outer),
-		holes: part.holes.map((hole) => copyRing(hole)),
+		outer: copyRing$1(part.outer),
+		holes: part.holes.map((hole) => copyRing$1(hole)),
 		bbox: { ...part.bbox }
 	}));
 }
@@ -767,8 +977,8 @@ function copyParts(parts) {
 function copyPart(part) {
 	return {
 		...part,
-		outer: copyRing(part.outer),
-		holes: part.holes.map((hole) => copyRing(hole)),
+		outer: copyRing$1(part.outer),
+		holes: part.holes.map((hole) => copyRing$1(hole)),
 		anchors: part.anchors ? part.anchors.map((point) => [point[0], point[1]]) : void 0,
 		bbox: { ...part.bbox }
 	};
@@ -777,9 +987,19 @@ function copyContours(contours) {
 	return contours.map((contour) => ({
 		...contour,
 		bbox: { ...contour.bbox },
-		ring: copyRing(contour.ring)
+		ring: copyRing$1(contour.ring)
 	}));
 }
+function groupPartsByGlyphPosition(parts) {
+	const grouped = /* @__PURE__ */ new Map();
+	parts.forEach((part) => {
+		if (typeof part.glyphPosition !== "number") return;
+		const bucket = grouped.get(part.glyphPosition) ?? [];
+		bucket.push(part);
+		grouped.set(part.glyphPosition, bucket);
+	});
+	return grouped;
+}
 function extractGlyphText(text, glyphPosition, glyphCount) {
 	if (glyphCount <= 1) return text;
 	return Array.from(text ?? "")[glyphPosition] ?? "";
@@ -808,6 +1028,19 @@ function normalizeShapeOptions(options = {}) {
 		openWidth: normalizePositive(options.openWidth, 0)
 	};
 }
+function extractShapeSourceOptions(opts) {
+	return {
+		size: opts.size,
+		flatten: opts.flatten,
+		edgeEpsilon: opts.edgeEpsilon,
+		kerning: opts.kerning,
+		letterSpacing: opts.letterSpacing,
+		tracking: opts.tracking,
+		script: opts.script,
+		language: opts.language,
+		features: opts.features
+	};
+}
 function resolveShapeVariant(shape, options = {}) {
 	const normalized = normalizeShapeOptions(options);
 	if (normalized.step <= 0 && normalized.openWidth <= 0) return shape;
@@ -820,84 +1053,158 @@ function resolveShapeVariant(shape, options = {}) {
 	shape._cache.shapes.set(cacheKey, next);
 	return next;
 }
+function deriveGlyphGeometryVariant(geometry, options = {}) {
+	const normalized = normalizeShapeOptions(options);
+	if (normalized.step <= 0 && normalized.openWidth <= 0) return geometry;
+	let parts = geometry.parts;
+	if (normalized.openWidth > 0) {
+		const geometryEpsilon = resolveGeometryEpsilon(normalized.openWidth);
+		parts = parts.map((part) => openPartWithSlit(part, normalized.openWidth, geometryEpsilon));
+	}
+	if (normalized.step > 0) parts = parts.map((part) => resamplePart(part, normalized.step));
+	return {
+		...geometry,
+		contours: [],
+		parts,
+		bbox: combineRects(parts.map((part) => part.bbox)) ?? emptyRect()
+	};
+}
 function toCacheKey(value) {
 	return normalizePositive(value, 0).toFixed(6);
 }
+function zeroShapeVariant() {
+	return {
+		openWidth: 0,
+		step: 0
+	};
+}
+function createGlyphDerivedShape(shape, variant) {
+	if (!canUseGlyphDerivedShape(shape)) return null;
+	return createTextShape({
+		text: shape.text,
+		glyphs: shape.raw.sourceLayout.glyphs,
+		metrics: shape.raw.sourceLayout.metrics
+	}, {
+		...shape.raw.sourceOptions,
+		...mergeShapeVariantOptions(shape.raw.variantOptions, variant)
+	}, shape.raw.fontInstance);
+}
+function canUseGlyphDerivedShape(shape) {
+	return shape.raw?.fontInstance != null && shape.raw?.sourceOptions != null && shape.raw?.sourceLayout != null && Array.isArray(shape.raw.sourceLayout.glyphs);
+}
+function mergeShapeVariantOptions(previous, next) {
+	return {
+		openWidth: normalizePositive(next.openWidth, previous?.openWidth ?? 0),
+		step: normalizePositive(next.step, previous?.step ?? 0)
+	};
+}
 function resolveGeometryEpsilon(width) {
 	return Math.max(1e-4, normalizePositive(width, 1) * .001);
 }
 function openPartWithSlit(part, width, epsilon) {
 	if (!part.holes || part.holes.length === 0) return copyPart(part);
-	let outer = copyRing(part.outer);
-	const holes = part.holes.map((hole) => copyRing(hole));
+	let outer = copyRing$1(part.outer);
+	const holes = part.holes.map((hole) => copyRing$1(hole));
 	const anchors = [];
+	const blockers = [];
 	while (holes.length > 0) {
 		let selectedHoleIndex = -1;
 		let selectedBridge = null;
-		holes.forEach((hole, holeIndex) => {
-			const blockers = holes.filter((_, index) => index !== holeIndex);
-			const candidate = findBestHoleBridge(outer, hole, blockers, epsilon);
-			if (candidate && (!selectedBridge || candidate.distance < selectedBridge.distance)) {
+		let selectedDist = Number.POSITIVE_INFINITY;
+		for (let hi = 0; hi < holes.length; hi++) {
+			blockers.length = 0;
+			for (let bi = 0; bi < holes.length; bi++) if (bi !== hi) blockers.push(holes[bi]);
+			const candidate = findBestHoleBridge(outer, holes[hi], blockers, epsilon);
+			if (candidate && candidate.distance < selectedDist) {
 				selectedBridge = candidate;
-				selectedHoleIndex = holeIndex;
+				selectedHoleIndex = hi;
+				selectedDist = candidate.distance;
 			}
-		});
+		}
 		if (!selectedBridge || selectedHoleIndex === -1) break;
 		const [hole] = holes.splice(selectedHoleIndex, 1);
 		const merged = mergeHoleIntoOuter(outer, hole, selectedBridge, width, epsilon);
 		outer = merged.ring;
-		anchors.push(...merged.anchors);
+		const mergedAnchors = merged.anchors;
+		for (let i = 0; i < mergedAnchors.length; i++) anchors.push(mergedAnchors[i]);
 	}
+	let holeArea = 0;
+	for (let i = 0; i < holes.length; i++) holeArea += Math.abs(signedArea(holes[i]));
 	return {
 		...part,
 		outer,
 		holes,
 		anchors,
 		bbox: ringBounds(outer),
-		area: Math.abs(signedArea(outer)) - holes.reduce((sum, hole) => sum + Math.abs(signedArea(hole)), 0)
+		area: Math.abs(signedArea(outer)) - holeArea
 	};
 }
 function resamplePart(part, step) {
 	const outer = resampleRing(part.outer, step, part.anchors ?? []);
-	const holes = part.holes.map((hole) => resampleRing(hole, step));
+	const srcHoles = part.holes;
+	const holes = new Array(srcHoles.length);
+	let holeArea = 0;
+	for (let i = 0; i < srcHoles.length; i++) {
+		holes[i] = resampleRing(srcHoles[i], step);
+		holeArea += Math.abs(signedArea(holes[i]));
+	}
 	return {
 		...part,
 		outer,
 		holes,
 		anchors: part.anchors ? part.anchors.map((point) => [point[0], point[1]]) : void 0,
 		bbox: ringBounds(outer),
-		area: Math.abs(signedArea(outer)) - holes.reduce((sum, hole) => sum + Math.abs(signedArea(hole)), 0)
+		area: Math.abs(signedArea(outer)) - holeArea
 	};
 }
 function findBestHoleBridge(outer, hole, blockers, epsilon) {
 	let best = null;
-	outer.forEach((outerPoint, outerIndex) => {
-		hole.forEach((holePoint, holeIndex) => {
-			if (!isVisibleBridge(outer, hole, blockers, outerPoint, holePoint, outerIndex, holeIndex, epsilon)) return;
-			const candidate = {
-				outerIndex,
-				holeIndex,
-				distance: distance(outerPoint, holePoint)
+	let bestDist = Number.POSITIVE_INFINITY;
+	const outerLen = outer.length;
+	const holeLen = hole.length;
+	for (let oi = 0; oi < outerLen; oi++) {
+		const op = outer[oi];
+		for (let hi = 0; hi < holeLen; hi++) {
+			const hp = hole[hi];
+			const dx = op[0] - hp[0], dy = op[1] - hp[1];
+			const dist = Math.sqrt(dx * dx + dy * dy);
+			if (dist >= bestDist) continue;
+			if (!isVisibleBridge(outer, hole, blockers, op, hp, oi, hi, epsilon)) continue;
+			best = {
+				outerIndex: oi,
+				holeIndex: hi,
+				distance: dist
 			};
-			if (!best || candidate.distance < best.distance) best = candidate;
-		});
-	});
+			bestDist = dist;
+		}
+	}
 	if (best) return best;
 	return findNearestBridge(outer, hole);
 }
 function findNearestBridge(outer, hole) {
-	let best = null;
-	outer.forEach((outerPoint, outerIndex) => {
-		hole.forEach((holePoint, holeIndex) => {
-			const candidate = {
-				outerIndex,
-				holeIndex,
-				distance: distance(outerPoint, holePoint)
-			};
-			if (!best || candidate.distance < best.distance) best = candidate;
-		});
-	});
-	return best;
+	let bestOi = 0, bestHi = 0;
+	let bestDistSq = Number.POSITIVE_INFINITY;
+	const outerLen = outer.length;
+	const holeLen = hole.length;
+	for (let oi = 0; oi < outerLen; oi++) {
+		const op = outer[oi];
+		const ox = op[0], oy = op[1];
+		for (let hi = 0; hi < holeLen; hi++) {
+			const hp = hole[hi];
+			const dx = ox - hp[0], dy = oy - hp[1];
+			const distSq = dx * dx + dy * dy;
+			if (distSq < bestDistSq) {
+				bestDistSq = distSq;
+				bestOi = oi;
+				bestHi = hi;
+			}
+		}
+	}
+	return {
+		outerIndex: bestOi,
+		holeIndex: bestHi,
+		distance: Math.sqrt(bestDistSq)
+	};
 }
 function isVisibleBridge(outer, hole, blockers, outerPoint, holePoint, outerIndex, holeIndex, epsilon) {
 	if (distance(outerPoint, holePoint) <= epsilon) return false;
@@ -1024,7 +1331,7 @@ function normalizeCutLocation(name, ring, cut, epsilon) {
 	};
 }
 function ringPath(ring, startIndex, endIndex) {
-	if (startIndex == null || endIndex == null) return copyRing(ring);
+	if (startIndex == null || endIndex == null) return copyRing$1(ring);
 	const path = [ring[startIndex]];
 	let cursor = startIndex;
 	while (cursor !== endIndex) {
@@ -1039,7 +1346,7 @@ function appendPath(target, path, epsilon) {
 	});
 }
 function resampleRing(ring, step, anchors = []) {
-	if (ring.length < 3) return copyRing(ring);
+	if (ring.length < 3) return copyRing$1(ring);
 	const normalizedAnchors = normalizeAnchorPoints(ring, anchors);
 	if (normalizedAnchors.length >= 2) return resampleRingWithAnchors(ring, step, normalizedAnchors);
 	return resampleClosedPath(ring, step);
@@ -1060,30 +1367,32 @@ function resampleRingWithAnchors(ring, step, anchorIndices) {
 		appendPath(result, resampleOpenPath(ringPath(ring, startIndex, endIndex), step), 1e-6);
 	}
 	if (result.length > 1 && pointsAlmostEqual2D(result[0], result[result.length - 1], 1e-6)) result.pop();
-	if (result.length < 3 || result.length >= ring.length) return copyRing(ring);
+	if (result.length < 3 || result.length >= ring.length) return copyRing$1(ring);
 	return result;
 }
 function resampleClosedPath(ring, step) {
-	const perimeter = ringPerimeter(ring);
-	if (perimeter <= 1e-9) return copyRing(ring);
+	const cumulative = buildCumulativeDistances(ring);
+	const perimeter = cumulative[ring.length];
+	if (perimeter <= 1e-9) return copyRing$1(ring);
 	const pointCount = Math.max(3, Math.round(perimeter / step));
-	if (pointCount >= ring.length) return copyRing(ring);
+	if (pointCount >= ring.length) return copyRing$1(ring);
 	const sampled = [];
-	for (let index = 0; index < pointCount; index += 1) {
-		const point = pointAtClosedPathDistance(ring, perimeter * index / pointCount);
+	for (let index = 0; index < pointCount; index++) {
+		const point = pointAtClosedPathDistanceFast(ring, cumulative, perimeter * index / pointCount);
 		if (sampled.length === 0 || !pointsAlmostEqual2D(sampled[sampled.length - 1], point, 1e-6)) sampled.push(point);
 	}
-	if (sampled.length < 3 || sampled.length >= ring.length) return copyRing(ring);
+	if (sampled.length < 3 || sampled.length >= ring.length) return copyRing$1(ring);
 	return sampled;
 }
 function resampleOpenPath(path, step) {
 	if (path.length <= 2) return path.map((point) => [point[0], point[1]]);
-	const length = polylineLength(path);
+	const cumulative = buildOpenCumulativeDistances(path);
+	const length = cumulative[path.length - 1];
 	if (length <= step) return [[path[0][0], path[0][1]], [path[path.length - 1][0], path[path.length - 1][1]]];
 	const divisionCount = Math.max(1, Math.round(length / step));
 	const sampled = [];
-	for (let index = 0; index <= divisionCount; index += 1) {
-		const point = pointAtOpenPathDistance(path, length * index / divisionCount);
+	for (let index = 0; index <= divisionCount; index++) {
+		const point = pointAtOpenPathDistanceFast(path, cumulative, length * index / divisionCount);
 		if (sampled.length === 0 || !pointsAlmostEqual2D(sampled[sampled.length - 1], point, 1e-6)) sampled.push(point);
 	}
 	return sampled;
@@ -3184,9 +3493,11 @@ var DEFAULT_LINE_HEIGHT_RATIO = 1.2;
 var HUGE_LAYOUT_WIDTH = 1e9;
 var JUSTIFY_EPSILON = 1e-6;
 var QUOTE_RE = /"/g;
+var SHARED_MEASURE_CACHE_LIMIT = 2048;
 var sharedMeasureContext = null;
 var sharedWordSegmenter = null;
 var sharedGraphemeSegmenter = null;
+var sharedMeasureCaches = /* @__PURE__ */ new WeakMap();
 function layoutParagraph(fontInstance, text, options = {}, state = {}) {
 	const normalized = normalizeParagraphOptions(fontInstance, options);
 	const textValue = String(text ?? "");
@@ -3453,9 +3764,25 @@ function truncateLineToWidth(line, maxWidth, measureWidth, suffix) {
 		width: 0,
 		hardBreak: false
 	};
-	let nextText = trimTrailingWhitespace(line.text);
-	while (nextText.length > 0 && measureWidth(`${nextText}${suffixText}`) > maxWidth + JUSTIFY_EPSILON) nextText = trimLastGrapheme(nextText);
-	const text = `${nextText}${suffixText}`;
+	const trimmed = trimTrailingWhitespace(line.text);
+	if (measureWidth(`${trimmed}${suffixText}`) <= maxWidth + JUSTIFY_EPSILON) {
+		const text = `${trimmed}${suffixText}`;
+		return {
+			...line,
+			text,
+			width: measureWidth(text),
+			hardBreak: false
+		};
+	}
+	const segmenter = getGraphemeSegmenter();
+	const graphemes = Array.from(segmenter.segment(trimmed), (seg) => seg.segment);
+	let lo = 0, hi = graphemes.length;
+	while (lo < hi) {
+		const mid = lo + hi + 1 >>> 1;
+		if (measureWidth(graphemes.slice(0, mid).join("") + suffixText) <= maxWidth + JUSTIFY_EPSILON) lo = mid;
+		else hi = mid - 1;
+	}
+	const text = (lo > 0 ? graphemes.slice(0, lo).join("") : "") + suffixText;
 	return {
 		...line,
 		text,
@@ -3866,15 +4193,24 @@ function createTextMeasurer(fontInstance, options) {
 	const cache = /* @__PURE__ */ new Map();
 	const openTypeMeasurer = createOpenTypeMeasurer(fontInstance, options);
 	const context = getMeasureContext();
+	const sharedCache = getSharedMeasureCache(fontInstance, "canvas");
+	const sharedKeyPrefix = `${options.font}\u0000`;
 	return (value) => {
 		if (value.length === 0) return 0;
 		if (cache.has(value)) return cache.get(value);
+		const sharedKey = `${sharedKeyPrefix}${value}`;
+		const sharedWidth = readSharedMeasureCache(sharedCache, sharedKey);
+		if (sharedWidth != null) {
+			cache.set(value, sharedWidth);
+			return sharedWidth;
+		}
 		let width;
 		if (context) {
 			context.font = options.font;
 			width = context.measureText(value).width;
 		} else width = openTypeMeasurer(value);
 		cache.set(value, width);
+		writeSharedMeasureCache(sharedCache, sharedKey, width);
 		return width;
 	};
 }
@@ -3887,6 +4223,7 @@ function createLazyTextMeasurer(fontInstance, options) {
 }
 function createOpenTypeMeasurer(fontInstance, options) {
 	const cache = /* @__PURE__ */ new Map();
+	const sharedCache = getSharedMeasureCache(fontInstance, "openType");
 	const widthOptions = {
 		x: 0,
 		y: 0,
@@ -3900,11 +4237,19 @@ function createOpenTypeMeasurer(fontInstance, options) {
 		language: options.language,
 		features: options.features
 	};
+	const sharedKeyPrefix = createOpenTypeMeasureKeyPrefix(widthOptions);
 	return (value) => {
 		if (value.length === 0) return 0;
 		if (cache.has(value)) return cache.get(value);
+		const sharedKey = `${sharedKeyPrefix}${value}`;
+		const sharedWidth = readSharedMeasureCache(sharedCache, sharedKey);
+		if (sharedWidth != null) {
+			cache.set(value, sharedWidth);
+			return sharedWidth;
+		}
 		const width = measureAdvanceWidth(fontInstance.font, value, widthOptions);
 		cache.set(value, width);
+		writeSharedMeasureCache(sharedCache, sharedKey, width);
 		return width;
 	};
 }
@@ -3920,6 +4265,49 @@ function getMeasureContext() {
 	}
 	return null;
 }
+function getSharedMeasureCache(fontInstance, bucket) {
+	if (fontInstance == null || typeof fontInstance !== "object" && typeof fontInstance !== "function") return null;
+	let caches = sharedMeasureCaches.get(fontInstance);
+	if (!caches) {
+		caches = {
+			canvas: /* @__PURE__ */ new Map(),
+			openType: /* @__PURE__ */ new Map()
+		};
+		sharedMeasureCaches.set(fontInstance, caches);
+	}
+	return caches[bucket];
+}
+function readSharedMeasureCache(cache, key) {
+	if (!cache || !cache.has(key)) return null;
+	const value = cache.get(key);
+	cache.delete(key);
+	cache.set(key, value);
+	return value;
+}
+function writeSharedMeasureCache(cache, key, value) {
+	if (!cache) return;
+	if (cache.has(key)) cache.delete(key);
+	cache.set(key, value);
+	if (cache.size > SHARED_MEASURE_CACHE_LIMIT) {
+		const oldestKey = cache.keys().next().value;
+		cache.delete(oldestKey);
+	}
+}
+function createOpenTypeMeasureKeyPrefix(options) {
+	return [
+		options.size,
+		options.kerning ? 1 : 0,
+		options.letterSpacing ?? "",
+		options.tracking ?? "",
+		options.script ?? "",
+		options.language ?? "",
+		serializeMeasureFeatures(options.features)
+	].join("|") + "\0";
+}
+function serializeMeasureFeatures(features) {
+	if (!features || typeof features !== "object") return "";
+	return Object.keys(features).sort().map((key) => `${key}:${features[key]}`).join(",");
+}
 function getWordSegmenter() {
 	if (sharedWordSegmenter == null) sharedWordSegmenter = new Intl.Segmenter(void 0, { granularity: "word" });
 	return sharedWordSegmenter;
@@ -3931,12 +4319,6 @@ function getGraphemeSegmenter() {
 function trimTrailingWhitespace(value) {
 	return value.replace(/\s+$/u, "");
 }
-function trimLastGrapheme(value) {
-	const segmenter = getGraphemeSegmenter();
-	const graphemes = Array.from(segmenter.segment(value), (segment) => segment.segment);
-	graphemes.pop();
-	return graphemes.join("");
-}
 function splitPreservingWhitespace(value) {
 	return value.split(/(\s+)/u).filter((token) => token.length > 0);
 }
@@ -4015,6 +4397,10 @@ var paParagraph = class paParagraph {
 		const { layout = "current", ...shapeOptions } = normalizeParagraphShapeOptions(options, "toRegions()");
 		return this._getBaseShape(layout).toRegions(shapeOptions);
 	}
+	toRegionViews(options = {}) {
+		const { layout = "current", ...shapeOptions } = normalizeParagraphShapeOptions(options, "toRegionViews()");
+		return this._getBaseShape(layout).toRegionViews(shapeOptions);
+	}
 	toPoints(options = {}) {
 		const { layout = "current", ...pointOptions } = normalizeParagraphPointOptions(options);
 		return this._getBaseShape(layout).toPoints(pointOptions);
@@ -4150,6 +4536,7 @@ var paFont = class paFont {
 		this.canvasFamily = this.family;
 		this._glyphTopologyCache = /* @__PURE__ */ new Map();
 		this._glyphFlatCache = /* @__PURE__ */ new Map();
+		this._glyphVariantCache = /* @__PURE__ */ new Map();
 	}
 	static async load(source, options = {}) {
 		const opts = normalizeLoadOptions(options);
@@ -4227,10 +4614,27 @@ var paFont = class paFont {
 		}
 		return this._glyphFlatCache.get(key);
 	}
+	_getGlyphGeometryVariant(glyph, opts) {
+		const openWidth = normalizeShapeVariantValue(opts.openWidth);
+		const step = normalizeShapeVariantValue(opts.step);
+		if (openWidth <= 0 && step <= 0) return this._getFlattenedGlyph(glyph, opts);
+		const key = `${glyph.index}:${opts.size}:${opts.flatten}:${toShapeVariantKey(openWidth)}:${toShapeVariantKey(step)}`;
+		if (!this._glyphVariantCache.has(key)) this._glyphVariantCache.set(key, deriveGlyphGeometryVariant(this._getFlattenedGlyph(glyph, opts), {
+			openWidth,
+			step
+		}));
+		return this._glyphVariantCache.get(key);
+	}
 	_layoutText(value, opts) {
 		return layoutGlyphs(this.font, value, opts);
 	}
 };
+function normalizeShapeVariantValue(value) {
+	return Number.isFinite(value) && value > 0 ? Number(value) : 0;
+}
+function toShapeVariantKey(value) {
+	return normalizeShapeVariantValue(value).toFixed(6);
+}
 async function fetchFontBytes(source) {
 	const response = await fetch(source);
 	if (!response.ok) throw new Error(`Failed to load font from ${source}: ${response.status} ${response.statusText}`);