@adecore/diagram 0.0.1 → 0.17.0-beta.1

package/dist/order.js

@@ -0,0 +1,224 @@
+import { bandCode, bandOfCode } from './graph.js';
+/* Sweeps of the barycenter heuristic, alternating down and up; the best order any of them reached is kept. */
+const SWEEPS = 12;
+/*
+ * The order inside every layer, in place. A unit moves to the average position of the units it is
+ * joined to in the layer it was compared with, a tie keeps the order it had (file order to begin
+ * with), and the members of a group stay together as one block. The blocks of groups keep one order
+ * in every layer, and a unit that is not in a group stays on the same side of a group from one layer
+ * to the next inside it, so no hop has to cross a group it does not belong to.
+ */
+export function orderLayers(layering) {
+    const { units, hops, bands, items } = layering;
+    const position = new Array(units.length).fill(0);
+    const bandPosition = bands.map((band) => new Array(band.last - band.first + 1).fill(0));
+    const hopsByLayer = items.map(() => []);
+    hops.forEach((hop, index) => {
+        hopsByLayer[units[hop.from].layer].push(index);
+    });
+    const flatten = (layer) => {
+        let at = 0;
+        for (const code of items[layer]) {
+            if (code >= 0) {
+                position[code] = at++;
+                continue;
+            }
+            const band = bands[bandOfCode(code)];
+            const members = band.members[layer - band.first];
+            bandPosition[bandOfCode(code)][layer - band.first] = at;
+            if (members.length === 0) {
+                at++;
+            }
+            for (const member of members) {
+                position[member] = at++;
+            }
+        }
+    };
+    const enforceBandOrder = (layer) => {
+        const row = items[layer];
+        const slots = [];
+        const present = [];
+        row.forEach((code, index) => {
+            if (code < 0) {
+                slots.push(index);
+                present.push(bandOfCode(code));
+            }
+        });
+        present.sort((left, right) => bands[left].rank - bands[right].rank);
+        slots.forEach((slot, index) => {
+            row[slot] = bandCode(present[index]);
+        });
+    };
+    const sortLayer = (layer, towardsUp) => {
+        const keyOf = (unit) => {
+            const neighbors = towardsUp ? units[unit].up : units[unit].down;
+            if (neighbors.length === 0) {
+                return position[unit];
+            }
+            let sum = 0;
+            for (const neighbor of neighbors) {
+                sum += position[neighbor];
+            }
+            return sum / neighbors.length;
+        };
+        const keyed = items[layer].map((code, index) => {
+            if (code >= 0) {
+                return { code, index, key: keyOf(code) };
+            }
+            const band = bands[bandOfCode(code)];
+            const slot = layer - band.first;
+            const members = band.members[slot].map((unit) => ({ unit, key: keyOf(unit), at: position[unit] }));
+            members.sort((left, right) => left.key - right.key || left.at - right.at);
+            band.members[slot] = members.map((member) => member.unit);
+            const key = members.length > 0 ? members.reduce((sum, member) => sum + member.key, 0) / members.length : bandPosition[bandOfCode(code)][slot];
+            return { code, index, key };
+        });
+        keyed.sort((left, right) => left.key - right.key || left.index - right.index);
+        items[layer] = keyed.map((entry) => entry.code);
+        enforceBandOrder(layer);
+        flatten(layer);
+    };
+    const updateRanks = () => {
+        const scores = bands.map((band, index) => {
+            let sum = 0;
+            for (let layer = band.first; layer <= band.last; layer++) {
+                const row = items[layer];
+                sum += row.indexOf(bandCode(index)) / row.length;
+            }
+            return sum / (band.last - band.first + 1);
+        });
+        const order = bands.map((_, index) => index).sort((left, right) => scores[left] - scores[right] || bands[left].rank - bands[right].rank);
+        order.forEach((band, rank) => {
+            bands[band].rank = rank;
+        });
+    };
+    // A free unit takes the side of every group its neighbors are on, as far as they agree.
+    const keepSides = () => {
+        for (let layer = 0; layer < items.length; layer++) {
+            if (!items[layer].some((code) => code < 0)) {
+                continue;
+            }
+            const previousIndex = new Map();
+            (items[layer - 1] ?? []).forEach((code, index) => previousIndex.set(code, index));
+            const free = items[layer].filter((code) => code >= 0);
+            for (const unit of free) {
+                const row = items[layer];
+                const present = row.filter((code) => code < 0).map(bandOfCode);
+                let lower = 0;
+                let upper = present.length;
+                const narrow = (source, sourceLayer) => {
+                    let low = 0;
+                    let high = present.length;
+                    present.forEach((band, slot) => {
+                        const target = bands[band];
+                        const sourceBand = units[source].band;
+                        if (sourceLayer < target.first || sourceLayer > target.last || sourceBand === band) {
+                            return;
+                        }
+                        const before = sourceBand >= 0 ? bands[sourceBand].rank < target.rank : previousIndex.get(source) < previousIndex.get(bandCode(band));
+                        if (before) {
+                            high = Math.min(high, slot);
+                        }
+                        else {
+                            low = Math.max(low, slot + 1);
+                        }
+                    });
+                    if (Math.max(lower, low) <= Math.min(upper, high)) {
+                        lower = Math.max(lower, low);
+                        upper = Math.min(upper, high);
+                    }
+                };
+                for (const source of units[unit].up) {
+                    narrow(source, layer - 1);
+                }
+                // A member of a group in the next layer cannot move, so the free unit follows it instead.
+                for (const target of units[unit].down) {
+                    if (units[target].band >= 0) {
+                        narrow(target, layer + 1);
+                    }
+                }
+                const at = row.indexOf(unit);
+                const slot = row.slice(0, at).filter((code) => code < 0).length;
+                if (slot < lower) {
+                    row.splice(at, 1);
+                    row.splice(row.indexOf(bandCode(present[lower - 1])) + 1, 0, unit);
+                }
+                else if (slot > upper) {
+                    row.splice(at, 1);
+                    row.splice(row.indexOf(bandCode(present[upper])), 0, unit);
+                }
+            }
+        }
+    };
+    const crossings = () => {
+        let total = 0;
+        for (let layer = 0; layer + 1 < items.length; layer++) {
+            const pairs = hopsByLayer[layer].map((index) => [position[hops[index].from], position[hops[index].to]]);
+            if (pairs.length < 2) {
+                continue;
+            }
+            pairs.sort((left, right) => left[0] - right[0] || left[1] - right[1]);
+            // A Fenwick tree over the positions of the next layer counts the pairs that come in out of order.
+            const size = pairs.reduce((largest, pair) => Math.max(largest, pair[1]), 0) + 2;
+            const tree = new Array(size + 1).fill(0);
+            pairs.forEach(([, to], seen) => {
+                let atMost = 0;
+                for (let i = to + 1; i > 0; i -= i & -i) {
+                    atMost += tree[i];
+                }
+                total += seen - atMost;
+                for (let i = to + 1; i <= size; i += i & -i) {
+                    tree[i] += 1;
+                }
+            });
+        }
+        return total;
+    };
+    const settle = () => {
+        items.forEach((_, layer) => enforceBandOrder(layer));
+        keepSides();
+        items.forEach((_, layer) => flatten(layer));
+        return crossings();
+    };
+    const snapshot = () => ({
+        items: items.map((row) => row.slice()),
+        members: bands.map((band) => band.members.map((slot) => slot.slice())),
+        ranks: bands.map((band) => band.rank)
+    });
+    items.forEach((_, layer) => flatten(layer));
+    // A band's first layer always holds a member, which is what made it the first.
+    const firstSeen = bands.map((band, index) => [band.first, position[band.members[0][0]], index]);
+    firstSeen
+        .slice()
+        .sort((left, right) => left[0] - right[0] || left[1] - right[1] || left[2] - right[2])
+        .forEach(([, , band], rank) => {
+        bands[band].rank = rank;
+    });
+    let bestCount = settle();
+    let best = snapshot();
+    for (let sweep = 0; sweep < SWEEPS && bestCount > 0; sweep++) {
+        if (sweep % 2 === 0) {
+            for (let layer = 1; layer < items.length; layer++) {
+                sortLayer(layer, true);
+            }
+        }
+        else {
+            for (let layer = items.length - 2; layer >= 0; layer--) {
+                sortLayer(layer, false);
+            }
+        }
+        updateRanks();
+        const count = settle();
+        if (count < bestCount) {
+            bestCount = count;
+            best = snapshot();
+        }
+    }
+    best.items.forEach((row, layer) => {
+        items[layer] = row;
+    });
+    bands.forEach((band, index) => {
+        band.members = best.members[index];
+        band.rank = best.ranks[index];
+    });
+}

package/dist/protocol.d.ts

@@ -0,0 +1,254 @@
+import { z } from 'zod';
+export declare const DiagramShapeSchema: z.ZodEnum<{
+    cylinder: "cylinder";
+    diamond: "diamond";
+    pill: "pill";
+    rect: "rect";
+    round: "round";
+}>;
+export type DiagramShape = z.infer<typeof DiagramShapeSchema>;
+export declare const DIAGRAM_SHAPES: ("cylinder" | "diamond" | "pill" | "rect" | "round")[];
+export declare const DiagramDirectionSchema: z.ZodEnum<{
+    down: "down";
+    right: "right";
+}>;
+export type DiagramDirection = z.infer<typeof DiagramDirectionSchema>;
+export declare const DiagramEdgeStyleSchema: z.ZodEnum<{
+    dashed: "dashed";
+    dotted: "dotted";
+    solid: "solid";
+}>;
+export type DiagramEdgeStyle = z.infer<typeof DiagramEdgeStyleSchema>;
+export declare const DiagramNodeSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    sub: z.ZodOptional<z.ZodString>;
+    shape: z.ZodOptional<z.ZodEnum<{
+        cylinder: "cylinder";
+        diamond: "diamond";
+        pill: "pill";
+        rect: "rect";
+        round: "round";
+    }>>;
+    tone: z.ZodOptional<z.ZodEnum<{
+        accent: "accent";
+        blue: "blue";
+        green: "green";
+        ink: "ink";
+        muted: "muted";
+        orange: "orange";
+        pink: "pink";
+        purple: "purple";
+        red: "red";
+        yellow: "yellow";
+    }>>;
+    pos: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+}, z.core.$strip>;
+export type DiagramNode = z.infer<typeof DiagramNodeSchema>;
+export declare const DiagramGroupSchema: z.ZodObject<{
+    id: z.ZodString;
+    label: z.ZodString;
+    wraps: z.ZodArray<z.ZodString>;
+    tone: z.ZodOptional<z.ZodEnum<{
+        accent: "accent";
+        blue: "blue";
+        green: "green";
+        ink: "ink";
+        muted: "muted";
+        orange: "orange";
+        pink: "pink";
+        purple: "purple";
+        red: "red";
+        yellow: "yellow";
+    }>>;
+}, z.core.$strip>;
+export type DiagramGroup = z.infer<typeof DiagramGroupSchema>;
+export declare const DiagramEdgeSchema: z.ZodObject<{
+    from: z.ZodString;
+    to: z.ZodString;
+    label: z.ZodOptional<z.ZodString>;
+    style: z.ZodOptional<z.ZodEnum<{
+        dashed: "dashed";
+        dotted: "dotted";
+        solid: "solid";
+    }>>;
+    tone: z.ZodOptional<z.ZodEnum<{
+        accent: "accent";
+        blue: "blue";
+        green: "green";
+        ink: "ink";
+        muted: "muted";
+        orange: "orange";
+        pink: "pink";
+        purple: "purple";
+        red: "red";
+        yellow: "yellow";
+    }>>;
+}, z.core.$strip>;
+export type DiagramEdge = z.infer<typeof DiagramEdgeSchema>;
+export declare const DiagramMetaSchema: z.ZodObject<{
+    title: z.ZodString;
+    direction: z.ZodEnum<{
+        down: "down";
+        right: "right";
+    }>;
+}, z.core.$strip>;
+export type DiagramMeta = z.infer<typeof DiagramMetaSchema>;
+export declare const DIAGRAM_VERSION = 1;
+export declare const DIAGRAM_LIMITS: {
+    nodes: number;
+    edges: number;
+};
+export declare const DiagramContentSchema: z.ZodObject<{
+    meta: z.ZodObject<{
+        title: z.ZodString;
+        direction: z.ZodEnum<{
+            down: "down";
+            right: "right";
+        }>;
+    }, z.core.$strip>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        sub: z.ZodOptional<z.ZodString>;
+        shape: z.ZodOptional<z.ZodEnum<{
+            cylinder: "cylinder";
+            diamond: "diamond";
+            pill: "pill";
+            rect: "rect";
+            round: "round";
+        }>>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            accent: "accent";
+            blue: "blue";
+            green: "green";
+            ink: "ink";
+            muted: "muted";
+            orange: "orange";
+            pink: "pink";
+            purple: "purple";
+            red: "red";
+            yellow: "yellow";
+        }>>;
+        pos: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strip>>;
+    groups: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        wraps: z.ZodArray<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            accent: "accent";
+            blue: "blue";
+            green: "green";
+            ink: "ink";
+            muted: "muted";
+            orange: "orange";
+            pink: "pink";
+            purple: "purple";
+            red: "red";
+            yellow: "yellow";
+        }>>;
+    }, z.core.$strip>>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        style: z.ZodOptional<z.ZodEnum<{
+            dashed: "dashed";
+            dotted: "dotted";
+            solid: "solid";
+        }>>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            accent: "accent";
+            blue: "blue";
+            green: "green";
+            ink: "ink";
+            muted: "muted";
+            orange: "orange";
+            pink: "pink";
+            purple: "purple";
+            red: "red";
+            yellow: "yellow";
+        }>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export type DiagramContent = z.infer<typeof DiagramContentSchema>;
+export declare const DiagramDocumentSchema: z.ZodObject<{
+    meta: z.ZodObject<{
+        title: z.ZodString;
+        direction: z.ZodEnum<{
+            down: "down";
+            right: "right";
+        }>;
+    }, z.core.$strip>;
+    nodes: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        sub: z.ZodOptional<z.ZodString>;
+        shape: z.ZodOptional<z.ZodEnum<{
+            cylinder: "cylinder";
+            diamond: "diamond";
+            pill: "pill";
+            rect: "rect";
+            round: "round";
+        }>>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            accent: "accent";
+            blue: "blue";
+            green: "green";
+            ink: "ink";
+            muted: "muted";
+            orange: "orange";
+            pink: "pink";
+            purple: "purple";
+            red: "red";
+            yellow: "yellow";
+        }>>;
+        pos: z.ZodOptional<z.ZodTuple<[z.ZodNumber, z.ZodNumber], null>>;
+    }, z.core.$strip>>;
+    groups: z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        label: z.ZodString;
+        wraps: z.ZodArray<z.ZodString>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            accent: "accent";
+            blue: "blue";
+            green: "green";
+            ink: "ink";
+            muted: "muted";
+            orange: "orange";
+            pink: "pink";
+            purple: "purple";
+            red: "red";
+            yellow: "yellow";
+        }>>;
+    }, z.core.$strip>>;
+    edges: z.ZodArray<z.ZodObject<{
+        from: z.ZodString;
+        to: z.ZodString;
+        label: z.ZodOptional<z.ZodString>;
+        style: z.ZodOptional<z.ZodEnum<{
+            dashed: "dashed";
+            dotted: "dotted";
+            solid: "solid";
+        }>>;
+        tone: z.ZodOptional<z.ZodEnum<{
+            accent: "accent";
+            blue: "blue";
+            green: "green";
+            ink: "ink";
+            muted: "muted";
+            orange: "orange";
+            pink: "pink";
+            purple: "purple";
+            red: "red";
+            yellow: "yellow";
+        }>>;
+    }, z.core.$strip>>;
+    version: z.ZodLiteral<1>;
+    rev: z.ZodNumber;
+}, z.core.$strip>;
+export type DiagramDocument = z.infer<typeof DiagramDocumentSchema>;
+export declare const EMPTY_DIAGRAM: DiagramDocument;
+export declare function migrateDiagram(value: unknown): DiagramDocument | null;
+export declare function diagramProblemIn(content: Pick<DiagramContent, 'nodes' | 'groups' | 'edges'>): string | null;

package/dist/protocol.js

@@ -0,0 +1,111 @@
+import { z } from 'zod';
+import { DrawingColorSchema, DrawingStrokeStyleSchema } from '@adecore/drawing/protocol';
+/*
+ * A diagram is a directed graph with groups, written rather than drawn: the file says what is
+ * connected to what and the layout is computed from that. Colors are the drawing palette's names,
+ * so a diagram follows the theme the way a drawing does.
+ */
+export const DiagramShapeSchema = z.enum(['rect', 'round', 'pill', 'diamond', 'cylinder']);
+export const DIAGRAM_SHAPES = DiagramShapeSchema.options;
+export const DiagramDirectionSchema = z.enum(['right', 'down']);
+export const DiagramEdgeStyleSchema = DrawingStrokeStyleSchema;
+export const DiagramNodeSchema = z.object({
+    id: z.string().min(1),
+    label: z.string(),
+    sub: z.string().optional(),
+    // Absent reads as 'rect'.
+    shape: DiagramShapeSchema.optional(),
+    tone: DrawingColorSchema.optional(),
+    // Only on a node a person dragged; every other node goes where the layout puts it.
+    pos: z.tuple([z.number(), z.number()]).optional()
+});
+export const DiagramGroupSchema = z.object({
+    id: z.string().min(1),
+    label: z.string(),
+    // Node ids, never group ids: a group is a box around nodes and does not nest.
+    wraps: z.array(z.string().min(1)),
+    tone: DrawingColorSchema.optional()
+});
+export const DiagramEdgeSchema = z.object({
+    from: z.string().min(1),
+    to: z.string().min(1),
+    label: z.string().optional(),
+    // Absent reads as 'solid'.
+    style: DiagramEdgeStyleSchema.optional(),
+    tone: DrawingColorSchema.optional()
+});
+export const DiagramMetaSchema = z.object({
+    title: z.string(),
+    direction: DiagramDirectionSchema
+});
+export const DIAGRAM_VERSION = 1;
+// Edges spanning many layers make layout costs grow quickly, so validation caps graph size.
+export const DIAGRAM_LIMITS = {
+    nodes: 100,
+    edges: 120
+};
+export const DiagramContentSchema = z.object({
+    meta: DiagramMetaSchema,
+    // In file order, which is also the order inside a layer of the layout.
+    nodes: z.array(DiagramNodeSchema),
+    groups: z.array(DiagramGroupSchema),
+    edges: z.array(DiagramEdgeSchema)
+});
+export const DiagramDocumentSchema = DiagramContentSchema.extend({
+    version: z.literal(DIAGRAM_VERSION),
+    // Goes up by one on every write; a save that names an older rev is a conflict.
+    rev: z.number().int().nonnegative()
+});
+export const EMPTY_DIAGRAM = { version: 1, rev: 0, meta: { title: '', direction: 'right' }, nodes: [], groups: [], edges: [] };
+/* One version so far, so reading is a parse. A file that is not a diagram at all reads as null. */
+export function migrateDiagram(value) {
+    const parsed = DiagramDocumentSchema.safeParse(value);
+    return parsed.success ? parsed.data : null;
+}
+/*
+ * The first rule of the graph the content breaks, as a sentence that names the id, or null. The
+ * schema cannot say this, and an agent that wrote the file needs the id to repair it: a silent drop
+ * would leave it believing the edge is there.
+ */
+export function diagramProblemIn(content) {
+    if (content.nodes.length > DIAGRAM_LIMITS.nodes) {
+        return `A diagram holds at most ${DIAGRAM_LIMITS.nodes} nodes, and this one has ${content.nodes.length}`;
+    }
+    if (content.edges.length > DIAGRAM_LIMITS.edges) {
+        return `A diagram holds at most ${DIAGRAM_LIMITS.edges} edges, and this one has ${content.edges.length}`;
+    }
+    // Nodes and groups share one namespace, so an id always says which box it means.
+    const nodes = new Set();
+    for (const node of content.nodes) {
+        if (nodes.has(node.id)) {
+            return `Two nodes share the id "${node.id}"`;
+        }
+        nodes.add(node.id);
+    }
+    const groups = new Set();
+    const groupOf = new Map();
+    for (const group of content.groups) {
+        if (nodes.has(group.id) || groups.has(group.id)) {
+            return `The group id "${group.id}" is already taken`;
+        }
+        groups.add(group.id);
+        for (const id of group.wraps) {
+            if (!nodes.has(id)) {
+                return `The group "${group.id}" wraps "${id}", which is not a node`;
+            }
+            const other = groupOf.get(id);
+            if (other !== undefined) {
+                return `The node "${id}" is in two groups, "${other}" and "${group.id}"`;
+            }
+            groupOf.set(id, group.id);
+        }
+    }
+    for (const edge of content.edges) {
+        for (const end of [edge.from, edge.to]) {
+            if (!nodes.has(end)) {
+                return `The edge from "${edge.from}" to "${edge.to}" names "${end}", which is not a node`;
+            }
+        }
+    }
+    return null;
+}

package/dist/reading-order.d.ts

@@ -0,0 +1,2 @@
+import type { DiagramDocument } from './protocol.ts';
+export declare function readingOrder(document: Pick<DiagramDocument, 'nodes' | 'groups' | 'edges'>): string[];

package/dist/reading-order.js

@@ -0,0 +1,23 @@
+import { layersOf } from './layout.js';
+function nameOf(node, id) {
+    return node && node.label.trim() !== '' ? node.label : id;
+}
+/*
+ * A diagram as lines an agent can read: every node layer by layer (file order inside a layer), then
+ * every edge as the two names it joins, then what each group holds. Unlike a drawing nothing has to
+ * be guessed, since the file already says what points at what.
+ */
+export function readingOrder(document) {
+    const byId = new Map(document.nodes.map((node) => [node.id, node]));
+    const layers = layersOf(document.nodes, document.edges);
+    const nodes = document.nodes
+        .map((node, index) => ({ node, index, layer: layers.get(node.id) ?? 0 }))
+        .sort((left, right) => left.layer - right.layer || left.index - right.index)
+        .map(({ node }) => (node.sub ? `${nameOf(node, node.id)} (${node.sub})` : nameOf(node, node.id)));
+    const edges = document.edges.map((edge) => {
+        const line = `${nameOf(byId.get(edge.from), edge.from)} -> ${nameOf(byId.get(edge.to), edge.to)}`;
+        return edge.label ? `${line}: ${edge.label}` : line;
+    });
+    const groups = document.groups.map((group) => `${group.label || group.id} wraps: ${group.wraps.map((id) => nameOf(byId.get(id), id)).join(', ')}`);
+    return [...nodes, ...edges, ...groups];
+}

package/dist/route.d.ts

@@ -0,0 +1,33 @@
+import type { Point, Rect } from './layout.ts';
+export declare const TRACK_GAP = 12;
+export declare const MIN_CHANNEL = 64;
+export interface ChannelHop {
+    hop: number;
+    ya: number;
+    yb: number;
+}
+export interface ChannelLabel {
+    edge: number;
+    hop: number;
+    y: number;
+    along: number;
+    across: number;
+}
+export interface ChannelInput {
+    start: number;
+    clearBefore: number;
+    clearAfter: number;
+    hops: ChannelHop[];
+    labels: ChannelLabel[];
+    obstacles: {
+        y: number;
+        h: number;
+    }[];
+}
+export interface ChannelResult {
+    width: number;
+    trackX: Map<number, number>;
+    labels: Map<number, Rect>;
+}
+export declare function conflictsOf(left: readonly Point[], right: readonly Point[]): number;
+export declare function routeChannel(input: ChannelInput): ChannelResult;