@office-kit/xlsx 0.8.0

package/dist/drawing/dml/geometry.d.ts

@@ -0,0 +1,113 @@
+import type { Point2D } from './shape-properties';
+/**
+ * ECMA-376 §20.1.10.55 preset shape catalogue (`ST_PresetShapeType`, 187
+ * entries). Pulled from openpyxl's `PresetGeometry2D.prst` Set so the test
+ * corpus stays directly comparable.
+ */
+export declare const PRESET_SHAPE_NAMES: ReadonlyArray<string>;
+/** True iff `name` is one of the 187 ECMA-376 preset shapes. */
+export declare const isPresetShapeName: (name: string) => boolean;
+/** `<a:gd name="..." fmla="..."/>`. Shape guide / formula. */
+export interface ShapeGuide {
+    name: string;
+    fmla: string;
+}
+/**
+ * Adjust point. ECMA-376 calls these out as a Coordinate (a string that may be
+ * a literal EMU number or a guide-name reference like `wd2`). We keep them as
+ * strings so guide-references survive round-trip.
+ */
+export interface AdjPoint2D {
+    x: string;
+    y: string;
+}
+/** `<a:cxn ang="..."><a:pos x y/></a:cxn>`. */
+export interface ConnectionSite {
+    /** Angle: either a number (degrees × 60_000) or a guide reference. */
+    ang: string;
+    pos: AdjPoint2D;
+}
+/** `<a:ahXY>`-style adjust handle. The polar variant uses the same shape with `ang` in `pos`. */
+export interface AdjustHandle {
+    /** `xy` (cartesian) or `polar`. */
+    kind: 'xy' | 'polar';
+    pos: AdjPoint2D;
+    /** Range constraints (xy) or radius/angle constraints (polar). */
+    gdRefX?: string;
+    minX?: string;
+    maxX?: string;
+    gdRefY?: string;
+    minY?: string;
+    maxY?: string;
+    gdRefR?: string;
+    minR?: string;
+    maxR?: string;
+    gdRefAng?: string;
+    minAng?: string;
+    maxAng?: string;
+}
+/** `<a:rect l t r b/>`. Optional bounding rect for custom geometry. */
+export interface GuideRect {
+    l: string;
+    t: string;
+    r: string;
+    b: string;
+}
+/** Path-command discriminated union. ECMA-376 §20.1.9.* */
+export type PathCommand = {
+    kind: 'moveTo';
+    pt: Point2D;
+} | {
+    kind: 'lnTo';
+    pt: Point2D;
+} | {
+    kind: 'arcTo';
+    wR: string;
+    hR: string;
+    stAng: string;
+    swAng: string;
+} | {
+    kind: 'quadBezTo';
+    pts: [Point2D, Point2D];
+} | {
+    kind: 'cubicBezTo';
+    pts: [Point2D, Point2D, Point2D];
+} | {
+    kind: 'close';
+};
+export type PathFill = 'none' | 'norm' | 'lighten' | 'lightenLess' | 'darken' | 'darkenLess';
+/** A single `<a:path>` element inside `<a:pathLst>`. */
+export interface GeometryPath {
+    w?: number;
+    h?: number;
+    fill?: PathFill;
+    stroke?: boolean;
+    extrusionOk?: boolean;
+    commands: PathCommand[];
+}
+/** `<a:prstGeom prst="..."><a:avLst/></a:prstGeom>`. */
+export interface PresetGeometry {
+    kind: 'preset';
+    prst: string;
+    avLst?: ShapeGuide[];
+}
+/** `<a:custGeom>...</a:custGeom>`. */
+export interface CustomGeometry {
+    kind: 'custom';
+    avLst?: ShapeGuide[];
+    gdLst?: ShapeGuide[];
+    ahLst?: AdjustHandle[];
+    cxnLst?: ConnectionSite[];
+    rect?: GuideRect;
+    pathLst: GeometryPath[];
+}
+export type Geometry = PresetGeometry | CustomGeometry;
+export declare const makePresetGeometry: (prst: string, avLst?: ShapeGuide[]) => PresetGeometry;
+export declare const makeCustomGeometry: (opts: {
+    pathLst: GeometryPath[];
+    avLst?: ShapeGuide[];
+    gdLst?: ShapeGuide[];
+    ahLst?: AdjustHandle[];
+    cxnLst?: ConnectionSite[];
+    rect?: GuideRect;
+}) => CustomGeometry;

package/dist/drawing/dml/line.d.ts

@@ -0,0 +1,41 @@
+import type { Fill } from './fill';
+export type PresetDash = 'solid' | 'dot' | 'dash' | 'lgDash' | 'dashDot' | 'lgDashDot' | 'lgDashDotDot' | 'sysDash' | 'sysDot' | 'sysDashDot' | 'sysDashDotDot';
+type LineDash = {
+    kind: 'preset';
+    val: PresetDash;
+} | {
+    kind: 'custDash';
+    pattern: number[];
+};
+export type LineCap = 'rnd' | 'sq' | 'flat';
+export type LineCompound = 'sng' | 'dbl' | 'thickThin' | 'thinThick' | 'tri';
+type LineAlign = 'ctr' | 'in';
+type LineJoin = {
+    kind: 'round';
+} | {
+    kind: 'bevel';
+} | {
+    kind: 'miter';
+    lim?: number;
+};
+export type LineEndType = 'none' | 'triangle' | 'stealth' | 'diamond' | 'oval' | 'arrow';
+export type LineEndSize = 'sm' | 'med' | 'lg';
+export interface LineEnd {
+    type?: LineEndType;
+    w?: LineEndSize;
+    len?: LineEndSize;
+}
+export interface LineProperties {
+    /** Line width in EMU (1pt ≈ 12700 EMU). */
+    w?: number;
+    cap?: LineCap;
+    cmpd?: LineCompound;
+    algn?: LineAlign;
+    fill?: Fill;
+    dash?: LineDash;
+    join?: LineJoin;
+    headEnd?: LineEnd;
+    tailEnd?: LineEnd;
+}
+export declare const makeLine: (opts?: Partial<LineProperties>) => LineProperties;
+export {};

package/dist/drawing/dml/shape-properties.d.ts

@@ -0,0 +1,33 @@
+import type { Point2D, PositiveSize2D } from '../anchor';
+import type { EffectsRef } from './effect';
+import type { Fill } from './fill';
+import type { Geometry } from './geometry';
+import type { LineProperties } from './line';
+export type { Point2D, PositiveSize2D };
+export type BlackWhiteMode = 'clr' | 'auto' | 'gray' | 'ltGray' | 'invGray' | 'grayWhite' | 'blackGray' | 'blackWhite' | 'black' | 'white' | 'hidden';
+/** `<a:xfrm>`. Position / size / rotation transformation. */
+export interface Transform2D {
+    off?: Point2D;
+    ext?: PositiveSize2D;
+    /** Rotation in 60_000-ths of a degree (0..21_600_000). */
+    rot?: number;
+    flipH?: boolean;
+    flipV?: boolean;
+    chOff?: Point2D;
+    chExt?: PositiveSize2D;
+}
+/**
+ * `<a:spPr>` wrapper. 3-D / text-body slots will be added as their primitive
+ * modules land — kept absent here so the type stays closed under the modules
+ * currently shipped.
+ */
+export interface ShapeProperties {
+    bwMode?: BlackWhiteMode;
+    xfrm?: Transform2D;
+    geometry?: Geometry;
+    fill?: Fill;
+    ln?: LineProperties;
+    /** Either `<a:effectLst>` (kind: 'lst') or `<a:effectDag>` (kind: 'dag'). */
+    effects?: EffectsRef;
+}
+export declare const makeShapeProperties: (opts?: Partial<ShapeProperties>) => ShapeProperties;

package/dist/drawing/dml/text.d.ts

@@ -0,0 +1,218 @@
+import type { DmlColorWithMods } from './colors';
+import type { EffectsRef } from './effect';
+import type { Fill } from './fill';
+import type { LineProperties } from './line';
+export type FontAlign = 'auto' | 't' | 'ctr' | 'base' | 'b';
+export type ParagraphAlign = 'l' | 'ctr' | 'r' | 'just' | 'justLow' | 'dist' | 'thaiDist';
+export type TextUnderline = 'none' | 'words' | 'sng' | 'dbl' | 'heavy' | 'dotted' | 'dottedHeavy' | 'dash' | 'dashHeavy' | 'dashLong' | 'dashLongHeavy' | 'dotDash' | 'dotDashHeavy' | 'dotDotDash' | 'dotDotDashHeavy' | 'wavy' | 'wavyHeavy' | 'wavyDbl';
+export type TextStrike = 'noStrike' | 'sngStrike' | 'dblStrike';
+export type TextCap = 'none' | 'small' | 'all';
+export type TextOverflow = 'overflow' | 'ellipsis' | 'clip';
+export type TextHorzOverflow = 'overflow' | 'clip';
+export type TextVertical = 'horz' | 'vert' | 'vert270' | 'wordArtVert' | 'eaVert' | 'mongolianVert' | 'wordArtVertRtl';
+export type TextWrap = 'none' | 'square';
+export type TextAnchor = 't' | 'ctr' | 'b' | 'just' | 'dist';
+/** `<a:lnSpc>` / `<a:spcBef>` / `<a:spcAft>` — either percent (×1000) or points (×100). */
+export type TextSpacing = {
+    kind: 'pct';
+    val: number;
+} | {
+    kind: 'pts';
+    val: number;
+};
+/** `<a:tab>`. */
+export interface TabStop {
+    pos: number;
+    algn?: 'l' | 'ctr' | 'r' | 'dec';
+}
+/** `<a:latin>` / `<a:ea>` / `<a:cs>` / `<a:sym>`. */
+export interface TextFont {
+    typeface: string;
+    panose?: string;
+    pitchFamily?: number;
+    charset?: number;
+}
+/** `<a:hlinkClick>` / `<a:hlinkMouseOver>`. */
+export interface HyperlinkInfo {
+    rId?: string;
+    invalidUrl?: string;
+    action?: string;
+    tgtFrame?: string;
+    tooltip?: string;
+    history?: boolean;
+    highlightClick?: boolean;
+    endSnd?: boolean;
+}
+/** `<a:rPr>` / `<a:endParaRPr>` / `<a:defRPr>`. */
+export interface RunProperties {
+    kumimoji?: boolean;
+    lang?: string;
+    altLang?: string;
+    /** Font size in 1/100ths of a point. */
+    sz?: number;
+    b?: boolean;
+    i?: boolean;
+    u?: TextUnderline;
+    strike?: TextStrike;
+    kern?: number;
+    cap?: TextCap;
+    spc?: number;
+    normalizeH?: boolean;
+    /** Baseline shift × 1000 (super/subscript). */
+    baseline?: number;
+    noProof?: boolean;
+    dirty?: boolean;
+    err?: boolean;
+    smtClean?: boolean;
+    smtId?: number;
+    bmk?: string;
+    /** Right-to-left flag. */
+    rtl?: boolean;
+    ln?: LineProperties;
+    fill?: Fill;
+    effects?: EffectsRef;
+    highlight?: DmlColorWithMods;
+    /** Underline-line: either `'follow'` (`<a:uLnTx/>`) or an explicit LineProperties (`<a:uLn>`). */
+    uLn?: 'follow' | LineProperties;
+    /** Underline-fill: either `'follow'` (`<a:uFillTx/>`) or an explicit Fill (`<a:uFill>`). */
+    uFill?: 'follow' | Fill;
+    latin?: TextFont;
+    ea?: TextFont;
+    cs?: TextFont;
+    sym?: TextFont;
+    hlinkClick?: HyperlinkInfo;
+    hlinkMouseOver?: HyperlinkInfo;
+}
+/** `<a:buChar>` / `<a:buAutoNum>` / `<a:buBlip>` / `<a:buNone>`. */
+export type BulletProperties = {
+    kind: 'none';
+} | {
+    kind: 'char';
+    char: string;
+} | {
+    kind: 'autoNum';
+    type: string;
+    startAt?: number;
+} | {
+    kind: 'blip';
+    embedRId?: string;
+    linkRId?: string;
+};
+/** `<a:pPr>`. */
+export interface ParagraphProperties {
+    marL?: number;
+    marR?: number;
+    /** Indent level (0..8). */
+    lvl?: number;
+    indent?: number;
+    algn?: ParagraphAlign;
+    defTabSz?: number;
+    rtl?: boolean;
+    eaLnBrk?: boolean;
+    fontAlgn?: FontAlign;
+    latinLnBrk?: boolean;
+    hangingPunct?: boolean;
+    lnSpc?: TextSpacing;
+    spcBef?: TextSpacing;
+    spcAft?: TextSpacing;
+    tabLst?: TabStop[];
+    defRPr?: RunProperties;
+    bullet?: BulletProperties;
+    /** Bullet font (`<a:buFont>` / `<a:buFontTx/>`). */
+    buFont?: 'follow' | TextFont;
+    /** Bullet color (`<a:buClr>` / `<a:buClrTx/>`). */
+    buClr?: 'follow' | DmlColorWithMods;
+    /** Bullet size: percent of run size, points, or "follow run". */
+    buSz?: 'follow' | {
+        kind: 'pct';
+        val: number;
+    } | {
+        kind: 'pts';
+        val: number;
+    };
+}
+/** `<a:r>` (regular run), `<a:br>` (line break), `<a:fld>` (field). */
+export type TextRun = {
+    kind: 'r';
+    rPr?: RunProperties;
+    t: string;
+} | {
+    kind: 'br';
+    rPr?: RunProperties;
+} | {
+    kind: 'fld';
+    id: string;
+    type?: string;
+    rPr?: RunProperties;
+    pPr?: ParagraphProperties;
+    t?: string;
+};
+/** `<a:p>`. */
+export interface TextParagraph {
+    pPr?: ParagraphProperties;
+    runs: TextRun[];
+    endParaRPr?: RunProperties;
+}
+/** `<a:bodyPr>` autofit choice. */
+export type AutoFit = {
+    kind: 'noAutofit';
+} | {
+    kind: 'normAutofit';
+    fontScale?: number;
+    lnSpcReduction?: number;
+} | {
+    kind: 'spAutoFit';
+};
+/** `<a:bodyPr>`. */
+export interface TextBodyProperties {
+    rot?: number;
+    spcFirstLastPara?: boolean;
+    vertOverflow?: TextOverflow;
+    horzOverflow?: TextHorzOverflow;
+    vert?: TextVertical;
+    wrap?: TextWrap;
+    lIns?: number;
+    tIns?: number;
+    rIns?: number;
+    bIns?: number;
+    numCol?: number;
+    spcCol?: number;
+    rtlCol?: boolean;
+    fromWordArt?: boolean;
+    anchor?: TextAnchor;
+    anchorCtr?: boolean;
+    forceAA?: boolean;
+    upright?: boolean;
+    compatLnSpc?: boolean;
+    autoFit?: AutoFit;
+    flatTxZ?: number;
+}
+/**
+ * `<a:lstStyle>` (list / level styles). ECMA-376 §21.1.2.4.12. One
+ * ParagraphProperties per indent level (0..8). `defPPr` is the default applied
+ * when no level-specific override exists.
+ */
+export interface TextListStyle {
+    defPPr?: ParagraphProperties;
+    lvl1pPr?: ParagraphProperties;
+    lvl2pPr?: ParagraphProperties;
+    lvl3pPr?: ParagraphProperties;
+    lvl4pPr?: ParagraphProperties;
+    lvl5pPr?: ParagraphProperties;
+    lvl6pPr?: ParagraphProperties;
+    lvl7pPr?: ParagraphProperties;
+    lvl8pPr?: ParagraphProperties;
+    lvl9pPr?: ParagraphProperties;
+}
+export interface TextBody {
+    bodyPr: TextBodyProperties;
+    lstStyle?: TextListStyle;
+    paragraphs: TextParagraph[];
+}
+export declare const makeRunProperties: (opts?: Partial<RunProperties>) => RunProperties;
+export declare const makeRun: (text: string, rPr?: RunProperties) => TextRun;
+export declare const makeBreak: (rPr?: RunProperties) => TextRun;
+export declare const makeParagraph: (runs: TextRun[], pPr?: ParagraphProperties, endParaRPr?: RunProperties) => TextParagraph;
+export declare const makeTextBody: (paragraphs: TextParagraph[], bodyPr?: TextBodyProperties, lstStyle?: TextListStyle) => TextBody;
+/** Convenience: build a single-paragraph body with one run. */
+export declare const makeSimpleTextBody: (text: string, rPr?: RunProperties) => TextBody;

package/dist/drawing/drawing-xml.d.ts

@@ -0,0 +1,5 @@
+import { type Drawing } from './drawing';
+/** Parse a `xl/drawings/drawingN.xml` payload into a Drawing object. */
+export declare function parseDrawingXml(bytes: Uint8Array | string): Drawing;
+/** Serialise a Drawing to its `xl/drawings/drawingN.xml` payload. */
+export declare function drawingToBytes(drawing: Drawing): Uint8Array;

package/dist/drawing/drawing.d.ts

@@ -0,0 +1,117 @@
+import type { ChartSpace } from '../chart/chart';
+import type { CxChartSpace } from '../chart/cx/chartex';
+import type { DrawingAnchor } from './anchor';
+import type { ShapeProperties } from './dml/shape-properties';
+import type { XlsxImage } from './image';
+/** Reference to a chart part — the chart's drawing-rels rId resolves to xl/charts/chartN.xml. */
+export interface ChartReference {
+    /** Drawing-rels rId pointing at the chart part. Populated on read; the writer assigns its own. */
+    rId?: string;
+    /**
+     * Legacy ECMA-376 chart payload (`c:chartSpace`). Stage-1 supports BarChart
+     * end-to-end; other chart kinds populate this field as their parsers /
+     * writers land.
+     */
+    space?: ChartSpace;
+    /**
+     * Excel-2016 chartex payload (`cx:chartSpace`). Mutually exclusive with
+     * {@link space} for any given drawing item; the parser sniffs the root
+     * element and populates whichever is appropriate.
+     */
+    cxSpace?: CxChartSpace;
+    /**
+     * `true` when the resolved chart part is a chartex (`cx:`) chart. Set by the
+     * package writer so the drawing emitter knows to use the chartex
+     * `<a:graphicData uri>` instead of the legacy chart URI — Excel rejects the
+     * workbook when the URI doesn't match the chart's actual root namespace.
+     */
+    isCx?: boolean;
+}
+/** Reference to an embedded picture inside a worksheet drawing. */
+export interface PictureReference {
+    /** Drawing-rels rId pointing at the embedded image. Populated on read; the writer assigns its own. */
+    rId?: string;
+    /** Resolved image bytes + metadata. Populated on read; the writer reads it back. */
+    image?: XlsxImage;
+    /** Picture display name (`<xdr:cNvPr name="...">`). */
+    name?: string;
+    /** Optional alt-text description. */
+    descr?: string;
+    /** Hidden flag (`<xdr:cNvPr hidden="1"/>`). */
+    hidden?: boolean;
+    /** Per-picture shape properties (extra fill / line / rotation). */
+    spPr?: ShapeProperties;
+}
+export interface DrawingItem {
+    anchor: DrawingAnchor;
+    content: {
+        kind: 'chart';
+        chart: ChartReference;
+    } | {
+        kind: 'picture';
+        picture: PictureReference;
+    } | {
+        kind: 'unsupported';
+        rawTag: string;
+    };
+}
+export interface Drawing {
+    items: DrawingItem[];
+}
+export declare function makeDrawing(items?: DrawingItem[]): Drawing;
+export declare function makeChartDrawingItem(anchor: DrawingAnchor, chart?: ChartReference): DrawingItem;
+export declare function makePictureDrawingItem(anchor: DrawingAnchor, picture: PictureReference | XlsxImage): DrawingItem;
+import type { Worksheet } from '../worksheet/worksheet';
+/**
+ * Drop an image onto a worksheet at a single-cell anchor. Lazy-allocates
+ * `ws.drawing` (as `makeDrawing([])`) on first call and appends a picture
+ * DrawingItem.
+ *
+ * `image` accepts either an `XlsxImage` (already loaded via `loadImage`) or raw
+ * image bytes — in the bytes case, this helper sniffs the format with
+ * `loadImage` itself.
+ *
+ * `at` is a cell ref like `"C3"`. Override `widthPx` / `heightPx` to scale;
+ * otherwise the helper uses 96×96 defaults that look fine for typical icons.
+ */
+export declare const addImageAt: (ws: Worksheet, at: string, image: XlsxImage | Uint8Array, opts?: {
+    widthPx?: number;
+    heightPx?: number;
+}) => DrawingItem;
+/**
+ * Anchor a chart to a worksheet at a single-cell ref. Lazy-allocates
+ * `ws.drawing`. `chart` is the same `ChartReference` shape `makeChart
+ * DrawingItem` accepts (`{ space }` for legacy chart, `{ cxSpace }` for
+ * chartex).
+ */
+export declare const addChartAt: (ws: Worksheet, at: string, chart: ChartReference, opts?: {
+    widthPx?: number;
+    heightPx?: number;
+}) => DrawingItem;
+/**
+ * Read-only snapshot of every picture DrawingItem on the sheet. Returns the
+ * matching items (each with its anchor + picture reference). Empty array when
+ * the sheet has no drawing or only non-picture items.
+ */
+export declare const listImagesOnSheet: (ws: Worksheet) => ReadonlyArray<DrawingItem>;
+/**
+ * Read-only snapshot of every chart DrawingItem on the sheet. Each item has its
+ * anchor + chart reference.
+ */
+export declare const listChartsOnSheet: (ws: Worksheet) => ReadonlyArray<DrawingItem>;
+/**
+ * Drop every DrawingItem from the worksheet. Returns the count removed. The
+ * `ws.drawing` field itself is left in place (empty) so subsequent `addImageAt`
+ * / `addChartAt` calls don't have to re-allocate.
+ */
+export declare const removeAllDrawingItems: (ws: Worksheet) => number;
+/**
+ * Drop every picture DrawingItem from the worksheet, leaving charts and any
+ * other content kinds untouched. Returns the count removed.
+ */
+export declare const removeAllImages: (ws: Worksheet) => number;
+/**
+ * Drop every chart DrawingItem from the worksheet, leaving pictures and any
+ * other content kinds untouched. Returns the count removed.
+ */
+export declare const removeAllCharts: (ws: Worksheet) => number;

package/dist/drawing/image.d.ts

@@ -0,0 +1,40 @@
+export type XlsxImageFormat = 'png' | 'jpeg' | 'gif' | 'bmp' | 'webp' | 'tiff' | 'svg' | 'emf' | 'wmf';
+/**
+ * Map from image format to the Content-Types Default extension that Excel uses
+ * in `[Content_Types].xml`. SVG / EMF / WMF use the same extension as the
+ * format string; PNG/JPEG/GIF/BMP do too. WebP and TIFF use their canonical
+ * short names.
+ */
+export declare const IMAGE_FORMAT_EXTENSION: Readonly<Record<XlsxImageFormat, string>>;
+/** Map from image format to its IANA `image/*` MIME type. */
+export declare const IMAGE_FORMAT_MIME: Readonly<Record<XlsxImageFormat, string>>;
+export interface XlsxImage {
+    bytes: Uint8Array;
+    format: XlsxImageFormat;
+    /** Pixel width. Zero when dimensions can't be determined for the format. */
+    width: number;
+    /** Pixel height. Zero when dimensions can't be determined for the format. */
+    height: number;
+    /** ZIP archive path, e.g. `xl/media/image3.png`. Set by the writer. */
+    path?: string;
+    /** rels-resolved id used by `<a:blip r:embed="...">`. Set by the loader. */
+    rId?: string;
+}
+export declare function detectImageFormat(bytes: Uint8Array): XlsxImageFormat | undefined;
+interface Dimensions {
+    width: number;
+    height: number;
+}
+export declare function detectImageDimensions(bytes: Uint8Array, format: XlsxImageFormat): Dimensions;
+/**
+ * Build an `XlsxImage` from raw bytes. Detects the format and dimensions
+ * automatically. Caller may pass an explicit `format` to override detection
+ * (e.g. when bytes were read from a `data:` URL with a known MIME type) or
+ * `width`/`height` to skip the parser.
+ */
+export declare function loadImage(bytes: Uint8Array, opts?: {
+    format?: XlsxImageFormat;
+    width?: number;
+    height?: number;
+}): XlsxImage;
+export {};

package/dist/drawing/index.d.ts

@@ -0,0 +1,14 @@
+export type { ChartReference, Drawing, DrawingItem, PictureReference, } from './drawing';
+export { addChartAt, addImageAt, listChartsOnSheet, listImagesOnSheet, makeChartDrawingItem, makeDrawing, makePictureDrawingItem, removeAllCharts, removeAllDrawingItems, removeAllImages, } from './drawing';
+export type { XlsxImage, XlsxImageFormat } from './image';
+export { loadImage } from './image';
+export type { AnchorMarker, DrawingAnchor, Point2D, PositiveSize2D, } from './anchor';
+export { makeOneCellAnchor } from './anchor';
+export type { BlackWhiteMode, ShapeProperties, Transform2D } from './dml/shape-properties';
+export { makeShapeProperties } from './dml/shape-properties';
+export type { ColorMod, DmlColor, DmlColorWithMods, SchemeColorName } from './dml/colors';
+export { makeColor, makeSchemeColor, makeSrgbColor, SCHEME_COLOR_NAMES, VALUED_COLOR_MOD_KINDS, VALUELESS_COLOR_MOD_KINDS, } from './dml/colors';
+export type { Blip, BlipEffect, Fill, GradientLineDir, GradientStop, RelativeRect, TileFill, TileFlip, } from './dml/fill';
+export { makeGradientFill, makeNoFill, makePatternFill, makeSolidFill, PRESET_PATTERN_NAMES, } from './dml/fill';
+export type { AutoFit, BulletProperties, FontAlign, HyperlinkInfo, ParagraphAlign, ParagraphProperties, RunProperties, TabStop, TextAnchor, TextBody, TextBodyProperties, TextCap, TextFont, TextHorzOverflow, TextListStyle, TextOverflow, TextParagraph, TextRun, TextSpacing, TextStrike, TextUnderline, TextVertical, TextWrap, } from './dml/text';
+export { makeBreak, makeParagraph, makeRun, makeRunProperties, makeSimpleTextBody, makeTextBody, } from './dml/text';