pa_font 0.1.1

package/dist/paFont.cjs

@@ -0,0 +1,1221 @@
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+let opentype_js = require("opentype.js");
+//#region src/paFont/geometry.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 midpoint(a, b) {
+	return [(a[0] + b[0]) * .5, (a[1] + b[1]) * .5];
+}
+function signedArea(ring) {
+	let area = 0;
+	for (let index = 0; index < ring.length; index += 1) {
+		const current = ring[index];
+		const next = ring[(index + 1) % ring.length];
+		area += current[0] * next[1] - next[0] * current[1];
+	}
+	return area * .5;
+}
+function pointInRing(point, ring) {
+	let inside = false;
+	for (let i = 0, j = ring.length - 1; i < ring.length; j = i, i += 1) {
+		const xi = ring[i][0];
+		const yi = ring[i][1];
+		const xj = ring[j][0];
+		const yj = ring[j][1];
+		if (yi > point[1] !== yj > point[1] && point[0] < (xj - xi) * (point[1] - yi) / (yj - yi || 1e-9) + xi) inside = !inside;
+	}
+	return inside;
+}
+function hitPart(point, part, epsilon) {
+	if (!rectContainsPoint(part.bbox, point, epsilon)) return "outside";
+	if (isPointOnRingEdge(point, part.outer, epsilon)) return "edge";
+	if (!pointInRing(point, part.outer)) return "outside";
+	for (const hole of part.holes) {
+		if (isPointOnRingEdge(point, hole, epsilon)) return "edge";
+		if (pointInRing(point, hole)) return "hole";
+	}
+	return "fill";
+}
+function isPointOnRingEdge(point, ring, epsilon) {
+	for (let index = 0; index < ring.length; index += 1) {
+		const a = ring[index];
+		const b = ring[(index + 1) % ring.length];
+		if (distancePointToSegment(point, a, b) <= epsilon) return true;
+	}
+	return false;
+}
+function distancePointToSegment(point, a, b) {
+	const dx = b[0] - a[0];
+	const dy = b[1] - a[1];
+	const lengthSq = dx * dx + dy * dy;
+	if (lengthSq === 0) return distance(point, a);
+	let t = ((point[0] - a[0]) * dx + (point[1] - a[1]) * dy) / lengthSq;
+	t = Math.max(0, Math.min(1, t));
+	return distance(point, [a[0] + dx * t, a[1] + dy * t]);
+}
+function distance(a, b) {
+	const dx = a[0] - b[0];
+	const dy = a[1] - b[1];
+	return Math.sqrt(dx * dx + dy * dy);
+}
+function sampleRing(ring, step, callback) {
+	for (let index = 0; index < ring.length; index += 1) {
+		const a = ring[index];
+		const b = ring[(index + 1) % ring.length];
+		const segmentLength = distance(a, b);
+		const divisions = Math.max(1, Math.ceil(segmentLength / step));
+		for (let offset = 0; offset < divisions; offset += 1) if (index > 0 || offset > 0) {
+			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]]);
+	}
+}
+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]);
+	});
+	return {
+		x: minX,
+		y: minY,
+		w: maxX - minX,
+		h: maxY - minY
+	};
+}
+function translateRing(ring, tx, ty) {
+	return ring.map((point) => [point[0] + tx, point[1] + ty]);
+}
+function translateRect(rect, tx, ty) {
+	return {
+		x: rect.x + tx,
+		y: rect.y + ty,
+		w: rect.w,
+		h: rect.h
+	};
+}
+function copyRing(ring) {
+	return ring.map((point) => [point[0], point[1]]);
+}
+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);
+	});
+	return {
+		x: minX,
+		y: minY,
+		w: maxX - minX,
+		h: maxY - minY
+	};
+}
+function rectContainsRect(outer, inner, epsilon = 1e-6) {
+	return inner.x >= outer.x - epsilon && inner.y >= outer.y - epsilon && inner.x + inner.w <= outer.x + outer.w + epsilon && inner.y + inner.h <= outer.y + outer.h + epsilon;
+}
+function rectContainsPoint(rect, point, epsilon = 0) {
+	return point[0] >= rect.x - epsilon && point[0] <= rect.x + rect.w + epsilon && point[1] >= rect.y - epsilon && point[1] <= rect.y + rect.h + epsilon;
+}
+function emptyRect() {
+	return {
+		x: 0,
+		y: 0,
+		w: 0,
+		h: 0
+	};
+}
+function normalizeNumber(value, fallback) {
+	return Number.isFinite(value) ? value : fallback;
+}
+function normalizePositive(value, fallback) {
+	return Number.isFinite(value) && value > 0 ? value : fallback;
+}
+function samePoint(a, b) {
+	return a.x === b.x && a.y === b.y;
+}
+function pointsEqual2D(a, b) {
+	return a[0] === b[0] && a[1] === b[1];
+}
+function pointsAlmostEqual2D(a, b, epsilon = 1e-6) {
+	return Math.abs(a[0] - b[0]) <= epsilon && Math.abs(a[1] - b[1]) <= epsilon;
+}
+function ringPerimeter(ring) {
+	let total = 0;
+	for (let index = 0; index < ring.length; index += 1) total += distance(ring[index], ring[(index + 1) % ring.length]);
+	return total;
+}
+function polylineLength(path) {
+	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);
+	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) {
+	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]];
+}
+function segmentIntersectsRing(a, b, ring, ignoredEdges, epsilon) {
+	for (let index = 0; index < ring.length; index += 1) {
+		if (ignoredEdges.has(index)) continue;
+		const c = ring[index];
+		const d = ring[(index + 1) % ring.length];
+		if (segmentsIntersect(a, b, c, d, epsilon)) return true;
+	}
+	return false;
+}
+function segmentsIntersect(a, b, c, d, epsilon) {
+	const o1 = orientation(a, b, c);
+	const o2 = orientation(a, b, d);
+	const o3 = orientation(c, d, a);
+	const o4 = orientation(c, d, b);
+	if ((o1 > epsilon && o2 < -epsilon || o1 < -epsilon && o2 > epsilon) && (o3 > epsilon && o4 < -epsilon || o3 < -epsilon && o4 > epsilon)) return true;
+	if (Math.abs(o1) <= epsilon && pointOnSegment(c, a, b, epsilon)) return true;
+	if (Math.abs(o2) <= epsilon && pointOnSegment(d, a, b, epsilon)) return true;
+	if (Math.abs(o3) <= epsilon && pointOnSegment(a, c, d, epsilon)) return true;
+	if (Math.abs(o4) <= epsilon && pointOnSegment(b, c, d, epsilon)) return true;
+	return false;
+}
+function orientation(a, b, c) {
+	return (b[0] - a[0]) * (c[1] - a[1]) - (b[1] - a[1]) * (c[0] - a[0]);
+}
+function pointOnSegment(point, start, end, epsilon) {
+	return point[0] >= Math.min(start[0], end[0]) - epsilon && point[0] <= Math.max(start[0], end[0]) + epsilon && point[1] >= Math.min(start[1], end[1]) - epsilon && point[1] <= Math.max(start[1], end[1]) + epsilon;
+}
+function mod(value, divisor) {
+	return (value % divisor + divisor) % divisor;
+}
+//#endregion
+//#region src/paFont/core.js
+function layoutGlyphs(font, value, opts) {
+	const glyphs = [];
+	const renderOptions = toRenderOptions(opts);
+	return {
+		text: value,
+		glyphs,
+		metrics: {
+			width: font.forEachGlyph(value, opts.x, opts.y, opts.size, renderOptions, (glyph, x, y, size) => {
+				glyphs.push({
+					glyph,
+					x,
+					y,
+					size,
+					index: glyphs.length
+				});
+			}) - opts.x,
+			x: opts.x,
+			y: opts.y,
+			size: opts.size
+		}
+	};
+}
+function measureText(font, value, opts) {
+	const renderOptions = toRenderOptions(opts);
+	const box = font.getPath(value, opts.x, opts.y, opts.size, renderOptions).getBoundingBox();
+	return {
+		width: font.getAdvanceWidth(value, opts.size, renderOptions),
+		bbox: {
+			x: box.x1,
+			y: box.y1,
+			w: box.x2 - box.x1,
+			h: box.y2 - box.y1
+		}
+	};
+}
+function buildGlyphTopology(glyph, fallbackUnitsPerEm) {
+	const commands = glyph.path?.commands ?? [];
+	const contours = [];
+	let contourId = 0;
+	let current = null;
+	const finishCurrentContour = () => {
+		if (!current || current.segments.length === 0) {
+			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);
+		}
+		contours.push({
+			id: contourId++,
+			start: cloneRawPoint(current.start),
+			segments: current.segments
+		});
+		current = null;
+	};
+	commands.forEach((cmd) => {
+		if (cmd.type === "M") {
+			finishCurrentContour();
+			current = {
+				start: {
+					x: cmd.x,
+					y: cmd.y
+				},
+				cursor: {
+					x: cmd.x,
+					y: cmd.y
+				},
+				segments: []
+			};
+			return;
+		}
+		if (!current) return;
+		if (cmd.type === "L") {
+			const to = {
+				x: cmd.x,
+				y: cmd.y
+			};
+			current.segments.push({
+				type: "L",
+				from: cloneRawPoint(current.cursor),
+				to
+			});
+			current.cursor = cloneRawPoint(to);
+			return;
+		}
+		if (cmd.type === "Q") {
+			const to = {
+				x: cmd.x,
+				y: cmd.y
+			};
+			current.segments.push({
+				type: "Q",
+				from: cloneRawPoint(current.cursor),
+				c1: {
+					x: cmd.x1,
+					y: cmd.y1
+				},
+				to
+			});
+			current.cursor = cloneRawPoint(to);
+			return;
+		}
+		if (cmd.type === "C") {
+			const to = {
+				x: cmd.x,
+				y: cmd.y
+			};
+			current.segments.push({
+				type: "C",
+				from: cloneRawPoint(current.cursor),
+				c1: {
+					x: cmd.x1,
+					y: cmd.y1
+				},
+				c2: {
+					x: cmd.x2,
+					y: cmd.y2
+				},
+				to
+			});
+			current.cursor = cloneRawPoint(to);
+			return;
+		}
+		if (cmd.type === "Z") finishCurrentContour();
+	});
+	finishCurrentContour();
+	return {
+		glyphIndex: glyph.index,
+		advanceWidth: glyph.advanceWidth ?? 0,
+		unitsPerEm: glyph.path?.unitsPerEm ?? fallbackUnitsPerEm ?? 1e3,
+		contours
+	};
+}
+function flattenGlyphTopology(topology, options) {
+	const scale = options.size / topology.unitsPerEm;
+	const classifiedContours = classifyContours(topology.contours.map((contour) => flattenContour(contour, scale, options.flatten)).filter(Boolean));
+	const parts = buildParts(classifiedContours);
+	const bbox = combineRects(parts.map((part) => part.bbox)) ?? emptyRect();
+	return {
+		glyphIndex: topology.glyphIndex,
+		advanceWidth: topology.advanceWidth * scale,
+		contours: classifiedContours,
+		parts,
+		bbox
+	};
+}
+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;
+		}
+		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);
+	const area = signedArea(ring);
+	return {
+		id: contour.id,
+		ring,
+		bbox,
+		area
+	};
+}
+function classifyContours(contours) {
+	const result = contours.map((contour) => ({
+		...contour,
+		parentId: null,
+		depth: 0,
+		role: "outer"
+	}));
+	result.forEach((child) => {
+		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;
+			}
+		});
+		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";
+	});
+	return result;
+}
+function buildParts(contours) {
+	return contours.filter((contour) => contour.role === "outer").map((outer) => {
+		const holeContours = contours.filter((contour) => contour.parentId === outer.id && contour.role === "hole");
+		return {
+			outer: copyRing(outer.ring),
+			holes: holeContours.map((hole) => copyRing(hole.ring)),
+			bbox: { ...outer.bbox },
+			area: Math.abs(outer.area) - holeContours.reduce((sum, hole) => sum + Math.abs(hole.area), 0)
+		};
+	});
+}
+function translateGlyphGeometry(geometry, tx, ty, glyphPosition) {
+	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
+		})),
+		contours: geometry.contours.map((contour) => ({
+			id: `${glyphPosition}:${contour.id}`,
+			sourceId: contour.id,
+			glyphPosition,
+			parentId: contour.parentId == null ? null : `${glyphPosition}:${contour.parentId}`,
+			depth: contour.depth,
+			role: contour.role,
+			area: contour.area,
+			bbox: translateRect(contour.bbox, tx, ty),
+			ring: translateRing(contour.ring, tx, ty)
+		})),
+		bbox: translateRect(geometry.bbox, tx, ty)
+	};
+}
+function normalizeTextOptions(options = {}) {
+	const size = normalizePositive(options.size, 72);
+	return {
+		x: normalizeNumber(options.x, 0),
+		y: normalizeNumber(options.y, 0),
+		size,
+		flatten: normalizePositive(options.flatten, 1.25),
+		edgeEpsilon: options.edgeEpsilon == null ? defaultEdgeEpsilon(size) : normalizePositive(options.edgeEpsilon, defaultEdgeEpsilon(size)),
+		kerning: options.kerning !== false,
+		letterSpacing: options.letterSpacing == null ? void 0 : normalizeNumber(options.letterSpacing, 0),
+		tracking: options.tracking == null ? void 0 : normalizeNumber(options.tracking, 0),
+		script: options.script,
+		language: options.language,
+		features: options.features
+	};
+}
+function defaultEdgeEpsilon(size) {
+	return Math.min(1, Math.max(.01, size * .0025));
+}
+function toRenderOptions(opts) {
+	const renderOptions = { kerning: opts.kerning };
+	if (opts.letterSpacing != null) renderOptions.letterSpacing = opts.letterSpacing;
+	if (opts.tracking != null) renderOptions.tracking = opts.tracking;
+	if (opts.script) renderOptions.script = opts.script;
+	if (opts.language) renderOptions.language = opts.language;
+	if (opts.features) renderOptions.features = opts.features;
+	return renderOptions;
+}
+function toArrayBuffer(value) {
+	if (value instanceof ArrayBuffer) return value;
+	if (ArrayBuffer.isView(value)) return value.buffer.slice(value.byteOffset, value.byteOffset + value.byteLength);
+	return value;
+}
+//#endregion
+//#region src/paFont/shape.js
+var PAShape = class {
+	constructor({ text, parts, contours, glyphs, bbox, metrics, edgeEpsilon }) {
+		this.text = text;
+		this.parts = parts;
+		this.bbox = bbox;
+		this.metrics = metrics;
+		this.edgeEpsilon = edgeEpsilon;
+		this.raw = {
+			contours,
+			glyphs
+		};
+		this._cache = {
+			glyphs: null,
+			openHoles: /* @__PURE__ */ new Map(),
+			resample: /* @__PURE__ */ new Map(),
+			shapes: /* @__PURE__ */ new Map(),
+			regionViews: null
+		};
+	}
+	get polygons() {
+		return this.parts.map((part) => [part.outer, ...part.holes]);
+	}
+	[Symbol.iterator]() {
+		return this._getRegionViews()[Symbol.iterator]();
+	}
+	glyphs() {
+		if (this._cache.glyphs) return this._cache.glyphs;
+		if (!Array.isArray(this.raw.glyphs) || this.raw.glyphs.length <= 1) {
+			this._cache.glyphs = [this];
+			return this._cache.glyphs;
+		}
+		this._cache.glyphs = this.raw.glyphs.map((_, glyphPosition) => createGlyphShape(this, glyphPosition));
+		return this._cache.glyphs;
+	}
+	toShape(options = {}) {
+		return resolveShapeVariant(this, options);
+	}
+	toRegions(options = {}) {
+		return createRegionCollection(this.toShape(options));
+	}
+	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 geometryEpsilon = resolveGeometryEpsilon(slitWidth);
+		const shape = createDerivedShape(this, this.parts.map((part) => openPartWithSlit(part, slitWidth, geometryEpsilon)));
+		this._cache.openHoles.set(cacheKey, shape);
+		return shape;
+	}
+	resample(step) {
+		const spacing = normalizePositive(step, 0);
+		if (spacing <= 0) return this;
+		const cacheKey = toCacheKey(spacing);
+		const cached = this._cache.resample.get(cacheKey);
+		if (cached) return cached;
+		const shape = createDerivedShape(this, this.parts.map((part) => resamplePart(part, spacing)));
+		this._cache.resample.set(cacheKey, shape);
+		return shape;
+	}
+	hit(x, y, epsilon = this.edgeEpsilon) {
+		const point = [x, y];
+		if (!rectContainsPoint(this.bbox, point, epsilon)) return "outside";
+		let holeHit = false;
+		for (const part of this.parts) {
+			const result = hitPart(point, part, epsilon);
+			if (result === "edge" || result === "fill") return result;
+			if (result === "hole") holeHit = true;
+		}
+		return holeHit ? "hole" : "outside";
+	}
+	contains(x, y, epsilon = this.edgeEpsilon) {
+		return this.hit(x, y, epsilon) === "fill";
+	}
+	toPoints(options = {}) {
+		const opts = normalizePointOptions(options);
+		const shape = opts.openWidth > 0 ? this.toShape({ openWidth: opts.openWidth }) : this;
+		const step = opts.step;
+		const includeHoles = opts.includeHoles;
+		const sampled = [];
+		shape.parts.forEach((part, partIndex) => {
+			sampleRing(part.outer, step, (point) => {
+				sampled.push({
+					x: point[0],
+					y: point[1],
+					partIndex,
+					hole: false
+				});
+			});
+			if (!includeHoles) return;
+			part.holes.forEach((hole, holeIndex) => {
+				sampleRing(hole, step, (point) => {
+					sampled.push({
+						x: point[0],
+						y: point[1],
+						partIndex,
+						hole: true,
+						holeIndex
+					});
+				});
+			});
+		});
+		return sampled;
+	}
+	_getRegionViews() {
+		if (!this._cache.regionViews) this._cache.regionViews = this.parts.map((part) => Object.freeze({
+			outer: part.outer,
+			holes: part.holes,
+			bbox: part.bbox
+		}));
+		return this._cache.regionViews;
+	}
+};
+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({
+			position: glyphPosition,
+			glyphIndex: item.glyph.index,
+			x: item.x,
+			y: item.y,
+			size: item.size,
+			bbox: translated.bbox,
+			partCount: translated.parts.length
+		});
+	});
+	const bbox = combineRects(parts.map((part) => part.bbox)) ?? emptyRect();
+	return new PAShape({
+		text: layout.text,
+		parts,
+		contours,
+		glyphs,
+		bbox,
+		metrics: {
+			...layout.metrics,
+			bbox
+		},
+		edgeEpsilon: opts.edgeEpsilon
+	});
+}
+function createGlyphShape(shape, glyphPosition) {
+	const glyphMeta = shape.raw.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());
+	return new PAShape({
+		text: extractGlyphText(shape.text, glyphPosition, shape.raw.glyphs?.length ?? 0),
+		parts,
+		contours,
+		glyphs: glyphMeta ? [{
+			...glyphMeta,
+			bbox,
+			partCount: parts.length
+		}] : [],
+		bbox,
+		metrics: {
+			x: glyphMeta?.x ?? shape.metrics?.x ?? 0,
+			y: glyphMeta?.y ?? shape.metrics?.y ?? 0,
+			size: glyphMeta?.size ?? shape.metrics?.size ?? 0,
+			width: bbox.w,
+			bbox
+		},
+		edgeEpsilon: shape.edgeEpsilon
+	});
+}
+function createDerivedShape(shape, parts) {
+	const copiedParts = copyParts(parts);
+	const bbox = combineRects(copiedParts.map((part) => part.bbox)) ?? emptyRect();
+	const glyphs = (shape.raw.glyphs ?? []).map((glyph, glyphPosition) => {
+		const glyphParts = copiedParts.filter((part) => part.glyphPosition === glyphPosition);
+		return {
+			...glyph,
+			bbox: combineRects(glyphParts.map((part) => part.bbox)) ?? (glyph.bbox ? { ...glyph.bbox } : emptyRect()),
+			partCount: glyphParts.length
+		};
+	});
+	return new PAShape({
+		text: shape.text,
+		parts: copiedParts,
+		contours: [],
+		glyphs,
+		bbox,
+		metrics: {
+			...shape.metrics,
+			bbox
+		},
+		edgeEpsilon: shape.edgeEpsilon
+	});
+}
+function createRegionCollection(shape) {
+	return shape.parts.map((part) => ({
+		outer: copyRing(part.outer),
+		holes: part.holes.map((hole) => copyRing(hole)),
+		bbox: { ...part.bbox }
+	}));
+}
+function copyParts(parts) {
+	return parts.map((part) => copyPart(part));
+}
+function copyPart(part) {
+	return {
+		...part,
+		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 }
+	};
+}
+function copyContours(contours) {
+	return contours.map((contour) => ({
+		...contour,
+		bbox: { ...contour.bbox },
+		ring: copyRing(contour.ring)
+	}));
+}
+function extractGlyphText(text, glyphPosition, glyphCount) {
+	if (glyphCount <= 1) return text;
+	return Array.from(text ?? "")[glyphPosition] ?? "";
+}
+function normalizePointOptions(options = {}) {
+	if (options == null) return {
+		step: 8,
+		openWidth: 0,
+		includeHoles: true
+	};
+	if (typeof options !== "object" || Array.isArray(options)) throw new TypeError("toPoints() expects an options object.");
+	return {
+		step: normalizePositive(options.step, 8),
+		openWidth: normalizePositive(options.openWidth, 0),
+		includeHoles: options.includeHoles !== false
+	};
+}
+function normalizeShapeOptions(options = {}) {
+	if (options == null) return {
+		step: 0,
+		openWidth: 0
+	};
+	if (typeof options !== "object" || Array.isArray(options)) throw new TypeError("toShape() and toRegions() expect an options object.");
+	return {
+		step: normalizePositive(options.step, 0),
+		openWidth: normalizePositive(options.openWidth, 0)
+	};
+}
+function resolveShapeVariant(shape, options = {}) {
+	const normalized = normalizeShapeOptions(options);
+	if (normalized.step <= 0 && normalized.openWidth <= 0) return shape;
+	const cacheKey = `${toCacheKey(normalized.step)}:${toCacheKey(normalized.openWidth)}`;
+	const cached = shape._cache.shapes.get(cacheKey);
+	if (cached) return cached;
+	let next = shape;
+	if (normalized.openWidth > 0) next = next.openHoles(normalized.openWidth);
+	if (normalized.step > 0) next = next.resample(normalized.step);
+	shape._cache.shapes.set(cacheKey, next);
+	return next;
+}
+function toCacheKey(value) {
+	return normalizePositive(value, 0).toFixed(6);
+}
+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));
+	const anchors = [];
+	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)) {
+				selectedBridge = candidate;
+				selectedHoleIndex = holeIndex;
+			}
+		});
+		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);
+	}
+	return {
+		...part,
+		outer,
+		holes,
+		anchors,
+		bbox: ringBounds(outer),
+		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 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)) - holes.reduce((sum, hole) => sum + Math.abs(signedArea(hole)), 0)
+	};
+}
+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)
+			};
+			if (!best || candidate.distance < best.distance) best = candidate;
+		});
+	});
+	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;
+}
+function isVisibleBridge(outer, hole, blockers, outerPoint, holePoint, outerIndex, holeIndex, epsilon) {
+	if (distance(outerPoint, holePoint) <= epsilon) return false;
+	const bridgeMidpoint = midpoint(outerPoint, holePoint);
+	if (!pointInRing(bridgeMidpoint, outer) || pointInRing(bridgeMidpoint, hole)) return false;
+	if (blockers.some((blocker) => pointInRing(bridgeMidpoint, blocker))) return false;
+	if (segmentIntersectsRing(outerPoint, holePoint, outer, new Set([outerIndex, mod(outerIndex - 1, outer.length)]), epsilon)) return false;
+	if (segmentIntersectsRing(outerPoint, holePoint, hole, new Set([holeIndex, mod(holeIndex - 1, hole.length)]), epsilon)) return false;
+	return !blockers.some((blocker) => segmentIntersectsRing(outerPoint, holePoint, blocker, /* @__PURE__ */ new Set(), epsilon));
+}
+function mergeHoleIntoOuter(outer, hole, bridge, width, epsilon) {
+	const slitWidth = clampSlitWidth(width, outer, hole, epsilon);
+	const outerCut = createRingCut(outer, bridge.outerIndex, slitWidth, epsilon);
+	const holeCut = createRingCut(hole, bridge.holeIndex, slitWidth, epsilon);
+	const outerPath = ringPath(outerCut.ring, outerCut.afterIndex, outerCut.beforeIndex);
+	const holePath = ringPath(holeCut.ring, holeCut.afterIndex, holeCut.beforeIndex);
+	const merged = [];
+	appendPath(merged, outerPath, epsilon);
+	appendPath(merged, holePath, epsilon);
+	if (merged.length > 1 && pointsAlmostEqual2D(merged[0], merged[merged.length - 1], epsilon)) merged.pop();
+	return {
+		ring: merged,
+		anchors: [
+			outerCut.ring[outerCut.beforeIndex],
+			holeCut.ring[holeCut.beforeIndex],
+			holeCut.ring[holeCut.afterIndex],
+			outerCut.ring[outerCut.afterIndex]
+		].map((point) => [point[0], point[1]])
+	};
+}
+function clampSlitWidth(width, outer, hole, epsilon) {
+	const minPerimeter = Math.min(ringPerimeter(outer), ringPerimeter(hole));
+	return Math.max(epsilon * 2, Math.min(width, Math.max(minPerimeter * .24, epsilon * 2)));
+}
+function createRingCut(ring, anchorIndex, width, epsilon) {
+	return insertRingCutPoints(ring, moveAlongRing(ring, anchorIndex, -width * .5, epsilon), moveAlongRing(ring, anchorIndex, width * .5, epsilon), epsilon);
+}
+function moveAlongRing(ring, anchorIndex, offset, epsilon) {
+	if (!Number.isFinite(offset) || Math.abs(offset) <= epsilon) return {
+		point: [ring[anchorIndex][0], ring[anchorIndex][1]],
+		vertexIndex: anchorIndex,
+		t: 0
+	};
+	let remaining = Math.abs(offset);
+	let currentIndex = anchorIndex;
+	const direction = offset > 0 ? 1 : -1;
+	while (remaining > epsilon) {
+		const nextIndex = direction > 0 ? (currentIndex + 1) % ring.length : mod(currentIndex - 1, ring.length);
+		const segmentIndex = direction > 0 ? currentIndex : nextIndex;
+		const segmentStart = ring[segmentIndex];
+		const segmentEnd = ring[(segmentIndex + 1) % ring.length];
+		const segmentLength = distance(segmentStart, segmentEnd);
+		if (segmentLength <= epsilon) {
+			currentIndex = direction > 0 ? nextIndex : segmentIndex;
+			continue;
+		}
+		if (remaining < segmentLength - epsilon) {
+			const t = remaining / segmentLength;
+			const ratio = direction > 0 ? t : 1 - t;
+			return {
+				point: [segmentStart[0] + (segmentEnd[0] - segmentStart[0]) * ratio, segmentStart[1] + (segmentEnd[1] - segmentStart[1]) * ratio],
+				segmentIndex,
+				t: ratio
+			};
+		}
+		remaining -= segmentLength;
+		currentIndex = direction > 0 ? nextIndex : segmentIndex;
+	}
+	return {
+		point: [ring[currentIndex][0], ring[currentIndex][1]],
+		vertexIndex: currentIndex,
+		t: 0
+	};
+}
+function insertRingCutPoints(ring, beforeCut, afterCut, epsilon) {
+	const cuts = [normalizeCutLocation("before", ring, beforeCut, epsilon), normalizeCutLocation("after", ring, afterCut, epsilon)];
+	const insertsBySegment = /* @__PURE__ */ new Map();
+	const cutIndices = {};
+	const augmented = [];
+	cuts.forEach((cut) => {
+		if (cut.vertexIndex != null) return;
+		const existing = insertsBySegment.get(cut.segmentIndex) ?? [];
+		existing.push(cut);
+		insertsBySegment.set(cut.segmentIndex, existing);
+	});
+	for (let index = 0; index < ring.length; index += 1) {
+		augmented.push([ring[index][0], ring[index][1]]);
+		cuts.forEach((cut) => {
+			if (cut.vertexIndex === index) cutIndices[cut.name] = augmented.length - 1;
+		});
+		(insertsBySegment.get(index) ?? []).sort((a, b) => a.t - b.t).forEach((cut) => {
+			augmented.push([cut.point[0], cut.point[1]]);
+			cutIndices[cut.name] = augmented.length - 1;
+		});
+	}
+	return {
+		ring: augmented,
+		beforeIndex: cutIndices.before,
+		afterIndex: cutIndices.after
+	};
+}
+function normalizeCutLocation(name, ring, cut, epsilon) {
+	if (cut.vertexIndex != null) return {
+		...cut,
+		name
+	};
+	const segmentStart = ring[cut.segmentIndex];
+	const segmentEnd = ring[(cut.segmentIndex + 1) % ring.length];
+	if (distance(cut.point, segmentStart) <= epsilon) return {
+		point: [segmentStart[0], segmentStart[1]],
+		vertexIndex: cut.segmentIndex,
+		t: 0,
+		name
+	};
+	if (distance(cut.point, segmentEnd) <= epsilon) return {
+		point: [segmentEnd[0], segmentEnd[1]],
+		vertexIndex: (cut.segmentIndex + 1) % ring.length,
+		t: 1,
+		name
+	};
+	return {
+		...cut,
+		name
+	};
+}
+function ringPath(ring, startIndex, endIndex) {
+	if (startIndex == null || endIndex == null) return copyRing(ring);
+	const path = [ring[startIndex]];
+	let cursor = startIndex;
+	while (cursor !== endIndex) {
+		cursor = (cursor + 1) % ring.length;
+		path.push(ring[cursor]);
+	}
+	return path;
+}
+function appendPath(target, path, epsilon) {
+	path.forEach((point) => {
+		if (target.length === 0 || !pointsAlmostEqual2D(target[target.length - 1], point, epsilon)) target.push([point[0], point[1]]);
+	});
+}
+function resampleRing(ring, step, anchors = []) {
+	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);
+}
+function normalizeAnchorPoints(ring, anchors) {
+	const indices = anchors.map((anchor) => findRingPointIndex(ring, anchor)).filter((index) => index >= 0).sort((a, b) => a - b);
+	return indices.filter((index, position) => index !== indices[position - 1]);
+}
+function findRingPointIndex(ring, point, epsilon = 1e-6) {
+	for (let index = 0; index < ring.length; index += 1) if (pointsAlmostEqual2D(ring[index], point, epsilon)) return index;
+	return -1;
+}
+function resampleRingWithAnchors(ring, step, anchorIndices) {
+	const result = [];
+	for (let index = 0; index < anchorIndices.length; index += 1) {
+		const startIndex = anchorIndices[index];
+		const endIndex = anchorIndices[(index + 1) % anchorIndices.length];
+		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);
+	return result;
+}
+function resampleClosedPath(ring, step) {
+	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(ring);
+	const sampled = [];
+	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(ring);
+	return sampled;
+}
+function resampleOpenPath(path, step) {
+	if (path.length <= 2) return path.map((point) => [point[0], point[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 += 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;
+}
+//#endregion
+//#region src/paFont/paFont.js
+var PAFont = class PAFont {
+	constructor(font) {
+		this.font = font;
+		this.unitsPerEm = font.unitsPerEm ?? 1e3;
+		this._glyphTopologyCache = /* @__PURE__ */ new Map();
+		this._glyphFlatCache = /* @__PURE__ */ new Map();
+	}
+	static async load(source, options = {}) {
+		const opts = normalizeLoadOptions(options);
+		if (source instanceof ArrayBuffer || ArrayBuffer.isView(source)) return new PAFont((0, opentype_js.parse)(toArrayBuffer(source)));
+		if (typeof window !== "undefined") return new PAFont((0, opentype_js.parse)(await fetchFontBytes(resolveBrowserFontSource(source, opts.base))));
+		const { target, loadOptions } = await resolveNodeFontSource(source, opts.base);
+		return new PAFont(await (0, opentype_js.load)(target, void 0, loadOptions));
+	}
+	text(value, options = {}) {
+		const opts = normalizeTextOptions(options);
+		return createTextShape(this._layoutText(String(value ?? ""), opts), opts, this);
+	}
+	glyph(value, options = {}) {
+		const opts = normalizeTextOptions(options);
+		const glyph = this.font.charToGlyph(String(value ?? ""));
+		return createTextShape({
+			text: String(value ?? ""),
+			glyphs: [{
+				glyph,
+				x: opts.x,
+				y: opts.y,
+				size: opts.size,
+				index: 0
+			}],
+			metrics: {
+				width: (glyph.advanceWidth ?? 0) * (opts.size / this.unitsPerEm),
+				x: opts.x,
+				y: opts.y,
+				size: opts.size
+			}
+		}, opts, this);
+	}
+	metrics(value, options = {}) {
+		const opts = normalizeTextOptions(options);
+		return measureText(this.font, String(value ?? ""), opts);
+	}
+	_getGlyphTopology(glyph) {
+		const key = String(glyph.index);
+		if (!this._glyphTopologyCache.has(key)) this._glyphTopologyCache.set(key, buildGlyphTopology(glyph, this.unitsPerEm));
+		return this._glyphTopologyCache.get(key);
+	}
+	_getFlattenedGlyph(glyph, opts) {
+		const key = `${glyph.index}:${opts.size}:${opts.flatten}`;
+		if (!this._glyphFlatCache.has(key)) {
+			const topology = this._getGlyphTopology(glyph);
+			this._glyphFlatCache.set(key, flattenGlyphTopology(topology, {
+				size: opts.size,
+				flatten: opts.flatten
+			}));
+		}
+		return this._glyphFlatCache.get(key);
+	}
+	_layoutText(value, opts) {
+		return layoutGlyphs(this.font, value, opts);
+	}
+};
+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}`);
+	const bytes = await response.arrayBuffer();
+	const signature = readSignature(bytes);
+	if ((response.headers.get("content-type") ?? "").includes("text/html") || isHtmlSignature(signature)) throw new Error(`Font URL returned HTML instead of font data: ${source}. Use a public font URL like "/assets/font.otf", or pass { base: import.meta.url } when loading a module-relative string path. Plain string paths in the browser are resolved from the current page URL.`);
+	return bytes;
+}
+function normalizeLoadOptions(options = {}) {
+	if (options == null) return {};
+	if (typeof options !== "object" || Array.isArray(options)) throw new TypeError("PAFont.load() options must be an object.");
+	return options;
+}
+function resolveBrowserFontSource(source, base) {
+	if (source instanceof URL) return source.href;
+	if (typeof source !== "string") throw new TypeError("PAFont.load() expects a string, URL, ArrayBuffer, or ArrayBufferView.");
+	if (base == null) return source;
+	return new URL(source, normalizeBase(base)).href;
+}
+async function resolveNodeFontSource(source, base) {
+	if (source instanceof URL) return toNodeLoadTarget(source);
+	if (typeof source !== "string") throw new TypeError("PAFont.load() expects a string, URL, ArrayBuffer, or ArrayBufferView.");
+	if (base == null) {
+		if (isLoadableUrlString(source)) return toNodeLoadTarget(new URL(source));
+		return {
+			target: source,
+			loadOptions: void 0
+		};
+	}
+	return toNodeLoadTarget(new URL(source, normalizeBase(base)));
+}
+function normalizeBase(base) {
+	if (base instanceof URL) return base;
+	if (typeof base === "string") return base;
+	throw new TypeError("PAFont.load() option \"base\" must be a string or URL.");
+}
+async function toNodeLoadTarget(url) {
+	if (url.protocol === "file:") return {
+		target: fileUrlToPath(url),
+		loadOptions: void 0
+	};
+	return {
+		target: url.href,
+		loadOptions: { isUrl: true }
+	};
+}
+function fileUrlToPath(url) {
+	const pathname = decodeURIComponent(url.pathname);
+	if (/^\/[a-zA-Z]:/.test(pathname)) return pathname.slice(1);
+	if (url.hostname) return `//${url.hostname}${pathname}`;
+	return pathname;
+}
+function isLoadableUrlString(value) {
+	return value.startsWith("http://") || value.startsWith("https://") || value.startsWith("file://");
+}
+function readSignature(bytes) {
+	const view = new Uint8Array(bytes, 0, Math.min(4, bytes.byteLength));
+	let signature = "";
+	for (const value of view) signature += String.fromCharCode(value);
+	return signature.toLowerCase();
+}
+function isHtmlSignature(signature) {
+	return signature === "<!do" || signature === "<htm";
+}
+//#endregion
+exports.PAFont = PAFont;
+exports.PAShape = PAShape;
+exports.default = PAFont;
+
+//# sourceMappingURL=paFont.cjs.map