@wimi/gantt 0.1.0

package/dist/VanillaGantt.common.js

@@ -0,0 +1,4751 @@
+/******/ (function() { // webpackBootstrap
+/******/ 	"use strict";
+/******/ 	var __webpack_modules__ = ({
+
+/***/ 2481:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isCallable = __webpack_require__(8252);
+var tryToString = __webpack_require__(1958);
+
+var $TypeError = TypeError;
+
+// `Assert: IsCallable(argument) is true`
+module.exports = function (argument) {
+  if (isCallable(argument)) return argument;
+  throw new $TypeError(tryToString(argument) + ' is not a function');
+};
+
+
+/***/ }),
+
+/***/ 7938:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var wellKnownSymbol = __webpack_require__(2666);
+var create = __webpack_require__(3369);
+var defineProperty = (__webpack_require__(1250).f);
+
+var UNSCOPABLES = wellKnownSymbol('unscopables');
+var ArrayPrototype = Array.prototype;
+
+// Array.prototype[@@unscopables]
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+if (ArrayPrototype[UNSCOPABLES] === undefined) {
+  defineProperty(ArrayPrototype, UNSCOPABLES, {
+    configurable: true,
+    value: create(null)
+  });
+}
+
+// add a key to Array.prototype[@@unscopables]
+module.exports = function (key) {
+  ArrayPrototype[UNSCOPABLES][key] = true;
+};
+
+
+/***/ }),
+
+/***/ 462:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isPrototypeOf = __webpack_require__(8130);
+
+var $TypeError = TypeError;
+
+module.exports = function (it, Prototype) {
+  if (isPrototypeOf(Prototype, it)) return it;
+  throw new $TypeError('Incorrect invocation');
+};
+
+
+/***/ }),
+
+/***/ 3162:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isObject = __webpack_require__(8271);
+
+var $String = String;
+var $TypeError = TypeError;
+
+// `Assert: Type(argument) is Object`
+module.exports = function (argument) {
+  if (isObject(argument)) return argument;
+  throw new $TypeError($String(argument) + ' is not an object');
+};
+
+
+/***/ }),
+
+/***/ 8658:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var toIndexedObject = __webpack_require__(2364);
+var toAbsoluteIndex = __webpack_require__(9283);
+var lengthOfArrayLike = __webpack_require__(6013);
+
+// `Array.prototype.{ indexOf, includes }` methods implementation
+var createMethod = function (IS_INCLUDES) {
+  return function ($this, el, fromIndex) {
+    var O = toIndexedObject($this);
+    var length = lengthOfArrayLike(O);
+    if (length === 0) return !IS_INCLUDES && -1;
+    var index = toAbsoluteIndex(fromIndex, length);
+    var value;
+    // Array#includes uses SameValueZero equality algorithm
+    // eslint-disable-next-line no-self-compare -- NaN check
+    if (IS_INCLUDES && el !== el) while (length > index) {
+      value = O[index++];
+      // eslint-disable-next-line no-self-compare -- NaN check
+      if (value !== value) return true;
+    // Array#indexOf ignores holes, Array#includes - not
+    } else for (;length > index; index++) {
+      if ((IS_INCLUDES || index in O) && O[index] === el) return IS_INCLUDES || index || 0;
+    } return !IS_INCLUDES && -1;
+  };
+};
+
+module.exports = {
+  // `Array.prototype.includes` method
+  // https://tc39.es/ecma262/#sec-array.prototype.includes
+  includes: createMethod(true),
+  // `Array.prototype.indexOf` method
+  // https://tc39.es/ecma262/#sec-array.prototype.indexof
+  indexOf: createMethod(false)
+};
+
+
+/***/ }),
+
+/***/ 592:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(7101);
+var isArray = __webpack_require__(8431);
+
+var $TypeError = TypeError;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+// Safari < 13 does not throw an error in this case
+var SILENT_ON_NON_WRITABLE_LENGTH_SET = DESCRIPTORS && !function () {
+  // makes no sense without proper strict mode support
+  if (this !== undefined) return true;
+  try {
+    // eslint-disable-next-line es/no-object-defineproperty -- safe
+    Object.defineProperty([], 'length', { writable: false }).length = 1;
+  } catch (error) {
+    return error instanceof TypeError;
+  }
+}();
+
+module.exports = SILENT_ON_NON_WRITABLE_LENGTH_SET ? function (O, length) {
+  if (isArray(O) && !getOwnPropertyDescriptor(O, 'length').writable) {
+    throw new $TypeError('Cannot set read only .length');
+  } return O.length = length;
+} : function (O, length) {
+  return O.length = length;
+};
+
+
+/***/ }),
+
+/***/ 9836:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var anObject = __webpack_require__(3162);
+var iteratorClose = __webpack_require__(1380);
+
+// call something on iterator step with safe closing on error
+module.exports = function (iterator, fn, value, ENTRIES) {
+  try {
+    return ENTRIES ? fn(anObject(value)[0], value[1]) : fn(value);
+  } catch (error) {
+    iteratorClose(iterator, 'throw', error);
+  }
+};
+
+
+/***/ }),
+
+/***/ 7409:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(2289);
+
+var toString = uncurryThis({}.toString);
+var stringSlice = uncurryThis(''.slice);
+
+module.exports = function (it) {
+  return stringSlice(toString(it), 8, -1);
+};
+
+
+/***/ }),
+
+/***/ 110:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var TO_STRING_TAG_SUPPORT = __webpack_require__(1153);
+var isCallable = __webpack_require__(8252);
+var classofRaw = __webpack_require__(7409);
+var wellKnownSymbol = __webpack_require__(2666);
+
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var $Object = Object;
+
+// ES3 wrong here
+var CORRECT_ARGUMENTS = classofRaw(function () { return arguments; }()) === 'Arguments';
+
+// fallback for IE11 Script Access Denied error
+var tryGet = function (it, key) {
+  try {
+    return it[key];
+  } catch (error) { /* empty */ }
+};
+
+// getting tag from ES6+ `Object.prototype.toString`
+module.exports = TO_STRING_TAG_SUPPORT ? classofRaw : function (it) {
+  var O, tag, result;
+  return it === undefined ? 'Undefined' : it === null ? 'Null'
+    // @@toStringTag case
+    : typeof (tag = tryGet(O = $Object(it), TO_STRING_TAG)) == 'string' ? tag
+    // builtinTag case
+    : CORRECT_ARGUMENTS ? classofRaw(O)
+    // ES3 arguments fallback
+    : (result = classofRaw(O)) === 'Object' && isCallable(O.callee) ? 'Arguments' : result;
+};
+
+
+/***/ }),
+
+/***/ 4993:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var hasOwn = __webpack_require__(9522);
+var ownKeys = __webpack_require__(5456);
+var getOwnPropertyDescriptorModule = __webpack_require__(6056);
+var definePropertyModule = __webpack_require__(1250);
+
+module.exports = function (target, source, exceptions) {
+  var keys = ownKeys(source);
+  var defineProperty = definePropertyModule.f;
+  var getOwnPropertyDescriptor = getOwnPropertyDescriptorModule.f;
+  for (var i = 0; i < keys.length; i++) {
+    var key = keys[i];
+    if (!hasOwn(target, key) && !(exceptions && hasOwn(exceptions, key))) {
+      defineProperty(target, key, getOwnPropertyDescriptor(source, key));
+    }
+  }
+};
+
+
+/***/ }),
+
+/***/ 6280:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var fails = __webpack_require__(8930);
+
+module.exports = !fails(function () {
+  function F() { /* empty */ }
+  F.prototype.constructor = null;
+  // eslint-disable-next-line es/no-object-getprototypeof -- required for testing
+  return Object.getPrototypeOf(new F()) !== F.prototype;
+});
+
+
+/***/ }),
+
+/***/ 4992:
+/***/ (function(module) {
+
+
+// `CreateIterResultObject` abstract operation
+// https://tc39.es/ecma262/#sec-createiterresultobject
+module.exports = function (value, done) {
+  return { value: value, done: done };
+};
+
+
+/***/ }),
+
+/***/ 232:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(7101);
+var definePropertyModule = __webpack_require__(1250);
+var createPropertyDescriptor = __webpack_require__(9299);
+
+module.exports = DESCRIPTORS ? function (object, key, value) {
+  return definePropertyModule.f(object, key, createPropertyDescriptor(1, value));
+} : function (object, key, value) {
+  object[key] = value;
+  return object;
+};
+
+
+/***/ }),
+
+/***/ 9299:
+/***/ (function(module) {
+
+
+module.exports = function (bitmap, value) {
+  return {
+    enumerable: !(bitmap & 1),
+    configurable: !(bitmap & 2),
+    writable: !(bitmap & 4),
+    value: value
+  };
+};
+
+
+/***/ }),
+
+/***/ 721:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(7101);
+var definePropertyModule = __webpack_require__(1250);
+var createPropertyDescriptor = __webpack_require__(9299);
+
+module.exports = function (object, key, value) {
+  if (DESCRIPTORS) definePropertyModule.f(object, key, createPropertyDescriptor(0, value));
+  else object[key] = value;
+};
+
+
+/***/ }),
+
+/***/ 7893:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var makeBuiltIn = __webpack_require__(4034);
+var defineProperty = __webpack_require__(1250);
+
+module.exports = function (target, name, descriptor) {
+  if (descriptor.get) makeBuiltIn(descriptor.get, name, { getter: true });
+  if (descriptor.set) makeBuiltIn(descriptor.set, name, { setter: true });
+  return defineProperty.f(target, name, descriptor);
+};
+
+
+/***/ }),
+
+/***/ 3589:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isCallable = __webpack_require__(8252);
+var definePropertyModule = __webpack_require__(1250);
+var makeBuiltIn = __webpack_require__(4034);
+var defineGlobalProperty = __webpack_require__(7214);
+
+module.exports = function (O, key, value, options) {
+  if (!options) options = {};
+  var simple = options.enumerable;
+  var name = options.name !== undefined ? options.name : key;
+  if (isCallable(value)) makeBuiltIn(value, name, options);
+  if (options.global) {
+    if (simple) O[key] = value;
+    else defineGlobalProperty(key, value);
+  } else {
+    try {
+      if (!options.unsafe) delete O[key];
+      else if (O[key]) simple = true;
+    } catch (error) { /* empty */ }
+    if (simple) O[key] = value;
+    else definePropertyModule.f(O, key, {
+      value: value,
+      enumerable: false,
+      configurable: !options.nonConfigurable,
+      writable: !options.nonWritable
+    });
+  } return O;
+};
+
+
+/***/ }),
+
+/***/ 2976:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var defineBuiltIn = __webpack_require__(3589);
+
+module.exports = function (target, src, options) {
+  for (var key in src) defineBuiltIn(target, key, src[key], options);
+  return target;
+};
+
+
+/***/ }),
+
+/***/ 7214:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(3405);
+
+// eslint-disable-next-line es/no-object-defineproperty -- safe
+var defineProperty = Object.defineProperty;
+
+module.exports = function (key, value) {
+  try {
+    defineProperty(globalThis, key, { value: value, configurable: true, writable: true });
+  } catch (error) {
+    globalThis[key] = value;
+  } return value;
+};
+
+
+/***/ }),
+
+/***/ 7101:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var fails = __webpack_require__(8930);
+
+// Detect IE8's incomplete defineProperty implementation
+module.exports = !fails(function () {
+  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+  return Object.defineProperty({}, 1, { get: function () { return 7; } })[1] !== 7;
+});
+
+
+/***/ }),
+
+/***/ 2998:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(3405);
+var isObject = __webpack_require__(8271);
+
+var document = globalThis.document;
+// typeof document.createElement is 'object' in old IE
+var EXISTS = isObject(document) && isObject(document.createElement);
+
+module.exports = function (it) {
+  return EXISTS ? document.createElement(it) : {};
+};
+
+
+/***/ }),
+
+/***/ 6994:
+/***/ (function(module) {
+
+
+var $TypeError = TypeError;
+var MAX_SAFE_INTEGER = 0x1FFFFFFFFFFFFF; // 2 ** 53 - 1 == 9007199254740991
+
+module.exports = function (it) {
+  if (it > MAX_SAFE_INTEGER) throw new $TypeError('Maximum allowed index exceeded');
+  return it;
+};
+
+
+/***/ }),
+
+/***/ 7658:
+/***/ (function(module) {
+
+
+// IE8- don't enum bug keys
+module.exports = [
+  'constructor',
+  'hasOwnProperty',
+  'isPrototypeOf',
+  'propertyIsEnumerable',
+  'toLocaleString',
+  'toString',
+  'valueOf'
+];
+
+
+/***/ }),
+
+/***/ 6332:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(3405);
+
+var navigator = globalThis.navigator;
+var userAgent = navigator && navigator.userAgent;
+
+module.exports = userAgent ? String(userAgent) : '';
+
+
+/***/ }),
+
+/***/ 5168:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(3405);
+var userAgent = __webpack_require__(6332);
+
+var process = globalThis.process;
+var Deno = globalThis.Deno;
+var versions = process && process.versions || Deno && Deno.version;
+var v8 = versions && versions.v8;
+var match, version;
+
+if (v8) {
+  match = v8.split('.');
+  // in old Chrome, versions of V8 isn't V8 = Chrome / 10
+  // but their correct versions are not interesting for us
+  version = match[0] > 0 && match[0] < 4 ? 1 : +(match[0] + match[1]);
+}
+
+// BrowserFS NodeJS `process` polyfill incorrectly set `.v8` to `0.0`
+// so check `userAgent` even if `.v8` exists, but 0
+if (!version && userAgent) {
+  match = userAgent.match(/Edge\/(\d+)/);
+  if (!match || match[1] >= 74) {
+    match = userAgent.match(/Chrome\/(\d+)/);
+    if (match) version = +match[1];
+  }
+}
+
+module.exports = version;
+
+
+/***/ }),
+
+/***/ 7725:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(3405);
+var getOwnPropertyDescriptor = (__webpack_require__(6056).f);
+var createNonEnumerableProperty = __webpack_require__(232);
+var defineBuiltIn = __webpack_require__(3589);
+var defineGlobalProperty = __webpack_require__(7214);
+var copyConstructorProperties = __webpack_require__(4993);
+var isForced = __webpack_require__(5129);
+
+/*
+  options.target         - name of the target object
+  options.global         - target is the global object
+  options.stat           - export as static methods of target
+  options.proto          - export as prototype methods of target
+  options.real           - real prototype method for the `pure` version
+  options.forced         - export even if the native feature is available
+  options.bind           - bind methods to the target, required for the `pure` version
+  options.wrap           - wrap constructors to preventing global pollution, required for the `pure` version
+  options.unsafe         - use the simple assignment of property instead of delete + defineProperty
+  options.sham           - add a flag to not completely full polyfills
+  options.enumerable     - export as enumerable property
+  options.dontCallGetSet - prevent calling a getter on target
+  options.name           - the .name of the function if it does not match the key
+*/
+module.exports = function (options, source) {
+  var TARGET = options.target;
+  var GLOBAL = options.global;
+  var STATIC = options.stat;
+  var FORCED, target, key, targetProperty, sourceProperty, descriptor;
+  if (GLOBAL) {
+    target = globalThis;
+  } else if (STATIC) {
+    target = globalThis[TARGET] || defineGlobalProperty(TARGET, {});
+  } else {
+    target = globalThis[TARGET] && globalThis[TARGET].prototype;
+  }
+  if (target) for (key in source) {
+    sourceProperty = source[key];
+    if (options.dontCallGetSet) {
+      descriptor = getOwnPropertyDescriptor(target, key);
+      targetProperty = descriptor && descriptor.value;
+    } else targetProperty = target[key];
+    FORCED = isForced(GLOBAL ? key : TARGET + (STATIC ? '.' : '#') + key, options.forced);
+    // contained in target
+    if (!FORCED && targetProperty !== undefined) {
+      if (typeof sourceProperty == typeof targetProperty) continue;
+      copyConstructorProperties(sourceProperty, targetProperty);
+    }
+    // add a flag to not completely full polyfills
+    if (options.sham || (targetProperty && targetProperty.sham)) {
+      createNonEnumerableProperty(sourceProperty, 'sham', true);
+    }
+    defineBuiltIn(target, key, sourceProperty, options);
+  }
+};
+
+
+/***/ }),
+
+/***/ 8930:
+/***/ (function(module) {
+
+
+module.exports = function (exec) {
+  try {
+    return !!exec();
+  } catch (error) {
+    return true;
+  }
+};
+
+
+/***/ }),
+
+/***/ 5990:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var NATIVE_BIND = __webpack_require__(5647);
+
+var FunctionPrototype = Function.prototype;
+var apply = FunctionPrototype.apply;
+var call = FunctionPrototype.call;
+
+// eslint-disable-next-line es/no-function-prototype-bind, es/no-reflect -- safe
+module.exports = typeof Reflect == 'object' && Reflect.apply || (NATIVE_BIND ? call.bind(apply) : function () {
+  return call.apply(apply, arguments);
+});
+
+
+/***/ }),
+
+/***/ 4445:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(9995);
+var aCallable = __webpack_require__(2481);
+var NATIVE_BIND = __webpack_require__(5647);
+
+var bind = uncurryThis(uncurryThis.bind);
+
+// optional / simple context binding
+module.exports = function (fn, that) {
+  aCallable(fn);
+  return that === undefined ? fn : NATIVE_BIND ? bind(fn, that) : function (/* ...args */) {
+    return fn.apply(that, arguments);
+  };
+};
+
+
+/***/ }),
+
+/***/ 5647:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var fails = __webpack_require__(8930);
+
+module.exports = !fails(function () {
+  // eslint-disable-next-line es/no-function-prototype-bind -- safe
+  var test = function () { /* empty */ }.bind();
+  // eslint-disable-next-line no-prototype-builtins -- safe
+  return typeof test != 'function' || test.hasOwnProperty('prototype');
+});
+
+
+/***/ }),
+
+/***/ 3176:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var NATIVE_BIND = __webpack_require__(5647);
+
+var call = Function.prototype.call;
+// eslint-disable-next-line es/no-function-prototype-bind -- safe
+module.exports = NATIVE_BIND ? call.bind(call) : function () {
+  return call.apply(call, arguments);
+};
+
+
+/***/ }),
+
+/***/ 3743:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(7101);
+var hasOwn = __webpack_require__(9522);
+
+var FunctionPrototype = Function.prototype;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getDescriptor = DESCRIPTORS && Object.getOwnPropertyDescriptor;
+
+var EXISTS = hasOwn(FunctionPrototype, 'name');
+// additional protection from minified / mangled / dropped function names
+var PROPER = EXISTS && function something() { /* empty */ }.name === 'something';
+var CONFIGURABLE = EXISTS && (!DESCRIPTORS || (DESCRIPTORS && getDescriptor(FunctionPrototype, 'name').configurable));
+
+module.exports = {
+  EXISTS: EXISTS,
+  PROPER: PROPER,
+  CONFIGURABLE: CONFIGURABLE
+};
+
+
+/***/ }),
+
+/***/ 9995:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var classofRaw = __webpack_require__(7409);
+var uncurryThis = __webpack_require__(2289);
+
+module.exports = function (fn) {
+  // Nashorn bug:
+  //   https://github.com/zloirock/core-js/issues/1128
+  //   https://github.com/zloirock/core-js/issues/1130
+  if (classofRaw(fn) === 'Function') return uncurryThis(fn);
+};
+
+
+/***/ }),
+
+/***/ 2289:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var NATIVE_BIND = __webpack_require__(5647);
+
+var FunctionPrototype = Function.prototype;
+var call = FunctionPrototype.call;
+// eslint-disable-next-line es/no-function-prototype-bind -- safe
+var uncurryThisWithBind = NATIVE_BIND && FunctionPrototype.bind.bind(call, call);
+
+module.exports = NATIVE_BIND ? uncurryThisWithBind : function (fn) {
+  return function () {
+    return call.apply(fn, arguments);
+  };
+};
+
+
+/***/ }),
+
+/***/ 3220:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(3405);
+var isCallable = __webpack_require__(8252);
+
+var aFunction = function (argument) {
+  return isCallable(argument) ? argument : undefined;
+};
+
+module.exports = function (namespace, method) {
+  return arguments.length < 2 ? aFunction(globalThis[namespace]) : globalThis[namespace] && globalThis[namespace][method];
+};
+
+
+/***/ }),
+
+/***/ 6226:
+/***/ (function(module) {
+
+
+// `GetIteratorDirect(obj)` abstract operation
+// https://tc39.es/ecma262/#sec-getiteratordirect
+module.exports = function (obj) {
+  return {
+    iterator: obj,
+    next: obj.next,
+    done: false
+  };
+};
+
+
+/***/ }),
+
+/***/ 8258:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var classof = __webpack_require__(110);
+var getMethod = __webpack_require__(3377);
+var isNullOrUndefined = __webpack_require__(3022);
+var Iterators = __webpack_require__(4988);
+var wellKnownSymbol = __webpack_require__(2666);
+
+var ITERATOR = wellKnownSymbol('iterator');
+
+module.exports = function (it) {
+  if (!isNullOrUndefined(it)) return getMethod(it, ITERATOR)
+    || getMethod(it, '@@iterator')
+    || Iterators[classof(it)];
+};
+
+
+/***/ }),
+
+/***/ 4750:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var call = __webpack_require__(3176);
+var aCallable = __webpack_require__(2481);
+var anObject = __webpack_require__(3162);
+var tryToString = __webpack_require__(1958);
+var getIteratorMethod = __webpack_require__(8258);
+
+var $TypeError = TypeError;
+
+module.exports = function (argument, usingIterator) {
+  var iteratorMethod = arguments.length < 2 ? getIteratorMethod(argument) : usingIterator;
+  if (aCallable(iteratorMethod)) return anObject(call(iteratorMethod, argument));
+  throw new $TypeError(tryToString(argument) + ' is not iterable');
+};
+
+
+/***/ }),
+
+/***/ 3377:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var aCallable = __webpack_require__(2481);
+var isNullOrUndefined = __webpack_require__(3022);
+
+// `GetMethod` abstract operation
+// https://tc39.es/ecma262/#sec-getmethod
+module.exports = function (V, P) {
+  var func = V[P];
+  return isNullOrUndefined(func) ? undefined : aCallable(func);
+};
+
+
+/***/ }),
+
+/***/ 3405:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var check = function (it) {
+  return it && it.Math === Math && it;
+};
+
+// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028
+module.exports =
+  // eslint-disable-next-line es/no-global-this -- safe
+  check(typeof globalThis == 'object' && globalThis) ||
+  check(typeof window == 'object' && window) ||
+  // eslint-disable-next-line no-restricted-globals -- safe
+  check(typeof self == 'object' && self) ||
+  check(typeof __webpack_require__.g == 'object' && __webpack_require__.g) ||
+  check(typeof this == 'object' && this) ||
+  // eslint-disable-next-line no-new-func -- fallback
+  (function () { return this; })() || Function('return this')();
+
+
+/***/ }),
+
+/***/ 9522:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(2289);
+var toObject = __webpack_require__(1724);
+
+var hasOwnProperty = uncurryThis({}.hasOwnProperty);
+
+// `HasOwnProperty` abstract operation
+// https://tc39.es/ecma262/#sec-hasownproperty
+// eslint-disable-next-line es/no-object-hasown -- safe
+module.exports = Object.hasOwn || function hasOwn(it, key) {
+  return hasOwnProperty(toObject(it), key);
+};
+
+
+/***/ }),
+
+/***/ 4036:
+/***/ (function(module) {
+
+
+module.exports = {};
+
+
+/***/ }),
+
+/***/ 9810:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var getBuiltIn = __webpack_require__(3220);
+
+module.exports = getBuiltIn('document', 'documentElement');
+
+
+/***/ }),
+
+/***/ 1782:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(7101);
+var fails = __webpack_require__(8930);
+var createElement = __webpack_require__(2998);
+
+// Thanks to IE8 for its funny defineProperty
+module.exports = !DESCRIPTORS && !fails(function () {
+  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+  return Object.defineProperty(createElement('div'), 'a', {
+    get: function () { return 7; }
+  }).a !== 7;
+});
+
+
+/***/ }),
+
+/***/ 1792:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(2289);
+var fails = __webpack_require__(8930);
+var classof = __webpack_require__(7409);
+
+var $Object = Object;
+var split = uncurryThis(''.split);
+
+// fallback for non-array-like ES3 and non-enumerable old V8 strings
+module.exports = fails(function () {
+  // throws an error in rhino, see https://github.com/mozilla/rhino/issues/346
+  // eslint-disable-next-line no-prototype-builtins -- safe
+  return !$Object('z').propertyIsEnumerable(0);
+}) ? function (it) {
+  return classof(it) === 'String' ? split(it, '') : $Object(it);
+} : $Object;
+
+
+/***/ }),
+
+/***/ 4117:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(2289);
+var isCallable = __webpack_require__(8252);
+var store = __webpack_require__(8486);
+
+var functionToString = uncurryThis(Function.toString);
+
+// this helper broken in `core-js@3.4.1-3.4.4`, so we can't use `shared` helper
+if (!isCallable(store.inspectSource)) {
+  store.inspectSource = function (it) {
+    return functionToString(it);
+  };
+}
+
+module.exports = store.inspectSource;
+
+
+/***/ }),
+
+/***/ 4206:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var NATIVE_WEAK_MAP = __webpack_require__(3337);
+var globalThis = __webpack_require__(3405);
+var isObject = __webpack_require__(8271);
+var createNonEnumerableProperty = __webpack_require__(232);
+var hasOwn = __webpack_require__(9522);
+var shared = __webpack_require__(8486);
+var sharedKey = __webpack_require__(4040);
+var hiddenKeys = __webpack_require__(4036);
+
+var OBJECT_ALREADY_INITIALIZED = 'Object already initialized';
+var TypeError = globalThis.TypeError;
+var WeakMap = globalThis.WeakMap;
+var set, get, has;
+
+var enforce = function (it) {
+  return has(it) ? get(it) : set(it, {});
+};
+
+var getterFor = function (TYPE) {
+  return function (it) {
+    var state;
+    if (!isObject(it) || (state = get(it)).type !== TYPE) {
+      throw new TypeError('Incompatible receiver, ' + TYPE + ' required');
+    } return state;
+  };
+};
+
+if (NATIVE_WEAK_MAP || shared.state) {
+  var store = shared.state || (shared.state = new WeakMap());
+  /* eslint-disable no-self-assign -- prototype methods protection */
+  store.get = store.get;
+  store.has = store.has;
+  store.set = store.set;
+  /* eslint-enable no-self-assign -- prototype methods protection */
+  set = function (it, metadata) {
+    if (store.has(it)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+    metadata.facade = it;
+    store.set(it, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return store.get(it) || {};
+  };
+  has = function (it) {
+    return store.has(it);
+  };
+} else {
+  var STATE = sharedKey('state');
+  hiddenKeys[STATE] = true;
+  set = function (it, metadata) {
+    if (hasOwn(it, STATE)) throw new TypeError(OBJECT_ALREADY_INITIALIZED);
+    metadata.facade = it;
+    createNonEnumerableProperty(it, STATE, metadata);
+    return metadata;
+  };
+  get = function (it) {
+    return hasOwn(it, STATE) ? it[STATE] : {};
+  };
+  has = function (it) {
+    return hasOwn(it, STATE);
+  };
+}
+
+module.exports = {
+  set: set,
+  get: get,
+  has: has,
+  enforce: enforce,
+  getterFor: getterFor
+};
+
+
+/***/ }),
+
+/***/ 450:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var wellKnownSymbol = __webpack_require__(2666);
+var Iterators = __webpack_require__(4988);
+
+var ITERATOR = wellKnownSymbol('iterator');
+var ArrayPrototype = Array.prototype;
+
+// check on default Array iterator
+module.exports = function (it) {
+  return it !== undefined && (Iterators.Array === it || ArrayPrototype[ITERATOR] === it);
+};
+
+
+/***/ }),
+
+/***/ 8431:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var classof = __webpack_require__(7409);
+
+// `IsArray` abstract operation
+// https://tc39.es/ecma262/#sec-isarray
+// eslint-disable-next-line es/no-array-isarray -- safe
+module.exports = Array.isArray || function isArray(argument) {
+  return classof(argument) === 'Array';
+};
+
+
+/***/ }),
+
+/***/ 8252:
+/***/ (function(module) {
+
+
+// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot
+var documentAll = typeof document == 'object' && document.all;
+
+// `IsCallable` abstract operation
+// https://tc39.es/ecma262/#sec-iscallable
+// eslint-disable-next-line unicorn/no-typeof-undefined -- required for testing
+module.exports = typeof documentAll == 'undefined' && documentAll !== undefined ? function (argument) {
+  return typeof argument == 'function' || argument === documentAll;
+} : function (argument) {
+  return typeof argument == 'function';
+};
+
+
+/***/ }),
+
+/***/ 5129:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var fails = __webpack_require__(8930);
+var isCallable = __webpack_require__(8252);
+
+var replacement = /#|\.prototype\./;
+
+var isForced = function (feature, detection) {
+  var value = data[normalize(feature)];
+  return value === POLYFILL ? true
+    : value === NATIVE ? false
+    : isCallable(detection) ? fails(detection)
+    : !!detection;
+};
+
+var normalize = isForced.normalize = function (string) {
+  return String(string).replace(replacement, '.').toLowerCase();
+};
+
+var data = isForced.data = {};
+var NATIVE = isForced.NATIVE = 'N';
+var POLYFILL = isForced.POLYFILL = 'P';
+
+module.exports = isForced;
+
+
+/***/ }),
+
+/***/ 3022:
+/***/ (function(module) {
+
+
+// we can't use just `it == null` since of `document.all` special case
+// https://tc39.es/ecma262/#sec-IsHTMLDDA-internal-slot-aec
+module.exports = function (it) {
+  return it === null || it === undefined;
+};
+
+
+/***/ }),
+
+/***/ 8271:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isCallable = __webpack_require__(8252);
+
+module.exports = function (it) {
+  return typeof it == 'object' ? it !== null : isCallable(it);
+};
+
+
+/***/ }),
+
+/***/ 4214:
+/***/ (function(module) {
+
+
+module.exports = false;
+
+
+/***/ }),
+
+/***/ 8944:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var getBuiltIn = __webpack_require__(3220);
+var isCallable = __webpack_require__(8252);
+var isPrototypeOf = __webpack_require__(8130);
+var USE_SYMBOL_AS_UID = __webpack_require__(5537);
+
+var $Object = Object;
+
+module.exports = USE_SYMBOL_AS_UID ? function (it) {
+  return typeof it == 'symbol';
+} : function (it) {
+  var $Symbol = getBuiltIn('Symbol');
+  return isCallable($Symbol) && isPrototypeOf($Symbol.prototype, $Object(it));
+};
+
+
+/***/ }),
+
+/***/ 6841:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var bind = __webpack_require__(4445);
+var call = __webpack_require__(3176);
+var anObject = __webpack_require__(3162);
+var tryToString = __webpack_require__(1958);
+var isArrayIteratorMethod = __webpack_require__(450);
+var lengthOfArrayLike = __webpack_require__(6013);
+var isPrototypeOf = __webpack_require__(8130);
+var getIterator = __webpack_require__(4750);
+var getIteratorMethod = __webpack_require__(8258);
+var iteratorClose = __webpack_require__(1380);
+
+var $TypeError = TypeError;
+
+var Result = function (stopped, result) {
+  this.stopped = stopped;
+  this.result = result;
+};
+
+var ResultPrototype = Result.prototype;
+
+module.exports = function (iterable, unboundFunction, options) {
+  var that = options && options.that;
+  var AS_ENTRIES = !!(options && options.AS_ENTRIES);
+  var IS_RECORD = !!(options && options.IS_RECORD);
+  var IS_ITERATOR = !!(options && options.IS_ITERATOR);
+  var INTERRUPTED = !!(options && options.INTERRUPTED);
+  var fn = bind(unboundFunction, that);
+  var iterator, iterFn, index, length, result, next, step;
+
+  var stop = function (condition) {
+    var $iterator = iterator;
+    iterator = undefined;
+    if ($iterator) iteratorClose($iterator, 'normal');
+    return new Result(true, condition);
+  };
+
+  var callFn = function (value) {
+    if (AS_ENTRIES) {
+      anObject(value);
+      return INTERRUPTED ? fn(value[0], value[1], stop) : fn(value[0], value[1]);
+    } return INTERRUPTED ? fn(value, stop) : fn(value);
+  };
+
+  if (IS_RECORD) {
+    iterator = iterable.iterator;
+  } else if (IS_ITERATOR) {
+    iterator = iterable;
+  } else {
+    iterFn = getIteratorMethod(iterable);
+    if (!iterFn) throw new $TypeError(tryToString(iterable) + ' is not iterable');
+    // optimisation for array iterators
+    if (isArrayIteratorMethod(iterFn)) {
+      for (index = 0, length = lengthOfArrayLike(iterable); length > index; index++) {
+        result = callFn(iterable[index]);
+        if (result && isPrototypeOf(ResultPrototype, result)) return result;
+      } return new Result(false);
+    }
+    iterator = getIterator(iterable, iterFn);
+  }
+
+  next = IS_RECORD ? iterable.next : iterator.next;
+  while (!(step = call(next, iterator)).done) {
+    // `IteratorValue` errors should propagate without closing the iterator
+    var value = step.value;
+    try {
+      result = callFn(value);
+    } catch (error) {
+      if (iterator) iteratorClose(iterator, 'throw', error);
+      else throw error;
+    }
+    if (typeof result == 'object' && result && isPrototypeOf(ResultPrototype, result)) return result;
+  } return new Result(false);
+};
+
+
+/***/ }),
+
+/***/ 7462:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var iteratorClose = __webpack_require__(1380);
+
+module.exports = function (iters, kind, value) {
+  for (var i = iters.length - 1; i >= 0; i--) {
+    if (iters[i] === undefined) continue;
+    try {
+      value = iteratorClose(iters[i].iterator, kind, value);
+    } catch (error) {
+      kind = 'throw';
+      value = error;
+    }
+  }
+  if (kind === 'throw') throw value;
+  return value;
+};
+
+
+/***/ }),
+
+/***/ 1380:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var call = __webpack_require__(3176);
+var anObject = __webpack_require__(3162);
+var getMethod = __webpack_require__(3377);
+
+module.exports = function (iterator, kind, value) {
+  var innerResult, innerError;
+  anObject(iterator);
+  try {
+    innerResult = getMethod(iterator, 'return');
+    if (!innerResult) {
+      if (kind === 'throw') throw value;
+      return value;
+    }
+    innerResult = call(innerResult, iterator);
+  } catch (error) {
+    innerError = true;
+    innerResult = error;
+  }
+  if (kind === 'throw') throw value;
+  if (innerError) throw innerResult;
+  anObject(innerResult);
+  return value;
+};
+
+
+/***/ }),
+
+/***/ 7211:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var call = __webpack_require__(3176);
+var create = __webpack_require__(3369);
+var createNonEnumerableProperty = __webpack_require__(232);
+var defineBuiltIns = __webpack_require__(2976);
+var wellKnownSymbol = __webpack_require__(2666);
+var InternalStateModule = __webpack_require__(4206);
+var getMethod = __webpack_require__(3377);
+var IteratorPrototype = (__webpack_require__(2274).IteratorPrototype);
+var createIterResultObject = __webpack_require__(4992);
+var iteratorClose = __webpack_require__(1380);
+var iteratorCloseAll = __webpack_require__(7462);
+
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var ITERATOR_HELPER = 'IteratorHelper';
+var WRAP_FOR_VALID_ITERATOR = 'WrapForValidIterator';
+var NORMAL = 'normal';
+var THROW = 'throw';
+var setInternalState = InternalStateModule.set;
+
+var createIteratorProxyPrototype = function (IS_ITERATOR) {
+  var getInternalState = InternalStateModule.getterFor(IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER);
+
+  return defineBuiltIns(create(IteratorPrototype), {
+    next: function next() {
+      var state = getInternalState(this);
+      // for simplification:
+      //   for `%WrapForValidIteratorPrototype%.next` or with `state.returnHandlerResult` our `nextHandler` returns `IterResultObject`
+      //   for `%IteratorHelperPrototype%.next` - just a value
+      if (IS_ITERATOR) return state.nextHandler();
+      if (state.done) return createIterResultObject(undefined, true);
+      try {
+        var result = state.nextHandler();
+        return state.returnHandlerResult ? result : createIterResultObject(result, state.done);
+      } catch (error) {
+        state.done = true;
+        throw error;
+      }
+    },
+    'return': function () {
+      var state = getInternalState(this);
+      var iterator = state.iterator;
+      var done = state.done;
+      state.done = true;
+      if (IS_ITERATOR) {
+        var returnMethod = getMethod(iterator, 'return');
+        return returnMethod ? call(returnMethod, iterator) : createIterResultObject(undefined, true);
+      }
+      if (done) return createIterResultObject(undefined, true);
+      if (state.inner) try {
+        iteratorClose(state.inner.iterator, NORMAL);
+      } catch (error) {
+        return iteratorClose(iterator, THROW, error);
+      }
+      if (state.openIters) try {
+        iteratorCloseAll(state.openIters, NORMAL);
+      } catch (error) {
+        if (iterator) return iteratorClose(iterator, THROW, error);
+        throw error;
+      }
+      if (iterator) iteratorClose(iterator, NORMAL);
+      return createIterResultObject(undefined, true);
+    }
+  });
+};
+
+var WrapForValidIteratorPrototype = createIteratorProxyPrototype(true);
+var IteratorHelperPrototype = createIteratorProxyPrototype(false);
+
+createNonEnumerableProperty(IteratorHelperPrototype, TO_STRING_TAG, 'Iterator Helper');
+
+module.exports = function (nextHandler, IS_ITERATOR, RETURN_HANDLER_RESULT) {
+  var IteratorProxy = function Iterator(record, state) {
+    if (state) {
+      state.iterator = record.iterator;
+      state.next = record.next;
+    } else state = record;
+    state.type = IS_ITERATOR ? WRAP_FOR_VALID_ITERATOR : ITERATOR_HELPER;
+    state.returnHandlerResult = !!RETURN_HANDLER_RESULT;
+    state.nextHandler = nextHandler;
+    state.counter = 0;
+    state.done = false;
+    setInternalState(this, state);
+  };
+
+  IteratorProxy.prototype = IS_ITERATOR ? WrapForValidIteratorPrototype : IteratorHelperPrototype;
+
+  return IteratorProxy;
+};
+
+
+/***/ }),
+
+/***/ 6483:
+/***/ (function(module) {
+
+
+// Should throw an error on invalid iterator
+// https://issues.chromium.org/issues/336839115
+module.exports = function (methodName, argument) {
+  // eslint-disable-next-line es/no-iterator -- required for testing
+  var method = typeof Iterator == 'function' && Iterator.prototype[methodName];
+  if (method) try {
+    method.call({ next: null }, argument).next();
+  } catch (error) {
+    return true;
+  }
+};
+
+
+/***/ }),
+
+/***/ 2229:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(3405);
+
+// https://github.com/tc39/ecma262/pull/3467
+module.exports = function (METHOD_NAME, ExpectedError) {
+  var Iterator = globalThis.Iterator;
+  var IteratorPrototype = Iterator && Iterator.prototype;
+  var method = IteratorPrototype && IteratorPrototype[METHOD_NAME];
+
+  var CLOSED = false;
+
+  if (method) try {
+    method.call({
+      next: function () { return { done: true }; },
+      'return': function () { CLOSED = true; }
+    }, -1);
+  } catch (error) {
+    // https://bugs.webkit.org/show_bug.cgi?id=291195
+    if (!(error instanceof ExpectedError)) CLOSED = false;
+  }
+
+  if (!CLOSED) return method;
+};
+
+
+/***/ }),
+
+/***/ 2274:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var fails = __webpack_require__(8930);
+var isCallable = __webpack_require__(8252);
+var isObject = __webpack_require__(8271);
+var create = __webpack_require__(3369);
+var getPrototypeOf = __webpack_require__(8778);
+var defineBuiltIn = __webpack_require__(3589);
+var wellKnownSymbol = __webpack_require__(2666);
+var IS_PURE = __webpack_require__(4214);
+
+var ITERATOR = wellKnownSymbol('iterator');
+var BUGGY_SAFARI_ITERATORS = false;
+
+// `%IteratorPrototype%` object
+// https://tc39.es/ecma262/#sec-%iteratorprototype%-object
+var IteratorPrototype, PrototypeOfArrayIteratorPrototype, arrayIterator;
+
+/* eslint-disable es/no-array-prototype-keys -- safe */
+if ([].keys) {
+  arrayIterator = [].keys();
+  // Safari 8 has buggy iterators w/o `next`
+  if (!('next' in arrayIterator)) BUGGY_SAFARI_ITERATORS = true;
+  else {
+    PrototypeOfArrayIteratorPrototype = getPrototypeOf(getPrototypeOf(arrayIterator));
+    if (PrototypeOfArrayIteratorPrototype !== Object.prototype) IteratorPrototype = PrototypeOfArrayIteratorPrototype;
+  }
+}
+
+var NEW_ITERATOR_PROTOTYPE = !isObject(IteratorPrototype) || fails(function () {
+  var test = {};
+  // FF44- legacy iterators case
+  return IteratorPrototype[ITERATOR].call(test) !== test;
+});
+
+if (NEW_ITERATOR_PROTOTYPE) IteratorPrototype = {};
+else if (IS_PURE) IteratorPrototype = create(IteratorPrototype);
+
+// `%IteratorPrototype%[@@iterator]()` method
+// https://tc39.es/ecma262/#sec-%iteratorprototype%-@@iterator
+if (!isCallable(IteratorPrototype[ITERATOR])) {
+  defineBuiltIn(IteratorPrototype, ITERATOR, function () {
+    return this;
+  });
+}
+
+module.exports = {
+  IteratorPrototype: IteratorPrototype,
+  BUGGY_SAFARI_ITERATORS: BUGGY_SAFARI_ITERATORS
+};
+
+
+/***/ }),
+
+/***/ 4988:
+/***/ (function(module) {
+
+
+module.exports = {};
+
+
+/***/ }),
+
+/***/ 6013:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var toLength = __webpack_require__(5531);
+
+// `LengthOfArrayLike` abstract operation
+// https://tc39.es/ecma262/#sec-lengthofarraylike
+module.exports = function (obj) {
+  return toLength(obj.length);
+};
+
+
+/***/ }),
+
+/***/ 4034:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(2289);
+var fails = __webpack_require__(8930);
+var isCallable = __webpack_require__(8252);
+var hasOwn = __webpack_require__(9522);
+var DESCRIPTORS = __webpack_require__(7101);
+var CONFIGURABLE_FUNCTION_NAME = (__webpack_require__(3743).CONFIGURABLE);
+var inspectSource = __webpack_require__(4117);
+var InternalStateModule = __webpack_require__(4206);
+
+var enforceInternalState = InternalStateModule.enforce;
+var getInternalState = InternalStateModule.get;
+var $String = String;
+// eslint-disable-next-line es/no-object-defineproperty -- safe
+var defineProperty = Object.defineProperty;
+var stringSlice = uncurryThis(''.slice);
+var replace = uncurryThis(''.replace);
+var join = uncurryThis([].join);
+
+var CONFIGURABLE_LENGTH = DESCRIPTORS && !fails(function () {
+  return defineProperty(function () { /* empty */ }, 'length', { value: 8 }).length !== 8;
+});
+
+var TEMPLATE = String(String).split('String');
+
+var makeBuiltIn = module.exports = function (value, name, options) {
+  if (stringSlice($String(name), 0, 7) === 'Symbol(') {
+    name = '[' + replace($String(name), /^Symbol\(([^)]*)\).*$/, '$1') + ']';
+  }
+  if (options && options.getter) name = 'get ' + name;
+  if (options && options.setter) name = 'set ' + name;
+  if (!hasOwn(value, 'name') || (CONFIGURABLE_FUNCTION_NAME && value.name !== name)) {
+    if (DESCRIPTORS) defineProperty(value, 'name', { value: name, configurable: true });
+    else value.name = name;
+  }
+  if (CONFIGURABLE_LENGTH && options && hasOwn(options, 'arity') && value.length !== options.arity) {
+    defineProperty(value, 'length', { value: options.arity });
+  }
+  try {
+    if (options && hasOwn(options, 'constructor') && options.constructor) {
+      if (DESCRIPTORS) defineProperty(value, 'prototype', { writable: false });
+    // in V8 ~ Chrome 53, prototypes of some methods, like `Array.prototype.values`, are non-writable
+    } else if (value.prototype) value.prototype = undefined;
+  } catch (error) { /* empty */ }
+  var state = enforceInternalState(value);
+  if (!hasOwn(state, 'source')) {
+    state.source = join(TEMPLATE, typeof name == 'string' ? name : '');
+  } return value;
+};
+
+// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative
+// eslint-disable-next-line no-extend-native -- required
+Function.prototype.toString = makeBuiltIn(function toString() {
+  return isCallable(this) && getInternalState(this).source || inspectSource(this);
+}, 'toString');
+
+
+/***/ }),
+
+/***/ 7966:
+/***/ (function(module) {
+
+
+var ceil = Math.ceil;
+var floor = Math.floor;
+
+// `Math.trunc` method
+// https://tc39.es/ecma262/#sec-math.trunc
+// eslint-disable-next-line es/no-math-trunc -- safe
+module.exports = Math.trunc || function trunc(x) {
+  var n = +x;
+  return (n > 0 ? floor : ceil)(n);
+};
+
+
+/***/ }),
+
+/***/ 3369:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+/* global ActiveXObject -- old IE, WSH */
+var anObject = __webpack_require__(3162);
+var definePropertiesModule = __webpack_require__(5422);
+var enumBugKeys = __webpack_require__(7658);
+var hiddenKeys = __webpack_require__(4036);
+var html = __webpack_require__(9810);
+var documentCreateElement = __webpack_require__(2998);
+var sharedKey = __webpack_require__(4040);
+
+var GT = '>';
+var LT = '<';
+var PROTOTYPE = 'prototype';
+var SCRIPT = 'script';
+var IE_PROTO = sharedKey('IE_PROTO');
+
+var EmptyConstructor = function () { /* empty */ };
+
+var scriptTag = function (content) {
+  return LT + SCRIPT + GT + content + LT + '/' + SCRIPT + GT;
+};
+
+// Create object with fake `null` prototype: use ActiveX Object with cleared prototype
+var NullProtoObjectViaActiveX = function (activeXDocument) {
+  activeXDocument.write(scriptTag(''));
+  activeXDocument.close();
+  var temp = activeXDocument.parentWindow.Object;
+  // eslint-disable-next-line no-useless-assignment -- avoid memory leak
+  activeXDocument = null;
+  return temp;
+};
+
+// Create object with fake `null` prototype: use iframe Object with cleared prototype
+var NullProtoObjectViaIFrame = function () {
+  // Thrash, waste and sodomy: IE GC bug
+  var iframe = documentCreateElement('iframe');
+  var JS = 'java' + SCRIPT + ':';
+  var iframeDocument;
+  iframe.style.display = 'none';
+  html.appendChild(iframe);
+  // https://github.com/zloirock/core-js/issues/475
+  iframe.src = String(JS);
+  iframeDocument = iframe.contentWindow.document;
+  iframeDocument.open();
+  iframeDocument.write(scriptTag('document.F=Object'));
+  iframeDocument.close();
+  return iframeDocument.F;
+};
+
+// Check for document.domain and active x support
+// No need to use active x approach when document.domain is not set
+// see https://github.com/es-shims/es5-shim/issues/150
+// variation of https://github.com/kitcambridge/es5-shim/commit/4f738ac066346
+// avoid IE GC bug
+var activeXDocument;
+var NullProtoObject = function () {
+  try {
+    activeXDocument = new ActiveXObject('htmlfile');
+  } catch (error) { /* ignore */ }
+  NullProtoObject = typeof document != 'undefined'
+    ? document.domain && activeXDocument
+      ? NullProtoObjectViaActiveX(activeXDocument) // old IE
+      : NullProtoObjectViaIFrame()
+    : NullProtoObjectViaActiveX(activeXDocument); // WSH
+  var length = enumBugKeys.length;
+  while (length--) delete NullProtoObject[PROTOTYPE][enumBugKeys[length]];
+  return NullProtoObject();
+};
+
+hiddenKeys[IE_PROTO] = true;
+
+// `Object.create` method
+// https://tc39.es/ecma262/#sec-object.create
+// eslint-disable-next-line es/no-object-create -- safe
+module.exports = Object.create || function create(O, Properties) {
+  var result;
+  if (O !== null) {
+    EmptyConstructor[PROTOTYPE] = anObject(O);
+    result = new EmptyConstructor();
+    EmptyConstructor[PROTOTYPE] = null;
+    // add "__proto__" for Object.getPrototypeOf polyfill
+    result[IE_PROTO] = O;
+  } else result = NullProtoObject();
+  return Properties === undefined ? result : definePropertiesModule.f(result, Properties);
+};
+
+
+/***/ }),
+
+/***/ 5422:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(7101);
+var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(3667);
+var definePropertyModule = __webpack_require__(1250);
+var anObject = __webpack_require__(3162);
+var toIndexedObject = __webpack_require__(2364);
+var objectKeys = __webpack_require__(7185);
+
+// `Object.defineProperties` method
+// https://tc39.es/ecma262/#sec-object.defineproperties
+// eslint-disable-next-line es/no-object-defineproperties -- safe
+exports.f = DESCRIPTORS && !V8_PROTOTYPE_DEFINE_BUG ? Object.defineProperties : function defineProperties(O, Properties) {
+  anObject(O);
+  var props = toIndexedObject(Properties);
+  var keys = objectKeys(Properties);
+  var length = keys.length;
+  var index = 0;
+  var key;
+  while (length > index) definePropertyModule.f(O, key = keys[index++], props[key]);
+  return O;
+};
+
+
+/***/ }),
+
+/***/ 1250:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(7101);
+var IE8_DOM_DEFINE = __webpack_require__(1782);
+var V8_PROTOTYPE_DEFINE_BUG = __webpack_require__(3667);
+var anObject = __webpack_require__(3162);
+var toPropertyKey = __webpack_require__(3704);
+
+var $TypeError = TypeError;
+// eslint-disable-next-line es/no-object-defineproperty -- safe
+var $defineProperty = Object.defineProperty;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+var ENUMERABLE = 'enumerable';
+var CONFIGURABLE = 'configurable';
+var WRITABLE = 'writable';
+
+// `Object.defineProperty` method
+// https://tc39.es/ecma262/#sec-object.defineproperty
+exports.f = DESCRIPTORS ? V8_PROTOTYPE_DEFINE_BUG ? function defineProperty(O, P, Attributes) {
+  anObject(O);
+  P = toPropertyKey(P);
+  anObject(Attributes);
+  if (typeof O === 'function' && P === 'prototype' && 'value' in Attributes && WRITABLE in Attributes && !Attributes[WRITABLE]) {
+    var current = $getOwnPropertyDescriptor(O, P);
+    if (current && current[WRITABLE]) {
+      O[P] = Attributes.value;
+      Attributes = {
+        configurable: CONFIGURABLE in Attributes ? Attributes[CONFIGURABLE] : current[CONFIGURABLE],
+        enumerable: ENUMERABLE in Attributes ? Attributes[ENUMERABLE] : current[ENUMERABLE],
+        writable: false
+      };
+    }
+  } return $defineProperty(O, P, Attributes);
+} : $defineProperty : function defineProperty(O, P, Attributes) {
+  anObject(O);
+  P = toPropertyKey(P);
+  anObject(Attributes);
+  if (IE8_DOM_DEFINE) try {
+    return $defineProperty(O, P, Attributes);
+  } catch (error) { /* empty */ }
+  if ('get' in Attributes || 'set' in Attributes) throw new $TypeError('Accessors not supported');
+  if ('value' in Attributes) O[P] = Attributes.value;
+  return O;
+};
+
+
+/***/ }),
+
+/***/ 6056:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(7101);
+var call = __webpack_require__(3176);
+var propertyIsEnumerableModule = __webpack_require__(6640);
+var createPropertyDescriptor = __webpack_require__(9299);
+var toIndexedObject = __webpack_require__(2364);
+var toPropertyKey = __webpack_require__(3704);
+var hasOwn = __webpack_require__(9522);
+var IE8_DOM_DEFINE = __webpack_require__(1782);
+
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var $getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+// `Object.getOwnPropertyDescriptor` method
+// https://tc39.es/ecma262/#sec-object.getownpropertydescriptor
+exports.f = DESCRIPTORS ? $getOwnPropertyDescriptor : function getOwnPropertyDescriptor(O, P) {
+  O = toIndexedObject(O);
+  P = toPropertyKey(P);
+  if (IE8_DOM_DEFINE) try {
+    return $getOwnPropertyDescriptor(O, P);
+  } catch (error) { /* empty */ }
+  if (hasOwn(O, P)) return createPropertyDescriptor(!call(propertyIsEnumerableModule.f, O, P), O[P]);
+};
+
+
+/***/ }),
+
+/***/ 7469:
+/***/ (function(__unused_webpack_module, exports, __webpack_require__) {
+
+
+var internalObjectKeys = __webpack_require__(6067);
+var enumBugKeys = __webpack_require__(7658);
+
+var hiddenKeys = enumBugKeys.concat('length', 'prototype');
+
+// `Object.getOwnPropertyNames` method
+// https://tc39.es/ecma262/#sec-object.getownpropertynames
+// eslint-disable-next-line es/no-object-getownpropertynames -- safe
+exports.f = Object.getOwnPropertyNames || function getOwnPropertyNames(O) {
+  return internalObjectKeys(O, hiddenKeys);
+};
+
+
+/***/ }),
+
+/***/ 4540:
+/***/ (function(__unused_webpack_module, exports) {
+
+
+// eslint-disable-next-line es/no-object-getownpropertysymbols -- safe
+exports.f = Object.getOwnPropertySymbols;
+
+
+/***/ }),
+
+/***/ 8778:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var hasOwn = __webpack_require__(9522);
+var isCallable = __webpack_require__(8252);
+var toObject = __webpack_require__(1724);
+var sharedKey = __webpack_require__(4040);
+var CORRECT_PROTOTYPE_GETTER = __webpack_require__(6280);
+
+var IE_PROTO = sharedKey('IE_PROTO');
+var $Object = Object;
+var ObjectPrototype = $Object.prototype;
+
+// `Object.getPrototypeOf` method
+// https://tc39.es/ecma262/#sec-object.getprototypeof
+// eslint-disable-next-line es/no-object-getprototypeof -- safe
+module.exports = CORRECT_PROTOTYPE_GETTER ? $Object.getPrototypeOf : function (O) {
+  var object = toObject(O);
+  if (hasOwn(object, IE_PROTO)) return object[IE_PROTO];
+  var constructor = object.constructor;
+  if (isCallable(constructor) && object instanceof constructor) {
+    return constructor.prototype;
+  } return object instanceof $Object ? ObjectPrototype : null;
+};
+
+
+/***/ }),
+
+/***/ 8130:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(2289);
+
+module.exports = uncurryThis({}.isPrototypeOf);
+
+
+/***/ }),
+
+/***/ 6067:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(2289);
+var hasOwn = __webpack_require__(9522);
+var toIndexedObject = __webpack_require__(2364);
+var indexOf = (__webpack_require__(8658).indexOf);
+var hiddenKeys = __webpack_require__(4036);
+
+var push = uncurryThis([].push);
+
+module.exports = function (object, names) {
+  var O = toIndexedObject(object);
+  var i = 0;
+  var result = [];
+  var key;
+  for (key in O) !hasOwn(hiddenKeys, key) && hasOwn(O, key) && push(result, key);
+  // Don't enum bug & hidden keys
+  while (names.length > i) if (hasOwn(O, key = names[i++])) {
+    ~indexOf(result, key) || push(result, key);
+  }
+  return result;
+};
+
+
+/***/ }),
+
+/***/ 7185:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var internalObjectKeys = __webpack_require__(6067);
+var enumBugKeys = __webpack_require__(7658);
+
+// `Object.keys` method
+// https://tc39.es/ecma262/#sec-object.keys
+// eslint-disable-next-line es/no-object-keys -- safe
+module.exports = Object.keys || function keys(O) {
+  return internalObjectKeys(O, enumBugKeys);
+};
+
+
+/***/ }),
+
+/***/ 6640:
+/***/ (function(__unused_webpack_module, exports) {
+
+
+var $propertyIsEnumerable = {}.propertyIsEnumerable;
+// eslint-disable-next-line es/no-object-getownpropertydescriptor -- safe
+var getOwnPropertyDescriptor = Object.getOwnPropertyDescriptor;
+
+// Nashorn ~ JDK8 bug
+var NASHORN_BUG = getOwnPropertyDescriptor && !$propertyIsEnumerable.call({ 1: 2 }, 1);
+
+// `Object.prototype.propertyIsEnumerable` method implementation
+// https://tc39.es/ecma262/#sec-object.prototype.propertyisenumerable
+exports.f = NASHORN_BUG ? function propertyIsEnumerable(V) {
+  var descriptor = getOwnPropertyDescriptor(this, V);
+  return !!descriptor && descriptor.enumerable;
+} : $propertyIsEnumerable;
+
+
+/***/ }),
+
+/***/ 5519:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var call = __webpack_require__(3176);
+var isCallable = __webpack_require__(8252);
+var isObject = __webpack_require__(8271);
+
+var $TypeError = TypeError;
+
+// `OrdinaryToPrimitive` abstract operation
+// https://tc39.es/ecma262/#sec-ordinarytoprimitive
+module.exports = function (input, pref) {
+  var fn, val;
+  if (pref === 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
+  if (isCallable(fn = input.valueOf) && !isObject(val = call(fn, input))) return val;
+  if (pref !== 'string' && isCallable(fn = input.toString) && !isObject(val = call(fn, input))) return val;
+  throw new $TypeError("Can't convert object to primitive value");
+};
+
+
+/***/ }),
+
+/***/ 5456:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var getBuiltIn = __webpack_require__(3220);
+var uncurryThis = __webpack_require__(2289);
+var getOwnPropertyNamesModule = __webpack_require__(7469);
+var getOwnPropertySymbolsModule = __webpack_require__(4540);
+var anObject = __webpack_require__(3162);
+
+var concat = uncurryThis([].concat);
+
+// all object keys, includes non-enumerable and symbols
+module.exports = getBuiltIn('Reflect', 'ownKeys') || function ownKeys(it) {
+  var keys = getOwnPropertyNamesModule.f(anObject(it));
+  var getOwnPropertySymbols = getOwnPropertySymbolsModule.f;
+  return getOwnPropertySymbols ? concat(keys, getOwnPropertySymbols(it)) : keys;
+};
+
+
+/***/ }),
+
+/***/ 2341:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var isNullOrUndefined = __webpack_require__(3022);
+
+var $TypeError = TypeError;
+
+// `RequireObjectCoercible` abstract operation
+// https://tc39.es/ecma262/#sec-requireobjectcoercible
+module.exports = function (it) {
+  if (isNullOrUndefined(it)) throw new $TypeError("Can't call method on " + it);
+  return it;
+};
+
+
+/***/ }),
+
+/***/ 4040:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var shared = __webpack_require__(8762);
+var uid = __webpack_require__(2161);
+
+var keys = shared('keys');
+
+module.exports = function (key) {
+  return keys[key] || (keys[key] = uid(key));
+};
+
+
+/***/ }),
+
+/***/ 8486:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var IS_PURE = __webpack_require__(4214);
+var globalThis = __webpack_require__(3405);
+var defineGlobalProperty = __webpack_require__(7214);
+
+var SHARED = '__core-js_shared__';
+var store = module.exports = globalThis[SHARED] || defineGlobalProperty(SHARED, {});
+
+(store.versions || (store.versions = [])).push({
+  version: '3.49.0',
+  mode: IS_PURE ? 'pure' : 'global',
+  copyright: '© 2013–2025 Denis Pushkarev (zloirock.ru), 2025–2026 CoreJS Company (core-js.io). All rights reserved.',
+  license: 'https://github.com/zloirock/core-js/blob/v3.49.0/LICENSE',
+  source: 'https://github.com/zloirock/core-js'
+});
+
+
+/***/ }),
+
+/***/ 8762:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var store = __webpack_require__(8486);
+
+module.exports = function (key, value) {
+  return store[key] || (store[key] = value || {});
+};
+
+
+/***/ }),
+
+/***/ 1520:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+/* eslint-disable es/no-symbol -- required for testing */
+var V8_VERSION = __webpack_require__(5168);
+var fails = __webpack_require__(8930);
+var globalThis = __webpack_require__(3405);
+
+var $String = globalThis.String;
+
+// eslint-disable-next-line es/no-object-getownpropertysymbols -- required for testing
+module.exports = !!Object.getOwnPropertySymbols && !fails(function () {
+  var symbol = Symbol('symbol detection');
+  // Chrome 38 Symbol has incorrect toString conversion
+  // `get-own-property-symbols` polyfill symbols converted to object are not Symbol instances
+  // nb: Do not call `String` directly to avoid this being optimized out to `symbol+''` which will,
+  // of course, fail.
+  return !$String(symbol) || !(Object(symbol) instanceof Symbol) ||
+    // Chrome 38-40 symbols are not inherited from DOM collections prototypes to instances
+    !Symbol.sham && V8_VERSION && V8_VERSION < 41;
+});
+
+
+/***/ }),
+
+/***/ 9283:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var toIntegerOrInfinity = __webpack_require__(136);
+
+var max = Math.max;
+var min = Math.min;
+
+// Helper for a popular repeating case of the spec:
+// Let integer be ? ToInteger(index).
+// If integer < 0, let result be max((length + integer), 0); else let result be min(integer, length).
+module.exports = function (index, length) {
+  var integer = toIntegerOrInfinity(index);
+  return integer < 0 ? max(integer + length, 0) : min(integer, length);
+};
+
+
+/***/ }),
+
+/***/ 2364:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+// toObject with fallback for non-array-like ES3 strings
+var IndexedObject = __webpack_require__(1792);
+var requireObjectCoercible = __webpack_require__(2341);
+
+module.exports = function (it) {
+  return IndexedObject(requireObjectCoercible(it));
+};
+
+
+/***/ }),
+
+/***/ 136:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var trunc = __webpack_require__(7966);
+
+// `ToIntegerOrInfinity` abstract operation
+// https://tc39.es/ecma262/#sec-tointegerorinfinity
+module.exports = function (argument) {
+  var number = +argument;
+  // eslint-disable-next-line no-self-compare -- NaN check
+  return number !== number || number === 0 ? 0 : trunc(number);
+};
+
+
+/***/ }),
+
+/***/ 5531:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var toIntegerOrInfinity = __webpack_require__(136);
+
+var min = Math.min;
+
+// `ToLength` abstract operation
+// https://tc39.es/ecma262/#sec-tolength
+module.exports = function (argument) {
+  var len = toIntegerOrInfinity(argument);
+  return len > 0 ? min(len, 0x1FFFFFFFFFFFFF) : 0; // 2 ** 53 - 1 == 9007199254740991
+};
+
+
+/***/ }),
+
+/***/ 1724:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var requireObjectCoercible = __webpack_require__(2341);
+
+var $Object = Object;
+
+// `ToObject` abstract operation
+// https://tc39.es/ecma262/#sec-toobject
+module.exports = function (argument) {
+  return $Object(requireObjectCoercible(argument));
+};
+
+
+/***/ }),
+
+/***/ 4610:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var call = __webpack_require__(3176);
+var isObject = __webpack_require__(8271);
+var isSymbol = __webpack_require__(8944);
+var getMethod = __webpack_require__(3377);
+var ordinaryToPrimitive = __webpack_require__(5519);
+var wellKnownSymbol = __webpack_require__(2666);
+
+var $TypeError = TypeError;
+var TO_PRIMITIVE = wellKnownSymbol('toPrimitive');
+
+// `ToPrimitive` abstract operation
+// https://tc39.es/ecma262/#sec-toprimitive
+module.exports = function (input, pref) {
+  if (!isObject(input) || isSymbol(input)) return input;
+  var exoticToPrim = getMethod(input, TO_PRIMITIVE);
+  var result;
+  if (exoticToPrim) {
+    if (pref === undefined) pref = 'default';
+    result = call(exoticToPrim, input, pref);
+    if (!isObject(result) || isSymbol(result)) return result;
+    throw new $TypeError("Can't convert object to primitive value");
+  }
+  if (pref === undefined) pref = 'number';
+  return ordinaryToPrimitive(input, pref);
+};
+
+
+/***/ }),
+
+/***/ 3704:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var toPrimitive = __webpack_require__(4610);
+var isSymbol = __webpack_require__(8944);
+
+// `ToPropertyKey` abstract operation
+// https://tc39.es/ecma262/#sec-topropertykey
+module.exports = function (argument) {
+  var key = toPrimitive(argument, 'string');
+  return isSymbol(key) ? key : key + '';
+};
+
+
+/***/ }),
+
+/***/ 1153:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var wellKnownSymbol = __webpack_require__(2666);
+
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+var test = {};
+// eslint-disable-next-line unicorn/no-immediate-mutation -- ES3 syntax limitation
+test[TO_STRING_TAG] = 'z';
+
+module.exports = String(test) === '[object z]';
+
+
+/***/ }),
+
+/***/ 1958:
+/***/ (function(module) {
+
+
+var $String = String;
+
+module.exports = function (argument) {
+  try {
+    return $String(argument);
+  } catch (error) {
+    return 'Object';
+  }
+};
+
+
+/***/ }),
+
+/***/ 2161:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var uncurryThis = __webpack_require__(2289);
+
+var id = 0;
+var postfix = Math.random();
+var toString = uncurryThis(1.1.toString);
+
+module.exports = function (key) {
+  return 'Symbol(' + (key === undefined ? '' : key) + ')_' + toString(++id + postfix, 36);
+};
+
+
+/***/ }),
+
+/***/ 5537:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+/* eslint-disable es/no-symbol -- required for testing */
+var NATIVE_SYMBOL = __webpack_require__(1520);
+
+module.exports = NATIVE_SYMBOL &&
+  !Symbol.sham &&
+  typeof Symbol.iterator == 'symbol';
+
+
+/***/ }),
+
+/***/ 3667:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var DESCRIPTORS = __webpack_require__(7101);
+var fails = __webpack_require__(8930);
+
+// V8 ~ Chrome 36-
+// https://bugs.chromium.org/p/v8/issues/detail?id=3334
+module.exports = DESCRIPTORS && fails(function () {
+  // eslint-disable-next-line es/no-object-defineproperty -- required for testing
+  return Object.defineProperty(function () { /* empty */ }, 'prototype', {
+    value: 42,
+    writable: false
+  }).prototype !== 42;
+});
+
+
+/***/ }),
+
+/***/ 3337:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(3405);
+var isCallable = __webpack_require__(8252);
+
+var WeakMap = globalThis.WeakMap;
+
+module.exports = isCallable(WeakMap) && /native code/.test(String(WeakMap));
+
+
+/***/ }),
+
+/***/ 2666:
+/***/ (function(module, __unused_webpack_exports, __webpack_require__) {
+
+
+var globalThis = __webpack_require__(3405);
+var shared = __webpack_require__(8762);
+var hasOwn = __webpack_require__(9522);
+var uid = __webpack_require__(2161);
+var NATIVE_SYMBOL = __webpack_require__(1520);
+var USE_SYMBOL_AS_UID = __webpack_require__(5537);
+
+var Symbol = globalThis.Symbol;
+var WellKnownSymbolsStore = shared('wks');
+var createWellKnownSymbol = USE_SYMBOL_AS_UID ? Symbol['for'] || Symbol : Symbol && Symbol.withoutSetter || uid;
+
+module.exports = function (name) {
+  if (!hasOwn(WellKnownSymbolsStore, name)) {
+    WellKnownSymbolsStore[name] = NATIVE_SYMBOL && hasOwn(Symbol, name)
+      ? Symbol[name]
+      : createWellKnownSymbol('Symbol.' + name);
+  } return WellKnownSymbolsStore[name];
+};
+
+
+/***/ }),
+
+/***/ 9690:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(7725);
+var $includes = (__webpack_require__(8658).includes);
+var fails = __webpack_require__(8930);
+var addToUnscopables = __webpack_require__(7938);
+
+// FF99+ bug
+var BROKEN_ON_SPARSE = fails(function () {
+  // eslint-disable-next-line es/no-array-prototype-includes -- detection
+  return !Array(1).includes();
+});
+
+// Safari 26.4- bug
+var BROKEN_ON_SPARSE_WITH_FROM_INDEX = fails(function () {
+  // eslint-disable-next-line no-sparse-arrays, es/no-array-prototype-includes -- detection
+  return [, 1].includes(undefined, 1);
+});
+
+// `Array.prototype.includes` method
+// https://tc39.es/ecma262/#sec-array.prototype.includes
+$({ target: 'Array', proto: true, forced: BROKEN_ON_SPARSE || BROKEN_ON_SPARSE_WITH_FROM_INDEX }, {
+  includes: function includes(el /* , fromIndex = 0 */) {
+    return $includes(this, el, arguments.length > 1 ? arguments[1] : undefined);
+  }
+});
+
+// https://tc39.es/ecma262/#sec-array.prototype-@@unscopables
+addToUnscopables('includes');
+
+
+/***/ }),
+
+/***/ 4495:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(7725);
+var toObject = __webpack_require__(1724);
+var lengthOfArrayLike = __webpack_require__(6013);
+var setArrayLength = __webpack_require__(592);
+var doesNotExceedSafeInteger = __webpack_require__(6994);
+var fails = __webpack_require__(8930);
+
+var INCORRECT_TO_LENGTH = fails(function () {
+  return [].push.call({ length: 0x100000000 }, 1) !== 4294967297;
+});
+
+// V8 <= 121 and Safari <= 15.4; FF < 23 throws InternalError
+// https://bugs.chromium.org/p/v8/issues/detail?id=12681
+var properErrorOnNonWritableLength = function () {
+  try {
+    // eslint-disable-next-line es/no-object-defineproperty -- safe
+    Object.defineProperty([], 'length', { writable: false }).push();
+  } catch (error) {
+    return error instanceof TypeError;
+  }
+};
+
+var FORCED = INCORRECT_TO_LENGTH || !properErrorOnNonWritableLength();
+
+// `Array.prototype.push` method
+// https://tc39.es/ecma262/#sec-array.prototype.push
+$({ target: 'Array', proto: true, arity: 1, forced: FORCED }, {
+  // eslint-disable-next-line no-unused-vars -- required for `.length`
+  push: function push(item) {
+    var O = toObject(this);
+    var len = lengthOfArrayLike(O);
+    var argCount = arguments.length;
+    doesNotExceedSafeInteger(len + argCount);
+    for (var i = 0; i < argCount; i++) {
+      O[len] = arguments[i];
+      len++;
+    }
+    setArrayLength(O, len);
+    return len;
+  }
+});
+
+
+/***/ }),
+
+/***/ 7622:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(7725);
+var globalThis = __webpack_require__(3405);
+var anInstance = __webpack_require__(462);
+var anObject = __webpack_require__(3162);
+var isCallable = __webpack_require__(8252);
+var getPrototypeOf = __webpack_require__(8778);
+var defineBuiltInAccessor = __webpack_require__(7893);
+var createProperty = __webpack_require__(721);
+var fails = __webpack_require__(8930);
+var hasOwn = __webpack_require__(9522);
+var wellKnownSymbol = __webpack_require__(2666);
+var IteratorPrototype = (__webpack_require__(2274).IteratorPrototype);
+var DESCRIPTORS = __webpack_require__(7101);
+var IS_PURE = __webpack_require__(4214);
+
+var CONSTRUCTOR = 'constructor';
+var ITERATOR = 'Iterator';
+var TO_STRING_TAG = wellKnownSymbol('toStringTag');
+
+var $TypeError = TypeError;
+var NativeIterator = globalThis[ITERATOR];
+
+// FF56- have non-standard global helper `Iterator`
+var FORCED = IS_PURE
+  || !isCallable(NativeIterator)
+  || NativeIterator.prototype !== IteratorPrototype
+  // FF44- non-standard `Iterator` passes previous tests
+  || !fails(function () { NativeIterator({}); });
+
+var IteratorConstructor = function Iterator() {
+  anInstance(this, IteratorPrototype);
+  if (getPrototypeOf(this) === IteratorPrototype) throw new $TypeError('Abstract class Iterator not directly constructable');
+};
+
+var defineIteratorPrototypeAccessor = function (key, value) {
+  if (DESCRIPTORS) {
+    defineBuiltInAccessor(IteratorPrototype, key, {
+      configurable: true,
+      get: function () {
+        return value;
+      },
+      set: function (replacement) {
+        anObject(this);
+        if (this === IteratorPrototype) throw new $TypeError("You can't redefine this property");
+        if (hasOwn(this, key)) this[key] = replacement;
+        else createProperty(this, key, replacement);
+      }
+    });
+  } else IteratorPrototype[key] = value;
+};
+
+if (!hasOwn(IteratorPrototype, TO_STRING_TAG)) defineIteratorPrototypeAccessor(TO_STRING_TAG, ITERATOR);
+
+if (FORCED || !hasOwn(IteratorPrototype, CONSTRUCTOR) || IteratorPrototype[CONSTRUCTOR] === Object) {
+  defineIteratorPrototypeAccessor(CONSTRUCTOR, IteratorConstructor);
+}
+
+IteratorConstructor.prototype = IteratorPrototype;
+
+// `Iterator` constructor
+// https://tc39.es/ecma262/#sec-iterator
+$({ global: true, constructor: true, forced: FORCED }, {
+  Iterator: IteratorConstructor
+});
+
+
+/***/ }),
+
+/***/ 3149:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(7725);
+var call = __webpack_require__(3176);
+var iterate = __webpack_require__(6841);
+var aCallable = __webpack_require__(2481);
+var anObject = __webpack_require__(3162);
+var getIteratorDirect = __webpack_require__(6226);
+var iteratorClose = __webpack_require__(1380);
+var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(2229);
+
+var everyWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('every', TypeError);
+
+// `Iterator.prototype.every` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.every
+$({ target: 'Iterator', proto: true, real: true, forced: everyWithoutClosingOnEarlyError }, {
+  every: function every(predicate) {
+    anObject(this);
+    try {
+      aCallable(predicate);
+    } catch (error) {
+      iteratorClose(this, 'throw', error);
+    }
+
+    if (everyWithoutClosingOnEarlyError) return call(everyWithoutClosingOnEarlyError, this, predicate);
+
+    var record = getIteratorDirect(this);
+    var counter = 0;
+    return !iterate(record, function (value, stop) {
+      if (!predicate(value, counter++)) return stop();
+    }, { IS_RECORD: true, INTERRUPTED: true }).stopped;
+  }
+});
+
+
+/***/ }),
+
+/***/ 746:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(7725);
+var call = __webpack_require__(3176);
+var aCallable = __webpack_require__(2481);
+var anObject = __webpack_require__(3162);
+var getIteratorDirect = __webpack_require__(6226);
+var createIteratorProxy = __webpack_require__(7211);
+var callWithSafeIterationClosing = __webpack_require__(9836);
+var IS_PURE = __webpack_require__(4214);
+var iteratorClose = __webpack_require__(1380);
+var iteratorHelperThrowsOnInvalidIterator = __webpack_require__(6483);
+var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(2229);
+
+var FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !iteratorHelperThrowsOnInvalidIterator('filter', function () { /* empty */ });
+var filterWithoutClosingOnEarlyError = !IS_PURE && !FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR
+  && iteratorHelperWithoutClosingOnEarlyError('filter', TypeError);
+
+var FORCED = IS_PURE || FILTER_WITHOUT_THROWING_ON_INVALID_ITERATOR || filterWithoutClosingOnEarlyError;
+
+var IteratorProxy = createIteratorProxy(function () {
+  var iterator = this.iterator;
+  var predicate = this.predicate;
+  var next = this.next;
+  var result, done, value;
+  while (true) {
+    result = anObject(call(next, iterator));
+    done = this.done = !!result.done;
+    if (done) return;
+    value = result.value;
+    if (callWithSafeIterationClosing(iterator, predicate, [value, this.counter++], true)) return value;
+  }
+});
+
+// `Iterator.prototype.filter` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.filter
+$({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
+  filter: function filter(predicate) {
+    anObject(this);
+    try {
+      aCallable(predicate);
+    } catch (error) {
+      iteratorClose(this, 'throw', error);
+    }
+
+    if (filterWithoutClosingOnEarlyError) return call(filterWithoutClosingOnEarlyError, this, predicate);
+
+    return new IteratorProxy(getIteratorDirect(this), {
+      predicate: predicate
+    });
+  }
+});
+
+
+/***/ }),
+
+/***/ 4059:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(7725);
+var call = __webpack_require__(3176);
+var iterate = __webpack_require__(6841);
+var aCallable = __webpack_require__(2481);
+var anObject = __webpack_require__(3162);
+var getIteratorDirect = __webpack_require__(6226);
+var iteratorClose = __webpack_require__(1380);
+var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(2229);
+
+var findWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('find', TypeError);
+
+// `Iterator.prototype.find` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.find
+$({ target: 'Iterator', proto: true, real: true, forced: findWithoutClosingOnEarlyError }, {
+  find: function find(predicate) {
+    anObject(this);
+    try {
+      aCallable(predicate);
+    } catch (error) {
+      iteratorClose(this, 'throw', error);
+    }
+
+    if (findWithoutClosingOnEarlyError) return call(findWithoutClosingOnEarlyError, this, predicate);
+
+    var record = getIteratorDirect(this);
+    var counter = 0;
+    return iterate(record, function (value, stop) {
+      if (predicate(value, counter++)) return stop(value);
+    }, { IS_RECORD: true, INTERRUPTED: true }).result;
+  }
+});
+
+
+/***/ }),
+
+/***/ 1119:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(7725);
+var call = __webpack_require__(3176);
+var iterate = __webpack_require__(6841);
+var aCallable = __webpack_require__(2481);
+var anObject = __webpack_require__(3162);
+var getIteratorDirect = __webpack_require__(6226);
+var iteratorClose = __webpack_require__(1380);
+var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(2229);
+
+var forEachWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('forEach', TypeError);
+
+// `Iterator.prototype.forEach` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.foreach
+$({ target: 'Iterator', proto: true, real: true, forced: forEachWithoutClosingOnEarlyError }, {
+  forEach: function forEach(fn) {
+    anObject(this);
+    try {
+      aCallable(fn);
+    } catch (error) {
+      iteratorClose(this, 'throw', error);
+    }
+
+    if (forEachWithoutClosingOnEarlyError) return call(forEachWithoutClosingOnEarlyError, this, fn);
+
+    var record = getIteratorDirect(this);
+    var counter = 0;
+    iterate(record, function (value) {
+      fn(value, counter++);
+    }, { IS_RECORD: true });
+  }
+});
+
+
+/***/ }),
+
+/***/ 8660:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(7725);
+var call = __webpack_require__(3176);
+var aCallable = __webpack_require__(2481);
+var anObject = __webpack_require__(3162);
+var getIteratorDirect = __webpack_require__(6226);
+var createIteratorProxy = __webpack_require__(7211);
+var callWithSafeIterationClosing = __webpack_require__(9836);
+var iteratorClose = __webpack_require__(1380);
+var iteratorHelperThrowsOnInvalidIterator = __webpack_require__(6483);
+var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(2229);
+var IS_PURE = __webpack_require__(4214);
+
+var MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR = !IS_PURE && !iteratorHelperThrowsOnInvalidIterator('map', function () { /* empty */ });
+var mapWithoutClosingOnEarlyError = !IS_PURE && !MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR
+  && iteratorHelperWithoutClosingOnEarlyError('map', TypeError);
+
+var FORCED = IS_PURE || MAP_WITHOUT_THROWING_ON_INVALID_ITERATOR || mapWithoutClosingOnEarlyError;
+
+var IteratorProxy = createIteratorProxy(function () {
+  var iterator = this.iterator;
+  var result = anObject(call(this.next, iterator));
+  var done = this.done = !!result.done;
+  if (!done) return callWithSafeIterationClosing(iterator, this.mapper, [result.value, this.counter++], true);
+});
+
+// `Iterator.prototype.map` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.map
+$({ target: 'Iterator', proto: true, real: true, forced: FORCED }, {
+  map: function map(mapper) {
+    anObject(this);
+    try {
+      aCallable(mapper);
+    } catch (error) {
+      iteratorClose(this, 'throw', error);
+    }
+
+    if (mapWithoutClosingOnEarlyError) return call(mapWithoutClosingOnEarlyError, this, mapper);
+
+    return new IteratorProxy(getIteratorDirect(this), {
+      mapper: mapper
+    });
+  }
+});
+
+
+/***/ }),
+
+/***/ 882:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(7725);
+var iterate = __webpack_require__(6841);
+var aCallable = __webpack_require__(2481);
+var anObject = __webpack_require__(3162);
+var getIteratorDirect = __webpack_require__(6226);
+var iteratorClose = __webpack_require__(1380);
+var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(2229);
+var apply = __webpack_require__(5990);
+var fails = __webpack_require__(8930);
+
+var $TypeError = TypeError;
+
+// https://bugs.webkit.org/show_bug.cgi?id=291651
+var FAILS_ON_INITIAL_UNDEFINED = fails(function () {
+  // eslint-disable-next-line es/no-iterator-prototype-reduce, es/no-array-prototype-keys, array-callback-return -- required for testing
+  [].keys().reduce(function () { /* empty */ }, undefined);
+});
+
+var reduceWithoutClosingOnEarlyError = !FAILS_ON_INITIAL_UNDEFINED && iteratorHelperWithoutClosingOnEarlyError('reduce', $TypeError);
+
+// `Iterator.prototype.reduce` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.reduce
+$({ target: 'Iterator', proto: true, real: true, forced: FAILS_ON_INITIAL_UNDEFINED || reduceWithoutClosingOnEarlyError }, {
+  reduce: function reduce(reducer /* , initialValue */) {
+    anObject(this);
+    try {
+      aCallable(reducer);
+    } catch (error) {
+      iteratorClose(this, 'throw', error);
+    }
+
+    var noInitial = arguments.length < 2;
+    var accumulator = noInitial ? undefined : arguments[1];
+    if (reduceWithoutClosingOnEarlyError) {
+      return apply(reduceWithoutClosingOnEarlyError, this, noInitial ? [reducer] : [reducer, accumulator]);
+    }
+    var record = getIteratorDirect(this);
+    var counter = 0;
+    iterate(record, function (value) {
+      if (noInitial) {
+        noInitial = false;
+        accumulator = value;
+      } else {
+        accumulator = reducer(accumulator, value, counter);
+      }
+      counter++;
+    }, { IS_RECORD: true });
+    if (noInitial) throw new $TypeError('Reduce of empty iterator with no initial value');
+    return accumulator;
+  }
+});
+
+
+/***/ }),
+
+/***/ 5528:
+/***/ (function(__unused_webpack_module, __unused_webpack_exports, __webpack_require__) {
+
+
+var $ = __webpack_require__(7725);
+var call = __webpack_require__(3176);
+var iterate = __webpack_require__(6841);
+var aCallable = __webpack_require__(2481);
+var anObject = __webpack_require__(3162);
+var getIteratorDirect = __webpack_require__(6226);
+var iteratorClose = __webpack_require__(1380);
+var iteratorHelperWithoutClosingOnEarlyError = __webpack_require__(2229);
+
+var someWithoutClosingOnEarlyError = iteratorHelperWithoutClosingOnEarlyError('some', TypeError);
+
+// `Iterator.prototype.some` method
+// https://tc39.es/ecma262/#sec-iterator.prototype.some
+$({ target: 'Iterator', proto: true, real: true, forced: someWithoutClosingOnEarlyError }, {
+  some: function some(predicate) {
+    anObject(this);
+    try {
+      aCallable(predicate);
+    } catch (error) {
+      iteratorClose(this, 'throw', error);
+    }
+
+    if (someWithoutClosingOnEarlyError) return call(someWithoutClosingOnEarlyError, this, predicate);
+
+    var record = getIteratorDirect(this);
+    var counter = 0;
+    return iterate(record, function (value, stop) {
+      if (predicate(value, counter++)) return stop();
+    }, { IS_RECORD: true, INTERRUPTED: true }).stopped;
+  }
+});
+
+
+/***/ })
+
+/******/ 	});
+/************************************************************************/
+/******/ 	// The module cache
+/******/ 	var __webpack_module_cache__ = {};
+/******/ 	
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/ 		// Check if module is in cache
+/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
+/******/ 		if (cachedModule !== undefined) {
+/******/ 			return cachedModule.exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = __webpack_module_cache__[moduleId] = {
+/******/ 			// no module.id needed
+/******/ 			// no module.loaded needed
+/******/ 			exports: {}
+/******/ 		};
+/******/ 	
+/******/ 		// Execute the module function
+/******/ 		__webpack_modules__[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/ 	
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/ 	
+/************************************************************************/
+/******/ 	/* webpack/runtime/define property getters */
+/******/ 	!function() {
+/******/ 		// define getter functions for harmony exports
+/******/ 		__webpack_require__.d = function(exports, definition) {
+/******/ 			for(var key in definition) {
+/******/ 				if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
+/******/ 					Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
+/******/ 				}
+/******/ 			}
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/global */
+/******/ 	!function() {
+/******/ 		__webpack_require__.g = (function() {
+/******/ 			if (typeof globalThis === 'object') return globalThis;
+/******/ 			try {
+/******/ 				return this || new Function('return this')();
+/******/ 			} catch (e) {
+/******/ 				if (typeof window === 'object') return window;
+/******/ 			}
+/******/ 		})();
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/hasOwnProperty shorthand */
+/******/ 	!function() {
+/******/ 		__webpack_require__.o = function(obj, prop) { return Object.prototype.hasOwnProperty.call(obj, prop); }
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/make namespace object */
+/******/ 	!function() {
+/******/ 		// define __esModule on exports
+/******/ 		__webpack_require__.r = function(exports) {
+/******/ 			if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 				Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 			}
+/******/ 			Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 		};
+/******/ 	}();
+/******/ 	
+/******/ 	/* webpack/runtime/publicPath */
+/******/ 	!function() {
+/******/ 		__webpack_require__.p = "";
+/******/ 	}();
+/******/ 	
+/************************************************************************/
+var __webpack_exports__ = {};
+// ESM COMPAT FLAG
+__webpack_require__.r(__webpack_exports__);
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  VanillaGantt: function() { return /* reexport */ VanillaGantt; }
+});
+
+;// ./node_modules/.pnpm/@vue+cli-service@5.0.9_@vue+compiler-sfc@3.5.38_lodash@4.18.1_vue-template-compiler@2.7_c9972e4047f004f60ec0a5944100d8f4/node_modules/@vue/cli-service/lib/commands/build/setPublicPath.js
+/* eslint-disable no-var */
+// This file is imported into lib/wc client bundles.
+
+if (typeof window !== 'undefined') {
+  var currentScript = window.document.currentScript
+  if (false) // removed by dead control flow
+{ var getCurrentScript; }
+
+  var src = currentScript && currentScript.src.match(/(.+\/)[^/]+\.js(\?.*)?$/)
+  if (src) {
+    __webpack_require__.p = src[1] // eslint-disable-line
+  }
+}
+
+// Indicate to webpack that this file can be concatenated
+/* harmony default export */ var setPublicPath = (null);
+
+// EXTERNAL MODULE: ./node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.array.includes.js
+var es_array_includes = __webpack_require__(9690);
+// EXTERNAL MODULE: ./node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.array.push.js
+var es_array_push = __webpack_require__(4495);
+// EXTERNAL MODULE: ./node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.iterator.constructor.js
+var es_iterator_constructor = __webpack_require__(7622);
+// EXTERNAL MODULE: ./node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.iterator.every.js
+var es_iterator_every = __webpack_require__(3149);
+// EXTERNAL MODULE: ./node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.iterator.filter.js
+var es_iterator_filter = __webpack_require__(746);
+// EXTERNAL MODULE: ./node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.iterator.find.js
+var es_iterator_find = __webpack_require__(4059);
+// EXTERNAL MODULE: ./node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.iterator.for-each.js
+var es_iterator_for_each = __webpack_require__(1119);
+// EXTERNAL MODULE: ./node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.iterator.map.js
+var es_iterator_map = __webpack_require__(8660);
+// EXTERNAL MODULE: ./node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.iterator.reduce.js
+var es_iterator_reduce = __webpack_require__(882);
+// EXTERNAL MODULE: ./node_modules/.pnpm/core-js@3.49.0/node_modules/core-js/modules/es.iterator.some.js
+var es_iterator_some = __webpack_require__(5528);
+;// ./packages/gantt/src/vanilla-gantt.css
+// extracted by mini-css-extract-plugin
+
+;// ./packages/gantt/src/VanillaGantt.js
+
+
+
+
+
+
+
+
+
+
+
+const SVG_NS = 'http://www.w3.org/2000/svg';
+const HOUR = 60 * 60 * 1000;
+const DEFAULT_TASK_TOOLTIP = {
+  visible: true,
+  customLayout: null,
+  className: '',
+  offsetX: 12,
+  offsetY: 12
+};
+const DEFAULT_OPTIONS = {
+  records: [],
+  recordKeyField: 'id',
+  taskKeyField: 'id',
+  minDate: '',
+  maxDate: '',
+  rowHeight: 78,
+  taskHeight: 36,
+  headerRowHeight: 24,
+  taskListTable: {
+    tableWidth: 'auto',
+    minTableWidth: 120,
+    maxTableWidth: 640,
+    columnResizable: true,
+    headerStyle: null,
+    columns: [{
+      field: 'name',
+      title: '工位',
+      width: 170,
+      tree: true
+    }],
+    renderHeader: null,
+    renderCell: null
+  },
+  timelineHeader: {
+    backgroundColor: '#fff',
+    colWidth: 56,
+    style: null,
+    scales: [{
+      unit: 'day',
+      step: 1,
+      rowHeight: 24
+    }, {
+      unit: 'hour',
+      step: 2,
+      rowHeight: 24,
+      colWidth: 56
+    }]
+  },
+  taskBar: {
+    tasksField: 'tasks',
+    startDateField: 'startDate',
+    endDateField: 'endDate',
+    progressField: 'progress',
+    laneField: 'lane',
+    statusField: 'status',
+    labelText: 'title',
+    subLabelText: 'subtitle',
+    barStyle: null,
+    projectStyle: null,
+    customLayout: null,
+    clip: true,
+    draggable: true,
+    dragStep: 60 * 1000,
+    tooltip: false,
+    onClick: null,
+    onContextMenu: null,
+    onMouseEnter: null,
+    onMouseLeave: null,
+    onDragStart: null,
+    onDrag: null,
+    onDragEnd: null,
+    lanes: [{
+      key: 'plan',
+      offset: 8,
+      height: 36
+    }, {
+      key: 'load',
+      offset: 52,
+      height: 6
+    }, {
+      key: 'unload',
+      offset: 66,
+      height: 6
+    }]
+  },
+  dependency: {
+    links: [],
+    linkLineStyle: null,
+    showLinks: false,
+    highlightConnected: false,
+    dimOpacity: 0.18
+  },
+  grid: {
+    backgroundColor: '#f7fbfb',
+    alternatingBackgroundColor: '#f8fbfb',
+    verticalLine: {
+      lineColor: '#e8eeee'
+    },
+    horizontalLine: {
+      lineColor: '#edf1f2'
+    },
+    backgroundRanges: [],
+    rowBackgroundRanges: []
+  },
+  markLine: null,
+  onScroll: null
+};
+class VanillaGantt {
+  constructor(container, options = {}) {
+    this.container = typeof container === 'string' ? document.querySelector(container) : container;
+    if (!this.container) {
+      throw new Error('VanillaGantt requires a valid container.');
+    }
+    this.options = mergeOptions(DEFAULT_OPTIONS, options);
+    this.expandedRows = {};
+    this.scrollTop = 0;
+    this.scrollLeft = 0;
+    this.disposers = [];
+    this.activeDrag = null;
+    this.activeLinkTaskKey = null;
+    this.activeLinkGroupKey = null;
+    this.suppressClickUntil = 0;
+    this.suppressClickTaskKey = null;
+    this.seedExpandedRows(this.options.records);
+    this.render();
+  }
+  setOptions(options = {}) {
+    const previousRecords = this.options.records;
+    this.options = mergeOptions(this.options, options);
+    if (options.records && options.records !== previousRecords) {
+      this.seedExpandedRows(options.records, true);
+    }
+    this.render();
+  }
+  destroy() {
+    this.cleanup();
+    this.container.innerHTML = '';
+  }
+  cleanup() {
+    this.hideTaskTooltip();
+    this.disposers.forEach(dispose => dispose());
+    this.disposers = [];
+  }
+  render() {
+    this.cleanup();
+    const root = el('div', 'vg');
+    root.style.setProperty('--vg-left-width', `${this.tableWidth}px`);
+    this.rootEl = root;
+    const left = el('div', 'vg-left');
+    const right = el('div', 'vg-right');
+    left.append(this.renderLeftHeader(), this.renderLeftBody(), this.renderResizeHandle(root));
+    right.append(this.renderTimeline(), this.renderBody());
+    root.append(left, right);
+    this.container.innerHTML = '';
+    this.container.append(root);
+    if (this.scrollEl) {
+      this.scrollEl.scrollTop = this.scrollTop;
+      this.scrollEl.scrollLeft = this.scrollLeft;
+    }
+  }
+  renderLeftHeader() {
+    const header = el('div', 'vg-left-header');
+    header.style.height = `${this.headerHeight}px`;
+    header.style.gridTemplateColumns = this.tableGridTemplateColumns;
+    applyTableHeaderStyle(header, this.taskListTable.headerStyle);
+    this.leftHeaderEl = header;
+    const custom = this.resolveContent(this.taskListTable.renderHeader, {
+      gantt: this
+    });
+    if (custom) {
+      header.append(custom);
+    } else {
+      this.tableColumns.forEach((column, columnIndex) => {
+        header.append(this.renderTableHeaderCell(column, columnIndex));
+      });
+    }
+    return header;
+  }
+  renderTableHeaderCell(column, columnIndex) {
+    const cell = el('div', `vg-table-header-cell${column.className ? ` ${column.className}` : ''}`);
+    const headerStyle = {
+      ...(this.taskListTable.headerStyle || {}),
+      ...(column.headerStyle || {})
+    };
+    applyTableHeaderStyle(cell, headerStyle);
+    const content = el('div', 'vg-table-header-content');
+    content.style.justifyContent = alignToFlex(column.headerAlign || headerStyle.textAlign || column.align || 'left');
+    const custom = this.resolveContent(column.renderHeader, {
+      column,
+      columnIndex,
+      gantt: this
+    });
+    if (custom) {
+      content.append(custom);
+    } else {
+      content.textContent = column.title || column.field || '';
+    }
+    cell.append(content);
+    if (this.isColumnResizable(column)) {
+      cell.append(this.renderColumnResizeHandle(column, columnIndex));
+    }
+    return cell;
+  }
+  renderColumnResizeHandle(column, columnIndex) {
+    const handle = el('span', 'vg-column-resize-handle');
+    const onMouseDown = event => {
+      const startX = event.clientX;
+      const startWidth = this.columnWidth(column);
+      const onMove = moveEvent => {
+        const next = startWidth + moveEvent.clientX - startX;
+        this.resizeColumn(columnIndex, next);
+      };
+      const onUp = () => {
+        document.removeEventListener('mousemove', onMove);
+        document.removeEventListener('mouseup', onUp);
+      };
+      document.addEventListener('mousemove', onMove);
+      document.addEventListener('mouseup', onUp);
+      event.preventDefault();
+      event.stopPropagation();
+    };
+    handle.addEventListener('mousedown', onMouseDown);
+    this.disposers.push(() => handle.removeEventListener('mousedown', onMouseDown));
+    return handle;
+  }
+  resizeColumn(columnIndex, width) {
+    const sourceColumn = this.sourceTableColumns[columnIndex];
+    if (!sourceColumn) return;
+    const minWidth = Number(sourceColumn.minWidth || 48);
+    const maxWidth = Number(sourceColumn.maxWidth || 600);
+    sourceColumn.width = Math.min(maxWidth, Math.max(minWidth, Math.round(width)));
+    if (typeof this.taskListTable.tableWidth === 'number') {
+      this.taskListTable.tableWidth = this.sourceTableColumns.reduce((total, item) => total + this.columnWidth(item), 0);
+    }
+    this.syncTableLayout();
+  }
+  syncTableLayout() {
+    const width = this.tableWidth;
+    if (this.rootEl) this.rootEl.style.setProperty('--vg-left-width', `${width}px`);
+    if (this.leftHeaderEl) this.leftHeaderEl.style.gridTemplateColumns = this.tableGridTemplateColumns;
+    if (this.leftBodyInner) {
+      Array.from(this.leftBodyInner.children).forEach(row => {
+        row.style.gridTemplateColumns = this.tableGridTemplateColumns;
+      });
+    }
+  }
+  renderLeftBody() {
+    const body = el('div', 'vg-left-body');
+    const inner = el('div', 'vg-left-body-inner');
+    inner.style.height = `${this.bodyHeight}px`;
+    inner.style.transform = `translateY(-${this.scrollTop}px)`;
+    this.leftBodyInner = inner;
+    this.visibleRows.forEach(row => {
+      const rowEl = el('div', `vg-row${row.children ? ' vg-row--group' : ''}`);
+      rowEl.style.height = `${row.height || this.options.rowHeight}px`;
+      rowEl.style.gridTemplateColumns = this.tableGridTemplateColumns;
+      this.tableColumns.forEach((column, columnIndex) => {
+        rowEl.append(this.renderTableCell(row, column, columnIndex));
+      });
+      inner.append(rowEl);
+    });
+    body.append(inner);
+    const onWheel = event => {
+      if (!this.scrollEl || !event.deltaY) return;
+      this.scrollEl.scrollTop += event.deltaY;
+      event.preventDefault();
+    };
+    body.addEventListener('wheel', onWheel, {
+      passive: false
+    });
+    this.disposers.push(() => body.removeEventListener('wheel', onWheel));
+    return body;
+  }
+  renderTableCell(row, column, columnIndex) {
+    const cell = el('div', `vg-table-cell${column.className ? ` ${column.className}` : ''}`);
+    cell.style.justifyContent = alignToFlex(column.align || 'left');
+    const value = this.getCellValue(row, column, columnIndex);
+    const payload = {
+      value,
+      record: row,
+      row,
+      column,
+      columnIndex,
+      expanded: this.isExpanded(row),
+      toggle: () => this.toggleRow(row),
+      gantt: this
+    };
+    const custom = this.resolveContent(column.renderCell || this.taskListTable.renderCell, payload);
+    if (custom) {
+      cell.append(custom);
+      this.bindTemplateToggle(cell, row);
+      return cell;
+    }
+    if (this.isTreeColumn(column, columnIndex)) {
+      cell.append(this.renderTreeCell(row, value));
+    } else if (column.field === 'load') {
+      cell.append(this.renderLoadCell(row, value));
+    } else {
+      cell.textContent = value === undefined || value === null ? '' : String(value);
+    }
+    return cell;
+  }
+  renderTreeCell(row, value) {
+    const name = el('div', `vg-row-name${row.children ? ' vg-row-name--toggle' : ''}`);
+    name.style.paddingLeft = `${row.level * 16}px`;
+    if (row.children) {
+      const button = el('button', 'vg-row-toggle');
+      button.type = 'button';
+      button.setAttribute('aria-label', this.isExpanded(row) ? '收起' : '展开');
+      button.setAttribute('aria-expanded', String(this.isExpanded(row)));
+      if (this.isExpanded(row)) {
+        button.classList.add('vg-row-toggle--expanded');
+      }
+      name.append(button);
+      name.addEventListener('click', () => this.toggleRow(row));
+    }
+    name.append(document.createTextNode(value === undefined || value === null ? '' : String(value)));
+    return name;
+  }
+  renderLoadCell(row, value) {
+    const loadValue = value === undefined ? row.load : value;
+    if (loadValue === undefined || loadValue === null) return document.createTextNode('');
+    const load = el('div', 'vg-row-load');
+    const bar = el('i');
+    bar.style.width = `${loadValue}%`;
+    bar.style.background = this.loadColor(loadValue);
+    const valueNode = el('b');
+    valueNode.textContent = `${loadValue}%`;
+    valueNode.style.color = this.loadColor(loadValue);
+    load.append(bar, valueNode);
+    return load;
+  }
+  getCellValue(row, column, columnIndex) {
+    if (typeof column.valueGetter === 'function') {
+      return column.valueGetter({
+        record: row,
+        row,
+        column,
+        columnIndex,
+        gantt: this
+      });
+    }
+    return column.field ? row[column.field] : undefined;
+  }
+  isTreeColumn(column, columnIndex) {
+    return column.tree === true || column.tree !== false && columnIndex === 0 && column.field === 'name';
+  }
+  isColumnResizable(column) {
+    if (column.resizable === false) return false;
+    return this.taskListTable.columnResizable !== false;
+  }
+  bindTemplateToggle(root, row) {
+    if (!row.children) return;
+    root.querySelectorAll('[data-vg-toggle]').forEach(node => {
+      const onClick = event => {
+        event.preventDefault();
+        event.stopPropagation();
+        this.toggleRow(row);
+      };
+      node.addEventListener('click', onClick);
+      this.disposers.push(() => node.removeEventListener('click', onClick));
+    });
+  }
+  renderResizeHandle(root) {
+    const handle = el('span', 'vg-resize-handle');
+    const onMouseDown = event => {
+      const startX = event.clientX;
+      const startWidth = this.tableWidth;
+      const onMove = moveEvent => {
+        const next = startWidth + moveEvent.clientX - startX;
+        this.taskListTable.tableWidth = Math.min(this.taskListTable.maxTableWidth, Math.max(this.taskListTable.minTableWidth, next));
+        root.style.setProperty('--vg-left-width', `${this.taskListTable.tableWidth}px`);
+      };
+      const onUp = () => {
+        document.removeEventListener('mousemove', onMove);
+        document.removeEventListener('mouseup', onUp);
+      };
+      document.addEventListener('mousemove', onMove);
+      document.addEventListener('mouseup', onUp);
+      event.preventDefault();
+    };
+    handle.addEventListener('mousedown', onMouseDown);
+    this.disposers.push(() => handle.removeEventListener('mousedown', onMouseDown));
+    return handle;
+  }
+  renderTimeline() {
+    const viewport = el('div', 'vg-timeline-viewport');
+    viewport.style.height = `${this.headerHeight}px`;
+    if (this.timelineHeader.backgroundColor) {
+      viewport.style.background = this.timelineHeader.backgroundColor;
+    }
+    const stage = el('div', 'vg-timeline-stage');
+    stage.style.width = `${this.chartWidth}px`;
+    stage.style.transform = `translateX(-${this.scrollLeft}px)`;
+    this.timelineStage = stage;
+    const svg = svgEl('svg', 'vg-timeline-svg');
+    attrs(svg, {
+      width: this.chartWidth,
+      height: this.headerHeight,
+      viewBox: `0 0 ${this.chartWidth} ${this.headerHeight}`
+    });
+    if (this.timelineHeader.backgroundColor) {
+      svg.style.background = this.timelineHeader.backgroundColor;
+    }
+    let y = 0;
+    this.timelineUnitsByScale.forEach((units, scaleIndex) => {
+      const scale = this.timelineScales[scaleIndex];
+      const height = this.scaleRowHeight(scale);
+      units.forEach(unit => {
+        svg.append(this.renderTimelineUnit(unit, y, height, scale, scaleIndex));
+      });
+      y += height;
+    });
+    stage.append(svg);
+    viewport.append(stage);
+    return viewport;
+  }
+  renderTimelineUnit(unit, y, height, scale, scaleIndex) {
+    const fo = svgEl('foreignObject');
+    attrs(fo, {
+      x: unit.x,
+      y,
+      width: unit.width,
+      height
+    });
+    const custom = this.resolveContent(scale.customLayout || this.timelineHeader.customLayout, {
+      dateInfo: unit,
+      unit,
+      scale,
+      scaleIndex,
+      major: scaleIndex === 0,
+      gantt: this
+    });
+    const style = this.timelineCellStyle(scale);
+    if (custom) {
+      applyTimelineStyleToContent(custom, this.timelineCustomCellStyle(scale));
+      fo.append(custom);
+    } else {
+      const cell = el('div', `vg-timeline-cell${scaleIndex === 0 ? ' vg-timeline-cell--major' : ''}`);
+      applyTimelineStyle(cell, style);
+      cell.textContent = unit.label;
+      fo.append(cell);
+    }
+    return fo;
+  }
+  renderBody() {
+    const scroll = el('div', 'vg-scroll');
+    const stage = el('div', 'vg-stage');
+    stage.style.width = `${this.chartWidth}px`;
+    stage.style.minWidth = `${this.chartWidth}px`;
+    const svg = svgEl('svg', 'vg-svg');
+    attrs(svg, {
+      width: this.chartWidth,
+      height: this.bodyHeight,
+      viewBox: `0 0 ${this.chartWidth} ${this.bodyHeight}`
+    });
+    svg.append(this.renderDefs());
+    this.appendGrid(svg);
+    const onCanvasClick = () => {
+      if (this.clearActiveLinkGroup()) this.render();
+    };
+    svg.addEventListener('click', onCanvasClick);
+    this.disposers.push(() => svg.removeEventListener('click', onCanvasClick));
+    stage.append(svg);
+    scroll.append(stage);
+    const onScroll = () => {
+      this.scrollTop = scroll.scrollTop;
+      this.scrollLeft = scroll.scrollLeft;
+      if (this.leftBodyInner) {
+        this.leftBodyInner.style.transform = `translateY(-${this.scrollTop}px)`;
+      }
+      if (this.timelineStage) {
+        this.timelineStage.style.transform = `translateX(-${this.scrollLeft}px)`;
+      }
+      if (typeof this.options.onScroll === 'function') {
+        this.options.onScroll({
+          scrollLeft: this.scrollLeft,
+          scrollTop: this.scrollTop
+        });
+      }
+    };
+    scroll.addEventListener('scroll', onScroll);
+    this.disposers.push(() => scroll.removeEventListener('scroll', onScroll));
+    this.scrollEl = scroll;
+    return scroll;
+  }
+  renderDefs() {
+    const defs = svgEl('defs');
+    const pattern = svgEl('pattern');
+    attrs(pattern, {
+      id: 'vg-diagonal-stripe',
+      patternUnits: 'userSpaceOnUse',
+      width: 8,
+      height: 8
+    });
+    const path = svgEl('path');
+    attrs(path, {
+      d: 'M-2,2 l4,-4 M0,8 l8,-8 M6,10 l4,-4',
+      stroke: '#86ddd4',
+      'stroke-width': 1
+    });
+    pattern.append(path);
+    defs.append(pattern);
+    return defs;
+  }
+  appendGrid(svg) {
+    if (this.grid.backgroundColor) {
+      svg.append(this.rect(0, 0, this.chartWidth, this.bodyHeight, this.grid.backgroundColor));
+    }
+    this.backgroundShades.forEach(shade => {
+      svg.append(this.rect(shade.x, 0, shade.width, this.bodyHeight, shade.fill));
+    });
+    this.visibleBackgroundRanges.forEach(range => {
+      const rect = this.rect(this.timeToX(range.startDate), 0, this.durationWidth(range.startDate, range.endDate), this.bodyHeight, range.color || range.fill || '#edf1f1');
+      rect.setAttribute('opacity', range.opacity === undefined ? 1 : range.opacity);
+      svg.append(rect);
+    });
+    this.verticalLines.forEach((item, index) => {
+      const style = this.resolveStyle(this.grid.verticalLine, {
+        index,
+        dateIndex: index,
+        date: item.startDate,
+        ganttInstance: this
+      });
+      const line = this.line(item.x, 0, item.x, this.bodyHeight, style.lineColor || '#e8eeee');
+      this.applyLineStyle(line, style);
+      svg.append(line);
+    });
+    this.rowLines.forEach((item, index) => {
+      const style = this.resolveStyle(this.grid.horizontalLine, {
+        index,
+        ganttInstance: this
+      });
+      const line = this.line(0, item.y, this.chartWidth, item.y, style.lineColor || '#edf1f2');
+      this.applyLineStyle(line, style);
+      svg.append(line);
+    });
+    this.markLines.forEach(markLine => {
+      this.appendMarkLine(svg, markLine);
+    });
+    this.visibleRowBackgroundRanges.forEach(range => {
+      const rect = this.rect(this.timeToX(range.startDate), this.rowTop(range.recordKey) + (range.offsetY || 0), this.durationWidth(range.startDate, range.endDate), range.height || this.options.rowHeight, range.color || range.fill || '#dcf8c9');
+      rect.setAttribute('opacity', range.opacity === undefined ? 1 : range.opacity);
+      svg.append(rect);
+    });
+    this.stripedTasks.forEach(task => {
+      const rect = this.rect(this.timeToX(this.taskStart(task)), this.taskY(task), this.durationWidth(this.taskStart(task), this.taskEnd(task)), this.taskRenderHeight(task), 'url(#vg-diagonal-stripe)');
+      svg.append(rect);
+    });
+    this.renderTasks.forEach(task => {
+      svg.append(this.renderTask(task));
+    });
+    this.visibleLinks.forEach(link => {
+      this.appendLink(svg, link);
+    });
+  }
+  appendMarkLine(svg, markLine) {
+    const x = this.timeToX(markLine.date);
+    if (x < 0 || x > this.chartWidth) return;
+    const style = markLine.style || {};
+    const line = this.line(x, 0, x, this.bodyHeight, style.lineColor || '#35cce0');
+    this.applyLineStyle(line, {
+      lineDash: [4, 4],
+      ...style
+    });
+    svg.append(line);
+    if (!markLine.content) return;
+    const text = svgEl('text', 'vg-mark-line-text');
+    attrs(text, {
+      x: x + 6,
+      y: 16,
+      fill: markLine.contentStyle && markLine.contentStyle.color ? markLine.contentStyle.color : style.lineColor || '#35cce0'
+    });
+    text.textContent = markLine.content;
+    svg.append(text);
+  }
+  appendLink(svg, link) {
+    const from = this.taskLayoutByKey[link.from];
+    const to = this.taskLayoutByKey[link.to];
+    if (!from || !to) return;
+    const route = this.linkRoute(link.type, from, to);
+    const style = {
+      ...(this.dependency.linkLineStyle || {}),
+      ...(link.linkLineStyle || {})
+    };
+    const color = style.lineColor || link.color || '#168dff';
+    const path = this.path(route.d, color);
+    attrs(path, {
+      fill: 'none',
+      'stroke-linejoin': 'round',
+      'stroke-linecap': 'round'
+    });
+    this.applyLineStyle(path, {
+      lineWidth: 2,
+      ...style
+    });
+    if (link.dashed) path.setAttribute('stroke-dasharray', '6 4');
+    svg.append(path);
+    svg.append(this.circle(route.start.x, route.start.y, 4, color));
+    svg.append(this.arrow(route.end.x, route.end.y, route.direction, color));
+  }
+  linkRoute(type, from, to) {
+    const fromStart = from.x;
+    const fromEnd = from.x + from.width;
+    const toStart = to.x;
+    const toEnd = to.x + to.width;
+    const normalizedType = type || 'finish_to_start';
+    let start;
+    let end;
+    if (normalizedType === 'start_to_start') {
+      start = {
+        x: fromStart,
+        y: from.centerY
+      };
+      end = {
+        x: toStart,
+        y: to.centerY
+      };
+    } else if (normalizedType === 'finish_to_finish') {
+      start = {
+        x: fromEnd,
+        y: from.centerY
+      };
+      end = {
+        x: toEnd,
+        y: to.centerY
+      };
+    } else if (normalizedType === 'start_to_finish') {
+      start = {
+        x: fromStart,
+        y: from.centerY
+      };
+      end = {
+        x: toEnd,
+        y: to.centerY
+      };
+    } else {
+      start = {
+        x: fromEnd,
+        y: from.centerY
+      };
+      end = {
+        x: toStart,
+        y: to.centerY
+      };
+    }
+    const direction = end.x >= start.x ? 1 : -1;
+    const gap = Math.abs(end.x - start.x);
+    const elbow = direction > 0 ? start.x + Math.max(20, gap / 2) : start.x + 28;
+    return {
+      start,
+      end,
+      direction,
+      d: `M ${start.x} ${start.y} H ${elbow} V ${end.y} H ${end.x}`
+    };
+  }
+  renderTask(task) {
+    const width = this.durationWidth(this.taskStart(task), this.taskEnd(task));
+    const height = this.taskRenderHeight(task);
+    const fo = svgEl('foreignObject', 'vg-task-fo');
+    attrs(fo, {
+      x: this.timeToX(this.taskStart(task)),
+      y: this.taskY(task),
+      width,
+      height
+    });
+    const row = this.rowById[task.__rowId];
+    const payload = this.createTaskPayload(task, {
+      row,
+      width,
+      height,
+      x: this.timeToX(this.taskStart(task)),
+      y: this.taskY(task)
+    });
+    const custom = this.resolveContent(this.taskBar.customLayout, payload);
+    fo.append(custom || this.renderDefaultTask(task));
+    if (this.isTaskDimmed(task)) {
+      fo.classList.add('vg-task-fo--dimmed');
+      fo.style.opacity = String(this.dependency.dimOpacity === undefined ? 0.18 : this.dependency.dimOpacity);
+    }
+    this.bindTaskInteractions(fo, task);
+    return fo;
+  }
+  bindTaskInteractions(node, task) {
+    if (this.isTaskDraggable(task)) {
+      node.classList.add('vg-task-fo--draggable');
+    }
+    const onClick = event => {
+      const taskKey = this.taskKey(task);
+      if (this.suppressClickTaskKey === taskKey && Date.now() < this.suppressClickUntil) {
+        event.preventDefault();
+        event.stopPropagation();
+        return;
+      }
+      const shouldRender = this.activateTaskLinkGroup(task);
+      this.callTaskCallback('onClick', task, event);
+      event.stopPropagation();
+      if (shouldRender) this.render();
+    };
+    const onContextMenu = event => {
+      if (typeof this.taskBar.onContextMenu !== 'function') return;
+      event.preventDefault();
+      this.callTaskCallback('onContextMenu', task, event);
+    };
+    const onMouseEnter = event => {
+      this.callTaskCallback('onMouseEnter', task, event);
+      this.showTaskTooltip(task, event);
+    };
+    const onMouseMove = event => {
+      this.positionTaskTooltip(event);
+    };
+    const onMouseLeave = event => {
+      this.callTaskCallback('onMouseLeave', task, event);
+      this.hideTaskTooltip();
+    };
+    const onPointerDown = event => {
+      this.startTaskDrag(node, task, event);
+    };
+    node.addEventListener('click', onClick);
+    node.addEventListener('contextmenu', onContextMenu);
+    node.addEventListener('mouseenter', onMouseEnter);
+    node.addEventListener('mousemove', onMouseMove);
+    node.addEventListener('mouseleave', onMouseLeave);
+    node.addEventListener('pointerdown', onPointerDown);
+    this.disposers.push(() => {
+      node.removeEventListener('click', onClick);
+      node.removeEventListener('contextmenu', onContextMenu);
+      node.removeEventListener('mouseenter', onMouseEnter);
+      node.removeEventListener('mousemove', onMouseMove);
+      node.removeEventListener('mouseleave', onMouseLeave);
+      node.removeEventListener('pointerdown', onPointerDown);
+    });
+  }
+  startTaskDrag(node, task, event) {
+    if (!this.isTaskDraggable(task)) return;
+    if (event.button !== undefined && event.button !== 0) return;
+    if (event.target && event.target.closest && event.target.closest('[data-vg-no-drag]')) return;
+    const sourceTask = this.findSourceTask(task);
+    if (!sourceTask) return;
+    const startTime = toTime(this.taskStart(sourceTask));
+    const endTime = toTime(this.taskEnd(sourceTask));
+    if (!Number.isFinite(startTime) || !Number.isFinite(endTime)) return;
+    const startPayload = this.createTaskPayload(task, {
+      event,
+      sourceTask,
+      startDate: new Date(startTime),
+      endDate: new Date(endTime),
+      originalStartDate: new Date(startTime),
+      originalEndDate: new Date(endTime)
+    });
+    if (this.callTaskCallback('onDragStart', task, event, startPayload) === false) return;
+    this.hideTaskTooltip();
+    node.classList.add('vg-task-fo--dragging');
+    if (node.setPointerCapture && event.pointerId !== undefined) {
+      node.setPointerCapture(event.pointerId);
+    }
+    const drag = {
+      node,
+      task,
+      sourceTask,
+      pointerId: event.pointerId,
+      startClientX: event.clientX,
+      originalStartTime: startTime,
+      originalEndTime: endTime,
+      nextStartTime: startTime,
+      nextEndTime: endTime,
+      moved: false
+    };
+    this.activeDrag = drag;
+    const onMove = moveEvent => this.moveTaskDrag(moveEvent);
+    const onUp = upEvent => {
+      document.removeEventListener('pointermove', onMove);
+      document.removeEventListener('pointerup', onUp);
+      document.removeEventListener('pointercancel', onUp);
+      this.endTaskDrag(upEvent);
+    };
+    document.addEventListener('pointermove', onMove);
+    document.addEventListener('pointerup', onUp);
+    document.addEventListener('pointercancel', onUp);
+    this.disposers.push(() => {
+      document.removeEventListener('pointermove', onMove);
+      document.removeEventListener('pointerup', onUp);
+      document.removeEventListener('pointercancel', onUp);
+    });
+    event.preventDefault();
+    event.stopPropagation();
+  }
+  moveTaskDrag(event) {
+    const drag = this.activeDrag;
+    if (!drag) return;
+    if (drag.pointerId !== undefined && event.pointerId !== undefined && drag.pointerId !== event.pointerId) return;
+    const deltaX = event.clientX - drag.startClientX;
+    if (Math.abs(deltaX) < 2 && !drag.moved) return;
+    const deltaMs = this.snapDragDelta(deltaX / this.pxPerMs);
+    const nextRange = this.clampDragRange(drag.originalStartTime + deltaMs, drag.originalEndTime + deltaMs);
+    drag.nextStartTime = nextRange.start;
+    drag.nextEndTime = nextRange.end;
+    drag.moved = true;
+    drag.node.setAttribute('x', this.timeToX(nextRange.start));
+    this.callTaskCallback('onDrag', drag.task, event, this.createTaskPayload(drag.task, {
+      event,
+      sourceTask: drag.sourceTask,
+      startDate: new Date(nextRange.start),
+      endDate: new Date(nextRange.end),
+      originalStartDate: new Date(drag.originalStartTime),
+      originalEndDate: new Date(drag.originalEndTime)
+    }));
+    event.preventDefault();
+  }
+  endTaskDrag(event) {
+    const drag = this.activeDrag;
+    if (!drag) return;
+    this.activeDrag = null;
+    drag.node.classList.remove('vg-task-fo--dragging');
+    if (drag.node.releasePointerCapture && drag.pointerId !== undefined) {
+      try {
+        drag.node.releasePointerCapture(drag.pointerId);
+      } catch (error) {}
+    }
+    if (drag.moved) {
+      this.updateTaskTime(drag.sourceTask, drag.nextStartTime, drag.nextEndTime);
+      this.suppressClickTaskKey = this.taskKey(drag.task);
+      this.suppressClickUntil = Date.now() + 300;
+      this.callTaskCallback('onDragEnd', drag.task, event, this.createTaskPayload(drag.task, {
+        event,
+        sourceTask: drag.sourceTask,
+        startDate: new Date(drag.nextStartTime),
+        endDate: new Date(drag.nextEndTime),
+        originalStartDate: new Date(drag.originalStartTime),
+        originalEndDate: new Date(drag.originalEndTime)
+      }));
+      this.render();
+    }
+  }
+  showTaskTooltip(task, event) {
+    const tooltip = this.taskTooltip;
+    if (!tooltip || tooltip.visible === false) return;
+    const payload = this.createTaskPayload(task, {
+      event
+    });
+    const content = this.resolveContent(tooltip.customLayout, payload) || this.renderDefaultTaskTooltip(payload);
+    if (!content) return;
+    this.hideTaskTooltip();
+    const node = el('div', `vg-tooltip${tooltip.className ? ` ${tooltip.className}` : ''}`);
+    node.append(content);
+    document.body.append(node);
+    this.tooltipEl = node;
+    this.positionTaskTooltip(event);
+  }
+  positionTaskTooltip(event) {
+    if (!this.tooltipEl || !event) return;
+    const tooltip = this.taskTooltip || {};
+    const offsetX = tooltip.offsetX === undefined ? 12 : Number(tooltip.offsetX);
+    const offsetY = tooltip.offsetY === undefined ? 12 : Number(tooltip.offsetY);
+    const rect = this.tooltipEl.getBoundingClientRect();
+    const maxLeft = window.innerWidth - rect.width - 8;
+    const maxTop = window.innerHeight - rect.height - 8;
+    const left = Math.max(8, Math.min(maxLeft, event.clientX + offsetX));
+    const top = Math.max(8, Math.min(maxTop, event.clientY + offsetY));
+    this.tooltipEl.style.left = `${left}px`;
+    this.tooltipEl.style.top = `${top}px`;
+  }
+  hideTaskTooltip() {
+    if (!this.tooltipEl) return;
+    this.tooltipEl.remove();
+    this.tooltipEl = null;
+  }
+  renderDefaultTaskTooltip(payload) {
+    const root = el('div', 'vg-tooltip-default');
+    const title = el('div', 'vg-tooltip-title');
+    title.textContent = this.taskLabel(payload.task, this.taskBar.labelText);
+    const time = el('div', 'vg-tooltip-time');
+    time.textContent = `${formatDateTime(payload.startDate)} - ${formatDateTime(payload.endDate)}`;
+    root.append(title, time);
+    const subtitle = this.taskLabel(payload.task, this.taskBar.subLabelText);
+    if (subtitle) {
+      const meta = el('div', 'vg-tooltip-meta');
+      meta.textContent = subtitle;
+      root.append(meta);
+    }
+    return root;
+  }
+  createTaskPayload(task, extra = {}) {
+    const row = extra.row || this.rowById[task.__rowId];
+    const sourceTask = extra.sourceTask || this.findSourceTask(task) || task;
+    const startTime = extra.startDate ? extra.startDate.getTime() : toTime(this.taskStart(sourceTask));
+    const endTime = extra.endDate ? extra.endDate.getTime() : toTime(this.taskEnd(sourceTask));
+    const width = extra.width === undefined ? this.durationWidth(this.taskStart(task), this.taskEnd(task)) : extra.width;
+    const height = extra.height === undefined ? this.taskRenderHeight(task) : extra.height;
+    return {
+      taskRecord: sourceTask,
+      task,
+      sourceTask,
+      rowRecord: row,
+      row,
+      taskKey: this.taskKey(task),
+      rowKey: task.__rowId,
+      x: extra.x === undefined ? this.timeToX(this.taskStart(task)) : extra.x,
+      y: extra.y === undefined ? this.taskY(task) : extra.y,
+      width,
+      height,
+      startDate: new Date(startTime),
+      endDate: new Date(endTime),
+      originalStartDate: extra.originalStartDate,
+      originalEndDate: extra.originalEndDate,
+      progress: this.taskProgress(task),
+      event: extra.event,
+      ganttInstance: this,
+      gantt: this
+    };
+  }
+  callTaskCallback(name, task, event, payload) {
+    const callback = this.taskBar[name];
+    if (typeof callback !== 'function') return undefined;
+    return callback(payload || this.createTaskPayload(task, {
+      event
+    }));
+  }
+  isTaskDraggable(task) {
+    if (task.draggable !== undefined) return task.draggable !== false;
+    if (task.parentAggregate) return false;
+    const draggable = this.taskBar.draggable;
+    if (typeof draggable === 'function') {
+      return draggable(this.createTaskPayload(task)) !== false;
+    }
+    return draggable !== false;
+  }
+  findSourceTask(task) {
+    const rowKey = task.__rowId;
+    const taskKey = this.taskKey(task);
+    if (!rowKey || !taskKey) return null;
+    const record = this.findRecordByKey(rowKey);
+    const tasks = record && Array.isArray(record[this.taskBar.tasksField]) ? record[this.taskBar.tasksField] : [];
+    return tasks.find(item => this.taskKey(item) === taskKey) || null;
+  }
+  findRecordByKey(recordKey, records = this.options.records) {
+    for (const record of records || []) {
+      if (this.recordKey(record) === recordKey) return record;
+      if (record.children) {
+        const found = this.findRecordByKey(recordKey, record.children);
+        if (found) return found;
+      }
+    }
+    return null;
+  }
+  snapDragDelta(deltaMs) {
+    const step = Number(this.taskBar.dragStep || 0);
+    if (!step) return deltaMs;
+    return Math.round(deltaMs / step) * step;
+  }
+  clampDragRange(startTime, endTime) {
+    const duration = endTime - startTime;
+    if (duration >= this.rangeMs) {
+      return {
+        start: this.startTime,
+        end: this.endTime
+      };
+    }
+    let start = startTime;
+    let end = endTime;
+    if (start < this.startTime) {
+      start = this.startTime;
+      end = start + duration;
+    }
+    if (end > this.endTime) {
+      end = this.endTime;
+      start = end - duration;
+    }
+    return {
+      start,
+      end
+    };
+  }
+  updateTaskTime(task, startTime, endTime) {
+    const startField = this.taskBar.startDateField;
+    const endField = this.taskBar.endDateField;
+    task[startField] = this.createTimeValueLike(task[startField], startTime);
+    task[endField] = this.createTimeValueLike(task[endField], endTime);
+  }
+  createTimeValueLike(source, time) {
+    if (source instanceof Date) return new Date(time);
+    if (typeof source === 'number') return time;
+    return formatLocalDateTime(new Date(time));
+  }
+  renderDefaultTask(task) {
+    const status = this.taskStatus(task);
+    const root = el('div', `vg-task vg-task--${status || 'normal'}`);
+    const style = this.taskStyle(task);
+    this.applyTaskStyle(root, style, task);
+    const title = el('div', 'vg-task-title');
+    title.textContent = this.taskLabel(task, this.taskBar.labelText);
+    const meta = el('div', 'vg-task-meta');
+    meta.textContent = this.taskLabel(task, this.taskBar.subLabelText);
+    root.append(title, meta);
+    const progressValue = this.taskProgress(task);
+    if (progressValue !== undefined) {
+      const progress = el('div', 'vg-task-progress');
+      const bar = el('i');
+      bar.style.width = `${progressValue}%`;
+      if (style.completedBarColor) bar.style.background = style.completedBarColor;
+      progress.append(bar);
+      root.append(progress);
+    }
+    if (task.locked) {
+      const lock = el('span', 'vg-task-lock');
+      lock.textContent = '▣';
+      root.append(lock);
+    }
+    return root;
+  }
+  applyTaskStyle(node, style, task) {
+    if (!style) return;
+    const progressValue = this.taskProgress(task);
+    const background = progressValue >= 100 && style.completedBarColor ? style.completedBarColor : style.barColor;
+    if (background) node.style.background = background;
+    if (style.borderColor) node.style.borderColor = style.borderColor;
+    if (style.borderLineWidth !== undefined) node.style.borderWidth = `${style.borderLineWidth}px`;
+    if (style.borderWidth !== undefined) node.style.borderWidth = `${style.borderWidth}px`;
+    if (style.cornerRadius !== undefined) node.style.borderRadius = `${style.cornerRadius}px`;
+  }
+  rect(x, y, width, height, fill) {
+    const rect = svgEl('rect');
+    attrs(rect, {
+      x,
+      y,
+      width,
+      height,
+      fill
+    });
+    return rect;
+  }
+  line(x1, y1, x2, y2, stroke) {
+    const line = svgEl('line');
+    attrs(line, {
+      x1,
+      y1,
+      x2,
+      y2,
+      stroke
+    });
+    return line;
+  }
+  circle(cx, cy, r, fill) {
+    const circle = svgEl('circle');
+    attrs(circle, {
+      cx,
+      cy,
+      r,
+      fill
+    });
+    return circle;
+  }
+  path(d, stroke) {
+    const path = svgEl('path', 'vg-link-path');
+    attrs(path, {
+      d,
+      stroke
+    });
+    return path;
+  }
+  arrow(x, y, direction, fill) {
+    const arrow = svgEl('path', 'vg-link-arrow');
+    const d = direction >= 0 ? `M ${x} ${y} l -8 -4 v 8 Z` : `M ${x} ${y} l 8 -4 v 8 Z`;
+    attrs(arrow, {
+      d,
+      fill
+    });
+    return arrow;
+  }
+  applyLineStyle(line, style = {}) {
+    if (style.lineWidth !== undefined) line.setAttribute('stroke-width', style.lineWidth);
+    if (style.lineDash) line.setAttribute('stroke-dasharray', style.lineDash.join(' '));
+  }
+  resolveStyle(style, payload) {
+    if (typeof style === 'function') return style(payload) || {};
+    return style || {};
+  }
+  resolveContent(renderer, payload) {
+    if (typeof renderer !== 'function') return null;
+    const result = renderer(payload);
+    if (result === undefined || result === null) return null;
+    if (result instanceof Node) return result;
+    if (result.rootContainer instanceof Node) return result.rootContainer;
+    const template = document.createElement('template');
+    template.innerHTML = String(result).trim();
+    return template.content;
+  }
+  seedExpandedRows(records, applyExplicit = false) {
+    records.forEach(record => {
+      if (record.children) {
+        const key = this.recordKey(record);
+        if (applyExplicit && record.expanded !== undefined) {
+          this.expandedRows[key] = record.expanded !== false;
+        } else if (this.expandedRows[key] === undefined) {
+          this.expandedRows[key] = record.expanded !== false;
+        }
+        this.seedExpandedRows(record.children, applyExplicit);
+      }
+    });
+  }
+  isExpanded(row) {
+    return row.children ? this.expandedRows[this.recordKey(row)] !== false : false;
+  }
+  toggleRow(row) {
+    if (!row.children) return;
+    const key = this.recordKey(row);
+    this.expandedRows[key] = !this.isExpanded(row);
+    this.render();
+  }
+  recordKey(record) {
+    return record.__recordKey || record[this.options.recordKeyField];
+  }
+  taskKey(task) {
+    return task[this.options.taskKeyField];
+  }
+  taskStart(task) {
+    return task[this.taskBar.startDateField];
+  }
+  taskEnd(task) {
+    return task[this.taskBar.endDateField];
+  }
+  taskProgress(task) {
+    return task[this.taskBar.progressField];
+  }
+  taskLane(task) {
+    return task[this.taskBar.laneField];
+  }
+  taskStatus(task) {
+    return task[this.taskBar.statusField];
+  }
+  taskLabel(task, label) {
+    if (!label) return '';
+    if (typeof label === 'function') return label(task);
+    return task[label] === undefined ? String(label) : String(task[label]);
+  }
+  taskStyle(task) {
+    const style = task.parentAggregate ? this.taskBar.projectStyle : this.taskBar.barStyle;
+    return this.resolveStyle(style, {
+      taskRecord: task,
+      index: this.renderTasks.findIndex(item => this.taskKey(item) === this.taskKey(task)),
+      startDate: new Date(toTime(this.taskStart(task))),
+      endDate: new Date(toTime(this.taskEnd(task))),
+      ganttInstance: this
+    });
+  }
+  isTaskDimmed(task) {
+    if (!this.dependency.highlightConnected) return false;
+    const key = this.taskKey(task);
+    if (!key) return false;
+    if (!this.visibleLinks.length) return false;
+    return !this.connectedTaskKeys[key];
+  }
+  activateTaskLinkGroup(task) {
+    const taskKey = this.taskKey(task);
+    const groupKey = this.firstLinkGroupKeyByTask(taskKey);
+    const nextTaskKey = groupKey ? taskKey : null;
+    const changed = this.activeLinkTaskKey !== nextTaskKey || this.activeLinkGroupKey !== groupKey;
+    this.activeLinkTaskKey = nextTaskKey;
+    this.activeLinkGroupKey = groupKey;
+    return changed;
+  }
+  clearActiveLinkGroup() {
+    if (!this.activeLinkTaskKey && !this.activeLinkGroupKey) return false;
+    this.activeLinkTaskKey = null;
+    this.activeLinkGroupKey = null;
+    return true;
+  }
+  timeToX(value) {
+    return (toTime(value) - this.startTime) * this.pxPerMs;
+  }
+  durationWidth(start, end) {
+    return Math.max(this.taskMinWidth, this.timeToX(end) - this.timeToX(start));
+  }
+  rowTop(recordKey) {
+    let top = 0;
+    for (const row of this.visibleRows) {
+      if (this.recordKey(row) === recordKey) return top;
+      top += row.height || this.options.rowHeight;
+    }
+    return 0;
+  }
+  taskY(task) {
+    return this.rowTop(task.__rowId) + this.taskOffsetY(task);
+  }
+  taskOffsetY(task) {
+    if (task.parentAggregate && task.offsetY !== undefined) return task.offsetY;
+    const lane = this.taskLane(task);
+    if (lane && this.laneByKey[lane]) return this.laneByKey[lane].offset;
+    return task.offsetY === undefined ? 10 : task.offsetY;
+  }
+  taskRenderHeight(task) {
+    if (task.parentAggregate && task.height !== undefined) return task.height;
+    const lane = this.taskLane(task);
+    if (lane && this.laneByKey[lane]) return this.laneByKey[lane].height;
+    if (task.height) return task.height;
+    const style = this.taskStyle(task);
+    return style.width || this.options.taskHeight;
+  }
+  createUnits(scale, scaleIndex) {
+    const units = [];
+    const unit = scale.unit || 'hour';
+    const step = scale.step || 1;
+    let cursor = this.floorDate(new Date(this.startTime), unit, scale.startOfWeek);
+    let dateIndex = 0;
+    while (cursor.getTime() < this.endTime) {
+      const unitStart = Math.max(cursor.getTime(), this.startTime);
+      const next = this.addUnit(cursor, unit, step);
+      const unitEnd = Math.min(next.getTime(), this.endTime);
+      if (unitEnd > unitStart) {
+        const info = {
+          type: unit,
+          unit,
+          step,
+          scaleIndex,
+          dateIndex,
+          key: `${unit}-${cursor.toISOString()}`,
+          title: this.formatUnitLabel(cursor, unit),
+          startDate: new Date(unitStart),
+          endDate: new Date(unitEnd),
+          days: Math.max(1, Math.ceil((unitEnd - unitStart) / (24 * HOUR))),
+          x: this.timeToX(unitStart),
+          width: Math.max(1, this.timeToX(unitEnd) - this.timeToX(unitStart))
+        };
+        info.label = this.formatTimelineLabel(scale, info);
+        units.push(info);
+        dateIndex += 1;
+      }
+      cursor = next;
+    }
+    return units;
+  }
+  formatTimelineLabel(scale, dateInfo) {
+    if (typeof scale.format === 'function') {
+      return scale.format(dateInfo);
+    }
+    return this.formatUnitLabel(dateInfo.startDate, scale.unit);
+  }
+  floorDate(date, unit, startOfWeek = 'monday') {
+    const next = new Date(date);
+    next.setSeconds(0, 0);
+    if (unit !== 'minute') next.setMinutes(0);
+    if (!['minute', 'hour'].includes(unit)) next.setHours(0);
+    if (unit === 'week') {
+      const day = next.getDay() || 7;
+      const offset = startOfWeek === 'sunday' ? next.getDay() : day - 1;
+      next.setDate(next.getDate() - offset);
+    }
+    if (unit === 'month') next.setDate(1);
+    if (unit === 'year') {
+      next.setMonth(0);
+      next.setDate(1);
+    }
+    return next;
+  }
+  addUnit(date, unit, step = 1) {
+    const next = new Date(date);
+    if (unit === 'minute') next.setMinutes(next.getMinutes() + step);else if (unit === 'hour') next.setHours(next.getHours() + step);else if (unit === 'day') next.setDate(next.getDate() + step);else if (unit === 'week') next.setDate(next.getDate() + 7 * step);else if (unit === 'month') next.setMonth(next.getMonth() + step);else if (unit === 'year') next.setFullYear(next.getFullYear() + step);
+    return next;
+  }
+  unitToMs(unit) {
+    if (unit === 'year') return 365 * 24 * HOUR;
+    if (unit === 'month') return 30 * 24 * HOUR;
+    if (unit === 'week') return 7 * 24 * HOUR;
+    if (unit === 'day') return 24 * HOUR;
+    if (unit === 'minute') return 60 * 1000;
+    return HOUR;
+  }
+  formatUnitLabel(date, unit) {
+    const month = String(date.getMonth() + 1).padStart(2, '0');
+    const day = String(date.getDate()).padStart(2, '0');
+    if (unit === 'year') return `${date.getFullYear()}`;
+    if (unit === 'month') return `${date.getFullYear()}-${month}`;
+    if (unit === 'week') return `${month}-${day}周`;
+    if (unit === 'day') return `${month}-${day}`;
+    if (unit === 'minute') return `${String(date.getHours()).padStart(2, '0')}:${String(date.getMinutes()).padStart(2, '0')}`;
+    return String(date.getHours()).padStart(2, '0');
+  }
+  scaleRowHeight(scale) {
+    return scale.rowHeight || this.options.headerRowHeight;
+  }
+  timelineCellStyle(scale) {
+    const style = {
+      ...(this.timelineHeader.style || {}),
+      ...(scale.style || {})
+    };
+    if (!style.backgroundColor && this.timelineHeader.backgroundColor) {
+      style.backgroundColor = this.timelineHeader.backgroundColor;
+    }
+    return style;
+  }
+  timelineCustomCellStyle(scale) {
+    return {
+      ...(this.timelineHeader.style || {}),
+      ...(scale.style || {})
+    };
+  }
+  getDescendantRecordKeys(row) {
+    const ids = [];
+    const walk = children => {
+      children.forEach(child => {
+        ids.push(this.recordKey(child));
+        if (child.children) walk(child.children);
+      });
+    };
+    walk(row.children || []);
+    return ids;
+  }
+  overlapsRange(start, end) {
+    return toTime(end) > this.startTime && toTime(start) < this.endTime;
+  }
+  isPrimaryTask(task) {
+    if (task.logistics) return false;
+    const lane = this.taskLane(task);
+    if (!lane) return true;
+    return lane === 'plan' || String(lane).startsWith('plan-');
+  }
+  isExpandedParentRow(recordKey) {
+    const row = this.rowById[recordKey];
+    return row && row.children && this.isExpanded(row);
+  }
+  aggregateWorkStatus(tasks) {
+    if (tasks.some(task => task.workStatus === 'severe-delay')) return 'severe-delay';
+    if (tasks.some(task => task.workStatus === 'slight-delay')) return 'slight-delay';
+    if (tasks.every(task => task.workStatus === 'not-started')) return 'not-started';
+    return 'progress-normal';
+  }
+  loadColor(load) {
+    if (load >= 90) return '#ff4d5a';
+    if (load >= 70) return '#f7a600';
+    return '#43c51a';
+  }
+  get taskListTable() {
+    return this.options.taskListTable || {};
+  }
+  get timelineHeader() {
+    return this.options.timelineHeader || {};
+  }
+  get taskBar() {
+    return this.options.taskBar || {};
+  }
+  get taskTooltip() {
+    const tooltip = this.taskBar.tooltip;
+    if (tooltip === false || tooltip === undefined || tooltip === null) return null;
+    if (tooltip === true) return DEFAULT_TASK_TOOLTIP;
+    return {
+      ...DEFAULT_TASK_TOOLTIP,
+      ...tooltip
+    };
+  }
+  get dependency() {
+    return this.options.dependency || {};
+  }
+  get grid() {
+    return this.options.grid || {};
+  }
+  get tableWidth() {
+    if (typeof this.taskListTable.tableWidth === 'number') return this.taskListTable.tableWidth;
+    return this.tableColumns.reduce((total, column) => total + this.columnWidth(column), 0);
+  }
+  get tableColumns() {
+    return this.sourceTableColumns.map(column => ({
+      width: 120,
+      ...column
+    }));
+  }
+  get sourceTableColumns() {
+    return this.taskListTable.columns && this.taskListTable.columns.length ? this.taskListTable.columns : DEFAULT_OPTIONS.taskListTable.columns;
+  }
+  get tableGridTemplateColumns() {
+    return this.tableColumns.map((column, index) => {
+      const width = this.columnWidth(column);
+      if (index === this.tableColumns.length - 1) return `minmax(${width}px, 1fr)`;
+      return `${width}px`;
+    }).join(' ');
+  }
+  columnWidth(column) {
+    return Number(column.width || column.minWidth || 120);
+  }
+  get startTime() {
+    const value = this.options.minDate || this.derivedStartTime;
+    return toTime(value);
+  }
+  get endTime() {
+    const value = this.options.maxDate || this.derivedEndTime;
+    return toTime(value);
+  }
+  get derivedStartTime() {
+    const values = this.allTasks.map(task => toTime(this.taskStart(task))).filter(Number.isFinite);
+    return values.length ? Math.min(...values) : Date.now();
+  }
+  get derivedEndTime() {
+    const values = this.allTasks.map(task => toTime(this.taskEnd(task))).filter(Number.isFinite);
+    return values.length ? Math.max(...values) : this.derivedStartTime + 24 * HOUR;
+  }
+  get headerHeight() {
+    return this.timelineScales.reduce((total, scale) => total + this.scaleRowHeight(scale), 0);
+  }
+  get bodyHeight() {
+    return this.visibleRows.reduce((height, row) => height + (row.height || this.options.rowHeight), 0);
+  }
+  get rangeMs() {
+    return Math.max(1, this.endTime - this.startTime);
+  }
+  get baseTimelineScale() {
+    const scales = this.timelineScales;
+    return scales[scales.length - 1] || DEFAULT_OPTIONS.timelineHeader.scales[1];
+  }
+  get scaleMs() {
+    return this.unitToMs(this.baseTimelineScale.unit) * (this.baseTimelineScale.step || 1);
+  }
+  get scalePx() {
+    return this.baseTimelineScale.colWidth || this.timelineHeader.colWidth || DEFAULT_OPTIONS.timelineHeader.colWidth;
+  }
+  get pxPerMs() {
+    return this.scalePx / this.scaleMs;
+  }
+  get chartWidth() {
+    return Math.max(1, Math.ceil(this.rangeMs / this.scaleMs * this.scalePx));
+  }
+  get timelineScales() {
+    return (this.timelineHeader.scales || []).filter(scale => scale.visible !== false);
+  }
+  get timelineUnitsByScale() {
+    return this.timelineScales.map((scale, index) => this.createUnits(scale, index));
+  }
+  get majorUnits() {
+    return this.timelineUnitsByScale[0] || [];
+  }
+  get baseUnits() {
+    const units = this.timelineUnitsByScale;
+    return units[units.length - 1] || [];
+  }
+  get verticalLines() {
+    return this.baseUnits.map(unit => ({
+      key: `line-${unit.key}`,
+      x: unit.x,
+      startDate: unit.startDate
+    }));
+  }
+  get rowLines() {
+    let top = 0;
+    return this.visibleRows.map(row => {
+      top += row.height || this.options.rowHeight;
+      return {
+        key: this.recordKey(row),
+        y: top
+      };
+    });
+  }
+  get backgroundShades() {
+    const fill = this.grid.alternatingBackgroundColor;
+    if (!fill) return [];
+    return this.majorUnits.filter((unit, index) => index % 2 === 0).map(unit => ({
+      key: `shade-${unit.key}`,
+      x: unit.x,
+      width: unit.width,
+      fill
+    }));
+  }
+  get flatRows() {
+    const rows = [];
+    const walk = (items, level = 0) => {
+      items.forEach(record => {
+        rows.push({
+          ...record,
+          __recordKey: this.recordKey(record),
+          level
+        });
+        if (record.children) walk(record.children, level + 1);
+      });
+    };
+    walk(this.options.records);
+    return rows;
+  }
+  get visibleRows() {
+    const rows = [];
+    const walk = (items, level = 0) => {
+      items.forEach(record => {
+        const normalized = {
+          ...record,
+          __recordKey: this.recordKey(record),
+          level
+        };
+        rows.push(normalized);
+        if (record.children && this.isExpanded(normalized)) {
+          walk(record.children, level + 1);
+        }
+      });
+    };
+    walk(this.options.records);
+    return rows;
+  }
+  get visibleRowIds() {
+    return this.visibleRows.reduce((ids, row) => {
+      ids[this.recordKey(row)] = true;
+      return ids;
+    }, {});
+  }
+  get rowById() {
+    return this.flatRows.reduce((map, row) => {
+      map[this.recordKey(row)] = row;
+      return map;
+    }, {});
+  }
+  get laneByKey() {
+    return (this.taskBar.lanes || []).reduce((map, lane) => {
+      map[lane.key] = lane;
+      return map;
+    }, {});
+  }
+  get allTasks() {
+    const tasks = [];
+    const tasksField = this.taskBar.tasksField;
+    const walk = records => {
+      records.forEach(record => {
+        const recordKey = this.recordKey(record);
+        const rowTasks = Array.isArray(record[tasksField]) ? record[tasksField] : [];
+        rowTasks.forEach(task => {
+          tasks.push({
+            ...task,
+            __rowId: recordKey
+          });
+        });
+        if (record.children) walk(record.children);
+      });
+    };
+    walk(this.options.records);
+    return tasks;
+  }
+  get renderTasks() {
+    return [...this.parentTimelineTasks, ...this.visibleTasks];
+  }
+  get stripedTasks() {
+    return this.renderTasks.filter(task => task.striped);
+  }
+  get visibleTasks() {
+    return this.allTasks.filter(task => {
+      const row = this.rowById[task.__rowId];
+      return row && !row.children && this.visibleRowIds[task.__rowId] && this.overlapsRange(this.taskStart(task), this.taskEnd(task));
+    });
+  }
+  get parentTimelineTasks() {
+    const tasks = [];
+    this.visibleRows.forEach(row => {
+      if (!row.children || this.isExpanded(row)) return;
+      const descendantIds = this.getDescendantRecordKeys(row);
+      const childTasks = this.allTasks.filter(task => {
+        return descendantIds.includes(task.__rowId) && this.isPrimaryTask(task) && this.overlapsRange(this.taskStart(task), this.taskEnd(task));
+      });
+      if (!childTasks.length) return;
+      const start = Math.min(...childTasks.map(task => toTime(this.taskStart(task))));
+      const end = Math.max(...childTasks.map(task => toTime(this.taskEnd(task))));
+      const progressTasks = childTasks.filter(task => this.taskProgress(task) !== undefined);
+      const progress = progressTasks.length ? Math.round(progressTasks.reduce((total, task) => total + this.taskProgress(task), 0) / progressTasks.length) : undefined;
+      tasks.push({
+        [this.options.taskKeyField]: `${this.recordKey(row)}__aggregate`,
+        [this.taskBar.startDateField]: start,
+        [this.taskBar.endDateField]: end,
+        [this.taskBar.progressField]: progress,
+        [this.taskBar.statusField]: this.taskStatus(childTasks[0]),
+        title: row.name,
+        subtitle: `${childTasks.length} 个工单`,
+        workStatus: this.aggregateWorkStatus(childTasks),
+        completed: childTasks.every(task => task.completed),
+        predecessorIncomplete: childTasks.some(task => task.predecessorIncomplete),
+        height: Math.max(28, (row.height || this.options.rowHeight) - 12),
+        offsetY: 6,
+        parentAggregate: true,
+        __rowId: this.recordKey(row)
+      });
+    });
+    return tasks;
+  }
+  get visibleBackgroundRanges() {
+    return (this.grid.backgroundRanges || []).filter(range => {
+      return toTime(range.endDate) > this.startTime && toTime(range.startDate) < this.endTime;
+    });
+  }
+  get visibleRowBackgroundRanges() {
+    return (this.grid.rowBackgroundRanges || []).filter(range => {
+      return this.visibleRowIds[range.recordKey] && !this.isExpandedParentRow(range.recordKey) && toTime(range.endDate) > this.startTime && toTime(range.startDate) < this.endTime;
+    });
+  }
+  get markLines() {
+    if (!this.options.markLine || this.options.markLine === true) return [];
+    return Array.isArray(this.options.markLine) ? this.options.markLine : [this.options.markLine];
+  }
+  get taskLayoutByKey() {
+    return this.renderTasks.reduce((map, task) => {
+      const key = this.taskKey(task);
+      if (!key) return map;
+      const y = this.taskY(task);
+      const height = this.taskRenderHeight(task);
+      map[key] = {
+        task,
+        x: this.timeToX(this.taskStart(task)),
+        y,
+        width: this.durationWidth(this.taskStart(task), this.taskEnd(task)),
+        height,
+        centerY: y + height / 2
+      };
+      return map;
+    }, {});
+  }
+  get visibleLinks() {
+    return this.activeNormalizedLinks.filter(link => {
+      return this.taskLayoutByKey[link.from] && this.taskLayoutByKey[link.to];
+    });
+  }
+  get activeNormalizedLinks() {
+    if (this.activeLinkGroupKey) {
+      return this.normalizedLinks.filter(link => link.__groupKey === this.activeLinkGroupKey);
+    }
+    return this.dependency.showLinks === true ? this.normalizedLinks : [];
+  }
+  get normalizedLinks() {
+    const links = [];
+    (this.dependency.links || []).forEach((link, linkIndex) => {
+      const fromKeys = toKeyList(link.from);
+      const toKeys = toKeyList(link.to);
+      const groupKey = link.id === undefined || link.id === null ? `link-${linkIndex}` : String(link.id);
+      fromKeys.forEach(from => {
+        toKeys.forEach(to => {
+          if (from === undefined || from === null || to === undefined || to === null) return;
+          links.push({
+            ...link,
+            from,
+            to,
+            __groupKey: groupKey
+          });
+        });
+      });
+    });
+    return links;
+  }
+  firstLinkGroupKeyByTask(taskKey) {
+    if (taskKey === undefined || taskKey === null) return null;
+    const link = this.normalizedLinks.find(item => item.from === taskKey || item.to === taskKey);
+    return link ? link.__groupKey : null;
+  }
+  get connectedTaskKeys() {
+    return this.visibleLinks.reduce((map, link) => {
+      map[link.from] = true;
+      map[link.to] = true;
+      return map;
+    }, {});
+  }
+  get taskMinWidth() {
+    if (typeof this.taskBar.barStyle === 'function') return 4;
+    const style = this.resolveStyle(this.taskBar.barStyle, {});
+    return style.minSize || 4;
+  }
+}
+function mergeOptions(base, patch) {
+  const baseTaskBar = base.taskBar || {};
+  const patchTaskBar = patch.taskBar || {};
+  return {
+    ...base,
+    ...patch,
+    taskListTable: {
+      ...(base.taskListTable || {}),
+      ...(patch.taskListTable || {})
+    },
+    timelineHeader: {
+      ...(base.timelineHeader || {}),
+      ...(patch.timelineHeader || {}),
+      scales: patch.timelineHeader && patch.timelineHeader.scales ? patch.timelineHeader.scales : base.timelineHeader && base.timelineHeader.scales || []
+    },
+    taskBar: {
+      ...baseTaskBar,
+      ...patchTaskBar,
+      tooltip: mergeNestedOption(baseTaskBar.tooltip, patchTaskBar.tooltip),
+      lanes: patchTaskBar.lanes ? patchTaskBar.lanes : baseTaskBar.lanes || []
+    },
+    dependency: {
+      ...(base.dependency || {}),
+      ...(patch.dependency || {}),
+      links: patch.dependency && patch.dependency.links ? patch.dependency.links : base.dependency && base.dependency.links || []
+    },
+    grid: {
+      ...(base.grid || {}),
+      ...(patch.grid || {}),
+      backgroundRanges: patch.grid && patch.grid.backgroundRanges ? patch.grid.backgroundRanges : base.grid && base.grid.backgroundRanges || [],
+      rowBackgroundRanges: patch.grid && patch.grid.rowBackgroundRanges ? patch.grid.rowBackgroundRanges : base.grid && base.grid.rowBackgroundRanges || []
+    },
+    records: patch.records || base.records || []
+  };
+}
+function mergeNestedOption(base, patch) {
+  if (patch === undefined) return base;
+  if (patch === false || patch === true || patch === null) return patch;
+  if (typeof patch === 'object' && !Array.isArray(patch)) {
+    return {
+      ...(typeof base === 'object' && base ? base : {}),
+      ...patch
+    };
+  }
+  return patch;
+}
+function applyTableHeaderStyle(node, style = {}) {
+  if (!style) return;
+  if (style.backgroundColor) node.style.background = style.backgroundColor;
+  if (style.color) node.style.color = style.color;
+  if (style.fontSize) node.style.fontSize = `${style.fontSize}px`;
+  if (style.fontWeight) node.style.fontWeight = style.fontWeight;
+}
+function applyTimelineStyle(node, style = {}) {
+  if (style.backgroundColor) node.style.background = style.backgroundColor;
+  if (style.color) node.style.color = style.color;
+  if (style.fontSize) node.style.fontSize = `${style.fontSize}px`;
+  if (style.fontWeight) node.style.fontWeight = style.fontWeight;
+  if (style.textAlign) node.style.justifyContent = alignToFlex(style.textAlign);
+}
+function applyTimelineStyleToContent(content, style = {}) {
+  if (!style || !Object.keys(style).length) return;
+  const target = content.nodeType === 11 ? content.firstElementChild : content;
+  if (target instanceof HTMLElement) {
+    applyTimelineStyle(target, style);
+  }
+}
+function alignToFlex(value) {
+  if (value === 'left' || value === 'start') return 'flex-start';
+  if (value === 'right' || value === 'end') return 'flex-end';
+  return 'center';
+}
+function toKeyList(value) {
+  if (Array.isArray(value)) return value;
+  if (value === undefined || value === null) return [];
+  return [value];
+}
+function el(tag, className = '') {
+  const node = document.createElement(tag);
+  if (className) node.className = className;
+  return node;
+}
+function svgEl(tag, className = '') {
+  const node = document.createElementNS(SVG_NS, tag);
+  if (className) node.setAttribute('class', className);
+  return node;
+}
+function attrs(node, values) {
+  Object.keys(values).forEach(key => {
+    if (values[key] !== undefined && values[key] !== null) {
+      node.setAttribute(key, values[key]);
+    }
+  });
+}
+function toTime(value) {
+  if (typeof value === 'number') return value;
+  if (value instanceof Date) return value.getTime();
+  return new Date(value).getTime();
+}
+function formatDateTime(date) {
+  const value = date instanceof Date ? date : new Date(date);
+  const month = String(value.getMonth() + 1).padStart(2, '0');
+  const day = String(value.getDate()).padStart(2, '0');
+  const hour = String(value.getHours()).padStart(2, '0');
+  const minute = String(value.getMinutes()).padStart(2, '0');
+  return `${value.getFullYear()}-${month}-${day} ${hour}:${minute}`;
+}
+function formatLocalDateTime(date) {
+  const value = date instanceof Date ? date : new Date(date);
+  const month = String(value.getMonth() + 1).padStart(2, '0');
+  const day = String(value.getDate()).padStart(2, '0');
+  const hour = String(value.getHours()).padStart(2, '0');
+  const minute = String(value.getMinutes()).padStart(2, '0');
+  const second = String(value.getSeconds()).padStart(2, '0');
+  return `${value.getFullYear()}-${month}-${day}T${hour}:${minute}:${second}`;
+}
+;// ./packages/gantt/src/index.js
+
+;// ./node_modules/.pnpm/@vue+cli-service@5.0.9_@vue+compiler-sfc@3.5.38_lodash@4.18.1_vue-template-compiler@2.7_c9972e4047f004f60ec0a5944100d8f4/node_modules/@vue/cli-service/lib/commands/build/entry-lib-no-default.js
+
+
+
+module.exports = __webpack_exports__;
+/******/ })()
+;
+//# sourceMappingURL=VanillaGantt.common.js.map