documents.js 2.1.0 → 2.2.0

package/dist/svg/read.cjs

@@ -0,0 +1,677 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_svg_paint = require("./paint.cjs");
+const require_svg_path = require("./path.cjs");
+const require_svg_units = require("./units.cjs");
+const require_svg_transform = require("./transform.cjs");
+let ooxml_js = require("ooxml.js");
+let document_schema_js = require("document-schema.js");
+let odf_js = require("odf.js");
+//#region src/svg/read.ts
+var SvgMissingRootElementError = class extends Error {
+	constructor() {
+		super("svg text must contain an <svg> root element");
+		this.name = "SvgMissingRootElementError";
+	}
+};
+const DEFAULT_WIDTH_PT = 225;
+const DEFAULT_HEIGHT_PT = 112.5;
+const KAPPA = 4 / 3 * (Math.SQRT2 - 1);
+function localName(tag) {
+	const colon = tag.indexOf(":");
+	return colon === -1 ? tag : tag.slice(colon + 1);
+}
+function findAttribute(element, name) {
+	for (const attribute of element.attributes) if (localName(attribute.name) === name) return (0, ooxml_js.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 += (0, ooxml_js.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?.(detail === void 0 ? { code } : {
+		code,
+		detail
+	});
+}
+function resolveFillPaint(state, spec, isFill) {
+	if (spec === void 0) return isFill ? {
+		r: 0,
+		g: 0,
+		b: 0
+	} : void 0;
+	const paint = require_svg_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 = (require_svg_units.parseSvgUserUnits(paint.strokeWidthSpec) ?? 1) * require_svg_transform.meanScaleFactor(ctm);
+	if (!(widthPt > 0)) return;
+	const style = require_svg_paint.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([
+		require_svg_transform.applyMatrix(ctm, x, y),
+		require_svg_transform.applyMatrix(ctm, x + width, y),
+		require_svg_transform.applyMatrix(ctm, x + width, y + height),
+		require_svg_transform.applyMatrix(ctm, x, y + height)
+	]);
+}
+function similarityFrame(ctm, x, y, width, height) {
+	const centre = require_svg_transform.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: require_svg_transform.applyMatrix(ctm, subpath.start.x, subpath.start.y),
+		closed: subpath.closed,
+		segments: subpath.segments.map((segment) => segment.kind === "line" ? {
+			kind: "line",
+			to: require_svg_transform.applyMatrix(ctm, segment.to.x, segment.to.y)
+		} : {
+			kind: "cubic",
+			control1: require_svg_transform.applyMatrix(ctm, segment.control1.x, segment.control1.y),
+			control2: require_svg_transform.applyMatrix(ctm, segment.control2.x, segment.control2.y),
+			to: require_svg_transform.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 require_svg_units.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 = require_svg_units.parseSvgUserUnits(findAttribute(element, "rx"));
+		const ryAttr = require_svg_units.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 = !require_svg_transform.isAxisAligned(ctm) && require_svg_transform.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: require_svg_transform.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 (!require_svg_transform.isAxisAligned(ctm) && !require_svg_transform.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 = !require_svg_transform.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: require_svg_transform.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 = require_svg_transform.applyMatrix(ctm, userUnits(element, "x1"), userUnits(element, "y1"));
+		const to = require_svg_transform.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 = require_svg_path.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 = require_svg_transform.parseSvgTransform(findAttribute(element, "transform"));
+		walkChildren(state, element, own === void 0 ? ctm : require_svg_transform.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 = require_svg_transform.parseSvgTransform(findAttribute(element, "transform"));
+		readShape(state, element, own === void 0 ? ctm : require_svg_transform.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 = require_svg_units.parseSvgLengthPt(findAttribute(root, "width"));
+	const attrHeight = require_svg_units.parseSvgLengthPt(findAttribute(root, "height"));
+	const parsedViewBox = require_svg_units.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) > 1e-6 * Math.max(viewBoxAspect, pageAspect)) report(state, "svg/preserve-aspect-ratio-stretched", `viewBox aspect ${viewBoxAspect.toFixed(4)} stretched onto page aspect ${pageAspect.toFixed(4)} 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 = (0, odf_js.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, {}));
+	const page = {
+		size: {
+			widthPt: rootGeometry.widthPt,
+			heightPt: rootGeometry.heightPt
+		},
+		shapes: [],
+		vectors: state.vectors
+	};
+	return {
+		kind: "drawing",
+		formatVersion: document_schema_js.CONTENT_FORMAT_VERSION,
+		metadata,
+		pages: [page]
+	};
+}
+//#endregion
+exports.SvgMissingRootElementError = SvgMissingRootElementError;
+exports.readSvgContent = readSvgContent;

package/dist/svg/read.d.cts

@@ -0,0 +1,12 @@
+import { SvgDiagnosticSink } from "./diagnostics.cjs";
+import { ContentDocument } from "document-schema.js";
+//#region src/svg/read.d.ts
+interface ReadSvgContentOptions {
+  readonly onSvgDiagnostic?: SvgDiagnosticSink;
+}
+declare class SvgMissingRootElementError extends Error {
+  constructor();
+}
+declare function readSvgContent(text: string, options?: ReadSvgContentOptions): ContentDocument;
+//#endregion
+export { ReadSvgContentOptions, SvgMissingRootElementError, readSvgContent };

package/dist/svg/read.d.ts

@@ -0,0 +1,12 @@
+import { SvgDiagnosticSink } from "./diagnostics.js";
+import { ContentDocument } from "document-schema.js";
+//#region src/svg/read.d.ts
+interface ReadSvgContentOptions {
+  readonly onSvgDiagnostic?: SvgDiagnosticSink;
+}
+declare class SvgMissingRootElementError extends Error {
+  constructor();
+}
+declare function readSvgContent(text: string, options?: ReadSvgContentOptions): ContentDocument;
+//#endregion
+export { ReadSvgContentOptions, SvgMissingRootElementError, readSvgContent };