@draftably/markdown 0.1.0 → 0.2.0

package/dist/types/src/import/import-core.d.ts

@@ -0,0 +1,105 @@
+/** Build native source from the facts retained by an importer. */
+import type { EndMarker } from '../model/markers';
+export type Format = 'dot' | 'mermaid' | 'd2';
+export type Impact = 'syntax' | 'semantics' | 'appearance' | 'layout' | 'security' | 'limit';
+export interface Diagnostic {
+    code: string;
+    severity: 'error' | 'warning' | 'info';
+    impact: Impact;
+    message: string;
+    line?: number;
+    column?: number;
+    foreignIds?: string[];
+}
+export interface NativeObject {
+    id: string;
+    kind: 'node' | 'group';
+    label: string;
+    parent?: string;
+    shape?: 'box' | 'pill' | 'circle' | 'diamond' | 'text';
+    color?: string;
+    shade?: number;
+}
+export interface NativeEdge {
+    id: string;
+    from: string;
+    to: string;
+    label: string;
+    directed: boolean;
+    head?: EndMarker;
+    tail?: EndMarker;
+    dashed?: boolean;
+    constraint?: false;
+    fromSide?: 'left' | 'right' | 'top' | 'bottom';
+    toSide?: 'left' | 'right' | 'top' | 'bottom';
+}
+export interface NativeLayout {
+    scope: string;
+    kind: 'flow' | 'column' | 'row' | 'sequence';
+    direction?: 'right' | 'down';
+}
+export interface NativeColor {
+    name: string;
+    fill: string;
+    stroke: string;
+    ink: string;
+}
+export interface NativePhase {
+    id: string;
+    label: string;
+    members: string[];
+}
+export interface NativeNote {
+    text: string;
+    near?: string;
+    side?: 'left' | 'right' | 'above' | 'below';
+}
+export interface NativePlan {
+    title: string;
+    objects: NativeObject[];
+    edges: NativeEdge[];
+    layouts: NativeLayout[];
+    colors: NativeColor[];
+    /** Sequence diagrams only. */
+    phases?: NativePhase[];
+    notes?: NativeNote[];
+}
+export interface IdMapping {
+    kind: string;
+    foreign: string;
+    native: string;
+}
+export interface ImportResult {
+    status: 'ready' | 'needs-review' | 'failed';
+    format: Format;
+    family: string;
+    diagnostics: Diagnostic[];
+    /** Absent on every fatal error; callers must not apply a partial graph. */
+    nativeSource?: string;
+    facts?: NativePlan;
+    ids: IdMapping[];
+    requires: string[];
+}
+export declare const LIMITS: Readonly<{
+    sourceBytes: number;
+    objects: 500;
+    edges: 1200;
+    depth: 12;
+    labelChars: number;
+    totalLabelBytes: number;
+    outputBytes: number;
+    nativeSourceChars: 300000;
+}>;
+export declare class Ids {
+    readonly entries: IdMapping[];
+    private readonly byForeign;
+    private readonly taken;
+    get(kind: string, foreign: string, preferred?: string): string;
+}
+export declare const quote: (value: string) => string;
+export declare const blankPlan: (title: string) => NativePlan;
+export declare function inputLimit(source: string): Diagnostic[];
+export declare function finish(format: Format, family: string, plan: NativePlan, diagnostics: Diagnostic[], ids: Ids): ImportResult;
+/** Only an explicit hex color is accepted. No CSS, URL, or Graphviz colorscheme interpretation. */
+export declare function hex(value: string | undefined): string | undefined;
+export declare function applyColor(plan: NativePlan, o: NativeObject, fill?: string, stroke?: string, ink?: string): void;

package/dist/types/src/import/mermaid-facade.d.ts

@@ -0,0 +1,120 @@
+/**
+ * Tested against mermaid 12.2.0. Uses its internal DB behind a narrow, checked boundary.
+ * This file parses only; it neither renders Mermaid nor attaches interaction callbacks.
+ * Call in an isolated Node worker with a DOM, or in a dedicated browser Mermaid instance.
+ */
+export declare const MERMAID_VERSION: "12.2.0";
+export type ParserDiagnostic = {
+    code: string;
+    severity: 'warning' | 'error';
+    message: string;
+    line?: number;
+    column?: number;
+    locationKind?: 'source' | 'parser-relative';
+};
+export type FlowVertex = {
+    id: string;
+    text: string;
+    type?: string;
+    labelType: string;
+    classes: string[];
+    styles: string[];
+    link?: string;
+    icon?: string;
+    img?: string;
+    props?: Record<string, unknown>;
+};
+export type FlowEdge = {
+    start: string;
+    end: string;
+    text: string;
+    type?: string;
+    stroke?: string;
+    id?: string;
+    isUserDefinedId: boolean;
+    labelType: string;
+    classes: string[];
+    style: string[];
+    length?: number;
+    interpolate?: string;
+    animate?: boolean;
+    animation?: string;
+};
+export type FlowGroup = {
+    id: string;
+    title: string;
+    nodes: string[];
+    dir?: string;
+    labelType: string;
+    classes: string[];
+    metadata?: Record<string, unknown>;
+};
+export type FlowClass = {
+    id: string;
+    styles: string[];
+    textStyles: string[];
+};
+export type FlowSnapshot = {
+    format: 'mermaid';
+    family: 'flowchart';
+    parserVersion: typeof MERMAID_VERSION;
+    direction: string;
+    vertices: FlowVertex[];
+    edges: FlowEdge[];
+    groups: FlowGroup[];
+    classes: FlowClass[];
+    defaultEdgeStyle: string[];
+    defaultEdgeInterpolate?: string;
+};
+/** One entry of Mermaid's ordered sequence log; `kind` is its LINETYPE name. */
+export type SequenceEvent = {
+    kind: string;
+    from?: string;
+    to?: string;
+    text: string;
+    placement?: 'left' | 'right' | 'over';
+    central: boolean;
+};
+export type SequenceActor = {
+    id: string;
+    name: string;
+    type: string;
+    box?: number;
+    links: string[];
+};
+export type SequenceBox = {
+    name?: string;
+    fill?: string;
+};
+export type SequenceSnapshot = {
+    format: 'mermaid';
+    family: 'sequence';
+    parserVersion: typeof MERMAID_VERSION;
+    title?: string;
+    actors: SequenceActor[];
+    boxes: SequenceBox[];
+    events: SequenceEvent[];
+    created: string[];
+    destroyed: string[];
+};
+export type ParseFlowResult = {
+    ok: true;
+    snapshot: FlowSnapshot | SequenceSnapshot;
+    diagnostics: ParserDiagnostic[];
+} | {
+    ok: false;
+    diagnostics: ParserDiagnostic[];
+};
+type MermaidApi = Pick<(typeof import('mermaid'))['default'], 'initialize' | 'mermaidAPI'>;
+/** DB strings contain Mermaid entity sentinels; preserve entity spelling for text decoding. */
+export declare function restoreEntitySpelling(value: string): string;
+/**
+ * Use an unattached HTML template only. Its content is inert and is never adopted into the page.
+ * Caller supplies the browser document or the dedicated worker's JSDOM document.
+ * Markdown markers deliberately remain visible; native Markdown rendering is not assumed.
+ */
+export declare function makePlainLabel(document: Document): (value: string) => string;
+export declare function preflightMermaidFlow(source: string): ParserDiagnostic[];
+/** Each factory owns a serialized queue because Mermaid maintains parser/configuration state. */
+export declare function createMermaidFlowParser(load: () => Promise<MermaidApi>): (source: string) => Promise<ParseFlowResult>;
+export {};

package/dist/types/src/import/mermaid-importer.d.ts

@@ -0,0 +1,4 @@
+import { type ImportResult } from './import-core';
+import { type ParseFlowResult } from './mermaid-facade';
+/** Convert a checked Mermaid snapshot into valid native source. */
+export declare function importMermaidFlow(parsed: ParseFlowResult, plainText: (value: string) => string, title?: string): ImportResult;

package/dist/types/src/import/mermaid-sequence.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Mermaid `sequenceDiagram` -> native source. Participants become nodes and messages become edges
+ * in file order. Native sequences have no fragments, so each top-level branch of a block becomes
+ * a phase band, and the warning says that the branch logic is gone.
+ */
+import { type Diagnostic, type ImportResult } from './import-core';
+import type { SequenceSnapshot } from './mermaid-facade';
+export declare function mapMermaidSequence(snapshot: SequenceSnapshot, plainText: (value: string) => string, title: string, diagnostics: Diagnostic[]): ImportResult;

package/dist/types/src/model/appearance.d.ts

@@ -0,0 +1,209 @@
+/**
+ * Diagram appearance: five preset themes, color families with numeric shades, and the overrides a
+ * file can set. `resolveAppearance` turns a saved appearance into the concrete colors, spacing and
+ * type that sizing, the canvas and both SVG exports read, so all of them agree.
+ *
+ * Diagram appearance is separate from the editor's light or dark mode.
+ */
+import type { Footnote } from './footnote';
+import type { Note } from './note';
+import { type FontRole, type TypeProfile } from './fonts';
+import type { FileConfig } from './link';
+export type ThemeId = 'drafting' | 'fieldnotes' | 'signal' | 'ink' | 'blueprint';
+export declare const THEME_IDS: ThemeId[];
+export declare const DEFAULT_THEME: ThemeId;
+/** Shade stops. Lower numbers are lighter and higher numbers darker, in every theme. */
+export declare const SHADES: readonly [50, 100, 200, 300, 400, 500, 600, 700, 800, 900, 950];
+export type Shade = (typeof SHADES)[number];
+export declare const isShade: (n: unknown) => n is Shade;
+/** Shade of a node that names a color without a shade. */
+export declare const NODE_SHADE: Shade;
+/**
+ * Shade of a group that names a color without a shade. Groups are quiet surfaces behind nodes, so
+ * this is a pale shade in light themes and a deep one in dark themes; the scale itself never flips.
+ */
+export declare const groupShadeFor: (theme: ThemeId) => Shade;
+/** Built-in color families, available in every theme. `primary` and `secondary` follow the theme. */
+export declare const BUILT_IN_FAMILIES: readonly ["primary", "secondary", "slate", "stone", "blue", "sky", "teal", "mint", "green", "amber", "orange", "red", "rose", "violet"];
+export declare const isBuiltInFamily: (name: string) => boolean;
+export interface Swatch {
+    fill: string;
+    stroke: string;
+    ink: string;
+}
+/** A file's color declaration: one shade of a family. Built-in shades may set some fields only. */
+export interface ColorDefinition {
+    family: string;
+    shade: Shade;
+    fill?: string;
+    stroke?: string;
+    ink?: string;
+}
+export interface AppearanceOverrides {
+    paddingX?: number;
+    paddingY?: number;
+    radius?: number;
+    titleFont?: FontRole;
+    annotationFont?: FontRole;
+    canvas?: string;
+    text?: string;
+    connection?: string;
+}
+export interface DiagramAppearance {
+    theme: ThemeId;
+    overrides: AppearanceOverrides;
+    colors: ColorDefinition[];
+    /** What the colors mean, from `legend` statements, drawn as a key beside the diagram. */
+    legend?: LegendEntry[];
+    /** Title and subtitle drawn above exported images, from `diagram` and `subtitle` statements. */
+    heading?: Heading;
+    /** Sentences drawn on the diagram without moving it, from `note` statements. */
+    notes?: Note[];
+    /** Entries of the block between the drawing and the key, from `footnote` statements. */
+    footnotes?: Footnote[];
+    /** Panel labels from a `compare` statement: draw the old and new versions side by side. */
+    compare?: {
+        /** Set by `draftably compare`: the changes the older panel draws in their new version. */
+        undrawn?: string;
+        before: string;
+        after: string;
+        /** `right` sets the panels side by side, `down` stacks them; chosen by `aspect` when unset. */
+        direction?: 'right' | 'down';
+        /** Width over height the whole image should come closest to; 1.6 when unset. */
+        aspect?: number;
+    };
+    /** File settings from `config` statements. */
+    config?: FileConfig;
+    /** Named emphasis states from `state` statements, in file order. */
+    states?: EmphasisState[];
+}
+/** One way to draw the diagram: these objects and connections in focus, the rest faded or plain. */
+export interface EmphasisState {
+    id: string;
+    label: string;
+    /** Objects (a group brings its members) and connections in focus. */
+    ids: string[];
+    /** How everything else draws: faded like a context line, or as usual. */
+    rest: 'dim' | 'plain';
+}
+export interface Heading {
+    title?: string;
+    subtitle?: string;
+    /** Width of the frame round the drawing, from `diagram width=`; never narrower than its content. */
+    width?: number;
+}
+/** The connection styles a `legend line` row can explain. */
+export declare const LEGEND_LINES: readonly ["dashed", "solid"];
+export type LegendLine = (typeof LEGEND_LINES)[number];
+/** One row of the key: a color swatch (`family`), or a short connection (`line`). */
+export interface LegendEntry {
+    family?: string;
+    line?: LegendLine;
+    /** Shade of the swatch; nodes' default when omitted. */
+    shade?: Shade;
+    label: string;
+}
+export declare const defaultAppearance: () => DiagramAppearance;
+/** Limits for numeric overrides, shared by the file parser and JSON validation. */
+export declare const OVERRIDE_LIMITS: {
+    readonly paddingX: {
+        readonly min: 4;
+        readonly max: 48;
+    };
+    readonly paddingY: {
+        readonly min: 4;
+        readonly max: 48;
+    };
+    readonly radius: {
+        readonly min: 0;
+        readonly max: 24;
+    };
+};
+export declare const HEX_COLOR: RegExp;
+interface Preset {
+    label: string;
+    description: string;
+    dark: boolean;
+    canvas: string;
+    text: string;
+    muted: string;
+    connection: string;
+    node: Swatch;
+    group: Swatch;
+    paddingX: number;
+    paddingY: number;
+    radius: number;
+    shadow: boolean;
+    titleFont: FontRole;
+    annotationFont: FontRole;
+    titleSize: number;
+    titleLine: number;
+    annotationSize: number;
+    /** Chroma multiplier for the built-in families: how saturated this theme's colors are. */
+    chroma: number;
+    /** Anchor colors for `primary` and `secondary`, at the shade they appear as. */
+    primary: [string, Shade];
+    secondary: [string, Shade];
+    /** Hue and chroma for built-in families this theme draws in its own way. */
+    hues?: Partial<Record<string, [number, number]>>;
+}
+export declare const PRESETS: Record<ThemeId, Preset>;
+export declare function contrast(a: string, b: string): number;
+/** Contrast targets (WCAG ratios) every generated color meets. */
+export declare const CONTRAST: {
+    /** Dark title text on a pale fill. */
+    readonly paleInk: 7;
+    /** White title text on a dark fill. */
+    readonly darkInk: 4.5;
+    /** A shape's outline against the canvas when its fill alone does not separate it. */
+    readonly outline: 3;
+    /** Connection lines and connection label text against the canvas. */
+    readonly connection: 4.5;
+    /** A group's frame against the canvas. */
+    readonly frame: 2;
+};
+/**
+ * Move a color's lightness away from `against` until it reaches `min` contrast with it. Colors
+ * that already meet the target are returned unchanged.
+ */
+export declare function ensureContrast(color: string, against: string, min: number): string;
+/** The built-in families of a preset on a canvas color, generated once. */
+export declare function builtInFamilies(theme: ThemeId, canvas?: string): Map<string, Map<Shade, Swatch>>;
+export interface ResolvedAppearance {
+    theme: ThemeId;
+    dark: boolean;
+    canvas: string;
+    text: string;
+    muted: string;
+    connection: string;
+    /** Default node and group colors when nothing names a family. */
+    node: Swatch;
+    group: Swatch;
+    paddingX: number;
+    paddingY: number;
+    radius: number;
+    shadow: boolean;
+    title: TypeProfile;
+    groupTitle: TypeProfile;
+    annotation: TypeProfile;
+    /** Space above a group's content; the group title sits in it. */
+    groupHeader: number;
+    /** Every family and the shades it defines: built-in ones plus the file's own. */
+    families: Map<string, Map<Shade, Swatch>>;
+    custom: Set<string>;
+    /** Strike a removed object's title through (`config strike-removed=on`). */
+    strikeRemoved: boolean;
+}
+/** Height of a group's title band, derived from the title's line height. */
+export declare const groupHeaderFor: (lineHeight: number) => number;
+/** Preset values, then file overrides. Omitted fields inherit from the preset. */
+export declare function resolveAppearance(appearance?: DiagramAppearance): ResolvedAppearance;
+/**
+ * Colors for an object. `family` is a family name, or `auto` for the theme's default surface; an
+ * omitted shade is 500 for nodes and 100 for groups. Unknown families or shades fall back to the
+ * default surface; the file parser reports them before they get here.
+ */
+export declare function swatchFor(r: ResolvedAppearance, family: string | undefined, shade: Shade | undefined, kind?: 'node' | 'group'): Swatch;
+/** Shades a family defines, in numeric order. */
+export declare const shadesOf: (r: ResolvedAppearance, family: string) => Shade[];
+export {};

package/dist/types/src/model/bounds.d.ts

@@ -0,0 +1,19 @@
+import type { VisibleGraph } from './graph';
+import type { Diagram, Point, Rect } from './types';
+/** How far a connection's ink reaches past its points: half the stroke plus the arrowhead's wings. */
+export declare const ROUTE_INK = 4;
+export interface BoundedRoute {
+    id?: string;
+    points: readonly Point[];
+    label: {
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    } | null;
+}
+/**
+ * Bounds of everything drawn: shapes with their labels, containers, every route point with its
+ * stroke and arrowhead, and every connection label box. `pad` adds a margin on each side.
+ */
+export declare function drawingBounds(doc: Diagram, vg: VisibleGraph, rects: ReadonlyMap<string, Rect>, routes: readonly BoundedRoute[], pad?: number): Rect;

package/dist/types/src/model/document.d.ts

@@ -0,0 +1,24 @@
+import { type DiagramAppearance } from './appearance';
+import type { Diagram, DiagramSettings } from './types';
+export declare const MAX_NODES = 500;
+export declare const MAX_EDGES = 1200;
+export declare function uid(prefix?: string): string;
+export declare const DEFAULT_SETTINGS: DiagramSettings;
+export declare function emptyDiagram(title?: string): Diagram;
+type Raw = any;
+export declare const isLegacyDiagram: (input: Raw) => boolean;
+/**
+ * Validate a diagram from any source and return a complete, canonical copy.
+ * Throws a readable error for anything that cannot be repaired.
+ */
+export declare function normalize(input: unknown): Diagram;
+/** Validate a saved appearance. A missing appearance is the default theme. */
+export declare function normalizeAppearance(input: Raw): DiagramAppearance;
+/** The meaning of a document, ignoring where the camera happens to be. */
+export declare function documentIdentity(doc: Diagram): string;
+/**
+ * Inputs that affect connection routing. The editor store keeps the key order of the document it
+ * replaced, so the worker's freshly projected copy of the same document lists its keys differently.
+ */
+export declare function routingFingerprint(doc: Diagram): string;
+export {};

package/dist/types/src/model/font-faces.d.ts

@@ -0,0 +1,24 @@
+/** SHA-256 prefix of the metric table and its four WOFF2 files, in declared face order. */
+export declare const fontMetricsVersion = "269b2d3580f4";
+export declare const FACES: {
+    'sans-500': {
+        family: string;
+        weight: number;
+        file: string;
+    };
+    'sans-600': {
+        family: string;
+        weight: number;
+        file: string;
+    };
+    'serif-600': {
+        family: string;
+        weight: number;
+        file: string;
+    };
+    'mono-500': {
+        family: string;
+        weight: number;
+        file: string;
+    };
+};

package/dist/types/src/model/fonts.d.ts

@@ -0,0 +1,47 @@
+export type FontRole = 'sans' | 'serif' | 'mono';
+export declare const FONT_ROLES: FontRole[];
+export interface FontFace {
+    /** Registered family name; unique so an installed copy of the font is never used instead. */
+    family: string;
+    weight: number;
+    file: string;
+}
+export { FACES } from './font-faces';
+import { FACES } from './font-faces';
+export type FaceId = keyof typeof FACES;
+/** Face used for each role: titles are a little heavier than annotations in sans-serif. */
+export declare const faceFor: (role: FontRole, title: boolean) => FaceId;
+export declare const fontStack: (role: FontRole) => string;
+/** A text style: which face, at what size and line height. */
+export interface TypeProfile {
+    role: FontRole;
+    face: FaceId;
+    family: string;
+    weight: number;
+    size: number;
+    lineHeight: number;
+}
+export declare function typeProfile(role: FontRole, title: boolean, size: number, lineHeight: number): TypeProfile;
+/**
+ * Width of `text` in `profile`, from the stored advance widths. Kerning is ignored, which only
+ * ever overstates a width slightly, so measured text fits where this says it fits.
+ */
+export declare function measureText(text: string, profile: Pick<TypeProfile, 'face' | 'size'>): number;
+/**
+ * The pieces an identifier reads in, so a long one can break where a reader would: after a
+ * separator (`/`, `.`, `_`, `-`, `:`) or between a lower-case letter or digit and a capital
+ * (camelCase). `annotationCommands` → `annotation`, `Commands`; `src/viz/Treemap.tsx` → `src/`,
+ * `viz/`, `Treemap.tsx`. A word with none of these is one piece.
+ */
+export declare function wordPieces(word: string): string[];
+/** Width of the widest piece of any word in `text`: the narrowest line it wraps into whole. */
+export declare function widestPiece(text: string, profile: Pick<TypeProfile, 'face' | 'size'>): number;
+/**
+ * Break text into lines no wider than `width`, starting a new line at each `\n`. A word longer
+ * than a line breaks between its pieces (`wordPieces`), and only a piece that is itself too long
+ * breaks by character. With `balance`, a paragraph that wraps keeps its line count but its lines
+ * run near equal (`even`), so no word sits alone on the last line when a better break exists.
+ */
+export declare function wrapLines(text: string, width: number, profile: TypeProfile, balance?: boolean): string[];
+/** Shorten text with an ellipsis so it fits in `width`. */
+export declare function truncateText(text: string, width: number, profile: TypeProfile): string;

package/dist/types/src/model/footnote.d.ts

@@ -0,0 +1,34 @@
+/**
+ * Footnotes: a block of short entries between the drawing and the key, from `footnote`
+ * statements, in file order, at body text size and wrapped to the frame. An entry may carry a
+ * marker (`1`, `a`, `*`) that a label can point at, and links in `[label](href)` form. The viewer,
+ * `inspect --svg`, PDF and the editor's exports all lay it out here.
+ */
+import { type ResolvedAppearance } from './appearance';
+import { type Run } from './rich-text';
+export interface Footnote {
+    text: string;
+    /** A short marker drawn before the entry, which labels can point at as `[1]`. */
+    mark?: string;
+}
+/** The block's entries, wrapped to `width`, with their offsets from its top-left corner. */
+export declare function footnoteSize(look: ResolvedAppearance, notes: readonly Footnote[], width: number): {
+    type: import("./fonts").TypeProfile;
+    gutter: number;
+    items: {
+        note: Footnote;
+        lines: Run[][];
+        y: number;
+    }[];
+    h: number;
+};
+export type FootnoteLayout = ReturnType<typeof footnoteSize>;
+/** Where each line of every entry is drawn, from the block's top-left corner at (x, y). */
+export declare function footnoteLines(layout: FootnoteLayout, x: number, y: number): {
+    entry: number;
+    runs: Run[];
+    x: number;
+    y: number;
+}[];
+/** SVG markup for the block: a short rule, then each entry's marker and wrapped text. */
+export declare function footnoteMarkup(look: ResolvedAppearance, layout: FootnoteLayout, x: number, y: number, write?: (href: string) => string | null): string;

package/dist/types/src/model/geometry.d.ts

@@ -0,0 +1,29 @@
+import type { Point, Rect } from './types';
+export declare const clamp: (n: number, min: number, max: number) => number;
+export declare const finite: (n: unknown) => n is number;
+/** Document coordinates are stored with one decimal place. */
+export declare const rounded: (n: number) => number;
+export declare const center: (r: Rect) => Point;
+export declare const manhattan: (a: Point, b: Point) => number;
+export declare const inside: (p: Point, r: Rect, pad?: number) => boolean;
+export declare const contains: (outer: Rect, inner: Rect) => boolean;
+export declare const overlaps: (a: Rect, b: Rect, pad?: number) => boolean;
+/** Bounding box of the given rectangles, or a placeholder area when there are none. */
+export declare function rectUnion(rects: readonly Rect[], pad?: number): Rect;
+/** Rectangle spanned by two corner points. */
+export declare const rectFromPoints: (a: Point, b: Point) => Rect;
+export type Segment = [Point, Point];
+export declare const segments: (points: readonly Point[]) => Segment[];
+export declare const shrink: (r: Rect, d: number) => Rect;
+/** Overlap of two rectangles larger than half a pixel on both axes. */
+export declare const covers: (a: Rect, b: Rect) => boolean;
+/** Length of a segment inside a rectangle (Liang–Barsky clipping). */
+export declare function segmentInside([a, b]: Segment, r: Rect): number;
+/** SVG path for an orthogonal polyline with rounded corners. */
+export declare function roundedPath(points: readonly Point[], radius: number): string;
+export declare const clone: <T>(value: T) => T;
+/**
+ * A rectangle whose left and right sides are zigzags, for a field of variable length: the reader
+ * sees it continue past what is drawn.
+ */
+export declare function brokenRectPath(r: Rect, step?: number, depth?: number): string;