@fazelstudio/floe 1.0.0

package/dist/src/layout/simple.js

@@ -0,0 +1,674 @@
+const DEFAULT_OPTS = {
+    nodeWidth: 120,
+    nodeHeight: 48,
+    rankSep: 80,
+    nodeSep: 32,
+    margin: 32,
+    minNodeWidth: 80,
+    maxNodeWidth: 200,
+};
+/**
+ * Deterministic, zero-dependency layered layout.
+ * - No random, no timestamps, no nondeterministic ordering
+ * - Supports TB, BT, LR, RL via coordinate transform
+ * - Handles cycles via bounded relaxation
+ */
+export class SimpleLayoutEngine {
+    opts;
+    constructor(opts) {
+        this.opts = { ...DEFAULT_OPTS, ...opts };
+    }
+    layout(diagram) {
+        // Empty diagram: minimal SVG size, deterministic (include groups empty)
+        if (diagram.nodes.length === 0 && (diagram.groups?.length ?? 0) === 0) {
+            return {
+                diagram,
+                direction: diagram.direction,
+                nodes: [],
+                edges: [],
+                groups: [],
+                width: this.opts.margin * 2 + 100,
+                height: this.opts.margin * 2 + 60,
+            };
+        }
+        // Include isolated groups handling: even if nodes empty but groups with members? But members are nodes, so nodes empty => groups empty too fallback.
+        // Deterministic node ordering: sort by id for rank grouping stability,
+        // but preserve original rank discovery order? We sort copy for processing.
+        const nodesById = new Map();
+        for (const n of diagram.nodes)
+            nodesById.set(n.id, n);
+        // Deterministic edge ordering: sort by source, target, label
+        const edgesSorted = [...diagram.edges].sort((a, b) => {
+            if (a.source !== b.source)
+                return a.source.localeCompare(b.source);
+            if (a.target !== b.target)
+                return a.target.localeCompare(b.target);
+            return (a.label ?? "").localeCompare(b.label ?? "");
+        });
+        // Compute node sizes deterministically based on label length
+        const nodeSizes = new Map();
+        for (const n of diagram.nodes) {
+            const label = n.label ?? n.id;
+            const size = estimateNodeSize(label, n.type, this.opts);
+            nodeSizes.set(n.id, size);
+        }
+        // ---- Rank assignment (longest path layering, deterministic) ----
+        const ranks = this.computeRanks(diagram.nodes, edgesSorted);
+        // Group by rank
+        const rankGroups = new Map();
+        for (const [id, rank] of ranks.entries()) {
+            const arr = rankGroups.get(rank) ?? [];
+            arr.push(id);
+            rankGroups.set(rank, arr);
+        }
+        // Sort ranks ascending
+        const sortedRanks = Array.from(rankGroups.keys()).sort((a, b) => a - b);
+        // Within each rank, sort ids alphabetically for determinism (stable)
+        for (const r of sortedRanks) {
+            rankGroups.get(r).sort((a, b) => a.localeCompare(b));
+        }
+        // ---- Coordinate assignment ----
+        // We first compute TB layout, then transform for other directions
+        const tbPositions = this.assignTbPositions(rankGroups, sortedRanks, nodeSizes);
+        // Transform for direction
+        const positioned = this.applyDirection(tbPositions, diagram.direction, nodeSizes);
+        // Build LayoutNodes
+        const layoutNodes = diagram.nodes
+            .slice()
+            .sort((a, b) => a.id.localeCompare(b.id))
+            .map((n) => {
+            const p = positioned.get(n.id);
+            const sz = nodeSizes.get(n.id);
+            return {
+                id: n.id,
+                label: n.label ?? n.id,
+                type: n.type,
+                x: p.x,
+                y: p.y,
+                width: sz.w,
+                height: sz.h,
+                data: n,
+            };
+        });
+        // For deterministic output, sort layoutNodes by id (already)
+        // Need width/height: compute bounds
+        let width;
+        let height;
+        if (positioned.size === 0) {
+            width = this.opts.margin * 2 + 100;
+            height = this.opts.margin * 2 + 60;
+        }
+        else {
+            // Compute max extents from positioned nodes
+            let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+            for (const [id, pos] of positioned.entries()) {
+                const sz = nodeSizes.get(id);
+                const left = pos.x - sz.w / 2;
+                const right = pos.x + sz.w / 2;
+                const top = pos.y - sz.h / 2;
+                const bottom = pos.y + sz.h / 2;
+                if (left < minX)
+                    minX = left;
+                if (right > maxX)
+                    maxX = right;
+                if (top < minY)
+                    minY = top;
+                if (bottom > maxY)
+                    maxY = bottom;
+            }
+            width = maxX + this.opts.margin;
+            height = maxY + this.opts.margin;
+            // Also account for min if not at margin (should be margin due to assignment, but ensure >=)
+            // Our positions already start at margin + w/2, so minX >= margin.
+            // Ensure deterministic rounding
+            width = Math.ceil(width);
+            height = Math.ceil(height);
+            // Ensure minimal size
+            if (width < this.opts.margin * 2 + 100)
+                width = this.opts.margin * 2 + 100;
+            if (height < this.opts.margin * 2 + 60)
+                height = this.opts.margin * 2 + 60;
+        }
+        // Build LayoutEdges with points
+        const nodePosMap = positioned;
+        const layoutEdges = edgesSorted.map((e) => {
+            const srcPos = nodePosMap.get(e.source);
+            const tgtPos = nodePosMap.get(e.target);
+            // Fallback if missing (should not happen, but handle deterministically)
+            if (!srcPos || !tgtPos) {
+                return {
+                    source: e.source,
+                    target: e.target,
+                    label: e.label,
+                    points: [
+                        { x: 0, y: 0 },
+                        { x: 0, y: 0 },
+                    ],
+                    data: e,
+                };
+            }
+            const srcSize = nodeSizes.get(e.source);
+            const tgtSize = nodeSizes.get(e.target);
+            const points = this.computeEdgePoints({ x: srcPos.x, y: srcPos.y, w: srcSize.w, h: srcSize.h }, { x: tgtPos.x, y: tgtPos.y, w: tgtSize.w, h: tgtSize.h }, diagram.direction, srcPos, tgtPos);
+            // label position: midpoint of polyline
+            let labelPos;
+            if (e.label) {
+                labelPos = this.computeLabelPos(points);
+            }
+            return {
+                source: e.source,
+                target: e.target,
+                label: e.label,
+                points,
+                labelPos,
+                data: e,
+            };
+        });
+        // Sort layoutEdges already sorted
+        // ---- Compute group layouts ----
+        const layoutGroups = this.computeGroups(diagram.groups ?? [], positioned, nodeSizes);
+        // Expand width/height to include groups if needed
+        let finalWidth = width;
+        let finalHeight = height;
+        for (const lg of layoutGroups) {
+            // flatten recursively
+            const all = flattenGroups([lg]);
+            for (const g of all) {
+                const right = g.x + g.width / 2;
+                const bottom = g.y + g.height / 2;
+                if (right + this.opts.margin > finalWidth)
+                    finalWidth = Math.ceil(right + this.opts.margin);
+                if (bottom + this.opts.margin > finalHeight)
+                    finalHeight = Math.ceil(bottom + this.opts.margin);
+            }
+        }
+        return {
+            diagram,
+            direction: diagram.direction,
+            nodes: layoutNodes,
+            edges: layoutEdges,
+            groups: layoutGroups,
+            width: finalWidth,
+            height: finalHeight,
+        };
+    }
+    computeRanks(nodes, edges) {
+        const ranks = new Map();
+        for (const n of nodes)
+            ranks.set(n.id, 0);
+        // Build indegree and adjacency for Kahn's topological layering (deterministic)
+        const indeg = new Map();
+        const adj = new Map();
+        for (const n of nodes) {
+            indeg.set(n.id, 0);
+            adj.set(n.id, []);
+        }
+        // Sort edges deterministically before building graph
+        const sortedEdges = [...edges].sort((a, b) => {
+            if (a.source !== b.source)
+                return a.source.localeCompare(b.source);
+            if (a.target !== b.target)
+                return a.target.localeCompare(b.target);
+            return (a.label ?? "").localeCompare(b.label ?? "");
+        });
+        for (const e of sortedEdges) {
+            // Only count edges where both nodes exist (should be all)
+            if (!indeg.has(e.target) || !adj.has(e.source))
+                continue;
+            indeg.set(e.target, (indeg.get(e.target) ?? 0) + 1);
+            adj.get(e.source).push(e.target);
+        }
+        // Sort adjacency lists for determinism
+        for (const list of adj.values())
+            list.sort((a, b) => a.localeCompare(b));
+        // Queue with indegree 0, sorted alphabetically
+        const queue = [];
+        for (const [id, d] of indeg.entries())
+            if (d === 0)
+                queue.push(id);
+        queue.sort((a, b) => a.localeCompare(b));
+        const processed = new Set();
+        while (queue.length > 0) {
+            // Deterministic: always take smallest alphabetically
+            // Since we keep queue sorted after each insertion, shift gives deterministic order
+            const u = queue.shift();
+            processed.add(u);
+            const uRank = ranks.get(u) ?? 0;
+            const neighbors = adj.get(u) ?? [];
+            for (const v of neighbors) {
+                // longest path: rank[v] = max(rank[v], rank[u]+1)
+                const cur = ranks.get(v) ?? 0;
+                const proposed = uRank + 1;
+                if (proposed > cur)
+                    ranks.set(v, proposed);
+                const newDeg = (indeg.get(v) ?? 1) - 1;
+                indeg.set(v, newDeg);
+                if (newDeg === 0) {
+                    queue.push(v);
+                    queue.sort((a, b) => a.localeCompare(b));
+                }
+            }
+        }
+        // Handle cycles: remaining nodes not processed (part of cycles)
+        if (processed.size < nodes.length) {
+            const remaining = nodes
+                .map((n) => n.id)
+                .filter((id) => !processed.has(id))
+                .sort((a, b) => a.localeCompare(b));
+            // Current max rank among processed
+            let maxRank = 0;
+            for (const v of ranks.values())
+                if (v > maxRank)
+                    maxRank = v;
+            // For remaining nodes, assign ranks based on predecessors that are already ranked
+            // Iterate in sorted order, allowing cycle nodes to reference each other if earlier in order
+            for (const id of remaining) {
+                let maxPred = -1;
+                for (const e of sortedEdges) {
+                    if (e.target === id) {
+                        const predRank = ranks.get(e.source);
+                        if (predRank !== undefined) {
+                            if (predRank > maxPred)
+                                maxPred = predRank;
+                        }
+                    }
+                }
+                if (maxPred >= 0) {
+                    // If predecessor exists, put at maxPred+1, but if that predecessor is also in remaining and not yet assigned beyond initial 0,
+                    // we still use its current rank (which may be 0). To avoid artificially high ranks, we clamp to maxRank+1 max
+                    const proposed = maxPred + 1;
+                    // Ensure not too high: if proposed > maxRank + remaining.length, clamp?
+                    ranks.set(id, proposed);
+                    if (proposed > maxRank)
+                        maxRank = proposed;
+                }
+                else {
+                    // No predecessor or isolated cycle entry
+                    const proposed = maxRank + 1;
+                    ranks.set(id, proposed);
+                    maxRank = proposed;
+                }
+            }
+        }
+        // Normalize to start at 0 (should already, but ensure)
+        const minRank = Math.min(...Array.from(ranks.values()));
+        if (minRank !== 0) {
+            for (const [k, v] of ranks.entries())
+                ranks.set(k, v - minRank);
+        }
+        return ranks;
+    }
+    assignTbPositions(rankGroups, sortedRanks, nodeSizes) {
+        const pos = new Map();
+        const { nodeHeight, rankSep, nodeSep, margin } = this.opts;
+        // Compute max group width for centering
+        let maxGroupWidth = 0;
+        for (const r of sortedRanks) {
+            const ids = rankGroups.get(r);
+            let w = 0;
+            for (const id of ids) {
+                const sz = nodeSizes.get(id);
+                w += sz.w;
+            }
+            w += Math.max(0, ids.length - 1) * nodeSep;
+            if (w > maxGroupWidth)
+                maxGroupWidth = w;
+        }
+        // Assign y per rank, x per node within rank
+        for (const rank of sortedRanks) {
+            const ids = rankGroups.get(rank);
+            // compute group width
+            let groupWidth = 0;
+            for (const id of ids)
+                groupWidth += nodeSizes.get(id).w;
+            groupWidth += Math.max(0, ids.length - 1) * nodeSep;
+            // y center for this rank
+            const y = margin + rank * (nodeHeight + rankSep) + nodeHeight / 2;
+            // starting x to center group
+            const startX = margin + (maxGroupWidth - groupWidth) / 2;
+            let cursor = startX;
+            for (const id of ids) {
+                const sz = nodeSizes.get(id);
+                const x = cursor + sz.w / 2;
+                pos.set(id, { x: round2(x), y: round2(y) });
+                cursor += sz.w + nodeSep;
+            }
+        }
+        // For TB, the maxGroupWidth ensures centered, but height computed from ranks
+        return pos;
+    }
+    applyDirection(tbPos, direction, nodeSizes) {
+        if (direction === "TB")
+            return tbPos;
+        // Compute bounds for TB to allow flipping
+        let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
+        for (const [id, p] of tbPos.entries()) {
+            const sz = nodeSizes.get(id);
+            const left = p.x - sz.w / 2;
+            const right = p.x + sz.w / 2;
+            const top = p.y - sz.h / 2;
+            const bottom = p.y + sz.h / 2;
+            if (left < minX)
+                minX = left;
+            if (right > maxX)
+                maxX = right;
+            if (top < minY)
+                minY = top;
+            if (bottom > maxY)
+                maxY = bottom;
+        }
+        const tbWidth = maxX + this.opts.margin;
+        const tbHeight = maxY + this.opts.margin;
+        const result = new Map();
+        for (const [id, p] of tbPos.entries()) {
+            let x = p.x;
+            let y = p.y;
+            if (direction === "BT") {
+                // flip Y: y' = tbHeight - y
+                y = tbHeight - y;
+            }
+            else if (direction === "LR") {
+                // swap axes: x' = y, y' = x  but need to maintain margin? Simpler: transpose
+                // For LR, rank becomes horizontal: so original y (rank) becomes x
+                // Original x (within rank) becomes y
+                // We can just swap
+                const tmp = x;
+                x = y;
+                y = tmp;
+            }
+            else if (direction === "RL") {
+                const tmp = x;
+                x = tbHeight - y; // since tbHeight is the extent in y direction which becomes x
+                y = tmp;
+            }
+            result.set(id, { x: round2(x), y: round2(y) });
+        }
+        // For LR/RL, we swapped but need to re-normalize to ensure margin? The swap already includes margin, so fine.
+        // However for RL we used tbHeight as width after transpose; ensure not negative.
+        // Simpler alternative for LR/RL: recompute via same method but swapped rankSep logic.
+        // But our transpose approach is deterministic and preserves relative spacing.
+        // For LR, after transpose, we may want to ensure left margin still applies: x values start at margin, which they do after swap because y originally started at margin+...
+        // It's okay.
+        return result;
+    }
+    computeEdgePoints(src, tgt, direction, srcPos, tgtPos) {
+        // Determine exit/entry sides based on direction and relative positions
+        // For TB/BT, use vertical sides unless same rank then use horizontal
+        // For LR/RL, use horizontal sides unless same "rank" (now column) then vertical
+        // If direction is TB: source bottom, target top
+        // BT: source top, target bottom
+        // LR: source right, target left
+        // RL: source left, target right
+        // For edges that go backwards (e.g., cycle where source rank > target rank), we still use direction's side? That may cause overlap but deterministic.
+        // To handle backwards, we could choose side based on vector between nodes.
+        // We'll use direction default, but if edge is reverse rank, we flip side to keep line going backwards visually.
+        // Determine if edge is "backward" by comparing rank order approximated via positions
+        let isBackward = false;
+        if (direction === "TB")
+            isBackward = srcPos.y > tgtPos.y;
+        else if (direction === "BT")
+            isBackward = srcPos.y < tgtPos.y;
+        else if (direction === "LR")
+            isBackward = srcPos.x > tgtPos.x;
+        else if (direction === "RL")
+            isBackward = srcPos.x < tgtPos.x;
+        // If same rank (positions equal in rank axis), use horizontal for TB/BT and vertical for LR/RL
+        const sameRank = (direction === "TB" || direction === "BT") ? Math.abs(srcPos.y - tgtPos.y) < 1 : Math.abs(srcPos.x - tgtPos.x) < 1;
+        let sx, sy, tx, ty;
+        if (sameRank) {
+            // horizontal edge within same rank for TB
+            if (srcPos.x < tgtPos.x) {
+                sx = src.x + src.w / 2;
+                sy = src.y;
+                tx = tgt.x - tgt.w / 2;
+                ty = tgt.y;
+            }
+            else {
+                sx = src.x - src.w / 2;
+                sy = src.y;
+                tx = tgt.x + tgt.w / 2;
+                ty = tgt.y;
+            }
+            // For LR same column, vertical
+            if (direction === "LR" || direction === "RL") {
+                if (srcPos.y < tgtPos.y) {
+                    sx = src.x;
+                    sy = src.y + src.h / 2;
+                    tx = tgt.x;
+                    ty = tgt.y - tgt.h / 2;
+                }
+                else {
+                    sx = src.x;
+                    sy = src.y - src.h / 2;
+                    tx = tgt.x;
+                    ty = tgt.y + tgt.h / 2;
+                }
+            }
+        }
+        else if (direction === "TB") {
+            if (!isBackward) {
+                sx = src.x;
+                sy = src.y + src.h / 2;
+                tx = tgt.x;
+                ty = tgt.y - tgt.h / 2;
+            }
+            else {
+                // backward: exit top, enter bottom
+                sx = src.x;
+                sy = src.y - src.h / 2;
+                tx = tgt.x;
+                ty = tgt.y + tgt.h / 2;
+            }
+        }
+        else if (direction === "BT") {
+            if (!isBackward) {
+                sx = src.x;
+                sy = src.y - src.h / 2;
+                tx = tgt.x;
+                ty = tgt.y + tgt.h / 2;
+            }
+            else {
+                sx = src.x;
+                sy = src.y + src.h / 2;
+                tx = tgt.x;
+                ty = tgt.y - tgt.h / 2;
+            }
+        }
+        else if (direction === "LR") {
+            if (!isBackward) {
+                sx = src.x + src.w / 2;
+                sy = src.y;
+                tx = tgt.x - tgt.w / 2;
+                ty = tgt.y;
+            }
+            else {
+                sx = src.x - src.w / 2;
+                sy = src.y;
+                tx = tgt.x + tgt.w / 2;
+                ty = tgt.y;
+            }
+        }
+        else { // RL
+            if (!isBackward) {
+                sx = src.x - src.w / 2;
+                sy = src.y;
+                tx = tgt.x + tgt.w / 2;
+                ty = tgt.y;
+            }
+            else {
+                sx = src.x + src.w / 2;
+                sy = src.y;
+                tx = tgt.x - tgt.w / 2;
+                ty = tgt.y;
+            }
+        }
+        // Round
+        sx = round2(sx);
+        sy = round2(sy);
+        tx = round2(tx);
+        ty = round2(ty);
+        // For straight edge, points are [start, end]
+        // For more interesting routing, if edge spans multiple ranks, we could add intermediate bend points
+        // For now, provide straight line. For orthogonal look, we could add one bend if needed for RL/LR?
+        // Keep simple deterministic: two points
+        // If edge is not straight due to needing to avoid overlapping nodes? Keep straight for simplicity
+        // Optionally add midpoint for label? But points length 2 is fine
+        // If source and target are same node (self-loop), create loop points
+        if (src.x === tgt.x && src.y === tgt.y) {
+            // self-loop: create small loop to the right
+            const loopSize = 24;
+            return [
+                { x: sx, y: sy },
+                { x: sx + loopSize, y: sy },
+                { x: sx + loopSize, y: sy + loopSize },
+                { x: src.x, y: src.y + src.h / 2 }, // bottom
+            ];
+        }
+        return [{ x: sx, y: sy }, { x: tx, y: ty }];
+    }
+    computeLabelPos(points) {
+        if (points.length === 0)
+            return { x: 0, y: 0 };
+        if (points.length === 1)
+            return { x: points[0].x, y: points[0].y };
+        if (points.length === 2) {
+            const a = points[0], b = points[1];
+            return { x: round2((a.x + b.x) / 2), y: round2((a.y + b.y) / 2 - 8) };
+        }
+        const mid = Math.floor(points.length / 2);
+        const a = points[mid - 1], b = points[mid];
+        return { x: round2((a.x + b.x) / 2), y: round2((a.y + b.y) / 2 - 8) };
+    }
+    computeGroups(groups, positioned, nodeSizes) {
+        const groupPadding = 20;
+        const headerHeight = 24; // space for group label
+        const recurse = (grp) => {
+            // Compute child layouts first
+            const childLayouts = grp.groups.map(recurse);
+            // Compute bounds of members + children
+            let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+            let hasContent = false;
+            for (const nid of grp.nodeIds) {
+                const pos = positioned.get(nid);
+                const sz = nodeSizes.get(nid);
+                if (!pos || !sz)
+                    continue;
+                hasContent = true;
+                const l = pos.x - sz.w / 2;
+                const r = pos.x + sz.w / 2;
+                const t = pos.y - sz.h / 2;
+                const b = pos.y + sz.h / 2;
+                if (l < minX)
+                    minX = l;
+                if (r > maxX)
+                    maxX = r;
+                if (t < minY)
+                    minY = t;
+                if (b > maxY)
+                    maxY = b;
+            }
+            for (const cl of childLayouts) {
+                hasContent = true;
+                const l = cl.x - cl.width / 2;
+                const r = cl.x + cl.width / 2;
+                const t = cl.y - cl.height / 2;
+                const b = cl.y + cl.height / 2;
+                if (l < minX)
+                    minX = l;
+                if (r > maxX)
+                    maxX = r;
+                if (t < minY)
+                    minY = t;
+                if (b > maxY)
+                    maxY = b;
+            }
+            if (!hasContent) {
+                // Empty group: small placeholder centered near margin
+                const cx = this.opts.margin + 50;
+                const cy = this.opts.margin + 30;
+                return {
+                    id: grp.id,
+                    label: grp.label ?? grp.id,
+                    type: grp.type,
+                    x: round2(cx),
+                    y: round2(cy),
+                    width: 100,
+                    height: 60,
+                    data: grp,
+                    memberIds: [...grp.nodeIds],
+                    children: childLayouts,
+                };
+            }
+            // Add padding and header
+            minX -= groupPadding;
+            maxX += groupPadding;
+            minY -= groupPadding + headerHeight;
+            maxY += groupPadding;
+            const w = maxX - minX;
+            const h = maxY - minY;
+            const cx = (minX + maxX) / 2;
+            const cy = (minY + maxY) / 2;
+            return {
+                id: grp.id,
+                label: grp.label ?? grp.id,
+                type: grp.type,
+                x: round2(cx),
+                y: round2(cy),
+                width: round2(w),
+                height: round2(h),
+                data: grp,
+                memberIds: [...grp.nodeIds],
+                children: childLayouts,
+            };
+        };
+        // For top-level groups, compute deterministically sorted by id
+        const sorted = [...groups].sort((a, b) => a.id.localeCompare(b.id));
+        return sorted.map(recurse);
+    }
+}
+function estimateNodeSize(label, type, opts) {
+    // Deterministic size based on label length and type
+    // Use char width 7, padding
+    const charW = 7;
+    const paddingX = 24;
+    const paddingY = 12;
+    const baseH = 36;
+    let minW = opts.minNodeWidth;
+    let maxW = opts.maxNodeWidth;
+    let h = opts.nodeHeight;
+    // Type-specific adjustments
+    if (type === "database") {
+        // database slightly wider
+        minW = Math.max(minW, 90);
+        h = 48;
+    }
+    else if (type === "person") {
+        // person as circle-like, make square
+        // width based on label but ensure at least height
+        minW = Math.max(minW, 80);
+        h = 48;
+    }
+    else if (type === "service") {
+        minW = Math.max(minW, 90);
+    }
+    const textW = label.length * charW + paddingX;
+    let w = Math.max(minW, Math.min(maxW, textW));
+    // Ensure width handles type decorations: database needs extra for cylinder? Keep same
+    // Snap to even for determinism
+    w = Math.round(w);
+    h = Math.round(h);
+    return { w, h };
+}
+function flattenGroups(groups) {
+    const out = [];
+    for (const g of groups) {
+        out.push(g);
+        if (g.children.length > 0)
+            out.push(...flattenGroups(g.children));
+    }
+    return out;
+}
+function round2(n) {
+    return Math.round(n * 100) / 100;
+}
+//# sourceMappingURL=simple.js.map