@draftably/markdown 0.1.0 → 0.2.0

package/dist/types/src/dsl/channels.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Routing channels inside groups.
+ *
+ * A group leaves `GROUP_INSET` between its members and its border. That is padding, not room for
+ * a line: a line routed through it runs beside a member and along the border at once. When a
+ * connection has to travel inside a group (a member boxed in by its neighbours, or a link between
+ * two of the group's children that can't go straight across), the group grows a channel on one
+ * side, wide enough for each such line to run a full standoff from the members,
+ * the border and each other. A link between children takes the side of them both ends lean
+ * toward, and a return (up or left) takes the left or top when they lean neither way, so a
+ * forward line and its return don't cross. The compiler lays the scene out once, plans channels
+ * from that geometry, and lays it out again with them.
+ */
+import type { ModelEdge } from './syntax';
+/**
+ * Room a group leaves round its content: the inset on the left, right and bottom (at least
+ * `GROUP_INSET`), and extra room under the title band on top (0 without a channel there).
+ */
+export interface Channel {
+    left: number;
+    right: number;
+    top: number;
+    bottom: number;
+    /** How many lines each side's channel was planned for. */
+    lines: Record<Side, number>;
+}
+/** Channels may grow the drawing's area by this much at most. */
+export declare const CHANNEL_BUDGET = 1.1;
+/**
+ * Drop the channels that carry fewest lines until the drawing laid out with the rest (`measure`)
+ * is within `CHANNEL_BUDGET` of its area without any (`plain`).
+ */
+export declare function trimChannels(plan: Map<string, Channel>, plain: number, measure: (channels: Map<string, Channel>) => number): Map<string, Channel>;
+interface Box {
+    id: string;
+    type: string;
+    parent: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+export type Side = 'left' | 'right' | 'top' | 'bottom';
+/**
+ * Channels for the scene laid out as `objects`. A group is keyed by id; groups with no traffic
+ * are left out.
+ */
+export declare function planChannels(objects: Box[], edges: ModelEdge[], routing?: {
+    edgeGap?: number;
+    portGap?: number;
+    standoff?: number;
+}): Map<string, Channel>;
+export {};

package/dist/types/src/dsl/compile.d.ts

@@ -0,0 +1,162 @@
+import { type ResolvedAppearance } from '../model/appearance';
+import type { CellsChrome, Lane, SequenceLayout } from '../model/types';
+import { GROUP_HEADER, GROUP_INSET, contentOrigin } from './frame';
+import { type Model, type ModelEdge, type ModelLayout, type ModelObject } from './syntax';
+/** The single render context. Browser window size changes the camera, never the layout. */
+export declare const RENDER_CONTEXT: {
+    readonly width: 1100;
+    readonly height: 720;
+};
+export { GROUP_HEADER, GROUP_INSET, contentOrigin };
+export interface SceneObject extends ModelObject {
+    /** World (diagram) coordinates. */
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    /** Position relative to the parent's content origin; `pin` and `stay` use these. */
+    localX: number;
+    localY: number;
+    /** Local position from the automatic recipe alone, before refinements; `nudge` offsets this. */
+    baseX: number;
+    baseY: number;
+    depth: number;
+    /** Sequence participants: how far the dashed lifeline runs below the box. */
+    lifeline?: number;
+    /** Soft groups: the tint's rectangles, relative to the group's top left; the first holds the label. */
+    hull?: Array<{
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }>;
+    /** Groups: lines the title wraps to, when more than one. */
+    titleLines?: number;
+}
+export interface Diagnostic {
+    level: 'error' | 'warning' | 'info';
+    code: string;
+    message: string;
+    /** Source line of the rule involved, when there is one. */
+    line?: number;
+    ids: string[];
+}
+/** A connection as the file declares it, plus the lane a fold's wrap edge returns along. */
+export interface SceneEdge extends ModelEdge {
+    lane?: Lane;
+    /** A sequence message: the height of its row; it is drawn straight between lifelines there. */
+    row?: number;
+}
+export interface Scene {
+    model: Model;
+    title: string;
+    objects: SceneObject[];
+    byId: Map<string, SceneObject>;
+    edges: SceneEdge[];
+    diagnostics: Diagnostic[];
+    /** The file's resolved appearance: the spacing and type every size above was computed with. */
+    look: ResolvedAppearance;
+    /** Rulers and run-on pieces of byte and bit layouts, by group. */
+    cells: Map<string, CellsChrome>;
+    /** Sequence diagrams: the panel they are drawn on and their phases' row bands. */
+    sequence?: SequenceLayout;
+}
+type Size = {
+    w: number;
+    h: number;
+};
+type Pos = {
+    x: number;
+    y: number;
+};
+export declare function compile(source: string): Promise<Scene>;
+/**
+ * Check source synchronously: every error `compile` can report, without running layout engines
+ * (they never add errors). Engine-governed scopes keep their built-in recipe in the result.
+ */
+export declare function checkSource(source: string): Scene;
+/**
+ * The scene as layout sees it, for edits that write positions: soft and frameless groups left
+ * out, and each object under the container that lays it out, which its local position is
+ * relative to.
+ */
+export declare function layoutView(scene: Scene): Scene;
+/** How far a soft refinement may give way before `check` warns that it no longer holds. */
+export declare const RELAXED_WARNING = 16;
+/** Solver budget for engine recipes; the same budget Compare and the timeline use. */
+export declare const ENGINE_ITERATIONS = 640;
+/** A labelled edge between two siblings, with the room its label needs across and down a gap. */
+interface LabelRoom {
+    a: string;
+    b: string;
+    w: number;
+    h: number;
+}
+export declare function layoutFor(m: Model, scope: string): ModelLayout;
+/**
+ * Size of a node: its requested size, or the default width with a height that fits the title in
+ * the theme's type and padding. A requested size is kept exactly; `overflow` reports a title that
+ * no longer fits in it.
+ */
+export declare function leafSize(o: ModelObject, size: {
+    width: number;
+    height?: number;
+} | undefined, look: ResolvedAppearance): {
+    w: number;
+    h: number;
+    overflow: boolean;
+};
+/**
+ * Longest-path ranks, in declaration order. Cycles are broken first: a depth-first walk from the
+ * sources (then any node not yet reached), in declaration order, sets aside each edge that returns
+ * to a node still on the walk. A loop therefore keeps its path along the reading direction and
+ * only its return edge runs backwards.
+ */
+export declare function rankLayers(ids: string[], pairs: Array<[string, string]>): string[][];
+/** A folded run: each band's ids in reading order, and the axis the bands read along. */
+export interface Fold {
+    bands: string[][];
+    axis: 'right' | 'down';
+}
+/**
+ * Fold a long run of ranks into bands, like lines of text: each band starts again at the
+ * beginning of the reading direction, and the bands stack across it. A run that is longer than
+ * the render context and more than `FOLD_ASPECT` times its depth is cut only between ranks (where
+ * no box spans the cut), into the fewest bands that bring it within both. Within a quarter of an
+ * even share, a cut is chosen for the fewest edges across it, keeping each decision with its
+ * branches and each loop whole, before an exact balance. Other runs are returned unchanged.
+ *
+ * `plan` is the same run laid out without its edge labels. Whether to fold, how many bands and
+ * where to cut are decided on it, so relabelling an edge never adds a band or moves a cut: the
+ * labels only widen the gaps they need inside their own band.
+ */
+export declare function foldRanks(items: Array<{
+    id: string;
+    w: number;
+    h: number;
+}>, positions: Map<string, Pos>, axis: 'right' | 'down', gap: number, pairs: Array<[string, string]>, rooms?: LabelRoom[], decisions?: Set<string>, plan?: Map<string, Pos>, { aspect, fewest, room, }?: {
+    aspect?: number;
+    fewest?: number;
+    room?: number;
+}): {
+    positions: Map<string, Pos>;
+    fold?: Fold;
+};
+/** How many times orthogonal paths, given as points along and across, cross one another. */
+export declare function crossings(paths: Array<Array<{
+    u: number;
+    v: number;
+}>>): number;
+/** The order of up to six items that scores fewest crossings; the first such, from `items`. */
+export declare function fewestCrossings<T>(items: T[], score: (order: T[]) => number): T[];
+/**
+ * Lay out a model. `arranged` holds world positions from layout engines; scopes that an engine
+ * governs take their children's relative placement from it instead of their built-in recipe.
+ *
+ * Nodes are laid out on slots: their size in the reference appearance (the default theme, with
+ * the file's own overrides), so a theme switch keeps rows, order and positions. Each node is drawn
+ * at its theme's size in its slot. A slot grows only where the theme's size is larger
+ * than the scope's gap can absorb (`SLOT_SPILL`), or where spilling would bring two boxes closer
+ * than `MIN_GAP`. With `slots`, objects come out at their slot size (the engines' input).
+ */
+export declare function layoutModel(m: Model, arranged?: Map<string, Pos & Size>, slots?: boolean): Scene;

package/dist/types/src/dsl/frame.d.ts

@@ -0,0 +1,38 @@
+/** Group frame metrics shared by the compiler, the projection and the translator. */
+/** Space between a group's frame and its content, on the sides and bottom. */
+export declare const GROUP_INSET = 24;
+/**
+ * Space between a group's top edge and its content in the default theme; the title sits in it.
+ * Themes with taller titles reserve more (`ResolvedAppearance.groupHeader`).
+ */
+export declare const GROUP_HEADER = 48;
+/**
+ * Horizontal room a group title needs besides its text: the icon and gap before it (33) and the
+ * frame controls after it (64), as `GroupView` and the SVG export truncate titles.
+ */
+export declare const GROUP_TITLE_CHROME: number;
+/** Room a soft group's tint leaves round its members, and above them for its label. */
+export declare const SOFT_PAD = 10;
+export declare const SOFT_LABEL = 18;
+/** Where a soft group's label sits in its tint: in the annotation face, at the top left. */
+export declare const SOFT_TITLE: {
+    x: number;
+    y: number;
+};
+/** Corner radius of each rectangle of a tint; small, so joined rectangles read as one shape. */
+export declare const SOFT_RADIUS = 6;
+/** Dash of a sequence participant's lifeline; quieter than a message line. */
+export declare const LIFELINE: {
+    dash: string;
+    width: number;
+};
+/** Top-left of a group's content area, which its children's local positions are relative to. */
+export declare const contentOrigin: (group: {
+    x: number;
+    y: number;
+}, header?: number) => {
+    x: number;
+    y: number;
+};
+/** Horizontal room a `cells` group's title needs besides its text: padding and the collapse control. */
+export declare const CELLS_TITLE_CHROME: number;

package/dist/types/src/dsl/lanes.d.ts

@@ -0,0 +1,23 @@
+import type { Lane } from '../model/types';
+import type { ModelEdge } from './syntax';
+interface Box {
+    id: string;
+    type: string;
+    shape?: string;
+    parent: string;
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+}
+/** A scope arranged along a reading axis, with its fold's bands when it folded. */
+export interface FlowScope {
+    scope: string;
+    axis: 'right' | 'down';
+    bands?: string[][];
+}
+export declare function returnLanes(flows: FlowScope[], edges: ModelEdge[], byId: Map<string, Box>, taken: Set<string>, labelSize?: (label: string) => {
+    w: number;
+    h: number;
+}): Map<string, Lane>;
+export {};

package/dist/types/src/dsl/legend-notes.d.ts

@@ -0,0 +1,3 @@
+import type { Diagnostic } from './compile';
+import type { Model } from './syntax';
+export declare function legendNotes(m: Model): Diagnostic[];

package/dist/types/src/dsl/project.d.ts

@@ -0,0 +1,39 @@
+import type { Diagram, Rect } from '../model/types';
+import type { Scene } from './compile';
+/** Editor state that is not part of the source and survives a reprojection. */
+export type ViewState = Partial<Pick<Diagram, 'settings' | 'camera' | 'theme' | 'collapsed'>>;
+export declare function projectScene(scene: Scene, view?: ViewState): Diagram;
+export interface CanonicalGeometry {
+    nodes: Array<{
+        id: string;
+        parent: string;
+        x: number;
+        y: number;
+        w: number;
+        h: number;
+    }>;
+    routes: Array<{
+        id: string;
+        points: Array<{
+            x: number;
+            y: number;
+        }>;
+    }>;
+}
+/** Rectangles for everything visible, as the canvas draws them. */
+export declare function visibleRects(doc: Diagram): {
+    vg: import("../model/graph").VisibleGraph;
+    rects: Map<string, Rect>;
+};
+/**
+ * Node rectangles and route points for a projected document. Edge label positions are left out:
+ * the browser measures label text with real fonts, which Node cannot reproduce.
+ */
+export declare function canonicalGeometry(doc: Diagram): CanonicalGeometry;
+export declare function measured(doc: Diagram, rects: Map<string, Rect>, routes: Array<{
+    id: string;
+    points: Array<{
+        x: number;
+        y: number;
+    }>;
+}>): CanonicalGeometry;

package/dist/types/src/dsl/syntax.d.ts

@@ -0,0 +1,317 @@
+/**
+ * The `.draft` diagram language: a line-based source format that keeps comments, plus a model
+ * parser and a formatter. Adapted from the Meld 0.1 prototype in `reference/meld/original`.
+ *
+ * Source is kept as a list of lines so that edits can change single statements and formatting
+ * keeps every comment and unrelated statement.
+ */
+import { type DiagramAppearance, type Shade } from '../model/appearance';
+import { type EndMarker } from '../model/markers';
+import type { Status } from '../model/status';
+import type { ColorKey, LayoutAlgorithmId, LayoutSettings, PortSide, RoutingSettings, ShapeKind } from '../model/types';
+export declare class DslError extends Error {
+    readonly line: number;
+    readonly column: number;
+    constructor(message: string, line?: number, column?: number);
+}
+/** Change marks before `node`, `group` and `edge`, read like a diff, and the status each sets. */
+export declare const MARKS: {
+    readonly '+': "added";
+    readonly '-': "removed";
+    readonly '~': "changed";
+    readonly '.': "context";
+};
+export type Mark = keyof typeof MARKS;
+/** A word in a statement. Quoted words are strings; bare words are identifiers and numbers. */
+export interface Word {
+    value: string;
+    quoted: boolean;
+}
+export interface Statement {
+    kind: 'statement';
+    command: string;
+    /** Change mark written before the command, as in a diff: `+`, `-`, `~` or `.`. */
+    mark?: Mark;
+    args: Word[];
+    attrs: Array<[string, Word]>;
+    /** Inline comment including its `#` or `//` marker. */
+    comment?: string;
+    /** 1-based line in the source this statement was parsed from; 0 when added by an edit. */
+    line: number;
+}
+export type SourceLine = {
+    kind: 'blank';
+} | {
+    kind: 'comment';
+    text: string;
+} | Statement;
+export interface SourceDoc {
+    lines: SourceLine[];
+}
+export declare const bare: (value: string | number) => Word;
+export declare const quoted: (value: string) => Word;
+/**
+ * Split one line into raw tokens, each with its 1-based start column, and a trailing comment.
+ * Quoted tokens keep their quotes.
+ */
+export declare function tokenize(text: string, line?: number): {
+    tokens: string[];
+    columns: number[];
+    comment?: string;
+};
+/** Read source text into lines. Only lexical errors are reported here. */
+export declare function readSource(source: string): SourceDoc;
+export declare function printStatement(s: Statement): string;
+/**
+ * Print source consistently: one space between words, no indentation, at most one blank line in a
+ * row, and a final newline. Comments and statement order are kept.
+ */
+export declare function printSource(doc: SourceDoc): string;
+/** Format source text. Throws `DslError` for lexical errors; semantics are not checked. */
+export declare const formatSource: (source: string) => string;
+export type DslColor = ColorKey | 'auto';
+export type DslShape = Exclude<ShapeKind, 'icon' | 'image'>;
+/** `cells` lays a group's members edge to edge as one object: a sequence, table or byte layout. */
+export type Algorithm = 'flow' | 'row' | 'column' | 'lanes' | 'sequence' | 'cells';
+export interface ModelObject {
+    id: string;
+    type: 'node' | 'group';
+    label: string;
+    parent: string;
+    color: DslColor;
+    /** Explicit shade; omitted means the default for the object type. */
+    shade?: Shade;
+    shape: DslShape;
+    /** From a change mark; unchanged when omitted. */
+    status?: Status;
+    /** With `~`: the label before the change. */
+    was?: string;
+    /** With `~`, nodes only: the shape before the change. */
+    wasShape?: DslShape;
+    /** With `~`, nodes only: the count before the change; 1 means a single box. */
+    wasCount?: number | string;
+    /** A link to open from exported drawings, such as a source file or URL. */
+    href?: string;
+    /**
+     * Nodes only: how many things this one box stands for, drawn as a stack with a badge. A short
+     * symbol such as `N` or `many` stands for an unknown number.
+     */
+    count?: number | string;
+    /**
+     * Groups only: `soft` draws a tint behind the members and `none` draws nothing. Either way the
+     * group is not a layout scope: its members are laid out with the nearest framed container's.
+     */
+    frame?: 'soft' | 'none';
+    /** Groups only: `fold=never` keeps the group's chain in one column even when it is much the tallest. */
+    fold?: 'never';
+    /** Set by the compiler: the soft groups this object sits in below its layout scope, outermost first. */
+    soft?: string[];
+    /** Cells only: how many columns (or units) of its group's grid the cell covers; `var` for a
+     * field of variable length in a byte or bit layout. */
+    span?: number | 'var';
+    line: number;
+}
+export interface ModelEdge {
+    id: string;
+    source: string;
+    target: string;
+    label: string;
+    dashed: boolean;
+    from: PortSide;
+    to: PortSide;
+    /** From a change mark; unchanged when omitted. */
+    status?: Status;
+    /** With `~`: the label before the change. */
+    was?: string;
+    /** `directed=false`: an undirected connection, drawn without an arrowhead. */
+    directed?: false;
+    /** `head=`: the mark at the target end, when it isn't the plain arrow. */
+    head?: EndMarker;
+    /** `tail=`: the mark at the source end, when it has one. */
+    tail?: EndMarker;
+    /** `constraint=false`: drawn and routed, but layout doesn't rank or order by it. */
+    constraint?: false;
+    line: number;
+}
+/** A layout engine run cold over a scope's subtree; see `src/engines/layout-engine.js`. */
+export interface EngineRecipe {
+    algorithm: LayoutAlgorithmId;
+    params: Partial<LayoutSettings>;
+}
+/** Image shapes a drawing can aim for (`fit=`, `vary --fit`): width over height. */
+export declare const FITS: {
+    readonly wide: 2;
+    readonly slide: 1.78;
+    readonly square: 1;
+    readonly page: 0.77;
+    readonly tall: 0.6;
+};
+export type Fit = keyof typeof FITS;
+export interface ModelLayout {
+    scope: string;
+    algorithm: Algorithm;
+    /** Set when the scope is arranged by a layout engine instead of a built-in recipe. */
+    engine?: EngineRecipe;
+    direction: 'auto' | 'right' | 'down';
+    /** `cells` only: columns in each row of the grid; one row or column without it. */
+    columns?: number;
+    /** `cells` only: a byte or bit layout, where each column is one unit of the same width. */
+    unit?: 'bit' | 'byte';
+    /** With `unit`: the width of one unit, and whether unit numbers run above the first row. */
+    unitWidth?: number;
+    ruler?: boolean;
+    /** `flow` only: whether a long run of ranks folds into bands. Engines take `fold` as a param. */
+    fold: 'auto' | 'never';
+    /** Root only: the image shape to aim for; compile tries direction and folding to get closest. */
+    fit?: Fit;
+    gap: number;
+    minWidth: number;
+    minHeight: number;
+    line: number;
+}
+export type Hint = {
+    type: 'order';
+    scope: string;
+    ids: string[];
+    line: number;
+} | {
+    type: 'align';
+    axis: 'x' | 'y';
+    ids: string[];
+    strength: Strength;
+    line: number;
+} | {
+    type: 'near';
+    id: string;
+    ref: string;
+    side: NearSide;
+    gap: number;
+    offset: number;
+    strength: Strength;
+    line: number;
+} | {
+    type: 'nudge';
+    id: string;
+    dx: number;
+    dy: number;
+    line: number;
+} | {
+    type: 'stay';
+    id: string;
+    x: number;
+    y: number;
+    weight: number;
+    line: number;
+} | {
+    type: 'pin';
+    id: string;
+    x: number;
+    y: number;
+    line: number;
+}
+/** `height` is unset for `height=auto`: the title's height at that width, as without a size. */
+ | {
+    type: 'size';
+    id: string;
+    width: number;
+    height?: number;
+    line: number;
+};
+export type Strength = 'prefer' | 'required';
+/**
+ * What `near id ref` places against: `ref` itself when it is a sibling of `id`, else the group
+ * around `ref` that is `id`'s sibling. Undefined when `ref` is not inside one.
+ */
+export declare function nearAnchor(by: Map<string, ModelObject>, id: string, ref: string): string | undefined;
+export type NearSide = 'right' | 'left' | 'above' | 'below';
+export type HintType = Hint['type'];
+export declare const POSITION_HINTS: HintType[];
+export interface Model {
+    title: string;
+    objects: ModelObject[];
+    edges: ModelEdge[];
+    layouts: ModelLayout[];
+    hints: Hint[];
+    /** Router settings from a `routing` statement. */
+    routing: Partial<RoutingSettings>;
+    /** Theme, overrides and color definitions from `theme` and `theme-color` statements. */
+    appearance: DiagramAppearance;
+    /** Source line of the `theme` statement, and of each `theme-color` by `family:shade`. */
+    themeLine: number;
+    colorLines: Map<string, number>;
+    /** Source line of each `legend` entry, in order. */
+    legendLines: number[];
+    /** Source line of each `note`, in order. */
+    noteLines: number[];
+    /** Source line of each `footnote`, in order. */
+    footnoteLines: number[];
+    /** Source line of each ID an emphasis state lists, by `state:id`. */
+    stateLines: Map<string, number>;
+    /** Sequence diagrams: `phase` statements, each a run of messages drawn as a row band. */
+    phases: Array<{
+        id: string;
+        label: string;
+        ids: string[];
+        line: number;
+    }>;
+    /** Sequence diagrams: the `was-order` statement, the older version's message order. */
+    wasOrder?: {
+        ids: string[];
+        line: number;
+    };
+    /** Problems that do not stop the file from drawing, such as a `config` key set twice. */
+    warnings: {
+        code: string;
+        message: string;
+        line: number;
+    }[];
+}
+/** `config` keys and the setting each sets. */
+export declare const CONFIG_KEYS: {
+    readonly 'link-base': "linkBase";
+    readonly editor: "editor";
+    readonly 'strike-removed': "strikeRemoved";
+};
+/** Theme attributes in the file and the override each sets. */
+export declare const THEME_ATTRS: {
+    readonly 'padding-x': "paddingX";
+    readonly 'padding-y': "paddingY";
+    readonly radius: "radius";
+    readonly 'title-font': "titleFont";
+    readonly 'annotation-font': "annotationFont";
+    readonly canvas: "canvas";
+    readonly text: "text";
+    readonly connection: "connection";
+};
+type Param<K extends string> = {
+    key: K;
+    min: number;
+    max: number;
+} | {
+    key: K;
+    choices: readonly string[];
+};
+/**
+ * Layout engines a file can name. `separate` is left out: it only repairs overlaps in the current
+ * drawing, so it cannot be recomputed from the source.
+ */
+export declare const ENGINES: readonly LayoutAlgorithmId[];
+/** Engine settings by source attribute. Ranges match the engine's own limits. */
+export declare const ENGINE_PARAMS: Record<string, Param<keyof LayoutSettings>>;
+/** Router settings by source attribute. Ranges match the router's own limits. */
+export declare const ROUTING_PARAMS: Record<string, Param<keyof RoutingSettings>>;
+/** Source attribute for an engine or router setting. */
+export declare const paramAttr: (table: Record<string, Param<string>>, key: string) => string | undefined;
+export declare const isIdentifier: (s: string) => boolean;
+export declare const COLORS: DslColor[];
+export declare const DSL_SHAPES: DslShape[];
+/** Shapes a node's box can draw as it was: a marker's box is a thin cut, so it has no other shape. */
+export declare const PAST_SHAPES: ("box" | "text" | "pill" | "circle" | "diamond")[];
+/** Parse and validate source. Throws `DslError` with a line number for the first problem. */
+export declare function parseModel(source: string | SourceDoc): Model;
+/**
+ * The container that lays an object out: its parent, or the nearest framed container above it
+ * when its parent is a soft or frameless group. Soft groups are never layout scopes.
+ */
+export declare function layoutParent(by: Map<string, ModelObject>, id: string): string;
+export {};