@grafloria/element 0.3.20 → 0.3.21

package/src/libs/engine/src/dsl/transformer/ASTTransformer.js

@@ -1,605 +0,0 @@
-"use strict";
-/**
- * AST Transformer - Converts Abstract Syntax Tree to DiagramModel
- *
- * Takes the parsed AST from the Parser and transforms it into
- * concrete NodeModel and LinkModel instances within a DiagramModel.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ASTTransformer = void 0;
-const DiagramModel_1 = require("../../models/DiagramModel");
-const NodeModel_1 = require("../../models/NodeModel");
-const GroupModel_1 = require("../../models/GroupModel");
-const layout_1 = require("../mermaid/layout");
-class ASTTransformer {
-    constructor() {
-        this.nodePositions = new Map();
-        this.nextAutoPosition = { x: 100, y: 100 };
-        this.nodeSpacing = 150;
-        /**
-         * The axis auto-placement advances along, from the diagram's direction
-         * keyword. `flowchart TD` is TOP-DOWN and must stack vertically; every
-         * direction used to lay out identically left-to-right, so TD/TB read as LR.
-         */
-        this.flowAxis = 'x';
-    }
-    /**
-     * Transform AST into DiagramModel
-     */
-    transform(ast, options = {}) {
-        var _a;
-        // Apply options
-        const { defaultNodeSize = { width: 120, height: 80 }, nodeSpacing = 150, startPosition = { x: 100, y: 100 }, autoPosition = true, diagramName = 'Generated Diagram', } = options;
-        this.nodeSpacing = nodeSpacing;
-        this.nextAutoPosition = Object.assign({}, startPosition);
-        // Create diagram
-        const diagram = new DiagramModel_1.DiagramModel(diagramName);
-        // Store diagram type in metadata
-        diagram.setMetadata('diagramType', ast.diagramType);
-        diagram.setMetadata('direction', ast.direction);
-        // TD / TB (top-down) and BT stack DOWN the page; LR / RL run across it.
-        this.flowAxis = /^(TD|TB|BT)$/i.test(String((_a = ast.direction) !== null && _a !== void 0 ? _a : '')) ? 'y' : 'x';
-        // Phase 1: structure — nodes, subgraphs→groups, and classDefs (stored so
-        // class applications in Phase 3 can resolve regardless of source order).
-        for (const statement of ast.statements) {
-            this.processStatement(statement, diagram, defaultNodeSize, autoPosition);
-        }
-        // Phase 2: top-level links (subgraph-internal links are created in
-        // createSubgraph, before their group is formed).
-        for (const statement of ast.statements) {
-            if (statement.type === 'EdgeDefinition') {
-                this.createLink(statement, diagram);
-            }
-        }
-        // Phase 2.5: type-aware placement. The chain-wrap positions assigned while
-        // creating nodes step along the flow axis in READING order, so a BRANCH
-        // renders as a straight line that lies about the graph ("Check -->|no|
-        // Order" reads as Pick→Order). Now that every edge exists, re-place the
-        // auto-positioned nodes by RANK: rank along the direction's flow axis,
-        // siblings spread on the cross axis — a fork reads as a fork. Nodes with
-        // EXPLICIT positions (none from a parse, but transform options can disable
-        // auto-positioning) are untouched.
-        if (autoPosition) {
-            this.applyRankPlacement(diagram, startPosition);
-        }
-        // Phase 3: the extension channel — Tier-1 directives (style/class/linkStyle/
-        // click) and Tier-2 %%grafloria: directives. Run last, over the FLATTENED tree,
-        // because they reference nodes/links/classDefs that must already exist.
-        this.applyDirectives(this.flattenStatements(ast.statements), diagram);
-        return diagram;
-    }
-    /**
-     * Rank-based placement over the whole parsed graph (Phase 2.5).
-     *
-     * Only nodes THIS transform auto-positioned (`this.nodePositions`) move — a
-     * guard, not a hope: anything with an explicit position (restored later by
-     * the sidecar, or added by a caller) must never be rearranged by a parse.
-     * Synchronous and deterministic; see dsl/mermaid/layout.ts.
-     */
-    applyRankPlacement(diagram, startPosition) {
-        var _a;
-        const placeable = diagram
-            .getNodes()
-            .filter((node) => this.nodePositions.has(node.id));
-        if (placeable.length === 0)
-            return;
-        const ids = placeable.map((n) => n.id);
-        const idSet = new Set(ids);
-        const edges = diagram
-            .getLinks()
-            .filter((l) => l.sourceNodeId !== undefined &&
-            l.targetNodeId !== undefined &&
-            idSet.has(l.sourceNodeId) &&
-            idSet.has(l.targetNodeId))
-            .map((l) => ({ from: l.sourceNodeId, to: l.targetNodeId }));
-        const direction = (_a = diagram.getMetadata('direction')) !== null && _a !== void 0 ? _a : 'TD';
-        const ranks = (0, layout_1.assignRanks)(ids, edges);
-        const positions = (0, layout_1.placeByRank)(placeable, ranks, {
-            direction,
-            start: startPosition,
-            // Bands are size-aware, so these are true GAPS — derived from the same
-            // nodeSpacing constant the chain-wrap used (150 ⇒ 75 / 50 by default).
-            rankGap: this.nodeSpacing / 2,
-            crossGap: this.nodeSpacing / 3,
-        });
-        for (const node of placeable) {
-            const position = positions.get(node.id);
-            if (!position)
-                continue;
-            node.setPosition(position.x, position.y);
-            this.nodePositions.set(node.id, position);
-        }
-        // The links were smart-linked against the CHAIN-WRAP positions: their port
-        // sides and generated paths describe the old picture. Re-select ports with
-        // the rank context (forward edges leave the flow side, back-edges loop),
-        // then drop the routed polylines so the renderer re-routes from the real
-        // geometry on first paint — the same invalidate-on-move rule the layout
-        // engine applies (see layout-route-invalidation.spec.ts).
-        const contextDirection = { TD: 'TB', TB: 'TB', BT: 'BT', LR: 'LR', RL: 'RL' }[direction.toUpperCase()];
-        diagram.getLayoutManager().optimizeConnections(Object.assign(Object.assign({}, (contextDirection ? { direction: contextDirection } : {})), { ranks }));
-        for (const link of diagram.getLinks()) {
-            if (link.sourceNodeId !== undefined &&
-                link.targetNodeId !== undefined &&
-                idSet.has(link.sourceNodeId) &&
-                idSet.has(link.targetNodeId) &&
-                link.points.length > 0) {
-                link.setPoints([]);
-            }
-        }
-    }
-    /**
-     * Process a single statement
-     */
-    processStatement(statement, diagram, defaultNodeSize, autoPosition) {
-        switch (statement.type) {
-            case 'NodeDefinition':
-                this.createNode(statement, diagram, defaultNodeSize, autoPosition);
-                break;
-            case 'EdgeDefinition':
-                // Edges are processed after all nodes are created
-                break;
-            case 'Subgraph':
-                this.createSubgraph(statement, diagram, defaultNodeSize, autoPosition);
-                break;
-            case 'ClassDef':
-                // Stored now; class applications resolve against it in Phase 3.
-                this.storeClassDef(statement, diagram);
-                break;
-            // Deferred to Phase 3 (need nodes / links / classDefs in place first).
-            case 'Style':
-            case 'ClassApplication':
-            case 'LinkStyle':
-            case 'Click':
-            case 'GrafloriaDirective':
-                break;
-        }
-    }
-    /** Depth-first flatten so directives inside subgraphs are applied too. */
-    flattenStatements(statements) {
-        const out = [];
-        for (const st of statements) {
-            out.push(st);
-            if (st.type === 'Subgraph')
-                out.push(...this.flattenStatements(st.statements));
-        }
-        return out;
-    }
-    /**
-     * Phase 3 — apply the extension channel. Node-targeting directives first
-     * (style/class/click), then link-targeting ones (linkStyle/grafloria:edge) which
-     * depend on link order.
-     */
-    applyDirectives(statements, diagram) {
-        for (const st of statements) {
-            if (st.type === 'Style')
-                this.applyStyle(st, diagram);
-            else if (st.type === 'ClassApplication')
-                this.applyClass(st, diagram);
-            else if (st.type === 'Click')
-                this.applyClick(st, diagram);
-            else if (st.type === 'GrafloriaDirective' && st.target === 'node') {
-                this.applyGrafloriaNode(st, diagram);
-            }
-        }
-        for (const st of statements) {
-            if (st.type === 'LinkStyle')
-                this.applyLinkStyle(st, diagram);
-            else if (st.type === 'GrafloriaDirective' && st.target === 'edge') {
-                this.applyGrafloriaEdge(st, diagram);
-            }
-        }
-    }
-    /** `class a,b hot` — resolve the classDef and apply it to each node. */
-    applyClass(node, diagram) {
-        const classDefs = (diagram.getMetadata('classDefs') || {});
-        const props = classDefs[node.className];
-        if (!props)
-            return;
-        for (const id of node.ids) {
-            const target = diagram.getNode(id);
-            if (target)
-                this.applyStyleToNode(target, props);
-        }
-    }
-    /** `linkStyle 0,2 …` — style links by insertion index (or 'default' = all). */
-    applyLinkStyle(node, diagram) {
-        const links = diagram.getLinks();
-        const targets = node.indices === 'default' ? links.map((_, i) => i) : node.indices;
-        for (const i of targets) {
-            if (links[i])
-                this.applyStyleToLink(links[i], node.properties);
-        }
-    }
-    /** `click a "url" "tip"` — the node's navigation target (metadata, not a node). */
-    applyClick(node, diagram) {
-        const target = diagram.getNode(node.id);
-        if (!target)
-            return;
-        if (node.href)
-            target.setMetadata('href', node.href);
-        if (node.tooltip)
-            target.setMetadata('tooltip', node.tooltip);
-    }
-    /** `%%grafloria:node a status:running` — Grafloria-only node state. */
-    applyGrafloriaNode(node, diagram) {
-        const target = diagram.getNode(node.ids[0]);
-        if (!target)
-            return;
-        if (node.properties['status']) {
-            target.setState({ status: node.properties['status'], animateStatus: true });
-        }
-    }
-    /** `%%grafloria:edge a b animation:flow` — Grafloria-only edge animation. */
-    applyGrafloriaEdge(node, diagram) {
-        const [source, target] = node.ids;
-        const link = diagram.getLinks().find((l) => l.sourceNodeId === source && l.targetNodeId === target);
-        if (!link)
-            return;
-        if (node.properties['animation']) {
-            const anim = { type: node.properties['animation'] };
-            if (node.properties['speed'])
-                anim['speed'] = node.properties['speed'];
-            link.updateStyle({ animation: anim });
-        }
-    }
-    /**
-     * Create a node from NodeDefinitionNode
-     */
-    createNode(astNode, diagram, defaultNodeSize, autoPosition) {
-        // Check if node already exists
-        let node = diagram.getNode(astNode.id);
-        if (node) {
-            // Update existing node with new information. setLabel writes the CANON
-            // (metadata.label — what the renderer and a11y read) and mirrors the
-            // legacy data.label slot; see DiagramEntity.setLabel.
-            if (astNode.label) {
-                node.setLabel(astNode.label);
-            }
-            return node;
-        }
-        // Determine position
-        let position;
-        if (autoPosition) {
-            position = this.getNextAutoPosition();
-        }
-        else {
-            position = { x: 100, y: 100 };
-        }
-        // Store position for this node ID
-        this.nodePositions.set(astNode.id, position);
-        // Determine size based on shape
-        const size = this.getSizeForShape(astNode.shape, defaultNodeSize);
-        // Create node
-        node = new NodeModel_1.NodeModel({
-            id: astNode.id,
-            type: this.getNodeTypeFromShape(astNode.shape),
-            position,
-            size,
-        });
-        // Set label through the canon (metadata.label + legacy mirror) — a parsed
-        // node must carry its label where the renderer reads it, or Mermaid-loaded
-        // diagrams draw unlabeled and read to screen readers as '<type> node'.
-        node.setLabel(astNode.label || astNode.id);
-        // Store shape information for DSL
-        node.setMetadata('dslShape', astNode.shape);
-        // Convert DSL shape to SVG renderer shape config
-        const shapeConfig = this.getShapeConfigFromDSLShape(astNode.shape);
-        node.setMetadata('shape', shapeConfig);
-        // Apply style if provided
-        if (astNode.style) {
-            this.applyStyleToNode(node, astNode.style);
-            // Merge style into shape config
-            const updatedShapeConfig = Object.assign({}, shapeConfig);
-            if (astNode.style.fill)
-                updatedShapeConfig.fill = astNode.style.fill;
-            if (astNode.style.stroke)
-                updatedShapeConfig.stroke = astNode.style.stroke;
-            if (astNode.style.strokeWidth !== undefined)
-                updatedShapeConfig.strokeWidth = astNode.style.strokeWidth;
-            node.setMetadata('shape', updatedShapeConfig);
-        }
-        // Add to diagram
-        diagram.addNode(node);
-        return node;
-    }
-    /**
-     * Create a link from EdgeDefinitionNode
-     */
-    createLink(astEdge, diagram) {
-        var _a;
-        // Get or create source node
-        let sourceNode = diagram.getNode(astEdge.source);
-        if (sourceNode && astEdge.sourceLabel) {
-            // Mermaid is last-write-wins: `a[First]` then `a[Second] --> b` leaves
-            // the label "Second". An explicit label riding INSIDE an edge line must
-            // update an existing node just like a repeated node definition does —
-            // a bare reference (`a --> b`, no label) must NOT reset it to the id.
-            sourceNode.setLabel(astEdge.sourceLabel);
-        }
-        if (!sourceNode) {
-            // Create implicit node for source using shape/label from edge definition
-            const sourceShape = astEdge.sourceShape || 'rectangle';
-            const sourceLabel = astEdge.sourceLabel || astEdge.source;
-            sourceNode = this.createNode({
-                type: 'NodeDefinition',
-                id: astEdge.source,
-                label: sourceLabel,
-                shape: sourceShape,
-                location: astEdge.location,
-            }, diagram, { width: 120, height: 80 }, true);
-        }
-        // Get or create target node
-        let targetNode = diagram.getNode(astEdge.target);
-        if (targetNode && astEdge.targetLabel) {
-            // Same last-write-wins rule as the source side above.
-            targetNode.setLabel(astEdge.targetLabel);
-        }
-        if (!targetNode) {
-            // Create implicit node for target using shape/label from edge definition
-            const targetShape = astEdge.targetShape || 'rectangle';
-            const targetLabel = astEdge.targetLabel || astEdge.target;
-            targetNode = this.createNode({
-                type: 'NodeDefinition',
-                id: astEdge.target,
-                label: targetLabel,
-                shape: targetShape,
-                location: astEdge.location,
-            }, diagram, { width: 120, height: 80 }, true);
-        }
-        // Use createSmartLink for automatic port selection
-        const pathType = this.getPathTypeFromLinkType(astEdge.linkType);
-        const link = diagram.createSmartLink(sourceNode, targetNode, pathType);
-        if (!link) {
-            console.warn(`Failed to create smart link between ${astEdge.source} and ${astEdge.target}`);
-            return null;
-        }
-        // Set label if provided — canonical write, same reasoning as node labels
-        // (svg-renderer reads link.getMetadata('label') for the edge label).
-        if (astEdge.label) {
-            link.setLabel(astEdge.label);
-            // …and ALSO as a real link label. `setLabel` only writes `metadata.label`
-            // (plus the legacy data mirror), but the SVG renderer paints from the
-            // `labels[]` array — so every Mermaid edge label (`-->|yes|`) parsed
-            // correctly, was stored on the link, and then never appeared. That left
-            // branch edges looking like unexplained stray lines.
-            if (!((_a = link.labels) === null || _a === void 0 ? void 0 : _a.length))
-                link.addLabel({ text: astEdge.label, slot: 'center' });
-        }
-        // Store link type information
-        link.setMetadata('dslLinkType', astEdge.linkType);
-        // Apply style if provided
-        if (astEdge.style) {
-            this.applyStyleToLink(link, astEdge.style);
-        }
-        // Set line style based on link type
-        this.applyLinkTypeStyle(link, astEdge.linkType);
-        return link;
-    }
-    /**
-     * Create a subgraph as a real GroupModel whose members are the nodes defined
-     * inside it. Mermaid's `subgraph … end` is a container; mapping it to a group
-     * is what makes "collapse the subgraph" and drop-to-assign work downstream.
-     */
-    createSubgraph(astSubgraph, diagram, defaultNodeSize, autoPosition) {
-        // Nodes (and nested subgraphs) first, so inner edges have endpoints…
-        for (const statement of astSubgraph.statements) {
-            this.processStatement(statement, diagram, defaultNodeSize, autoPosition);
-        }
-        // …then the subgraph's OWN edges. The transformer's top-level edge pass
-        // only walks `ast.statements`, so without this a `subgraph { a --> b }`
-        // drew its nodes but never its wire.
-        for (const statement of astSubgraph.statements) {
-            if (statement.type === 'EdgeDefinition') {
-                this.createLink(statement, diagram);
-            }
-        }
-        // The group and its membership.
-        const groupId = astSubgraph.id || `subgraph-${diagram.getGroups().length + 1}`;
-        const group = new GroupModel_1.GroupModel({ id: groupId, name: astSubgraph.label || astSubgraph.id || groupId });
-        diagram.addGroup(group);
-        const memberIds = new Set();
-        this.collectDirectNodeIds(astSubgraph.statements, memberIds);
-        for (const id of memberIds) {
-            if (diagram.getNode(id))
-                group.addMember(id, diagram);
-        }
-        if (astSubgraph.direction) {
-            group.setMetadata('direction', astSubgraph.direction);
-        }
-    }
-    /**
-     * Node ids defined AT THIS subgraph level (its own node defs + edge
-     * endpoints). Nested subgraphs form their own groups, so their nodes are not
-     * pulled into the parent's membership.
-     */
-    collectDirectNodeIds(statements, into) {
-        for (const statement of statements) {
-            if (statement.type === 'NodeDefinition') {
-                into.add(statement.id);
-            }
-            else if (statement.type === 'EdgeDefinition') {
-                into.add(statement.source);
-                into.add(statement.target);
-            }
-        }
-    }
-    /**
-     * Apply style to a node
-     */
-    applyStyle(styleNode, diagram) {
-        const node = diagram.getNode(styleNode.targetId);
-        if (!node) {
-            console.warn(`Style target node not found: ${styleNode.targetId}`);
-            return;
-        }
-        this.applyStyleToNode(node, styleNode.properties);
-    }
-    /**
-     * Store class definition in diagram metadata
-     */
-    storeClassDef(classDefNode, diagram) {
-        const classDefs = diagram.getMetadata('classDefs') || {};
-        classDefs[classDefNode.className] = classDefNode.properties;
-        diagram.setMetadata('classDefs', classDefs);
-    }
-    /**
-     * Apply style properties to a node
-     */
-    applyStyleToNode(node, properties) {
-        if (properties.fill) {
-            node.style.fill = properties.fill;
-        }
-        if (properties.stroke) {
-            node.style.stroke = properties.stroke;
-        }
-        if (properties.strokeWidth !== undefined) {
-            node.style.strokeWidth = properties.strokeWidth;
-        }
-        if (properties.color) {
-            node.style.color = properties.color;
-        }
-        if (properties.strokeDasharray) {
-            node.style.strokeDasharray = properties.strokeDasharray;
-        }
-        // Paints must ALSO ride the shape-config metadata — that is where the SVG
-        // renderer reads fill/stroke for the shape (node.style alone renders
-        // nothing). Mirrors the inline-style path in createNode. node.style stays
-        // set too, which is what the generator's analyzer detects for round-trip.
-        const shapeConfig = Object.assign({}, node.getMetadata('shape'));
-        if (properties.fill)
-            shapeConfig['fill'] = properties.fill;
-        if (properties.stroke)
-            shapeConfig['stroke'] = properties.stroke;
-        if (properties.strokeWidth !== undefined)
-            shapeConfig['strokeWidth'] = properties.strokeWidth;
-        node.setMetadata('shape', shapeConfig);
-        // Mark it so the generator re-emits a `style` line (the analyzer's own
-        // hasCustomStyle heuristic wrongly treats fill/stroke as "not custom").
-        node.setMetadata('dslStyled', true);
-    }
-    /**
-     * Apply style properties to a link
-     */
-    applyStyleToLink(link, properties) {
-        if (properties.stroke) {
-            link.style.stroke = properties.stroke;
-        }
-        if (properties.strokeWidth !== undefined) {
-            link.style.strokeWidth = properties.strokeWidth;
-        }
-        if (properties.strokeDasharray) {
-            link.style.strokeDasharray = properties.strokeDasharray;
-        }
-    }
-    /**
-     * Apply link type styling (dashed, thick, etc.)
-     */
-    applyLinkTypeStyle(link, linkType) {
-        switch (linkType) {
-            case 'dotted-line':
-            case 'dotted-arrow':
-                link.style.strokeDasharray = '5,5';
-                break;
-            case 'thick-line':
-            case 'thick-arrow':
-                link.style.strokeWidth = 4;
-                break;
-            default:
-                // Default styling
-                break;
-        }
-    }
-    /**
-     * Get node type from shape
-     */
-    getNodeTypeFromShape(shape) {
-        const shapeToType = {
-            'rectangle': 'flowchart:process',
-            'rounded-rectangle': 'flowchart:terminator',
-            'stadium': 'flowchart:terminator',
-            'subroutine': 'flowchart:subprocess',
-            'cylindrical': 'flowchart:data',
-            'circle': 'flowchart:connector',
-            'asymmetric': 'flowchart:document',
-            'rhombus': 'flowchart:decision',
-            'hexagon': 'flowchart:preparation',
-            'trapezoid': 'flowchart:manual-input',
-            'trapezoid-alt': 'flowchart:manual-input',
-        };
-        return shapeToType[shape] || 'flowchart:process';
-    }
-    /**
-     * Convert DSL NodeShape to SVG renderer shape configuration
-     * SVG renderer expects shape metadata in format: { type: 'rect' | 'circle' | 'ellipse' | 'diamond' | 'hexagon', cornerRadius?: number }
-     */
-    getShapeConfigFromDSLShape(shape) {
-        const shapeMapping = {
-            'rectangle': { type: 'rect' },
-            'rounded-rectangle': { type: 'rect', cornerRadius: 10 },
-            'stadium': { type: 'ellipse' }, // Stadium is essentially a tall ellipse
-            'subroutine': { type: 'rect', cornerRadius: 5 },
-            'cylindrical': { type: 'ellipse' }, // Cylinder approximated as ellipse
-            'circle': { type: 'circle' },
-            'asymmetric': { type: 'rect' }, // Document shape - fallback to rect for now
-            'rhombus': { type: 'diamond' },
-            'hexagon': { type: 'hexagon' },
-            'trapezoid': { type: 'rect' }, // Trapezoid - fallback to rect for now
-            'trapezoid-alt': { type: 'rect' }, // Trapezoid alt - fallback to rect for now
-        };
-        return shapeMapping[shape] || { type: 'rect' };
-    }
-    /**
-     * Get size for shape
-     */
-    getSizeForShape(shape, defaultSize) {
-        // Different shapes may need different default sizes
-        switch (shape) {
-            case 'circle':
-                // Circles should be square
-                return { width: 80, height: 80 };
-            case 'rhombus':
-                // Diamonds are usually wider
-                return { width: 140, height: 80 };
-            case 'hexagon':
-                return { width: 140, height: 80 };
-            default:
-                return defaultSize;
-        }
-    }
-    /**
-     * Get path type from link type
-     */
-    getPathTypeFromLinkType(linkType) {
-        // For now, use smooth curves for all
-        // This can be made more sophisticated later
-        return 'smooth';
-    }
-    /**
-     * Get next auto-position for a node
-     */
-    getNextAutoPosition() {
-        const position = Object.assign({}, this.nextAutoPosition);
-        // Advance along the DIRECTION's axis, wrapping on the cross axis. This used
-        // to always step in x, so `flowchart TD` produced the same left-to-right
-        // chain as `LR` — the direction keyword parsed, was stored on the diagram,
-        // and then nothing read it.
-        const along = this.flowAxis;
-        const across = along === 'x' ? 'y' : 'x';
-        const limit = along === 'x' ? 1000 : 700; // wrap a column sooner than a row
-        this.nextAutoPosition[along] += this.nodeSpacing;
-        if (this.nextAutoPosition[along] > limit) {
-            this.nextAutoPosition[along] = 100;
-            this.nextAutoPosition[across] += this.nodeSpacing;
-        }
-        return position;
-    }
-    /**
-     * Reset auto-positioning state
-     */
-    resetAutoPosition(startPosition) {
-        this.nextAutoPosition = Object.assign({}, startPosition);
-        this.nodePositions.clear();
-    }
-}
-exports.ASTTransformer = ASTTransformer;
-//# sourceMappingURL=ASTTransformer.js.map