pa_font 0.2.6 → 0.2.8

package/dist/paFont.js

@@ -3,127 +3,52 @@ import { load, parse } from "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) {
-	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 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 midpoint(a, b) {
 	return [(a[0] + b[0]) * .5, (a[1] + b[1]) * .5];
@@ -181,37 +106,28 @@ function distance(a, b) {
 	return Math.sqrt(dx * dx + dy * dy);
 }
 function sampleRing(ring, step, callback) {
-	const len = ring.length;
-	for (let index = 0; index < len; index++) {
+	for (let index = 0; index < ring.length; index += 1) {
 		const a = ring[index];
-		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 b = ring[(index + 1) % ring.length];
+		const segmentLength = distance(a, b);
 		const divisions = Math.max(1, Math.ceil(segmentLength / step));
-		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++) {
+		for (let offset = 0; offset < divisions; offset += 1) if (index > 0 || offset > 0) {
 			const t = offset / divisions;
-			callback([a[0] + dx * t, a[1] + dy * t]);
-		}
+			callback([a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t]);
+		} else callback([a[0], a[1]]);
 	}
 }
 function ringBounds(ring) {
-	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;
-	}
+	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]);
+	});
 	return {
 		x: minX,
 		y: minY,
@@ -220,10 +136,7 @@ function ringBounds(ring) {
 	};
 }
 function translateRing(ring, tx, 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;
+	return ring.map((point) => [point[0] + tx, point[1] + ty]);
 }
 function translateRect(rect, tx, ty) {
 	return {
@@ -233,29 +146,21 @@ function translateRect(rect, tx, ty) {
 		h: rect.h
 	};
 }
-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 copyRing(ring) {
+	return ring.map((point) => [point[0], point[1]]);
 }
 function combineRects(rects) {
-	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;
-	}
+	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);
+	});
 	return {
 		x: minX,
 		y: minY,
@@ -297,64 +202,43 @@ function ringPerimeter(ring) {
 	for (let index = 0; index < ring.length; index += 1) total += distance(ring[index], ring[(index + 1) % ring.length]);
 	return total;
 }
-function buildCumulativeDistances(ring) {
-	const len = ring.length;
-	const cumulative = new Float64Array(len + 1);
-	let total = 0;
-	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);
+function polylineLength(path) {
 	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];
+	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);
 	if (perimeter <= 1e-9) return [ring[0][0], ring[0][1]];
-	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) {
+	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) {
 	if (distanceAlong <= 0) return [path[0][0], path[0][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];
+	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]];
 }
 function segmentIntersectsRing(a, b, ring, ignoredEdges, epsilon) {
 	for (let index = 0; index < ring.length; index += 1) {
@@ -436,28 +320,23 @@ function buildGlyphTopology(glyph, fallbackUnitsPerEm) {
 			current = null;
 			return;
 		}
-		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
-			}
-		});
+		if (!samePoint(current.cursor, current.start)) {
+			current.segments.push({
+				type: "L",
+				from: cloneRawPoint(current.cursor),
+				to: cloneRawPoint(current.start)
+			});
+			current.cursor = cloneRawPoint(current.start);
+		}
 		contours.push({
 			id: contourId++,
-			start: current.start,
+			start: cloneRawPoint(current.start),
 			segments: current.segments
 		});
 		current = null;
 	};
-	for (let i = 0, len = commands.length; i < len; i++) {
-		const cmd = commands[i];
-		const type = cmd.type;
-		if (type === "M") {
+	commands.forEach((cmd) => {
+		if (cmd.type === "M") {
 			finishCurrentContour();
 			current = {
 				start: {
@@ -470,49 +349,47 @@ function buildGlyphTopology(glyph, fallbackUnitsPerEm) {
 				},
 				segments: []
 			};
-			continue;
+			return;
 		}
-		if (!current) continue;
-		if (type === "L") {
+		if (!current) return;
+		if (cmd.type === "L") {
 			const to = {
 				x: cmd.x,
 				y: cmd.y
 			};
 			current.segments.push({
 				type: "L",
-				from: current.cursor,
+				from: cloneRawPoint(current.cursor),
 				to
 			});
-			current.cursor = to;
-			continue;
+			current.cursor = cloneRawPoint(to);
+			return;
 		}
-		if (type === "Q") {
-			const from = current.cursor;
+		if (cmd.type === "Q") {
 			const to = {
 				x: cmd.x,
 				y: cmd.y
 			};
 			current.segments.push({
 				type: "Q",
-				from,
+				from: cloneRawPoint(current.cursor),
 				c1: {
 					x: cmd.x1,
 					y: cmd.y1
 				},
 				to
 			});
-			current.cursor = to;
-			continue;
+			current.cursor = cloneRawPoint(to);
+			return;
 		}
-		if (type === "C") {
-			const from = current.cursor;
+		if (cmd.type === "C") {
 			const to = {
 				x: cmd.x,
 				y: cmd.y
 			};
 			current.segments.push({
 				type: "C",
-				from,
+				from: cloneRawPoint(current.cursor),
 				c1: {
 					x: cmd.x1,
 					y: cmd.y1
@@ -523,11 +400,11 @@ function buildGlyphTopology(glyph, fallbackUnitsPerEm) {
 				},
 				to
 			});
-			current.cursor = to;
-			continue;
+			current.cursor = cloneRawPoint(to);
+			return;
 		}
-		if (type === "Z") finishCurrentContour();
-	}
+		if (cmd.type === "Z") finishCurrentContour();
+	});
 	finishCurrentContour();
 	return {
 		glyphIndex: glyph.index,
@@ -551,25 +428,18 @@ function flattenGlyphTopology(topology, options) {
 }
 function flattenContour(contour, scale, tolerance) {
 	const ring = [];
-	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;
+	pushUniquePoint(ring, toScreenPoint(contour.start, scale));
+	contour.segments.forEach((segment) => {
+		if (segment.type === "L") {
+			pushUniquePoint(ring, toScreenPoint(segment.to, scale));
+			return;
 		}
-	}
+		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);
@@ -582,45 +452,37 @@ function flattenContour(contour, scale, tolerance) {
 	};
 }
 function classifyContours(contours) {
-	const len = contours.length;
-	const result = new Array(len);
-	for (let i = 0; i < len; i++) result[i] = {
-		...contours[i],
+	const result = contours.map((contour) => ({
+		...contour,
 		parentId: null,
 		depth: 0,
 		role: "outer"
-	};
-	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);
+	}));
+	result.forEach((child) => {
 		let parent = null;
 		let parentArea = Number.POSITIVE_INFINITY;
-		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;
-		}
+		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;
+			}
+		});
 		if (parent) child.parentId = parent.id;
-	}
+	});
 	const byId = new Map(result.map((contour) => [contour.id, contour]));
-	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";
-	}
+	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";
+	});
 	return result;
 }
 function buildParts(contours) {
@@ -635,26 +497,16 @@ function buildParts(contours) {
 	});
 }
 function translateGlyphGeometry(geometry, tx, ty, glyphPosition) {
-	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] = {
+	return {
+		parts: geometry.parts.map((part, partIndex) => ({
 			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: i
-		};
-	}
-	for (let i = 0; i < contoursLen; i++) {
-		const contour = srcContours[i];
-		contours[i] = {
+			partIndex
+		})),
+		contours: geometry.contours.map((contour) => ({
 			id: `${glyphPosition}:${contour.id}`,
 			sourceId: contour.id,
 			glyphPosition,
@@ -664,11 +516,7 @@ 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)
 	};
 }
@@ -844,31 +692,26 @@ var PAShape = class {
 function createTextShape(layout, opts, fontInstance) {
 	const parts = [];
 	const contours = [];
-	const layoutGlyphs = layout.glyphs;
-	const glyphCount = layoutGlyphs.length;
-	const glyphs = new Array(glyphCount);
-	const sourceLayoutGlyphs = Array.isArray(layoutGlyphs) ? layoutGlyphs.slice() : [];
+	const glyphs = [];
+	const sourceLayoutGlyphs = Array.isArray(layout.glyphs) ? layout.glyphs.slice() : [];
 	const variantOptions = {
 		openWidth: normalizePositive(opts.openWidth, 0),
 		step: normalizePositive(opts.step, 0)
 	};
-	for (let glyphPosition = 0; glyphPosition < glyphCount; glyphPosition++) {
-		const item = layoutGlyphs[glyphPosition];
+	layout.glyphs.forEach((item, 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] = {
+		parts.push(...translated.parts);
+		contours.push(...translated.contours);
+		glyphs.push({
 			position: glyphPosition,
 			glyphIndex: item.glyph.index,
 			x: item.x,
 			y: item.y,
 			size: item.size,
 			bbox: translated.bbox,
-			partCount: tParts.length
-		};
-	}
+			partCount: translated.parts.length
+		});
+	});
 	const bbox = combineRects(parts.map((part) => part.bbox)) ?? emptyRect();
 	return new PAShape({
 		text: layout.text,
@@ -962,8 +805,8 @@ function createDerivedShape(shape, parts) {
 }
 function createRegionCollection(shape) {
 	return shape.parts.map((part) => ({
-		outer: copyRing$1(part.outer),
-		holes: part.holes.map((hole) => copyRing$1(hole)),
+		outer: copyRing(part.outer),
+		holes: part.holes.map((hole) => copyRing(hole)),
 		bbox: { ...part.bbox }
 	}));
 }
@@ -973,8 +816,8 @@ function copyParts(parts) {
 function copyPart(part) {
 	return {
 		...part,
-		outer: copyRing$1(part.outer),
-		holes: part.holes.map((hole) => copyRing$1(hole)),
+		outer: copyRing(part.outer),
+		holes: part.holes.map((hole) => copyRing(hole)),
 		anchors: part.anchors ? part.anchors.map((point) => [point[0], point[1]]) : void 0,
 		bbox: { ...part.bbox }
 	};
@@ -983,7 +826,7 @@ function copyContours(contours) {
 	return contours.map((contour) => ({
 		...contour,
 		bbox: { ...contour.bbox },
-		ring: copyRing$1(contour.ring)
+		ring: copyRing(contour.ring)
 	}));
 }
 function groupPartsByGlyphPosition(parts) {
@@ -1099,108 +942,76 @@ function resolveGeometryEpsilon(width) {
 }
 function openPartWithSlit(part, width, epsilon) {
 	if (!part.holes || part.holes.length === 0) return copyPart(part);
-	let outer = copyRing$1(part.outer);
-	const holes = part.holes.map((hole) => copyRing$1(hole));
+	let outer = copyRing(part.outer);
+	const holes = part.holes.map((hole) => copyRing(hole));
 	const anchors = [];
-	const blockers = [];
 	while (holes.length > 0) {
 		let selectedHoleIndex = -1;
 		let selectedBridge = null;
-		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) {
+		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)) {
 				selectedBridge = candidate;
-				selectedHoleIndex = hi;
-				selectedDist = candidate.distance;
+				selectedHoleIndex = holeIndex;
 			}
-		}
+		});
 		if (!selectedBridge || selectedHoleIndex === -1) break;
 		const [hole] = holes.splice(selectedHoleIndex, 1);
 		const merged = mergeHoleIntoOuter(outer, hole, selectedBridge, width, epsilon);
 		outer = merged.ring;
-		const mergedAnchors = merged.anchors;
-		for (let i = 0; i < mergedAnchors.length; i++) anchors.push(mergedAnchors[i]);
+		anchors.push(...merged.anchors);
 	}
-	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)) - holeArea
+		area: Math.abs(signedArea(outer)) - holes.reduce((sum, hole) => sum + Math.abs(signedArea(hole)), 0)
 	};
 }
 function resamplePart(part, step) {
 	const outer = resampleRing(part.outer, step, part.anchors ?? []);
-	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]));
-	}
+	const holes = part.holes.map((hole) => resampleRing(hole, step));
 	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)) - holeArea
+		area: Math.abs(signedArea(outer)) - holes.reduce((sum, hole) => sum + Math.abs(signedArea(hole)), 0)
 	};
 }
 function findBestHoleBridge(outer, hole, blockers, epsilon) {
 	let best = null;
-	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
+	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)
 			};
-			bestDist = dist;
-		}
-	}
+			if (!best || candidate.distance < best.distance) best = candidate;
+		});
+	});
 	if (best) return best;
 	return findNearestBridge(outer, hole);
 }
 function findNearestBridge(outer, hole) {
-	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)
-	};
+	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;
 }
 function isVisibleBridge(outer, hole, blockers, outerPoint, holePoint, outerIndex, holeIndex, epsilon) {
 	if (distance(outerPoint, holePoint) <= epsilon) return false;
@@ -1327,7 +1138,7 @@ function normalizeCutLocation(name, ring, cut, epsilon) {
 	};
 }
 function ringPath(ring, startIndex, endIndex) {
-	if (startIndex == null || endIndex == null) return copyRing$1(ring);
+	if (startIndex == null || endIndex == null) return copyRing(ring);
 	const path = [ring[startIndex]];
 	let cursor = startIndex;
 	while (cursor !== endIndex) {
@@ -1342,7 +1153,7 @@ function appendPath(target, path, epsilon) {
 	});
 }
 function resampleRing(ring, step, anchors = []) {
-	if (ring.length < 3) return copyRing$1(ring);
+	if (ring.length < 3) return copyRing(ring);
 	const normalizedAnchors = normalizeAnchorPoints(ring, anchors);
 	if (normalizedAnchors.length >= 2) return resampleRingWithAnchors(ring, step, normalizedAnchors);
 	return resampleClosedPath(ring, step);
@@ -1363,32 +1174,30 @@ 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$1(ring);
+	if (result.length < 3 || result.length >= ring.length) return copyRing(ring);
 	return result;
 }
 function resampleClosedPath(ring, step) {
-	const cumulative = buildCumulativeDistances(ring);
-	const perimeter = cumulative[ring.length];
-	if (perimeter <= 1e-9) return copyRing$1(ring);
+	const perimeter = ringPerimeter(ring);
+	if (perimeter <= 1e-9) return copyRing(ring);
 	const pointCount = Math.max(3, Math.round(perimeter / step));
-	if (pointCount >= ring.length) return copyRing$1(ring);
+	if (pointCount >= ring.length) return copyRing(ring);
 	const sampled = [];
-	for (let index = 0; index < pointCount; index++) {
-		const point = pointAtClosedPathDistanceFast(ring, cumulative, perimeter * index / pointCount);
+	for (let index = 0; index < pointCount; index += 1) {
+		const point = pointAtClosedPathDistance(ring, 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$1(ring);
+	if (sampled.length < 3 || sampled.length >= ring.length) return copyRing(ring);
 	return sampled;
 }
 function resampleOpenPath(path, step) {
 	if (path.length <= 2) return path.map((point) => [point[0], point[1]]);
-	const cumulative = buildOpenCumulativeDistances(path);
-	const length = cumulative[path.length - 1];
+	const length = polylineLength(path);
 	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++) {
-		const point = pointAtOpenPathDistanceFast(path, cumulative, length * index / divisionCount);
+	for (let index = 0; index <= divisionCount; index += 1) {
+		const point = pointAtOpenPathDistance(path, length * index / divisionCount);
 		if (sampled.length === 0 || !pointsAlmostEqual2D(sampled[sampled.length - 1], point, 1e-6)) sampled.push(point);
 	}
 	return sampled;
@@ -3760,25 +3569,9 @@ function truncateLineToWidth(line, maxWidth, measureWidth, suffix) {
 		width: 0,
 		hardBreak: false
 	};
-	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;
+	let nextText = trimTrailingWhitespace(line.text);
+	while (nextText.length > 0 && measureWidth(`${nextText}${suffixText}`) > maxWidth + JUSTIFY_EPSILON) nextText = trimLastGrapheme(nextText);
+	const text = `${nextText}${suffixText}`;
 	return {
 		...line,
 		text,
@@ -4315,6 +4108,12 @@ 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);
 }