@docen/docx 0.3.1 → 0.3.3

package/dist/extensions/utils.mjs

@@ -1,2 +1,508 @@
-import { S as twipToCss, _ as shadingFromElement, a as characterSpacingFromCss, b as sizeToCss, c as indentFromElement, d as renderBorderCSS, f as renderParagraphStyles, g as shadingFromCss, h as resolveFontName, i as bordersFromElement, l as lineSpacingToCss, m as renderTableCellStyles, n as alignmentFromElement, o as characterSpacingToCss, p as renderRunStyles, r as alignmentToCss, s as cssToTwip, t as alignmentFromCss, u as normalizeColorToHex, v as shadingToCss, x as spacingFromElement, y as sizeFromCss } from "../utils-BPT4tjcn.mjs";
-export { alignmentFromCss, alignmentFromElement, alignmentToCss, bordersFromElement, characterSpacingFromCss, characterSpacingToCss, cssToTwip, indentFromElement, lineSpacingToCss, normalizeColorToHex, renderBorderCSS, renderParagraphStyles, renderRunStyles, renderTableCellStyles, resolveFontName, shadingFromCss, shadingFromElement, shadingToCss, sizeFromCss, sizeToCss, spacingFromElement, twipToCss };
+import { sectionMarginDefaults, sectionPageSizeDefaults } from "@office-open/docx";
+//#region src/extensions/utils.ts
+/** Factory for a Tiptap attr that carries an office-open native value: never
+*  parsed from HTML nor rendered to it, defaulting to null (ProseMirror stores
+*  every declared attr). Shared by every extension carrying OOXML attrs
+*  (paragraph/heading/table/table-cell/…). */
+const attrNative = () => ({
+	default: null,
+	parseHTML: () => null,
+	rendered: false
+});
+/** Common CSS named colors → hex */
+const CSS_COLORS = {
+	black: "#000000",
+	white: "#FFFFFF",
+	red: "#FF0000",
+	green: "#008000",
+	blue: "#0000FF",
+	yellow: "#FFFF00",
+	cyan: "#00FFFF",
+	magenta: "#FF00FF",
+	gray: "#808080",
+	grey: "#808080",
+	orange: "#FFA500",
+	purple: "#800080",
+	pink: "#FFC0CB",
+	brown: "#A52A2A",
+	lime: "#00FF00",
+	navy: "#000080",
+	teal: "#008080",
+	silver: "#C0C0C0",
+	maroon: "#800000",
+	olive: "#808000",
+	aqua: "#00FFFF",
+	fuchsia: "#FF00FF",
+	indigo: "#4B0082",
+	violet: "#EE82EE",
+	coral: "#FF7F50",
+	gold: "#FFD700",
+	salmon: "#FA8072",
+	tomato: "#FF6347"
+};
+/** Normalize a CSS color value to hex (e.g., "red" → "#FF0000", "#ff0000" → "#FF0000").
+*  Accepts a string (CSS name/hex or bare OOXML hex), or an OOXML ColorOptions
+*  object ({ val, themeColor, themeTint, themeShade }) — the object form
+*  resolves to its val (the RGB fallback Word stores alongside themeColor) for
+*  CSS rendering. The themeColor/tint/shade are preserved verbatim in the attrs
+*  and round-trip back to the DOCX (see text-style/paragraph parseDocx), so
+*  theme semantics survive even though only val is rendered here. A pure theme
+*  reference with no val (rare — Word usually stores both) would need theme.xml
+*  to resolve and is left unset. */
+function normalizeColorToHex(color) {
+	if (!color) return void 0;
+	if (typeof color === "object") {
+		const { val } = color;
+		return val ? normalizeColorToHex(val) : void 0;
+	}
+	if (typeof color !== "string") return void 0;
+	if (color === "auto") return void 0;
+	if (color.startsWith("#")) return color.length === 4 ? `#${color[1]}${color[1]}${color[2]}${color[2]}${color[3]}${color[3]}`.toUpperCase() : color.toUpperCase();
+	if (/^[0-9A-Fa-f]{6}$/.test(color)) return `#${color.toUpperCase()}`;
+	if (/^[0-9A-Fa-f]{3}$/.test(color)) return `#${color[0]}${color[0]}${color[1]}${color[1]}${color[2]}${color[2]}`.toUpperCase();
+	return CSS_COLORS[color.toLowerCase()] ?? void 0;
+}
+/** Resolve a font value (string or OOXML rFonts { ascii, eastAsia, hAnsi, cs }) to a CSS family name. */
+function resolveFontName(font) {
+	if (!font) return null;
+	if (typeof font === "string") return font;
+	if (typeof font === "object") {
+		const f = font;
+		return f.ascii || f.hAnsi || f.eastAsia || null;
+	}
+	return null;
+}
+/** Resolve a font value to a CSS font-family list with an eastAsia fallback.
+*  Mirrors Word's per-Unicode-range font selection (MS-OE376): Basic Latin uses
+*  the ascii font, CJK Ideographs use eastAsia. CSS can't split a run by range,
+*  so list ascii first (it carries Basic Latin glyphs) then eastAsia — the
+*  browser falls back to eastAsia for CJK chars the ascii font lacks. Without
+*  this, CJK text renders in the ascii font (e.g. Times) instead of the
+*  document's CJK font (e.g. SimSun). Use this for font-family rendering;
+*  resolveFontName (single name) stays for UI/parse. */
+function resolveFontFamilyCss(font) {
+	if (!font) return null;
+	if (typeof font === "string") return font;
+	if (typeof font === "object") {
+		const f = font;
+		const ascii = f.ascii || f.hAnsi;
+		const ea = f.eastAsia;
+		if (ascii && ea && ascii !== ea) return `"${ascii}","${ea}"`;
+		return ascii || ea || null;
+	}
+	return null;
+}
+/** CSS value (e.g., "18pt") → twip number. 1 pt = 20 twips, 1 px = 15 twips (96 DPI). */
+function cssToTwip(value) {
+	if (!value) return void 0;
+	const match = value.match(/^([\d.]+)(pt|px|em|cm|in)?$/);
+	if (!match) return void 0;
+	const num = parseFloat(match[1]);
+	switch (match[2] ?? "pt") {
+		case "pt": return Math.round(num * 20);
+		case "px": return Math.round(num * 15);
+		case "in": return Math.round(num * 1440);
+		case "cm": return Math.round(num * 567);
+		case "em": return Math.round(num * 240);
+		default: return Math.round(num * 20);
+	}
+}
+/** Twip value → CSS string (e.g., 360 → "18pt"). */
+function twipToCss(value) {
+	if (value == null) return null;
+	if (typeof value === "string") return value;
+	return `${value / 20}pt`;
+}
+const ALIGNMENT_TO_CSS = {
+	left: "left",
+	center: "center",
+	right: "right",
+	start: "start",
+	end: "end",
+	both: "justify",
+	distribute: "justify"
+};
+const CSS_TO_ALIGNMENT = {
+	left: "left",
+	center: "center",
+	right: "right",
+	start: "start",
+	end: "end",
+	justify: "both"
+};
+/** OOXML alignment → CSS text-align. */
+function alignmentToCss(alignment) {
+	if (!alignment) return null;
+	return ALIGNMENT_TO_CSS[alignment] ?? null;
+}
+/** CSS text-align → OOXML alignment. */
+function alignmentFromCss(css) {
+	if (!css) return null;
+	return CSS_TO_ALIGNMENT[css] ?? null;
+}
+/** Shading.fill → CSS background-color hex. */
+function shadingToCss(shading) {
+	if (!shading?.fill) return null;
+	return normalizeColorToHex(shading.fill) ?? null;
+}
+/** CSS background-color → ShadingAttributesProperties (fill normalized to hex). */
+function shadingFromCss(css) {
+	const hex = normalizeColorToHex(css ?? void 0);
+	return hex ? {
+		fill: hex,
+		type: "clear"
+	} : null;
+}
+function lineSpacingToCss(spacing, snapToGrid = null) {
+	if (!spacing?.line) return null;
+	const rule = spacing.lineRule;
+	if (rule === "exact" || rule === "exactly" || rule === "atLeast") return `${Number(spacing.line) / 20}pt`;
+	if (snapToGrid === false) return `calc(var(--docen-font-metric, 1.2) * ${Number((Number(spacing.line) / 240).toFixed(2))} * var(--docen-line-base, 1em))`;
+	return `calc(var(--docen-font-metric, 1.2) * var(--docen-line-base, 1em) + var(--docen-line-pitch, 0pt))`;
+}
+/** twips → mm (1 in = 1440 tw = 25.4 mm), 2dp string. */
+function twipsToMm(twips) {
+	return `${(twips / 1440 * 25.4).toFixed(2)}mm`;
+}
+/** Resolve a section's printable page dimensions (twips), honoring orientation.
+*  A landscape section commonly stores portrait dims (w<h) with
+*  `orientation: "landscape"` — swap width/height so width is the larger edge.
+*  Falls back to the engine's default page size (@office-open/docx
+*  `sectionPageSizeDefaults` = A4) when the size is absent or non-numeric — the
+*  engine's `stringifySectionPropertiesXml` fills an empty sectPr the same way,
+*  so edit-time geometry matches render/measure/generate/export. */
+function resolvePageSize(size) {
+	const fallback = {
+		width: sectionPageSizeDefaults.WIDTH,
+		height: sectionPageSizeDefaults.HEIGHT
+	};
+	if (!size || typeof size !== "object") return fallback;
+	const s = size;
+	const w = typeof s.width === "number" ? s.width : void 0;
+	const h = typeof s.height === "number" ? s.height : void 0;
+	if (w == null || h == null) return fallback;
+	return s.orientation === "landscape" && w < h ? {
+		width: h,
+		height: w
+	} : {
+		width: w,
+		height: h
+	};
+}
+/** Page margin (twips) → CSS padding. Sides absent or non-numeric fall back to
+*  the engine's default margins (@office-open/docx `sectionMarginDefaults`:
+*  top/bottom 1440tw, left/right 1800tw — MS Office zh-CN "Normal"), matching
+*  the page-size fallback above and the engine's empty-sectPr behavior. Margins
+*  are left as-is: office-open returns them already rotated for a landscape
+*  section. */
+function sectionMarginCss(margin) {
+	const def = sectionMarginDefaults;
+	const m = margin && typeof margin === "object" ? margin : {};
+	const num = (v, d) => typeof v === "number" ? v : d;
+	return `padding:${[
+		num(m.top, def.TOP),
+		num(m.right, def.RIGHT),
+		num(m.bottom, def.BOTTOM),
+		num(m.left, def.LEFT)
+	].map(twipsToMm).join(" ")}`;
+}
+/** Document grid linePitch (twips) → container CSS line-height.
+*  Per ECMA-376 snapToGrid, the grid linePitch is ADDED to each line (single-
+*  line paragraphs inherit it). So the container line-height (inherited by
+*  paragraphs without their own spacing) is the font's `normal` metric + the
+*  grid pitch, set only when the grid type enables line-snapping (not
+*  "default"). The --docen-line-pitch var carries the pitch so per-paragraph
+*  lineSpacingToCss can add the same pitch; --docen-font-metric is injected per
+*  paragraph by the editor; 1.2 is the fallback for static HTML export. */
+function sectionLinePitchCss(grid) {
+	if (!grid || typeof grid !== "object") return [];
+	const g = grid;
+	if (!g.type || g.type === "default" || typeof g.linePitch !== "number" || !g.linePitch) return [];
+	const pitch = `${(g.linePitch / 20).toFixed(2)}pt`;
+	return [`line-height:calc(var(--docen-font-metric, 1.2) * 1em + ${pitch})`, `--docen-line-pitch:${pitch}`];
+}
+function sizeToCss(size) {
+	if (size == null) return null;
+	return `${size}pt`;
+}
+function sizeFromCss(css) {
+	if (!css) return null;
+	const m = css.match(/^([\d.]+)(pt|px)?$/);
+	if (!m) return null;
+	const num = parseFloat(m[1]);
+	return (m[2] ?? "pt") === "px" ? num * .75 : num;
+}
+function characterSpacingToCss(spacing) {
+	if (spacing == null) return null;
+	return `${spacing / 20}pt`;
+}
+function characterSpacingFromCss(css) {
+	if (!css) return null;
+	const m = css.match(/^(-?[\d.]+)pt$/);
+	return m ? Math.round(parseFloat(m[1]) * 20) : null;
+}
+/** Render a BorderOptions to CSS string. OOXML border.size is in eighths of a point. */
+function renderBorderCSS(border) {
+	if (!border || !border.style || border.style === "none" || border.style === "nil") return null;
+	const size = border.size != null ? `${border.size / 8}pt` : "1pt";
+	const cssStyle = {
+		single: "solid",
+		dashed: "dashed",
+		dotted: "dotted",
+		double: "double",
+		dotDash: "dashed",
+		dotDotDash: "dotted",
+		dashSmallGap: "dashed"
+	}[border.style || "single"] || "solid";
+	const hex = border.color && border.color !== "auto" ? normalizeColorToHex(border.color) : null;
+	return hex ? `${cssStyle} ${size} ${hex}` : `${cssStyle} ${size}`;
+}
+const EMU_PER_PX = 9525;
+const EMU_PER_PT = 12700;
+/**
+* Render a drawing's Floating anchor (wp:anchor) to CSS — shared by Image and
+* WpgGroup so anchored drawings render consistently:
+*  - wrapNone (type 0): position:absolute at the EMU offset (text does not flow
+*    around it — "in front of text" / "behind text"); z-index lifts it above or
+*    below the text layer per behindDocument.
+*  - topAndBottom (3): float + clear:both.
+*  - square/tight/through (1/2/4): with an hPos.offset, float:right pulled to
+*    the offset via margin-right so text wraps beside it with no overlap;
+*    otherwise float on the wrap side (tight/through add shape-outside, src).
+* Wrap margins (wp:distT/B/L/R) are EMU, rendered as pt.
+*/
+function floatingToStyles(floating, src, width) {
+	const f = floating;
+	if (!f) return [];
+	const styles = [];
+	styles.push(`z-index:${f.behindDocument ? -1 : f.zIndex ?? 1}`);
+	const wrapType = f.wrap?.type ?? 0;
+	const hOff = f.horizontalPosition?.offset;
+	const vOff = f.verticalPosition?.offset;
+	if (wrapType === 0) {
+		styles.push("position:absolute");
+		if (hOff != null) styles.push(`left:${(hOff / EMU_PER_PX).toFixed(1)}px`);
+		if (vOff != null) styles.push(`top:${(vOff / EMU_PER_PX).toFixed(1)}px`);
+	} else if (wrapType !== 3 && hOff != null && width != null) {
+		const offPx = (hOff / EMU_PER_PX).toFixed(1);
+		styles.push("float:right", `margin-right:calc(100% - ${offPx}px - ${width}px)`);
+		if (vOff != null) styles.push(`margin-top:${(vOff / EMU_PER_PX).toFixed(1)}px`);
+		const m = f.margins;
+		if (m?.left) styles.push(`margin-left:${(m.left / EMU_PER_PT).toFixed(1)}pt`);
+	} else if (wrapType === 3) styles.push("float:left", "clear:both");
+	else {
+		const side = f.wrap?.side;
+		const floatSide = side === "right" || side === "outside" ? "right" : "left";
+		styles.push(`float:${floatSide}`);
+		if ((wrapType === 2 || wrapType === 4) && src) styles.push(`shape-outside:url(${src})`);
+	}
+	if (!(wrapType !== 0 && wrapType !== 3 && hOff != null && width != null) && wrapType !== 0) {
+		const m = f.margins;
+		if (m) {
+			if (m.top) styles.push(`margin-top:${(m.top / EMU_PER_PT).toFixed(1)}pt`);
+			if (m.bottom) styles.push(`margin-bottom:${(m.bottom / EMU_PER_PT).toFixed(1)}pt`);
+			if (m.left) styles.push(`margin-left:${(m.left / EMU_PER_PT).toFixed(1)}pt`);
+			if (m.right) styles.push(`margin-right:${(m.right / EMU_PER_PT).toFixed(1)}pt`);
+		}
+	}
+	return styles;
+}
+/**
+* Where a wrapNone floating drawing's absolute top/left should resolve from.
+*
+* verticalPosition.relative (OOXML vRelativeFrom) defaults to "paragraph"
+* (also "line"); "page"/"margin"/"column" scope to the page box. The drawing is
+* position:absolute, so its offsetParent decides the origin: a
+* paragraph-anchored drawing must sit inside a position:relative <p> (the editor
+* CSS adds that via p:has([data-float-anchor])), otherwise top/left measure
+* from the page top and the drawing floats over the heading/body instead of
+* its own blank paragraph (verified on sample anchored drawing groups). Only
+* relevant for wrapNone (type 0); the float-based wraps stay inline.
+*/
+function floatAnchorScope(floating) {
+	const vRel = floating?.verticalPosition?.relative;
+	if (vRel === "page" || vRel === "margin" || vRel === "column") return "page";
+	return "paragraph";
+}
+/**
+* Compute all paragraph-level CSS styles from nested attrs.
+* Shared by Paragraph and Heading extensions for node-level renderHTML.
+* Attrs store office-open native values; mappers here convert to CSS.
+*/
+function renderParagraphStyles(attrs, opts) {
+	const a = attrs;
+	const styles = [];
+	const align = alignmentToCss(a.alignment);
+	if (align) styles.push(`text-align:${align}`);
+	if (a.indent) {
+		const left = twipToCss(a.indent.left);
+		if (left) styles.push(`margin-left:${left}`);
+		const right = twipToCss(a.indent.right);
+		if (right) styles.push(`margin-right:${right}`);
+		if (a.indent.firstLine != null) {
+			const fl = twipToCss(a.indent.firstLine);
+			if (fl) styles.push(`text-indent:${fl}`);
+		} else if (a.indent.hanging != null) {
+			const h = twipToCss(a.indent.hanging);
+			if (h) styles.push(`text-indent:-${h}`);
+		} else if (a.indent.firstLineChars != null) styles.push(`text-indent:${a.indent.firstLineChars / 100}em`);
+	}
+	const markLineHeight = a.run?.size != null ? sizeToCss(a.run.size) : null;
+	if (markLineHeight) styles.push(`line-height:${markLineHeight}`);
+	if (a.spacing) {
+		const before = twipToCss(a.spacing.before);
+		if (before) styles.push(`margin-top:${before}`);
+		const after = twipToCss(a.spacing.after);
+		if (after) styles.push(`margin-bottom:${after}`);
+		const lh = lineSpacingToCss(a.spacing, opts?.empty ? false : a.snapToGrid);
+		if (lh) styles.push(`line-height:${lh}`);
+	}
+	const bg = shadingToCss(a.shading);
+	if (bg) styles.push(`background-color:${bg}`, `color:contrast-color(${bg})`);
+	if (a.border) {
+		const sides = [
+			["top", a.border.top],
+			["bottom", a.border.bottom],
+			["left", a.border.left],
+			["right", a.border.right]
+		];
+		for (const [side, b] of sides) {
+			const css = b ? renderBorderCSS(b) : null;
+			if (css) styles.push(`border-${side}:${css}`);
+		}
+	}
+	return styles;
+}
+/**
+* Compute run-level CSS (font/size/color/weight/…) from office-open run attrs.
+* Shared by text-style marks and the styles→CSS generator (stylesToCss).
+*/
+function renderRunStyles(attrs) {
+	const a = attrs;
+	const styles = [];
+	if (a.bold) styles.push("font-weight:bold");
+	if (a.italic) styles.push("font-style:italic");
+	if (a.smallCaps) styles.push("font-variant:small-caps");
+	if (a.allCaps) styles.push("text-transform:uppercase");
+	const deco = [];
+	if (a.underline) deco.push("underline");
+	if (a.strike || a.doubleStrike) deco.push("line-through");
+	if (deco.length) styles.push(`text-decoration:${deco.join(" ")}`);
+	const font = resolveFontFamilyCss(a.font);
+	if (font) styles.push(`font-family:${font}`);
+	const size = sizeToCss(a.size);
+	if (size) styles.push(`font-size:${size}`);
+	const color = a.color === "auto" ? void 0 : normalizeColorToHex(a.color);
+	if (color) styles.push(`color:${color}`);
+	const spacing = characterSpacingToCss(a.characterSpacing);
+	if (spacing) styles.push(`letter-spacing:${spacing}`);
+	if (a.highlight) {
+		const hl = normalizeColorToHex(typeof a.highlight === "string" ? a.highlight : null);
+		if (hl) styles.push(`background-color:${hl}`, `color:contrast-color(${hl})`);
+	}
+	return styles;
+}
+/**
+* Compute table cell CSS styles from nested attrs.
+* Shared by TableCell and TableHeader extensions.
+*/
+function renderTableCellStyles(attrs) {
+	const a = attrs;
+	const styles = [];
+	if (a.noWrap) styles.push("white-space:nowrap");
+	const bg = shadingToCss(a.shading);
+	if (bg) styles.push(`background-color:${bg}`, `color:contrast-color(${bg})`);
+	if (a.verticalAlign) styles.push(`vertical-align:${a.verticalAlign}`);
+	if (a.margins) {
+		const m = a.margins;
+		const side = (s) => s && typeof s.size === "number" ? twipToCss(s.size) ?? "0pt" : "0pt";
+		styles.push(`padding:${side(m.top)} ${side(m.right)} ${side(m.bottom)} ${side(m.left)}`);
+	}
+	if (a.borders) for (const side of [
+		"top",
+		"right",
+		"bottom",
+		"left"
+	]) {
+		const b = a.borders[side];
+		if (!b) continue;
+		styles.push(`border-${side}:${renderBorderCSS(b) ?? "none"}`);
+	}
+	return styles;
+}
+/** Parse text-align → OOXML alignment. */
+function alignmentFromElement(el) {
+	return alignmentFromCss(el.style.textAlign || null);
+}
+/** Parse margin-left/right + text-indent → OOXML indent (twips). */
+function indentFromElement(el) {
+	const indent = {};
+	const left = cssToTwip(el.style.marginLeft);
+	if (left) indent.left = left;
+	const right = cssToTwip(el.style.marginRight);
+	if (right) indent.right = right;
+	const ti = el.style.textIndent;
+	if (ti) if (ti.startsWith("-")) {
+		const h = cssToTwip(ti.slice(1));
+		if (h) indent.hanging = h;
+	} else {
+		const f = cssToTwip(ti);
+		if (f) indent.firstLine = f;
+	}
+	return Object.keys(indent).length > 0 ? indent : null;
+}
+/** Parse margin-top/bottom + line-height → OOXML spacing (twips). */
+function spacingFromElement(el) {
+	const spacing = {};
+	const before = cssToTwip(el.style.marginTop);
+	if (before) spacing.before = before;
+	const after = cssToTwip(el.style.marginBottom);
+	if (after) spacing.after = after;
+	const lh = el.style.lineHeight;
+	if (lh) {
+		const m = lh.match(/^([\d.]+)(pt|px)?$/);
+		if (m) {
+			const num = parseFloat(m[1]);
+			if (m[2]) {
+				spacing.line = Math.round(num * (m[2] === "px" ? 15 : 20));
+				spacing.lineRule = "exact";
+			} else {
+				spacing.line = Math.round(num * 240);
+				spacing.lineRule = "auto";
+			}
+		}
+	}
+	return Object.keys(spacing).length > 0 ? spacing : null;
+}
+/** Parse border-* → OOXML BordersOptions. */
+function bordersFromElement(el) {
+	const borders = {};
+	const sides = [
+		["top", el.style.borderTop],
+		["bottom", el.style.borderBottom],
+		["left", el.style.borderLeft],
+		["right", el.style.borderRight]
+	];
+	for (const [side, css] of sides) {
+		if (!css || css === "initial" || css === "none") continue;
+		const m = css.match(/^(none|solid|dashed|dotted|double)\s+([\d.]+pt)\s+(.+)$/);
+		if (!m) continue;
+		borders[side] = {
+			style: {
+				solid: "single",
+				dashed: "dashed",
+				dotted: "dotted",
+				double: "double"
+			}[m[1]] ?? "single",
+			size: Math.round(parseFloat(m[2]) * 8),
+			color: m[3]
+		};
+	}
+	return Object.keys(borders).length > 0 ? borders : null;
+}
+/** Parse background-color → OOXML shading. */
+function shadingFromElement(el) {
+	return shadingFromCss(el.style.backgroundColor || null);
+}
+//#endregion
+export { alignmentFromCss, alignmentFromElement, alignmentToCss, attrNative, bordersFromElement, characterSpacingFromCss, characterSpacingToCss, cssToTwip, floatAnchorScope, floatingToStyles, indentFromElement, lineSpacingToCss, normalizeColorToHex, renderBorderCSS, renderParagraphStyles, renderRunStyles, renderTableCellStyles, resolveFontFamilyCss, resolveFontName, resolvePageSize, sectionLinePitchCss, sectionMarginCss, shadingFromCss, shadingFromElement, shadingToCss, sizeFromCss, sizeToCss, spacingFromElement, twipToCss, twipsToMm };

package/dist/extensions/wpg-group.d.mts

@@ -0,0 +1,2 @@
+import { b as renderWpsInterior, v as WpgGroup, x as renderWpsText, y as WpsData } from "../core-DRaLI8nd.mjs";
+export { WpgGroup, WpsData, renderWpsInterior, renderWpsText };

package/dist/extensions/wpg-group.mjs

@@ -0,0 +1,2 @@
+import { d as WpgGroup, f as renderWpsInterior, p as renderWpsText } from "../core-B8ba_FNi.mjs";
+export { WpgGroup, renderWpsInterior, renderWpsText };

package/dist/extensions/wps-shape.d.mts

@@ -0,0 +1,2 @@
+import { _ as WpsShape } from "../core-DRaLI8nd.mjs";
+export { WpsShape };

package/dist/extensions/wps-shape.mjs

@@ -0,0 +1,2 @@
+import { u as WpsShape } from "../core-B8ba_FNi.mjs";
+export { WpsShape };