reamkit 0.1.0-alpha.0

package/dist/esm/pdf/chart-geometry.js

@@ -0,0 +1,674 @@
+var AXIS_COLOR = "595959";
+var GRID_COLOR = "D9D9D9";
+var LABEL_COLOR = "595959";
+var TITLE_COLOR = "404040";
+var SERIES_COLORS = [
+	"4472C4",
+	"ED7D31",
+	"A5A5A5",
+	"FFC000",
+	"5B9BD5",
+	"70AD47"
+];
+var seriesColor = (s, i) => s.colorHex ?? SERIES_COLORS[i % SERIES_COLORS.length];
+function niceNum(range, round) {
+	const exp = Math.floor(Math.log10(range));
+	const f = range / 10 ** exp;
+	let nf;
+	if (round) nf = f < 1.5 ? 1 : f < 3 ? 2 : f < 7 ? 5 : 10;
+	else nf = f <= 1 ? 1 : f <= 2 ? 2 : f <= 5 ? 5 : 10;
+	return nf * 10 ** exp;
+}
+function niceScale(dataMin, dataMax, maxTicks = 6) {
+	const lo = Math.min(dataMin, dataMax);
+	let hi = Math.max(dataMin, dataMax);
+	if (lo === hi) hi = lo + 1;
+	const step = niceNum(niceNum(hi - lo, false) / Math.max(1, maxTicks - 1), true);
+	return {
+		min: Math.floor(lo / step) * step,
+		max: Math.ceil(hi / step) * step,
+		step
+	};
+}
+function formatTick(v, step) {
+	if (Number.isInteger(step) && Number.isInteger(v)) return String(v);
+	const decimals = Math.max(0, -Math.floor(Math.log10(step)));
+	return v.toFixed(decimals).replace(/\.?0+$/, (m) => m.includes(".") ? "" : m);
+}
+var ticks = (s) => {
+	const out = [];
+	for (let v = s.min; v <= s.max + 1e-9; v += s.step) out.push(Math.abs(v) < 1e-9 ? 0 : v);
+	return out;
+};
+function buildFrame(chart, wPt, hPt, measure, horizontal, opts = {}) {
+	const rects = [];
+	const polylines = [];
+	const labels = [];
+	const nCats = Math.max(chart.categories.length, ...chart.series.map((s) => s.values.length), 1);
+	const allVals = chart.series.flatMap((s) => s.values.slice(0, nCats));
+	const [dataMin, dataMax] = opts.dataRange ?? [Math.min(0, ...allVals), Math.max(0, ...allVals)];
+	const scale = niceScale(dataMin, dataMax);
+	const fmtVal = opts.formatValue ?? ((v) => formatTick(v, scale.step));
+	const tickVals = ticks(scale);
+	let top = 4;
+	if (chart.title) top += 13 * 1.6;
+	if (chart.valAxisTitle) top += 9 * 1.4;
+	const legend = layoutLegend(chart.series.map((s, i) => ({
+		name: s.name ?? "",
+		colorHex: seriesColor(s, i)
+	})).filter((e) => e.name !== ""), chart.hasLegend, chart.legendPos ?? "b", wPt, hPt, measure);
+	const plotRight = wPt - 4 - legend.rightWidth;
+	const tickLabelW = Math.max(0, ...tickVals.map((v) => measure(fmtVal(v), 9))) + 4;
+	const catLabelH = 9 * 1.6;
+	const catTitleH = chart.catAxisTitle ? 9 * 1.5 : 0;
+	const x0 = 4 + tickLabelW;
+	const y0 = 4 + legend.bottomHeight + catTitleH + catLabelH;
+	const plotW = Math.max(1, plotRight - x0);
+	const plotH = Math.max(1, hPt - top - y0);
+	const valueOffset = (v) => (v - scale.min) / (scale.max - scale.min) * (horizontal ? plotW : plotH);
+	const zeroOffset = valueOffset(0);
+	if (chart.title) labels.push({
+		text: chart.title,
+		x: wPt / 2,
+		y: hPt - 4 - 13,
+		sizePt: 13,
+		colorHex: TITLE_COLOR,
+		align: "center"
+	});
+	if (chart.valAxisTitle) labels.push({
+		text: chart.valAxisTitle,
+		x: x0,
+		y: hPt - top + 3,
+		sizePt: 9,
+		colorHex: LABEL_COLOR,
+		align: "left"
+	});
+	if (chart.catAxisTitle) labels.push({
+		text: chart.catAxisTitle,
+		x: x0 + plotW / 2,
+		y: legend.bottomHeight + 2,
+		sizePt: 9,
+		colorHex: LABEL_COLOR,
+		align: "center"
+	});
+	for (const v of tickVals) {
+		const off = valueOffset(v);
+		if (horizontal) {
+			const gx = x0 + off;
+			polylines.push({
+				points: [[gx, y0], [gx, y0 + plotH]],
+				strokeHex: GRID_COLOR,
+				widthPt: .75
+			});
+			labels.push({
+				text: fmtVal(v),
+				x: gx,
+				y: y0 - 9,
+				sizePt: 9,
+				colorHex: LABEL_COLOR,
+				align: "center"
+			});
+		} else {
+			const gy = y0 + off;
+			polylines.push({
+				points: [[x0, gy], [x0 + plotW, gy]],
+				strokeHex: GRID_COLOR,
+				widthPt: .75
+			});
+			labels.push({
+				text: fmtVal(v),
+				x: x0 - 3,
+				y: gy - 9 / 3,
+				sizePt: 9,
+				colorHex: LABEL_COLOR,
+				align: "right"
+			});
+		}
+	}
+	const slot = (horizontal ? plotH : plotW) / nCats;
+	for (let c = 0; c < nCats; c++) {
+		const cat = chart.categories[c] ?? "";
+		if (!cat) continue;
+		const center = (horizontal ? y0 : x0) + c * slot + slot / 2;
+		if (horizontal) labels.push({
+			text: cat,
+			x: x0 - 3,
+			y: center - 9 / 3,
+			sizePt: 9,
+			colorHex: LABEL_COLOR,
+			align: "right"
+		});
+		else labels.push({
+			text: cat,
+			x: center,
+			y: y0 - 9,
+			sizePt: 9,
+			colorHex: LABEL_COLOR,
+			align: "center"
+		});
+	}
+	polylines.push({
+		points: [[x0, y0], [x0, y0 + plotH]],
+		strokeHex: AXIS_COLOR,
+		widthPt: 1
+	});
+	polylines.push({
+		points: [[x0, y0], [x0 + plotW, y0]],
+		strokeHex: AXIS_COLOR,
+		widthPt: 1
+	});
+	legend.emit(rects, labels);
+	return {
+		x0,
+		y0,
+		plotW,
+		plotH,
+		nCats,
+		slot,
+		horizontal,
+		zeroOffset,
+		valueOffset,
+		rects,
+		polylines,
+		labels
+	};
+}
+var pctLabel = (v) => `${Math.round(v * 100)}%`;
+var fmtDataLabel = (v) => Number.isInteger(v) ? String(v) : String(Math.round(v * 100) / 100);
+function catCount(chart) {
+	return Math.max(chart.categories.length, ...chart.series.map((s) => s.values.length), 1);
+}
+function stackedTotals(chart, nCats) {
+	let max = 0;
+	let min = 0;
+	for (let c = 0; c < nCats; c++) {
+		let pos = 0;
+		let neg = 0;
+		for (const s of chart.series) {
+			const v = s.values[c] ?? 0;
+			if (v >= 0) pos += v;
+			else neg += v;
+		}
+		max = Math.max(max, pos);
+		min = Math.min(min, neg);
+	}
+	return {
+		min,
+		max
+	};
+}
+function groupingFrameOpts(chart, nCats) {
+	const g = chart.grouping ?? "clustered";
+	if (g === "percentStacked") return {
+		dataRange: [0, 1],
+		formatValue: pctLabel
+	};
+	if (g === "stacked") {
+		const t = stackedTotals(chart, nCats);
+		return { dataRange: [Math.min(0, t.min), Math.max(0, t.max)] };
+	}
+	return {};
+}
+function buildBarScene(chart, wPt, hPt, measure) {
+	const g = chart.grouping ?? "clustered";
+	const stacked = g === "stacked" || g === "percentStacked";
+	const percent = g === "percentStacked";
+	const horizontal = chart.barDir === "bar";
+	const f = buildFrame(chart, wPt, hPt, measure, horizontal, groupingFrameOpts(chart, catCount(chart)));
+	if (stacked) {
+		const groupPad = f.slot * .15;
+		const barW = f.slot - 2 * groupPad;
+		for (let c = 0; c < f.nCats; c++) {
+			const along = (horizontal ? f.y0 : f.x0) + c * f.slot + groupPad;
+			const denom = percent ? chart.series.reduce((a, s) => a + Math.abs(s.values[c] ?? 0), 0) || 1 : 1;
+			let cumPos = 0;
+			let cumNeg = 0;
+			for (let s = 0; s < chart.series.length; s++) {
+				const series = chart.series[s];
+				const v = (series.values[c] ?? 0) / denom;
+				const base = v >= 0 ? cumPos : cumNeg;
+				const top = base + v;
+				const o0 = f.valueOffset(base);
+				const o1 = f.valueOffset(top);
+				const lo = Math.min(o0, o1);
+				const span = Math.abs(o1 - o0);
+				const color = pointColor(series, c) ?? seriesColor(series, s);
+				if (horizontal) f.rects.push({
+					x: f.x0 + lo,
+					y: along,
+					w: span,
+					h: barW,
+					fillHex: color
+				});
+				else f.rects.push({
+					x: along,
+					y: f.y0 + lo,
+					w: barW,
+					h: span,
+					fillHex: color
+				});
+				if (chart.showValues && span > 9) {
+					const raw = series.values[c] ?? 0;
+					if (horizontal) f.labels.push(centeredLabel(fmtDataLabel(raw), f.x0 + lo + span / 2, along + barW * .3));
+					else f.labels.push(centeredLabel(fmtDataLabel(raw), along + barW / 2, f.y0 + lo + span / 2 - 3));
+				}
+				if (v >= 0) cumPos = top;
+				else cumNeg = top;
+			}
+		}
+		return {
+			rects: f.rects,
+			polylines: f.polylines,
+			wedges: [],
+			labels: f.labels
+		};
+	}
+	const nSer = Math.max(1, chart.series.length);
+	const groupPad = f.slot * .15;
+	const barW = (f.slot - 2 * groupPad) / nSer;
+	for (let c = 0; c < f.nCats; c++) {
+		const slotStart = (horizontal ? f.y0 : f.x0) + c * f.slot + groupPad;
+		for (let s = 0; s < chart.series.length; s++) {
+			const series = chart.series[s];
+			const len = f.valueOffset(series.values[c] ?? 0) - f.zeroOffset;
+			const color = pointColor(series, c) ?? seriesColor(series, s);
+			const along = slotStart + s * barW;
+			if (horizontal) {
+				const bx = f.x0 + f.zeroOffset + Math.min(0, len);
+				f.rects.push({
+					x: bx,
+					y: along,
+					w: Math.abs(len),
+					h: barW * .9,
+					fillHex: color
+				});
+			} else {
+				const by = f.y0 + f.zeroOffset + Math.min(0, len);
+				f.rects.push({
+					x: along,
+					y: by,
+					w: barW * .9,
+					h: Math.abs(len),
+					fillHex: color
+				});
+			}
+			if (chart.showValues) {
+				const txt = fmtDataLabel(series.values[c] ?? 0);
+				if (horizontal) {
+					const end = f.x0 + f.zeroOffset + len;
+					f.labels.push({
+						text: txt,
+						x: end + (len >= 0 ? 3 : -3),
+						y: along + barW * .25,
+						sizePt: 9,
+						colorHex: LABEL_COLOR,
+						align: len >= 0 ? "left" : "right"
+					});
+				} else {
+					const end = f.y0 + f.zeroOffset + len;
+					f.labels.push(centeredLabel(txt, along + barW * .45, len >= 0 ? end + 2 : end - 9));
+				}
+			}
+		}
+	}
+	return {
+		rects: f.rects,
+		polylines: f.polylines,
+		wedges: [],
+		labels: f.labels
+	};
+}
+function centeredLabel(text, x, y) {
+	return {
+		text,
+		x,
+		y,
+		sizePt: 9,
+		colorHex: LABEL_COLOR,
+		align: "center"
+	};
+}
+function areaBand(top, base, f, xAt, fillHex) {
+	const pts = [];
+	for (let c = 0; c < f.nCats; c++) pts.push([xAt(c), f.y0 + f.valueOffset(top[c] ?? 0)]);
+	for (let c = f.nCats - 1; c >= 0; c--) pts.push([xAt(c), f.y0 + f.valueOffset(base[c] ?? 0)]);
+	return {
+		points: pts,
+		fillHex,
+		strokeHex: fillHex,
+		widthPt: 1
+	};
+}
+function buildAreaScene(chart, wPt, hPt, measure) {
+	const g = chart.grouping ?? "standard";
+	const stacked = g === "stacked" || g === "percentStacked";
+	const percent = g === "percentStacked";
+	const nCats = catCount(chart);
+	const f = buildFrame(chart, wPt, hPt, measure, false, groupingFrameOpts(chart, nCats));
+	const xAt = (c) => f.x0 + c * f.slot + f.slot / 2;
+	const polygons = [];
+	if (stacked) {
+		const cum = new Array(nCats).fill(0);
+		for (let s = 0; s < chart.series.length; s++) {
+			const series = chart.series[s];
+			const base = cum.slice();
+			const top = cum.map((b, c) => {
+				const denom = percent ? chart.series.reduce((a, ss) => a + Math.abs(ss.values[c] ?? 0), 0) || 1 : 1;
+				return b + (series.values[c] ?? 0) / denom;
+			});
+			polygons.push(areaBand(top, base, f, xAt, seriesColor(series, s)));
+			for (let c = 0; c < nCats; c++) cum[c] = top[c];
+		}
+	} else {
+		const base = new Array(nCats).fill(0);
+		for (let s = chart.series.length - 1; s >= 0; s--) {
+			const series = chart.series[s];
+			const top = Array.from({ length: nCats }, (_, c) => series.values[c] ?? 0);
+			polygons.push(areaBand(top, base, f, xAt, seriesColor(series, s)));
+		}
+	}
+	return {
+		rects: f.rects,
+		polylines: f.polylines,
+		wedges: [],
+		labels: f.labels,
+		polygons
+	};
+}
+function buildScatterScene(chart, wPt, hPt, measure) {
+	const rects = [];
+	const polylines = [];
+	const labels = [];
+	const xs = [];
+	const ys = [];
+	for (const s of chart.series) for (let i = 0; i < s.values.length; i++) {
+		xs.push(s.xValues?.[i] ?? i);
+		ys.push(s.values[i] ?? 0);
+	}
+	if (xs.length === 0) return {
+		rects,
+		polylines,
+		wedges: [],
+		labels
+	};
+	const xScale = niceScale(Math.min(...xs), Math.max(...xs));
+	const yScale = niceScale(Math.min(...ys), Math.max(...ys));
+	const xTicks = ticks(xScale);
+	const yTicks = ticks(yScale);
+	let top = 4;
+	if (chart.title) top += 13 * 1.6;
+	const legend = layoutLegend(chart.series.map((s, i) => ({
+		name: s.name ?? "",
+		colorHex: seriesColor(s, i)
+	})).filter((e) => e.name !== ""), chart.hasLegend, chart.legendPos ?? "b", wPt, hPt, measure);
+	const x0 = 4 + (Math.max(0, ...yTicks.map((v) => measure(formatTick(v, yScale.step), 9))) + 4);
+	const y0 = 4 + legend.bottomHeight + 9 * 1.6;
+	const plotW = Math.max(1, wPt - 4 - legend.rightWidth - x0);
+	const plotH = Math.max(1, hPt - top - y0);
+	const xAt = (v) => x0 + (v - xScale.min) / (xScale.max - xScale.min) * plotW;
+	const yAt = (v) => y0 + (v - yScale.min) / (yScale.max - yScale.min) * plotH;
+	if (chart.title) labels.push({
+		text: chart.title,
+		x: wPt / 2,
+		y: hPt - 4 - 13,
+		sizePt: 13,
+		colorHex: TITLE_COLOR,
+		align: "center"
+	});
+	for (const v of yTicks) {
+		const gy = yAt(v);
+		polylines.push({
+			points: [[x0, gy], [x0 + plotW, gy]],
+			strokeHex: GRID_COLOR,
+			widthPt: .75
+		});
+		labels.push({
+			text: formatTick(v, yScale.step),
+			x: x0 - 3,
+			y: gy - 9 / 3,
+			sizePt: 9,
+			colorHex: LABEL_COLOR,
+			align: "right"
+		});
+	}
+	for (const v of xTicks) {
+		const gx = xAt(v);
+		polylines.push({
+			points: [[gx, y0], [gx, y0 + plotH]],
+			strokeHex: GRID_COLOR,
+			widthPt: .75
+		});
+		labels.push({
+			text: formatTick(v, xScale.step),
+			x: gx,
+			y: y0 - 9,
+			sizePt: 9,
+			colorHex: LABEL_COLOR,
+			align: "center"
+		});
+	}
+	polylines.push({
+		points: [[x0, y0], [x0, y0 + plotH]],
+		strokeHex: AXIS_COLOR,
+		widthPt: 1
+	});
+	polylines.push({
+		points: [[x0, y0], [x0 + plotW, y0]],
+		strokeHex: AXIS_COLOR,
+		widthPt: 1
+	});
+	for (let s = 0; s < chart.series.length; s++) {
+		const series = chart.series[s];
+		const color = seriesColor(series, s);
+		for (let i = 0; i < series.values.length; i++) {
+			const px = xAt(series.xValues?.[i] ?? i);
+			const py = yAt(series.values[i] ?? 0);
+			rects.push({
+				x: px - 2,
+				y: py - 2,
+				w: 4,
+				h: 4,
+				fillHex: color
+			});
+		}
+	}
+	legend.emit(rects, labels);
+	return {
+		rects,
+		polylines,
+		wedges: [],
+		labels
+	};
+}
+function buildLineScene(chart, wPt, hPt, measure) {
+	const allVals = chart.series.flatMap((s) => s.values);
+	const f = buildFrame(chart, wPt, hPt, measure, false, { dataRange: allVals.length > 0 ? [Math.min(...allVals), Math.max(...allVals)] : [0, 1] });
+	for (let s = 0; s < chart.series.length; s++) {
+		const series = chart.series[s];
+		const color = seriesColor(series, s);
+		const pts = [];
+		for (let c = 0; c < f.nCats; c++) {
+			const x = f.x0 + c * f.slot + f.slot / 2;
+			const y = f.y0 + f.valueOffset(series.values[c] ?? 0);
+			pts.push([x, y]);
+			if (chart.showValues) f.labels.push(centeredLabel(fmtDataLabel(series.values[c] ?? 0), x, y + 3));
+		}
+		if (pts.length >= 2) f.polylines.push({
+			points: pts,
+			strokeHex: color,
+			widthPt: 1.5
+		});
+		else if (pts.length === 1) {
+			const [px, py] = pts[0];
+			f.rects.push({
+				x: px - 1.5,
+				y: py - 1.5,
+				w: 3,
+				h: 3,
+				fillHex: color
+			});
+		}
+	}
+	return {
+		rects: f.rects,
+		polylines: f.polylines,
+		wedges: [],
+		labels: f.labels
+	};
+}
+var sliceColor = (series, i) => pointColor(series, i) ?? SERIES_COLORS[i % SERIES_COLORS.length];
+function buildPieScene(chart, wPt, hPt, measure) {
+	const rects = [];
+	const wedges = [];
+	const labels = [];
+	const series = chart.series[0];
+	const values = series ? series.values.map((v) => Math.max(0, v)) : [];
+	const total = values.reduce((a, b) => a + b, 0);
+	if (!series || total <= 0) return {
+		rects,
+		polylines: [],
+		wedges,
+		labels
+	};
+	let top = 4;
+	if (chart.title) top += 13 * 1.6;
+	const legend = layoutLegend(chart.categories.map((c, i) => ({
+		name: c,
+		colorHex: sliceColor(series, i)
+	})), chart.hasLegend, chart.legendPos ?? "r", wPt, hPt, measure);
+	const availW = Math.max(1, wPt - 8 - legend.rightWidth);
+	const availH = Math.max(1, hPt - top - 4 - legend.bottomHeight);
+	const r = Math.max(1, Math.min(availW, availH) / 2 * .95);
+	const cx = 4 + availW / 2;
+	const cy = 4 + legend.bottomHeight + availH / 2;
+	const holeR = chart.doughnut ? r * .5 : 0;
+	const labelR = chart.doughnut ? (holeR + r) / 2 : r * .6;
+	let ang = Math.PI / 2;
+	for (let i = 0; i < values.length; i++) {
+		const v = values[i];
+		if (v <= 0) continue;
+		const sweep = -(v / total) * 2 * Math.PI;
+		wedges.push({
+			cx,
+			cy,
+			r,
+			startRad: ang,
+			sweepRad: sweep,
+			fillHex: sliceColor(series, i),
+			strokeHex: "FFFFFF"
+		});
+		const mid = ang + sweep / 2;
+		const pct = Math.round(v / total * 100);
+		if (pct >= 5) labels.push({
+			text: `${pct}%`,
+			x: cx + Math.cos(mid) * labelR,
+			y: cy + Math.sin(mid) * labelR - 9 / 3,
+			sizePt: 9,
+			colorHex: chart.doughnut ? LABEL_COLOR : "FFFFFF",
+			align: "center"
+		});
+		ang += sweep;
+	}
+	if (holeR > 0) wedges.push({
+		cx,
+		cy,
+		r: holeR,
+		startRad: 0,
+		sweepRad: -2 * Math.PI,
+		fillHex: "FFFFFF"
+	});
+	if (chart.title) labels.push({
+		text: chart.title,
+		x: wPt / 2,
+		y: hPt - 4 - 13,
+		sizePt: 13,
+		colorHex: TITLE_COLOR,
+		align: "center"
+	});
+	legend.emit(rects, labels);
+	return {
+		rects,
+		polylines: [],
+		wedges,
+		labels
+	};
+}
+function pointColor(series, idx) {
+	return series.pointColors?.find((p) => p.idx === idx)?.colorHex;
+}
+function layoutLegend(entries, hasLegend, pos, wPt, hPt, measure) {
+	if (!hasLegend || entries.length === 0) return {
+		rightWidth: 0,
+		bottomHeight: 0,
+		emit: () => {}
+	};
+	const sw = 9;
+	const gap = 4;
+	const entryW = (e) => sw + 3 + measure(e.name, 9) + gap * 2;
+	if (pos === "r" || pos === "l") {
+		const colW = Math.max(...entries.map(entryW));
+		return {
+			rightWidth: pos === "r" ? colW : 0,
+			bottomHeight: 0,
+			emit: (rects, labels) => {
+				const lx = pos === "r" ? wPt - colW + gap : gap;
+				let ly = hPt / 2 + entries.length * (sw + 4) / 2 - sw;
+				for (const e of entries) {
+					rects.push({
+						x: lx,
+						y: ly,
+						w: sw,
+						h: sw,
+						fillHex: e.colorHex
+					});
+					labels.push({
+						text: e.name,
+						x: lx + sw + 3,
+						y: ly + 1,
+						sizePt: 9,
+						colorHex: LABEL_COLOR,
+						align: "left"
+					});
+					ly -= sw + 4;
+				}
+			}
+		};
+	}
+	const totalW = entries.reduce((acc, e) => acc + entryW(e), 0);
+	return {
+		rightWidth: 0,
+		bottomHeight: sw + 6,
+		emit: (rects, labels) => {
+			let lx = (wPt - totalW) / 2 + gap;
+			const ly = 2;
+			for (const e of entries) {
+				rects.push({
+					x: lx,
+					y: ly,
+					w: sw,
+					h: sw,
+					fillHex: e.colorHex
+				});
+				labels.push({
+					text: e.name,
+					x: lx + sw + 3,
+					y: ly + 1,
+					sizePt: 9,
+					colorHex: LABEL_COLOR,
+					align: "left"
+				});
+				lx += entryW(e);
+			}
+		}
+	};
+}
+function buildChartScene(chart, wPt, hPt, measure) {
+	if (chart.type === "bar") return buildBarScene(chart, wPt, hPt, measure);
+	if (chart.type === "line") return buildLineScene(chart, wPt, hPt, measure);
+	if (chart.type === "pie") return buildPieScene(chart, wPt, hPt, measure);
+	if (chart.type === "area") return buildAreaScene(chart, wPt, hPt, measure);
+	if (chart.type === "scatter") return buildScatterScene(chart, wPt, hPt, measure);
+	return null;
+}
+//#endregion
+export { buildChartScene };

package/dist/esm/pdf/cid-font.d.ts

@@ -0,0 +1,15 @@
+import { ParsedTtf } from '../font/index.js';
+import { PdfRef } from './objects.js';
+import { PdfDocument } from './writer.js';
+export interface EmbedTtfOptions {
+    readonly usedGids?: Iterable<number>;
+    readonly cidSet?: boolean;
+}
+export interface EmbeddedFont {
+    readonly fontRef: PdfRef;
+    readonly parsed: ParsedTtf;
+    readonly pdfWidthForGid: (gid: number) => number;
+    readonly textWidthPt: (text: string, fontSize: number) => number;
+    readonly encodeTextAsCidHex: (text: string) => string;
+}
+export declare function embedTtfFont(doc: PdfDocument, parsed: ParsedTtf, options?: EmbedTtfOptions): EmbeddedFont;