paint

type PaintErrorCode =
/** An `a:srgbClr/@val` that is not six hex digits. */
'COLOR_HEX' |
/** A `ST_Percentage` or `ST_Angle` attribute that does not parse. */
'COLOR_NUMBER' |
/** A scheme colour name outside `ST_SchemeColorVal`. */
'COLOR_SCHEME_NAME' |
/** A `schemeClr` was resolved with no `clrScheme` in the context. */
'COLOR_NO_SCHEME' |
/** `schemeClr val="phClr"` outside a style invocation that supplies one. */
'COLOR_NO_PHCLR' |
/** A theme whose slots refer to each other in a cycle. */
'COLOR_SCHEME_CYCLE' |
/** A `sysClr` with no `lastClr` and a name this build has no value for. */
'COLOR_SYS_UNKNOWN' |
/** A `prstClr` name outside `ST_PresetColorVal`. */
'COLOR_PRST_UNKNOWN' |
/** A transform name outside the twenty-eight DrawingML defines. */
'COLOR_TRANSFORM' |
/**
 * An `a:gradFill` with no stops to interpolate between.
 *
 * PowerPoint refuses the package for this - both an empty `a:gsLst` and a
 * single stop come back repaired - so a deck in the wild will not contain one,
 * and a caller that has synthesised one has made a mistake worth naming.
 */
'FILL_NO_STOPS' |
/** A `pattFill/@prst` outside the 54 names PowerPoint accepts. */
'FILL_PATTERN_UNKNOWN' |
/**
 * A `prstDash/@val` outside the eleven `ST_PresetLineDashVal` names.
 *
 * PowerPoint refuses the package for this, so a deck in the wild will not
 * contain one and a caller that has synthesised one has made a mistake.
 */
'LINE_DASH_UNKNOWN' |
/** An `a:ln/@cmpd` outside the five `ST_CompoundLine` values. Also refused. */
'LINE_COMPOUND_UNKNOWN' |
/** A `headEnd`/`tailEnd` `@type` outside the six. Also refused. */
'LINE_END_UNKNOWN' |
/** A line end `@w` or `@len` that is not `sm`, `med` or `lg`. Also refused. */
'LINE_END_SIZE' |
/** A device scale that is not a positive number of pixels to the point. A caller mistake. */
'LINE_DEVICE_SCALE' |
/**
 * A negative blur radius.
 *
 * `a:outerShdw/@blurRad` and `a:glow/@rad` are both positive coordinates and
 * PowerPoint refuses a package carrying a negative one, so this is a caller
 * mistake rather than a file it will ever have to cope with.
 */
'EFFECT_NEGATIVE_RADIUS' |
/** An image fill whose resolution is unknown, so a tile has no natural size. */
'FILL_BLIP_RESOLUTION' |
/** An `a:srcRect` that crops the whole image away. */
'FILL_BLIP_CROP' |
/** A blip with no pixels in it. */
'FILL_BLIP_SIZE' |
/** An `a:tile` scaled to zero. */
'FILL_BLIP_SCALE';

class PaintError extends Error {
  readonly code: PaintErrorCode;
  /** The offending token, when the failure is about one. */
  readonly token: string | null;
  constructor(code: PaintErrorCode, message: string, token?: string | null);
}

type Channel = number;

function toLinear(c: Channel): Channel;

function fromLinear(c: Channel): Channel;

function clamp01(c: number): number;

interface Hsl {
  h: number;
  s: number;
  l: number;
}

function rgbToHsl(r: Channel, g: Channel, b: Channel): Hsl;

function hslToRgb(hsl: Hsl): [Channel, Channel, Channel];

function wrapHue(h: number): number;

function luma709(r: Channel, g: Channel, b: Channel): Channel;

function toByte(c: Channel): number;

function parseHex(value: string): [Channel, Channel, Channel] | null;

function toHex(r: Channel, g: Channel, b: Channel): string;

type PercentTransformOp = 'tint' | 'shade' | 'alpha' | 'alphaOff' | 'alphaMod' | 'hueMod' | 'sat' | 'satOff' | 'satMod' | 'lum' | 'lumOff' | 'lumMod' | 'red' | 'redOff' | 'redMod' | 'green' | 'greenOff' | 'greenMod' | 'blue' | 'blueOff' | 'blueMod';

type AngleTransformOp = 'hue' | 'hueOff';

type FlagTransformOp = 'comp' | 'inv' | 'gray' | 'gamma' | 'invGamma';

type ColorTransformOp = PercentTransformOp | AngleTransformOp | FlagTransformOp;

type ColorTransform = {
  readonly op: PercentTransformOp;
  readonly val: number;
} | {
  readonly op: AngleTransformOp;
  readonly val: number;
} | {
  readonly op: FlagTransformOp;
};

const COLOR_TRANSFORM_OPS: readonly ColorTransformOp[];

function transformShape(op: string): 'percent' | 'angle' | 'flag' | null;

type SchemeSlot = 'dk1' | 'lt1' | 'dk2' | 'lt2' | 'accent1' | 'accent2' | 'accent3' | 'accent4' | 'accent5' | 'accent6' | 'hlink' | 'folHlink';

const SCHEME_SLOTS: readonly SchemeSlot[];

type MappedColorName = 'bg1' | 'tx1' | 'bg2' | 'tx2' | 'accent1' | 'accent2' | 'accent3' | 'accent4' | 'accent5' | 'accent6' | 'hlink' | 'folHlink';

const MAPPED_COLOR_NAMES: readonly MappedColorName[];

type SchemeColorName = SchemeSlot | MappedColorName | 'phClr';

type ClrScheme = Readonly<Record<SchemeSlot, Color>>;

type ClrMap = Readonly<Record<MappedColorName, SchemeSlot>>;

type Color =
/** `a:srgbClr` - six hex digits. */
{
  readonly space: 'srgb';
  readonly hex: string;
  readonly transforms: readonly ColorTransform[];
} |
/** `a:scrgbClr` - three percentages, hundred-thousandths. */
{
  readonly space: 'scrgb';
  readonly r: number;
  readonly g: number;
  readonly b: number;
  readonly transforms: readonly ColorTransform[];
} |
/** `a:hslClr` - hue in sixtieths of a degree, sat and lum in hundred-thousandths. */
{
  readonly space: 'hsl';
  readonly hue: number;
  readonly sat: number;
  readonly lum: number;
  readonly transforms: readonly ColorTransform[];
} |
/** `a:schemeClr` - a name resolved against a theme and a colour map. */
{
  readonly space: 'scheme';
  readonly name: SchemeColorName;
  readonly transforms: readonly ColorTransform[];
} |
/** `a:sysClr` - a machine colour, with the last value the writer saw. */
{
  readonly space: 'sys';
  readonly name: string;
  readonly lastClr: string | null;
  readonly transforms: readonly ColorTransform[];
} |
/** `a:prstClr` - one of the 140 names in `ST_PresetColorVal`. */
{
  readonly space: 'prst';
  readonly name: string;
  readonly transforms: readonly ColorTransform[];
};

interface Rgba {
  readonly r: number;
  readonly g: number;
  readonly b: number;
  readonly a: number;
}

function applyTransforms(base: Rgba, transforms: readonly ColorTransform[]): Rgba;

interface ColorContext {
  /** The theme's `a:clrScheme`. Required by any `a:schemeClr`. */
  readonly scheme?: ClrScheme;
  /**
   * The `p:clrMap` in force, from the master or overridden by a layout or slide.
   * Required by a `schemeClr` naming one of the twelve mapped names.
   */
  readonly map?: ClrMap;
  /**
   * The colour the enclosing `a:fillRef`/`a:lnRef`/`a:effectRef` was invoked
   * with, which is what `schemeClr val="phClr"` means. Supplied by the style
   * resolver in 2.9; there is nothing sensible to default it to.
   */
  readonly phClr?: Rgba;
  /**
   * Values for `a:sysClr` when the element has no `@lastClr`. Defaults to the
   * table in `sys-colors.ts`, which is one Windows machine's light theme - see
   * the long note there about why `@lastClr` wins here and does not in
   * PowerPoint.
   */
  readonly systemColors?: Readonly<Record<string, string>>;
}

function mapSchemeName(name: SchemeColorName, map: ClrMap | undefined): SchemeSlot | null;

function resolveColor(color: Color, ctx?: ColorContext): Rgba;

function toHexColor(color: Rgba): string;

function toCss(color: Rgba): string;

function parsePercentage(token: string): number;

function parseAngle(token: string): number;

function parseSrgbValue(token: string): string;

const PRESET_COLORS: Readonly<Record<string, string>>;

function isPresetColorName(name: string): boolean;

const SYSTEM_COLORS: Readonly<Record<string, string>>;

function isSystemColorName(name: string): boolean;

interface RelativeRect {
  readonly l: number;
  readonly t: number;
  readonly r: number;
  readonly b: number;
}

const WHOLE_RECT: RelativeRect;

type TileFlipMode = 'none' | 'x' | 'y' | 'xy';

interface GradientStop {
  /** `ST_PositiveFixedPercentage`, hundred-thousandths, as written. */
  readonly pos: number;
  readonly color: Color;
}

interface LinearShade {
  readonly kind: 'linear';
  /**
   * Sixtieths of a degree. Zero points along +x so stop 0 is on the left, and
   * the angle increases **clockwise on screen**, y pointing down: `5400000` runs
   * top to bottom. Measured on six angles against a square shape, each landing
   * within a tenth of a degree of the value written.
   */
  readonly ang: number;
  /**
   * `@scaled`. False means the written angle is the visual angle. True means it
   * is measured in a space where the shape is a unit square - see
   * `linearGradientVector`, which is where the aspect correction actually
   * happens and where the direction it bends is recorded.
   */
  readonly scaled: boolean;
}

interface PathShade {
  readonly kind: 'path';
  readonly path: 'shape' | 'circle' | 'rect';
  /**
   * `a:fillToRect`, or `null` when the element was absent - which is a different
   * focus from four zero insets, measured. ADR 0022.
   */
  readonly fillToRect: RelativeRect | null;
}

type GradientShade = LinearShade | PathShade;

interface GradientFill {
  readonly type: 'gradient';
  /** As written, in document order. `resolveGradientStops` is what sorts them. */
  readonly stops: readonly GradientStop[];
  /** `null` when the markup carried neither `a:lin` nor `a:path`. */
  readonly shade: GradientShade | null;
  /** `a:tileRect`, or `null` for the default. Insets, and they may be negative. */
  readonly tileRect: RelativeRect | null;
  /**
   * `@flip`. Recorded so it round-trips, and otherwise unused: measured to have
   * no effect on what PowerPoint paints. See `gradient.ts`.
   */
  readonly flip: TileFlipMode;
  /** `@rotWithShape`. Defaults to true, and PowerPoint writes it explicitly. */
  readonly rotWithShape: boolean;
}

interface PatternFill {
  readonly type: 'pattern';
  /** `ST_PresetPatternVal`. One of the 54 in `pattern-tiles.ts`. */
  readonly prst: string;
  /** The marks. `null` when the element omitted `a:fgClr`. */
  readonly fg: Color | null;
  /** The ground. `null` when the element omitted `a:bgClr`. */
  readonly bg: Color | null;
}

interface SolidFill {
  readonly type: 'solid';
  readonly color: Color;
}

interface NoFill {
  readonly type: 'none';
}

interface GroupFill {
  readonly type: 'group';
}

type TileAlign = 'tl' | 't' | 'tr' | 'l' | 'ctr' | 'r' | 'bl' | 'b' | 'br';

type BlipEffect = {
  readonly kind: 'grayscale';
} | {
  readonly kind: 'biLevel';
  readonly thresh: number;
} | {
  readonly kind: 'lum';
  readonly bright: number;
  readonly contrast: number;
} | {
  readonly kind: 'duotone';
  readonly from: Color;
  readonly to: Color;
} | {
  readonly kind: 'alphaModFix';
  readonly amt: number;
} | {
  readonly kind: 'clrChange';
  readonly from: Color;
  readonly to: Color;
  readonly useAlpha: boolean;
};

interface BlipStretch {
  readonly kind: 'stretch';
  /** `a:fillRect`: insets of the destination, and they may be negative. */
  readonly fillRect: RelativeRect;
}

interface BlipTile {
  readonly kind: 'tile';
  /** `@tx`/`@ty` in EMU, positive right and down, from the `@algn` anchor. */
  readonly tx: number;
  readonly ty: number;
  /** `@sx`/`@sy` in hundred-thousandths of the natural tile size. */
  readonly sx: number;
  readonly sy: number;
  /** `@flip`. Mirrors ALTERNATE tiles, so the visible period doubles. */
  readonly flip: TileFlipMode;
  readonly algn: TileAlign;
}

interface BlipFill {
  readonly type: 'blip';
  /**
   * `a:blip/@r:embed`, which the caller resolves against the part's own rels -
   * the same contract `buBlip` uses.
   *
   * `null` when the blip names no raster at all, which is what PowerPoint
   * writes for a picture that is only an SVG. ADR 0037.
   */
  readonly embed: string | null;
  /** `asvg:svgBlip/@r:embed`: the vector original, drawn from 10.7. */
  readonly svgEmbed: string | null;
  /** The part whose rels `embed` is scoped to; rIds are per-part, never global. */
  readonly part: string;
  /** `a:srcRect`: insets of the SOURCE, as fractions of the image. */
  readonly srcRect: RelativeRect;
  readonly mode: BlipStretch | BlipTile;
  readonly effects: readonly BlipEffect[];
  /** `@dpi`. Zero, which is what PowerPoint writes, means the image's own. */
  readonly dpi: number;
  readonly rotWithShape: boolean;
}

type Fill = NoFill | SolidFill | GradientFill | PatternFill | GroupFill | BlipFill;

const RAMP_BLEND_GAMMA = 2.2;

const TWO_STOP_RAMP: readonly (readonly [number, number])[];

function toRampSpace(channel: number): number;

function fromRampSpace(value: number): number;

function twoStopWeight(t: number): number;

function sortStops(stops: readonly GradientStop[]): readonly GradientStop[];

interface ResolvedStop {
  /** 0 to 1. */
  readonly pos: number;
  readonly color: Rgba;
}

interface TwoColorRamp {
  /** The colour at factor 0 - whatever sits at position 0. */
  readonly from: Rgba;
  /** The other colour. */
  readonly to: Rgba;
  /** One factor per sorted stop: 0 where the colour is `from`, 1 where it is `to`. */
  readonly factors: readonly number[];
}

function twoColorRamp(stops: readonly ResolvedStop[]): TwoColorRamp | null;

function resolveGradientStops(fill: GradientFill, ctx?: ColorContext): readonly ResolvedStop[];

function gradientColorAt(fill: GradientFill, t: number, ctx?: ColorContext): Rgba;

interface GradientVector {
  readonly x1: number;
  readonly y1: number;
  readonly x2: number;
  readonly y2: number;
}

function linearGradientVector(shade: LinearShade, w: number, h: number): GradientVector;

function insetRect(rect: RelativeRect): {
  l: number;
  t: number;
  r: number;
  b: number;
};

interface PathGeometry {
  /** The focus, in shape units from the shape's top-left corner. */
  readonly fx: number;
  readonly fy: number;
  /**
   * How the distance from the focus is measured.
   *
   * `radial` is a true circle - isotropic in shape units, so on a wide shape the
   * bands are circles and not ellipses. `box` is the Chebyshev distance, giving
   * concentric rectangles. `outline` follows the shape's own geometry, which for
   * a rectangle is `box` and for an ellipse is the ellipse.
   */
  readonly metric: 'radial' | 'box' | 'outline';
  /** For `radial`: the circle the last stop lands on, always the shape's own. */
  readonly cx: number;
  readonly cy: number;
  readonly radius: number;
  /** The shape, in the same units, which is what `box` normalises against. */
  readonly w: number;
  readonly h: number;
}

function pathGeometry(shade: PathShade, w: number, h: number): PathGeometry;

function pathPositionAt(geometry: PathGeometry, x: number, y: number): number;

interface SvgStop {
  readonly offset: number;
  readonly color: string;
  readonly opacity: number;
}

function svgStops(fill: GradientFill, ctx?: ColorContext): readonly SvgStop[];

interface Rect {
  readonly x: number;
  readonly y: number;
  readonly w: number;
  readonly h: number;
}

interface ImageSize {
  readonly widthPx: number;
  readonly heightPx: number;
  /** The image's own declared resolution, which is what sizes a tile. */
  readonly dpi: number;
}

interface StretchPlacement {
  readonly kind: 'stretch';
  /** Where the whole image goes, in the shape's own EMU, before cropping. */
  readonly image: Rect;
  /** The part of that destination the crop leaves visible. */
  readonly clip: Rect;
}

interface TilePlacement {
  readonly kind: 'tile';
  /** One tile, in the shape's own EMU. */
  readonly tileW: number;
  readonly tileH: number;
  /** The top-left corner of the tile the `@algn` anchor placed. */
  readonly originX: number;
  readonly originY: number;
  readonly flipX: boolean;
  readonly flipY: boolean;
  /** Where the whole image sits inside one tile, once the crop is undone. */
  readonly image: Rect;
}

type BlipPlacement = StretchPlacement | TilePlacement;

const BLIP_LUMA: {
  readonly r: 0.2126;
  readonly g: 0.7152;
  readonly b: 0.0722;
};

function contrastScale(contrast: number): number;

function brightOffset(bright: number, scale: number): number;

function blipPlacement(fill: BlipFill, box: Rect, image: ImageSize): BlipPlacement;

interface PatternTile {
  /** Width of the repeat, in pixels at 96 DPI. */
  readonly w: number;
  /** Height of the repeat, in pixels at 96 DPI. */
  readonly h: number;
  /**
   * Row-major coverage, two hex digits per pixel: `00` is the background
   * colour, `FF` the foreground, and anything between is antialiasing.
   */
  readonly cover: string;
}

const PATTERN_PIXEL_EMU = 9525;

const PATTERN_TILE_PIXELS = 8;

const PATTERN_TILES: Readonly<Record<string, PatternTile>>;

const PRESET_PATTERN_NAMES: readonly string[];

const ANTIALIASED_PATTERNS: readonly string[];

function isPresetPatternName(name: string): boolean;

interface ResolvedPattern {
  /** Width of the repeat, in EMU. */
  readonly width: number;
  /** Height of the repeat, in EMU. */
  readonly height: number;
  /** Coverage per pixel, row-major, 0 to 1. `length` is `cols * rows`. */
  readonly coverage: readonly number[];
  readonly cols: number;
  readonly rows: number;
  readonly fg: Rgba;
  readonly bg: Rgba;
}

function resolvePattern(fill: PatternFill, ctx?: ColorContext): ResolvedPattern;

function patternPixel(pattern: ResolvedPattern, col: number, row: number): Rgba;

function patternInk(name: string): number;

const COMPOUND_RUNS_60: Readonly<Record<string, readonly number[]>>;

const COMPOUND_RUNS: Readonly<Record<string, readonly number[]>>;

const COMPOUND_NAMES: readonly string[];

function isCompoundName(name: string): boolean;

interface DashSegment {
  readonly d: number;
  readonly sp: number;
}

const PRESET_DASHES: Readonly<Record<string, readonly DashSegment[]>>;

const PRESET_DASH_NAMES: readonly string[];

function isPresetDashName(name: string): boolean;

type MarkerAnchor = 'tip' | 'centre';

interface Marker {
  /** The family the silhouette was fitted to. */
  readonly outline: string;
  readonly anchor: MarkerAnchor;
  /** False for `arrow`, which is stroked rather than filled. */
  readonly filled: boolean;
  /** How far the back is cut forward, as a fraction of the length. Zero for most. */
  readonly notch: number;
  /**
   * The outline in a unit box: x from 0 at the back to 1 at the tip, y from
   * -0.5 to 0.5. Scale by (len x w, wid x w) to get the marker at a stroke
   * width of w.
   */
  readonly path: string;
}

const MARKER_SIZE: Readonly<Record<string, number>>;

const MARKER_SIZE_NAMES: readonly string[];

const MARKERS: Readonly<Record<string, Marker>>;

const MARKER_TYPE_NAMES: readonly string[];

function isMarkerTypeName(name: string): boolean;

function isMarkerSizeName(name: string): boolean;

const EMU_PER_POINT = 12700;

const DEFAULT_LINE_WIDTH = 9525;

const DEFAULT_LINE_CAP: LineCap;

const DEFAULT_LINE_JOIN: LineJoinKind;

const DEFAULT_MITER_LIMIT = 8;

type LineCap = 'flat' | 'sq' | 'rnd';

type LineJoinKind = 'round' | 'bevel' | 'miter';

type PenAlignment = 'ctr' | 'in';

type LineEndSize = 'sm' | 'med' | 'lg';

interface LineJoin {
  readonly kind: LineJoinKind;
  /** A multiple of the stroke width. `null` means the attribute was absent. */
  readonly limit: number | null;
}

interface LineEnd {
  readonly type: string;
  readonly w: LineEndSize;
  readonly len: LineEndSize;
}

type LineDash = {
  readonly kind: 'preset';
  readonly val: string;
} | {
  readonly kind: 'custom';
  readonly stops: readonly DashSegment[];
};

interface Line {
  readonly w: number | null;
  readonly cap: LineCap | null;
  readonly cmpd: string | null;
  readonly algn: PenAlignment | null;
  /** `null` is a genuine absence; an explicit `a:noFill` is `{ type: 'none' }`. */
  readonly fill: Fill | null;
  readonly dash: LineDash | null;
  readonly join: LineJoin | null;
  readonly headEnd: LineEnd | null;
  readonly tailEnd: LineEnd | null;
}

interface ResolvedLine {
  /** EMU. */
  readonly width: number;
  readonly cap: LineCap;
  readonly join: LineJoin & {
    readonly limit: number;
  };
  readonly algn: PenAlignment;
  readonly cmpd: string;
  readonly fill: Fill;
  readonly dash: readonly DashSegment[] | null;
  readonly headEnd: LineEnd | null;
  readonly tailEnd: LineEnd | null;
}

function resolveLine(line: Line): ResolvedLine;

function dashSegments(dash: LineDash): readonly DashSegment[];

function dashArray(segments: readonly DashSegment[], width: number, cap: LineCap): number[];

interface StrokeRail {
  /** Distance from the path to the rail's centre. Negative is outward. */
  readonly offset: number;
  /** EMU. */
  readonly width: number;
}

function compoundRails(cmpd: string, width: number, algn: PenAlignment): StrokeRail[];

interface MarkerGeometry {
  readonly type: string;
  /** EMU, along the line. */
  readonly length: number;
  /** EMU, across it. */
  readonly width: number;
  /** EMU from the marker's back edge to the line's endpoint. */
  readonly refX: number;
  readonly filled: boolean;
  /** The outline in a unit box; scale by `length` and `width`. */
  readonly path: string;
}

function markerGeometry(end: LineEnd | null, strokeWidth: number): MarkerGeometry | null;

function markerOvershoot(end: LineEnd | null, strokeWidth: number): number;

const MIN_PX_PER_PT = 0.05;

interface DevicePen {
  /** The pen, in EMU: the width in whole device pixels, a half up, never under one. */
  readonly width: number;
  /** Half a device pixel in EMU when the pen is odd, else zero: an odd pen sits on pixel centres. */
  readonly shift: number;
}

function devicePen(widthEmu: number, pxPerPt: number): DevicePen;

function deviceStrokeWidth(widthEmu: number, pxPerPt: number): number;

const MIN_MARKER_PEN: number;

function markerPen(widthEmu: number, pxPerPt: number | null): number;

interface SvgStroke {
  readonly 'stroke-width': number;
  readonly 'stroke-linecap': 'butt' | 'square' | 'round';
  readonly 'stroke-linejoin': 'round' | 'bevel' | 'miter';
  readonly 'stroke-miterlimit': number;
  readonly 'stroke-dasharray': readonly number[] | null;
}

function svgStroke(line: ResolvedLine, railWidth?: number): SvgStroke;

const BLUR_RADIUS_TO_SIGMA: number;

const EDGE_GROWTH_PER_RADIUS = 0.9;

const GLOW_RADIUS_SCALE = 0.5;

type RectAlignment = 'tl' | 't' | 'tr' | 'l' | 'ctr' | 'r' | 'bl' | 'b' | 'br';

const DEFAULT_SHADOW_ALIGN: RectAlignment;

interface ShadowGeometry {
  /** EMU. */
  readonly blurRad: number;
  /** EMU. */
  readonly dist: number;
  /** Sixtieths of a degree. Zero points along +x and the angle turns toward +y. */
  readonly dir: number;
  /** Thousandths of a percent, as written. 100000 is unity. */
  readonly sx: number;
  readonly sy: number;
  /** Sixtieths of a degree. */
  readonly kx: number;
  readonly ky: number;
  readonly algn: RectAlignment;
  readonly rotWithShape: boolean;
}

interface OuterShadow extends ShadowGeometry {
  readonly kind: 'outerShdw';
  readonly color: Color;
}

interface InnerShadow extends ShadowGeometry {
  readonly kind: 'innerShdw';
  readonly color: Color;
}

interface PresetShadow {
  readonly kind: 'prstShdw';
  readonly prst: string;
  readonly dist: number;
  readonly dir: number;
  readonly color: Color;
}

interface Glow {
  readonly kind: 'glow';
  /** EMU. */
  readonly rad: number;
  readonly color: Color;
}

interface SoftEdge {
  readonly kind: 'softEdge';
  /** EMU. */
  readonly rad: number;
}

interface Blur {
  readonly kind: 'blur';
  /** EMU. */
  readonly rad: number;
  readonly grow: boolean;
}

interface Reflection {
  readonly kind: 'reflection';
  readonly blurRad: number;
  readonly stA: number;
  readonly stPos: number;
  readonly endA: number;
  readonly endPos: number;
  readonly dist: number;
  readonly dir: number;
  readonly fadeDir: number;
  readonly sx: number;
  readonly sy: number;
  readonly kx: number;
  readonly ky: number;
  readonly algn: RectAlignment;
  readonly rotWithShape: boolean;
}

type Effect = OuterShadow | InnerShadow | PresetShadow | Glow | SoftEdge | Blur | Reflection;

function blurSigma(radius: number): number;

function glowGeometry(rad: number): {
  grow: number;
  sigma: number;
};

function softEdgeGeometry(rad: number): {
  shrink: number;
  sigma: number;
};

function shadowOffset(dist: number, dir: number): {
  dx: number;
  dy: number;
};

interface Box {
  readonly x: number;
  readonly y: number;
  readonly w: number;
  readonly h: number;
}

function anchorPoint(algn: RectAlignment, box: Box): {
  x: number;
  y: number;
};

type Matrix = readonly [number, number, number, number, number, number];

function shadowMatrix(shadow: ShadowGeometry, box: Box): Matrix;

type FilterPrimitive = {
  readonly op: 'gaussian';
  readonly in: string;
  readonly result: string;
  readonly stdDeviation: number;
} | {
  readonly op: 'offset';
  readonly in: string;
  readonly result: string;
  readonly dx: number;
  readonly dy: number;
} | {
  readonly op: 'flood';
  readonly result: string;
  readonly color: string;
  readonly opacity: number;
} | {
  readonly op: 'composite';
  readonly in: string;
  readonly in2: string;
  readonly result: string;
  readonly operator: 'in' | 'out' | 'over' | 'atop' | 'xor';
} | {
  readonly op: 'merge';
  readonly inputs: readonly string[];
  readonly result: string;
} | {
  readonly op: 'morphology';
  readonly in: string;
  readonly result: string;
  readonly operator: 'dilate' | 'erode';
  readonly radius: number;
} | {
  readonly op: 'matrix';
  readonly in: string;
  readonly result: string;
  readonly matrix: Matrix;
};

interface FilterGraph {
  /** How far the effects reach outside the shape's own box, in EMU on each side. */
  readonly margin: {
    left: number;
    top: number;
    right: number;
    bottom: number;
  };
  readonly primitives: readonly FilterPrimitive[];
  /** The `result` name holding the finished picture. */
  readonly result: string;
}

function effectMargin(effect: Effect, box: Box): {
  left: number;
  top: number;
  right: number;
  bottom: number;
};

function shadowBox(shadow: ShadowGeometry, box: Box): Box;

function effectFilter(effects: readonly Effect[], box: Box, colorOf: (color: Color) => {
  css: string;
  alpha: number;
}): FilterGraph;