text

type TextErrorCode =
/** A font size that is not a positive, finite number of hundredths of a point. */
'TEXT_SIZE' |
/** An `a:lnSpc` value outside what `ST_TextSpacing` can hold. */
'TEXT_LINE_SPACING' |
/** A line index or count that is not a non-negative integer. */
'TEXT_LINE_COUNT' |
/** A typeface name that cannot be written into a CSS font shorthand. */
'TEXT_FONT_FAMILY' |
/** A wrap width or hyphen advance that is not a usable length. */
'TEXT_BREAK_WIDTH' |
/** An `a:normAutofit` scale outside what `ST_TextFontScalePercentOrPercentString` can hold. */
'TEXT_AUTOFIT_SCALE' |
/** A body height or inset that is not a usable length. */
'TEXT_AUTOFIT_HEIGHT' |
/**
 * A typeface whose per-face line metrics were never measured.
 *
 * Two of the numbers the last line of a block needs belong to the typeface
 * and are not derivable from anything a browser reports - see `autofit.ts`.
 * A caller that reaches this either passes `APPROXIMATE_FACE_METRICS` on
 * purpose, with a diagnostic, or supplies its own; what it must not do is
 * get a plausible number from here without having asked for one.
 */
'TEXT_FACE_METRICS' |
/** An `@u` or `@strike` value that is not in its ST_ simple type. */
'TEXT_DECORATION' |
/** An `a:buAutoNum/@type` that is not one of the 41 schemes PowerPoint accepts. */
'TEXT_AUTONUMBER_SCHEME' |
/**
 * One of the two schemes T5 measured but could not read.
 *
 * `arabic1Minus` and `arabic2Minus` are shaped into glyph ids before they are
 * drawn, so the measurement holds indices into a font rather than characters.
 * Distinct from `TEXT_AUTONUMBER_SCHEME` because the scheme is real and the
 * gap is ours - "not a scheme" would send somebody to go and check the file.
 */
'TEXT_AUTONUMBER_UNMEASURED' |
/**
 * A bullet number outside `ST_TextBulletStartAtNum`, which is 1 to 32767.
 *
 * Not pedantry: `startAt="0"`, `"-1"`, `"32768"` and `"65536"` are each a
 * package PowerPoint **repairs** rather than reads, measured one probe to a
 * package. A reader that quietly renders one has accepted a file the format's
 * own author refuses.
 */
'TEXT_AUTONUMBER_VALUE' |
/** A bullet whose kind and content disagree - an `autonum` with no scheme, say. */
'TEXT_BULLET' |
/**
 * A date field whose `@lang` and `@type` were never measured.
 *
 * PowerPoint formats dates with Windows' own per-locale patterns, and
 * `Intl.DateTimeFormat` reproduces them on a quarter of the readings. So the
 * patterns are a measured table, and a cell outside it is a gap the caller
 * has to handle - by showing the cached text, which is what `renderField`
 * does - rather than a licence to invent a plausible date.
 */
'TEXT_FIELD_LOCALE' |
/** A field kind or slide number that cannot be rendered as asked. */
'TEXT_FIELD' |
/** A code point outside Unicode, handed to the script-run splitter. */
'TEXT_SCRIPT_RUN' |
/**
 * An `a:bodyPr` value the text frame cannot lay out.
 *
 * A `@numCol` outside `ST_TextColumnCount`, a `@vert` or `@anchor` that is not
 * one of the enumerated values, or a length that is not finite. Each is a
 * package PowerPoint repairs rather than reads.
 */
'TEXT_FRAME' |
/**
 * No `OffscreenCanvas`, or no 2d context on one.
 *
 * The measurer is built for a Web Worker, where `OffscreenCanvas` is the only
 * canvas there is. A caller that reaches this on the main thread has imported
 * the Worker-side measurer into the document side by mistake, which is worth
 * saying rather than silently falling back to a DOM canvas the plan
 * deliberately does not use.
 */
'TEXT_NO_CANVAS';

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

interface LineSpacing {
  readonly kind: 'percent' | 'points';
  /**
   * For `percent`, `a:spcPct/@val` in thousandths of a percent - the value
   * `ST_Percentage` parses to, so both the `150000` and the `150%` spellings
   * arrive here as 150000. For `points`, `a:spcPts/@val` in hundredths of a
   * point.
   */
  readonly value: number;
}

const NATURAL_LINE_FACTOR = 1.2;

function quantisePercent(value: number): number;

function naturalLineHeight(sz: number): number;

function lineAdvance(sz: number, lnSpc?: LineSpacing): number;

function lineTop(index: number, advance: number): number;

function blockHeight(lineCount: number, advance: number, lastLineHeight: number, spcFirstLastPara?: boolean): number;

interface RunFont {
  /** `a:latin/@typeface`, already resolved through any `+mj-lt`/`+mn-lt`. */
  readonly family: string;
  /** `a:rPr/@sz`, hundredths of a point. */
  readonly sz: number;
  readonly bold?: boolean | undefined;
  readonly italic?: boolean | undefined;
  /** `a:rPr/@spc`, hundredths of a point. May be negative. */
  readonly spc?: number | undefined;
  /** `a:rPr/@kern`: the minimum font size at which kerning happens. */
  readonly kern?: number | undefined;
}

function kerningEnabled(kern: number | undefined, sz: number): boolean;

function cssFamily(family: string): string;

function cssFont(font: RunFont): string;

function cssLetterSpacing(spc: number | undefined): string;

interface Advance {
  /** The pen advance across the run: what a line's width is made of. */
  readonly width: number;
}

interface TextMeasurer {
  /** The advance of `text` set in `font`, in points. */
  measure(text: string, font: RunFont): Advance;
}

interface MeasuringContext {
  font: string;
  letterSpacing: string;
  fontKerning: string;
  measureText(text: string): {
    readonly width: number;
    readonly fontBoundingBoxAscent: number;
    readonly fontBoundingBoxDescent: number;
    /** Negative where the ideographic baseline is below the alphabetic one. */
    readonly ideographicBaseline: number;
  };
}

function createMeasuringContext(): MeasuringContext;

function createCanvasMeasurer(): TextMeasurer;

interface FaceBox {
  readonly ascent: number;
  readonly descent: number;
  /**
   * The ideographic baseline below the alphabetic one, as a fraction of the em.
   *
   * Only vertical text reads it: an upright glyph's baseline sits `1 - this`
   * from the leading edge of its cell. ADR 0039.
   */
  readonly ideographic: number;
}

function baselineShare(box: FaceBox): number;

function baselineDrop(lineHeightPt: number, box: FaceBox): number;

const FACE_BOX_PX = 1000;

interface FaceBoxProbe {
  box(family: string): FaceBox;
}

function createFaceBoxProbe(context?: MeasuringContext): FaceBoxProbe;

interface RuleMetrics {
  /** Below the baseline is positive, so a strikethrough's offset is negative. */
  readonly offset: number;
  readonly thickness: number;
}

interface FaceRules {
  readonly underline: RuleMetrics;
  readonly strike: RuleMetrics;
}

const MEASURED_FACE_RULES: Readonly<Record<string, FaceRules>>;

type Underline = 'none' | 'words' | 'sng' | 'dbl' | 'heavy' | 'dotted' | 'dottedHeavy' | 'dash' | 'dashHeavy' | 'dashLong' | 'dashLongHeavy' | 'dotDash' | 'dotDashHeavy' | 'dotDotDash' | 'dotDotDashHeavy' | 'wavy' | 'wavyHeavy' | 'wavyDbl';

type Strike = 'noStrike' | 'sngStrike' | 'dblStrike';

type RulePattern = 'solid' | 'dotted' | 'dashed' | 'longDashed' | 'dotDash' | 'dotDotDash';

interface DrawnRule {
  /** The rule's top edge below the baseline; a strikethrough's is negative. */
  readonly top: number;
  readonly thickness: number;
  readonly pattern: RulePattern;
  /** Drawn as a wave rather than a straight rail. */
  readonly wavy: boolean;
}

const APPROXIMATE_FACE_RULES: FaceRules;

function faceRules(typeface: string): FaceRules;

function hasFaceRules(typeface: string): boolean;

function underlineRules(underline: Underline | undefined, sizePt: number, rules: FaceRules): readonly DrawnRule[];

function strikeRules(strike: Strike | undefined, sizePt: number, rules: FaceRules): readonly DrawnRule[];

function decoratedStretches(text: string, underline: Underline | undefined): readonly (readonly [number, number])[];

interface KinsokuSets {
  /** Characters that may not begin a line. */
  readonly noStart: ReadonlySet<string>;
  /** Characters that may not end a line. */
  readonly noEnd: ReadonlySet<string>;
}

const BUILT_IN_KINSOKU: KinsokuSets;

const HANGING_PUNCTUATION: ReadonlySet<string>;

function kinsokuInForce(stated: KinsokuSets | undefined, strictFirstAndLastChars: boolean | undefined): KinsokuSets;

interface BreakTailoring {
  /**
   * `@latinLnBrk`. **Absent behaves as `false`.**
   *
   * ECMA-376 gives the attribute a default of `true`. PowerPoint does not:
   * measured over 24 box widths on a 28-code-point string, a paragraph stating
   * nothing lays out identically to one stating `0` and differently from one
   * stating `1` at every width. Following the standard here breaks every long
   * word in every deck.
   */
  readonly latinLnBrk?: boolean | undefined;
  /**
   * `@eaLnBrk`.
   *
   * Measured **inert**: all three of absent, `1` and `0` lay out identically on
   * a nine-ideograph string at every box width. It is accepted and ignored
   * rather than absent from this interface, so that a caller passing it is not
   * quietly getting a different rule than they think, and so the next person to
   * wonder finds the answer here.
   */
  readonly eaLnBrk?: boolean | undefined;
  /**
   * `@hangingPunct`. **Absent behaves as `true`.**
   *
   * Only affects the six characters in `HANGING_PUNCTUATION`, and only the fit
   * test - it never adds or removes an opportunity. Measured inert on Latin
   * punctuation: a Latin comma hangs by way of the space after it, not by way
   * of this attribute.
   */
  readonly hangingPunct?: boolean | undefined;
}

interface BreakOptions {
  readonly tailoring?: BreakTailoring | undefined;
  /**
   * The kinsoku sets in force. Defaults to PowerPoint's built-in list, which is
   * what applies unless a package both states `p:kinsoku` and turns
   * `strictFirstAndLastChars` off - see `kinsokuInForce`.
   */
  readonly kinsoku?: KinsokuSets | undefined;
}

function isEastAsian(ch: string): boolean;

function toCodePoints(text: string): readonly string[];

function breakOpportunities(text: string, options?: BreakOptions): readonly number[];

type RangeMeasurer = (start: number, end: number) => number;

interface WrapInput {
  readonly text: string;
  /** The usable width, in points: the frame width less `lIns` and `rIns`. */
  readonly widthPt: number;
  readonly measure: RangeMeasurer;
  /**
   * The advance of a hyphen in the run's face, in points.
   *
   * Charged to a line that ends on a soft hyphen, because that line draws one.
   * Measured: at a box sized for exactly the code points up to and including a
   * soft hyphen, PowerPoint refused the break and fell back to the space before
   * it. The soft hyphen has no advance of its own, so the only thing that can
   * have overflowed is the hyphen it drew.
   */
  readonly hyphenWidthPt: number;
  readonly tailoring?: BreakTailoring | undefined;
  readonly kinsoku?: KinsokuSets | undefined;
}

interface LineBox {
  /** Index of the first code point on the line. */
  readonly start: number;
  /** One past the last code point on the line, including anything that hangs. */
  readonly end: number;
  /**
   * One past the last code point charged to the width.
   *
   * Equal to `end` unless something hangs. The difference is what a renderer
   * must let overflow the frame, and what an alignment calculation must ignore.
   */
  readonly measuredEnd: number;
  /** Whether the line draws a hyphen after its last code point. */
  readonly hyphen: boolean;
  /** The text on the line, hanging characters included. */
  readonly text: string;
}

function wrapText(input: WrapInput): readonly LineBox[];

interface AutofitScale {
  /** `a:normAutofit/@fontScale`. */
  readonly fontScale: number;
  /** `a:normAutofit/@lnSpcReduction`. */
  readonly lnSpcReduction: number;
}

const AUTOFIT_LADDER: readonly AutofitScale[];

interface FaceLineMetrics {
  /**
   * `b`: the per-size term in `lastLine = 0.75 x advance + b x size`.
   *
   * Spans 0.2053 on Tahoma to 0.3000 on Courier New. Fitted across seven sizes
   * and two line spacings a face, to a worst residual of 0.0043pt.
   */
  readonly lastLineCoefficient: number;
  /**
   * `C`: the multiple of the effective size up to which the last line takes the
   * whole advance instead of the fitted value.
   *
   * Indistinguishable from the 1.2 line box on five of the six faces measured,
   * and 1.2698 on Courier New - which is the only reason it is a field rather
   * than the constant 1.2.
   */
  readonly floorRatio: number;
}

const MEASURED_FACE_METRICS: Readonly<Record<string, FaceLineMetrics>>;

const APPROXIMATE_FACE_METRICS: FaceLineMetrics;

function faceLineMetrics(typeface: string): FaceLineMetrics;

function hasFaceLineMetrics(typeface: string): boolean;

function effectiveFontSize(sz: number, fontScale?: number): number;

function autofitAdvance(effectiveSizePt: number, lnSpcReduction?: number, lnSpc?: LineSpacing): number;

function lastLineHeight(advancePt: number, effectiveSizePt: number, metrics: FaceLineMetrics): number;

interface ParagraphBox {
  /** How many lines it wrapped into at this scale. At least one. */
  readonly lines: number;
  /** `a:rPr/@sz` in hundredths of a point, before any scale. */
  readonly sz: number;
  /** The metrics of the face that governs the paragraph's last line. */
  readonly metrics: FaceLineMetrics;
  readonly lnSpc?: LineSpacing | undefined;
  readonly spcBef?: LineSpacing | undefined;
  readonly spcAft?: LineSpacing | undefined;
}

function textBodyHeight(paragraphs: readonly ParagraphBox[], scale: AutofitScale, spcFirstLastPara?: boolean): number;

function storedScale(fontScale?: number, lnSpcReduction?: number): AutofitScale;

interface AutofitRequest {
  /**
   * The height the text has to fit in, in points: the shape height less `tIns`
   * and `bIns`.
   *
   * Measured 20/20 against 12/20 for testing against the shape height itself,
   * so the insets are the caller's to subtract and are named here rather than
   * passed as a rectangle, to make forgetting them harder.
   */
  readonly bodyHeightPt: number;
  /** `a:bodyPr/@spcFirstLastPara`, resolved. Absent behaves as false. */
  readonly spcFirstLastPara?: boolean | undefined;
  /**
   * Lay the text out at a candidate scale and report each paragraph.
   *
   * A callback rather than a fixed list because the line count is a consequence
   * of the scale: shrinking the font rewraps the text, and a fit test that used
   * one line count for every rung would be wrong on every paragraph that wraps.
   * Use `effectiveFontSize` to get the size to wrap at.
   */
  readonly layout: (scale: AutofitScale) => readonly ParagraphBox[];
}

interface AutofitResult {
  readonly scale: AutofitScale;
  /** The paragraphs as `layout` reported them at the chosen scale. */
  readonly paragraphs: readonly ParagraphBox[];
  /** The height those paragraphs occupy, in points. */
  readonly heightPt: number;
  /** True when even the last rung overflows, so the text is drawn overflowing. */
  readonly overflows: boolean;
}

function fitAutofit(request: AutofitRequest): AutofitResult;

const SHAPE_AUTOFIT_SLACK: number;

function requiredShapeHeight(paragraphs: readonly ParagraphBox[], insets: {
  readonly topPt: number;
  readonly bottomPt: number;
}, scale?: AutofitScale, spcFirstLastPara?: boolean): number;

const AUTONUMBER_SCHEMES: readonly ["alphaLcPeriod", "alphaUcPeriod", "arabicParenR", "arabicPeriod", "romanLcParenBoth", "romanLcParenR", "romanLcPeriod", "romanUcPeriod", "alphaLcParenBoth", "alphaLcParenR", "alphaUcParenBoth", "alphaUcParenR", "arabicParenBoth", "arabicPlain", "romanUcParenBoth", "romanUcParenR", "ea1ChsPlain", "ea1ChsPeriod", "circleNumDbPlain", "circleNumWdWhitePlain", "circleNumWdBlackPlain", "ea1ChtPlain", "ea1ChtPeriod", "arabic2Minus", "arabic1Minus", "hebrew2Minus", "ea1JpnKorPlain", "ea1JpnKorPeriod", "arabicDbPlain", "arabicDbPeriod", "thaiAlphaPeriod", "thaiAlphaParenR", "thaiAlphaParenBoth", "thaiNumPeriod", "thaiNumParenR", "thaiNumParenBoth", "hindiAlphaPeriod", "hindiNumPeriod", "ea1JpnChsDbPeriod", "hindiNumParenR", "hindiAlpha1Period"];

type AutonumberScheme = (typeof AUTONUMBER_SCHEMES)[number];

function isAutonumberScheme(value: string): value is AutonumberScheme;

const START_AT_MIN = 1;

const START_AT_MAX = 32767;

interface Alphabet {
  readonly letters: string;
  readonly wrap: number;
  readonly bias: number;
  readonly fillWithLast: boolean;
}

const ALPHABETS: Readonly<Record<string, Alphabet>>;

interface AutonumberRule {
  readonly numeral: string;
  readonly prefix: string;
  readonly suffix: string;
}

const UNMEASURED_SCHEMES: readonly string[];

function autonumberRule(scheme: string): AutonumberRule;

function formatAutonumber(scheme: string, n: number): string;

function autonumberTypeface(scheme: string): string | null;

type BulletKind = 'none' | 'char' | 'autonum' | 'blip';

type BulletSize = {
  readonly kind: 'percent';
  readonly value: number;
} | {
  readonly kind: 'points';
  readonly value: number;
} | {
  readonly kind: 'text';
};

type BulletColor<TColor> = {
  readonly kind: 'color';
  readonly value: TColor;
} | {
  readonly kind: 'text';
};

type BulletFont = {
  readonly kind: 'typeface';
  readonly value: string;
} | {
  readonly kind: 'text';
};

interface ResolvedBullet<TColor> {
  readonly kind: BulletKind;
  /** `a:buChar/@char`, as written. The private-use mapping happens at draw time. */
  readonly char?: string | undefined;
  /** `a:buAutoNum/@type`. */
  readonly scheme?: string | undefined;
  /** `a:buAutoNum/@startAt`. Absent is measured to behave exactly as `1`. */
  readonly startAt?: number | undefined;
  /** The relationship id of an `a:buBlip`'s image. */
  readonly blip?: string | undefined;
  readonly font?: BulletFont | undefined;
  readonly size?: BulletSize | undefined;
  readonly color?: BulletColor<TColor> | undefined;
}

interface NumberedParagraph {
  /** `a:pPr/@lvl`, 0 through 8. */
  readonly level: number;
  /** The resolved `a:buAutoNum/@type`, or `null` for any other bullet kind. */
  readonly scheme: string | null;
  /** The resolved `a:buAutoNum/@startAt`; absent behaves as 1. */
  readonly startAt: number;
}

function numberParagraphs(paragraphs: readonly NumberedParagraph[]): readonly (number | null)[];

const SYMBOL_TYPEFACES: readonly string[];

function isSymbolTypeface(typeface: string): boolean;

function symbolBulletChar(char: string, typeface: string | undefined): string;

interface BulletContext<TColor> {
  /** The **first** run's typeface. Measured: not the largest run's, not the paragraph's. */
  readonly typeface: string;
  /** The first run's `@sz`, hundredths of a point. */
  readonly sz: number;
  readonly color: TColor;
}

type DrawableBullet<TColor> = {
  readonly kind: 'none';
} | {
  readonly kind: 'text';
  /** The characters to draw, already mapped for a symbol face. */
  readonly text: string;
  readonly typeface: string;
  /** Hundredths of a point. */
  readonly sz: number;
  readonly color: TColor;
} | {
  readonly kind: 'picture';
  readonly blip: string;
  /** The height to scale the picture to, in hundredths of a point. */
  readonly sz: number;
};

function drawableBullet<TColor>(bullet: ResolvedBullet<TColor>, context: BulletContext<TColor>, number?: number): DrawableBullet<TColor>;

const BLIP_BULLET_HEIGHT = 0.7;

interface BulletLayout {
  /** The bullet's left edge, from the text frame's left inset. */
  readonly bulletLeftPt: number;
  /** The first line's text left edge. */
  readonly firstLineLeftPt: number;
  /** Every line after the first. */
  readonly wrappedLeftPt: number;
}

function bulletLayout(marLPt: number, indentPt: number, bulletAdvancePt: number): BulletLayout;

function blipBulletWidth(sz: number, aspect: number): number;

function isStartAtInRange(startAt: number): boolean;

const RESERVED_FIELD_TYPES: readonly ["slidenum", "datetime", "datetime1", "datetime2", "datetime3", "datetime4", "datetime5", "datetime6", "datetime7", "datetime8", "datetime9", "datetime10", "datetime11", "datetime12", "datetime13", "datetimeFigureOut", "uaqdatetime1", "uaqdatetime2"];

type ReservedFieldType = (typeof RESERVED_FIELD_TYPES)[number];

function isReservedFieldType(type: string): type is ReservedFieldType;

function renderDatePattern(pattern: string, at: Date, lang: string): string;

function datePatternFor(type: string, lang: string): string | null;

function formatDateTimeField(type: string, lang: string, at: Date): string;

interface FieldRequest {
  /** `a:fld/@type`. An unreserved value is the cache's cue, not an error. */
  readonly type: string;
  /** The `@lang` of the field's own `a:rPr`, which is what drives the format. */
  readonly lang: string;
  /** The `a:t` PowerPoint last wrote, which is the fallback and never the answer. */
  readonly cachedText: string;
  /** The slide's one-based position, for `slidenum`. */
  readonly slideNumber?: number | undefined;
  /** The instant to render a date at. Passed in so a test is not a clock. */
  readonly now: Date;
}

interface RenderedField {
  readonly text: string;
  /**
   * - `computed`: a reserved type with a measured pattern, recomputed as
   *   PowerPoint recomputes it.
   * - `cached`: the `a:t`, because the type is not reserved or its locale was
   *   never measured. Diagnosable, and the right thing to show.
   */
  readonly source: 'computed' | 'cached';
  /** Why the cache was used, for the diagnostics panel. Empty when it was not. */
  readonly reason: string;
}

function renderField(request: FieldRequest): RenderedField;

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

type ScriptSlot = 'latin' | 'ea' | 'cs' | 'sym';

interface RunTypefaces {
  readonly latin: string;
  readonly ea?: string | undefined;
  readonly cs?: string | undefined;
  readonly sym?: string | undefined;
}

function scriptSlotOf(code: number): ScriptSlot;

function typefaceFor(code: number, faces: RunTypefaces): string;

interface ScriptRun {
  /** Index of the first code unit, into the original string. */
  readonly start: number;
  /** Index one past the last code unit. */
  readonly end: number;
  readonly slot: ScriptSlot;
  readonly typeface: string;
  readonly text: string;
}

function splitScriptRuns(text: string, faces: RunTypefaces): readonly ScriptRun[];

type Anchor = 't' | 'ctr' | 'b' | 'just' | 'dist';

type VerticalText = 'horz' | 'vert' | 'vert270' | 'wordArtVert' | 'eaVert' | 'mongolianVert' | 'wordArtVertRtl';

type VertOverflow = 'overflow' | 'ellipsis' | 'clip';

type Edge = 'left' | 'top' | 'right' | 'bottom';

interface Insets {
  readonly left: number;
  readonly top: number;
  readonly right: number;
  readonly bottom: number;
}

const DEFAULT_INSETS: Insets;

interface Box {
  readonly leftPt: number;
  readonly topPt: number;
  readonly widthPt: number;
  readonly heightPt: number;
}

function contentBox(frame: {
  widthPt: number;
  heightPt: number;
}, insets: Insets): Box;

function turnedInsets(insets: Insets, quarterDeg: number): Insets;

interface FrameAxes {
  readonly stacking: 'x' | 'y';
  readonly anchorFrom: Edge;
  readonly alignFrom: Edge;
  /** GDI is asked for the `@`-prefixed vertical face. */
  readonly verticalFace: boolean;
  /** Each character occupies a line of its own. */
  readonly stackedGlyphs: boolean;
}

const VERTICAL_AXES: Readonly<Record<VerticalText, FrameAxes>>;

function frameAxes(vert?: VerticalText): FrameAxes;

function anchorFraction(anchor?: Anchor): number;

function offsetAlong(from: Edge, fraction: number, availablePt: number, blockPt: number): number;

function blockOrigin(input: {
  readonly content: Box;
  readonly axes: FrameAxes;
  readonly anchor?: Anchor | undefined;
  readonly anchorCtr?: boolean | undefined;
  readonly blockAcrossPt: number;
  readonly blockAlongPt: number;
}): {
  readonly leftPt: number;
  readonly topPt: number;
};

function emptyParagraphHeight(sz: number, lnSpcMultiple?: number): number;

const MAX_COLUMNS = 16;

function columnBox(input: {
  readonly content: Box;
  readonly index: number;
  readonly numCol?: number | undefined;
  readonly spcColPt?: number | undefined;
  readonly rtlCol?: boolean | undefined;
}): Box;

const ELLIPSIS = "…";

interface OverflowLine {
  readonly topPt: number;
  readonly heightPt: number;
}

interface DrawnLines {
  /** How many of the lines are drawn as they are. */
  readonly count: number;
  /** An ellipsis is drawn as the next line, in place of the one that did not fit. */
  readonly ellipsis: boolean;
}

function drawnLines(lines: readonly OverflowLine[], availableHeightPt: number, overflow?: VertOverflow): DrawnLines;

interface UprightPen {
  /** The glyph's alphabetic baseline, from the leading edge of its cell. */
  readonly alongPt: number;
  /** The glyph's own x origin, from the leading edge of the line box. */
  readonly acrossPt: number;
}

function uprightPen(cell: {
  readonly sizePt: number;
  readonly advancePt: number;
  readonly lineHeightPt: number;
  readonly ideographic: number;
}): UprightPen;

function wordArtCell(sizePt: number, face: {
  readonly ascent: number;
  readonly descent: number;
}): number;

function stackedPen(cell: {
  readonly sizePt: number;
  readonly advancePt: number;
  readonly cellPt: number;
  readonly columnPt: number;
  readonly descent: number;
}): UprightPen;

const ANCHORS: readonly string[];

const FINGERPRINT_TEXT = "Hamburgefonstiv";

const FINGERPRINT_PX = 100;

interface FontProbe {
  /** The advance of `text` set at `px` in `stack`, which is a CSS family list. */
  advance(stack: string, px: number, text: string): number;
}

function createFontProbe(): FontProbe;

function anchoredStack(family: string, anchor: string): string;

function isFontAvailable(family: string, probe: FontProbe): boolean;

function fontFingerprint(family: string, probe: FontProbe): number;

function metricsAgree(a: string, b: string, probe: FontProbe): boolean;

const POWERPOINT_LAST_RESORT = "Calibri";

const LAST_RESORT_FAMILIES: readonly string[];

const LAST_RESORT_GENERIC = "sans-serif";

interface Substitute {
  /** The typeface a deck names. */
  readonly missing: string;
  /** What to render with instead. */
  readonly use: string;
  /** Whether `use` was designed to the same advances as `missing`. */
  readonly metricCompatible: boolean;
  readonly note?: string;
}

const SUBSTITUTES: readonly Substitute[];

function substituteFor(family: string): Substitute | undefined;

function fontStack(family: string, drawn?: string): string;

function verifySubstitute(substitute: Substitute, probe: FontProbe, available: (family: string) => boolean): boolean | null;

type FontStatus = 'present' | 'substituted' | 'missing';

interface FontFinding {
  /** The typeface as the deck names it, after any `+mj-lt` was resolved. */
  readonly typeface: string;
  readonly status: FontStatus;
  /** The family the text will be laid out in. */
  readonly rendersAs: string;
  /** The whole CSS family list, which is what a renderer sets. */
  readonly stack: string;
  /** `null` when the claim could not be checked because a face is absent. */
  readonly metricCompatible: boolean | null;
  /** Whether `metricCompatible` was measured here rather than taken from the table. */
  readonly verified: boolean;
  /** How many runs asked for this typeface. */
  readonly runs: number;
}

function fontReport(requested: Iterable<string>, probe?: FontProbe): readonly FontFinding[];

function substitutedFonts(findings: readonly FontFinding[]): readonly FontFinding[];