@0dep/bpmn-extensions 0.0.2 → 0.0.3

package/README.md

@@ -40,6 +40,10 @@ npm install @0dep/bpmn-extensions bpmn-elements
 - **`zeebe:calledElement`** — call activity target process id.
 - **`zeebe:loopCharacteristics`** — collection-based multi-instance (`inputCollection` / `inputElement`),
   sequential or parallel, with `outputElement` aggregated into the `outputCollection` array in input order.
+- **`zeebe:subscription`** — the referenced message's `correlationKey` is resolved when the catching
+  element (receive task, message event) starts waiting, and exposed on its content as
+  `subscription: { message, correlationKey }` — route an incoming message by matching it against the
+  waiting elements (`getPostponed()`) and signalling the right one.
 
 ## API
 
@@ -128,8 +132,12 @@ in `test/helpers/factory.js`, then run on a real bpmn-elements `Definition`. The
 the engine's `Logger` to the [`debug`](https://www.npmjs.com/package/debug) package, so
 `DEBUG=bpmn-extensions:* npm test` traces the engine and extensions (`:error:*` for errors only).
 
-See the `camunda8-bpmn-schemas` skill (`.claude/skills/`) for a reference of the `zeebe:*`
-extension elements and FEEL.
+# Ecosystem
+
+- [bpmn-engine](https://github.com/paed01/bpmn-engine) — BPMN 2.0 execution engine wrapping `bpmn-elements`; the batteries-included way to run, stop, resume, and recover flows.
+- [bpmn-middleware](https://github.com/zerodep/bpmn-middleware) — Express middleware exposing the engine over HTTP, with pluggable state storage.
+- [@onify/flow-extensions](https://github.com/onify/flow-extensions) — Onify Flow extensions for `bpmn-elements`.
+- [dmn-elements](https://github.com/zerodep/dmn-elements) — Executable DMN 1.3 decision elements; back a Business Rule Task with it (see [Conformance](/docs/Conformance.md#business-rule-task-and-dmn)).
 
 ## License
 

package/dist/index.js

@@ -16203,11 +16203,11 @@ function evaluateFeel(expression, context) {
  * @param {string} expression FEEL unary test
  * @param {any} input The value being tested, available as `?` in the test
  * @param {Record<string, any>} [context] Additional variables in scope
- * @returns {boolean}
+ * @returns {boolean} true only when the test is satisfied — an undecidable (null) test is false
  */
 function evaluateFeelUnaryTest(expression, input, context) {
-  const { value } = unaryTest(stripFeel(expression), { ...(context || {}), '?': input });
-  return value;
+  const { value } = unaryTest(stripFeel(expression), { ...context, '?': input });
+  return value === true;
 }
 
 /**
@@ -16227,10 +16227,17 @@ function resolveValue(value, context) {
  * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups).
  */
 class FormatActivity {
+  /**
+   * @param {import('bpmn-elements').Activity} activity
+   * @param {any} assignmentDefinition
+   */
   constructor(activity, assignmentDefinition) {
     this.activity = activity;
     this.assignmentDefinition = assignmentDefinition;
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   resolve(elementApi) {
     const scope = elementApi.environment.variables;
     const result = {};
@@ -16259,9 +16266,15 @@ class FormatActivity {
  * Format a process on enter: documentation.
  */
 class FormatProcess {
+  /**
+   * @param {import('bpmn-elements').Process} bp
+   */
   constructor(bp) {
     this.process = bp;
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Process>} elementApi
+   */
   resolve(elementApi) {
     const result = {};
     const documentation = this.process.behaviour.documentation;
@@ -16280,7 +16293,7 @@ class FormatProcess {
 function resolveList(value, scope) {
   if (!value) return undefined;
   const resolved = resolveValue(value, scope);
-  if (Array.isArray(resolved)) return resolved.filter((v) => v !== null && v !== undefined);
+  if (Array.isArray(resolved)) return resolved.filter(Boolean);
   if (typeof resolved !== 'string') return undefined;
   return resolved
     .split(',')
@@ -16558,6 +16571,12 @@ function JobService(taskType, activity) {
   this.activity = activity;
 }
 
+/**
+ * Execute
+ * @param {import('bpmn-elements').ElementBrokerMessage} executionMessage
+ * @param {CallableFunction} callback
+ * @returns {any}
+ */
 JobService.prototype.execute = function execute(executionMessage, callback) {
   const activity = this.activity;
   const environment = activity.environment;
@@ -16575,23 +16594,58 @@ JobService.prototype.execute = function execute(executionMessage, callback) {
   return serviceFn.call(activity, executionMessage, (err, result) => callback(err, result));
 };
 
+/**
+ * `zeebe:subscription` — rides on the referenced `bpmn:Message`, not on the catching element.
+ *
+ * Resolves the correlation key in the activity's variable scope on enter and exposes it on the
+ * element content as `subscription`. Correlation itself is the embedding application's job:
+ * read the resolved key off the waiting activity (`getPostponed()` → `content.subscription`)
+ * and signal the matching one (`api.signal(...)`).
+ */
+class Subscription {
+  /**
+   * @param {{ id: string, name?: string }} messageRef The serialized message reference
+   * @param {{ correlationKey: string }} subscription The `zeebe:Subscription` behaviour
+   */
+  constructor(messageRef, subscription) {
+    this.message = { id: messageRef.id, name: messageRef.name };
+    this.correlationKey = subscription.correlationKey;
+  }
+  /**
+   * @param {import('bpmn-elements').IApi<any>} elementApi
+   * @returns {{ message: { id: string, name?: string }, correlationKey: any }}
+   */
+  resolve(elementApi) {
+    return {
+      message: this.message,
+      correlationKey: resolveValue(this.correlationKey, elementApi.environment.variables),
+    };
+  }
+}
+
+/**
+ * The extension handlers assembled for one element.
+ * @typedef {object} ExtensionHandlers
+ * @property {FormatActivity | FormatProcess} format
+ * @property {IoMapping} [io]
+ * @property {TaskHeaders} [headers]
+ * @property {Properties} [properties]
+ * @property {ExecutionListeners} [listeners]
+ * @property {Form} [form]
+ * @property {LoopCharacteristics} [loop]
+ * @property {any} [script]
+ * @property {any} [calledDecision]
+ * @property {Function} [Service]
+ * @property {Subscription} [subscription]
+ */
+
 /**
  * Inspect an element's extension elements and assemble the extension handlers it needs.
  * @param {import('bpmn-elements').Activity | import('bpmn-elements').Process} element
- * @returns {{
- *   format: FormatActivity | FormatProcess,
- *   io?: IoMapping,
- *   headers?: TaskHeaders,
- *   properties?: Properties,
- *   listeners?: ExecutionListeners,
- *   form?: Form,
- *   loop?: LoopCharacteristics,
- *   script?: any,
- *   calledDecision?: any,
- *   Service?: Function,
- * }}
+ * @param {import('bpmn-elements').ContextInstance} [context]
+ * @returns {ExtensionHandlers}
  */
-function getExtensions(element) {
+function getExtensions(element, context) {
   const result = {};
   const isProcess = element.type === 'bpmn:Process';
 
@@ -16635,6 +16689,18 @@ function getExtensions(element) {
     }
   }
 
+  // A message catch (receive task / message event) may reference a bpmn:Message carrying a
+  // zeebe:subscription with the correlation key. The subscription lives on the message element,
+  // which the instantiated bpmn-elements Message strips — read it off the serialized context.
+  const messageRef =
+    element.behaviour.messageRef ?? element.behaviour.eventDefinitions?.find((ed) => ed.behaviour?.messageRef)?.behaviour.messageRef;
+  if (messageRef?.id && context) {
+    const subscription = context.definitionContext
+      .getActivityById(messageRef.id)
+      ?.behaviour.extensionElements?.values?.find((v) => v.$type === 'zeebe:Subscription');
+    if (subscription?.correlationKey) result.subscription = new Subscription(messageRef, subscription);
+  }
+
   // Output side of a multi-instance `zeebe:loopCharacteristics` (the input side is lifted by extendFn).
   const loopExtension = element.behaviour.loopCharacteristics?.behaviour?.extensionElements?.values?.find(
     (v) => v.$type === 'zeebe:LoopCharacteristics'
@@ -16648,6 +16714,13 @@ function getExtensions(element) {
 
 const SUBPROCESS_TYPES = new Set(['bpmn:SubProcess', 'bpmn:AdHocSubProcess', 'bpmn:Transaction']);
 
+// Consumer tags shared between activate (here and in the SubProcessExtensions override) and
+// deactivate — deactivate cancels by tag, so both must subscribe with these exact tags.
+const ON_ENTER_TAG = '0dep-bpmn-extensions:on-enter';
+const ON_EXECUTED_TAG = '0dep-bpmn-extensions:on-executed';
+const ON_START_TAG = '0dep-bpmn-extensions:on-start';
+const ON_END_TAG = '0dep-bpmn-extensions:on-end';
+
 /**
  * Activity-level extensions.
  *
@@ -16656,43 +16729,55 @@ const SUBPROCESS_TYPES = new Set(['bpmn:SubProcess', 'bpmn:AdHocSubProcess', 'bp
  * proceeding — the same mechanism bpmn-elements uses for extension formatting.
  */
 class ElementExtensions {
-  constructor(activity) {
+  /**
+   * @param {import('bpmn-elements').Activity} activity
+   * @param {import('bpmn-elements').ContextInstance} context
+   */
+  constructor(activity, context) {
     this.activity = activity;
     this.formatQ = activity.broker.getQueue('format-run-q');
 
-    this.extensions = getExtensions(activity);
+    /** @type {import('./getExtensions.js').ExtensionHandlers} */
+    this.extensions = getExtensions(activity, context);
     const Service = this.extensions.Service;
     if (Service) activity.behaviour.Service = Service;
   }
+  /**
+   * Activate extensions
+   * @param {import('bpmn-elements').ElementBrokerMessage} message
+   */
   activate(message) {
     const activity = this.activity;
     const listeners = this.extensions.listeners;
 
     if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
-      activity.on('start', (api) => this._onEnter(api), { consumerTag: '0dep-bpmn-extensions:on-enter' });
+      activity.on('start', (api) => this._onEnter(api), { consumerTag: ON_ENTER_TAG });
     } else {
-      activity.on('enter', (api) => this._onEnter(api), { consumerTag: '0dep-bpmn-extensions:on-enter' });
+      activity.on('enter', (api) => this._onEnter(api), { consumerTag: ON_ENTER_TAG });
     }
 
     activity.on('activity.execution.completed', (api) => this._onExecuted(api), {
-      consumerTag: '0dep-bpmn-extensions:on-executed',
+      consumerTag: ON_EXECUTED_TAG,
     });
 
     if (listeners?.onStart) {
-      activity.on('start', (api) => this._onListener('start', api), { consumerTag: '0dep-bpmn-extensions:on-start' });
+      activity.on('start', (api) => this._onListener('start', api), { consumerTag: ON_START_TAG });
     }
     if (listeners?.onEnd) {
-      activity.on('end', (api) => this._onListener('end', api), { consumerTag: '0dep-bpmn-extensions:on-end' });
+      activity.on('end', (api) => this._onListener('end', api), { consumerTag: ON_END_TAG });
     }
   }
   deactivate() {
     const broker = this.activity.broker;
-    broker.cancel('0dep-bpmn-extensions:on-enter');
-    broker.cancel('0dep-bpmn-extensions:on-executed');
-    broker.cancel('0dep-bpmn-extensions:on-start');
-    broker.cancel('0dep-bpmn-extensions:on-end');
+    broker.cancel(ON_ENTER_TAG);
+    broker.cancel(ON_EXECUTED_TAG);
+    broker.cancel(ON_START_TAG);
+    broker.cancel(ON_END_TAG);
   }
-  /** @internal Shared with SubProcessExtensions. */
+  /**
+   * @internal Shared with SubProcessExtensions.
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   async _onEnter(elementApi) {
     this.formatQ.queueMessage({ routingKey: 'run.enter.format' }, { endRoutingKey: 'run.enter.complete' }, { persistent: false });
     try {
@@ -16702,7 +16787,10 @@ class ElementExtensions {
       elementApi.broker.publish('format', 'run.enter.error', { error: err }, { persistent: false });
     }
   }
-  /** @internal Shared with SubProcessExtensions. */
+  /**
+   * @internal Shared with SubProcessExtensions.
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   async _onExecuted(elementApi) {
     this.formatQ.queueMessage({ routingKey: 'run.end.format' }, { endRoutingKey: 'run.end.complete' }, { persistent: false });
     try {
@@ -16712,7 +16800,10 @@ class ElementExtensions {
       elementApi.broker.publish('format', 'run.end.error', { error: err }, { persistent: false });
     }
   }
-  /** @internal Shared with SubProcessExtensions. */
+  /**
+   * @internal Shared with SubProcessExtensions.
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   async _onListener(eventType, elementApi) {
     const routingKey = `run.listener.${eventType}`;
     this.formatQ.queueMessage({ routingKey }, { endRoutingKey: `${routingKey}.complete` }, { persistent: false });
@@ -16724,13 +16815,17 @@ class ElementExtensions {
       elementApi.broker.publish('format', `${routingKey}.error`, { error: err }, { persistent: false });
     }
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   #formatOnEnter(elementApi) {
-    const { format, io, headers, properties, form } = this.extensions;
+    const { format, io, headers, properties, form, subscription } = this.extensions;
     const result = { ...format.resolve(elementApi) };
 
     if (headers) result.headers = headers.resolve();
     if (properties) result.properties = properties.resolve(elementApi);
     if (form) result.form = form.resolve(elementApi);
+    if (subscription) result.subscription = subscription.resolve(elementApi);
     if (io?.hasInput) {
       result.input = io.getInput(elementApi);
       // A (sub) process input mapping creates local variables visible to its children; a job
@@ -16742,6 +16837,9 @@ class ElementExtensions {
     Object.assign(elementApi.content, result);
     return result;
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   #formatOnExecuted(elementApi) {
     const { io, script, calledDecision, loop } = this.extensions;
     let jobResult = elementApi.content.output;
@@ -16778,6 +16876,10 @@ class ElementExtensions {
     }
     return {};
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   * @param {any} output
+   */
   #assignOutput(elementApi, output) {
     const environment = this.activity.environment;
     // Visible to downstream FEEL within the process, and surfaced as process output
@@ -16793,8 +16895,12 @@ class ElementExtensions {
  * the result to the process variables.
  */
 class ProcessExtensions {
+  /**
+   * @param {import('bpmn-elements').Process} bp
+   */
   constructor(bp) {
     this.process = bp;
+    /** @type {import('./getExtensions.js').ExtensionHandlers} */
     this.extensions = getExtensions(bp);
   }
   activate() {
@@ -16808,6 +16914,9 @@ class ProcessExtensions {
   deactivate() {
     this.process.broker.cancel('0dep-bpmn-extensions:on-enter');
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Process>} elementApi
+   */
   #onEnter(elementApi) {
     try {
       // bpmn-elements (>=18.0.4) forwards a call activity's formatted input — its io mapping plus,
@@ -16849,14 +16958,14 @@ class SubProcessExtensions extends ElementExtensions {
     const listeners = this.extensions.listeners;
     const enterKey = message.fields.redelivered && message.fields.routingKey === 'run.start' ? 'activity.start' : 'activity.enter';
 
-    this.#subscribe(enterKey, (api) => this._onEnter(api), '0dep-bpmn-extensions:on-enter');
-    this.#subscribe('activity.execution.completed', (api) => this._onExecuted(api), '0dep-bpmn-extensions:on-executed');
+    this.#subscribe(enterKey, (api) => this._onEnter(api), ON_ENTER_TAG);
+    this.#subscribe('activity.execution.completed', (api) => this._onExecuted(api), ON_EXECUTED_TAG);
 
     if (listeners?.onStart) {
-      this.#subscribe('activity.start', (api) => this._onListener('start', api), '0dep-bpmn-extensions:on-start');
+      this.#subscribe('activity.start', (api) => this._onListener('start', api), ON_START_TAG);
     }
     if (listeners?.onEnd) {
-      this.#subscribe('activity.end', (api) => this._onListener('end', api), '0dep-bpmn-extensions:on-end');
+      this.#subscribe('activity.end', (api) => this._onListener('end', api), ON_END_TAG);
     }
   }
   #subscribe(routingKey, callback, consumerTag) {
@@ -16880,7 +16989,7 @@ class SubProcessExtensions extends ElementExtensions {
  * definition resolves FEEL expressions (`= ...`) instead of the default
  * `${...}` template expressions.
  *
- * @returns {import('bpmn-elements').IExpressions}
+ * @returns {import('bpmn-elements').IExpressions & {isExpression: (text:string) => boolean, hasExpression: (text:string) => boolean}}
  */
 function FeelExpressions() {
   return {
@@ -16915,10 +17024,7 @@ function resolveExpression(templatedString, context) {
  * (e.g. a multi-instance item).
  */
 function getScope(context) {
-  const environment = context && context.environment;
-  const variables = environment ? environment.variables : {};
-  const local = context && context.content && context.content.variables;
-  return { ...variables, ...local };
+  return { ...context?.environment?.variables, ...context?.content?.variables };
 }
 
 /**
@@ -16937,10 +17043,18 @@ function FeelScripts() {
 }
 
 class FeelScriptRegistry {
-  register() {}
+  register() {
+    return undefined;
+  }
+  /**
+   * @param {string} _scriptFormat
+   * @param {{ id: string, [x: string]: any }} activity
+   * @returns {import('bpmn-elements').Script} the FEEL script, or undefined when the activity
+   *   has no `zeebe:script` — bpmn-elements handles that, but `IScripts` declares a bare `Script`
+   */
   getScript(_scriptFormat, activity) {
     const expression = getScriptExpression(activity);
-    if (expression === undefined) return undefined;
+    if (expression === undefined) return /** @type {any} */ (undefined);
     return new FeelScript(expression);
   }
 }
@@ -16972,8 +17086,8 @@ function getScriptExpression(activity) {
 /**
  * A flow extension activated by bpmn-elements around an element's run.
  * @typedef {object} FlowExtension
- * @property {(message: any) => void} activate
- * @property {(message?: any) => void} deactivate
+ * @property {(message: import('bpmn-elements').ElementBrokerMessage) => void} activate
+ * @property {(message?: import('bpmn-elements').ElementBrokerMessage) => void} deactivate
  */
 
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0dep/bpmn-extensions",
-  "version": "0.0.2",
+  "version": "0.0.3",
   "description": "Flow extensions for bpmn-elements: FEEL expressions and the zeebe-namespace BPMN extension elements",
   "type": "module",
   "module": "src/index.js",
@@ -51,18 +51,26 @@
     "access": "public"
   },
   "peerDependencies": {
-    "bpmn-elements": ">=18.0.4"
+    "bpmn-elements": ">=18.0.12"
   },
   "dependencies": {
     "feelin": "^7.0.1"
   },
+  "overrides": {
+    "mocha": {
+      "yargs": "^18.1.0"
+    }
+  },
   "devDependencies": {
     "@eslint/js": "^10.0.1",
     "@rollup/plugin-commonjs": "^29.0.3",
     "@rollup/plugin-node-resolve": "^16.0.3",
-    "bpmn-elements": "^18.0.4",
+    "@types/chai": "^5.2.3",
+    "@types/mocha": "^10.0.10",
+    "@types/node": "^26.1.1",
+    "bpmn-elements": "^18.0.12",
     "bpmn-moddle": "^9.0.1",
-    "c8": "^11.0.0",
+    "c8": "^12.0.0",
     "chai": "^6.2.2",
     "debug": "^4.4.3",
     "dts-buddy": "^0.8.2",

package/src/ElementExtensions.js

@@ -2,6 +2,13 @@ import { getExtensions } from './getExtensions.js';
 
 const SUBPROCESS_TYPES = new Set(['bpmn:SubProcess', 'bpmn:AdHocSubProcess', 'bpmn:Transaction']);
 
+// Consumer tags shared between activate (here and in the SubProcessExtensions override) and
+// deactivate — deactivate cancels by tag, so both must subscribe with these exact tags.
+export const ON_ENTER_TAG = '0dep-bpmn-extensions:on-enter';
+export const ON_EXECUTED_TAG = '0dep-bpmn-extensions:on-executed';
+export const ON_START_TAG = '0dep-bpmn-extensions:on-start';
+export const ON_END_TAG = '0dep-bpmn-extensions:on-end';
+
 /**
  * Activity-level extensions.
  *
@@ -10,43 +17,55 @@ const SUBPROCESS_TYPES = new Set(['bpmn:SubProcess', 'bpmn:AdHocSubProcess', 'bp
  * proceeding — the same mechanism bpmn-elements uses for extension formatting.
  */
 export class ElementExtensions {
-  constructor(activity) {
+  /**
+   * @param {import('bpmn-elements').Activity} activity
+   * @param {import('bpmn-elements').ContextInstance} context
+   */
+  constructor(activity, context) {
     this.activity = activity;
     this.formatQ = activity.broker.getQueue('format-run-q');
 
-    this.extensions = getExtensions(activity);
+    /** @type {import('./getExtensions.js').ExtensionHandlers} */
+    this.extensions = getExtensions(activity, context);
     const Service = this.extensions.Service;
     if (Service) activity.behaviour.Service = Service;
   }
+  /**
+   * Activate extensions
+   * @param {import('bpmn-elements').ElementBrokerMessage} message
+   */
   activate(message) {
     const activity = this.activity;
     const listeners = this.extensions.listeners;
 
     if (message.fields.redelivered && message.fields.routingKey === 'run.start') {
-      activity.on('start', (api) => this._onEnter(api), { consumerTag: '0dep-bpmn-extensions:on-enter' });
+      activity.on('start', (api) => this._onEnter(api), { consumerTag: ON_ENTER_TAG });
     } else {
-      activity.on('enter', (api) => this._onEnter(api), { consumerTag: '0dep-bpmn-extensions:on-enter' });
+      activity.on('enter', (api) => this._onEnter(api), { consumerTag: ON_ENTER_TAG });
     }
 
     activity.on('activity.execution.completed', (api) => this._onExecuted(api), {
-      consumerTag: '0dep-bpmn-extensions:on-executed',
+      consumerTag: ON_EXECUTED_TAG,
     });
 
     if (listeners?.onStart) {
-      activity.on('start', (api) => this._onListener('start', api), { consumerTag: '0dep-bpmn-extensions:on-start' });
+      activity.on('start', (api) => this._onListener('start', api), { consumerTag: ON_START_TAG });
     }
     if (listeners?.onEnd) {
-      activity.on('end', (api) => this._onListener('end', api), { consumerTag: '0dep-bpmn-extensions:on-end' });
+      activity.on('end', (api) => this._onListener('end', api), { consumerTag: ON_END_TAG });
     }
   }
   deactivate() {
     const broker = this.activity.broker;
-    broker.cancel('0dep-bpmn-extensions:on-enter');
-    broker.cancel('0dep-bpmn-extensions:on-executed');
-    broker.cancel('0dep-bpmn-extensions:on-start');
-    broker.cancel('0dep-bpmn-extensions:on-end');
+    broker.cancel(ON_ENTER_TAG);
+    broker.cancel(ON_EXECUTED_TAG);
+    broker.cancel(ON_START_TAG);
+    broker.cancel(ON_END_TAG);
   }
-  /** @internal Shared with SubProcessExtensions. */
+  /**
+   * @internal Shared with SubProcessExtensions.
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   async _onEnter(elementApi) {
     this.formatQ.queueMessage({ routingKey: 'run.enter.format' }, { endRoutingKey: 'run.enter.complete' }, { persistent: false });
     try {
@@ -56,7 +75,10 @@ export class ElementExtensions {
       elementApi.broker.publish('format', 'run.enter.error', { error: err }, { persistent: false });
     }
   }
-  /** @internal Shared with SubProcessExtensions. */
+  /**
+   * @internal Shared with SubProcessExtensions.
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   async _onExecuted(elementApi) {
     this.formatQ.queueMessage({ routingKey: 'run.end.format' }, { endRoutingKey: 'run.end.complete' }, { persistent: false });
     try {
@@ -66,7 +88,10 @@ export class ElementExtensions {
       elementApi.broker.publish('format', 'run.end.error', { error: err }, { persistent: false });
     }
   }
-  /** @internal Shared with SubProcessExtensions. */
+  /**
+   * @internal Shared with SubProcessExtensions.
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   async _onListener(eventType, elementApi) {
     const routingKey = `run.listener.${eventType}`;
     this.formatQ.queueMessage({ routingKey }, { endRoutingKey: `${routingKey}.complete` }, { persistent: false });
@@ -78,13 +103,17 @@ export class ElementExtensions {
       elementApi.broker.publish('format', `${routingKey}.error`, { error: err }, { persistent: false });
     }
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   #formatOnEnter(elementApi) {
-    const { format, io, headers, properties, form } = this.extensions;
+    const { format, io, headers, properties, form, subscription } = this.extensions;
     const result = { ...format.resolve(elementApi) };
 
     if (headers) result.headers = headers.resolve();
     if (properties) result.properties = properties.resolve(elementApi);
     if (form) result.form = form.resolve(elementApi);
+    if (subscription) result.subscription = subscription.resolve(elementApi);
     if (io?.hasInput) {
       result.input = io.getInput(elementApi);
       // A (sub) process input mapping creates local variables visible to its children; a job
@@ -96,6 +125,9 @@ export class ElementExtensions {
     Object.assign(elementApi.content, result);
     return result;
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   #formatOnExecuted(elementApi) {
     const { io, script, calledDecision, loop } = this.extensions;
     let jobResult = elementApi.content.output;
@@ -132,6 +164,10 @@ export class ElementExtensions {
     }
     return {};
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   * @param {any} output
+   */
   #assignOutput(elementApi, output) {
     const environment = this.activity.environment;
     // Visible to downstream FEEL within the process, and surfaced as process output

package/src/Expressions.js

@@ -7,7 +7,7 @@ import { isFeelExpression, evaluateFeel } from './feel.js';
  * definition resolves FEEL expressions (`= ...`) instead of the default
  * `${...}` template expressions.
  *
- * @returns {import('bpmn-elements').IExpressions}
+ * @returns {import('bpmn-elements').IExpressions & {isExpression: (text:string) => boolean, hasExpression: (text:string) => boolean}}
  */
 export function FeelExpressions() {
   return {
@@ -42,8 +42,5 @@ function resolveExpression(templatedString, context) {
  * (e.g. a multi-instance item).
  */
 function getScope(context) {
-  const environment = context && context.environment;
-  const variables = environment ? environment.variables : {};
-  const local = context && context.content && context.content.variables;
-  return { ...variables, ...local };
+  return { ...context?.environment?.variables, ...context?.content?.variables };
 }

package/src/ProcessExtensions.js

@@ -6,8 +6,12 @@ import { getExtensions } from './getExtensions.js';
  * the result to the process variables.
  */
 export class ProcessExtensions {
+  /**
+   * @param {import('bpmn-elements').Process} bp
+   */
   constructor(bp) {
     this.process = bp;
+    /** @type {import('./getExtensions.js').ExtensionHandlers} */
     this.extensions = getExtensions(bp);
   }
   activate() {
@@ -21,6 +25,9 @@ export class ProcessExtensions {
   deactivate() {
     this.process.broker.cancel('0dep-bpmn-extensions:on-enter');
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Process>} elementApi
+   */
   #onEnter(elementApi) {
     try {
       // bpmn-elements (>=18.0.4) forwards a call activity's formatted input — its io mapping plus,

package/src/SubProcessExtensions.js

@@ -1,4 +1,4 @@
-import { ElementExtensions } from './ElementExtensions.js';
+import { ElementExtensions, ON_ENTER_TAG, ON_EXECUTED_TAG, ON_START_TAG, ON_END_TAG } from './ElementExtensions.js';
 
 /**
  * Sub-process extensions.
@@ -14,14 +14,14 @@ export class SubProcessExtensions extends ElementExtensions {
     const listeners = this.extensions.listeners;
     const enterKey = message.fields.redelivered && message.fields.routingKey === 'run.start' ? 'activity.start' : 'activity.enter';
 
-    this.#subscribe(enterKey, (api) => this._onEnter(api), '0dep-bpmn-extensions:on-enter');
-    this.#subscribe('activity.execution.completed', (api) => this._onExecuted(api), '0dep-bpmn-extensions:on-executed');
+    this.#subscribe(enterKey, (api) => this._onEnter(api), ON_ENTER_TAG);
+    this.#subscribe('activity.execution.completed', (api) => this._onExecuted(api), ON_EXECUTED_TAG);
 
     if (listeners?.onStart) {
-      this.#subscribe('activity.start', (api) => this._onListener('start', api), '0dep-bpmn-extensions:on-start');
+      this.#subscribe('activity.start', (api) => this._onListener('start', api), ON_START_TAG);
     }
     if (listeners?.onEnd) {
-      this.#subscribe('activity.end', (api) => this._onListener('end', api), '0dep-bpmn-extensions:on-end');
+      this.#subscribe('activity.end', (api) => this._onListener('end', api), ON_END_TAG);
     }
   }
   #subscribe(routingKey, callback, consumerTag) {

package/src/extensions/FeelScripts.js

@@ -16,10 +16,18 @@ export function FeelScripts() {
 }
 
 class FeelScriptRegistry {
-  register() {}
+  register() {
+    return undefined;
+  }
+  /**
+   * @param {string} _scriptFormat
+   * @param {{ id: string, [x: string]: any }} activity
+   * @returns {import('bpmn-elements').Script} the FEEL script, or undefined when the activity
+   *   has no `zeebe:script` — bpmn-elements handles that, but `IScripts` declares a bare `Script`
+   */
   getScript(_scriptFormat, activity) {
     const expression = getScriptExpression(activity);
-    if (expression === undefined) return undefined;
+    if (expression === undefined) return /** @type {any} */ (undefined);
     return new FeelScript(expression);
   }
 }

package/src/extensions/Subscription.js

@@ -0,0 +1,30 @@
+import { resolveValue } from '../feel.js';
+
+/**
+ * `zeebe:subscription` — rides on the referenced `bpmn:Message`, not on the catching element.
+ *
+ * Resolves the correlation key in the activity's variable scope on enter and exposes it on the
+ * element content as `subscription`. Correlation itself is the embedding application's job:
+ * read the resolved key off the waiting activity (`getPostponed()` → `content.subscription`)
+ * and signal the matching one (`api.signal(...)`).
+ */
+export class Subscription {
+  /**
+   * @param {{ id: string, name?: string }} messageRef The serialized message reference
+   * @param {{ correlationKey: string }} subscription The `zeebe:Subscription` behaviour
+   */
+  constructor(messageRef, subscription) {
+    this.message = { id: messageRef.id, name: messageRef.name };
+    this.correlationKey = subscription.correlationKey;
+  }
+  /**
+   * @param {import('bpmn-elements').IApi<any>} elementApi
+   * @returns {{ message: { id: string, name?: string }, correlationKey: any }}
+   */
+  resolve(elementApi) {
+    return {
+      message: this.message,
+      correlationKey: resolveValue(this.correlationKey, elementApi.environment.variables),
+    };
+  }
+}

package/src/extensions/TaskDefinition.js

@@ -22,6 +22,12 @@ export function JobService(taskType, activity) {
   this.activity = activity;
 }
 
+/**
+ * Execute
+ * @param {import('bpmn-elements').ElementBrokerMessage} executionMessage
+ * @param {CallableFunction} callback
+ * @returns {any}
+ */
 JobService.prototype.execute = function execute(executionMessage, callback) {
   const activity = this.activity;
   const environment = activity.environment;

package/src/extensions/formatters.js

@@ -5,10 +5,17 @@ import { resolveValue } from '../feel.js';
  * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups).
  */
 export class FormatActivity {
+  /**
+   * @param {import('bpmn-elements').Activity} activity
+   * @param {any} assignmentDefinition
+   */
   constructor(activity, assignmentDefinition) {
     this.activity = activity;
     this.assignmentDefinition = assignmentDefinition;
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
+   */
   resolve(elementApi) {
     const scope = elementApi.environment.variables;
     const result = {};
@@ -37,9 +44,15 @@ export class FormatActivity {
  * Format a process on enter: documentation.
  */
 export class FormatProcess {
+  /**
+   * @param {import('bpmn-elements').Process} bp
+   */
   constructor(bp) {
     this.process = bp;
   }
+  /**
+   * @param {import('bpmn-elements').IApi<import('bpmn-elements').Process>} elementApi
+   */
   resolve(elementApi) {
     const result = {};
     const documentation = this.process.behaviour.documentation;
@@ -58,7 +71,7 @@ export class FormatProcess {
 function resolveList(value, scope) {
   if (!value) return undefined;
   const resolved = resolveValue(value, scope);
-  if (Array.isArray(resolved)) return resolved.filter((v) => v !== null && v !== undefined);
+  if (Array.isArray(resolved)) return resolved.filter(Boolean);
   if (typeof resolved !== 'string') return undefined;
   return resolved
     .split(',')

package/src/feel.js

@@ -40,11 +40,11 @@ export function evaluateFeel(expression, context) {
  * @param {string} expression FEEL unary test
  * @param {any} input The value being tested, available as `?` in the test
  * @param {Record<string, any>} [context] Additional variables in scope
- * @returns {boolean}
+ * @returns {boolean} true only when the test is satisfied — an undecidable (null) test is false
  */
 export function evaluateFeelUnaryTest(expression, input, context) {
-  const { value } = unaryTest(stripFeel(expression), { ...(context || {}), '?': input });
-  return value;
+  const { value } = unaryTest(stripFeel(expression), { ...context, '?': input });
+  return value === true;
 }
 
 /**

package/src/getExtensions.js

@@ -6,24 +6,31 @@ import { ExecutionListeners } from './extensions/ExecutionListeners.js';
 import { Form } from './extensions/Form.js';
 import { LoopCharacteristics } from './extensions/LoopCharacteristics.js';
 import { JobService } from './extensions/TaskDefinition.js';
+import { Subscription } from './extensions/Subscription.js';
+
+/**
+ * The extension handlers assembled for one element.
+ * @typedef {object} ExtensionHandlers
+ * @property {FormatActivity | FormatProcess} format
+ * @property {IoMapping} [io]
+ * @property {TaskHeaders} [headers]
+ * @property {Properties} [properties]
+ * @property {ExecutionListeners} [listeners]
+ * @property {Form} [form]
+ * @property {LoopCharacteristics} [loop]
+ * @property {any} [script]
+ * @property {any} [calledDecision]
+ * @property {Function} [Service]
+ * @property {Subscription} [subscription]
+ */
 
 /**
  * Inspect an element's extension elements and assemble the extension handlers it needs.
  * @param {import('bpmn-elements').Activity | import('bpmn-elements').Process} element
- * @returns {{
- *   format: FormatActivity | FormatProcess,
- *   io?: IoMapping,
- *   headers?: TaskHeaders,
- *   properties?: Properties,
- *   listeners?: ExecutionListeners,
- *   form?: Form,
- *   loop?: LoopCharacteristics,
- *   script?: any,
- *   calledDecision?: any,
- *   Service?: Function,
- * }}
+ * @param {import('bpmn-elements').ContextInstance} [context]
+ * @returns {ExtensionHandlers}
  */
-export function getExtensions(element) {
+export function getExtensions(element, context) {
   const result = {};
   const isProcess = element.type === 'bpmn:Process';
 
@@ -67,6 +74,18 @@ export function getExtensions(element) {
     }
   }
 
+  // A message catch (receive task / message event) may reference a bpmn:Message carrying a
+  // zeebe:subscription with the correlation key. The subscription lives on the message element,
+  // which the instantiated bpmn-elements Message strips — read it off the serialized context.
+  const messageRef =
+    element.behaviour.messageRef ?? element.behaviour.eventDefinitions?.find((ed) => ed.behaviour?.messageRef)?.behaviour.messageRef;
+  if (messageRef?.id && context) {
+    const subscription = context.definitionContext
+      .getActivityById(messageRef.id)
+      ?.behaviour.extensionElements?.values?.find((v) => v.$type === 'zeebe:Subscription');
+    if (subscription?.correlationKey) result.subscription = new Subscription(messageRef, subscription);
+  }
+
   // Output side of a multi-instance `zeebe:loopCharacteristics` (the input side is lifted by extendFn).
   const loopExtension = element.behaviour.loopCharacteristics?.behaviour?.extensionElements?.values?.find(
     (v) => v.$type === 'zeebe:LoopCharacteristics'

package/src/index.js

@@ -12,8 +12,8 @@ export { ServiceError, FormatError } from './Errors.js';
 /**
  * A flow extension activated by bpmn-elements around an element's run.
  * @typedef {object} FlowExtension
- * @property {(message: any) => void} activate
- * @property {(message?: any) => void} deactivate
+ * @property {(message: import('bpmn-elements').ElementBrokerMessage) => void} activate
+ * @property {(message?: import('bpmn-elements').ElementBrokerMessage) => void} deactivate
  */
 
 /**

package/types/index.d.ts

@@ -18,8 +18,8 @@ declare module '@0dep/bpmn-extensions' {
 	 * A flow extension activated by bpmn-elements around an element's run.
 	 */
 	export type FlowExtension = {
-		activate: (message: any) => void;
-		deactivate: (message?: any) => void;
+		activate: (message: import("bpmn-elements").ElementBrokerMessage) => void;
+		deactivate: (message?: import("bpmn-elements").ElementBrokerMessage) => void;
 	};
 	/**
 	 * FEEL-aware expressions implementation for bpmn-elements.
@@ -29,7 +29,10 @@ declare module '@0dep/bpmn-extensions' {
 	 * `${...}` template expressions.
 	 *
 	 * */
-	export function FeelExpressions(): import("bpmn-elements").IExpressions;
+	export function FeelExpressions(): import("bpmn-elements").IExpressions & {
+		isExpression: (text: string) => boolean;
+		hasExpression: (text: string) => boolean;
+	};
 	/**
 	 * A bpmn-elements `scripts` implementation for script tasks.
 	 *
@@ -75,7 +78,10 @@ declare module '@0dep/bpmn-extensions' {
 		type: string | undefined;
 		taskType: any;
 		activity: any;
-		execute(executionMessage: any, callback: any): any;
+		/**
+		 * Execute
+		 * */
+		execute(executionMessage: import("bpmn-elements").ElementBrokerMessage, callback: CallableFunction): any;
 	}
 	/**
 	 * Activity-level extensions.
@@ -85,29 +91,29 @@ declare module '@0dep/bpmn-extensions' {
 	 * proceeding — the same mechanism bpmn-elements uses for extension formatting.
 	 */
 	export class ElementExtensions {
-		constructor(activity: any);
-		activity: any;
-		formatQ: any;
-		extensions: {
-			format: FormatActivity | FormatProcess;
-			io?: IoMapping;
-			headers?: TaskHeaders;
-			properties?: Properties;
-			listeners?: ExecutionListeners;
-			form?: Form;
-			loop?: LoopCharacteristics;
-			script?: any;
-			calledDecision?: any;
-			Service?: Function;
-		};
-		activate(message: any): void;
+		
+		constructor(activity: import("bpmn-elements").Activity, context: import("bpmn-elements").ContextInstance);
+		activity: import("bpmn-elements").Activity;
+		formatQ: import("smqp").Queue | undefined;
+		
+		extensions: ExtensionHandlers;
+		/**
+		 * Activate extensions
+		 * */
+		activate(message: import("bpmn-elements").ElementBrokerMessage): void;
 		deactivate(): void;
-		/** @internal Shared with SubProcessExtensions. */
-		_onEnter(elementApi: any): Promise<void>;
-		/** @internal Shared with SubProcessExtensions. */
-		_onExecuted(elementApi: any): Promise<void>;
-		/** @internal Shared with SubProcessExtensions. */
-		_onListener(eventType: any, elementApi: any): Promise<void>;
+		/**
+		 * @internal Shared with SubProcessExtensions.
+		 * */
+		_onEnter(elementApi: import("bpmn-elements").IApi<import("bpmn-elements").Activity>): Promise<void>;
+		/**
+		 * @internal Shared with SubProcessExtensions.
+		 * */
+		_onExecuted(elementApi: import("bpmn-elements").IApi<import("bpmn-elements").Activity>): Promise<void>;
+		/**
+		 * @internal Shared with SubProcessExtensions.
+		 * */
+		_onListener(eventType: any, elementApi: import("bpmn-elements").IApi<import("bpmn-elements").Activity>): Promise<void>;
 		#private;
 	}
 	/**
@@ -115,20 +121,11 @@ declare module '@0dep/bpmn-extensions' {
 	 * the result to the process variables.
 	 */
 	export class ProcessExtensions {
-		constructor(bp: any);
-		process: any;
-		extensions: {
-			format: FormatActivity | FormatProcess;
-			io?: IoMapping;
-			headers?: TaskHeaders;
-			properties?: Properties;
-			listeners?: ExecutionListeners;
-			form?: Form;
-			loop?: LoopCharacteristics;
-			script?: any;
-			calledDecision?: any;
-			Service?: Function;
-		};
+		
+		constructor(bp: import("bpmn-elements").Process);
+		process: import("bpmn-elements").Process;
+		
+		extensions: ExtensionHandlers;
 		activate(): void;
 		deactivate(): void;
 		#private;
@@ -143,6 +140,7 @@ declare module '@0dep/bpmn-extensions' {
 	 * sub-process's own id.
 	 */
 	export class SubProcessExtensions extends ElementExtensions {
+		activate(message: any): void;
 		#private;
 	}
 	/**
@@ -164,7 +162,8 @@ declare module '@0dep/bpmn-extensions' {
 	 * @param expression FEEL unary test
 	 * @param input The value being tested, available as `?` in the test
 	 * @param context Additional variables in scope
-	 * */
+	 * @returns true only when the test is satisfied — an undecidable (null) test is false
+	 */
 	export function evaluateFeelUnaryTest(expression: string, input: any, context?: Record<string, any>): boolean;
 	/**
 	 * Resolve a value: evaluate it as FEEL when it starts with `=`, otherwise
@@ -186,15 +185,33 @@ declare module '@0dep/bpmn-extensions' {
 			statusCode: number;
 		};
 	}
+	/**
+	 * The extension handlers assembled for one element.
+	 */
+	type ExtensionHandlers = {
+		format: FormatActivity | FormatProcess;
+		io?: IoMapping | undefined;
+		headers?: TaskHeaders | undefined;
+		properties?: Properties | undefined;
+		listeners?: ExecutionListeners | undefined;
+		form?: Form | undefined;
+		loop?: LoopCharacteristics | undefined;
+		script?: any;
+		calledDecision?: any;
+		Service?: Function | undefined;
+		subscription?: Subscription | undefined;
+	};
 	/**
 	 * Format an activity on enter from its behaviour and extensions: documentation and,
 	 * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups).
 	 */
 	class FormatActivity {
-		constructor(activity: any, assignmentDefinition: any);
-		activity: any;
+		
+		constructor(activity: import("bpmn-elements").Activity, assignmentDefinition: any);
+		activity: import("bpmn-elements").Activity;
 		assignmentDefinition: any;
-		resolve(elementApi: any): {
+		
+		resolve(elementApi: import("bpmn-elements").IApi<import("bpmn-elements").Activity>): {
 			description: any;
 			assignee: any;
 			candidateUsers: any[];
@@ -205,9 +222,11 @@ declare module '@0dep/bpmn-extensions' {
 	 * Format a process on enter: documentation.
 	 */
 	class FormatProcess {
-		constructor(bp: any);
-		process: any;
-		resolve(elementApi: any): {
+		
+		constructor(bp: import("bpmn-elements").Process);
+		process: import("bpmn-elements").Process;
+		
+		resolve(elementApi: import("bpmn-elements").IApi<import("bpmn-elements").Process>): {
 			description: any;
 		};
 	}
@@ -323,6 +342,39 @@ declare module '@0dep/bpmn-extensions' {
 		 * */
 		aggregate(indexedOutput: Record<string, any> | undefined, baseScope: Record<string, any>): any[];
 	}
+	/**
+	 * `zeebe:subscription` — rides on the referenced `bpmn:Message`, not on the catching element.
+	 *
+	 * Resolves the correlation key in the activity's variable scope on enter and exposes it on the
+	 * element content as `subscription`. Correlation itself is the embedding application's job:
+	 * read the resolved key off the waiting activity (`getPostponed()` → `content.subscription`)
+	 * and signal the matching one (`api.signal(...)`).
+	 */
+	class Subscription {
+		/**
+		 * @param messageRef The serialized message reference
+		 * @param subscription The `zeebe:Subscription` behaviour
+		 */
+		constructor(messageRef: {
+			id: string;
+			name?: string;
+		}, subscription: {
+			correlationKey: string;
+		});
+		message: {
+			id: string;
+			name: string | undefined;
+		};
+		correlationKey: string;
+		
+		resolve(elementApi: import("bpmn-elements").IApi<any>): {
+			message: {
+				id: string;
+				name?: string;
+			};
+			correlationKey: any;
+		};
+	}
 
 	export {};
 }

package/types/index.d.ts.map

@@ -24,7 +24,8 @@
 		"Properties",
 		"ExecutionListeners",
 		"Form",
-		"LoopCharacteristics"
+		"LoopCharacteristics",
+		"Subscription"
 	],
 	"sources": [
 		"../src/index.js",
@@ -42,7 +43,8 @@
 		"../src/extensions/Properties.js",
 		"../src/extensions/ExecutionListeners.js",
 		"../src/extensions/Form.js",
-		"../src/extensions/LoopCharacteristics.js"
+		"../src/extensions/LoopCharacteristics.js",
+		"../src/extensions/Subscription.js"
 	],
 	"sourcesContent": [
 		null,
@@ -60,8 +62,9 @@
 		null,
 		null,
 		null,
+		null,
 		null
 	],
-	"mappings": ";;;;;;;iBAwBgBA,UAAUA;;;;;;;;iBAqBVC,QAAQA;;;;;;;;;;;;;;;;iBClCRC,eAAeA;;;;;;;;;;;iBCEfC,WAAWA;;;;;;;;;;;;;;;iBCIXC,UAAUA;cAAVA,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCNbC,iBAAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCJjBC,iBAAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCIjBC,oBAAoBA;;;;;;iBCEjBC,gBAAgBA;;;;iBAShBC,SAASA;;;;;;iBAUTC,YAAYA;;;;;;;iBAYZC,qBAAqBA;;;;;;iBAYrBC,YAAYA;cCxDfC,YAAYA;;;;;;;cAQZC,WAAWA;;;;;;;;;;;OCFXC,cAAcA;;;;;;;;;;;;;;OAgCdC,aAAaA;;;;;;;;;;;;;;;;;;OCzBbC,SAASA;;;;;;;;;;;;;;;;;;;;;;;OCPTC,WAAWA;;;;;;;;;;;OCEXC,UAAUA;;;;;;;;;;;;;;;OCIVC,kBAAkBA;;;;;;;;;;;;;;;;;;;OCFlBC,IAAIA;;;;;;;;;;;;;;;;;;;;;;OCGJC,mBAAmBA",
+	"mappings": ";;;;;;;iBAwBgBA,UAAUA;;;;;;;;iBAqBVC,QAAQA;;;;;;;;;;;;;;;;iBClCRC,eAAeA;;;;;;;;;;;;;;iBCEfC,WAAWA;;;;;;;;;;;;;;;iBCIXC,UAAUA;cAAVA,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCCbC,iBAAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCXjBC,iBAAiBA;;;;;;;;;;;;;;;;;;;cCIjBC,oBAAoBA;;;;;;;iBCEjBC,gBAAgBA;;;;iBAShBC,SAASA;;;;;;iBAUTC,YAAYA;;;;;;;;iBAYZC,qBAAqBA;;;;;;iBAYrBC,YAAYA;cCxDfC,YAAYA;;;;;;;cAQZC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;OCFXC,cAAcA;;;;;;;;;;;;;;;;OAuCdC,aAAaA;;;;;;;;;;;;;;;;;;;;OChCbC,SAASA;;;;;;;;;;;;;;;;;;;;;;;OCPTC,WAAWA;;;;;;;;;;;OCEXC,UAAUA;;;;;;;;;;;;;;;OCIVC,kBAAkBA;;;;;;;;;;;;;;;;;;;OCFlBC,IAAIA;;;;;;;;;;;;;;;;;;;;;;OCGJC,mBAAmBA;;;;;;;;;;;;;;;;;;;OCHnBC,YAAYA",
 	"ignoreList": []
 }