@fecp/designer 5.5.48 → 5.5.49

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

@@ -0,0 +1,149 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const LayoutUtil = require("../../../../diagram-js/lib/layout/LayoutUtil.js");
+const ModelUtil = require("../../util/ModelUtil.js");
+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 (ModelUtil.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 (ModelUtil.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 = LayoutUtil.asTRBL(element.bounds);
+    planeTrbl.top = Math.min(trbl.top, planeTrbl.top);
+    planeTrbl.left = Math.min(trbl.left, planeTrbl.left);
+  });
+  return LayoutUtil.asBounds(planeTrbl);
+}
+function shouldMoveToPlane(bo, plane) {
+  var parent = bo.$parent;
+  if (!ModelUtil.is(parent, "bpmn:SubProcess") || parent === plane.bpmnElement) {
+    return false;
+  }
+  if (ModelUtil.isAny(bo, ["bpmn:DataInputAssociation", "bpmn:DataOutputAssociation"])) {
+    return false;
+  }
+  return true;
+}
+exports.default = SubprocessCompatibility;

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index = require("../../../../diagram-js/lib/features/overlays/index.js");
+const index$1 = require("../../../../diagram-js/lib/features/change-support/index.js");
+const index$2 = require("../../../../diagram-js/lib/features/root-elements/index.js");
+const DrilldownBreadcrumbs = require("./DrilldownBreadcrumbs.js");
+const DrilldownCentering = require("./DrilldownCentering.js");
+const SubprocessCompatibility = require("./SubprocessCompatibility.js");
+const DrilldownOverlayBehavior = require("./DrilldownOverlayBehavior.js");
+const DrilldownModdule = {
+  __depends__: [index.default, index$1.default, index$2.default],
+  __init__: ["drilldownBreadcrumbs", "drilldownOverlayBehavior", "drilldownCentering", "subprocessCompatibility"],
+  drilldownBreadcrumbs: ["type", DrilldownBreadcrumbs.default],
+  drilldownCentering: ["type", DrilldownCentering.default],
+  drilldownOverlayBehavior: ["type", DrilldownOverlayBehavior.default],
+  subprocessCompatibility: ["type", SubprocessCompatibility.default]
+};
+exports.default = DrilldownModdule;

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const ModelUtil = require("../../util/ModelUtil.js");
+function getLabelAttr(semantic) {
+  if (ModelUtil.is(semantic, "bpmn:FlowElement") || ModelUtil.is(semantic, "bpmn:Participant") || ModelUtil.is(semantic, "bpmn:Lane") || ModelUtil.is(semantic, "bpmn:SequenceFlow") || ModelUtil.is(semantic, "bpmn:MessageFlow") || ModelUtil.is(semantic, "bpmn:DataInput") || ModelUtil.is(semantic, "bpmn:DataOutput")) {
+    return "name";
+  }
+  if (ModelUtil.is(semantic, "bpmn:TextAnnotation")) {
+    return "text";
+  }
+  if (ModelUtil.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] || "";
+  }
+}
+exports.getLabel = getLabel;

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

@@ -0,0 +1,184 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_esm = require("../../../min-dash/dist/index.esm.js");
+const ModelUtil = require("../util/ModelUtil.js");
+const LabelUtil = require("../util/LabelUtil.js");
+const LayoutUtil = require("../../../diagram-js/lib/layout/LayoutUtil.js");
+const DiUtil = require("../util/DiUtil.js");
+const LabelUtil$1 = require("../features/label-editing/LabelUtil.js");
+const Util = require("./Util.js");
+function elementData(semantic, di, attrs) {
+  return index_esm.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 [LayoutUtil.getMid(source), LayoutUtil.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: Util.elementToString(refSemantic),
+    referenced: Util.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 (ModelUtil.is(di, "bpmndi:BPMNPlane")) {
+    var attrs = ModelUtil.is(semantic, "bpmn:SubProcess") ? { id: semantic.id + "_plane" } : {};
+    element = this._elementFactory.createRoot(elementData(semantic, di, attrs));
+    this._canvas.addRootElement(element);
+  } else if (ModelUtil.is(di, "bpmndi:BPMNShape")) {
+    var collapsed = !DiUtil.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 (ModelUtil.is(semantic, "bpmn:BoundaryEvent")) {
+      this._attachBoundary(semantic, element);
+    }
+    if (ModelUtil.is(semantic, "bpmn:Lane")) {
+      parentIndex = 0;
+    }
+    if (ModelUtil.is(semantic, "bpmn:DataStoreReference")) {
+      if (!isPointInsideBBox(parentElement, LayoutUtil.getMid(bounds))) {
+        parentElement = this._canvas.findRoot(parentElement);
+      }
+    }
+    this._canvas.addShape(element, parentElement, parentIndex);
+  } else if (ModelUtil.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 (ModelUtil.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: Util.elementToString(di),
+      semantic: Util.elementToString(semantic)
+    }));
+  }
+  if (LabelUtil.isLabelExternal(semantic) && LabelUtil$1.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: Util.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 = LabelUtil.getExternalLabelBounds(di, element);
+  text = LabelUtil$1.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 || !LabelUtil$1.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: Util.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 ModelUtil.is(semantic, "bpmn:Group");
+}
+exports.default = BpmnImporter;

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

@@ -0,0 +1,296 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const index_esm = require("../../../min-dash/dist/index.esm.js");
+const Util = require("./Util.js");
+const CompatibilityUtil = require("../util/CompatibilityUtil.js");
+function is(element, type) {
+  return element.$instanceOf(type);
+}
+function findDisplayCandidate(definitions) {
+  return index_esm.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: Util.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: Util.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: Util.elementToString(bpmnElement)
+          }),
+          { element: bpmnElement }
+        );
+      } else {
+        diMap[bpmnElement.id] = di;
+        CompatibilityUtil.ensureCompatDiRef(bpmnElement);
+      }
+    } else {
+      logError(
+        translate("no bpmnElement referenced in {element}", {
+          element: Util.elementToString(di)
+        }),
+        { element: di }
+      );
+    }
+  }
+  function handleDiagram(diagram) {
+    handlePlane(diagram.plane);
+  }
+  function handlePlane(plane) {
+    registerDi(plane);
+    index_esm.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: Util.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: Util.elementToString(plane),
+            rootElement: Util.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: Util.elementToString(plane),
+          rootElement: Util.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 = index_esm.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) {
+    index_esm.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) {
+    index_esm.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;
+    }
+    index_esm.forEach(ioSpecification.dataInputs, contextual(handleDataInput, context));
+    index_esm.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() {
+      index_esm.forEach(flowNode.dataInputAssociations, contextual(handleDataAssociation, context));
+      index_esm.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) {
+    index_esm.forEach(laneSet.lanes, contextual(handleLane, context));
+  }
+  function handleLaneSets(laneSets, context) {
+    index_esm.forEach(laneSets, contextual(handleLaneSet, context));
+  }
+  function handleFlowElementsContainer(container, context) {
+    handleFlowElements(container.flowElements, context);
+    if (container.laneSets) {
+      handleLaneSets(container.laneSets, context);
+    }
+  }
+  function handleFlowElements(flowElements, context) {
+    index_esm.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: Util.elementToString(e),
+            context: context ? Util.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) {
+    index_esm.forEach(collaboration.participants, contextual(handleParticipant, context));
+    handleArtifacts(collaboration.artifacts, context);
+    deferred.push(function() {
+      handleMessageFlows(collaboration.messageFlows, context);
+    });
+  }
+  function wireFlowNodeRefs(lane) {
+    index_esm.forEach(lane.flowNodeRef, function(flowNode) {
+      var lanes = flowNode.get("lanes");
+      if (lanes) {
+        lanes.push(lane);
+      }
+    });
+  }
+  return {
+    handleDeferred,
+    handleDefinitions,
+    handleSubProcess,
+    registerDi
+  };
+}
+exports.default = BpmnTreeWalker;