@weasel-js/diagram 1.10.1 → 1.11.1

package/dist/dataTypes-B-iEwKZp.d.ts

@@ -0,0 +1,553 @@
+import { DerivedDep, PoseDescriptor, NodeShapeEntry, MarkerRef, Page, PageLayoutOptions, AddNodeSpec, Stroke, RectPose } from '@weasel-js/core';
+import { Vec2 } from '@weasel-js/core/math';
+import { E as EdgeHop, S as StyleField, P as PortAnchor, D as DiagramGroup, R as RowTextStyle, a as Row, O as Outline, b as PortSpec, B as BodySpec, c as DiagramLabel, L as LayoutPorts, d as LayoutFn, e as LayoutOptions, M as MeasureRowText, f as DiagramNode } from './types-BbHunLXm.js';
+
+/**
+ * Off-page markers as data: what a connector cut at the page gap holds, and
+ * what each of its two tags holds. The pass that writes both is `install`.
+ */
+/** A connector whose ends sit on different pages: its reference letter, and
+ *  the pages its `from` and `to` ends are on. */
+interface OffPageSplit {
+    ref: string;
+    from: string;
+    to: string;
+}
+/** Which end of which connector a tag names the far page for. */
+interface OffPageTag {
+    edge: string;
+    end: 'from' | 'to';
+}
+/** The id of the tag at end `end` of connector `edgeId`. */
+declare const offPageTagId: (edgeId: string, end: "from" | "to") => string;
+/** The off-page tag trait on a node's data (`data.diagram.offPageTag`), or `null`. */
+declare function offPageTagOf(node: {
+    data: unknown;
+}): OffPageTag | null;
+
+/**
+ * The edge trait: what an edge's `data` says about its ends and its route, and
+ * who owns each. Data only — the routers and the scene wiring are in `edge`,
+ * so layout can read an edge without reaching the scene.
+ */
+
+/** Where an edge attaches at one end. */
+interface EdgeEnd {
+    /** The port to leave from, when the endpoint declares one. Falls back to
+     *  the nearest port, so an edge drawn before ports were thought about still
+     *  meets the shape. */
+    port?: string;
+    /** The port layout last named here. While `port` still equals it, or names
+     *  none, layout owns the end and names it again on its next run. */
+    laidOut?: string;
+}
+/** Whether layout may name this end's port: it names none, or only the one
+ *  layout last named. */
+declare function layoutOwnsPort(end: EdgeEnd): boolean;
+/** The trait on an edge's `data`, under the same key participants use. */
+interface DiagramEdge {
+    from: EdgeEnd;
+    to: EdgeEnd;
+    /** Registry key for the router. Resolved by whoever builds the edge's
+     *  `derivePath`; unknown keys fall back to `straight`. */
+    router?: string;
+    /** Points in world coordinates the route must pass through, in order. The
+     *  author owns these; the router owns everything between them. */
+    waypoints?: readonly Vec2[];
+    /** The waypoints layout last wrote here. While `waypoints` still equals
+     *  them, layout owns the route and rewrites it on its next run; once anyone
+     *  edits them, they are the author's and layout leaves them alone. */
+    laidOut?: readonly Vec2[];
+    /** The bends between the ends that the obstacle-avoiding router last
+     *  computed, kept so the edge draws without rerouting. The router owns it,
+     *  and while it is here each end aims at its nearest bend. */
+    route?: readonly Vec2[];
+    /** Where it bows over the connectors drawn before it, as the line-jump
+     *  pass last computed. Literal, so any reader draws them. */
+    hops?: readonly EdgeHop[];
+    /** Set while its ends sit on different pages, when it draws as two stubs
+     *  ending at off-page tags. The off-page pass owns it (`installOffPageMarkers`). */
+    offPage?: OffPageSplit;
+    /** The theme role it is drawn in. Unset, the theme's own connector style. */
+    style?: string;
+    /** The colors the author set by hand, which a theme leaves as they are. */
+    ownStyle?: readonly StyleField[];
+}
+/** Whether layout may rewrite this edge's route: it has no waypoints, or only
+ *  the ones layout last wrote. */
+declare function layoutOwnsRoute(edge: DiagramEdge): boolean;
+/** Whether layout writes this edge's waypoints: it owns the route, and the
+ *  edge is not routed around obstacles, whose bends are never stops. */
+declare function layoutWritesRoute(edge: DiagramEdge): boolean;
+/** The edge trait on a node's data, or `null`. */
+declare function diagramEdgeOf(node: {
+    data: unknown;
+}): DiagramEdge | null;
+
+/**
+ * A group's box, and anything pinned to a point on another node.
+ *
+ * The box is an ordinary node that depends on its members and derives its pose
+ * from theirs: their union, grown by the inset. Drag a member and the box
+ * follows; lay the diagram out and the box lands around wherever the members
+ * went. Nothing has to keep it in sync, because nothing stores it.
+ *
+ * An anchored node — a group's title is the first — derives its pose from one
+ * dependency's bounds the same way, so it travels with the box it labels.
+ */
+
+/** Where an anchored node sits on its dependency. */
+interface DiagramAnchor {
+    /** The point on the dependency's bounds, normalized as a port's is. */
+    at: PortAnchor;
+    /** The point on the node's own bounds that lands there. Default `at`, so
+     *  `{ u: 0, v: 0 }` puts the node's top-left on the dependency's. */
+    self?: PortAnchor;
+    /** Then moved by this much, in world units. */
+    offset?: Vec2;
+}
+/** The group trait on a node's data, or `null`. */
+declare function diagramGroupOf(node: {
+    data: unknown;
+}): DiagramGroup | null;
+/** The anchor trait on a node's data, or `null`. */
+declare function diagramAnchorOf(node: {
+    data: unknown;
+}): DiagramAnchor | null;
+/** Options for {@link groupDerivePose} and {@link anchorDerivePose}.
+ *  `geometry` defaults to the kit's `AUTO_POSE_DESCRIPTOR`. */
+interface GroupPoseOptions<TPose> {
+    geometry?: PoseDescriptor<TPose>;
+}
+/** A `derivePose` function as the scene calls it: the node, then what it depends on, in `dependsOn` order. */
+type DiagramDerivePose<TPose> = (node: {
+    pose: TPose;
+    data: unknown;
+}, deps: readonly (DerivedDep<TPose> | undefined)[]) => TPose | null;
+/**
+ * A `derivePose` that draws a group's box around its members: the union of
+ * what each takes up, its `margin` included, grown by the trait's inset. `null` — the authored pose stands — when the node
+ * carries no group trait or every member is gone.
+ */
+declare function groupDerivePose<TPose>(opts?: GroupPoseOptions<TPose>): DiagramDerivePose<TPose>;
+/** A group's box around the union of its members: grown by its inset, and
+ *  widened evenly to its `minWidth`. */
+declare function boxAround(union: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, group: DiagramGroup): {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+};
+/**
+ * A `derivePose` that keeps a node at a point on its dependency's bounds.
+ * `null` when the node carries no anchor trait or the dependency is gone.
+ */
+declare function anchorDerivePose<TPose>(opts?: GroupPoseOptions<TPose>): DiagramDerivePose<TPose>;
+/** Registry key for {@link GROUP_DERIVE_POSE}. */
+declare const DIAGRAM_GROUP = "diagram:group";
+/** Registry key for {@link ANCHOR_DERIVE_POSE}. */
+declare const DIAGRAM_ANCHOR = "diagram:anchor";
+/** The default group derivation, a stable reference so `toJSON` can find its key. */
+declare const GROUP_DERIVE_POSE: DiagramDerivePose<unknown>;
+/** The default anchor derivation, a stable reference for the same reason. */
+declare const ANCHOR_DERIVE_POSE: DiagramDerivePose<unknown>;
+
+/**
+ * Marks: what a data node draws besides its rows. A drawn mark is SVG path
+ * data in a unit square, stretched over the node's box, so it follows the node
+ * wherever layout or a drag puts it. A text mark is pinned to a point on the box.
+ */
+
+/** One mark on a `DataNode`. Colors default to the node's stroke and text. */
+type DataMark = {
+    d: string;
+    fill?: string;
+    stroke?: string;
+    strokeWidth?: number;
+    dash?: number[];
+    opacity?: number;
+} | {
+    text: string;
+    at: PortAnchor;
+    self?: PortAnchor;
+    offset?: Vec2;
+    color?: string;
+    style?: RowTextStyle;
+};
+/** The trait on a drawn mark's `data`: path data in a unit square. */
+interface DiagramMark {
+    d: string;
+}
+/** The mark a scene node carries, or null for a node that is not a drawn
+ *  mark: how `markShape` tells which nodes it paints. */
+declare function diagramMarkOf(node: {
+    data: unknown;
+}): DiagramMark | null;
+/** The painter for a drawn mark. */
+declare function markShape<TPose>(opts?: {
+    geometry?: PoseDescriptor<TPose>;
+}): NodeShapeEntry<unknown, TPose>;
+/** Register {@link markShape}; returns the disposer. */
+declare function registerMarkShape<TPose>(opts?: {
+    geometry?: PoseDescriptor<TPose>;
+}): () => void;
+
+/** The face a diagram node's text is set in. */
+type DiagramTextStyle = {
+    fontFamily: string;
+    fontSize: number;
+    fontWeight?: number;
+    align?: 'center';
+};
+type Font = {
+    fontFamily: string;
+    fontSize: number;
+};
+/** The face a body row's text is set in. A label row's is centered in the row. */
+declare function rowTextStyle(row: Row | undefined, font: Font): DiagramTextStyle;
+
+/** The roles every shipped theme styles, with the name a picker shows. */
+declare const DIAGRAM_ROLES: readonly [{
+    readonly id: "default";
+    readonly label: "Default";
+}, {
+    readonly id: "accent";
+    readonly label: "Accent";
+}, {
+    readonly id: "muted";
+    readonly label: "Muted";
+}, {
+    readonly id: "positive";
+    readonly label: "Positive";
+}, {
+    readonly id: "warning";
+    readonly label: "Warning";
+}, {
+    readonly id: "negative";
+    readonly label: "Negative";
+}];
+/** The id of one of {@link DIAGRAM_ROLES}. A theme may style roles of its own besides. */
+type DiagramRole = (typeof DIAGRAM_ROLES)[number]['id'];
+
+/** The face a theme sets diagram text in. A text row keeps its own size. */
+interface DiagramFont {
+    family: string;
+    size: number;
+}
+/**
+ * A document's colors and face. Applying one writes literal colors into the
+ * scene, so nothing that reads the scene needs the theme to draw it.
+ */
+interface DiagramTheme {
+    id: string;
+    name: string;
+    /** A shape's fill, stroke and text by role id. A connector given a role takes that role's stroke. */
+    roles: Readonly<Record<string, NodeStyle>>;
+    /** The names a picker shows for roles beyond {@link DIAGRAM_ROLES}, or for a shipped role renamed. */
+    roleLabels?: Readonly<Record<string, string>>;
+    /** The role a shape or connector naming none, or naming one this theme lacks, is drawn in. */
+    defaultRole: string;
+    /** A connector naming no role. */
+    edge: EdgeStyle;
+    /** A connector's label, where the connector names no role. */
+    label: {
+        fill: string;
+        font?: DiagramFont;
+    };
+    /** A group's or a container's box, its `text` the title's color. */
+    container: NodeStyle;
+    /** A pool's header, and its lanes' bodies in turn. */
+    lane: {
+        header: NodeStyle;
+        bodies: readonly NodeStyle[];
+    };
+    /** The page a document is drawn on. */
+    page: string;
+    font: DiagramFont;
+    /** Colors for a series of things the theme cannot name in advance: an effect look's value types. */
+    series: readonly string[];
+}
+/** The document value a theme is saved under: a shipped theme's id, or a whole custom theme. */
+declare const DIAGRAM_THEME_KEY = "diagram:theme";
+
+/**
+ * The plain data `diagramScene` reads, and the options and styles it takes.
+ */
+
+/** One node of a {@link DiagramData}: its rows of text, and optionally its outline, ports, size, and starting place. */
+interface DataNode {
+    id: string;
+    /** Shorthand for one `label` row per line. Ignored when `rows` is given. */
+    lines?: readonly string[];
+    rows?: readonly Row[];
+    /** Default `DiagramSceneOptions.outline`, which defaults to `'rect'`. */
+    outline?: Outline;
+    /** Perimeter ports, replacing the four compass midpoints. */
+    ports?: readonly PortSpec[];
+    /** Labels for the perimeter ports by id, drawn outside the box beside each. */
+    portLabels?: Readonly<Record<string, string>>;
+    /** Layout leaves this node at `at`. */
+    pinned?: boolean;
+    /** Where the node starts, before layout. Unset, nodes start on the
+     *  diagonal in source order, which is what within-rank order is seeded
+     *  from. */
+    at?: Vec2;
+    /** The smallest the box may be. Its content grows it past this. */
+    width?: number;
+    height?: number;
+    /** Default `DiagramSceneOptions.padding`. */
+    padding?: number;
+    /** Default `DiagramSceneOptions.gap`. */
+    gap?: number;
+    /** Default `DiagramSceneOptions.verticalAlign`. */
+    verticalAlign?: BodySpec['verticalAlign'];
+    /** Drawn over the box besides its rows: shapes in a unit square stretched
+     *  over it, and text pinned to a point on it. */
+    marks?: readonly DataMark[];
+    /** The theme role it is drawn in, under `DiagramSceneOptions.theme`. Kept on its trait. */
+    style?: string;
+    /** Colors of its own, over its role's. Each one set is listed in the trait's `ownStyle`, so a
+     *  theme change leaves it. */
+    colors?: Partial<NodeStyle>;
+}
+/** One edge of a {@link DiagramData}, between two nodes or groups by id. */
+interface DataEdge {
+    /** The scene node id this edge gets, for an editor that must find it again
+     *  after its ends, ports or label change. Unset, {@link edgeIdOf} derives
+     *  one from those. */
+    id?: string;
+    /** A node's id, or a group's: an edge naming a group meets its box. */
+    from: string;
+    to: string;
+    /** The port to leave from or arrive at. Unset, the end facing the other
+     *  node most directly. */
+    fromPort?: string;
+    toPort?: string;
+    label?: string;
+    /** Where along the edge the label sits. Unset or at `'mid'`, under
+     *  `layered` the label sits in the room layout leaves it beside its wire,
+     *  at this placement's offset, else `DiagramSceneOptions.labelPlacement`'s;
+     *  otherwise at the placement. */
+    labelPlacement?: DiagramLabel;
+    /** Default `DiagramSceneOptions.router`. */
+    router?: DiagramRouter;
+    /** World points the route passes through. Layout does not move them. */
+    waypoints?: readonly Vec2[];
+    /** A route a layout run wrote, as `DiagramView`'s `onMove` reports it: drawn
+     *  until layout runs again, which may replace it. `waypoints` wins. */
+    routed?: readonly Vec2[];
+    /** Ports a layout run named, as `onMove` reports them: used like `routed`,
+     *  and not part of the edge's id. `fromPort` and `toPort` win. */
+    routedPorts?: LayoutPorts;
+    /** The theme role it is drawn in, under `DiagramSceneOptions.theme`: that role's stroke. Kept on its trait. */
+    style?: string;
+    /** Its stroke, markers, and label color of its own, over the theme's. `stroke` and `label` are
+     *  listed in the trait's `ownStyle` (as `stroke` and `text`), so a theme change leaves them. */
+    colors?: Partial<EdgeStyle>;
+}
+/** A box drawn around some nodes, which layout keeps together. */
+interface DataGroup {
+    /** Shares one namespace with node ids. */
+    id: string;
+    /** Node ids, and the ids of groups nested in this one. A node or group a
+     *  later group also names stays in this one; an id that is neither is
+     *  ignored, and so is one that would put a group inside itself. */
+    members: readonly string[];
+    /** Drawn inside the box, above its members. */
+    label?: string;
+    /** Between the box and its members, and around the label. Default
+     *  `DiagramSceneOptions.groupPadding`. */
+    padding?: number;
+    /** The axis its members can be dragged along to change their order, in a
+     *  `DiagramView` given `onReorder`. A member that is a group carries
+     *  everything inside it. */
+    reorder?: 'x' | 'y';
+}
+/** A diagram as plain data, the input to `diagramScene`. */
+interface DiagramData {
+    nodes: readonly DataNode[];
+    edges: readonly DataEdge[];
+    /** A group may be a member of another. `layered`, `tree`, `force`, and `chain`
+     *  keep each group's members together; `'none'` ignores groups but still
+     *  draws them. */
+    groups?: readonly DataGroup[];
+    /** Containers and pools: regions drawn as scene containers that hold their
+     *  members, which a `DiagramView` drags shapes into and out of. */
+    containers?: readonly DataContainer[];
+    /** The sheets the diagram is drawn on, in world space as `layoutPages` places them; a node
+     *  belongs to the page its box overlaps most (`pageOfBounds`). A connector whose ends belong
+     *  to different pages is split into two stubs, each with an off-page tag. A node in the gap
+     *  between pages belongs to none, and its connectors stay whole. */
+    pages?: readonly Page[];
+    /** How `pages` are laid out in world space. */
+    pageLayout?: PageLayoutOptions;
+}
+/**
+ * A container or a pool, drawn as a region that holds its members. Its id
+ * shares one namespace with node, group, and lane ids.
+ *
+ * With a `box` it is laid out as one node of that size, and its members ride
+ * along with it: a member with no `at` is seeded inside its body, in rows.
+ * With none, a container is laid out as a group and its box fits its members.
+ * A pool always has a box, {@link DEFAULT_POOL_ACROSS} across and
+ * {@link DEFAULT_LANE_SIZE} along per lane when none is given. An edge with
+ * an end inside a boxed region ranks against the outermost one holding it.
+ */
+interface DataContainer {
+    id: string;
+    role: 'container' | 'pool';
+    /** Its title, drawn in its header. */
+    label?: string;
+    /** A container's direct members: node ids and container ids. A member
+     *  already claimed by an earlier container, a pool, an unknown id, and one
+     *  that would put a container inside itself are ignored. */
+    members?: readonly string[];
+    /** A pool's lanes, in the order they stack. */
+    lanes?: readonly DataLane[];
+    /** The axis a pool stacks its lanes along: `'y'` for rows. Default `'y'`. */
+    axis?: 'x' | 'y';
+    /** Where it stands and how big it is, in world units. A pool's size along
+     *  its stack is shared by the lanes that give no `size`. */
+    box?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Layout leaves its box where it is. */
+    pinned?: boolean;
+    /** The theme role it is drawn in. Unset, a container takes the theme's
+     *  `container` style, a pool its `lane.header`. */
+    style?: string;
+    /** Colors of its own, over its style's, listed in its trait's `ownStyle` as a node's are. */
+    colors?: Partial<NodeStyle>;
+}
+/** One lane of a pool. Its id shares the node id namespace. */
+interface DataLane {
+    id: string;
+    label?: string;
+    /** Its depth along the pool's stack, in world units. */
+    size?: number;
+    /** Node ids and container ids, claimed as a container's are. */
+    members?: readonly string[];
+    /** Colors of its own, as a container's. A lane draws no fill. */
+    colors?: Partial<NodeStyle>;
+}
+/** A pool's size across its stack when it gives no box. */
+declare const DEFAULT_POOL_ACROSS = 600;
+/** A lane's size along its pool's stack when neither it nor the pool's box gives one. */
+declare const DEFAULT_LANE_SIZE = 120;
+/** The colors and outline a node is drawn with. */
+interface NodeStyle {
+    fill: string;
+    stroke: string;
+    text: string;
+    strokeWidth?: number;
+    dash?: number[];
+}
+/** A node's or region's outline width when its style gives none. */
+declare const NODE_STROKE_WIDTH = 2;
+/** A lane's outline width, which its style does not change. */
+declare const LANE_STROKE_WIDTH = 1;
+/** An edge's stroke width when its style gives none. */
+declare const EDGE_STROKE_WIDTH = 1.5;
+/** The stroke, markers, and label color an edge is drawn with. */
+interface EdgeStyle {
+    stroke: string;
+    width?: number;
+    dash?: number[];
+    /** `null` for none. Default none. */
+    markerStart?: MarkerRef | null;
+    /** `null` for none. Default `'arrow'`. */
+    markerEnd?: MarkerRef | null;
+    /** Default `stroke`. */
+    label?: string;
+}
+/** How an edge is drawn between its ends. */
+type DiagramRouter = 'straight' | 'bezier' | 'orthogonal' | 'avoid';
+/** The `data` of a scene node `diagramScene` makes: its diagram role, and what it paints. */
+interface DiagramSceneData {
+    diagram?: DiagramNode | DiagramEdge | {
+        label: DiagramLabel;
+    } | {
+        anchor: DiagramAnchor;
+    } | {
+        mark: DiagramMark;
+    } | {
+        offPageTag: OffPageTag;
+    };
+    fill?: {
+        paint: {
+            color: string;
+            opacity?: number;
+        };
+    };
+    stroke?: Stroke;
+    text?: string;
+    style?: DiagramTextStyle;
+    verticalAlign?: 'top' | 'center' | 'bottom';
+    /** What a slot is filled with: an image the kit's image painter draws. */
+    image?: {
+        src: string;
+        opacity?: number;
+    };
+    /** A body's text row: its place among the body's rows (see `DiagramNode.body`). */
+    bodyRow?: number;
+    /** An off-page tag's box, behind its text, and the room between them. */
+    background?: {
+        paint: {
+            color: string;
+        };
+    };
+    padding?: number;
+}
+/** A scene node spec, as `diagramScene` returns them. */
+type DiagramSpec<TLayer extends string = 'main'> = AddNodeSpec<DiagramSceneData, TLayer, RectPose>;
+/** How `diagramScene` lays out, routes, and styles a {@link DiagramData}. */
+interface DiagramSceneOptions<TLayer extends string = 'main'> {
+    /** The layer every spec goes on. Default `'main'`. */
+    layer?: TLayer;
+    /** A layout by name, or any `LayoutFn`. Default `'layered'`. `'none'`
+     *  leaves every node at its `at`. */
+    layout?: 'layered' | 'tree' | 'force' | 'chain' | 'none' | LayoutFn;
+    /** Merged over `{ order: 'barycenter' }`. */
+    layoutOptions?: LayoutOptions;
+    /** Default `'bezier'`. */
+    router?: DiagramRouter;
+    /** The text style rows fall back on. Default 12px sans-serif. */
+    font?: {
+        fontFamily: string;
+        fontSize: number;
+    };
+    /** Measures one run of text. Default an estimate from character count, so
+     *  layout needs no canvas; pass `canvasMeasure(ctx)` for real widths. */
+    measure?: MeasureRowText;
+    /** Default `'rect'`. */
+    outline?: Outline;
+    /** Between a box's outline and its rows. Default 8. */
+    padding?: number;
+    /** Between adjacent rows. Default 4. */
+    gap?: number;
+    /** Where a box's rows sit when it is taller than they need. Default `'center'`. */
+    verticalAlign?: BodySpec['verticalAlign'];
+    /** The narrowest a box may be. Default 64. */
+    minWidth?: number;
+    /** Where edge labels sit. Default `{ at: 'mid', offset: 9 }`. */
+    labelPlacement?: DiagramLabel;
+    nodeStyle?: (node: DataNode) => NodeStyle;
+    /** Default 12. */
+    groupPadding?: number;
+    /** A group's box and label. `text` colors the label. */
+    groupStyle?: (group: DataGroup) => NodeStyle;
+    edgeStyle?: (edge: DataEdge) => EdgeStyle;
+    /** Styles nodes by their `style` role, and edges, groups and text by the theme, where the
+     *  functions above leave them; and its face is the default `font`. */
+    theme?: DiagramTheme;
+}
+
+export { ANCHOR_DERIVE_POSE as A, type GroupPoseOptions as B, NODE_STROKE_WIDTH as C, type DiagramTheme as D, type EdgeStyle as E, type OffPageTag as F, GROUP_DERIVE_POSE as G, anchorDerivePose as H, boxAround as I, diagramAnchorOf as J, diagramEdgeOf as K, LANE_STROKE_WIDTH as L, diagramGroupOf as M, type NodeStyle as N, type OffPageSplit as O, diagramMarkOf as P, groupDerivePose as Q, layoutOwnsPort as R, layoutOwnsRoute as S, layoutWritesRoute as T, markShape as U, offPageTagId as V, offPageTagOf as W, registerMarkShape as X, rowTextStyle as Y, type DiagramData as a, type DiagramSceneOptions as b, type DataEdge as c, type DataNode as d, type DiagramRouter as e, type DiagramSpec as f, type EdgeEnd as g, type DiagramSceneData as h, type DiagramEdge as i, type DataContainer as j, DEFAULT_LANE_SIZE as k, DEFAULT_POOL_ACROSS as l, DIAGRAM_ANCHOR as m, DIAGRAM_GROUP as n, DIAGRAM_ROLES as o, DIAGRAM_THEME_KEY as p, type DataGroup as q, type DataLane as r, type DataMark as s, type DiagramAnchor as t, type DiagramDerivePose as u, type DiagramFont as v, type DiagramMark as w, type DiagramRole as x, type DiagramTextStyle as y, EDGE_STROKE_WIDTH as z };