relu-bpmn/dist/index.js

RELU快速开发平台bpmn组件

var __defProp = Object.defineProperty;
var __defNormalProp = (obj, key2, value) => key2 in obj ? __defProp(obj, key2, { enumerable: true, configurable: true, writable: true, value }) : obj[key2] = value;
var __publicField = (obj, key2, value) => __defNormalProp(obj, typeof key2 !== "symbol" ? key2 + "" : key2, value);
import { inject, ref, h as h$2, getCurrentInstance, nextTick, reactive, defineComponent, createVNode, Fragment, isVNode, Comment, Text as Text$1, computed, provide, unref, shallowRef, watch, watchEffect, onBeforeUnmount, triggerRef, render, cloneVNode, onBeforeMount, onMounted, onUpdated, Teleport, Transition, onUnmounted, TransitionGroup, toRaw, withDirectives, vShow, isRef, openBlock, createElementBlock, markRaw } from "vue";
const simpleDefaultXml = `<?xml version="1.0" encoding="UTF-8"?>
<bpmn2:definitions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:bpmn2="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" xmlns:di="http://www.omg.org/spec/DD/20100524/DI" id="sample-diagram" targetNamespace="http://www.flowable.org/processdef" xsi:schemaLocation="http://www.omg.org/spec/BPMN/20100524/MODEL BPMN20.xsd">
  <bpmn2:process id="Process_1" name="" isExecutable="true">
    <bpmn2:startEvent id="Event_0oz4pwh" >
      <bpmn2:outgoing>Flow_1iadlmn</bpmn2:outgoing>
    </bpmn2:startEvent>
    <bpmn2:userTask id="Activity_1qf73gq">
      <bpmn2:incoming>Flow_1iadlmn</bpmn2:incoming>
      <bpmn2:outgoing>Flow_1kz1x8a</bpmn2:outgoing>
    </bpmn2:userTask>
    <bpmn2:sequenceFlow id="Flow_1iadlmn" sourceRef="Event_0oz4pwh" targetRef="Activity_1qf73gq" />
    <bpmn2:endEvent id="Event_0zlhfee">
      <bpmn2:incoming>Flow_1kz1x8a</bpmn2:incoming>
    </bpmn2:endEvent>
    <bpmn2:sequenceFlow id="Flow_1kz1x8a" sourceRef="Activity_1qf73gq" targetRef="Event_0zlhfee" />
  </bpmn2:process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_1">
    <bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="Process_1">
      <bpmndi:BPMNShape id="Event_0oz4pwh_di" bpmnElement="Event_0oz4pwh">
        <dc:Bounds x="675" y="75" width="90" height="32" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Activity_1qf73gq_di" bpmnElement="Activity_1qf73gq">
        <dc:Bounds x="620" y="227" width="200" height="88" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNShape id="Event_0zlhfee_di" bpmnElement="Event_0zlhfee">
        <dc:Bounds x="675" y="435" width="90" height="32" />
      </bpmndi:BPMNShape>
      <bpmndi:BPMNEdge id="Flow_1iadlmn_di" bpmnElement="Flow_1iadlmn">
        <di:waypoint x="720" y="107" />
        <di:waypoint x="720" y="227" />
        <bpmndi:BPMNLabel>
          <dc:Bounds x="706" y="181" width="28" height="28" />
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
      <bpmndi:BPMNEdge id="Flow_1kz1x8a_di" bpmnElement="Flow_1kz1x8a">
        <di:waypoint x="720" y="315" />
        <di:waypoint x="720" y="435" />
        <bpmndi:BPMNLabel>
          <dc:Bounds x="706" y="361" width="28" height="28" />
        </bpmndi:BPMNLabel>
      </bpmndi:BPMNEdge>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</bpmn2:definitions>`;
const defaultXml = `<?xml version="1.0" encoding="UTF-8"?>
<bpmn2:definitions xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:bpmn2="http://www.omg.org/spec/BPMN/20100524/MODEL" xmlns:bpmndi="http://www.omg.org/spec/BPMN/20100524/DI" xmlns:dc="http://www.omg.org/spec/DD/20100524/DC" id="sample-diagram" targetNamespace="http://www.flowable.org/processdef" xsi:schemaLocation="http://www.omg.org/spec/BPMN/20100524/MODEL BPMN20.xsd">
  <bpmn2:process id="Process_1"  isExecutable="true">
    <bpmn2:startEvent id="Event_04q7xii"  />
  </bpmn2:process>
  <bpmndi:BPMNDiagram id="BPMNDiagram_1">
    <bpmndi:BPMNPlane id="BPMNPlane_1" bpmnElement="Process_1">
      <bpmndi:BPMNShape id="Event_04q7xii_di" bpmnElement="Event_04q7xii" >
        <dc:Bounds x="145" y="304" width="90" height="32" />
      </bpmndi:BPMNShape>
    </bpmndi:BPMNPlane>
  </bpmndi:BPMNDiagram>
</bpmn2:definitions>`;
const bpmnTask = "bpmn:UserTask";
const bpmnStart = "bpmn:StartEvent";
const bpmnEnd = "bpmn:EndEvent";
const bpmnGateway = "bpmn:InclusiveGateway";
const bpmnSequenceFlow = "bpmn:SequenceFlow";
const bpmnTimer = "bpmn:IntermediateCatchEvent";
const bpmnSubFlow = "subFlow";
const bpmnInclusive = "bpmn:InclusiveGateway";
const bpmnParallel = "bpmn:ParallelGateway";
const bpmnExclusive = "bpmn:ExclusiveGateway";
const bpmnChoose = "choose";
const bpmnGroup = "bpmn:Group";
const bpmnLabel = "label";
const bpmnIncoming = "bpmn2:incoming";
const bpmnTrigger = "trigger";
const bpmnExecute = "execute";
const bpmnOutgoing = "bpmn2:outgoing";
const bpmnAddData = "addData";
const bpmnGetData = "getData";
const bpmnUpdateData = "updateData";
const bpmnDelData = "deleteData";
const bpmnInterface = "dataInterface";
const bpmnLaunchFlow = "launchFlow";
const bpmnMessage = "message";
const bpmnSchedule = "schedule";
const bpmnEvent = "event";
const bpmnTime = "timeout";
const bpmnNotice = "notice";
const bpmnWebhook = "webhook";
const bpmnCopy = "copy";
const bpmnPaste = "paste";
const bpmnProcessing = "processing";
const typeStart = "start";
const typeGateway = "gateway";
const typeEnd = "end";
const typeTask = "approver";
const typeLabel = "label";
const typeTimer = "timer";
const typeSubFlow = "subFlow";
const typeConfluence = "confluence";
const typeGroup = "group";
const typeTrigger = "trigger";
const typeExecute = "execute";
const typeAddData = "addData";
const typeGetData = "getData";
const typeUpdateData = "updateData";
const typeDelData = "deleteData";
const typeInterface = "dataInterface";
const typeLaunchFlow = "launchFlow";
const typeMessage = "message";
const typeSchedule = "schedule";
const typeEventTrigger = "eventTrigger";
const typeTimeTrigger = "timeTrigger";
const typeNoticeTrigger = "noticeTrigger";
const typeWebhookTrigger = "webhookTrigger";
const typeConnect = "connect";
const typeCondition = "condition";
const typeCopy = "copy";
const typePaste = "paste";
const typeProcessing = "processing";
const typeInclusion = "inclusion";
const typeParallel = "parallel";
const typeExclusive = "exclusive";
const typeChoose = "choose";
function flatten(arr) {
  return Array.prototype.concat.apply([], arr);
}
const nativeToString$1 = Object.prototype.toString;
const nativeHasOwnProperty$1 = Object.prototype.hasOwnProperty;
function isUndefined$2(obj) {
  return obj === void 0;
}
function isDefined(obj) {
  return obj !== void 0;
}
function isNil(obj) {
  return obj == null;
}
function isArray$5(obj) {
  return nativeToString$1.call(obj) === "[object Array]";
}
function isObject$2(obj) {
  return nativeToString$1.call(obj) === "[object Object]";
}
function isNumber(obj) {
  return nativeToString$1.call(obj) === "[object Number]";
}
function isFunction$1(obj) {
  const tag = nativeToString$1.call(obj);
  return tag === "[object Function]" || tag === "[object AsyncFunction]" || tag === "[object GeneratorFunction]" || tag === "[object AsyncGeneratorFunction]" || tag === "[object Proxy]";
}
function isString$1(obj) {
  return nativeToString$1.call(obj) === "[object String]";
}
function ensureArray(obj) {
  if (isArray$5(obj)) {
    return;
  }
  throw new Error("must supply array");
}
function has$1(target, key2) {
  return !isNil(target) && nativeHasOwnProperty$1.call(target, key2);
}
function find(collection, matcher) {
  const matchFn = toMatcher(matcher);
  let match2;
  forEach$1(collection, function(val, key2) {
    if (matchFn(val, key2)) {
      match2 = val;
      return false;
    }
  });
  return match2;
}
function findIndex(collection, matcher) {
  const matchFn = toMatcher(matcher);
  let idx = isArray$5(collection) ? -1 : void 0;
  forEach$1(collection, function(val, key2) {
    if (matchFn(val, key2)) {
      idx = key2;
      return false;
    }
  });
  return idx;
}
function filter(collection, matcher) {
  const matchFn = toMatcher(matcher);
  let result = [];
  forEach$1(collection, function(val, key2) {
    if (matchFn(val, key2)) {
      result.push(val);
    }
  });
  return result;
}
function forEach$1(collection, iterator) {
  let val, result;
  if (isUndefined$2(collection)) {
    return;
  }
  const convertKey = isArray$5(collection) ? toNum$1 : identity$1;
  for (let key2 in collection) {
    if (has$1(collection, key2)) {
      val = collection[key2];
      result = iterator(val, convertKey(key2));
      if (result === false) {
        return val;
      }
    }
  }
}
function without(arr, matcher) {
  if (isUndefined$2(arr)) {
    return [];
  }
  ensureArray(arr);
  const matchFn = toMatcher(matcher);
  return arr.filter(function(el, idx) {
    return !matchFn(el, idx);
  });
}
function reduce(collection, iterator, result) {
  forEach$1(collection, function(value, idx) {
    result = iterator(result, value, idx);
  });
  return result;
}
function every(collection, matcher) {
  return !!reduce(collection, function(matches2, val, key2) {
    return matches2 && matcher(val, key2);
  }, true);
}
function some(collection, matcher) {
  return !!find(collection, matcher);
}
function map$2(collection, fn) {
  let result = [];
  forEach$1(collection, function(val, key2) {
    result.push(fn(val, key2));
  });
  return result;
}
function keys$1(collection) {
  return collection && Object.keys(collection) || [];
}
function size(collection) {
  return keys$1(collection).length;
}
function values(collection) {
  return map$2(collection, (val) => val);
}
function groupBy(collection, extractor, grouped = {}) {
  extractor = toExtractor(extractor);
  forEach$1(collection, function(val) {
    let discriminator = extractor(val) || "_";
    let group = grouped[discriminator];
    if (!group) {
      group = grouped[discriminator] = [];
    }
    group.push(val);
  });
  return grouped;
}
function uniqueBy(extractor, ...collections) {
  extractor = toExtractor(extractor);
  let grouped = {};
  forEach$1(collections, (c2) => groupBy(c2, extractor, grouped));
  let result = map$2(grouped, function(val, key2) {
    return val[0];
  });
  return result;
}
const unionBy = uniqueBy;
function sortBy(collection, extractor) {
  extractor = toExtractor(extractor);
  let sorted = [];
  forEach$1(collection, function(value, key2) {
    let disc = extractor(value, key2);
    let entry = {
      d: disc,
      v: value
    };
    for (var idx = 0; idx < sorted.length; idx++) {
      let { d: d2 } = sorted[idx];
      if (disc < d2) {
        sorted.splice(idx, 0, entry);
        return;
      }
    }
    sorted.push(entry);
  });
  return map$2(sorted, (e2) => e2.v);
}
function matchPattern(pattern) {
  return function(el) {
    return every(pattern, function(val, key2) {
      return el[key2] === val;
    });
  };
}
function toExtractor(extractor) {
  return isFunction$1(extractor) ? extractor : (e2) => {
    return e2[extractor];
  };
}
function toMatcher(matcher) {
  return isFunction$1(matcher) ? matcher : (e2) => {
    return e2 === matcher;
  };
}
function identity$1(arg) {
  return arg;
}
function toNum$1(arg) {
  return Number(arg);
}
function debounce(fn, timeout2) {
  let timer;
  let lastArgs;
  let lastThis;
  let lastNow;
  function fire(force) {
    let now2 = Date.now();
    let scheduledDiff = force ? 0 : lastNow + timeout2 - now2;
    if (scheduledDiff > 0) {
      return schedule2(scheduledDiff);
    }
    fn.apply(lastThis, lastArgs);
    clear2();
  }
  function schedule2(timeout3) {
    timer = setTimeout(fire, timeout3);
  }
  function clear2() {
    if (timer) {
      clearTimeout(timer);
    }
    timer = lastNow = lastArgs = lastThis = void 0;
  }
  function flush() {
    if (timer) {
      fire(true);
    }
    clear2();
  }
  function callback(...args) {
    lastNow = Date.now();
    lastArgs = args;
    lastThis = this;
    if (!timer) {
      schedule2(timeout2);
    }
  }
  callback.flush = flush;
  callback.cancel = clear2;
  return callback;
}
function bind$2(fn, target) {
  return fn.bind(target);
}
function assign$1(target, ...others) {
  return Object.assign(target, ...others);
}
function set$1(target, path, value) {
  let currentTarget = target;
  forEach$1(path, function(key2, idx) {
    if (typeof key2 !== "number" && typeof key2 !== "string") {
      throw new Error("illegal key type: " + typeof key2 + ". Key should be of type number or string.");
    }
    if (key2 === "constructor") {
      throw new Error("illegal key: constructor");
    }
    if (key2 === "__proto__") {
      throw new Error("illegal key: __proto__");
    }
    let nextKey = path[idx + 1];
    let nextTarget = currentTarget[key2];
    if (isDefined(nextKey) && isNil(nextTarget)) {
      nextTarget = currentTarget[key2] = isNaN(+nextKey) ? {} : [];
    }
    if (isUndefined$2(nextKey)) {
      if (isUndefined$2(value)) {
        delete currentTarget[key2];
      } else {
        currentTarget[key2] = value;
      }
    } else {
      currentTarget = nextTarget;
    }
  });
  return target;
}
function pick(target, properties) {
  let result = {};
  let obj = Object(target);
  forEach$1(properties, function(prop) {
    if (prop in obj) {
      result[prop] = target[prop];
    }
  });
  return result;
}
function omit$1(target, properties) {
  let result = {};
  let obj = Object(target);
  forEach$1(obj, function(prop, key2) {
    if (properties.indexOf(key2) === -1) {
      result[key2] = prop;
    }
  });
  return result;
}
function is$3(element, type) {
  var bo = getBusinessObject$1(element);
  return bo && typeof bo.$instanceOf === "function" && bo.$instanceOf(type);
}
function isAny$1(element, types2) {
  return some(types2, function(t2) {
    return is$3(element, t2);
  });
}
function getBusinessObject$1(element) {
  return element && element.businessObject || element;
}
function getDi$1(element) {
  return element && element.di;
}
function isConnection$3(value) {
  return isObject$2(value) && has$1(value, "waypoints");
}
function isLabel(value) {
  return isObject$2(value) && has$1(value, "labelTarget");
}
var DEFAULT_LABEL_SIZE$1 = {
  width: 90,
  height: 20
};
var FLOW_LABEL_INDENT = 15;
function isLabelExternal(semantic) {
  return is$3(semantic, "bpmn:Event") || is$3(semantic, "bpmn:Gateway") || is$3(semantic, "bpmn:DataStoreReference") || is$3(semantic, "bpmn:DataObjectReference") || is$3(semantic, "bpmn:DataInput") || is$3(semantic, "bpmn:DataOutput") || is$3(semantic, "bpmn:SequenceFlow") || is$3(semantic, "bpmn:MessageFlow") || is$3(semantic, "bpmn:Group");
}
function hasExternalLabel(element) {
  return isLabel(element.label);
}
function getFlowLabelPosition(waypoints) {
  var mid2 = waypoints.length / 2 - 1;
  var first = waypoints[Math.floor(mid2)];
  var second = waypoints[Math.ceil(mid2 + 0.01)];
  var position2 = getWaypointsMid(waypoints);
  var angle = Math.atan((second.y - first.y) / (second.x - first.x));
  var x2 = position2.x, y2 = position2.y;
  if (Math.abs(angle) < Math.PI / 2) {
    y2 -= FLOW_LABEL_INDENT;
  } else {
    x2 += FLOW_LABEL_INDENT;
  }
  return { x: x2, y: y2 };
}
function getWaypointsMid(waypoints) {
  var mid2 = waypoints.length / 2 - 1;
  var first = waypoints[Math.floor(mid2)];
  var second = waypoints[Math.ceil(mid2 + 0.01)];
  return {
    x: first.x + (second.x - first.x) / 2,
    y: first.y + (second.y - first.y) / 2
  };
}
function getExternalLabelMid(element) {
  if (element.waypoints) {
    return getFlowLabelPosition(element.waypoints);
  } else if (is$3(element, "bpmn:Group")) {
    return {
      x: element.x + element.width / 2,
      y: element.y + DEFAULT_LABEL_SIZE$1.height / 2
    };
  } else {
    return {
      x: element.x + element.width / 2,
      y: element.y + element.height + DEFAULT_LABEL_SIZE$1.height / 2
    };
  }
}
function getExternalLabelBounds(di, element) {
  var mid2, size2, bounds, label = di.label;
  if (label && label.bounds) {
    bounds = label.bounds;
    size2 = {
      width: Math.max(DEFAULT_LABEL_SIZE$1.width, bounds.width),
      height: bounds.height
    };
    mid2 = {
      x: bounds.x + bounds.width / 2,
      y: bounds.y + bounds.height / 2
    };
  } else {
    mid2 = getExternalLabelMid(element);
    size2 = DEFAULT_LABEL_SIZE$1;
  }
  return assign$1({
    x: mid2.x - size2.width / 2,
    y: mid2.y - size2.height / 2
  }, size2);
}
function getLabelAttr(semantic) {
  if (is$3(semantic, "bpmn:FlowElement") || is$3(semantic, "bpmn:Participant") || is$3(semantic, "bpmn:Lane") || is$3(semantic, "bpmn:SequenceFlow") || is$3(semantic, "bpmn:MessageFlow") || is$3(semantic, "bpmn:DataInput") || is$3(semantic, "bpmn:DataOutput")) {
    return "name";
  }
  if (is$3(semantic, "bpmn:TextAnnotation")) {
    return "text";
  }
  if (is$3(semantic, "bpmn:Group")) {
    return "categoryValueRef";
  }
}
function getCategoryValue(semantic) {
  var categoryValueRef = semantic["categoryValueRef"];
  if (!categoryValueRef) {
    return "";
  }
  return categoryValueRef.value || "";
}
function getLabel(element) {
  var semantic = element.businessObject, attr2 = getLabelAttr(semantic);
  if (attr2) {
    if (attr2 === "categoryValueRef") {
      return getCategoryValue(semantic);
    }
    return semantic[attr2] || "";
  }
}
function setLabel(element, text) {
  var semantic = element.businessObject, attr2 = getLabelAttr(semantic);
  if (attr2) {
    if (attr2 === "categoryValueRef") {
      semantic["categoryValueRef"].value = text;
    } else {
      semantic[attr2] = text;
    }
  }
  return element;
}
const hexList = [];
for (let i2 = 0; i2 <= 15; i2++) {
  hexList[i2] = i2.toString(16);
}
function buildUUID() {
  let uuid2 = "";
  for (let i2 = 1; i2 <= 36; i2++) {
    if (i2 === 9 || i2 === 14 || i2 === 19 || i2 === 24) {
      uuid2 += "-";
    } else if (i2 === 15) {
      uuid2 += 4;
    } else if (i2 === 20) {
      uuid2 += hexList[Math.random() * 4 | 8];
    } else {
      uuid2 += hexList[Math.random() * 16 | 0];
    }
  }
  return uuid2.replace(/-/g, "");
}
function buildBitUUID(length2 = 6) {
  return buildUUID().substring(0, length2);
}
const reluApproverConfig = {
  name: typeTask,
  shapeType: bpmnTask,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnTask
    }
  },
  palette: {
    name: "create.relu-task",
    group: "model",
    className: "icon-relu-create icon-relu-task",
    title: "创建一个类型为relu-task的任务节点"
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-node-approve",
    iconColor: "#1DACEB",
    titleColor: "linear-gradient(90deg, #C0EDF8 0%, #B4DEF2 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "审批节点",
    bodyDefaultText: "请设置审批人"
  },
  contextPad: {
    default: true
  },
  properties: {}
};
const START = {
  name: "append.relu-start",
  group: "model",
  className: "context-pad-start icon-ym icon-ym-flow-node-start",
  icon: "icon-ym icon-ym-flow-node-start",
  title: "流程发起",
  ymName: "relu-startEvent",
  type: bpmnStart,
  elementName: typeStart,
  wnType: typeStart
};
const APPROVER = {
  name: "append.relu-task",
  group: "model",
  className: "context-pad-approver icon-ym icon-ym-flow-node-approve",
  title: "审批节点",
  type: bpmnTask,
  elementName: typeTask,
  wnType: typeTask
};
const PROCESSING = {
  name: "append.relu-processing",
  group: "model",
  className: "context-pad-processing icon-ym icon-ym-generator-todo",
  title: "办理节点",
  type: bpmnProcessing,
  elementName: typeProcessing,
  wnType: typeProcessing
};
const SUBFLOW = {
  name: "append.relu-subFlow",
  group: "model",
  className: "context-pad-sub-flow icon-ym icon-ym-flow-node-subFlow",
  title: "子流程",
  type: bpmnSubFlow,
  elementName: typeSubFlow,
  wnType: typeSubFlow
};
const TRIGGER = {
  name: "append.relu-trigger",
  group: "model",
  className: "context-pad-trigger icon-ym icon-ym-flow-trigger-event",
  title: "触发节点",
  type: bpmnTask,
  elementName: typeTrigger,
  wnType: typeTrigger
};
const GROUP = {
  name: "append.relu-group",
  group: "model",
  className: "context-pad-sub-flow icon-ym icon-ym-flow-node-subFlow",
  title: "分组",
  type: bpmnGroup,
  elementName: typeGroup,
  wnType: typeGroup
};
const END = {
  name: "append.relu-end",
  group: "model",
  className: "context-pad-end icon-ym icon-ym-flow-node-end",
  title: "结束",
  type: bpmnEnd,
  elementName: typeEnd,
  wnType: typeEnd
};
const CONNECT = {
  name: "append.relu-connect",
  group: "connect",
  className: "context-pad-connect icon-ym icon-ym-flow-line",
  title: "连线",
  type: "connect",
  wnType: typeLabel
};
const DELETE = {
  name: "delete",
  group: "edit",
  className: "context-pad-delete icon-ym icon-ym-app-delete",
  title: "删除",
  ymName: "relu-delete",
  type: "delete"
};
const INCLUSIVE = {
  name: "append.relu-inclusive",
  group: "model",
  className: "context-pad-condition icon-ym icon-ym-flow-node-condition-multiple",
  title: "包容分支 ",
  type: bpmnInclusive,
  elementName: typeInclusion,
  wnType: typeInclusion
};
const PARALLEL = {
  name: "append.relu-parallel",
  group: "model",
  className: "context-pad-interflow icon-ym icon-ym-flow-node-parallel",
  title: "并行分支",
  type: bpmnParallel,
  elementName: typeParallel,
  wnType: typeParallel
};
const EXCLUSIVE = {
  name: "append.relu-exclusive",
  group: "model",
  className: "context-pad-branch icon-ym icon-ym-flow-node-condition-single",
  title: "排它分支",
  type: bpmnExclusive,
  elementName: typeExclusive,
  wnType: typeExclusive
};
const GETDATA = {
  name: "append.relu-getData",
  group: "model",
  className: "context-pad-getData icon-ym icon-ym-header-search",
  title: "获取数据",
  type: bpmnExecute,
  elementName: typeGetData,
  wnType: typeGetData
};
const ADDDATA = {
  name: "append.relu-addData",
  group: "model",
  className: "context-pad-addData icon-ym icon-ym-btn-add",
  title: "新增数据",
  type: bpmnExecute,
  elementName: typeAddData,
  wnType: typeAddData
};
const UPDATEDATA = {
  name: "append.relu-updateData",
  group: "model",
  className: "context-pad-updateData icon-ym icon-ym-generator-annular",
  title: "更新数据",
  type: bpmnExecute,
  elementName: typeUpdateData,
  wnType: typeUpdateData
};
const DELDATA = {
  name: "append.relu-delData",
  group: "model",
  className: "context-pad-delData icon-ym icon-ym-btn-clearn",
  title: "删除数据",
  type: bpmnExecute,
  elementName: typeDelData,
  wnType: typeDelData
};
const INTERFACE = {
  name: "append.relu-interface",
  group: "model",
  className: "context-pad-interface icon-ym icon-ym-options",
  title: "数据接口",
  type: bpmnExecute,
  elementName: typeInterface,
  wnType: typeInterface
};
const LAUNCH = {
  name: "append.relu-launch",
  group: "model",
  className: "context-pad-launch icon-ym icon-ym-flow-node-branch",
  title: "发起审批",
  type: bpmnExecute,
  elementName: typeLaunchFlow,
  wnType: typeLaunchFlow
};
const MESSAGE = {
  name: "append.relu-message",
  group: "model",
  className: "context-pad-message icon-ym icon-ym-header-message",
  title: "消息通知",
  type: bpmnExecute,
  elementName: typeMessage,
  wnType: typeMessage
};
const SCHEDULE = {
  name: "append.relu-schedule",
  group: "model",
  className: "context-pad-schedule icon-ym icon-ym-xingcheng",
  title: "创建日程",
  type: bpmnExecute,
  elementName: typeSchedule,
  wnType: typeSchedule
};
const EVENTTRIGGER = {
  name: "append.relu-event-trigger",
  group: "model",
  className: "context-pad-event-trigger icon-ym icon-ym-flow-trigger-event",
  title: "事件触发",
  type: bpmnEvent,
  elementName: typeEventTrigger,
  wnType: typeEventTrigger
};
const TIMETRIGGER = {
  name: "append.relu-timeout-trigger",
  group: "model",
  className: "context-pad-timeout-trigger icon-ym icon-ym-flow-trigger-timer",
  title: "定时触发",
  type: bpmnTime,
  elementName: typeTimeTrigger,
  wnType: typeTimeTrigger
};
const NOTICETRIGGER = {
  name: "append.relu-notice-trigger",
  group: "model",
  className: "context-pad-notice-trigger icon-ym icon-ym-flow-trigger-notice",
  title: "通知触发",
  type: bpmnNotice,
  elementName: typeNoticeTrigger,
  wnType: typeNoticeTrigger
};
const WEBHOOKTRIGGER = {
  name: "append.relu-webhook-trigger",
  group: "model",
  className: "context-pad-webhook-trigger icon-ym icon-ym-flow-trigger-webhook",
  title: "webhook",
  type: bpmnWebhook,
  elementName: typeWebhookTrigger,
  wnType: typeWebhookTrigger
};
const COPY = {
  name: "append.relu-copy",
  group: "model",
  className: "context-pad-copy ym-custom ym-custom-content-copy",
  title: "复制",
  type: bpmnCopy,
  elementName: null,
  wnType: typeCopy
};
const PASTE = {
  name: "append.relu-paste",
  group: "model",
  className: "context-pad-paste ym-custom ym-custom-content-paste",
  title: "粘贴",
  type: bpmnPaste,
  elementName: null,
  wnType: typePaste
};
const CHOOSE = {
  name: "append.relu-choose",
  group: "model",
  className: "context-pad-condition icon-ym icon-ym-flow-node-branch",
  title: "选择分支",
  type: bpmnChoose,
  elementName: typeChoose,
  wnType: typeChoose
};
const reluConfigBpmnContextPad = {
  start: START,
  approver: APPROVER,
  subFlow: SUBFLOW,
  end: END,
  connect: CONNECT,
  del: DELETE,
  inclusive: INCLUSIVE,
  parallel: PARALLEL,
  exclusive: EXCLUSIVE,
  group: GROUP,
  trigger: TRIGGER,
  getData: GETDATA,
  addData: ADDDATA,
  updateData: UPDATEDATA,
  delData: DELDATA,
  interfaceData: INTERFACE,
  launch: LAUNCH,
  message: MESSAGE,
  schedule: SCHEDULE,
  event: EVENTTRIGGER,
  timeout: TIMETRIGGER,
  notice: NOTICETRIGGER,
  webhook: WEBHOOKTRIGGER,
  copy: COPY,
  paste: PASTE,
  processing: PROCESSING,
  choose: CHOOSE
};
const { approver: approver$6, processing: processing$1, subFlow: subFlow$2, connect: connect$d, event: event$1, timeout, notice: notice$2, webhook } = reluConfigBpmnContextPad;
const reluStartConfig = {
  name: typeStart,
  shapeType: bpmnStart,
  palette: {
    name: "create.relu-task",
    group: "model",
    className: "icon-relu-create icon-relu-task",
    title: "创建一个类型为relu-task的任务节点"
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-node-start",
    iconColor: "#4cd823",
    titleColor: "#f0f5ff",
    background: "#ffffff",
    attr: { x: 0, y: 0, width: 90, rx: 16, height: 32 },
    rendererName: "流程发起",
    bodyDefaultText: "暂未选择表单"
  },
  contextPad: {
    default: false,
    customization: { approver: approver$6, processing: processing$1, subFlow: subFlow$2, connect: connect$d },
    taskCustomization: { event: event$1, timeout, notice: notice$2, webhook }
  },
  properties: {}
};
const { del: del$e } = reluConfigBpmnContextPad;
const reluEndConfig = {
  name: typeEnd,
  shapeType: bpmnEnd,
  palette: {
    name: "create.relu-task",
    group: "model",
    className: "icon-relu-create icon-relu-task",
    title: "创建一个类型为relu-task的任务节点"
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-node-end",
    iconColor: "#8B8BA0",
    titleColor: "#EDF3F8",
    attr: { x: 0, y: 0, width: 90, rx: 16, height: 32 },
    rendererName: "流程结束"
  },
  contextPad: {
    default: false,
    customization: { del: del$e }
  },
  properties: {}
};
const reluSubFlowConfig = {
  name: typeSubFlow,
  shapeType: bpmnSubFlow,
  element: {
    label: "subProcess",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnSubFlow
    }
  },
  palette: {
    name: "create.relu-task",
    group: "model",
    className: "icon-relu-create icon-relu-task",
    title: "创建一个类型为relu-task的任务节点"
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-node-subFlow",
    iconColor: "#F0962D",
    titleColor: "linear-gradient(90deg, #FFDFC1 0%, #FDDAA7 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, width: 200, height: 88, background: "#e6f4ff" },
    rendererName: "子流程",
    bodyDefaultText: "请设置发起人"
  },
  contextPad: {
    default: false
  },
  properties: {}
};
const { approver: approver$5, subFlow: subFlow$1, inclusive: inclusive$1, parallel: parallel$1, exclusive: exclusive$1, trigger, getData: getData$d, addData: addData$d, updateData: updateData$d, delData: delData$d, interfaceData: interfaceData$d, message: message$d, launch: launch$d, schedule: schedule$d, choose, processing } = reluConfigBpmnContextPad;
const reluLabelConfig = {
  name: bpmnLabel,
  shapeType: bpmnLabel,
  element: {
    label: "Timer",
    actionName: "replace-with-timer",
    className: "bpmn-icon-timer",
    target: {
      type: bpmnLabel
    }
  },
  palette: {
    name: "create.yinmai-timer",
    group: "model",
    className: "icon-yinmai-create icon-yinmai-timer",
    title: "修改为渲染按钮"
  },
  renderer: {
    background: "#ffffff",
    attr: { x: 0, y: 0, width: 28, height: 28 },
    rendererName: "label按钮",
    fillColor: "rgb(255,255,255)"
  },
  contextPad: {
    default: false,
    customization: { approver: approver$5, subFlow: subFlow$1, processing, exclusive: exclusive$1, inclusive: inclusive$1, parallel: parallel$1, choose, trigger },
    groupCustomization: { getData: getData$d, addData: addData$d, updateData: updateData$d, delData: delData$d, interfaceData: interfaceData$d, message: message$d, launch: launch$d, schedule: schedule$d }
  },
  properties: {}
};
const { approver: approver$4 } = reluConfigBpmnContextPad;
const reluExclusiveConfig = {
  name: bpmnExclusive,
  shapeType: bpmnExclusive,
  element: {
    label: "Timer",
    actionName: "replace-with-timer",
    className: "bpmn-icon-timer",
    target: {
      type: bpmnExclusive
    }
  },
  palette: {
    name: "create.yinmai-timer",
    group: "model",
    className: "icon-yinmai-create icon-yinmai-timer"
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-node-approve",
    iconColor: "#1DACEB",
    titleColor: "#C0EDF8",
    background: "#ffffff",
    attr: { x: 0, y: 0, width: 90, rx: 16, height: 32 },
    rendererName: "条件分支",
    bodyDefaultText: "请设置审批人"
  },
  contextPad: {
    default: false,
    customization: { approver: approver$4 }
  },
  properties: {}
};
const { approver: approver$3 } = reluConfigBpmnContextPad;
const reluInclusiveConfig = {
  name: typeInclusion,
  shapeType: bpmnInclusive,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnInclusive
    }
  },
  palette: {
    name: "create.relu-task",
    group: "model",
    className: "icon-relu-create icon-relu-task",
    title: "创建一个类型为relu-task的任务节点"
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-node-approve",
    iconColor: "#1DACEB",
    titleColor: "#C0EDF8",
    background: "#ffffff",
    attr: { x: 0, y: 0, width: 90, rx: 16, height: 32 },
    rendererName: "条件分支",
    bodyDefaultText: "请设置审批人"
  },
  contextPad: {
    default: false,
    customization: { approver: approver$3 }
  },
  properties: {}
};
const { approver: approver$2 } = reluConfigBpmnContextPad;
const reluParallelConfig = {
  name: typeParallel,
  shapeType: bpmnParallel,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: typeParallel
    }
  },
  palette: {
    name: "create.relu-task",
    group: "model",
    className: "icon-relu-create icon-relu-task",
    title: "创建一个类型为relu-task的任务节点"
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-node-approve",
    iconColor: "#1DACEB",
    titleColor: "#C0EDF8",
    background: "#ffffff",
    attr: { x: 0, y: 0, width: 90, rx: 16, height: 32 },
    rendererName: "并行分支",
    bodyDefaultText: "请设置审批人"
  },
  contextPad: {
    default: false,
    customization: { approver: approver$2 }
  },
  properties: {}
};
const { del: del$d } = reluConfigBpmnContextPad;
const reluSequenceFlow = {
  name: bpmnSequenceFlow,
  shapeType: bpmnSequenceFlow,
  contextPad: {
    default: false,
    customization: { del: del$d }
  },
  properties: {}
};
const { approver: approver$1, subFlow, inclusive, parallel, exclusive } = reluConfigBpmnContextPad;
const reluGroupConfig = {
  name: bpmnGroup,
  shapeType: bpmnGroup,
  element: {
    label: "Group",
    actionName: "replace-with-group",
    className: "bpmn-icon-group",
    target: {
      type: bpmnGroup
    }
  },
  palette: {
    name: "create.yinmai-group",
    group: "model",
    className: "icon-yinmai-create icon-yinmai-group",
    title: "修改为渲染按钮"
  },
  renderer: {
    background: "#ffffff",
    attr: { x: 0, y: 0, width: 28, height: 28 },
    rendererName: "分组123",
    fillColor: "rgb(255,255,255)"
  },
  contextPad: {
    default: false,
    customization: { approver: approver$1, subFlow, inclusive, parallel, exclusive }
  },
  properties: {}
};
const { getData: getData$c, addData: addData$c, updateData: updateData$c, delData: delData$c, interfaceData: interfaceData$c, message: message$c, launch: launch$c, schedule: schedule$c, connect: connect$c, copy: copy$9, paste: paste$8, del: del$c } = reluConfigBpmnContextPad;
const reluTriggerConfig = {
  name: typeTrigger,
  shapeType: bpmnTrigger,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnTask
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-trigger-event",
    iconColor: "#4DCE62",
    titleColor: "linear-gradient(90deg, #BFEBC6 0%, #A4EBAF 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "触发节点",
    bodyDefaultText: "请设置触发事件"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$c, addData: addData$c, updateData: updateData$c, delData: delData$c, interfaceData: interfaceData$c, message: message$c, launch: launch$c, schedule: schedule$c, connect: connect$c, copy: copy$9, del: del$c },
    otherCustomization: { getData: getData$c, addData: addData$c, updateData: updateData$c, delData: delData$c, interfaceData: interfaceData$c, message: message$c, launch: launch$c, schedule: schedule$c, connect: connect$c, copy: copy$9, paste: paste$8, del: del$c }
  },
  properties: {}
};
const { getData: getData$b, addData: addData$b, updateData: updateData$b, delData: delData$b, interfaceData: interfaceData$b, message: message$b, launch: launch$b, schedule: schedule$b, connect: connect$b, del: del$b, paste: paste$7, copy: copy$8 } = reluConfigBpmnContextPad;
const reluAddDataConfig = {
  name: typeAddData,
  shapeType: bpmnAddData,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnAddData
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-btn-add",
    iconColor: "#439815",
    titleColor: "linear-gradient(90deg, #D6FABF 0%, #68C62C 100%",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "新增数据",
    bodyDefaultText: "请设置新增数据"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$b, addData: addData$b, updateData: updateData$b, delData: delData$b, interfaceData: interfaceData$b, message: message$b, launch: launch$b, schedule: schedule$b, connect: connect$b, copy: copy$8, del: del$b },
    otherCustomization: { getData: getData$b, addData: addData$b, updateData: updateData$b, delData: delData$b, interfaceData: interfaceData$b, message: message$b, launch: launch$b, schedule: schedule$b, connect: connect$b, copy: copy$8, paste: paste$7, del: del$b }
  },
  properties: {}
};
const { getData: getData$a, addData: addData$a, updateData: updateData$a, delData: delData$a, interfaceData: interfaceData$a, message: message$a, launch: launch$a, schedule: schedule$a, connect: connect$a, del: del$a, paste: paste$6, copy: copy$7 } = reluConfigBpmnContextPad;
const reluGetDataConfig = {
  name: typeGetData,
  shapeType: bpmnGetData,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnGetData
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-header-search",
    iconColor: "#4936DD",
    titleColor: "linear-gradient(90deg, #C1C8FF 0%, #A481F2 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "获取数据",
    bodyDefaultText: "请设置获取数据"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$a, addData: addData$a, updateData: updateData$a, delData: delData$a, interfaceData: interfaceData$a, message: message$a, launch: launch$a, schedule: schedule$a, connect: connect$a, copy: copy$7, del: del$a },
    otherCustomization: { getData: getData$a, addData: addData$a, updateData: updateData$a, delData: delData$a, interfaceData: interfaceData$a, message: message$a, launch: launch$a, schedule: schedule$a, connect: connect$a, copy: copy$7, paste: paste$6, del: del$a }
  },
  properties: {}
};
const { getData: getData$9, addData: addData$9, updateData: updateData$9, delData: delData$9, interfaceData: interfaceData$9, message: message$9, launch: launch$9, schedule: schedule$9, connect: connect$9, copy: copy$6, paste: paste$5, del: del$9 } = reluConfigBpmnContextPad;
const reluUpdateDataConfig = {
  name: typeUpdateData,
  shapeType: bpmnUpdateData,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnUpdateData
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-generator-annular",
    iconColor: "#24BEC4",
    titleColor: "linear-gradient(90deg, #CDFAF3 0%, #55E2CC 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "更新数据",
    bodyDefaultText: "请设置更新数据"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$9, addData: addData$9, updateData: updateData$9, delData: delData$9, interfaceData: interfaceData$9, message: message$9, launch: launch$9, schedule: schedule$9, connect: connect$9, copy: copy$6, del: del$9 },
    otherCustomization: { getData: getData$9, addData: addData$9, updateData: updateData$9, delData: delData$9, interfaceData: interfaceData$9, message: message$9, launch: launch$9, schedule: schedule$9, connect: connect$9, copy: copy$6, paste: paste$5, del: del$9 }
  },
  properties: {}
};
const { getData: getData$8, addData: addData$8, updateData: updateData$8, delData: delData$8, interfaceData: interfaceData$8, message: message$8, launch: launch$8, schedule: schedule$8, connect: connect$8, del: del$8, paste: paste$4, copy: copy$5 } = reluConfigBpmnContextPad;
const reluDelDataConfig = {
  name: typeDelData,
  shapeType: bpmnDelData,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnDelData
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-btn-clearn",
    iconColor: "#DD363C",
    titleColor: "linear-gradient(90deg, #FFCDC1 0%, #FF8E92 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "删除数据",
    bodyDefaultText: "请设置删除节点"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$8, addData: addData$8, updateData: updateData$8, delData: delData$8, interfaceData: interfaceData$8, message: message$8, launch: launch$8, schedule: schedule$8, connect: connect$8, copy: copy$5, del: del$8 },
    otherCustomization: { getData: getData$8, addData: addData$8, updateData: updateData$8, delData: delData$8, interfaceData: interfaceData$8, message: message$8, launch: launch$8, schedule: schedule$8, connect: connect$8, copy: copy$5, paste: paste$4, del: del$8 }
  },
  properties: {}
};
const { getData: getData$7, addData: addData$7, updateData: updateData$7, delData: delData$7, interfaceData: interfaceData$7, message: message$7, launch: launch$7, schedule: schedule$7, connect: connect$7, del: del$7, paste: paste$3, copy: copy$4 } = reluConfigBpmnContextPad;
const reluInterfaceConfig = {
  name: typeInterface,
  shapeType: bpmnInterface,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnInterface
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-options",
    iconColor: "#3C5EEF",
    titleColor: "linear-gradient(90deg, #D0DCFF 0%, #90A5FF 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "数据接口",
    bodyDefaultText: "请设置数据接口"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$7, addData: addData$7, updateData: updateData$7, delData: delData$7, interfaceData: interfaceData$7, message: message$7, launch: launch$7, schedule: schedule$7, connect: connect$7, copy: copy$4, del: del$7 },
    otherCustomization: { getData: getData$7, addData: addData$7, updateData: updateData$7, delData: delData$7, interfaceData: interfaceData$7, message: message$7, launch: launch$7, schedule: schedule$7, connect: connect$7, copy: copy$4, paste: paste$3, del: del$7 }
  },
  properties: {}
};
const { getData: getData$6, addData: addData$6, updateData: updateData$6, delData: delData$6, interfaceData: interfaceData$6, message: message$6, launch: launch$6, schedule: schedule$6, connect: connect$6, copy: copy$3, paste: paste$2, del: del$6 } = reluConfigBpmnContextPad;
const reluLaunchConfig = {
  name: typeLaunchFlow,
  shapeType: bpmnLaunchFlow,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnLaunchFlow
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-node-branch",
    iconColor: "#5ED87F",
    titleColor: "linear-gradient(90deg, #B6F7BB 0%, #5ED87F 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "发起审批",
    bodyDefaultText: "请设置发起审批"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$6, addData: addData$6, updateData: updateData$6, delData: delData$6, interfaceData: interfaceData$6, message: message$6, launch: launch$6, schedule: schedule$6, connect: connect$6, copy: copy$3, del: del$6 },
    otherCustomization: { getData: getData$6, addData: addData$6, updateData: updateData$6, delData: delData$6, interfaceData: interfaceData$6, message: message$6, launch: launch$6, schedule: schedule$6, connect: connect$6, copy: copy$3, paste: paste$2, del: del$6 }
  },
  properties: {}
};
const { getData: getData$5, addData: addData$5, updateData: updateData$5, delData: delData$5, interfaceData: interfaceData$5, message: message$5, launch: launch$5, schedule: schedule$5, connect: connect$5, copy: copy$2, paste: paste$1, del: del$5 } = reluConfigBpmnContextPad;
const reluMessageConfig = {
  name: typeMessage,
  shapeType: bpmnMessage,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnMessage
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-header-message",
    iconColor: "#F5CD61",
    titleColor: "linear-gradient(90deg, #FCE6AB 0%, #F5CD61 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "消息通知",
    bodyDefaultText: "请设置消息通知"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$5, addData: addData$5, updateData: updateData$5, delData: delData$5, interfaceData: interfaceData$5, message: message$5, launch: launch$5, schedule: schedule$5, connect: connect$5, copy: copy$2, del: del$5 },
    otherCustomization: { getData: getData$5, addData: addData$5, updateData: updateData$5, delData: delData$5, interfaceData: interfaceData$5, message: message$5, launch: launch$5, schedule: schedule$5, connect: connect$5, copy: copy$2, paste: paste$1, del: del$5 }
  },
  properties: {}
};
const { getData: getData$4, addData: addData$4, updateData: updateData$4, delData: delData$4, interfaceData: interfaceData$4, message: message$4, launch: launch$4, schedule: schedule$4, connect: connect$4, copy: copy$1, paste, del: del$4 } = reluConfigBpmnContextPad;
const reluScheduleConfig = {
  name: typeSchedule,
  shapeType: bpmnSchedule,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnSchedule
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-xingcheng",
    iconColor: "#7DB2F0",
    titleColor: "linear-gradient(90deg, #ABE6FC 0%, #7DB2F0 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "创建日程",
    bodyDefaultText: "请设置创建日程信息"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$4, addData: addData$4, updateData: updateData$4, delData: delData$4, interfaceData: interfaceData$4, message: message$4, launch: launch$4, schedule: schedule$4, connect: connect$4, copy: copy$1, del: del$4 },
    otherCustomization: { getData: getData$4, addData: addData$4, updateData: updateData$4, delData: delData$4, interfaceData: interfaceData$4, message: message$4, launch: launch$4, schedule: schedule$4, connect: connect$4, copy: copy$1, paste, del: del$4 }
  },
  properties: {}
};
const { getData: getData$3, addData: addData$3, updateData: updateData$3, delData: delData$3, interfaceData: interfaceData$3, message: message$3, launch: launch$3, schedule: schedule$3, connect: connect$3, del: del$3 } = reluConfigBpmnContextPad;
const reluWebhookConfig = {
  name: typeWebhookTrigger,
  shapeType: bpmnWebhook,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnTask
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-trigger-webhook",
    iconColor: "#4DCE62",
    titleColor: "linear-gradient(90deg, #BFEBC6 0%, #A4EBAF 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "webhook触发",
    bodyDefaultText: "请设置触发事件"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$3, addData: addData$3, updateData: updateData$3, delData: delData$3, interfaceData: interfaceData$3, message: message$3, launch: launch$3, schedule: schedule$3, connect: connect$3, del: del$3 }
  },
  properties: {}
};
const { getData: getData$2, addData: addData$2, updateData: updateData$2, delData: delData$2, interfaceData: interfaceData$2, message: message$2, launch: launch$2, schedule: schedule$2, connect: connect$2, del: del$2 } = reluConfigBpmnContextPad;
const reluEventConfig = {
  name: typeEventTrigger,
  shapeType: bpmnEvent,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnTask
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-trigger-event",
    iconColor: "#4DCE62",
    titleColor: "linear-gradient(90deg, #BFEBC6 0%, #A4EBAF 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "事件触发",
    bodyDefaultText: "请设置触发事件"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$2, addData: addData$2, updateData: updateData$2, delData: delData$2, interfaceData: interfaceData$2, message: message$2, launch: launch$2, schedule: schedule$2, connect: connect$2, del: del$2 }
  },
  properties: {}
};
const { getData: getData$1, addData: addData$1, updateData: updateData$1, delData: delData$1, interfaceData: interfaceData$1, message: message$1, launch: launch$1, schedule: schedule$1, connect: connect$1, del: del$1 } = reluConfigBpmnContextPad;
const reluTimeConfig = {
  name: typeTimeTrigger,
  shapeType: bpmnTime,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnTask
    }
  },
  renderer: {
    icon: "icon-ym icon-ym icon-ym icon-ym-flow-trigger-timer",
    iconColor: "#4DCE62",
    titleColor: "linear-gradient(90deg, #BFEBC6 0%, #A4EBAF 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "定时触发",
    bodyDefaultText: "请设置触发事件"
  },
  contextPad: {
    default: false,
    customization: { getData: getData$1, addData: addData$1, updateData: updateData$1, delData: delData$1, interfaceData: interfaceData$1, message: message$1, launch: launch$1, schedule: schedule$1, connect: connect$1, del: del$1 }
  },
  properties: {}
};
const { getData, addData, updateData, delData, interfaceData, message, launch, schedule, connect, del } = reluConfigBpmnContextPad;
const reluNoticeConfig = {
  name: typeNoticeTrigger,
  shapeType: bpmnNotice,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",
    target: {
      type: bpmnTask
    }
  },
  renderer: {
    icon: "icon-ym icon-ym-flow-trigger-notice",
    iconColor: "#4DCE62",
    titleColor: "linear-gradient(90deg, #BFEBC6 0%, #A4EBAF 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "通知触发",
    bodyDefaultText: "请设置触发事件"
  },
  contextPad: {
    default: false,
    customization: { getData, addData, updateData, delData, interfaceData, message, launch, schedule, connect, del }
  },
  properties: {}
};
const reluProcessingConfig = {
  name: typeProcessing,
  shapeType: bpmnProcessing,
  element: {
    label: "Processing",
    actionName: "replace-with-processing",
    className: "bpmn-icon-processing",
    target: {
      type: bpmnProcessing
    }
  },
  palette: {
    name: "create.relu-processing",
    group: "model",
    className: "icon-relu-create icon-relu-processing",
    title: "创建一个类型为relu-processing的任务节点"
  },
  renderer: {
    icon: "icon-ym icon-ym-generator-todo",
    iconColor: "#C33B5F",
    titleColor: "linear-gradient(90deg, #FFC1DB 0%, #F2819F 100%)",
    background: "#ffffff",
    attr: { x: 0, y: 0, rx: 8, width: 200, height: 88 },
    rendererName: "办理节点",
    bodyDefaultText: "请设置办理人"
  },
  contextPad: {
    default: true
  },
  properties: {}
};
const { approver } = reluConfigBpmnContextPad;
const reluChooseConfig = {
  name: typeChoose,
  shapeType: bpmnChoose,
  element: {
    label: "Task",
    actionName: "replace-with-task",
    className: "bpmn-icon-task",