pa_font 0.2.4 → 0.2.6

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);
+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,
@@ -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)
 	};
 }
@@ -696,26 +848,31 @@ var PAShape = class {
 function createTextShape(layout, opts, fontInstance) {
 	const parts = [];
 	const contours = [];
-	const glyphs = [];
-	const sourceLayoutGlyphs = Array.isArray(layout.glyphs) ? layout.glyphs.slice() : [];
+	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)
 	};
-	layout.glyphs.forEach((item, glyphPosition) => {
+	for (let glyphPosition = 0; glyphPosition < glyphCount; glyphPosition++) {
+		const item = layoutGlyphs[glyphPosition];
 		const translated = translateGlyphGeometry(fontInstance._getGlyphGeometryVariant(item.glyph, opts), item.x, item.y, glyphPosition);
-		parts.push(...translated.parts);
-		contours.push(...translated.contours);
-		glyphs.push({
+		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,
@@ -809,8 +966,8 @@ function createDerivedShape(shape, parts) {
 }
 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 }
 	}));
 }
@@ -820,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 }
 	};
@@ -830,7 +987,7 @@ function copyContours(contours) {
 	return contours.map((contour) => ({
 		...contour,
 		bbox: { ...contour.bbox },
-		ring: copyRing(contour.ring)
+		ring: copyRing$1(contour.ring)
 	}));
 }
 function groupPartsByGlyphPosition(parts) {
@@ -946,76 +1103,108 @@ function resolveGeometryEpsilon(width) {
 }
 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;
@@ -1142,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) {
@@ -1157,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);
@@ -1178,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;
@@ -3573,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,
@@ -4112,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);
 }