@fecp/designer 5.5.48 → 5.5.50

package/es/node_modules/bpmn-js/lib/features/drilldown/SubprocessCompatibility.mjs

@@ -0,0 +1,149 @@
+import { asTRBL, asBounds } from "../../../../diagram-js/lib/layout/LayoutUtil.mjs";
+import { is, isAny } from "../../util/ModelUtil.mjs";
+var DEFAULT_POSITION = {
+  x: 180,
+  y: 160
+};
+function SubprocessCompatibility(eventBus, moddle) {
+  this._eventBus = eventBus;
+  this._moddle = moddle;
+  var self = this;
+  eventBus.on("import.render.start", 1500, function(e, context) {
+    self.handleImport(context.definitions);
+  });
+}
+SubprocessCompatibility.prototype.handleImport = function(definitions) {
+  if (!definitions.diagrams) {
+    return;
+  }
+  var self = this;
+  this._definitions = definitions;
+  this._processToDiagramMap = {};
+  definitions.diagrams.forEach(function(diagram) {
+    if (!diagram.plane || !diagram.plane.bpmnElement) {
+      return;
+    }
+    self._processToDiagramMap[diagram.plane.bpmnElement.id] = diagram;
+  });
+  var newDiagrams = [];
+  definitions.diagrams.forEach(function(diagram) {
+    var createdDiagrams = self.createNewDiagrams(diagram.plane);
+    Array.prototype.push.apply(newDiagrams, createdDiagrams);
+  });
+  newDiagrams.forEach(function(diagram) {
+    self.movePlaneElementsToOrigin(diagram.plane);
+  });
+};
+SubprocessCompatibility.prototype.createNewDiagrams = function(plane) {
+  var self = this;
+  var collapsedElements = [];
+  var elementsToMove = [];
+  plane.get("planeElement").forEach(function(diElement) {
+    var bo = diElement.bpmnElement;
+    if (!bo) {
+      return;
+    }
+    var parent = bo.$parent;
+    if (is(bo, "bpmn:SubProcess") && !diElement.isExpanded) {
+      collapsedElements.push(bo);
+    }
+    if (shouldMoveToPlane(bo, plane)) {
+      elementsToMove.push({ diElement, parent });
+    }
+  });
+  var newDiagrams = [];
+  collapsedElements.forEach(function(element) {
+    if (!self._processToDiagramMap[element.id]) {
+      var diagram = self.createDiagram(element);
+      self._processToDiagramMap[element.id] = diagram;
+      newDiagrams.push(diagram);
+    }
+  });
+  elementsToMove.forEach(function(element) {
+    var diElement = element.diElement;
+    var parent = element.parent;
+    while (parent && collapsedElements.indexOf(parent) === -1) {
+      parent = parent.$parent;
+    }
+    if (!parent) {
+      return;
+    }
+    var diagram = self._processToDiagramMap[parent.id];
+    self.moveToDiPlane(diElement, diagram.plane);
+  });
+  return newDiagrams;
+};
+SubprocessCompatibility.prototype.movePlaneElementsToOrigin = function(plane) {
+  var elements = plane.get("planeElement");
+  var planeBounds = getPlaneBounds(plane);
+  var offset = {
+    x: planeBounds.x - DEFAULT_POSITION.x,
+    y: planeBounds.y - DEFAULT_POSITION.y
+  };
+  elements.forEach(function(diElement) {
+    if (diElement.waypoint) {
+      diElement.waypoint.forEach(function(waypoint) {
+        waypoint.x = waypoint.x - offset.x;
+        waypoint.y = waypoint.y - offset.y;
+      });
+    } else if (diElement.bounds) {
+      diElement.bounds.x = diElement.bounds.x - offset.x;
+      diElement.bounds.y = diElement.bounds.y - offset.y;
+    }
+  });
+};
+SubprocessCompatibility.prototype.moveToDiPlane = function(diElement, newPlane) {
+  var containingDiagram = findRootDiagram(diElement);
+  var parentPlaneElement = containingDiagram.plane.get("planeElement");
+  parentPlaneElement.splice(parentPlaneElement.indexOf(diElement), 1);
+  newPlane.get("planeElement").push(diElement);
+};
+SubprocessCompatibility.prototype.createDiagram = function(bo) {
+  var plane = this._moddle.create("bpmndi:BPMNPlane", { bpmnElement: bo });
+  var diagram = this._moddle.create("bpmndi:BPMNDiagram", {
+    plane
+  });
+  plane.$parent = diagram;
+  plane.bpmnElement = bo;
+  diagram.$parent = this._definitions;
+  this._definitions.diagrams.push(diagram);
+  return diagram;
+};
+SubprocessCompatibility.$inject = ["eventBus", "moddle"];
+function findRootDiagram(element) {
+  if (is(element, "bpmndi:BPMNDiagram")) {
+    return element;
+  } else {
+    return findRootDiagram(element.$parent);
+  }
+}
+function getPlaneBounds(plane) {
+  var planeTrbl = {
+    top: Infinity,
+    right: -Infinity,
+    bottom: -Infinity,
+    left: Infinity
+  };
+  plane.planeElement.forEach(function(element) {
+    if (!element.bounds) {
+      return;
+    }
+    var trbl = asTRBL(element.bounds);
+    planeTrbl.top = Math.min(trbl.top, planeTrbl.top);
+    planeTrbl.left = Math.min(trbl.left, planeTrbl.left);
+  });
+  return asBounds(planeTrbl);
+}
+function shouldMoveToPlane(bo, plane) {
+  var parent = bo.$parent;
+  if (!is(parent, "bpmn:SubProcess") || parent === plane.bpmnElement) {
+    return false;
+  }
+  if (isAny(bo, ["bpmn:DataInputAssociation", "bpmn:DataOutputAssociation"])) {
+    return false;
+  }
+  return true;
+}
+export {
+  SubprocessCompatibility as default
+};

package/es/node_modules/bpmn-js/lib/features/drilldown/index.mjs

@@ -0,0 +1,18 @@
+import OverlaysModule from "../../../../diagram-js/lib/features/overlays/index.mjs";
+import ChangeSupportModule from "../../../../diagram-js/lib/features/change-support/index.mjs";
+import RootElementsModule from "../../../../diagram-js/lib/features/root-elements/index.mjs";
+import DrilldownBreadcrumbs from "./DrilldownBreadcrumbs.mjs";
+import DrilldownCentering from "./DrilldownCentering.mjs";
+import SubprocessCompatibility from "./SubprocessCompatibility.mjs";
+import DrilldownOverlayBehavior from "./DrilldownOverlayBehavior.mjs";
+const DrilldownModdule = {
+  __depends__: [OverlaysModule, ChangeSupportModule, RootElementsModule],
+  __init__: ["drilldownBreadcrumbs", "drilldownOverlayBehavior", "drilldownCentering", "subprocessCompatibility"],
+  drilldownBreadcrumbs: ["type", DrilldownBreadcrumbs],
+  drilldownCentering: ["type", DrilldownCentering],
+  drilldownOverlayBehavior: ["type", DrilldownOverlayBehavior],
+  subprocessCompatibility: ["type", SubprocessCompatibility]
+};
+export {
+  DrilldownModdule as default
+};

package/es/node_modules/bpmn-js/lib/features/label-editing/LabelUtil.mjs

@@ -0,0 +1,31 @@
+import { is } from "../../util/ModelUtil.mjs";
+function getLabelAttr(semantic) {
+  if (is(semantic, "bpmn:FlowElement") || is(semantic, "bpmn:Participant") || is(semantic, "bpmn:Lane") || is(semantic, "bpmn:SequenceFlow") || is(semantic, "bpmn:MessageFlow") || is(semantic, "bpmn:DataInput") || is(semantic, "bpmn:DataOutput")) {
+    return "name";
+  }
+  if (is(semantic, "bpmn:TextAnnotation")) {
+    return "text";
+  }
+  if (is(semantic, "bpmn:Group")) {
+    return "categoryValueRef";
+  }
+}
+function getCategoryValue(semantic) {
+  var categoryValueRef = semantic["categoryValueRef"];
+  if (!categoryValueRef) {
+    return "";
+  }
+  return categoryValueRef.value || "";
+}
+function getLabel(element) {
+  var semantic = element.businessObject, attr = getLabelAttr(semantic);
+  if (attr) {
+    if (attr === "categoryValueRef") {
+      return getCategoryValue(semantic);
+    }
+    return semantic[attr] || "";
+  }
+}
+export {
+  getLabel
+};

package/es/node_modules/bpmn-js/lib/import/BpmnImporter.mjs

@@ -0,0 +1,184 @@
+import { assign } from "../../../min-dash/dist/index.esm.mjs";
+import { is } from "../util/ModelUtil.mjs";
+import { isLabelExternal, getExternalLabelBounds } from "../util/LabelUtil.mjs";
+import { getMid } from "../../../diagram-js/lib/layout/LayoutUtil.mjs";
+import { isExpanded } from "../util/DiUtil.mjs";
+import { getLabel } from "../features/label-editing/LabelUtil.mjs";
+import { elementToString } from "./Util.mjs";
+function elementData(semantic, di, attrs) {
+  return assign({
+    id: semantic.id,
+    type: semantic.$type,
+    businessObject: semantic,
+    di
+  }, attrs);
+}
+function getWaypoints(di, source, target) {
+  var waypoints = di.waypoint;
+  if (!waypoints || waypoints.length < 2) {
+    return [getMid(source), getMid(target)];
+  }
+  return waypoints.map(function(p) {
+    return { x: p.x, y: p.y };
+  });
+}
+function notYetDrawn(translate, semantic, refSemantic, property) {
+  return new Error(translate("element {element} referenced by {referenced}#{property} not yet drawn", {
+    element: elementToString(refSemantic),
+    referenced: elementToString(semantic),
+    property
+  }));
+}
+function BpmnImporter(eventBus, canvas, elementFactory, elementRegistry, translate, textRenderer) {
+  this._eventBus = eventBus;
+  this._canvas = canvas;
+  this._elementFactory = elementFactory;
+  this._elementRegistry = elementRegistry;
+  this._translate = translate;
+  this._textRenderer = textRenderer;
+}
+BpmnImporter.$inject = [
+  "eventBus",
+  "canvas",
+  "elementFactory",
+  "elementRegistry",
+  "translate",
+  "textRenderer"
+];
+BpmnImporter.prototype.add = function(semantic, di, parentElement) {
+  var element, translate = this._translate, hidden;
+  var parentIndex;
+  if (is(di, "bpmndi:BPMNPlane")) {
+    var attrs = is(semantic, "bpmn:SubProcess") ? { id: semantic.id + "_plane" } : {};
+    element = this._elementFactory.createRoot(elementData(semantic, di, attrs));
+    this._canvas.addRootElement(element);
+  } else if (is(di, "bpmndi:BPMNShape")) {
+    var collapsed = !isExpanded(semantic, di), isFrame = isFrameElement(semantic);
+    hidden = parentElement && (parentElement.hidden || parentElement.collapsed);
+    var bounds = di.bounds;
+    element = this._elementFactory.createShape(elementData(semantic, di, {
+      collapsed,
+      hidden,
+      x: Math.round(bounds.x),
+      y: Math.round(bounds.y),
+      width: Math.round(bounds.width),
+      height: Math.round(bounds.height),
+      isFrame
+    }));
+    if (is(semantic, "bpmn:BoundaryEvent")) {
+      this._attachBoundary(semantic, element);
+    }
+    if (is(semantic, "bpmn:Lane")) {
+      parentIndex = 0;
+    }
+    if (is(semantic, "bpmn:DataStoreReference")) {
+      if (!isPointInsideBBox(parentElement, getMid(bounds))) {
+        parentElement = this._canvas.findRoot(parentElement);
+      }
+    }
+    this._canvas.addShape(element, parentElement, parentIndex);
+  } else if (is(di, "bpmndi:BPMNEdge")) {
+    var source = this._getSource(semantic), target = this._getTarget(semantic);
+    hidden = parentElement && (parentElement.hidden || parentElement.collapsed);
+    element = this._elementFactory.createConnection(elementData(semantic, di, {
+      hidden,
+      source,
+      target,
+      waypoints: getWaypoints(di, source, target)
+    }));
+    if (is(semantic, "bpmn:DataAssociation")) {
+      parentElement = this._canvas.findRoot(parentElement);
+    }
+    this._canvas.addConnection(element, parentElement, parentIndex);
+  } else {
+    throw new Error(translate("unknown di {di} for element {semantic}", {
+      di: elementToString(di),
+      semantic: elementToString(semantic)
+    }));
+  }
+  if (isLabelExternal(semantic) && getLabel(element)) {
+    this.addLabel(semantic, di, element);
+  }
+  this._eventBus.fire("bpmnElement.added", { element });
+  return element;
+};
+BpmnImporter.prototype._attachBoundary = function(boundarySemantic, boundaryElement) {
+  var translate = this._translate;
+  var hostSemantic = boundarySemantic.attachedToRef;
+  if (!hostSemantic) {
+    throw new Error(translate("missing {semantic}#attachedToRef", {
+      semantic: elementToString(boundarySemantic)
+    }));
+  }
+  var host = this._elementRegistry.get(hostSemantic.id), attachers = host && host.attachers;
+  if (!host) {
+    throw notYetDrawn(translate, boundarySemantic, hostSemantic, "attachedToRef");
+  }
+  boundaryElement.host = host;
+  if (!attachers) {
+    host.attachers = attachers = [];
+  }
+  if (attachers.indexOf(boundaryElement) === -1) {
+    attachers.push(boundaryElement);
+  }
+};
+BpmnImporter.prototype.addLabel = function(semantic, di, element) {
+  var bounds, text, label;
+  bounds = getExternalLabelBounds(di, element);
+  text = getLabel(element);
+  if (text) {
+    bounds = this._textRenderer.getExternalLabelBounds(bounds, text);
+  }
+  label = this._elementFactory.createLabel(elementData(semantic, di, {
+    id: semantic.id + "_label",
+    labelTarget: element,
+    type: "label",
+    hidden: element.hidden || !getLabel(element),
+    x: Math.round(bounds.x),
+    y: Math.round(bounds.y),
+    width: Math.round(bounds.width),
+    height: Math.round(bounds.height)
+  }));
+  return this._canvas.addShape(label, element.parent);
+};
+BpmnImporter.prototype._getEnd = function(semantic, side) {
+  var element, refSemantic, type = semantic.$type, translate = this._translate;
+  refSemantic = semantic[side + "Ref"];
+  if (side === "source" && type === "bpmn:DataInputAssociation") {
+    refSemantic = refSemantic && refSemantic[0];
+  }
+  if (side === "source" && type === "bpmn:DataOutputAssociation" || side === "target" && type === "bpmn:DataInputAssociation") {
+    refSemantic = semantic.$parent;
+  }
+  element = refSemantic && this._getElement(refSemantic);
+  if (element) {
+    return element;
+  }
+  if (refSemantic) {
+    throw notYetDrawn(translate, semantic, refSemantic, side + "Ref");
+  } else {
+    throw new Error(translate("{semantic}#{side} Ref not specified", {
+      semantic: elementToString(semantic),
+      side
+    }));
+  }
+};
+BpmnImporter.prototype._getSource = function(semantic) {
+  return this._getEnd(semantic, "source");
+};
+BpmnImporter.prototype._getTarget = function(semantic) {
+  return this._getEnd(semantic, "target");
+};
+BpmnImporter.prototype._getElement = function(semantic) {
+  return this._elementRegistry.get(semantic.id);
+};
+function isPointInsideBBox(bbox, point) {
+  var x = point.x, y = point.y;
+  return x >= bbox.x && x <= bbox.x + bbox.width && y >= bbox.y && y <= bbox.y + bbox.height;
+}
+function isFrameElement(semantic) {
+  return is(semantic, "bpmn:Group");
+}
+export {
+  BpmnImporter as default
+};

package/es/node_modules/bpmn-js/lib/import/BpmnTreeWalker.mjs

@@ -0,0 +1,296 @@
+import { filter, forEach, find } from "../../../min-dash/dist/index.esm.mjs";
+import { elementToString } from "./Util.mjs";
+import { ensureCompatDiRef } from "../util/CompatibilityUtil.mjs";
+function is(element, type) {
+  return element.$instanceOf(type);
+}
+function findDisplayCandidate(definitions) {
+  return find(definitions.rootElements, function(e) {
+    return is(e, "bpmn:Process") || is(e, "bpmn:Collaboration");
+  });
+}
+function BpmnTreeWalker(handler, translate) {
+  var handledElements = {};
+  var deferred = [];
+  var diMap = {};
+  function contextual(fn, ctx) {
+    return function(e) {
+      fn(e, ctx);
+    };
+  }
+  function handled(element) {
+    handledElements[element.id] = element;
+  }
+  function isHandled(element) {
+    return handledElements[element.id];
+  }
+  function visit(element, ctx) {
+    var gfx = element.gfx;
+    if (gfx) {
+      throw new Error(
+        translate("already rendered {element}", { element: elementToString(element) })
+      );
+    }
+    return handler.element(element, diMap[element.id], ctx);
+  }
+  function visitRoot(element, diagram) {
+    return handler.root(element, diMap[element.id], diagram);
+  }
+  function visitIfDi(element, ctx) {
+    try {
+      var gfx = diMap[element.id] && visit(element, ctx);
+      handled(element);
+      return gfx;
+    } catch (e) {
+      logError(e.message, { element, error: e });
+      console.error(translate("failed to import {element}", { element: elementToString(element) }));
+      console.error(e);
+    }
+  }
+  function logError(message, context) {
+    handler.error(message, context);
+  }
+  function registerDi(di) {
+    var bpmnElement = di.bpmnElement;
+    if (bpmnElement) {
+      if (diMap[bpmnElement.id]) {
+        logError(
+          translate("multiple DI elements defined for {element}", {
+            element: elementToString(bpmnElement)
+          }),
+          { element: bpmnElement }
+        );
+      } else {
+        diMap[bpmnElement.id] = di;
+        ensureCompatDiRef(bpmnElement);
+      }
+    } else {
+      logError(
+        translate("no bpmnElement referenced in {element}", {
+          element: elementToString(di)
+        }),
+        { element: di }
+      );
+    }
+  }
+  function handleDiagram(diagram) {
+    handlePlane(diagram.plane);
+  }
+  function handlePlane(plane) {
+    registerDi(plane);
+    forEach(plane.planeElement, handlePlaneElement);
+  }
+  function handlePlaneElement(planeElement) {
+    registerDi(planeElement);
+  }
+  function handleDefinitions(definitions, diagram) {
+    var diagrams = definitions.diagrams;
+    if (diagram && diagrams.indexOf(diagram) === -1) {
+      throw new Error(translate("diagram not part of bpmn:Definitions"));
+    }
+    if (!diagram && diagrams && diagrams.length) {
+      diagram = diagrams[0];
+    }
+    if (!diagram) {
+      throw new Error(translate("no diagram to display"));
+    }
+    diMap = {};
+    handleDiagram(diagram);
+    var plane = diagram.plane;
+    if (!plane) {
+      throw new Error(translate(
+        "no plane for {element}",
+        { element: elementToString(diagram) }
+      ));
+    }
+    var rootElement = plane.bpmnElement;
+    if (!rootElement) {
+      rootElement = findDisplayCandidate(definitions);
+      if (!rootElement) {
+        throw new Error(translate("no process or collaboration to display"));
+      } else {
+        logError(
+          translate("correcting missing bpmnElement on {plane} to {rootElement}", {
+            plane: elementToString(plane),
+            rootElement: elementToString(rootElement)
+          })
+        );
+        plane.bpmnElement = rootElement;
+        registerDi(plane);
+      }
+    }
+    var ctx = visitRoot(rootElement, plane);
+    if (is(rootElement, "bpmn:Process") || is(rootElement, "bpmn:SubProcess")) {
+      handleProcess(rootElement, ctx);
+    } else if (is(rootElement, "bpmn:Collaboration")) {
+      handleCollaboration(rootElement, ctx);
+      handleUnhandledProcesses(definitions.rootElements, ctx);
+    } else {
+      throw new Error(
+        translate("unsupported bpmnElement for {plane}: {rootElement}", {
+          plane: elementToString(plane),
+          rootElement: elementToString(rootElement)
+        })
+      );
+    }
+    handleDeferred();
+  }
+  function handleDeferred() {
+    var fn;
+    while (deferred.length) {
+      fn = deferred.shift();
+      fn();
+    }
+  }
+  function handleProcess(process, context) {
+    handleFlowElementsContainer(process, context);
+    handleIoSpecification(process.ioSpecification, context);
+    handleArtifacts(process.artifacts, context);
+    handled(process);
+  }
+  function handleUnhandledProcesses(rootElements, ctx) {
+    var processes = filter(rootElements, function(e) {
+      return !isHandled(e) && is(e, "bpmn:Process") && e.laneSets;
+    });
+    processes.forEach(contextual(handleProcess, ctx));
+  }
+  function handleMessageFlow(messageFlow, context) {
+    visitIfDi(messageFlow, context);
+  }
+  function handleMessageFlows(messageFlows, context) {
+    forEach(messageFlows, contextual(handleMessageFlow, context));
+  }
+  function handleDataAssociation(association, context) {
+    visitIfDi(association, context);
+  }
+  function handleDataInput(dataInput, context) {
+    visitIfDi(dataInput, context);
+  }
+  function handleDataOutput(dataOutput, context) {
+    visitIfDi(dataOutput, context);
+  }
+  function handleArtifact(artifact, context) {
+    visitIfDi(artifact, context);
+  }
+  function handleArtifacts(artifacts, context) {
+    forEach(artifacts, function(e) {
+      if (is(e, "bpmn:Association")) {
+        deferred.push(function() {
+          handleArtifact(e, context);
+        });
+      } else {
+        handleArtifact(e, context);
+      }
+    });
+  }
+  function handleIoSpecification(ioSpecification, context) {
+    if (!ioSpecification) {
+      return;
+    }
+    forEach(ioSpecification.dataInputs, contextual(handleDataInput, context));
+    forEach(ioSpecification.dataOutputs, contextual(handleDataOutput, context));
+  }
+  function handleSubProcess(subProcess, context) {
+    handleFlowElementsContainer(subProcess, context);
+    handleArtifacts(subProcess.artifacts, context);
+  }
+  function handleFlowNode(flowNode, context) {
+    var childCtx = visitIfDi(flowNode, context);
+    if (is(flowNode, "bpmn:SubProcess")) {
+      handleSubProcess(flowNode, childCtx || context);
+    }
+    if (is(flowNode, "bpmn:Activity")) {
+      handleIoSpecification(flowNode.ioSpecification, context);
+    }
+    deferred.push(function() {
+      forEach(flowNode.dataInputAssociations, contextual(handleDataAssociation, context));
+      forEach(flowNode.dataOutputAssociations, contextual(handleDataAssociation, context));
+    });
+  }
+  function handleSequenceFlow(sequenceFlow, context) {
+    visitIfDi(sequenceFlow, context);
+  }
+  function handleDataElement(dataObject, context) {
+    visitIfDi(dataObject, context);
+  }
+  function handleLane(lane, context) {
+    deferred.push(function() {
+      var newContext = visitIfDi(lane, context);
+      if (lane.childLaneSet) {
+        handleLaneSet(lane.childLaneSet, newContext || context);
+      }
+      wireFlowNodeRefs(lane);
+    });
+  }
+  function handleLaneSet(laneSet, context) {
+    forEach(laneSet.lanes, contextual(handleLane, context));
+  }
+  function handleLaneSets(laneSets, context) {
+    forEach(laneSets, contextual(handleLaneSet, context));
+  }
+  function handleFlowElementsContainer(container, context) {
+    handleFlowElements(container.flowElements, context);
+    if (container.laneSets) {
+      handleLaneSets(container.laneSets, context);
+    }
+  }
+  function handleFlowElements(flowElements, context) {
+    forEach(flowElements, function(e) {
+      if (is(e, "bpmn:SequenceFlow")) {
+        deferred.push(function() {
+          handleSequenceFlow(e, context);
+        });
+      } else if (is(e, "bpmn:BoundaryEvent")) {
+        deferred.unshift(function() {
+          handleFlowNode(e, context);
+        });
+      } else if (is(e, "bpmn:FlowNode")) {
+        handleFlowNode(e, context);
+      } else if (is(e, "bpmn:DataObject")) ;
+      else if (is(e, "bpmn:DataStoreReference")) {
+        handleDataElement(e, context);
+      } else if (is(e, "bpmn:DataObjectReference")) {
+        handleDataElement(e, context);
+      } else {
+        logError(
+          translate("unrecognized flowElement {element} in context {context}", {
+            element: elementToString(e),
+            context: context ? elementToString(context.businessObject) : "null"
+          }),
+          { element: e, context }
+        );
+      }
+    });
+  }
+  function handleParticipant(participant, context) {
+    var newCtx = visitIfDi(participant, context);
+    var process = participant.processRef;
+    if (process) {
+      handleProcess(process, newCtx || context);
+    }
+  }
+  function handleCollaboration(collaboration, context) {
+    forEach(collaboration.participants, contextual(handleParticipant, context));
+    handleArtifacts(collaboration.artifacts, context);
+    deferred.push(function() {
+      handleMessageFlows(collaboration.messageFlows, context);
+    });
+  }
+  function wireFlowNodeRefs(lane) {
+    forEach(lane.flowNodeRef, function(flowNode) {
+      var lanes = flowNode.get("lanes");
+      if (lanes) {
+        lanes.push(lane);
+      }
+    });
+  }
+  return {
+    handleDeferred,
+    handleDefinitions,
+    handleSubProcess,
+    registerDi
+  };
+}
+export {
+  BpmnTreeWalker as default
+};