js.documents 14.4.56 → 14.4.57

package/dist/svg/read.d.ts

@@ -1,5 +1,5 @@
 import { i as SvgDiagnosticSink } from "../diagnostics-DVAXKgcf.js";
-import { ContentDocument } from "document-schema.js";
+import { Color, ContentDocument, ContentVector } from "document-schema.js";
 //#region src/svg/read.d.ts
 interface ReadSvgContentOptions {
   readonly onSvgDiagnostic?: SvgDiagnosticSink;
@@ -7,6 +7,21 @@ interface ReadSvgContentOptions {
 declare class SvgMissingRootElementError extends Error {
   constructor();
 }
+declare const KAPPA_NUMERATOR = 4;
+declare const KAPPA: number;
+interface PaintState {
+  readonly fillSpec?: string;
+  readonly strokeSpec?: string;
+  readonly strokeWidthSpec?: string;
+  readonly fillRuleSpec?: string;
+  readonly dashSpec?: string;
+}
+interface ReaderState {
+  readonly sink?: SvgDiagnosticSink;
+  vectors: ContentVector[];
+  paintOrder: number;
+}
+declare function resolveFillPaint(state: ReaderState, spec: string | undefined, isFill: boolean): Color | undefined;
 declare function readSvgContent(text: string, options?: ReadSvgContentOptions): ContentDocument;
 //#endregion
-export { ReadSvgContentOptions, SvgMissingRootElementError, readSvgContent };
+export { KAPPA, KAPPA_NUMERATOR, PaintState, ReadSvgContentOptions, ReaderState, SvgMissingRootElementError, readSvgContent, resolveFillPaint };

package/dist/svg/read.js

@@ -1,679 +1,2 @@
-import { parseSvgDashStyle, parseSvgPaint } from "./paint.js";
-import { parseSvgPathData } from "./path.js";
-import { PT_PER_PX, parseSvgLengthPt, parseSvgUserUnits, parseSvgViewBox } from "./units.js";
-import { applyMatrix, composeMatrices, isAxisAligned, isNonReflectingSimilarity, meanScaleFactor, parseSvgTransform, similarityRotationDeg } from "./transform.js";
-import { decodeEntities } from "ooxml.js";
-import { parseXml } from "odf.js";
-//#region src/svg/read.ts
-const ASPECT_DISPLAY_DECIMALS = 4;
-const ASPECT_COMPARE_TOLERANCE = 1e-6;
-var SvgMissingRootElementError = class extends Error {
-	constructor() {
-		super("svg text must contain an <svg> root element");
-		this.name = "SvgMissingRootElementError";
-	}
-};
-const DEFAULT_VIEWPORT_WIDTH_PX = 300;
-const DEFAULT_VIEWPORT_HEIGHT_PX = 150;
-const DEFAULT_WIDTH_PT = DEFAULT_VIEWPORT_WIDTH_PX * PT_PER_PX;
-const DEFAULT_HEIGHT_PT = DEFAULT_VIEWPORT_HEIGHT_PX * PT_PER_PX;
-const KAPPA = 4 / 3 * (Math.SQRT2 - 1);
-function localName(tag) {
-	return tag.slice(tag.indexOf(":") + 1);
-}
-function findAttribute(element, name) {
-	for (const attribute of element.attributes) if (localName(attribute.name) === name) return decodeEntities(attribute.value);
-}
-function elementChildren(node) {
-	return node.type === "element" ? node.children.filter((child) => child.type === "element") : [];
-}
-function textOf(element) {
-	let text = "";
-	for (const child of element.children) if (child.type === "text" || child.type === "cdata") text += decodeEntities(child.value);
-	return text;
-}
-function childPaintState(element, parent) {
-	return {
-		fillSpec: findAttribute(element, "fill") ?? parent.fillSpec,
-		strokeSpec: findAttribute(element, "stroke") ?? parent.strokeSpec,
-		strokeWidthSpec: findAttribute(element, "stroke-width") ?? parent.strokeWidthSpec,
-		fillRuleSpec: findAttribute(element, "fill-rule") ?? parent.fillRuleSpec,
-		dashSpec: findAttribute(element, "stroke-dasharray") ?? parent.dashSpec
-	};
-}
-function report(state, code, detail) {
-	state.sink?.({
-		code,
-		detail
-	});
-}
-function resolveFillPaint(state, spec, isFill) {
-	if (spec === void 0) return isFill ? {
-		r: 0,
-		g: 0,
-		b: 0
-	} : void 0;
-	const paint = parseSvgPaint(spec);
-	if (paint === void 0) {
-		report(state, "svg/paint-unsupported", spec);
-		return isFill ? {
-			r: 0,
-			g: 0,
-			b: 0
-		} : void 0;
-	}
-	if (paint.kind === "none") return;
-	if (paint.kind === "url") {
-		report(state, "svg/gradient-unsupported", `#${paint.fragment}`);
-		return;
-	}
-	if (paint.kind === "currentColor") {
-		report(state, "svg/paint-unsupported", "currentColor renders as black: the CSS color property is out of scope");
-		return {
-			r: 0,
-			g: 0,
-			b: 0
-		};
-	}
-	return paint.color;
-}
-function resolveStroke(state, paint, ctm) {
-	const color = resolveFillPaint(state, paint.strokeSpec, false);
-	if (color === void 0) return;
-	const widthPt = (parseSvgUserUnits(paint.strokeWidthSpec) ?? 1) * meanScaleFactor(ctm);
-	if (!(widthPt > 0)) return;
-	const style = parseSvgDashStyle(paint.dashSpec);
-	return style === void 0 ? {
-		color,
-		widthPt
-	} : {
-		color,
-		widthPt,
-		style
-	};
-}
-function resolvePaint(state, paint, ctm) {
-	return {
-		fill: resolveFillPaint(state, paint.fillSpec, true),
-		stroke: resolveStroke(state, paint, ctm)
-	};
-}
-function boxOfPoints(points) {
-	let minX = Number.POSITIVE_INFINITY;
-	let minY = Number.POSITIVE_INFINITY;
-	let maxX = Number.NEGATIVE_INFINITY;
-	let maxY = Number.NEGATIVE_INFINITY;
-	for (const point of points) {
-		minX = Math.min(minX, point.x);
-		minY = Math.min(minY, point.y);
-		maxX = Math.max(maxX, point.x);
-		maxY = Math.max(maxY, point.y);
-	}
-	return {
-		xPt: minX,
-		yPt: minY,
-		widthPt: maxX - minX,
-		heightPt: maxY - minY
-	};
-}
-function axisAlignedFrame(ctm, x, y, width, height) {
-	return boxOfPoints([
-		applyMatrix(ctm, x, y),
-		applyMatrix(ctm, x + width, y),
-		applyMatrix(ctm, x + width, y + height),
-		applyMatrix(ctm, x, y + height)
-	]);
-}
-function similarityFrame(ctm, x, y, width, height) {
-	const centre = applyMatrix(ctm, x + width / 2, y + height / 2);
-	const scale = Math.hypot(ctm.a, ctm.b);
-	return {
-		xPt: centre.x - scale * width / 2,
-		yPt: centre.y - scale * height / 2,
-		widthPt: scale * width,
-		heightPt: scale * height
-	};
-}
-function buildPathVector(state, subpaths, ctm, paint, fillRule) {
-	const placed = subpaths.map((subpath) => ({
-		start: applyMatrix(ctm, subpath.start.x, subpath.start.y),
-		closed: subpath.closed,
-		segments: subpath.segments.map((segment) => segment.kind === "line" ? {
-			kind: "line",
-			to: applyMatrix(ctm, segment.to.x, segment.to.y)
-		} : {
-			kind: "cubic",
-			control1: applyMatrix(ctm, segment.control1.x, segment.control1.y),
-			control2: applyMatrix(ctm, segment.control2.x, segment.control2.y),
-			to: applyMatrix(ctm, segment.to.x, segment.to.y)
-		})
-	}));
-	const frame = boxOfPoints(placed.flatMap((subpath) => [subpath.start, ...subpath.segments.flatMap((segment) => segment.kind === "line" ? [segment.to] : [
-		segment.control1,
-		segment.control2,
-		segment.to
-	])]));
-	if (frame.widthPt === 0 && frame.heightPt === 0) return;
-	const localSubpaths = placed.map((subpath) => ({
-		start: {
-			xPt: subpath.start.x - frame.xPt,
-			yPt: subpath.start.y - frame.yPt
-		},
-		closed: subpath.closed,
-		segments: subpath.segments.map((segment) => segment.kind === "line" ? {
-			kind: "line",
-			to: {
-				xPt: segment.to.x - frame.xPt,
-				yPt: segment.to.y - frame.yPt
-			}
-		} : {
-			kind: "cubic",
-			control1: {
-				xPt: segment.control1.x - frame.xPt,
-				yPt: segment.control1.y - frame.yPt
-			},
-			control2: {
-				xPt: segment.control2.x - frame.xPt,
-				yPt: segment.control2.y - frame.yPt
-			},
-			to: {
-				xPt: segment.to.x - frame.xPt,
-				yPt: segment.to.y - frame.yPt
-			}
-		})
-	}));
-	const sourceIndex = state.vectors.length;
-	return {
-		kind: "path",
-		frame,
-		subpaths: localSubpaths,
-		...paint.fill !== void 0 ? { fill: paint.fill } : {},
-		...fillRule !== void 0 ? { fillRule } : {},
-		...paint.stroke !== void 0 ? { stroke: paint.stroke } : {},
-		paintOrder: state.paintOrder++,
-		sourcePath: `svg/vector[${sourceIndex}]`
-	};
-}
-function roundedRectSubpaths(x, y, width, height, rx, ry) {
-	const radiusX = Math.min(rx, width / 2);
-	const radiusY = Math.min(ry, height / 2);
-	const kx = radiusX * KAPPA;
-	const ky = radiusY * KAPPA;
-	return [{
-		start: {
-			x: x + radiusX,
-			y
-		},
-		closed: true,
-		segments: [
-			{
-				kind: "line",
-				to: {
-					x: x + width - radiusX,
-					y
-				}
-			},
-			{
-				kind: "cubic",
-				control1: {
-					x: x + width - radiusX + kx,
-					y
-				},
-				control2: {
-					x: x + width,
-					y: y + radiusY - ky
-				},
-				to: {
-					x: x + width,
-					y: y + radiusY
-				}
-			},
-			{
-				kind: "line",
-				to: {
-					x: x + width,
-					y: y + height - radiusY
-				}
-			},
-			{
-				kind: "cubic",
-				control1: {
-					x: x + width,
-					y: y + height - radiusY + ky
-				},
-				control2: {
-					x: x + width - radiusX + kx,
-					y: y + height
-				},
-				to: {
-					x: x + width - radiusX,
-					y: y + height
-				}
-			},
-			{
-				kind: "line",
-				to: {
-					x: x + radiusX,
-					y: y + height
-				}
-			},
-			{
-				kind: "cubic",
-				control1: {
-					x: x + radiusX - kx,
-					y: y + height
-				},
-				control2: {
-					x,
-					y: y + height - radiusY + ky
-				},
-				to: {
-					x,
-					y: y + height - radiusY
-				}
-			},
-			{
-				kind: "line",
-				to: {
-					x,
-					y: y + radiusY
-				}
-			},
-			{
-				kind: "cubic",
-				control1: {
-					x,
-					y: y + radiusY - ky
-				},
-				control2: {
-					x: x + radiusX - kx,
-					y
-				},
-				to: {
-					x: x + radiusX,
-					y
-				}
-			}
-		]
-	}];
-}
-function ellipseSubpaths(cx, cy, rx, ry) {
-	const kx = rx * KAPPA;
-	const ky = ry * KAPPA;
-	return [{
-		start: {
-			x: cx + rx,
-			y: cy
-		},
-		closed: true,
-		segments: [
-			{
-				kind: "cubic",
-				control1: {
-					x: cx + rx,
-					y: cy + ky
-				},
-				control2: {
-					x: cx + kx,
-					y: cy + ry
-				},
-				to: {
-					x: cx,
-					y: cy + ry
-				}
-			},
-			{
-				kind: "cubic",
-				control1: {
-					x: cx - kx,
-					y: cy + ry
-				},
-				control2: {
-					x: cx - rx,
-					y: cy + ky
-				},
-				to: {
-					x: cx - rx,
-					y: cy
-				}
-			},
-			{
-				kind: "cubic",
-				control1: {
-					x: cx - rx,
-					y: cy - ky
-				},
-				control2: {
-					x: cx - kx,
-					y: cy - ry
-				},
-				to: {
-					x: cx,
-					y: cy - ry
-				}
-			},
-			{
-				kind: "cubic",
-				control1: {
-					x: cx + kx,
-					y: cy - ry
-				},
-				control2: {
-					x: cx + rx,
-					y: cy - ky
-				},
-				to: {
-					x: cx + rx,
-					y: cy
-				}
-			}
-		]
-	}];
-}
-function userUnits(element, attr) {
-	return parseSvgUserUnits(findAttribute(element, attr)) ?? 0;
-}
-function readShape(state, element, ctm, paint) {
-	const name = localName(element.tag);
-	const id = findAttribute(element, "id");
-	const detail = id === void 0 ? name : `${name}#${id}`;
-	let fillRule;
-	const fillRuleSpec = paint.fillRuleSpec;
-	if (fillRuleSpec !== void 0 && fillRuleSpec !== "nonzero") {
-		if (fillRuleSpec === "evenodd") fillRule = "evenodd";
-		else report(state, "svg/paint-unsupported", fillRuleSpec);
-	}
-	const resolved = resolvePaint(state, paint, ctm);
-	if (resolved.fill === void 0 && resolved.stroke === void 0) {
-		report(state, "svg/element-skipped", `${detail}: nothing painted (fill and stroke both absent or none)`);
-		return;
-	}
-	if (name === "rect") {
-		const x = userUnits(element, "x");
-		const y = userUnits(element, "y");
-		const width = userUnits(element, "width");
-		const height = userUnits(element, "height");
-		if (width <= 0 || height <= 0) {
-			report(state, "svg/element-skipped", `${detail}: zero or negative size`);
-			return;
-		}
-		const rxAttr = parseSvgUserUnits(findAttribute(element, "rx"));
-		const ryAttr = parseSvgUserUnits(findAttribute(element, "ry"));
-		const rx = rxAttr ?? ryAttr ?? 0;
-		const ry = ryAttr ?? rxAttr ?? 0;
-		if (rx > 0 || ry > 0) {
-			const vector = buildPathVector(state, roundedRectSubpaths(x, y, width, height, rx, ry), ctm, resolved, fillRule);
-			if (vector !== void 0) state.vectors.push(vector);
-			return;
-		}
-		const rotated = !isAxisAligned(ctm) && isNonReflectingSimilarity(ctm);
-		const frame = rotated ? similarityFrame(ctm, x, y, width, height) : axisAlignedFrame(ctm, x, y, width, height);
-		if (frame.widthPt <= 0 || frame.heightPt <= 0) {
-			report(state, "svg/element-skipped", `${detail}: collapses to zero size under transform`);
-			return;
-		}
-		state.vectors.push({
-			kind: "rect",
-			frame,
-			...rotated ? { rotationDeg: similarityRotationDeg(ctm) } : {},
-			...resolved.fill !== void 0 ? { fill: resolved.fill } : {},
-			...resolved.stroke !== void 0 ? { stroke: resolved.stroke } : {},
-			paintOrder: state.paintOrder++,
-			sourcePath: `svg/vector[${state.vectors.length}]`
-		});
-		return;
-	}
-	if (name === "circle" || name === "ellipse") {
-		const cx = userUnits(element, "cx");
-		const cy = userUnits(element, "cy");
-		const rx = name === "circle" ? userUnits(element, "r") : userUnits(element, "rx");
-		const ry = name === "circle" ? userUnits(element, "r") : userUnits(element, "ry");
-		if (rx <= 0 || ry <= 0) {
-			report(state, "svg/element-skipped", `${detail}: zero or negative radius`);
-			return;
-		}
-		if (!isAxisAligned(ctm) && !isNonReflectingSimilarity(ctm)) {
-			const vector = buildPathVector(state, ellipseSubpaths(cx, cy, rx, ry), ctm, resolved, fillRule);
-			if (vector !== void 0) state.vectors.push(vector);
-			return;
-		}
-		const rotated = !isAxisAligned(ctm);
-		const frame = rotated ? similarityFrame(ctm, cx - rx, cy - ry, rx * 2, ry * 2) : axisAlignedFrame(ctm, cx - rx, cy - ry, rx * 2, ry * 2);
-		if (frame.widthPt <= 0 || frame.heightPt <= 0) {
-			report(state, "svg/element-skipped", `${detail}: collapses to zero size under transform`);
-			return;
-		}
-		state.vectors.push({
-			kind: "ellipse",
-			frame,
-			...rotated ? { rotationDeg: similarityRotationDeg(ctm) } : {},
-			...resolved.fill !== void 0 ? { fill: resolved.fill } : {},
-			...resolved.stroke !== void 0 ? { stroke: resolved.stroke } : {},
-			paintOrder: state.paintOrder++,
-			sourcePath: `svg/vector[${state.vectors.length}]`
-		});
-		return;
-	}
-	if (name === "line") {
-		if (resolved.stroke === void 0) {
-			report(state, "svg/element-skipped", `${detail}: a line paints only through its stroke, which is absent or none`);
-			return;
-		}
-		const from = applyMatrix(ctm, userUnits(element, "x1"), userUnits(element, "y1"));
-		const to = applyMatrix(ctm, userUnits(element, "x2"), userUnits(element, "y2"));
-		if (from.x === to.x && from.y === to.y) {
-			report(state, "svg/element-skipped", `${detail}: zero-length line`);
-			return;
-		}
-		state.vectors.push({
-			kind: "line",
-			from: {
-				xPt: from.x,
-				yPt: from.y
-			},
-			to: {
-				xPt: to.x,
-				yPt: to.y
-			},
-			stroke: resolved.stroke,
-			paintOrder: state.paintOrder++,
-			sourcePath: `svg/vector[${state.vectors.length}]`
-		});
-		return;
-	}
-	if (name === "polyline" || name === "polygon") {
-		const pointsRaw = findAttribute(element, "points");
-		if (pointsRaw === void 0) {
-			report(state, "svg/element-skipped", `${detail}: no points attribute`);
-			return;
-		}
-		const numbers = pointsRaw.trim().split(/[\s,]+/).filter((part) => part !== "").map(Number);
-		if (numbers.length === 0 || numbers.length % 2 !== 0 || !numbers.every((value) => Number.isFinite(value))) {
-			report(state, "svg/element-unsupported", `${detail}: malformed points attribute`);
-			return;
-		}
-		if (numbers.length < 4) {
-			report(state, "svg/element-skipped", `${detail}: fewer than two points`);
-			return;
-		}
-		const segments = [];
-		for (let i = 2; i < numbers.length; i += 2) segments.push({
-			kind: "line",
-			to: {
-				x: numbers[i],
-				y: numbers[i + 1]
-			}
-		});
-		const vector = buildPathVector(state, [{
-			start: {
-				x: numbers[0],
-				y: numbers[1]
-			},
-			closed: name === "polygon",
-			segments
-		}], ctm, resolved, fillRule);
-		if (vector === void 0) report(state, "svg/element-skipped", `${detail}: all points coincide`);
-		else state.vectors.push(vector);
-		return;
-	}
-	if (name === "path") {
-		const d = findAttribute(element, "d");
-		if (d === void 0 || d.trim() === "") {
-			report(state, "svg/element-skipped", `${detail}: no d attribute`);
-			return;
-		}
-		const parsed = parseSvgPathData(d);
-		if (parsed === void 0 || parsed.length === 0) {
-			report(state, "svg/element-unsupported", `${detail}: malformed or empty path data`);
-			return;
-		}
-		const vector = buildPathVector(state, parsed, ctm, resolved, fillRule);
-		if (vector === void 0) report(state, "svg/element-skipped", `${detail}: path collapses to a single point`);
-		else state.vectors.push(vector);
-		return;
-	}
-}
-const NON_RENDERING_ELEMENTS = /* @__PURE__ */ new Set([
-	"defs",
-	"title",
-	"desc",
-	"metadata",
-	"linearGradient",
-	"radialGradient",
-	"pattern",
-	"clipPath",
-	"mask",
-	"marker",
-	"symbol",
-	"script"
-]);
-function walkElement(state, element, ctm, paint) {
-	const name = localName(element.tag);
-	const id = findAttribute(element, "id");
-	const detail = id === void 0 ? name : `${name}#${id}`;
-	if (findAttribute(element, "style") !== void 0) report(state, "svg/css-style-ignored", detail);
-	for (const opacityAttr of [
-		"opacity",
-		"fill-opacity",
-		"stroke-opacity"
-	]) {
-		const raw = findAttribute(element, opacityAttr);
-		if (raw !== void 0) {
-			const value = Number(raw);
-			if (Number.isFinite(value) && value < 1) report(state, "svg/opacity-ignored", `${detail}: ${opacityAttr}=${raw}`);
-		}
-	}
-	if (name === "g" || name === "a") {
-		const own = parseSvgTransform(findAttribute(element, "transform"));
-		walkChildren(state, element, own === void 0 ? ctm : composeMatrices(ctm, own), childPaintState(element, paint));
-		return;
-	}
-	if (NON_RENDERING_ELEMENTS.has(name)) return;
-	if (name === "style") {
-		report(state, "svg/css-style-ignored", detail);
-		return;
-	}
-	if (name === "text" || name === "tspan" || name === "textPath" || name === "tref") {
-		report(state, "svg/text-unsupported", detail);
-		return;
-	}
-	if (name === "image") {
-		report(state, "svg/image-unsupported", detail);
-		return;
-	}
-	if (name === "use") {
-		report(state, "svg/use-unsupported", detail);
-		return;
-	}
-	if (name === "rect" || name === "circle" || name === "ellipse" || name === "line" || name === "polyline" || name === "polygon" || name === "path") {
-		const own = parseSvgTransform(findAttribute(element, "transform"));
-		readShape(state, element, own === void 0 ? ctm : composeMatrices(ctm, own), childPaintState(element, paint));
-		return;
-	}
-	report(state, "svg/element-unsupported", detail);
-}
-function walkChildren(state, element, ctm, paint) {
-	for (const child of elementChildren(element)) walkElement(state, child, ctm, paint);
-}
-function resolveRootGeometry(root, state) {
-	const attrWidth = parseSvgLengthPt(findAttribute(root, "width"));
-	const attrHeight = parseSvgLengthPt(findAttribute(root, "height"));
-	const parsedViewBox = parseSvgViewBox(findAttribute(root, "viewBox"));
-	const viewBox = parsedViewBox !== void 0 && parsedViewBox.width > 0 && parsedViewBox.height > 0 ? parsedViewBox : void 0;
-	let widthPt = attrWidth !== void 0 && attrWidth > 0 ? attrWidth : void 0;
-	let heightPt = attrHeight !== void 0 && attrHeight > 0 ? attrHeight : void 0;
-	if (widthPt === void 0 !== (heightPt === void 0)) {
-		widthPt = void 0;
-		heightPt = void 0;
-	}
-	if (widthPt === void 0 || heightPt === void 0) {
-		if (viewBox !== void 0) {
-			widthPt = viewBox.width;
-			heightPt = viewBox.height;
-		} else {
-			widthPt = DEFAULT_WIDTH_PT;
-			heightPt = DEFAULT_HEIGHT_PT;
-			report(state, "svg/default-size-assumed", "neither width/height nor a usable viewBox was present; assuming the CSS default replaced-element size of 300x150 px");
-		}
-	}
-	if (viewBox === void 0) return {
-		widthPt,
-		heightPt,
-		map: {
-			a: .75,
-			b: 0,
-			c: 0,
-			d: .75,
-			e: 0,
-			f: 0
-		}
-	};
-	const preserveAspectRatio = findAttribute(root, "preserveAspectRatio") ?? "xMidYMid meet";
-	if (preserveAspectRatio.trim() !== "none") {
-		const viewBoxAspect = viewBox.width / viewBox.height;
-		const pageAspect = widthPt / heightPt;
-		if (Math.abs(viewBoxAspect - pageAspect) > ASPECT_COMPARE_TOLERANCE * Math.max(viewBoxAspect, pageAspect)) report(state, "svg/preserve-aspect-ratio-stretched", `viewBox aspect ${viewBoxAspect.toFixed(ASPECT_DISPLAY_DECIMALS)} stretched onto page aspect ${pageAspect.toFixed(ASPECT_DISPLAY_DECIMALS)} under preserveAspectRatio="${preserveAspectRatio.trim()}" (letterboxing is out of scope)`);
-	}
-	const sx = widthPt / viewBox.width;
-	const sy = heightPt / viewBox.height;
-	return {
-		widthPt,
-		heightPt,
-		map: {
-			a: sx,
-			b: 0,
-			c: 0,
-			d: sy,
-			e: -viewBox.minX * sx,
-			f: -viewBox.minY * sy
-		}
-	};
-}
-function readSvgContent(text, options) {
-	const root = parseXml(text).find((node) => node.type === "element" && localName(node.tag) === "svg");
-	if (root === void 0) throw new SvgMissingRootElementError();
-	const state = {
-		sink: options?.onSvgDiagnostic,
-		vectors: [],
-		paintOrder: 0
-	};
-	const rootGeometry = resolveRootGeometry(root, state);
-	const titleElement = elementChildren(root).find((child) => localName(child.tag) === "title");
-	const title = titleElement === void 0 ? void 0 : textOf(titleElement).trim();
-	const metadata = title === void 0 || title === "" ? {} : { title };
-	walkChildren(state, root, rootGeometry.map, childPaintState(root, {}));
-	return {
-		kind: "drawing",
-		metadata,
-		pages: [{
-			size: {
-				widthPt: rootGeometry.widthPt,
-				heightPt: rootGeometry.heightPt
-			},
-			shapes: [],
-			vectors: state.vectors
-		}]
-	};
-}
-//#endregion
-export { SvgMissingRootElementError, readSvgContent };
+import { a as resolveFillPaint, i as readSvgContent, n as KAPPA_NUMERATOR, r as SvgMissingRootElementError, t as KAPPA } from "../read-BSH--XB4.js";
+export { KAPPA, KAPPA_NUMERATOR, SvgMissingRootElementError, readSvgContent, resolveFillPaint };