@0dep/bpmn-extensions 0.0.4 → 0.0.5

package/README.md

@@ -1,6 +1,6 @@
 # @0dep/bpmn-extensions
 
-[![Built latest](https://github.com/zerodep/bpmn-extensions/actions/workflows/build-latest.yaml/badge.svg)](https://github.com/zerodep/bpmn-extensions/actions/workflows/build-latest.yaml)[![Coverage Status](https://coveralls.io/repos/github/zerodep/bpmn-extensions/badge.svg?branch=main)](https://coveralls.io/github/zerodep/bpmn-extensions?branch=main)[![npm version](https://img.shields.io/npm/v/@0dep/bpmn-extensions)](https://www.npmjs.com/package/@0dep/bpmn-extensions)
+[![Built latest](https://github.com/zerodep/bpmn-extensions/actions/workflows/build-latest.yaml/badge.svg)](https://github.com/zerodep/bpmn-extensions/actions/workflows/build-latest.yaml)[![Coverage Status](https://coveralls.io/repos/github/zerodep/bpmn-extensions/badge.svg?branch=main)](https://coveralls.io/github/zerodep/bpmn-extensions?branch=main)
 
 Flow extensions for [bpmn-elements](https://github.com/paed01/bpmn-elements) with
 [FEEL](https://www.omg.org/dmn/) expression support.
@@ -38,6 +38,9 @@ npm install @0dep/bpmn-extensions bpmn-elements
   process's input becomes variables local to its children.
 - **`zeebe:taskHeaders`** / **`zeebe:properties`** — exposed on the element content.
 - **`zeebe:assignmentDefinition`** — assignee / candidate users / groups for user tasks.
+- **`zeebe:priorityDefinition`** / **`zeebe:taskSchedule`** — a user task's `priority` and
+  `dueDate` / `followUpDate` resolved onto the element content for a task list to order and
+  remind by; FEEL date results are exposed as ISO 8601 strings.
 - **`zeebe:formDefinition`** — resolves a user task's form (`formId` / `formKey` / `externalReference`,
   `bindingType`) onto the element content for a task list to render.
 - **`zeebe:executionListeners`** — blocking start/end job workers around an element, called as
@@ -54,6 +57,9 @@ npm install @0dep/bpmn-extensions bpmn-elements
 ## API
 
 - `extensions(element, context)` — the flow extensions factory; pass it as an environment extension.
+  Elements that carry no zeebe extension data (and nothing else to format) get no extension attached
+  at all and run untouched; call activities and processes are always attached, since they propagate
+  io across process boundaries.
 - `extendFn(behaviour)` — moddle-context-serializer behaviour extender (lifts the extension data
   bpmn-elements expects on the behaviour: call activity process id and multi-instance collection).
 - `FeelExpressions()` — a bpmn-elements `IExpressions` implementation backed by FEEL.
@@ -69,7 +75,7 @@ Wire it into a bpmn-elements definition (see `test/helpers/testHelpers.js` for t
 ```javascript
 import { createRequire } from 'node:module';
 import { strict as assert } from 'node:assert';
-import BpmnModdle from 'bpmn-moddle';
+import { BpmnModdle } from 'bpmn-moddle';
 import * as elements from 'bpmn-elements';
 import { Serializer, TypeResolver } from 'moddle-context-serializer';
 import { extensions, extendFn, FeelExpressions, FeelScripts } from '@0dep/bpmn-extensions';

package/dist/index.js

@@ -11609,9 +11609,9 @@ function getSpecializer(spec) {
  *
  * @return {T[]}
  */
-const nativeHasOwnProperty$1 = Object.prototype.hasOwnProperty;
+const nativeHasOwnProperty = Object.prototype.hasOwnProperty;
 
-function isNil$2(obj) {
+function isNil$1(obj) {
   return obj == null;
 }
 
@@ -11623,8 +11623,8 @@ function isNil$2(obj) {
  *
  * @return {Boolean}
  */
-function has$1(target, key) {
-  return !isNil$2(target) && nativeHasOwnProperty$1.call(target, key);
+function has(target, key) {
+  return !isNil$1(target) && nativeHasOwnProperty.call(target, key);
 }
 
 let nextTagID = 0;
@@ -13107,7 +13107,7 @@ class VariableContext {
         continue;
       }
 
-      if (has$1(merged, key)) {
+      if (has(merged, key)) {
 
         // deep merge nested contexts
         merged[key] = this.__merge(merged[key], value);
@@ -13241,7 +13241,7 @@ class Variables {
         return null;
       }
 
-      if (!isNil$2(scope.value)) {
+      if (!isNil$1(scope.value)) {
         return scope.value;
       }
     }
@@ -13871,33 +13871,6 @@ const parser = LRParser.deserialize({
   tokenPrec: 2660
 });
 
-/**
- * Flatten array, one level deep.
- *
- * @template T
- *
- * @param {T[][] | T[] | null} [arr]
- *
- * @return {T[]}
- */
-const nativeHasOwnProperty = Object.prototype.hasOwnProperty;
-
-function isNil$1(obj) {
-  return obj == null;
-}
-
-/**
- * Return true, if target owns a property with the given key.
- *
- * @param {Object} target
- * @param {String} key
- *
- * @return {Boolean}
- */
-function has(target, key) {
-  return !isNil$1(target) && nativeHasOwnProperty.call(target, key);
-}
-
 function isNil(e) {
     return e === null || e === undefined;
 }
@@ -16239,16 +16212,21 @@ function getFeelScope(environment, localVariables) {
 
 /**
  * Format an activity on enter from its behaviour and extensions: documentation and,
- * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups).
+ * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups),
+ * `zeebe:priorityDefinition` (priority), and `zeebe:taskSchedule` (due/follow-up date).
  */
 class FormatActivity {
   /**
    * @param {import('bpmn-elements').Activity} activity
    * @param {any} assignmentDefinition
+   * @param {any} [priorityDefinition]
+   * @param {any} [taskSchedule]
    */
-  constructor(activity, assignmentDefinition) {
+  constructor(activity, assignmentDefinition, priorityDefinition, taskSchedule) {
     this.activity = activity;
     this.assignmentDefinition = assignmentDefinition;
+    this.priorityDefinition = priorityDefinition;
+    this.taskSchedule = taskSchedule;
   }
   /**
    * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
@@ -16260,7 +16238,7 @@ class FormatActivity {
     const documentation = this.activity.behaviour.documentation;
     if (documentation && !elementApi.content.description) {
       const text = documentation[0]?.text;
-      if (text) result.description = resolveValue(text, scope);
+      if (text) result.description = /** @type {string} */ (resolveValue(text, scope));
     }
 
     const assignment = this.assignmentDefinition;
@@ -16273,6 +16251,22 @@ class FormatActivity {
       if (groups) result.candidateGroups = groups;
     }
 
+    const priority = this.priorityDefinition?.priority;
+    if (priority !== undefined) {
+      const resolved = resolveValue(priority, scope);
+      // A static attribute value is a string — expose a numeric one as a number (like retries).
+      const num = Number(resolved);
+      /** @type {Number | string | undefined} */
+      result.priority = typeof resolved === 'string' && resolved.trim() !== '' && Number.isFinite(num) ? num : resolved;
+    }
+
+    const schedule = this.taskSchedule;
+    if (schedule) {
+      const { dueDate, followUpDate } = schedule;
+      if (dueDate !== undefined) result.dueDate = resolveDate(dueDate, scope);
+      if (followUpDate !== undefined) result.followUpDate = resolveDate(followUpDate, scope);
+    }
+
     return result;
   }
 }
@@ -16295,15 +16289,33 @@ class FormatProcess {
     const documentation = this.process.behaviour.documentation;
     if (documentation && !elementApi.content.description) {
       const text = documentation[0]?.text;
-      if (text) result.description = resolveValue(text, getFeelScope(elementApi.environment));
+      if (text) result.description = /** @type {string} */ (resolveValue(text, getFeelScope(elementApi.environment)));
     }
     return result;
   }
 }
 
+/**
+ * Resolve a due/follow-up date to an ISO 8601 string. A FEEL temporal result (a luxon
+ * DateTime) or a Date is ISO-stringified — content is JSON-serialized on `getState()`, so a
+ * string is the shape that survives a recover round trip. Anything else passes through as-is.
+ * @param {any} value
+ * @param {any} scope
+ * @returns {string | undefined} Date as iso string
+ */
+function resolveDate(value, scope) {
+  const resolved = resolveValue(value, scope);
+  if (typeof resolved?.toISO === 'function') return resolved.toISO();
+  if (resolved instanceof Date) return resolved.toISOString();
+  return resolved;
+}
+
 /**
  * Resolve a candidate users/groups value to a string array. A FEEL expression may yield an
  * array directly, otherwise a comma-separated string is split.
+ * @param {any} value
+ * @param {any} scope
+ * @returns {string[] | undefined}
  */
 function resolveList(value, scope) {
   if (!value) return undefined;
@@ -16652,6 +16664,7 @@ class Subscription {
  * @property {any} [calledDecision]
  * @property {Function} [Service]
  * @property {Subscription} [subscription]
+ * @property {boolean} [isEmpty] no zeebe extension data found and nothing to format — the element needs no extension
  */
 
 /**
@@ -16664,10 +16677,15 @@ function getExtensions(element, context) {
   const result = {};
   const isProcess = element.type === 'bpmn:Process';
 
-  let assignmentDefinition;
+  let assignmentDefinition, priorityDefinition, taskSchedule;
+  let foundZeebe = false;
   const values = element.behaviour.extensionElements?.values;
   if (values) {
     for (const ext of values) {
+      // Any zeebe-namespaced extension element counts as found — including ones with no
+      // handler (e.g. the bare `zeebe:userTask` marker), which keep the element extension
+      // loaded so e.g. a native user task's completion payload is merged.
+      if (ext.$type.startsWith('zeebe:')) foundZeebe = true;
       switch (ext.$type) {
         case 'zeebe:IoMapping':
           result.io = new IoMapping(element, ext);
@@ -16681,6 +16699,12 @@ function getExtensions(element, context) {
         case 'zeebe:AssignmentDefinition':
           assignmentDefinition = ext;
           break;
+        case 'zeebe:PriorityDefinition':
+          priorityDefinition = ext;
+          break;
+        case 'zeebe:TaskSchedule':
+          taskSchedule = ext;
+          break;
         case 'zeebe:ExecutionListeners':
           if (ext.listeners?.length) result.listeners = new ExecutionListeners(element, ext);
           break;
@@ -16722,7 +16746,16 @@ function getExtensions(element, context) {
   );
   if (loopExtension?.outputCollection) result.loop = new LoopCharacteristics(loopExtension);
 
-  result.format = isProcess ? new FormatProcess(element) : new FormatActivity(element, assignmentDefinition);
+  // Nothing zeebe-flavoured and nothing to format — the element needs no extension. A call
+  // activity is never inert: its output unwrap/merge is type-driven (the standard BPMN
+  // `calledElement` attribute needs no zeebe elements). Ignored for processes — a called
+  // process always needs its inbound input promoted, whatever it carries itself.
+  result.isEmpty =
+    !foundZeebe && !result.subscription && !loopExtension && !element.behaviour.documentation && element.type !== 'bpmn:CallActivity';
+
+  result.format = isProcess
+    ? new FormatProcess(element)
+    : new FormatActivity(element, assignmentDefinition, priorityDefinition, taskSchedule);
 
   return result;
 }
@@ -17099,20 +17132,32 @@ function getScriptExpression(activity) {
 
 /**
  * Flow extensions factory. Pass it to the engine via the environment `extensions` option.
+ *
+ * Returns undefined for an element that carries no zeebe extension data and nothing else to
+ * format (no documentation, not a call activity) — bpmn-elements skips falsy extensions, so
+ * plain elements run untouched, with no broker subscriptions or format-queue traffic.
  * @param {import('bpmn-elements').Activity | import('bpmn-elements').Process} element
  * @param {import('bpmn-elements').ContextInstance} context
- * @returns {FlowExtension}
+ * @returns {FlowExtension | undefined}
  */
 function extensions(element, context) {
   switch (element.type) {
     case 'bpmn:Process':
+      // A process is always attached: a called process needs its inbound input promoted
+      // even when it carries no zeebe extension data of its own.
       return new ProcessExtensions(element, context);
     case 'bpmn:SubProcess':
     case 'bpmn:AdHocSubProcess':
-    case 'bpmn:Transaction':
-      return new SubProcessExtensions(element, context);
-    default:
-      return new ElementExtensions(element, context);
+    case 'bpmn:Transaction': {
+      const subProcessExtensions = new SubProcessExtensions(element, context);
+      if (subProcessExtensions.extensions.isEmpty) return undefined;
+      return subProcessExtensions;
+    }
+    default: {
+      const elementExtensions = new ElementExtensions(element, context);
+      if (elementExtensions.extensions.isEmpty) return undefined;
+      return elementExtensions;
+    }
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0dep/bpmn-extensions",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Flow extensions for bpmn-elements: FEEL expressions and the zeebe-namespace BPMN extension elements",
   "type": "module",
   "module": "src/index.js",
@@ -69,7 +69,7 @@
     "@types/mocha": "^10.0.10",
     "@types/node": "^26.1.1",
     "bpmn-elements": "^18.0.12",
-    "bpmn-moddle": "^9.0.1",
+    "bpmn-moddle": "^10.1.0",
     "c8": "^12.0.0",
     "chai": "^6.2.2",
     "debug": "^4.4.3",

package/src/extensions/formatters.js

@@ -2,16 +2,21 @@ import { resolveValue, getFeelScope } from '../feel.js';
 
 /**
  * Format an activity on enter from its behaviour and extensions: documentation and,
- * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups).
+ * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups),
+ * `zeebe:priorityDefinition` (priority), and `zeebe:taskSchedule` (due/follow-up date).
  */
 export class FormatActivity {
   /**
    * @param {import('bpmn-elements').Activity} activity
    * @param {any} assignmentDefinition
+   * @param {any} [priorityDefinition]
+   * @param {any} [taskSchedule]
    */
-  constructor(activity, assignmentDefinition) {
+  constructor(activity, assignmentDefinition, priorityDefinition, taskSchedule) {
     this.activity = activity;
     this.assignmentDefinition = assignmentDefinition;
+    this.priorityDefinition = priorityDefinition;
+    this.taskSchedule = taskSchedule;
   }
   /**
    * @param {import('bpmn-elements').IApi<import('bpmn-elements').Activity>} elementApi
@@ -23,7 +28,7 @@ export class FormatActivity {
     const documentation = this.activity.behaviour.documentation;
     if (documentation && !elementApi.content.description) {
       const text = documentation[0]?.text;
-      if (text) result.description = resolveValue(text, scope);
+      if (text) result.description = /** @type {string} */ (resolveValue(text, scope));
     }
 
     const assignment = this.assignmentDefinition;
@@ -36,6 +41,22 @@ export class FormatActivity {
       if (groups) result.candidateGroups = groups;
     }
 
+    const priority = this.priorityDefinition?.priority;
+    if (priority !== undefined) {
+      const resolved = resolveValue(priority, scope);
+      // A static attribute value is a string — expose a numeric one as a number (like retries).
+      const num = Number(resolved);
+      /** @type {Number | string | undefined} */
+      result.priority = typeof resolved === 'string' && resolved.trim() !== '' && Number.isFinite(num) ? num : resolved;
+    }
+
+    const schedule = this.taskSchedule;
+    if (schedule) {
+      const { dueDate, followUpDate } = schedule;
+      if (dueDate !== undefined) result.dueDate = resolveDate(dueDate, scope);
+      if (followUpDate !== undefined) result.followUpDate = resolveDate(followUpDate, scope);
+    }
+
     return result;
   }
 }
@@ -58,15 +79,33 @@ 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, getFeelScope(elementApi.environment));
+      if (text) result.description = /** @type {string} */ (resolveValue(text, getFeelScope(elementApi.environment)));
     }
     return result;
   }
 }
 
+/**
+ * Resolve a due/follow-up date to an ISO 8601 string. A FEEL temporal result (a luxon
+ * DateTime) or a Date is ISO-stringified — content is JSON-serialized on `getState()`, so a
+ * string is the shape that survives a recover round trip. Anything else passes through as-is.
+ * @param {any} value
+ * @param {any} scope
+ * @returns {string | undefined} Date as iso string
+ */
+function resolveDate(value, scope) {
+  const resolved = resolveValue(value, scope);
+  if (typeof resolved?.toISO === 'function') return resolved.toISO();
+  if (resolved instanceof Date) return resolved.toISOString();
+  return resolved;
+}
+
 /**
  * Resolve a candidate users/groups value to a string array. A FEEL expression may yield an
  * array directly, otherwise a comma-separated string is split.
+ * @param {any} value
+ * @param {any} scope
+ * @returns {string[] | undefined}
  */
 function resolveList(value, scope) {
   if (!value) return undefined;

package/src/getExtensions.js

@@ -22,6 +22,7 @@ import { Subscription } from './extensions/Subscription.js';
  * @property {any} [calledDecision]
  * @property {Function} [Service]
  * @property {Subscription} [subscription]
+ * @property {boolean} [isEmpty] no zeebe extension data found and nothing to format — the element needs no extension
  */
 
 /**
@@ -34,10 +35,15 @@ export function getExtensions(element, context) {
   const result = {};
   const isProcess = element.type === 'bpmn:Process';
 
-  let assignmentDefinition;
+  let assignmentDefinition, priorityDefinition, taskSchedule;
+  let foundZeebe = false;
   const values = element.behaviour.extensionElements?.values;
   if (values) {
     for (const ext of values) {
+      // Any zeebe-namespaced extension element counts as found — including ones with no
+      // handler (e.g. the bare `zeebe:userTask` marker), which keep the element extension
+      // loaded so e.g. a native user task's completion payload is merged.
+      if (ext.$type.startsWith('zeebe:')) foundZeebe = true;
       switch (ext.$type) {
         case 'zeebe:IoMapping':
           result.io = new IoMapping(element, ext);
@@ -51,6 +57,12 @@ export function getExtensions(element, context) {
         case 'zeebe:AssignmentDefinition':
           assignmentDefinition = ext;
           break;
+        case 'zeebe:PriorityDefinition':
+          priorityDefinition = ext;
+          break;
+        case 'zeebe:TaskSchedule':
+          taskSchedule = ext;
+          break;
         case 'zeebe:ExecutionListeners':
           if (ext.listeners?.length) result.listeners = new ExecutionListeners(element, ext);
           break;
@@ -92,7 +104,16 @@ export function getExtensions(element, context) {
   );
   if (loopExtension?.outputCollection) result.loop = new LoopCharacteristics(loopExtension);
 
-  result.format = isProcess ? new FormatProcess(element) : new FormatActivity(element, assignmentDefinition);
+  // Nothing zeebe-flavoured and nothing to format — the element needs no extension. A call
+  // activity is never inert: its output unwrap/merge is type-driven (the standard BPMN
+  // `calledElement` attribute needs no zeebe elements). Ignored for processes — a called
+  // process always needs its inbound input promoted, whatever it carries itself.
+  result.isEmpty =
+    !foundZeebe && !result.subscription && !loopExtension && !element.behaviour.documentation && element.type !== 'bpmn:CallActivity';
+
+  result.format = isProcess
+    ? new FormatProcess(element)
+    : new FormatActivity(element, assignmentDefinition, priorityDefinition, taskSchedule);
 
   return result;
 }

package/src/index.js

@@ -18,20 +18,32 @@ export { ServiceError, FormatError } from './Errors.js';
 
 /**
  * Flow extensions factory. Pass it to the engine via the environment `extensions` option.
+ *
+ * Returns undefined for an element that carries no zeebe extension data and nothing else to
+ * format (no documentation, not a call activity) — bpmn-elements skips falsy extensions, so
+ * plain elements run untouched, with no broker subscriptions or format-queue traffic.
  * @param {import('bpmn-elements').Activity | import('bpmn-elements').Process} element
  * @param {import('bpmn-elements').ContextInstance} context
- * @returns {FlowExtension}
+ * @returns {FlowExtension | undefined}
  */
 export function extensions(element, context) {
   switch (element.type) {
     case 'bpmn:Process':
+      // A process is always attached: a called process needs its inbound input promoted
+      // even when it carries no zeebe extension data of its own.
       return new ProcessExtensions(element, context);
     case 'bpmn:SubProcess':
     case 'bpmn:AdHocSubProcess':
-    case 'bpmn:Transaction':
-      return new SubProcessExtensions(element, context);
-    default:
-      return new ElementExtensions(element, context);
+    case 'bpmn:Transaction': {
+      const subProcessExtensions = new SubProcessExtensions(element, context);
+      if (subProcessExtensions.extensions.isEmpty) return undefined;
+      return subProcessExtensions;
+    }
+    default: {
+      const elementExtensions = new ElementExtensions(element, context);
+      if (elementExtensions.extensions.isEmpty) return undefined;
+      return elementExtensions;
+    }
   }
 }
 

package/types/index.d.ts

@@ -4,8 +4,12 @@ declare module '@0dep/bpmn-extensions' {
 	 * */
 	/**
 	 * Flow extensions factory. Pass it to the engine via the environment `extensions` option.
+	 *
+	 * Returns undefined for an element that carries no zeebe extension data and nothing else to
+	 * format (no documentation, not a call activity) — bpmn-elements skips falsy extensions, so
+	 * plain elements run untouched, with no broker subscriptions or format-queue traffic.
 	 * */
-	export function extensions(element: import("bpmn-elements").Activity | import("bpmn-elements").Process, context: import("bpmn-elements").ContextInstance): FlowExtension;
+	export function extensions(element: import("bpmn-elements").Activity | import("bpmn-elements").Process, context: import("bpmn-elements").ContextInstance): FlowExtension | undefined;
 	/**
 	 * Behaviour extend function for moddle-context-serializer.
 	 *
@@ -210,22 +214,33 @@ declare module '@0dep/bpmn-extensions' {
 		calledDecision?: any;
 		Service?: Function | undefined;
 		subscription?: Subscription | undefined;
+		/**
+		 * no zeebe extension data found and nothing to format — the element needs no extension
+		 */
+		isEmpty?: boolean | undefined;
 	};
 	/**
 	 * Format an activity on enter from its behaviour and extensions: documentation and,
-	 * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups).
+	 * for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups),
+	 * `zeebe:priorityDefinition` (priority), and `zeebe:taskSchedule` (due/follow-up date).
 	 */
 	class FormatActivity {
 		
-		constructor(activity: import("bpmn-elements").Activity, assignmentDefinition: any);
+		constructor(activity: import("bpmn-elements").Activity, assignmentDefinition: any, priorityDefinition?: any, taskSchedule?: any);
 		activity: import("bpmn-elements").Activity;
 		assignmentDefinition: any;
+		priorityDefinition: any;
+		taskSchedule: any;
 		
 		resolve(elementApi: import("bpmn-elements").IApi<import("bpmn-elements").Activity>): {
-			description: any;
+			description: string;
 			assignee: any;
-			candidateUsers: any[];
-			candidateGroups: any[];
+			candidateUsers: string[];
+			candidateGroups: string[];
+			
+			priority: number | string | undefined;
+			dueDate: string | undefined;
+			followUpDate: string | undefined;
 		};
 	}
 	/**
@@ -237,7 +252,7 @@ declare module '@0dep/bpmn-extensions' {
 		process: import("bpmn-elements").Process;
 		
 		resolve(elementApi: import("bpmn-elements").IApi<import("bpmn-elements").Process>): {
-			description: any;
+			description: string;
 		};
 	}
 	/**

package/types/index.d.ts.map

@@ -66,6 +66,6 @@
 		null,
 		null
 	],
-	"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",
+	"mappings": ";;;;;;;;;;;iBA4BgBA,UAAUA;;;;;;;;iBA6BVC,QAAQA;;;;;;;;;;;;;;;;iBC9CRC,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;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OCDXC,cAAcA;;;;;;;;;;;;;;;;;;;;;;OA2DdC,aAAaA;;;;;;;;;;;;;;;;;;;;OCrDbC,SAASA;;;;;;;;;;;;;;;;;;;;;;;OCPTC,WAAWA;;;;;;;;;;;OCEXC,UAAUA;;;;;;;;;;;;;;;OCIVC,kBAAkBA;;;;;;;;;;;;;;;;;;;OCFlBC,IAAIA;;;;;;;;;;;;;;;;;;;;;;OCGJC,mBAAmBA;;;;;;;;;;;;;;;;;;;OCHnBC,YAAYA",
 	"ignoreList": []
 }