@0dep/bpmn-extensions 0.0.5 → 0.0.6

package/README.md

@@ -12,10 +12,11 @@ which covers the older `camunda:*` extension elements.
 ## Install
 
 ```sh
-npm install @0dep/bpmn-extensions bpmn-elements
+npm install @0dep/bpmn-extensions bpmn-elements croner
 ```
 
-`bpmn-elements` (>= 18) is a peer dependency. Requires Node.js >= 22.
+`bpmn-elements` (>= 18) and [`croner`](https://www.npmjs.com/package/croner) (cron timer cycles) are
+peer dependencies. Requires Node.js >= 22.
 
 ## What it does
 
@@ -49,6 +50,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.
+- **Timer start events with cron** — a `TimerEventDefinition` that also parses a **cron** `timeCycle`
+  (`0 0 * * *`, as Camunda 8 schedules timer start events) besides ISO 8601 intervals. A top-level
+  timer start event's cycle is lifted onto its behaviour as `scheduledStart` by `extendFn` and exposed
+  on the start event content, so a scheduler can find the flows to start without running them.
 - **`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
@@ -61,7 +66,10 @@ npm install @0dep/bpmn-extensions bpmn-elements
   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).
+  bpmn-elements expects on the behaviour: call activity process id, multi-instance collection, and a
+  timer start event's cycle as `scheduledStart`).
+- `TimerEventDefinition` — a bpmn-elements timer event definition that accepts cron `timeCycle`s;
+  install it through the type resolver: `TypeResolver({ ...elements, TimerEventDefinition })`.
 - `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`,
@@ -130,6 +138,60 @@ A service task's `zeebe:taskDefinition type="charge-card"` is dispatched to the
 service named `charge-card`. Its callback result is the job's variables, which `zeebe:ioMapping`
 output parameters map back into the process.
 
+## Extract timers
+
+List the timers of a definition without running it — e.g. to schedule flows by their timer start
+event. The serializer collects every timer event definition; `extendFn` marks a timer start event's
+cycle as `scheduledStart`, and the cron-capable `TimerEventDefinition` parses each one to its next
+expiry:
+
+```javascript
+import { createRequire } from 'node:module';
+import { strict as assert } from 'node:assert';
+import { BpmnModdle } from 'bpmn-moddle';
+import * as elements from 'bpmn-elements';
+import { Serializer, TypeResolver } from 'moddle-context-serializer';
+import { extendFn, TimerEventDefinition } from '@0dep/bpmn-extensions';
+
+const require = createRequire(import.meta.url);
+const moddle = new BpmnModdle({ zeebe: require('zeebe-bpmn-moddle/resources/zeebe.json') });
+
+const source = `<?xml version="1.0" encoding="UTF-8"?>
+<definitions xmlns="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" id="def">
+  <process id="nightly" isExecutable="true">
+    <startEvent id="start">
+      <timerEventDefinition>
+        <timeCycle xsi:type="tFormalExpression">0 1 * * *</timeCycle>
+      </timerEventDefinition>
+    </startEvent>
+    <sequenceFlow id="to-task" sourceRef="start" targetRef="task" />
+    <userTask id="task" />
+    <boundaryEvent id="reminder" cancelActivity="false" attachedToRef="task">
+      <timerEventDefinition>
+        <timeDuration xsi:type="tFormalExpression">R3/PT1M</timeDuration>
+      </timerEventDefinition>
+    </boundaryEvent>
+  </process>
+</definitions>`;
+
+const moddleContext = await moddle.fromXML(source);
+const serializer = Serializer(moddleContext, TypeResolver({ ...elements, TimerEventDefinition }), extendFn);
+
+const dummyActivity = { id: 'dummy', broker: {}, environment: { Logger() {} } };
+const timers = serializer.getTimers().map((t) => ({
+  ...t,
+  parsed: new TimerEventDefinition(dummyActivity, { type: t.timer.type, behaviour: t.timer }).parse(t.timer.timerType, t.timer.value),
+}));
+
+console.log(timers.map((t) => [t.parent.id, t.timer.timerType, t.timer.value, t.parsed.expireAt]));
+assert.equal(timers.length, 2);
+assert.equal(timers[0].parent.id, 'start');
+assert.ok(timers[0].parsed.expireAt instanceof Date);
+
+// A timer start event is a schedule: the cycle is lifted onto the behaviour
+assert.equal(serializer.getActivityById('start').behaviour.scheduledStart, '0 1 * * *');
+```
+
 ## Development
 
 ```sh
@@ -147,6 +209,7 @@ the engine's `Logger` to the [`debug`](https://www.npmjs.com/package/debug) pack
 
 # Ecosystem
 
+- [0dep.se/run](https://0dep.se/run) — Run a BPMN diagram in the browser: `bpmn-elements` wired with `@0dep/bpmn-extensions`, drawn with bpmn-js; step through, signal waiting tasks, and drop DMN files for business rule tasks.
 - [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`.

package/dist/index.js

@@ -1,5 +1,8 @@
 'use strict';
 
+var croner = require('croner');
+var bpmnElements = require('bpmn-elements');
+
 // these aren't really private, but nor are they really useful to document
 
 /**
@@ -16211,8 +16214,8 @@ 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),
+ * Format an activity on enter from its behaviour and extensions: documentation, a top-level
+ * timer start event's `scheduledStart` (lifted by `extendFn`) and, for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups),
  * `zeebe:priorityDefinition` (priority), and `zeebe:taskSchedule` (due/follow-up date).
  */
 class FormatActivity {
@@ -16241,6 +16244,11 @@ class FormatActivity {
       if (text) result.description = /** @type {string} */ (resolveValue(text, scope));
     }
 
+    // A timer start event's cycle is only a schedule when it starts the process itself — a
+    // sub-process start event runs whenever its parent does.
+    const scheduledStart = this.activity.behaviour.scheduledStart;
+    if (scheduledStart && this.activity.parent?.type === 'bpmn:Process') result.scheduledStart = scheduledStart;
+
     const assignment = this.assignmentDefinition;
     if (assignment) {
       const { assignee, candidateUsers, candidateGroups } = assignment;
@@ -16746,12 +16754,18 @@ function getExtensions(element, context) {
   );
   if (loopExtension?.outputCollection) result.loop = new LoopCharacteristics(loopExtension);
 
-  // Nothing zeebe-flavoured and nothing to format — the element needs no extension. A call
+  // Nothing zeebe-flavoured and nothing to format (documentation, a process-level timer start
+  // event's `scheduledStart`) — 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';
+    !foundZeebe &&
+    !result.subscription &&
+    !loopExtension &&
+    !element.behaviour.documentation &&
+    !(element.behaviour.scheduledStart && element.parent?.type === 'bpmn:Process') &&
+    element.type !== 'bpmn:CallActivity';
 
   result.format = isProcess
     ? new FormatProcess(element)
@@ -17123,6 +17137,50 @@ function getScriptExpression(activity) {
   return script?.expression;
 }
 
+/**
+ * bpmn-elements timer event definition that also accepts a **cron** `timeCycle` (Camunda 8
+ * timer start events schedule with cron, e.g. `0 0 * * *`). An ISO 8601 interval is tried
+ * first; on failure the value is parsed as cron and the next run is the expiry.
+ *
+ * Install it via the type resolver so it replaces the bpmn-elements default:
+ * `TypeResolver({ ...elements, TimerEventDefinition })`.
+ */
+class TimerEventDefinition extends bpmnElements.TimerEventDefinition {
+  /**
+   * Supported timeCycle formats
+   * @returns {string[]}
+   */
+  get supports() {
+    return ['cron', 'iso8601'];
+  }
+  /**
+   * @param {import('bpmn-elements').TimerType} timerType
+   * @param {string} value
+   * @returns {import('bpmn-elements').parsedTimer}
+   */
+  parse(timerType, value) {
+    if (timerType !== 'timeCycle') return super.parse(timerType, value);
+
+    /** @type {any} */
+    let isoError;
+    try {
+      return super.parse(timerType, value);
+    } catch (err) {
+      isoError = err;
+    }
+
+    try {
+      const expireAt = new croner.Cron(value).nextRun();
+      if (!expireAt) throw new RangeError('cron has no next run');
+      return { expireAt, delay: expireAt.getTime() - Date.now() };
+    } catch (/** @type {any} */ err) {
+      this.logger.error(`<${this.activity?.id}> failed to parse timeCycle: ${isoError.message}`);
+      this.logger.error(`<${this.activity?.id}> failed to parse timeCycle as cron: ${err.message}`);
+      throw new RangeError(`Failed to parse timeCycle <${value?.substring(0, 255)}> as ISO 8601 interval or cron`, { cause: err });
+    }
+  }
+}
+
 /**
  * A flow extension activated by bpmn-elements around an element's run.
  * @typedef {object} FlowExtension
@@ -17166,10 +17224,17 @@ function extensions(element, context) {
  *
  * Lifts extension data onto the places bpmn-elements expects to find it on the element
  * behaviour: the call activity's called process id (`zeebe:calledElement`) and the multi-instance
- * input collection/element (`zeebe:loopCharacteristics`).
+ * input collection/element (`zeebe:loopCharacteristics`). A timer start event's `timeCycle`
+ * (ISO 8601 or cron) is lifted as `scheduledStart`, so a scheduler can find it without running
+ * the flow.
  * @param {any} behaviour
  */
 function extendFn(behaviour) {
+  if (behaviour.$type === 'bpmn:StartEvent' && Array.isArray(behaviour.eventDefinitions)) {
+    const timer = behaviour.eventDefinitions.find((ed) => ed?.type === 'bpmn:TimerEventDefinition' && ed.behaviour?.timeCycle);
+    if (timer) behaviour.scheduledStart = timer.behaviour.timeCycle;
+  }
+
   const values = behaviour.extensionElements?.values;
   if (Array.isArray(values)) {
     for (const ext of values) {
@@ -17197,6 +17262,7 @@ exports.JobService = JobService;
 exports.ProcessExtensions = ProcessExtensions;
 exports.ServiceError = ServiceError;
 exports.SubProcessExtensions = SubProcessExtensions;
+exports.TimerEventDefinition = TimerEventDefinition;
 exports.evaluateFeel = evaluateFeel;
 exports.evaluateFeelUnaryTest = evaluateFeelUnaryTest;
 exports.extendFn = extendFn;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@0dep/bpmn-extensions",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "description": "Flow extensions for bpmn-elements: FEEL expressions and the zeebe-namespace BPMN extension elements",
   "type": "module",
   "module": "src/index.js",
@@ -51,7 +51,8 @@
     "access": "public"
   },
   "peerDependencies": {
-    "bpmn-elements": ">=18.0.12"
+    "bpmn-elements": ">=18.0.12",
+    "croner": ">=9"
   },
   "dependencies": {
     "feelin": "^7.0.1"
@@ -72,6 +73,7 @@
     "bpmn-moddle": "^10.1.0",
     "c8": "^12.0.0",
     "chai": "^6.2.2",
+    "croner": "^10.0.1",
     "debug": "^4.4.3",
     "dts-buddy": "^0.8.2",
     "eslint": "^10.6.0",
@@ -83,7 +85,7 @@
     "rollup": "^4.62.2",
     "texample": "^1.0.2",
     "typescript": "^6.0.3",
-    "zeebe-bpmn-moddle": "^1.15.0"
+    "zeebe-bpmn-moddle": "^2.0.0"
   },
   "files": [
     "src",

package/src/TimerEventDefinition.js

@@ -0,0 +1,46 @@
+import { Cron } from 'croner';
+import { TimerEventDefinition as BaseTimerEventDefinition } from 'bpmn-elements';
+
+/**
+ * bpmn-elements timer event definition that also accepts a **cron** `timeCycle` (Camunda 8
+ * timer start events schedule with cron, e.g. `0 0 * * *`). An ISO 8601 interval is tried
+ * first; on failure the value is parsed as cron and the next run is the expiry.
+ *
+ * Install it via the type resolver so it replaces the bpmn-elements default:
+ * `TypeResolver({ ...elements, TimerEventDefinition })`.
+ */
+export class TimerEventDefinition extends BaseTimerEventDefinition {
+  /**
+   * Supported timeCycle formats
+   * @returns {string[]}
+   */
+  get supports() {
+    return ['cron', 'iso8601'];
+  }
+  /**
+   * @param {import('bpmn-elements').TimerType} timerType
+   * @param {string} value
+   * @returns {import('bpmn-elements').parsedTimer}
+   */
+  parse(timerType, value) {
+    if (timerType !== 'timeCycle') return super.parse(timerType, value);
+
+    /** @type {any} */
+    let isoError;
+    try {
+      return super.parse(timerType, value);
+    } catch (err) {
+      isoError = err;
+    }
+
+    try {
+      const expireAt = new Cron(value).nextRun();
+      if (!expireAt) throw new RangeError('cron has no next run');
+      return { expireAt, delay: expireAt.getTime() - Date.now() };
+    } catch (/** @type {any} */ err) {
+      this.logger.error(`<${this.activity?.id}> failed to parse timeCycle: ${isoError.message}`);
+      this.logger.error(`<${this.activity?.id}> failed to parse timeCycle as cron: ${err.message}`);
+      throw new RangeError(`Failed to parse timeCycle <${value?.substring(0, 255)}> as ISO 8601 interval or cron`, { cause: err });
+    }
+  }
+}

package/src/extensions/formatters.js

@@ -1,8 +1,8 @@
 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),
+ * Format an activity on enter from its behaviour and extensions: documentation, a top-level
+ * timer start event's `scheduledStart` (lifted by `extendFn`) and, for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups),
  * `zeebe:priorityDefinition` (priority), and `zeebe:taskSchedule` (due/follow-up date).
  */
 export class FormatActivity {
@@ -31,6 +31,11 @@ export class FormatActivity {
       if (text) result.description = /** @type {string} */ (resolveValue(text, scope));
     }
 
+    // A timer start event's cycle is only a schedule when it starts the process itself — a
+    // sub-process start event runs whenever its parent does.
+    const scheduledStart = this.activity.behaviour.scheduledStart;
+    if (scheduledStart && this.activity.parent?.type === 'bpmn:Process') result.scheduledStart = scheduledStart;
+
     const assignment = this.assignmentDefinition;
     if (assignment) {
       const { assignee, candidateUsers, candidateGroups } = assignment;

package/src/getExtensions.js

@@ -104,12 +104,18 @@ export function getExtensions(element, context) {
   );
   if (loopExtension?.outputCollection) result.loop = new LoopCharacteristics(loopExtension);
 
-  // Nothing zeebe-flavoured and nothing to format — the element needs no extension. A call
+  // Nothing zeebe-flavoured and nothing to format (documentation, a process-level timer start
+  // event's `scheduledStart`) — 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';
+    !foundZeebe &&
+    !result.subscription &&
+    !loopExtension &&
+    !element.behaviour.documentation &&
+    !(element.behaviour.scheduledStart && element.parent?.type === 'bpmn:Process') &&
+    element.type !== 'bpmn:CallActivity';
 
   result.format = isProcess
     ? new FormatProcess(element)

package/src/index.js

@@ -5,6 +5,7 @@ import { SubProcessExtensions } from './SubProcessExtensions.js';
 export { ElementExtensions, ProcessExtensions, SubProcessExtensions };
 export { FeelExpressions } from './Expressions.js';
 export { FeelScripts } from './extensions/FeelScripts.js';
+export { TimerEventDefinition } from './TimerEventDefinition.js';
 export { isFeelExpression, stripFeel, evaluateFeel, evaluateFeelUnaryTest, resolveValue, getFeelScope } from './feel.js';
 export { JobService } from './extensions/TaskDefinition.js';
 export { ServiceError, FormatError } from './Errors.js';
@@ -52,10 +53,17 @@ export function extensions(element, context) {
  *
  * Lifts extension data onto the places bpmn-elements expects to find it on the element
  * behaviour: the call activity's called process id (`zeebe:calledElement`) and the multi-instance
- * input collection/element (`zeebe:loopCharacteristics`).
+ * input collection/element (`zeebe:loopCharacteristics`). A timer start event's `timeCycle`
+ * (ISO 8601 or cron) is lifted as `scheduledStart`, so a scheduler can find it without running
+ * the flow.
  * @param {any} behaviour
  */
 export function extendFn(behaviour) {
+  if (behaviour.$type === 'bpmn:StartEvent' && Array.isArray(behaviour.eventDefinitions)) {
+    const timer = behaviour.eventDefinitions.find((ed) => ed?.type === 'bpmn:TimerEventDefinition' && ed.behaviour?.timeCycle);
+    if (timer) behaviour.scheduledStart = timer.behaviour.timeCycle;
+  }
+
   const values = behaviour.extensionElements?.values;
   if (Array.isArray(values)) {
     for (const ext of values) {

package/types/index.d.ts

@@ -1,4 +1,5 @@
 declare module '@0dep/bpmn-extensions' {
+	import type { TimerEventDefinition as BaseTimerEventDefinition } from 'bpmn-elements';
 	/**
 	 * A flow extension activated by bpmn-elements around an element's run.
 	 * */
@@ -15,7 +16,9 @@ declare module '@0dep/bpmn-extensions' {
 	 *
 	 * Lifts extension data onto the places bpmn-elements expects to find it on the element
 	 * behaviour: the call activity's called process id (`zeebe:calledElement`) and the multi-instance
-	 * input collection/element (`zeebe:loopCharacteristics`).
+	 * input collection/element (`zeebe:loopCharacteristics`). A timer start event's `timeCycle`
+	 * (ISO 8601 or cron) is lifted as `scheduledStart`, so a scheduler can find it without running
+	 * the flow.
 	 * */
 	export function extendFn(behaviour: any): void;
 	/**
@@ -48,6 +51,20 @@ declare module '@0dep/bpmn-extensions' {
 	 *
 	 * */
 	export function FeelScripts(): import("bpmn-elements").IScripts;
+	/**
+	 * bpmn-elements timer event definition that also accepts a **cron** `timeCycle` (Camunda 8
+	 * timer start events schedule with cron, e.g. `0 0 * * *`). An ISO 8601 interval is tried
+	 * first; on failure the value is parsed as cron and the next run is the expiry.
+	 *
+	 * Install it via the type resolver so it replaces the bpmn-elements default:
+	 * `TypeResolver({ ...elements, TimerEventDefinition })`.
+	 */
+	export class TimerEventDefinition extends BaseTimerEventDefinition {
+		/**
+		 * Supported timeCycle formats
+		 * */
+		get supports(): string[];
+	}
 	/**
 	 * `zeebe:taskDefinition`.
 	 *
@@ -220,8 +237,8 @@ declare module '@0dep/bpmn-extensions' {
 		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),
+	 * Format an activity on enter from its behaviour and extensions: documentation, a top-level
+	 * timer start event's `scheduledStart` (lifted by `extendFn`) and, for user tasks, the `zeebe:assignmentDefinition` (assignee, candidate users/groups),
 	 * `zeebe:priorityDefinition` (priority), and `zeebe:taskSchedule` (due/follow-up date).
 	 */
 	class FormatActivity {
@@ -234,6 +251,7 @@ declare module '@0dep/bpmn-extensions' {
 		
 		resolve(elementApi: import("bpmn-elements").IApi<import("bpmn-elements").Activity>): {
 			description: string;
+			scheduledStart: any;
 			assignee: any;
 			candidateUsers: string[];
 			candidateGroups: string[];

package/types/index.d.ts.map

@@ -6,6 +6,7 @@
 		"extendFn",
 		"FeelExpressions",
 		"FeelScripts",
+		"TimerEventDefinition",
 		"JobService",
 		"ElementExtensions",
 		"ProcessExtensions",
@@ -32,6 +33,7 @@
 		"../src/index.js",
 		"../src/Expressions.js",
 		"../src/extensions/FeelScripts.js",
+		"../src/TimerEventDefinition.js",
 		"../src/extensions/TaskDefinition.js",
 		"../src/ElementExtensions.js",
 		"../src/ProcessExtensions.js",
@@ -64,8 +66,9 @@
 		null,
 		null,
 		null,
+		null,
 		null
 	],
-	"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",
+	"mappings": ";;;;;;;;;;;;iBA6BgBA,UAAUA;;;;;;;;;;iBA+BVC,QAAQA;;;;;;;;;;;;;;;;iBCjDRC,eAAeA;;;;;;;;;;;;;;iBCEfC,WAAWA;;;;;;;;;cCFdC,oBAAoBA;;;;;;;;;;;;;;;;;;;;iBCMjBC,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;;;;;;;;;;;;;;;;;;;;;;;OAgEdC,aAAaA;;;;;;;;;;;;;;;;;;;;OC1DbC,SAASA;;;;;;;;;;;;;;;;;;;;;;;OCPTC,WAAWA;;;;;;;;;;;OCEXC,UAAUA;;;;;;;;;;;;;;;OCIVC,kBAAkBA;;;;;;;;;;;;;;;;;;;OCFlBC,IAAIA;;;;;;;;;;;;;;;;;;;;;;OCGJC,mBAAmBA;;;;;;;;;;;;;;;;;;;OCHnBC,YAAYA",
 	"ignoreList": []
 }