@0dep/bpmn-extensions 0.0.3 → 0.0.4

package/README.md

@@ -21,6 +21,12 @@ npm install @0dep/bpmn-extensions bpmn-elements
 
 - **FEEL expressions** — a `FeelExpressions()` adapter resolves FEEL (`= order.total > 100`)
   everywhere bpmn-elements resolves an expression, including sequence flow conditions.
+- **Environment services in FEEL scope** — every FEEL expression can call the environment services
+  as functions, namespaced under `services` (e.g. a condition `= services.isEligible(order)`).
+  This strays from strict Camunda 8 conformance on purpose: unlike functions smuggled through
+  variables, services survive `getState()`/`recover()` — state is JSON-serialized (functions are
+  dropped), while services are re-supplied by the host at recover time — so service-backed
+  conditions are resume-safe. A variable named `services` shadows the overlay.
 - **`zeebe:script`** — a `FeelScripts()` adapter runs a script task's FEEL `expression` and assigns
   the result to its `resultVariable`.
 - **`zeebe:taskDefinition`** — maps a service task's job `type` to an environment service (job worker).
@@ -52,7 +58,8 @@ npm install @0dep/bpmn-extensions bpmn-elements
   bpmn-elements expects on the behaviour: call activity process id and multi-instance collection).
 - `FeelExpressions()` — a bpmn-elements `IExpressions` implementation backed by FEEL.
 - `FeelScripts()` — a bpmn-elements `scripts` implementation that runs `zeebe:script` FEEL expressions.
-- FEEL helpers: `isFeelExpression`, `stripFeel`, `evaluateFeel`, `evaluateFeelUnaryTest`, `resolveValue`.
+- FEEL helpers: `isFeelExpression`, `stripFeel`, `evaluateFeel`, `evaluateFeelUnaryTest`, `resolveValue`,
+  `getFeelScope` (the scope every expression is evaluated in: `services` + environment variables + local overlay).
 - `JobService`, `ServiceError`, `FormatError`.
 
 ## Usage

package/dist/index.js

@@ -16222,6 +16222,21 @@ function resolveValue(value, context) {
   return value;
 }
 
+/**
+ * Build the FEEL evaluation scope for an environment. The environment services are exposed
+ * under `services`, callable as FEEL functions (e.g. `services.isEligible(order)`) — resume-safe,
+ * since the host re-supplies services at recover time, unlike functions smuggled through
+ * variables, which JSON state serialization drops. The environment variables form the base
+ * scope, overlaid with any local variables (a job result, element-local variables such as a
+ * multi-instance item); a variable named `services` shadows the overlay.
+ * @param {import('bpmn-elements').Environment} [environment]
+ * @param {Record<string, any>} [localVariables] scope-local overlay
+ * @returns {Record<string, any>}
+ */
+function getFeelScope(environment, localVariables) {
+  return { services: environment?.services, ...environment?.variables, ...localVariables };
+}
+
 /**
  * Format an activity on enter from its behaviour and extensions: documentation and,
  * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups).
@@ -16239,7 +16254,7 @@ class FormatActivity {
    * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
    */
   resolve(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const result = {};
 
     const documentation = this.activity.behaviour.documentation;
@@ -16280,7 +16295,7 @@ class FormatProcess {
     const documentation = this.process.behaviour.documentation;
     if (documentation && !elementApi.content.description) {
       const text = documentation[0]?.text;
-      if (text) result.description = resolveValue(text, elementApi.environment.variables);
+      if (text) result.description = resolveValue(text, getFeelScope(elementApi.environment));
     }
     return result;
   }
@@ -16329,7 +16344,7 @@ class IoMapping {
    * @param {import('bpmn-elements').IApi<any>} elementApi
    */
   getInput(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const result = {};
     for (const { source, target } of this.inputParameters) {
       if (!target) continue;
@@ -16343,7 +16358,7 @@ class IoMapping {
    * @param {Record<string, any>} [jobResult] Variables produced by the job
    */
   getOutput(elementApi, jobResult) {
-    const scope = { ...elementApi.environment.variables, ...jobResult };
+    const scope = getFeelScope(elementApi.environment, jobResult);
     const result = {};
     for (const { source, target } of this.outputParameters) {
       if (!target) continue;
@@ -16399,7 +16414,7 @@ class Properties {
     this.properties = properties.properties || [];
   }
   resolve(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const result = {};
     for (const { name, value } of this.properties) {
       if (name === undefined) continue;
@@ -16495,7 +16510,7 @@ class Form {
     this.formDefinition = formDefinition;
   }
   resolve(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const { formId, formKey, externalReference, bindingType, versionTag } = this.formDefinition;
     return {
       ...(formId !== undefined && { formId: resolveValue(formId, scope) }),
@@ -16528,7 +16543,7 @@ class LoopCharacteristics {
   }
   /**
    * @param {Record<string, any>|undefined} indexedOutput bpmn-elements index-keyed instance outputs
-   * @param {Record<string, any>} baseScope process variables in scope for `outputElement`
+   * @param {Record<string, any>} baseScope base scope for `outputElement` (services + process variables)
    * @returns {any[]}
    */
   aggregate(indexedOutput, baseScope) {
@@ -16583,7 +16598,7 @@ JobService.prototype.execute = function execute(executionMessage, callback) {
 
   let jobType;
   try {
-    jobType = resolveValue(this.taskType, environment.variables);
+    jobType = resolveValue(this.taskType, getFeelScope(environment));
   } catch (err) {
     return callback(err);
   }
@@ -16618,7 +16633,7 @@ class Subscription {
   resolve(elementApi) {
     return {
       message: this.message,
-      correlationKey: resolveValue(this.correlationKey, elementApi.environment.variables),
+      correlationKey: resolveValue(this.correlationKey, getFeelScope(elementApi.environment)),
     };
   }
 }
@@ -16846,7 +16861,7 @@ class ElementExtensions {
 
     // Multi-instance: aggregate the per-instance outputs into the `outputCollection` array.
     if (loop?.hasOutputCollection) {
-      const output = { [loop.outputCollection]: loop.aggregate(jobResult, elementApi.environment.variables) };
+      const output = { [loop.outputCollection]: loop.aggregate(jobResult, getFeelScope(elementApi.environment)) };
       this.#assignOutput(elementApi, output);
       return { output };
     }
@@ -17009,22 +17024,14 @@ function hasExpression(text) {
 
 /**
  * Resolve a templated string. Static literals are returned as-is; FEEL expressions are
- * evaluated against the environment variables (overlaid with any element-local variables).
+ * evaluated in the environment scope (see `getFeelScope`), overlaid with any element-local
+ * variables carried on the message content (e.g. a multi-instance item).
  * @param {string} templatedString
  * @param {{ environment?: import('bpmn-elements').Environment, content?: any }} [context]
  */
 function resolveExpression(templatedString, context) {
   if (!isFeelExpression(templatedString)) return templatedString;
-  return evaluateFeel(templatedString, getScope(context));
-}
-
-/**
- * Build the FEEL variable scope from a resolution context. Process/definition variables form
- * the base scope, overlaid with any local variables carried on the element message content
- * (e.g. a multi-instance item).
- */
-function getScope(context) {
-  return { ...context?.environment?.variables, ...context?.content?.variables };
+  return evaluateFeel(templatedString, getFeelScope(context?.environment, context?.content?.variables));
 }
 
 /**
@@ -17049,12 +17056,12 @@ class FeelScriptRegistry {
   /**
    * @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`
+   * @returns {import('bpmn-elements').Script | undefined} the FEEL script, or undefined when
+   *   the activity has no `zeebe:script`
    */
   getScript(_scriptFormat, activity) {
     const expression = getScriptExpression(activity);
-    if (expression === undefined) return /** @type {any} */ (undefined);
+    if (expression === undefined) return undefined;
     return new FeelScript(expression);
   }
 }
@@ -17065,7 +17072,7 @@ class FeelScript {
   }
   execute(scope, callback) {
     try {
-      const value = isFeelExpression(this.expression) ? evaluateFeel(this.expression, { ...scope.environment.variables }) : this.expression;
+      const value = isFeelExpression(this.expression) ? evaluateFeel(this.expression, getFeelScope(scope.environment)) : this.expression;
       callback(null, value);
     } catch (err) {
       callback(err);
@@ -17149,6 +17156,7 @@ exports.evaluateFeel = evaluateFeel;
 exports.evaluateFeelUnaryTest = evaluateFeelUnaryTest;
 exports.extendFn = extendFn;
 exports.extensions = extensions;
+exports.getFeelScope = getFeelScope;
 exports.isFeelExpression = isFeelExpression;
 exports.resolveValue = resolveValue;
 exports.stripFeel = stripFeel;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0dep/bpmn-extensions",
-  "version": "0.0.3",
+  "version": "0.0.4",
   "description": "Flow extensions for bpmn-elements: FEEL expressions and the zeebe-namespace BPMN extension elements",
   "type": "module",
   "module": "src/index.js",

package/src/ElementExtensions.js

@@ -1,4 +1,5 @@
 import { getExtensions } from './getExtensions.js';
+import { getFeelScope } from './feel.js';
 
 const SUBPROCESS_TYPES = new Set(['bpmn:SubProcess', 'bpmn:AdHocSubProcess', 'bpmn:Transaction']);
 
@@ -134,7 +135,7 @@ export class ElementExtensions {
 
     // Multi-instance: aggregate the per-instance outputs into the `outputCollection` array.
     if (loop?.hasOutputCollection) {
-      const output = { [loop.outputCollection]: loop.aggregate(jobResult, elementApi.environment.variables) };
+      const output = { [loop.outputCollection]: loop.aggregate(jobResult, getFeelScope(elementApi.environment)) };
       this.#assignOutput(elementApi, output);
       return { output };
     }

package/src/Expressions.js

@@ -1,4 +1,4 @@
-import { isFeelExpression, evaluateFeel } from './feel.js';
+import { isFeelExpression, evaluateFeel, getFeelScope } from './feel.js';
 
 /**
  * FEEL-aware expressions implementation for bpmn-elements.
@@ -27,20 +27,12 @@ function hasExpression(text) {
 
 /**
  * Resolve a templated string. Static literals are returned as-is; FEEL expressions are
- * evaluated against the environment variables (overlaid with any element-local variables).
+ * evaluated in the environment scope (see `getFeelScope`), overlaid with any element-local
+ * variables carried on the message content (e.g. a multi-instance item).
  * @param {string} templatedString
  * @param {{ environment?: import('bpmn-elements').Environment, content?: any }} [context]
  */
 function resolveExpression(templatedString, context) {
   if (!isFeelExpression(templatedString)) return templatedString;
-  return evaluateFeel(templatedString, getScope(context));
-}
-
-/**
- * Build the FEEL variable scope from a resolution context. Process/definition variables form
- * the base scope, overlaid with any local variables carried on the element message content
- * (e.g. a multi-instance item).
- */
-function getScope(context) {
-  return { ...context?.environment?.variables, ...context?.content?.variables };
+  return evaluateFeel(templatedString, getFeelScope(context?.environment, context?.content?.variables));
 }

package/src/extensions/FeelScripts.js

@@ -1,4 +1,4 @@
-import { isFeelExpression, evaluateFeel } from '../feel.js';
+import { isFeelExpression, evaluateFeel, getFeelScope } from '../feel.js';
 
 /**
  * A bpmn-elements `scripts` implementation for script tasks.
@@ -22,12 +22,12 @@ class FeelScriptRegistry {
   /**
    * @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`
+   * @returns {import('bpmn-elements').Script | undefined} the FEEL script, or undefined when
+   *   the activity has no `zeebe:script`
    */
   getScript(_scriptFormat, activity) {
     const expression = getScriptExpression(activity);
-    if (expression === undefined) return /** @type {any} */ (undefined);
+    if (expression === undefined) return undefined;
     return new FeelScript(expression);
   }
 }
@@ -38,7 +38,7 @@ class FeelScript {
   }
   execute(scope, callback) {
     try {
-      const value = isFeelExpression(this.expression) ? evaluateFeel(this.expression, { ...scope.environment.variables }) : this.expression;
+      const value = isFeelExpression(this.expression) ? evaluateFeel(this.expression, getFeelScope(scope.environment)) : this.expression;
       callback(null, value);
     } catch (err) {
       callback(err);

package/src/extensions/Form.js

@@ -1,4 +1,4 @@
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * `zeebe:formDefinition`.
@@ -13,7 +13,7 @@ export class Form {
     this.formDefinition = formDefinition;
   }
   resolve(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const { formId, formKey, externalReference, bindingType, versionTag } = this.formDefinition;
     return {
       ...(formId !== undefined && { formId: resolveValue(formId, scope) }),

package/src/extensions/IoMapping.js

@@ -1,4 +1,4 @@
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * `zeebe:ioMapping`.
@@ -28,7 +28,7 @@ export class IoMapping {
    * @param {import('bpmn-elements').IApi<any>} elementApi
    */
   getInput(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const result = {};
     for (const { source, target } of this.inputParameters) {
       if (!target) continue;
@@ -42,7 +42,7 @@ export class IoMapping {
    * @param {Record<string, any>} [jobResult] Variables produced by the job
    */
   getOutput(elementApi, jobResult) {
-    const scope = { ...elementApi.environment.variables, ...jobResult };
+    const scope = getFeelScope(elementApi.environment, jobResult);
     const result = {};
     for (const { source, target } of this.outputParameters) {
       if (!target) continue;

package/src/extensions/LoopCharacteristics.js

@@ -21,7 +21,7 @@ export class LoopCharacteristics {
   }
   /**
    * @param {Record<string, any>|undefined} indexedOutput bpmn-elements index-keyed instance outputs
-   * @param {Record<string, any>} baseScope process variables in scope for `outputElement`
+   * @param {Record<string, any>} baseScope base scope for `outputElement` (services + process variables)
    * @returns {any[]}
    */
   aggregate(indexedOutput, baseScope) {

package/src/extensions/Properties.js

@@ -1,4 +1,4 @@
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * `zeebe:properties`.
@@ -11,7 +11,7 @@ export class Properties {
     this.properties = properties.properties || [];
   }
   resolve(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const result = {};
     for (const { name, value } of this.properties) {
       if (name === undefined) continue;

package/src/extensions/Subscription.js

@@ -1,4 +1,4 @@
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * `zeebe:subscription` — rides on the referenced `bpmn:Message`, not on the catching element.
@@ -24,7 +24,7 @@ export class Subscription {
   resolve(elementApi) {
     return {
       message: this.message,
-      correlationKey: resolveValue(this.correlationKey, elementApi.environment.variables),
+      correlationKey: resolveValue(this.correlationKey, getFeelScope(elementApi.environment)),
     };
   }
 }

package/src/extensions/TaskDefinition.js

@@ -1,5 +1,5 @@
 import { ServiceError } from '../Errors.js';
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * `zeebe:taskDefinition`.
@@ -34,7 +34,7 @@ JobService.prototype.execute = function execute(executionMessage, callback) {
 
   let jobType;
   try {
-    jobType = resolveValue(this.taskType, environment.variables);
+    jobType = resolveValue(this.taskType, getFeelScope(environment));
   } catch (err) {
     return callback(err);
   }

package/src/extensions/formatters.js

@@ -1,4 +1,4 @@
-import { resolveValue } from '../feel.js';
+import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * Format an activity on enter from its behaviour and extensions: documentation and,
@@ -17,7 +17,7 @@ export class FormatActivity {
    * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
    */
   resolve(elementApi) {
-    const scope = elementApi.environment.variables;
+    const scope = getFeelScope(elementApi.environment);
     const result = {};
 
     const documentation = this.activity.behaviour.documentation;
@@ -58,7 +58,7 @@ export class FormatProcess {
     const documentation = this.process.behaviour.documentation;
     if (documentation && !elementApi.content.description) {
       const text = documentation[0]?.text;
-      if (text) result.description = resolveValue(text, elementApi.environment.variables);
+      if (text) result.description = resolveValue(text, getFeelScope(elementApi.environment));
     }
     return result;
   }

package/src/feel.js

@@ -58,3 +58,18 @@ export function resolveValue(value, context) {
   if (isFeelExpression(value)) return evaluateFeel(value, context);
   return value;
 }
+
+/**
+ * Build the FEEL evaluation scope for an environment. The environment services are exposed
+ * under `services`, callable as FEEL functions (e.g. `services.isEligible(order)`) — resume-safe,
+ * since the host re-supplies services at recover time, unlike functions smuggled through
+ * variables, which JSON state serialization drops. The environment variables form the base
+ * scope, overlaid with any local variables (a job result, element-local variables such as a
+ * multi-instance item); a variable named `services` shadows the overlay.
+ * @param {import('bpmn-elements').Environment} [environment]
+ * @param {Record<string, any>} [localVariables] scope-local overlay
+ * @returns {Record<string, any>}
+ */
+export function getFeelScope(environment, localVariables) {
+  return { services: environment?.services, ...environment?.variables, ...localVariables };
+}

package/src/index.js

@@ -5,7 +5,7 @@ import { SubProcessExtensions } from './SubProcessExtensions.js';
 export { ElementExtensions, ProcessExtensions, SubProcessExtensions };
 export { FeelExpressions } from './Expressions.js';
 export { FeelScripts } from './extensions/FeelScripts.js';
-export { isFeelExpression, stripFeel, evaluateFeel, evaluateFeelUnaryTest, resolveValue } from './feel.js';
+export { isFeelExpression, stripFeel, evaluateFeel, evaluateFeelUnaryTest, resolveValue, getFeelScope } from './feel.js';
 export { JobService } from './extensions/TaskDefinition.js';
 export { ServiceError, FormatError } from './Errors.js';
 

package/types/index.d.ts

@@ -171,6 +171,16 @@ declare module '@0dep/bpmn-extensions' {
 	 * @param context Variables in scope for FEEL evaluation
 	 * */
 	export function resolveValue(value: any, context?: Record<string, any>): any;
+	/**
+	 * Build the FEEL evaluation scope for an environment. The environment services are exposed
+	 * under `services`, callable as FEEL functions (e.g. `services.isEligible(order)`) — resume-safe,
+	 * since the host re-supplies services at recover time, unlike functions smuggled through
+	 * variables, which JSON state serialization drops. The environment variables form the base
+	 * scope, overlaid with any local variables (a job result, element-local variables such as a
+	 * multi-instance item); a variable named `services` shadows the overlay.
+	 * @param localVariables scope-local overlay
+	 * */
+	export function getFeelScope(environment?: import("bpmn-elements").Environment, localVariables?: Record<string, any>): Record<string, any>;
 	export class ServiceError extends Error {
 		constructor(jobType: any);
 		code: string;
@@ -338,7 +348,7 @@ declare module '@0dep/bpmn-extensions' {
 		get hasOutputCollection(): boolean;
 		/**
 		 * @param indexedOutput bpmn-elements index-keyed instance outputs
-		 * @param baseScope process variables in scope for `outputElement`
+		 * @param baseScope base scope for `outputElement` (services + process variables)
 		 * */
 		aggregate(indexedOutput: Record<string, any> | undefined, baseScope: Record<string, any>): any[];
 	}

package/types/index.d.ts.map

@@ -15,6 +15,7 @@
 		"evaluateFeel",
 		"evaluateFeelUnaryTest",
 		"resolveValue",
+		"getFeelScope",
 		"ServiceError",
 		"FormatError",
 		"FormatActivity",
@@ -65,6 +66,6 @@
 		null,
 		null
 	],
-	"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",
+	"mappings": ";;;;;;;iBAwBgBA,UAAUA;;;;;;;;iBAqBVC,QAAQA;;;;;;;;;;;;;;;;iBClCRC,eAAeA;;;;;;;;;;;;;;iBCEfC,WAAWA;;;;;;;;;;;;;;;iBCIXC,UAAUA;cAAVA,UAAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCEbC,iBAAiBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;cCZjBC,iBAAiBA;;;;;;;;;;;;;;;;;;;cCIjBC,oBAAoBA;;;;;;;iBCEjBC,gBAAgBA;;;;iBAShBC,SAASA;;;;;;iBAUTC,YAAYA;;;;;;;;iBAYZC,qBAAqBA;;;;;;iBAYrBC,YAAYA;;;;;;;;;;iBAgBZC,YAAYA;cCxEfC,YAAYA;;;;;;;cAQZC,WAAWA;;;;;;;;;;;;;;;;;;;;;;;;;;;OCFXC,cAAcA;;;;;;;;;;;;;;;;OAuCdC,aAAaA;;;;;;;;;;;;;;;;;;;;OChCbC,SAASA;;;;;;;;;;;;;;;;;;;;;;;OCPTC,WAAWA;;;;;;;;;;;OCEXC,UAAUA;;;;;;;;;;;;;;;OCIVC,kBAAkBA;;;;;;;;;;;;;;;;;;;OCFlBC,IAAIA;;;;;;;;;;;;;;;;;;;;;;OCGJC,mBAAmBA;;;;;;;;;;;;;;;;;;;OCHnBC,YAAYA",
 	"ignoreList": []
 }