camunda-bpmn-js 5.14.0 → 5.14.2

package/dist/camunda-cloud-modeler.development.js

@@ -143768,1212 +143768,1219 @@
     });
   };
 
-  class CachedValue {
-    constructor(generatorFunction) {
-      this._generate = generatorFunction;
-      this.value = null;
-      this.valid = false;
-    }
-
-    invalidate() {
-      this.valid = false;
-    }
-
-    get() {
-      if (!this.valid) {
-        this.value = this._generate();
-        this.valid = true;
-      }
-
-      return this.value;
-    }
-  }
+  class CachedValue {
+    constructor(generatorFunction) {
+      this._generate = generatorFunction;
+      this.value = null;
+      this.valid = false;
+    }
 
-  function hasOutputMappings(element) {
-    return !!getOutputParameters(element).length;
-  }
-
-  function hasInputParameter(element, name) {
-    return getInputParameters(element).find(function(input) {
-      return (
-        input.target === name || // zeebe
-        input.name === name // camunda
-      );
-    });
-  }
-
-  function getExtensionElementsList(businessObject, type = undefined) {
-    const extensionElements = businessObject.get('extensionElements');
-
-    if (!extensionElements) {
-      return [];
-    }
-
-    const values = extensionElements.get('values');
-
-    if (!values || !values.length) {
-      return [];
-    }
-
-    if (type) {
-      return values.filter(value => is$4(value, type));
-    }
-
-    return values;
-  }
-
-  // helpers //////////
-
-  function getInputParameters(element) {
-    return getParameters(element, 'inputParameters');
-  }
-
-  function getOutputParameters(element) {
-    return getParameters(element, 'outputParameters');
-  }
-
-  function getInputOutput(element) {
-    return (
-      (getExtensionElements$2(element, 'zeebe:IoMapping'))[0] ||
-      (getExtensionElements$2(element, 'camunda:InputOutput'))[0]
-    );
-  }
-
-  function getParameters(element, property) {
-    var inputOutput = getInputOutput(element);
-
-    return (inputOutput && inputOutput.get(property)) || [];
-  }
-
-  function getExtensionElements$2(element, type) {
-    var elements = [];
-    var extensionElements = element.get('extensionElements');
-
-    if (typeof extensionElements !== 'undefined') {
-      var extensionValues = extensionElements.get('values');
-
-      if (typeof extensionValues !== 'undefined') {
-        elements = filter(extensionValues, function(value) {
-          return is$4(value, type);
-        });
-      }
-    }
-
-    return elements;
+    invalidate() {
+      this.valid = false;
+    }
+
+    get() {
+      if (!this.valid) {
+        this.value = this._generate();
+        this.valid = true;
+      }
+
+      return this.value;
+    }
   }
 
-  function getScope(element, globalScope, variableName) {
-    var parents = getParents(element);
-
-    if (hasOutputMappings(element)) {
-      return element;
-    }
-
-    var scopedParent = parents.find(function(parent) {
-      return (
-        is$4(parent, 'bpmn:SubProcess') && hasInputParameter(parent, variableName)
-      );
-    });
-
-    return scopedParent ? scopedParent : globalScope;
-  }
-
-  function getParents(element) {
-    var parents = [];
-    var current = element;
-
-    while (current.$parent) {
-      parents.push(current.$parent);
-      current = current.$parent;
-    }
-
-    return parents;
+  function hasOutputMappings(element) {
+    return !!getOutputParameters(element).length;
   }
 
-  /**
-   * @typedef {Object} AdditionalVariable
-   * @property {string} name The name of the variable
-   * @property {string} [type] The type of the variable
-   * @property {string} [info] A description of the variable displayed as a tooltip
-   * @property {boolean} [isList] whether the variable is a list
-   * @property {Array<AdditionalVariable>} [entries] If the variable is a context, this contains the entries of the context
-   * @property {djs.model.Base} [scope] The scope of the variable, by default it is the container element of the element the variable is created from
-   */
-
-  /**
-   * @typedef {AdditionalVariable} ProcessVariable
-   * @property {Array<ModdleElement>} origin
-   * @property {ModdleElement} scope
-   * @property {Array<Object>} provider
-   */
-
-  /**
-   * Base Class that handles additional variable extractors, variable parsing and caching.
-   */
-  class BaseVariableResolver {
-    constructor(eventBus, bpmnjs) {
-      this.providers = [];
-      this._eventBus = eventBus;
-      this._bpmnjs = bpmnjs;
-
-      this.rawVariables = new CachedValue(this._generateRawVariables.bind(this));
-      this.parsedVariables = new CachedValue(async () => {
-
-        const rawVariables = await this.getRawVariables();
-        const context = { variables: rawVariables };
-
-        eventBus.fire('variableResolver.parseVariables', context);
-
-        return context.variables;
-      });
-
-      eventBus.on([ 'commandStack.changed', 'diagram.clear', 'import.done', 'variables.changed' ], () => {
-        this.invalidateCache();
-      });
-
-      eventBus.on('variableResolver.parseVariables', (e, context) => {
-        context.variables = this._parseVariables(context.variables);
-      });
-    }
-
-    /**
-     * To be implemented by a subclass. This should be an instance of `getProcessVariables` from `@bpmn-io/extract-process-variables`,
-     * either C7 or C8.
-     *
-     * @returns {Promise<Array<ProcessVariable>>}
-     */
-    _baseExtractor() {
-      return [];
-    }
-
-
-    /**
-     * Returns an Object of all variables that are available in the current diagram,
-     * mapped to the respective scope.
-     * Variables with the same name are NOT merged together. Use this function to
-     * run linting, e.g. to check for conflicting variable schemas.
-     *
-     * The result is cached until the diagram changes.
-     *
-     * @async
-     * @returns {Object} rawVariables
-     * @returns {Array<ProcessVariable>} rawVariables.<scope>
-     */
-    async getRawVariables() {
-      return await this.rawVariables.get();
-    }
-
-    /**
-     * Returns an array of all variables that are available in the current diagram.
-     * Variables with the same name are NOT merged together. Use this function to
-     * run linting, e.g. to check for conflicting variable schemas.
-     *
-     * Use this function if you need all availables for all root elements. To filter for scope,
-     * use `getProcessVariables` or `getVariablesForElement`
-     *
-     * The result is cached until the diagram changes.
-     *
-     * @async
-     * @returns {Object} rawVariables
-     * @returns {Array<ProcessVariable>} rawVariables.<rootElement>
-     */
-    async getVariables() {
-      return await this.parsedVariables.get();
-    }
-
-    /**
-     * Force the cache to be invalidated an the variable extractors to be called
-     * again the next time `getVariables` is called.
-     */
-    invalidateCache() {
-      this.rawVariables.invalidate();
-      this.parsedVariables.invalidate();
-    }
-
-    /**
-     * Calls the baseExtractor and maps variables to the respective root element.
-     * Cf. `getRawVariables`
-     *
-     * @async
-     * @returns {Object} rawVariables
-     * @returns {Array<ProcessVariable>} rawVariables.<scope>
-     */
-    async _generateRawVariables() {
-      const bpmnjs = this._bpmnjs;
-
-      const variables = {};
-
-      const workerTasks = bpmnjs.getDefinitions().get('rootElements').map(async element => {
-
-        const elementVariables = await this._baseExtractor(element, [ this._extractor.bind(this) ]);
-
-        // Annotate variables with extractor information
-        variables[element.id] = elementVariables.map(variable => {
-          if (!variable.provider) {
-            variable.provider = [ this._baseExtractor ];
-          }
-
-          return variable;
-        });
-      });
-
-      await Promise.all(workerTasks);
-
-      return variables;
-    }
-
-
-    /**
-     * Parses the list of all variables and checks for duplicates. If duplicates are found, the schemas are merged
-     * into a single variable.
-     * Also maps the attribute `variable.type` to `variable.detail` for the feel editor to display it.
-     *
-     * Cf. `getVariables`
-     *
-     * @async
-     * @param {Object} rawVariables
-     * @param {Array<ProcessVariable>} rawVariables[scope]
-     * @returns {Object} parsedVariables
-     * @returns {Array<ProcessVariable>} parsedVariables[scope]
-     */
-    _parseVariables(rawVariables) {
-      const parsedVariables = {};
-      for (const key in rawVariables) {
-        const variables = rawVariables[key];
-
-        const mergedVariables = [];
-
-        variables.forEach(variable => {
-          const existingVariable = mergedVariables.find(v =>
-            v.name === variable.name && v.scope === variable.scope
-          );
-
-          if (existingVariable) {
-            merge('origin', existingVariable, variable);
-            merge('provider', existingVariable, variable);
-            mergeEntries(existingVariable, variable);
-          } else {
-            mergedVariables.push(variable);
-          }
-        });
-
-        mapToEditorFormat(mergedVariables);
-
-        parsedVariables[key] = mergedVariables;
-      }
-
-      return parsedVariables;
-    }
-
-    /**
-     * Callback used by `@bpmn-io/extract-process-variables`. It adds additional information from the <AdditionalVariable>
-     * returned from the providers to the <ProcessVariable> that is used by the resolver.
-     *
-     * It does not have a return value, the variables are added as a side effect to the `context.processVariables` array
-     *
-     * @async
-     * @param {Object} context
-     * @param {Array<ModdleElement>} context.elements
-     * @param {ModdleElement} context.containerElement
-     * @param {Array<ProcessVariable>} context.processVariables
-     */
-    async _extractor(context) {
-      const {
-        elements,
-        containerElement,
-        processVariables
-      } = context;
-
-      const self = this;
-
-      const workerTasks = elements.flatMap((element) => {
-        return self.providers.map(async (provider) => {
-          const newVariables = await provider.getVariables(element);
-
-          if (!newVariables) {
-            return;
-          }
-
-          // add scope and origin to variables
-          newVariables.forEach(variable => {
-            processVariables.push({
-              ...cloneVariable(variable),
-              origin: [ element ],
-              scope: variable.scope || getScope(element, containerElement, variable.name),
-              provider: [ provider ]
-            });
-          });
-        });
-      });
-
-      await Promise.all(workerTasks);
-    }
-
-    /**
-     * Add a new VariableProvider. This will be used the next time `getVariables` is called.
-     *
-     * @param {VariableProvider} provider
-     */
-    registerProvider(provider) {
-      this.providers.push(provider);
-      this.invalidateCache();
-    }
-
-    /**
-     * Returns all variables for the given root element.
-     *
-     * @async
-     * @param {ModdleElement} element
-     * @returns {Array<ProcessVariable>} variables
-     */
-    async getProcessVariables(element) {
-      const bo = getBusinessObject$2(element);
-
-      const allVariables = await this.getVariables();
-      return allVariables[bo.id] || [];
-    }
-
-    /**
-     * Returns all variables in the scope of the given element.
-     *
-     * @async
-     * @param {ModdleElement} element
-     * @returns {Array<ProcessVariable>} variables
-     */
-    async getVariablesForElement(element) {
-      const bo = getBusinessObject$2(element);
-
-      const root = getRootElement(bo);
-      const allVariables = await this.getProcessVariables(root);
-
-      // (1) get variables for given scope
-      var scopeVariables = allVariables.filter(function(variable) {
-        return variable.scope.id === bo.id;
-      });
-
-      // (2) get variables for parent scopes
-      var parents = getParents(bo);
-
-      var parentsScopeVariables = allVariables.filter(function(variable) {
-        return parents.find(function(parent) {
-          return parent.id === variable.scope.id;
-        });
-      });
-
-      const reversedVariables = [ ...scopeVariables, ...parentsScopeVariables ].reverse();
-
-      const seenNames = new Set();
-
-      return reversedVariables.filter(variable => {
-
-        // if external variable, keep
-        if (variable.provider.find(extractor => extractor !== this._baseExtractor)) {
-          return true;
-        }
-
-        // if not external, keep only the first occurrence of each name
-        if (!seenNames.has(variable.name)) {
-          seenNames.add(variable.name);
-
-          return true;
-        }
-
-        return false;
-      });
-    }
-  }
-
-  BaseVariableResolver.$inject = [ 'eventBus', 'bpmnjs' ];
-
-
-  // helpers //////////////////////
-
-  function getRootElement(element) {
-    const businessObject = getBusinessObject$2(element);
-
-    if (is$4(businessObject, 'bpmn:Participant')) {
-      return businessObject.processRef;
-    }
-
-    if (is$4(businessObject, 'bpmn:Process')) {
-      return businessObject;
-    }
-
-    let parent = businessObject;
-
-    while (parent.$parent && !is$4(parent, 'bpmn:Process')) {
-      parent = parent.$parent;
-    }
-
-    return parent;
-  }
-
-  function merge(property, target, source) {
-    if (!source[property]) {
-      source[property] = [];
-    }
-
-    if (!target[property]) {
-      target[property] = [];
-    }
-
-    const propertiesToAdd = source[property].filter(o => !target[property].includes(o));
-
-    target[property].push(...propertiesToAdd);
-  }
-
-  function mergeEntries(target, source, visited = []) {
-    if (visited.includes(source) || visited.includes(target)) {
-      return;
-    }
-    visited.push(source);
-    visited.push(target);
-
-    target.type = extendList(target.type, source.type, '|');
-    target.info = extendList(target.info, source.info, '\n');
-    target.isList = !!target.isList === !!source.isList ? target.isList : 'optional';
-
-    if (!source.entries) {
-      return;
-    }
-
-    if (!target.entries) {
-      target.entries = [];
-    }
-
-    source.entries.forEach(variable => {
-      const existingEntry = target.entries.find(e => e.name === variable.name);
-
-      if (existingEntry) {
-        mergeEntries(existingEntry, variable, visited);
-      } else {
-        target.entries.push(variable);
-      }
-    });
-  }
-
-  const extendList = (target, source, separator) => {
-    if (!target || target === source) {
-      return source;
-    } else {
-      const existingTypes = target.split(separator);
-      if (!existingTypes.includes(source)) {
-        existingTypes.push(source);
-      }
-      return existingTypes.join(separator);
-    }
-  };
-
-  function mapToEditorFormat(variables) {
-    if (!variables) {
-      return;
-    }
-
-    variables.forEach(variable => {
-      variable.detail = variable.type;
-      mapToEditorFormat(variable.entries);
-    });
-  }
-
-  function cloneVariable(variable) {
-    const newVariable = { ...variable };
-
-    if (newVariable.entries) {
-      newVariable.entries = newVariable.entries.map(cloneVariable);
-    }
-
-    return newVariable;
+  function hasInputParameter(element, name) {
+    return getInputParameters(element).find(function(input) {
+      return (
+        input.target === name || // zeebe
+        input.name === name // camunda
+      );
+    });
   }
 
-  class EntriesContext extends VariableContext$1 {
-    constructor(value = { entries: {} }) {
-      super(value);
-
-      this.value.entries = this.value.entries || {};
-
-      const context = this.value;
-
-      for (const key in context.entries) {
-        const entry = context.entries[key];
-
-        if (entry instanceof EntriesContext) {
-          continue;
-        }
-
-        context.entries[key] = this.constructor.of(context.entries[key]);
-      }
-    }
-
-    getKeys() {
-      return Object.keys(this.value.entries);
-    }
-
-    get(key) {
-      const value = this.value.entries[key];
-
-      if (!value) {
-        return value;
-      }
-
-      if (value.atomic) {
-        return value.atomicValue;
-      }
-
-      return value;
-    }
-
-    set(key, value) {
-      return this.constructor.of(
-        {
-          ...this.value,
-          entries: {
-            ...this.value.entries,
-            [key]: value
-          }
-        }
-      );
-    }
-
-    static of(...contexts) {
-      const unwrap = (context) => {
-
-        if (
-          this.isAtomic(context)
-        ) {
-          if (context instanceof this) {
-            return context.value;
-          }
-
-          return {
-            atomic: true,
-            atomicValue: context
-          };
-        }
-
-        return { ...context };
-      };
-
-      const merged = contexts.reduce((merged, context) => {
-
-        const {
-          entries = {},
-          ...rest
-        } = unwrap(context);
-
-        return {
-          ...merged,
-          ...rest,
-          entries: {
-            ...merged.entries,
-            ...entries
-          }
-        };
-      }, {});
-
-      return new this(merged);
-    }
+  function getExtensionElementsList(businessObject, type = undefined) {
+    const extensionElements = businessObject.get('extensionElements');
+
+    if (!extensionElements) {
+      return [];
+    }
+
+    const values = extensionElements.get('values');
+
+    if (!values || !values.length) {
+      return [];
+    }
+
+    if (type) {
+      return values.filter(value => is$4(value, type));
+    }
+
+    return values;
+  }
+
+  // helpers //////////
+
+  function getInputParameters(element) {
+    return getParameters(element, 'inputParameters');
+  }
+
+  function getOutputParameters(element) {
+    return getParameters(element, 'outputParameters');
+  }
+
+  function getInputOutput(element) {
+    return (
+      (getExtensionElements$2(element, 'zeebe:IoMapping'))[0] ||
+      (getExtensionElements$2(element, 'camunda:InputOutput'))[0]
+    );
+  }
+
+  function getParameters(element, property) {
+    var inputOutput = getInputOutput(element);
+
+    return (inputOutput && inputOutput.get(property)) || [];
+  }
+
+  function getExtensionElements$2(element, type) {
+    var elements = [];
+    var extensionElements = element.get('extensionElements');
+
+    if (typeof extensionElements !== 'undefined') {
+      var extensionValues = extensionElements.get('values');
+
+      if (typeof extensionValues !== 'undefined') {
+        elements = filter(extensionValues, function(value) {
+          return is$4(value, type);
+        });
+      }
+    }
+
+    return elements;
+  }
+
+  function getScope(element, globalScope, variableName) {
+    var parents = getParents(element);
+
+    if (hasOutputMappings(element)) {
+      return element;
+    }
+
+    var scopedParent = parents.find(function(parent) {
+      return (
+        is$4(parent, 'bpmn:SubProcess') && hasInputParameter(parent, variableName)
+      );
+    });
+
+    return scopedParent ? scopedParent : globalScope;
+  }
+
+  function getParents(element) {
+    var parents = [];
+    var current = element;
+
+    while (current.$parent) {
+      parents.push(current.$parent);
+      current = current.$parent;
+    }
+
+    return parents;
+  }
+
+  /**
+   * @typedef {Object} AdditionalVariable
+   * @property {string} name The name of the variable
+   * @property {string} [type] The type of the variable
+   * @property {string} [info] A description of the variable displayed as a tooltip
+   * @property {boolean} [isList] whether the variable is a list
+   * @property {Array<AdditionalVariable>} [entries] If the variable is a context, this contains the entries of the context
+   * @property {djs.model.Base} [scope] The scope of the variable, by default it is the container element of the element the variable is created from
+   */
+
+  /**
+   * @typedef {AdditionalVariable} ProcessVariable
+   * @property {Array<ModdleElement>} origin
+   * @property {ModdleElement} scope
+   * @property {Array<Object>} provider
+   */
+
+  /**
+   * Base Class that handles additional variable extractors, variable parsing and caching.
+   */
+  class BaseVariableResolver {
+    constructor(eventBus, bpmnjs) {
+      this.providers = [];
+      this._eventBus = eventBus;
+      this._bpmnjs = bpmnjs;
+
+      this.rawVariables = new CachedValue(this._generateRawVariables.bind(this));
+      this.parsedVariables = new CachedValue(async () => {
+
+        const rawVariables = await this.getRawVariables();
+        const context = { variables: rawVariables };
+
+        eventBus.fire('variableResolver.parseVariables', context);
+
+        return context.variables;
+      });
+
+      eventBus.on([ 'commandStack.changed', 'diagram.clear', 'import.done', 'variables.changed' ], () => {
+        this.invalidateCache();
+      });
+
+      eventBus.on('variableResolver.parseVariables', (e, context) => {
+        context.variables = this._parseVariables(context.variables);
+      });
+    }
+
+    /**
+     * To be implemented by a subclass. This should be an instance of `getProcessVariables` from `@bpmn-io/extract-process-variables`,
+     * either C7 or C8.
+     *
+     * @returns {Promise<Array<ProcessVariable>>}
+     */
+    _baseExtractor() {
+      return [];
+    }
+
+
+    /**
+     * Returns an Object of all variables that are available in the current diagram,
+     * mapped to the respective scope.
+     * Variables with the same name are NOT merged together. Use this function to
+     * run linting, e.g. to check for conflicting variable schemas.
+     *
+     * The result is cached until the diagram changes.
+     *
+     * @async
+     * @returns {Object} rawVariables
+     * @returns {Array<ProcessVariable>} rawVariables.<scope>
+     */
+    async getRawVariables() {
+      return await this.rawVariables.get();
+    }
+
+    /**
+     * Returns an array of all variables that are available in the current diagram.
+     * Variables with the same name are NOT merged together. Use this function to
+     * run linting, e.g. to check for conflicting variable schemas.
+     *
+     * Use this function if you need all availables for all root elements. To filter for scope,
+     * use `getProcessVariables` or `getVariablesForElement`
+     *
+     * The result is cached until the diagram changes.
+     *
+     * @async
+     * @returns {Object} rawVariables
+     * @returns {Array<ProcessVariable>} rawVariables.<rootElement>
+     */
+    async getVariables() {
+      return await this.parsedVariables.get();
+    }
+
+    /**
+     * Force the cache to be invalidated an the variable extractors to be called
+     * again the next time `getVariables` is called.
+     */
+    invalidateCache() {
+      this.rawVariables.invalidate();
+      this.parsedVariables.invalidate();
+    }
+
+    /**
+     * Calls the baseExtractor and maps variables to the respective root element.
+     * Cf. `getRawVariables`
+     *
+     * @async
+     * @returns {Object} rawVariables
+     * @returns {Array<ProcessVariable>} rawVariables.<scope>
+     */
+    async _generateRawVariables() {
+      const bpmnjs = this._bpmnjs;
+
+      const variables = {};
+
+      const workerTasks = bpmnjs.getDefinitions().get('rootElements').map(async element => {
+
+        const elementVariables = await this._baseExtractor(element, [ this._extractor.bind(this) ]);
+
+        // Annotate variables with extractor information
+        variables[element.id] = elementVariables.map(variable => {
+          if (!variable.provider) {
+            variable.provider = [ this._baseExtractor ];
+          }
+
+          return variable;
+        });
+      });
+
+      await Promise.all(workerTasks);
+
+      return variables;
+    }
+
+
+    /**
+     * Parses the list of all variables and checks for duplicates. If duplicates are found, the schemas are merged
+     * into a single variable.
+     * Also maps the attribute `variable.type` to `variable.detail` for the feel editor to display it.
+     *
+     * Cf. `getVariables`
+     *
+     * @async
+     * @param {Object} rawVariables
+     * @param {Array<ProcessVariable>} rawVariables[scope]
+     * @returns {Object} parsedVariables
+     * @returns {Array<ProcessVariable>} parsedVariables[scope]
+     */
+    _parseVariables(rawVariables) {
+      const parsedVariables = {};
+      for (const key in rawVariables) {
+        const variables = rawVariables[key];
+
+        const mergedVariables = [];
+
+        variables.forEach(variable => {
+          const existingVariable = mergedVariables.find(v =>
+            v.name === variable.name && v.scope === variable.scope
+          );
+
+          if (existingVariable) {
+            merge('origin', existingVariable, variable);
+            merge('provider', existingVariable, variable);
+            mergeEntries(existingVariable, variable);
+          } else {
+            mergedVariables.push(variable);
+          }
+        });
+
+        mapToEditorFormat(mergedVariables);
+
+        parsedVariables[key] = mergedVariables;
+      }
+
+      return parsedVariables;
+    }
+
+    /**
+     * Callback used by `@bpmn-io/extract-process-variables`. It adds additional information from the <AdditionalVariable>
+     * returned from the providers to the <ProcessVariable> that is used by the resolver.
+     *
+     * It does not have a return value, the variables are added as a side effect to the `context.processVariables` array
+     *
+     * @async
+     * @param {Object} context
+     * @param {Array<ModdleElement>} context.elements
+     * @param {ModdleElement} context.containerElement
+     * @param {Array<ProcessVariable>} context.processVariables
+     */
+    async _extractor(context) {
+      const {
+        elements,
+        containerElement,
+        processVariables
+      } = context;
+
+      const self = this;
+
+      const workerTasks = elements.flatMap((element) => {
+        return self.providers.map(async (provider) => {
+          const newVariables = await provider.getVariables(element);
+
+          if (!newVariables) {
+            return;
+          }
+
+          // add scope and origin to variables
+          newVariables.forEach(variable => {
+            processVariables.push({
+              ...cloneVariable(variable),
+              origin: [ element ],
+              scope: variable.scope || getScope(element, containerElement, variable.name),
+              provider: [ provider ]
+            });
+          });
+        });
+      });
+
+      await Promise.all(workerTasks);
+    }
+
+    /**
+     * Add a new VariableProvider. This will be used the next time `getVariables` is called.
+     *
+     * @param {VariableProvider} provider
+     */
+    registerProvider(provider) {
+      this.providers.push(provider);
+      this.invalidateCache();
+    }
+
+    /**
+     * Returns all variables for the given root element.
+     *
+     * @async
+     * @param {ModdleElement} element
+     * @returns {Array<ProcessVariable>} variables
+     */
+    async getProcessVariables(element) {
+      const bo = getBusinessObject$2(element);
+
+      const allVariables = await this.getVariables();
+      return allVariables[bo.id] || [];
+    }
+
+    /**
+     * Returns all variables in the scope of the given element.
+     *
+     * @async
+     * @param {ModdleElement} element
+     * @returns {Array<ProcessVariable>} variables
+     */
+    async getVariablesForElement(element) {
+      const bo = getBusinessObject$2(element);
+
+      const root = getRootElement(bo);
+      const allVariables = await this.getProcessVariables(root);
+
+      // (1) get variables for given scope
+      var scopeVariables = allVariables.filter(function(variable) {
+        return variable.scope.id === bo.id;
+      });
+
+      // (2) get variables for parent scopes
+      var parents = getParents(bo);
+
+      var parentsScopeVariables = allVariables.filter(function(variable) {
+        return parents.find(function(parent) {
+          return parent.id === variable.scope.id;
+        });
+      });
+
+      const reversedVariables = [ ...scopeVariables, ...parentsScopeVariables ].reverse();
+
+      const seenNames = new Set();
+
+      return reversedVariables.filter(variable => {
+
+        // if external variable, keep
+        if (variable.provider.find(extractor => extractor !== this._baseExtractor)) {
+          return true;
+        }
+
+        // if not external, keep only the first occurrence of each name
+        if (!seenNames.has(variable.name)) {
+          seenNames.add(variable.name);
+
+          return true;
+        }
+
+        return false;
+      });
+    }
+  }
+
+  BaseVariableResolver.$inject = [ 'eventBus', 'bpmnjs' ];
+
+
+  // helpers //////////////////////
+
+  function getRootElement(element) {
+    const businessObject = getBusinessObject$2(element);
+
+    if (is$4(businessObject, 'bpmn:Participant')) {
+      return businessObject.processRef;
+    }
+
+    if (is$4(businessObject, 'bpmn:Process')) {
+      return businessObject;
+    }
+
+    let parent = businessObject;
+
+    while (parent.$parent && !is$4(parent, 'bpmn:Process')) {
+      parent = parent.$parent;
+    }
+
+    return parent;
+  }
+
+  function merge(property, target, source) {
+    if (!source[property]) {
+      source[property] = [];
+    }
+
+    if (!target[property]) {
+      target[property] = [];
+    }
+
+    const propertiesToAdd = source[property].filter(o => !target[property].includes(o));
+
+    target[property].push(...propertiesToAdd);
+  }
+
+  function mergeEntries(target, source, visited = []) {
+    if (visited.includes(source) || visited.includes(target)) {
+      return;
+    }
+    visited.push(source);
+    visited.push(target);
+
+    target.type = extendList(target.type, source.type, '|');
+    target.info = extendList(target.info, source.info, '\n');
+    target.isList = !!target.isList === !!source.isList ? target.isList : 'optional';
+
+    if (!source.entries) {
+      return;
+    }
+
+    if (!target.entries) {
+      target.entries = [];
+    }
+
+    source.entries.forEach(variable => {
+      const existingEntry = target.entries.find(e => e.name === variable.name);
+
+      if (existingEntry) {
+        mergeEntries(existingEntry, variable, visited);
+      } else {
+        target.entries.push(variable);
+      }
+    });
+  }
+
+  const extendList = (target, source, separator) => {
+    if (!target || target === source) {
+      return source;
+    } else {
+      const existingTypes = target.split(separator);
+      if (!existingTypes.includes(source)) {
+        existingTypes.push(source);
+      }
+      return existingTypes.join(separator);
+    }
+  };
+
+  function mapToEditorFormat(variables) {
+    if (!variables) {
+      return;
+    }
+
+    variables.forEach(variable => {
+      variable.detail = variable.type;
+      mapToEditorFormat(variable.entries);
+    });
+  }
+
+  function cloneVariable(variable) {
+    const newVariable = { ...variable };
+
+    if (newVariable.entries) {
+      newVariable.entries = newVariable.entries.map(cloneVariable);
+    }
+
+    return newVariable;
+  }
+
+  class EntriesContext extends VariableContext$1 {
+    constructor(value = { entries: {} }) {
+      super(value);
+
+      this.value.entries = this.value.entries || {};
+
+      const context = this.value;
+
+      for (const key in context.entries) {
+        const entry = context.entries[key];
+
+        if (entry instanceof EntriesContext) {
+          continue;
+        }
+
+        context.entries[key] = this.constructor.of(context.entries[key]);
+      }
+    }
+
+    getKeys() {
+      return Object.keys(this.value.entries);
+    }
+
+    get(key) {
+      const value = this.value.entries[key];
+
+      if (!value) {
+        return value;
+      }
+
+      if (value.atomic) {
+        return value.atomicValue;
+      }
+
+      return value;
+    }
+
+    set(key, value) {
+      return this.constructor.of(
+        {
+          ...this.value,
+          entries: {
+            ...this.value.entries,
+            [key]: value
+          }
+        }
+      );
+    }
+
+    static of(...contexts) {
+      const unwrap = (context) => {
+
+        if (
+          this.isAtomic(context)
+        ) {
+          if (context instanceof this) {
+            return context.value;
+          }
+
+          return {
+            atomic: true,
+            atomicValue: context
+          };
+        }
+
+        return { ...context };
+      };
+
+      const merged = contexts.reduce((merged, context) => {
+
+        const {
+          entries = {},
+          ...rest
+        } = unwrap(context);
+
+        return {
+          ...merged,
+          ...rest,
+          entries: {
+            ...merged.entries,
+            ...entries
+          }
+        };
+      }, {});
+
+      return new this(merged);
+    }
+  }
+
+  function parseVariables(variables) {
+
+    const variablesToResolve = [];
+
+    // Step 1 - Parse all variables and populate all that don't have references
+    // to other variables
+    variables.forEach(variable => {
+      variable.origin.forEach(origin => {
+        const expressionDetails = getExpressionDetails(variable, origin);
+
+        if (!expressionDetails) {
+          return;
+        }
+
+        const { expression, unresolved } = expressionDetails;
+
+        variablesToResolve.push({ variable, expression, unresolved });
+      });
+    });
+
+    // Step 2 - Order all Variables and resolve them
+    return resolveReferences(variablesToResolve, variables);
+  }
+
+  function resolveReferences(variablesToResolve, allVariables) {
+    const sortedVariables = [];
+
+    // Step 2.1 - Try to order Variables that rely on each other
+    variablesToResolve.forEach((details) => {
+      const { variable, unresolved } = details;
+      const insertBefore = sortedVariables.findIndex(({ unresolved: u }) => {
+        return u.includes(variable.name);
+      });
+
+      // Insert directly before the first variable that depends on this one
+      if (insertBefore > -1) {
+        sortedVariables.splice(insertBefore, 0, details);
+        return;
+      }
+
+      // Insert directly after the last variable that this one depends on
+      // this ensures that later downstream variables are behind this one
+      const insertAfter = sortedVariables.findLastIndex(({ variable: v }) => {
+        return unresolved.includes(v.name);
+      });
+
+      if (insertAfter > -1) {
+        sortedVariables.splice(insertAfter + 1, 0, details);
+        return;
+      }
+
+      sortedVariables.push(details);
+    });
+
+    const variablesWithoutMappings = allVariables.filter(v =>
+      !variablesToResolve.find(({ variable: unresolved }) => {
+      })
+    );
+
+    const rootContext = {
+      entries: toOptimizedFormat(variablesWithoutMappings)
+    };
+
+    const newVariables = [];
+
+    // Step 2.2 - parse in order, building up the context with resolved variable values
+    // This will resolve all variables that don't have circular dependencies on each other
+    sortedVariables.forEach(({ variable, expression }) => {
+      const resultContext = getResultContext(expression, filterForScope(rootContext, variable));
+
+      let computedResult = resultContext.computedValue();
+
+      // Wrap primitive values in an EntriesContext
+      if (!(computedResult instanceof EntriesContext)) {
+        computedResult = EntriesContext.of(computedResult);
+      }
+
+      // Ensure we don't copy the scope from the mapped variable
+      computedResult.scope = variable.scope;
+
+      rootContext.entries[variable.name] = computedResult;
+
+      newVariables.push({
+        newVariable: toUnifiedFormat({
+          [variable.name]: computedResult
+        })[0],
+        oldVariable: variable
+      });
+    });
+
+    // Ensure meta-data (scope, origin) is kept from original variable
+    const result = newVariables.map(({ newVariable, oldVariable }) => {
+      if (oldVariable) {
+        return {
+          ...newVariable,
+          ...oldVariable
+        };
+      }
+      return newVariable;
+    });
+
+    return result;
+  }
+
+
+  // helpers //////////////////////
+
+  /**
+   * Parses the expression with the given variables and return the result context
+   *
+   * @param {String} expression
+   * @param {Variables} variables
+   * @returns {EntriesContext}
+   */
+  function getResultContext(expression, variables = {}) {
+    const contextTracker = trackVariables$1(variables, EntriesContext);
+
+    // This is a hack to get the latest variables from the context tracker
+    // lezer does not automatically annotate the parse tree with the context
+    let latestVariables = contextTracker.start;
+
+    const customContextTracker = new ContextTracker({
+      start: contextTracker.start,
+      reduce(...args) {
+        const result = contextTracker.reduce(...args);
+        latestVariables = result;
+        return result;
+      }
+    });
+
+    const contextualParser = parser$3.configure({
+      contextTracker: customContextTracker,
+      strict: true
+    });
+
+    try {
+      contextualParser.parse(expression);
+    } catch (error) {
+
+      // bail out in case of an error
+      return latestVariables;
+    }
+
+    return latestVariables;
   }
 
-  function parseVariables(variables) {
-
-    const variablesToResolve = [];
-
-    // Step 1 - Parse all variables and populate all that don't have references
-    // to other variables
-    variables.forEach(variable => {
-      variable.origin.forEach(origin => {
-        const expressionDetails = getExpressionDetails(variable, origin);
-
-        if (!expressionDetails) {
-          return;
-        }
-
-        const { expression, unresolved } = expressionDetails;
-
-        variablesToResolve.push({ variable, expression, unresolved });
-      });
-    });
-
-    // Step 2 - Order all Variables and resolve them
-    return resolveReferences(variablesToResolve, variables);
-  }
-
-  function resolveReferences(variablesToResolve, allVariables) {
-    const sortedVariables = [];
-
-    // Step 2.1 - Try to order Variables that rely on each other
-    variablesToResolve.forEach((details) => {
-      const { variable, unresolved } = details;
-      const insertBefore = sortedVariables.findIndex(({ unresolved: u }) => {
-        return u.includes(variable.name);
-      });
-
-      // Insert directly before the first variable that depends on this one
-      if (insertBefore > -1) {
-        sortedVariables.splice(insertBefore, 0, details);
-        return;
-      }
-
-      // Insert directly after the last variable that this one depends on
-      // this ensures that later downstream variables are behind this one
-      const insertAfter = sortedVariables.findLastIndex(({ variable: v }) => {
-        return unresolved.includes(v.name);
-      });
-
-      if (insertAfter > -1) {
-        sortedVariables.splice(insertAfter + 1, 0, details);
-        return;
-      }
-
-      sortedVariables.push(details);
-    });
-
-    const variablesWithoutMappings = allVariables.filter(v =>
-      !variablesToResolve.find(({ variable: unresolved }) => {
-      })
-    );
-
-    const rootContext = {
-      entries: toOptimizedFormat(variablesWithoutMappings)
-    };
-
-    const newVariables = [];
-
-    // Step 2.2 - parse in order, building up the context with resolved variable values
-    // This will resolve all variables that don't have circular dependencies on each other
-    sortedVariables.forEach(({ variable, expression }) => {
-      const resultContext = getResultContext(expression, filterForScope(rootContext, variable));
-
-      let computedResult = resultContext.computedValue();
-
-      // Wrap primitive values in an EntriesContext
-      if (!(computedResult instanceof EntriesContext)) {
-        computedResult = EntriesContext.of(computedResult);
-      }
-
-      // Ensure we don't copy the scope from the mapped variable
-      computedResult.scope = variable.scope;
-
-      rootContext.entries[variable.name] = computedResult;
-
-      newVariables.push({
-        newVariable: toUnifiedFormat({
-          [variable.name]: computedResult
-        })[0],
-        oldVariable: variable
-      });
-    });
-
-    // Ensure meta-data (scope, origin) is kept from original variable
-    const result = newVariables.map(({ newVariable, oldVariable }) => {
-      if (oldVariable) {
-        return {
-          ...newVariable,
-          ...oldVariable
-        };
-      }
-      return newVariable;
-    });
-
-    return result;
-  }
-
-
-  // helpers //////////////////////
-
-  /**
-   * Parses the expression with the given variables and return the result context
-   *
-   * @param {String} expression
-   * @param {Variables} variables
-   * @returns {EntriesContext}
-   */
-  function getResultContext(expression, variables = {}) {
-    const contextTracker = trackVariables$1(variables, EntriesContext);
-
-    // This is a hack to get the latest variables from the context tracker
-    // lezer does not automatically annotate the parse tree with the context
-    let latestVariables = null;
-
-    const customContextTracker = new ContextTracker({
-      start: contextTracker.start,
-      reduce(...args) {
-        const result = contextTracker.reduce(...args);
-        latestVariables = result;
-        return result;
-      }
-    });
-
-    const contextualParser = parser$3.configure({
-      contextTracker: customContextTracker
-    });
-
-    contextualParser.parse(expression);
-
-    return latestVariables;
-  }
-
-  /**
-   * Given a Variable and a specific origin, return the mapping expression and all
-   * unresolved variables used in that expression. Returns undefined if no mapping
-   * exists for the given origin.
-   *
-   * @param {ProcessVariable} variable
-   * @param {djs.model.Base} origin
-   * @returns {{ expression: String, unresolved: Array<String> }}}
-   */
-  function getExpressionDetails(variable, origin) {
-
-    // if variable scope is !== origin (global), prioritize IoExpression over ScriptExpression
-    // if variable scope is === origin (local), prioritize ScriptExpression over IoExpression
-    const expression = variable.scope !== origin
-      ? getIoExpression(variable, origin) || getScriptExpression(variable, origin)
-      : getScriptExpression(variable, origin) || getIoExpression(variable, origin);
-
-    if (!expression) {
-      return;
-    }
-
-    const result = getResultContext(expression);
-
-    const unresolved = findUnresolvedVariables(result);
-
-    return { expression, unresolved };
-  }
-
-  /**
-   * Given a Variable and a specific origin, return the mapping expression for all
-   * input outputs mapping. Returns undefined if no mapping exists for the given origin.
-   *
-   * @param {ProcessVariable} variable
-   * @param {djs.model.Base} origin
-   * @returns { expression: String}
-   */
-  function getIoExpression(variable, origin) {
-    const ioMapping = getExtensionElementsList(origin, 'zeebe:IoMapping')[0];
-
-    if (!ioMapping) {
-      return;
-    }
-
-    let mappings;
-    if (origin === variable.scope) {
-      mappings = ioMapping.inputParameters;
-    } else {
-      mappings = ioMapping.outputParameters;
-    }
-
-    if (!mappings) {
-      return;
-    }
-
-    const mapping = mappings.slice().reverse().find(mapping => mapping.target === variable.name);
-
-    if (!mapping || !mapping.source) {
-      return;
-    }
-
-    return mapping.source.substring(1);
-
-  }
-
-  /**
-   * Given a Variable and a specific origin, return the mapping expression for script
-   * task result variable. Returns undefined if no mapping exists for the given origin.
-   *
-   * @param {ProcessVariable} variable
-   * @param {djs.model.Base} origin
-   * @returns {string}
-   */
-  function getScriptExpression(variable, origin) {
-    const script = getExtensionElementsList(origin, 'zeebe:Script')[0];
-
-    if (!script || !script.expression) {
-      return;
-    }
-
-    if (script.resultVariable === variable.name) {
-      return script.expression.substring(1);
-    }
-  }
-
-  /**
-   * Traverses the parseTree and returns all `VariableName` nodes with no value
-   *
-   * @param {Object} node
-   * @returns {Array<String>}
-   */
-  function findUnresolvedVariables(node) {
-    const results = [];
-
-    results.push(...(node.children.flatMap(findUnresolvedVariables)));
-
-    if (node.name === 'VariableName' && !node.value) {
-      results.push(node.raw);
-    }
-
-    return results;
-  }
-
-
-  /**
-   * Transforms the entries of a variable from an array to an object.
-   * This allows faster lookup times during parsing.
-   *
-   * [ { name, entries: [] } ]
-   * to
-   * {name: { name, entries: {} }}
-   */
-  function toOptimizedFormat(variables) {
-
-    if (!variables) {
-      return;
-    }
-
-    const result = {};
-
-    variables.forEach(variable => {
-      result[variable.name] = { ...variable };
-      result[variable.name].entries = toOptimizedFormat(variable.entries);
-    });
-
-    return result;
-  }
-
-  /**
-   * Transforms EntriesContext to the format required by the feel-editor
-   */
-  function toUnifiedFormat(variables) {
-    if (!variables) {
-      return;
-    }
-
-    const result = [];
-
-    for (const key in variables) {
-      let variable = variables[key];
-
-      if (variable instanceof EntriesContext) {
-        variable = variable.value;
-      }
-
-      if (!variable) {
-        result.push({
-          name: key
-        });
-        continue;
-      }
-
-      result.push({
-        ...annotate(variable),
-        entries: toUnifiedFormat(variable.entries),
-        name: key,
-        scope: variable.scope
-      });
-    }
-
-    return result;
-  }
-
-
-  function annotate(variable) {
-    return {
-      ...variable,
-      type: getType$1(variable),
-      info: getInfo(variable)
-    };
-
-  }
-
-  function getType$1(variable) {
-
-    if (!variable) {
-      return '';
-    }
-
-    if (variable.type) {
-      return variable.type;
-    }
-
-    if (variable.entries && Object.keys(variable.entries).length) {
-      return 'Context';
-    }
-
-    if (variable.atomicValue) {
-      return capitalize$1(typeof variable.atomicValue);
-    }
-
-    return '';
-  }
-
-  function getInfo(variable) {
-    if (!variable) {
-      return '';
-    }
-
-    if (variable.info) {
-      return variable.info;
-    }
-
-    if (variable.atomicValue) {
-      return '' + variable.atomicValue;
-    }
-
-    return '';
-  }
-
-  function capitalize$1(string) {
-    return string.charAt(0).toUpperCase() + string.slice(1);
-  }
-
-  function filterForScope(context, variable) {
-    const scopedResults = {
-      entries: {}
-    };
-
-    const validScopes = variable.origin.flatMap(bo => {
-      return [ bo, ...getParents(bo) ];
-    });
-
-    for (const key in context.entries) {
-      const entry = context.entries[key];
-
-      if (validScopes.find(scope => scope.id === entry.scope.id)) {
-        scopedResults.entries[key] = entry;
-      }
-    }
-
-    return scopedResults;
-  }
-
-  /**
-   * Remove input/output element name after current definition
-   */
-  function getElementNamesToRemove(moddleElement, inputOutput) {
-    const namesToFilter = [];
-
-    // Input: remove all inputs defined after the current input definition
-    if (is$4(moddleElement, 'zeebe:Input')) {
-      const allInputs = inputOutput.inputParameters;
-
-      const inputsToFilter =
-          allInputs
-            .slice(allInputs.indexOf(moddleElement))
-            .map(o => o.target);
-
-      namesToFilter.push(...inputsToFilter);
-    }
-
-    const allOutputs = inputOutput.outputParameters;
-
-    // Output: remove all outputs defined after the current output definition
-    if (is$4(moddleElement, 'zeebe:Output')) {
-
-      // Get all output mappings defined after the current element, including own name
-      const outputsToFilter = allOutputs
-        .slice(allOutputs.indexOf(moddleElement))
-        .map(o => o.target);
-
-      namesToFilter.push(...outputsToFilter);
-    }
-
-    // Input or general property: remove all outputs
-    else if (allOutputs) {
-
-      // Input or execution-related element, remove all outputs
-      const outputsToFilter = allOutputs
-        .map(o => o.target);
-
-      namesToFilter.push(...outputsToFilter);
-    }
-
-    return namesToFilter;
+  /**
+   * Given a Variable and a specific origin, return the mapping expression and all
+   * unresolved variables used in that expression. Returns undefined if no mapping
+   * exists for the given origin.
+   *
+   * @param {ProcessVariable} variable
+   * @param {djs.model.Base} origin
+   * @returns {{ expression: String, unresolved: Array<String> }}}
+   */
+  function getExpressionDetails(variable, origin) {
+
+    // if variable scope is !== origin (global), prioritize IoExpression over ScriptExpression
+    // if variable scope is === origin (local), prioritize ScriptExpression over IoExpression
+    const expression = variable.scope !== origin
+      ? getIoExpression(variable, origin) || getScriptExpression(variable, origin)
+      : getScriptExpression(variable, origin) || getIoExpression(variable, origin);
+
+    if (!expression) {
+      return;
+    }
+
+    const result = getResultContext(expression);
+
+    const unresolved = findUnresolvedVariables(result);
+
+    return { expression, unresolved };
+  }
+
+  /**
+   * Given a Variable and a specific origin, return the mapping expression for all
+   * input outputs mapping. Returns undefined if no mapping exists for the given origin.
+   *
+   * @param {ProcessVariable} variable
+   * @param {djs.model.Base} origin
+   * @returns { expression: String}
+   */
+  function getIoExpression(variable, origin) {
+    const ioMapping = getExtensionElementsList(origin, 'zeebe:IoMapping')[0];
+
+    if (!ioMapping) {
+      return;
+    }
+
+    let mappings;
+    if (origin === variable.scope) {
+      mappings = ioMapping.inputParameters;
+    } else {
+      mappings = ioMapping.outputParameters;
+    }
+
+    if (!mappings) {
+      return;
+    }
+
+    const mapping = mappings.slice().reverse().find(mapping => mapping.target === variable.name);
+
+    if (!mapping || !mapping.source) {
+      return;
+    }
+
+    return mapping.source.substring(1);
+
+  }
+
+  /**
+   * Given a Variable and a specific origin, return the mapping expression for script
+   * task result variable. Returns undefined if no mapping exists for the given origin.
+   *
+   * @param {ProcessVariable} variable
+   * @param {djs.model.Base} origin
+   * @returns {string}
+   */
+  function getScriptExpression(variable, origin) {
+    const script = getExtensionElementsList(origin, 'zeebe:Script')[0];
+
+    if (!script || !script.expression) {
+      return;
+    }
+
+    if (script.resultVariable === variable.name) {
+      return script.expression.substring(1);
+    }
+  }
+
+  /**
+   * Traverses the parseTree and returns all `VariableName` nodes with no value
+   *
+   * @param {Object} node
+   * @returns {Array<String>}
+   */
+  function findUnresolvedVariables(node) {
+    const results = [];
+
+    results.push(...(node.children.flatMap(findUnresolvedVariables)));
+
+    if (node.name === 'VariableName' && !node.value) {
+      results.push(node.raw);
+    }
+
+    return results;
+  }
+
+
+  /**
+   * Transforms the entries of a variable from an array to an object.
+   * This allows faster lookup times during parsing.
+   *
+   * [ { name, entries: [] } ]
+   * to
+   * {name: { name, entries: {} }}
+   */
+  function toOptimizedFormat(variables) {
+
+    if (!variables) {
+      return;
+    }
+
+    const result = {};
+
+    variables.forEach(variable => {
+      result[variable.name] = { ...variable };
+      result[variable.name].entries = toOptimizedFormat(variable.entries);
+    });
+
+    return result;
   }
 
-  const HIGH_PRIORITY$1 = 2000;
-
-  /**
-   * The Camunda 8 Implementation for the VariableResolver.
-   */
-  class ZeebeVariableResolver extends BaseVariableResolver {
-    constructor(eventBus, bpmnjs) {
-      super(eventBus, bpmnjs);
-      this._baseExtractor = getProcessVariables;
-
-      eventBus.on('variableResolver.parseVariables', HIGH_PRIORITY$1, this._resolveVariables);
-    }
-
-    async getVariablesForElement(element, moddleElement) {
-      const variables = await super.getVariablesForElement(element);
-
-      const bo = getBusinessObject$2(element);
-
-      if (!moddleElement) {
-        return variables;
-      }
-
-      const inputOutput = getInputOutput(bo);
-
-      if (!inputOutput) {
-        return variables;
-      }
-
-      const namesToFilter = getElementNamesToRemove(moddleElement, inputOutput);
-
-      return variables.filter(v => {
-
-        // Keep all variables that are also defined in other elements
-        if (v.origin.length > 1 || v.origin[0] !== bo) {
-          return true;
-        }
-
-        // Keep all variables from external data providers in outputs
-        if (
-          is$4(moddleElement, 'zeebe:Output') &&
-          v.provider.find(extractor => extractor !== this._baseExtractor)
-        ) {
-          return true;
-        }
-
-        // Filter all pre-defined variables
-        return !namesToFilter.includes(v.name);
-      });
-    }
-
-    /**
-     * Parsed the variables and resolves the variable schema to kept the
-     * variable schema throughout the process.
-     *
-     * @param {Event} e
-     * @param {Object} context
-     * @param {Array<ProcessVariable>} context.variables
-     */
-    _resolveVariables(e, context) {
-      const rawVariables = context.variables;
-
-      const mappedVariables = {};
-
-      for (const key in rawVariables) {
-        const variables = rawVariables[key];
-        const newVariables = parseVariables(variables);
-
-        mappedVariables[key] = [ ...variables, ...newVariables ];
-      }
-
-      context.variables = mappedVariables;
-    }
+  /**
+   * Transforms EntriesContext to the format required by the feel-editor
+   */
+  function toUnifiedFormat(variables) {
+    if (!variables) {
+      return;
+    }
+
+    const result = [];
+
+    for (const key in variables) {
+      let variable = variables[key];
+
+      if (variable instanceof EntriesContext) {
+        variable = variable.value;
+      }
+
+      if (!variable) {
+        result.push({
+          name: key
+        });
+        continue;
+      }
+
+      result.push({
+        ...annotate(variable),
+        entries: toUnifiedFormat(variable.entries),
+        name: key,
+        scope: variable.scope
+      });
+    }
+
+    return result;
+  }
+
+
+  function annotate(variable) {
+    return {
+      ...variable,
+      type: getType$1(variable),
+      info: getInfo(variable)
+    };
+
+  }
+
+  function getType$1(variable) {
+
+    if (!variable) {
+      return '';
+    }
+
+    if (variable.type) {
+      return variable.type;
+    }
+
+    if (variable.entries && Object.keys(variable.entries).length) {
+      return 'Context';
+    }
+
+    if (variable.atomicValue) {
+      return capitalize$1(typeof variable.atomicValue);
+    }
+
+    return '';
+  }
+
+  function getInfo(variable) {
+    if (!variable) {
+      return '';
+    }
+
+    if (variable.info) {
+      return variable.info;
+    }
+
+    if (variable.atomicValue) {
+      return '' + variable.atomicValue;
+    }
+
+    return '';
+  }
+
+  function capitalize$1(string) {
+    return string.charAt(0).toUpperCase() + string.slice(1);
+  }
+
+  function filterForScope(context, variable) {
+    const scopedResults = {
+      entries: {}
+    };
+
+    const validScopes = variable.origin.flatMap(bo => {
+      return [ bo, ...getParents(bo) ];
+    });
+
+    for (const key in context.entries) {
+      const entry = context.entries[key];
+
+      if (validScopes.find(scope => scope.id === entry.scope.id)) {
+        scopedResults.entries[key] = entry;
+      }
+    }
+
+    return scopedResults;
+  }
+
+  /**
+   * Remove input/output element name after current definition
+   */
+  function getElementNamesToRemove(moddleElement, inputOutput) {
+    const namesToFilter = [];
+
+    // Input: remove all inputs defined after the current input definition
+    if (is$4(moddleElement, 'zeebe:Input')) {
+      const allInputs = inputOutput.inputParameters;
+
+      const inputsToFilter =
+          allInputs
+            .slice(allInputs.indexOf(moddleElement))
+            .map(o => o.target);
+
+      namesToFilter.push(...inputsToFilter);
+    }
+
+    const allOutputs = inputOutput.outputParameters;
+
+    // Output: remove all outputs defined after the current output definition
+    if (is$4(moddleElement, 'zeebe:Output')) {
+
+      // Get all output mappings defined after the current element, including own name
+      const outputsToFilter = allOutputs
+        .slice(allOutputs.indexOf(moddleElement))
+        .map(o => o.target);
+
+      namesToFilter.push(...outputsToFilter);
+    }
+
+    // Input or general property: remove all outputs
+    else if (allOutputs) {
+
+      // Input or execution-related element, remove all outputs
+      const outputsToFilter = allOutputs
+        .map(o => o.target);
+
+      namesToFilter.push(...outputsToFilter);
+    }
+
+    return namesToFilter;
+  }
+
+  const HIGH_PRIORITY$1 = 2000;
+
+  /**
+   * The Camunda 8 Implementation for the VariableResolver.
+   */
+  class ZeebeVariableResolver extends BaseVariableResolver {
+    constructor(eventBus, bpmnjs) {
+      super(eventBus, bpmnjs);
+      this._baseExtractor = getProcessVariables;
+
+      eventBus.on('variableResolver.parseVariables', HIGH_PRIORITY$1, this._resolveVariables);
+    }
+
+    async getVariablesForElement(element, moddleElement) {
+      const variables = await super.getVariablesForElement(element);
+
+      const bo = getBusinessObject$2(element);
+
+      if (!moddleElement) {
+        return variables;
+      }
+
+      const inputOutput = getInputOutput(bo);
+
+      if (!inputOutput) {
+        return variables;
+      }
+
+      const namesToFilter = getElementNamesToRemove(moddleElement, inputOutput);
+
+      return variables.filter(v => {
+
+        // Keep all variables that are also defined in other elements
+        if (v.origin.length > 1 || v.origin[0] !== bo) {
+          return true;
+        }
+
+        // Keep all variables from external data providers in outputs
+        if (
+          is$4(moddleElement, 'zeebe:Output') &&
+          v.provider.find(extractor => extractor !== this._baseExtractor)
+        ) {
+          return true;
+        }
+
+        // Filter all pre-defined variables
+        return !namesToFilter.includes(v.name);
+      });
+    }
+
+    /**
+     * Parsed the variables and resolves the variable schema to kept the
+     * variable schema throughout the process.
+     *
+     * @param {Event} e
+     * @param {Object} context
+     * @param {Array<ProcessVariable>} context.variables
+     */
+    _resolveVariables(e, context) {
+      const rawVariables = context.variables;
+
+      const mappedVariables = {};
+
+      for (const key in rawVariables) {
+        const variables = rawVariables[key];
+        const newVariables = parseVariables(variables);
+
+        mappedVariables[key] = [ ...variables, ...newVariables ];
+      }
+
+      context.variables = mappedVariables;
+    }
+  }
+
+  /**
+   * @typedef Variable
+   * @property {string} name The name of the variable
+   * @property {string} [type] The type of the variable
+   * @property {string} [info] A description of the variable displayed as a tooltip
+   * @property {boolean} [isList] whether the variable is a list
+   * @property {Array<Variable>} [entries] If the variable is a context, this contains the entries of the context
+   * @property {djs.model.Base} [scope] The scope of the variable, by default it is the container element of the element the variable is created from
+   */
+
+  /**
+   * A basic provider that may be extended to provide variables for the variable resolver.
+   *
+   * Extensions should implement the method `getVariables`.
+   */
+  class VariableProvider {
+    constructor(variableResolver) {
+      this._variableResolver = variableResolver;
+      this.register();
+    }
+
+    /**
+     * This method should implement the creation of a list of process variables.
+     *
+     * @param {djs.model.Base} element
+     * @return {Array<Variable>} a list of process variables
+     *
+     * The following example contains one variable
+     *
+     * @example
+     * VariableProvider.getVariables = function(element) {
+     *   const variables = [
+     *     {
+     *       name: 'myVariable',
+     *       type: 'String',
+     *       info: 'This is a global variable'
+     *     }
+     *   ];
+     *
+     *   if (is(element, 'bpmn:Process')) {
+     *     return variables;
+     *   }
+     * }
+     */
+    getVariables(element) { }
+
+    register() {
+      this._variableResolver.registerProvider(this);
+    }
   }
 
-  /**
-   * @typedef Variable
-   * @property {string} name The name of the variable
-   * @property {string} [type] The type of the variable
-   * @property {string} [info] A description of the variable displayed as a tooltip
-   * @property {boolean} [isList] whether the variable is a list
-   * @property {Array<Variable>} [entries] If the variable is a context, this contains the entries of the context
-   * @property {djs.model.Base} [scope] The scope of the variable, by default it is the container element of the element the variable is created from
-   */
-
-  /**
-   * A basic provider that may be extended to provide variables for the variable resolver.
-   *
-   * Extensions should implement the method `getVariables`.
-   */
-  class VariableProvider {
-    constructor(variableResolver) {
-      this._variableResolver = variableResolver;
-      this.register();
-    }
-
-    /**
-     * This method should implement the creation of a list of process variables.
-     *
-     * @param {djs.model.Base} element
-     * @return {Array<Variable>} a list of process variables
-     *
-     * The following example contains one variable
-     *
-     * @example
-     * VariableProvider.getVariables = function(element) {
-     *   const variables = [
-     *     {
-     *       name: 'myVariable',
-     *       type: 'String',
-     *       info: 'This is a global variable'
-     *     }
-     *   ];
-     *
-     *   if (is(element, 'bpmn:Process')) {
-     *     return variables;
-     *   }
-     * }
-     */
-    getVariables(element) { }
-
-    register() {
-      this._variableResolver.registerProvider(this);
-    }
-  }
-
   VariableProvider.$inject = [ 'variableResolver' ];
 
-  /**
-   * TODO: This method tries to mirror the behavior of ConnectorMappings. However, this is not possible in all cases,
-   * as the absence of the header has execution implications. This should be replaced with engine behavior in the
-   * Connector Implementation at one point.
-   */
-  class ConnectorVariableProvider extends VariableProvider {
-    getVariables(element) {
-
-      const result = [];
-
-      const taskheaders = getExtensionElementsList(element, 'zeebe:TaskHeaders')[0];
-
-      if (!taskheaders || !taskheaders.values) {
-        return;
-      }
-
-      const headers = taskheaders.values;
-
-      const resultVariable = headers.find(header => {
-        return header.key === 'resultVariable';
-      });
-
-      const resultExpression = headers.find(header => {
-        return header.key === 'resultExpression';
-      });
-
-      if (resultVariable && resultVariable.value) {
-        result.push({
-          name: resultVariable.value
-        });
-      }
-
-      if (resultExpression && resultExpression.value) {
-
-        // parse with FEEL
-        const resultContext = getResultContext(resultExpression.value.substring(1));
-
-        const expressionVariables = toUnifiedFormat(resultContext.computedValue());
-
-        if (expressionVariables && expressionVariables.length > 0) {
-          result.push(
-            ...expressionVariables[0].entries
-          );
-        }
-      }
-
-      return result;
-    }
+  /**
+   * TODO: This method tries to mirror the behavior of ConnectorMappings. However, this is not possible in all cases,
+   * as the absence of the header has execution implications. This should be replaced with engine behavior in the
+   * Connector Implementation at one point.
+   */
+  class ConnectorVariableProvider extends VariableProvider {
+    getVariables(element) {
+
+      const result = [];
+
+      const taskheaders = getExtensionElementsList(element, 'zeebe:TaskHeaders')[0];
+
+      if (!taskheaders || !taskheaders.values) {
+        return;
+      }
+
+      const headers = taskheaders.values;
+
+      const resultVariable = headers.find(header => {
+        return header.key === 'resultVariable';
+      });
+
+      const resultExpression = headers.find(header => {
+        return header.key === 'resultExpression';
+      });
+
+      if (resultVariable && resultVariable.value) {
+        result.push({
+          name: resultVariable.value
+        });
+      }
+
+      if (resultExpression && resultExpression.value) {
+
+        // parse with FEEL
+        const resultContext = getResultContext(resultExpression.value.substring(1));
+
+        const expressionVariables = toUnifiedFormat(resultContext.computedValue());
+
+        if (expressionVariables && expressionVariables.length > 0) {
+          result.push(
+            ...expressionVariables[0].entries
+          );
+        }
+      }
+
+      return result;
+    }
   }
 
-  const ZeebeVariableResolverModule = {
-    __init__: [
-      'variableResolver',
-      'connectorVariableProvider'
-    ],
-    variableResolver: [ 'type', ZeebeVariableResolver ],
-    connectorVariableProvider: [ 'type', ConnectorVariableProvider ]
+  const ZeebeVariableResolverModule = {
+    __init__: [
+      'variableResolver',
+      'connectorVariableProvider'
+    ],
+    variableResolver: [ 'type', ZeebeVariableResolver ],
+    connectorVariableProvider: [ 'type', ConnectorVariableProvider ]
   };
 
   const EXAMPLE_JSON_PROPERTY_NAME = 'camundaModeler:exampleOutputJson';