diff --git a/dist/editor/extensions/allowedMimeTypes.php b/dist/editor/extensions/allowedMimeTypes.php deleted file mode 100644 index 2f99b159..00000000 --- a/dist/editor/extensions/allowedMimeTypes.php +++ /dev/null @@ -1,12 +0,0 @@ - 'image/svg+xml;charset=UTF-8', - 'png' => 'image/png', - 'jpeg' => 'image/jpeg', - 'bmp' => 'image/bmp', - 'webp' => 'image/webp', - 'pdf' => 'application/pdf' -); - -?> diff --git a/dist/editor/extensions/closepath_icons.svg b/dist/editor/extensions/closepath_icons.svg deleted file mode 100644 index b103a6ee..00000000 --- a/dist/editor/extensions/closepath_icons.svg +++ /dev/null @@ -1,41 +0,0 @@ - - - - - Layer 1 - - - - - - - - - - - - - - - - - Layer 1 - - - - - - - - - - - - - - - - - - - diff --git a/dist/editor/extensions/ext-arrows.js b/dist/editor/extensions/ext-arrows.js index 878d53a4..2b22cb0c 100644 --- a/dist/editor/extensions/ext-arrows.js +++ b/dist/editor/extensions/ext-arrows.js @@ -1,3 +1,1651 @@ +function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); +} + +var REACT_ELEMENT_TYPE; + +function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; +} + +function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); +} + +function _AwaitValue(value) { + this.wrapped = value; +} + +function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } +} + +if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; +} + +_AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); +}; + +_AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); +}; + +_AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); +}; + +function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; +} + +function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); +} + +function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; +} + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} + +function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; +} + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} + +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} + +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} + +function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; +} + +function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); +} + +function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); +} + +function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; +} + +function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); +} + +function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); +} + +function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } +} + +function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); +} + +function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; +} + +function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); +} + +function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} + +function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; +} + +function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; +} + +function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } +} + +function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); +} + +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; +} + +function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); +} + +function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; +} + +function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; +} + +function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); +} + +function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); +} + +function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; +} + +function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); +} + +function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; +} + +function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); +} + +function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); +} + +function _temporalUndefined() {} + +function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); +} + +function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; +} + +function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); +} + +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} + +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); +} + +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); +} + +function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; +} + +function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; +} + +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} + +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; +} + +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; +} + +function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); +} + +function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; +} + +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); +} + +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); +} + +function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); +} + +function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); +} + +function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; +} + +var id = 0; + +function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; +} + +function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; +} + +function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } +} + +function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; +} + +function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); +} + +function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); +} + +function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; +} + +function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; +} + +function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } +} + +function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; +} + +function _hasDecorators(element) { + return element.decorators && element.decorators.length; +} + +function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); +} + +function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; +} + +function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; +} + +function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); +} + +function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); +} + /** * @file ext-arrows.js * @@ -6,321 +1654,353 @@ * @copyright 2010 Alexis Deveria * */ - -export default { +var extArrows = { name: 'arrows', - async init (S) { - const strings = await S.importLocale(); - const svgEditor = this; - const svgCanvas = svgEditor.canvas; - const // {svgcontent} = S, - addElem = svgCanvas.addSVGElementFromJson, - {nonce, $} = S, - prefix = 'se_arrow_'; + init: function init(S) { + var _this = this; - let selElems, arrowprefix, randomizeIds = S.randomize_ids; + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() { + var strings, svgEditor, svgCanvas, addElem, nonce, $, prefix, selElems, arrowprefix, randomizeIds, setArrowNonce, unsetArrowNonce, pathdata, getLinked, showPanel, resetMarker, addMarker, setArrow, colorChanged, contextTools; + return regeneratorRuntime.wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + colorChanged = function _colorChanged(elem) { + var color = elem.getAttribute('stroke'); + var mtypes = ['start', 'mid', 'end']; + var defs = svgCanvas.findDefs(); + $.each(mtypes, function (i, type) { + var marker = getLinked(elem, 'marker-' + type); - /** - * @param {Window} win - * @param {!(string|Integer)} n - * @returns {void} - */ - function setArrowNonce (win, n) { - randomizeIds = true; - arrowprefix = prefix + n + '_'; - pathdata.fw.id = arrowprefix + 'fw'; - pathdata.bk.id = arrowprefix + 'bk'; - } + if (!marker) { + return; + } - /** - * @param {Window} win - * @returns {void} - */ - function unsetArrowNonce (win) { - randomizeIds = false; - arrowprefix = prefix; - pathdata.fw.id = arrowprefix + 'fw'; - pathdata.bk.id = arrowprefix + 'bk'; - } + var curColor = $(marker).children().attr('fill'); + var curD = $(marker).children().attr('d'); - svgCanvas.bind('setnonce', setArrowNonce); - svgCanvas.bind('unsetnonce', unsetArrowNonce); + if (curColor === color) { + return; + } - if (randomizeIds) { - arrowprefix = prefix + nonce + '_'; - } else { - arrowprefix = prefix; - } + var allMarkers = $(defs).find('marker'); + var newMarker = null; // Different color, check if already made - const pathdata = { - fw: {d: 'm0,0l10,5l-10,5l5,-5l-5,-5z', refx: 8, id: arrowprefix + 'fw'}, - bk: {d: 'm10,0l-10,5l10,5l-5,-5l5,-5z', refx: 2, id: arrowprefix + 'bk'} - }; + allMarkers.each(function () { + var attrs = $(this).children().attr(['fill', 'd']); - /** - * Gets linked element. - * @param {Element} elem - * @param {string} attr - * @returns {Element} - */ - function getLinked (elem, attr) { - const str = elem.getAttribute(attr); - if (!str) { return null; } - const m = str.match(/\(#(.*)\)/); - // const m = str.match(/\(#(?.+)\)/); - // if (!m || !m.groups.id) { - if (!m || m.length !== 2) { - return null; - } - return svgCanvas.getElem(m[1]); - // return svgCanvas.getElem(m.groups.id); - } + if (attrs.fill === color && attrs.d === curD) { + // Found another marker with this color and this path + newMarker = this; + } + }); - /** - * @param {boolean} on - * @returns {void} - */ - function showPanel (on) { - $('#arrow_panel').toggle(on); - if (on) { - const el = selElems[0]; - const end = el.getAttribute('marker-end'); - const start = el.getAttribute('marker-start'); - const mid = el.getAttribute('marker-mid'); - let val; - if (end && start) { - val = 'both'; - } else if (end) { - val = 'end'; - } else if (start) { - val = 'start'; - } else if (mid) { - val = 'mid'; - if (mid.includes('bk')) { - val = 'mid_bk'; + if (!newMarker) { + // Create a new marker with this color + var lastId = marker.id; + var dir = lastId.includes('_fw') ? 'fw' : 'bk'; + newMarker = addMarker(dir, type, arrowprefix + dir + allMarkers.length); + $(newMarker).children().attr('fill', color); + } + + $(elem).attr('marker-' + type, 'url(#' + newMarker.id + ')'); // Check if last marker can be removed + + var remove = true; + $(S.svgcontent).find('line, polyline, path, polygon').each(function () { + var element = this; + $.each(mtypes, function (j, mtype) { + if ($(element).attr('marker-' + mtype) === 'url(#' + marker.id + ')') { + remove = false; + return remove; + } + + return undefined; + }); + + if (!remove) { + return false; + } + + return undefined; + }); // Not found, so can safely remove + + if (remove) { + $(marker).remove(); + } + }); + }; + + setArrow = function _setArrow() { + resetMarker(); + var type = this.value; + + if (type === 'none') { + return; + } // Set marker on element + + + var dir = 'fw'; + + if (type === 'mid_bk') { + type = 'mid'; + dir = 'bk'; + } else if (type === 'both') { + addMarker('bk', type); + svgCanvas.changeSelectedAttribute('marker-start', 'url(#' + pathdata.bk.id + ')'); + type = 'end'; + dir = 'fw'; + } else if (type === 'start') { + dir = 'bk'; + } + + addMarker(dir, type); + svgCanvas.changeSelectedAttribute('marker-' + type, 'url(#' + pathdata[dir].id + ')'); + svgCanvas.call('changed', selElems); + }; + + addMarker = function _addMarker(dir, type, id) { + // TODO: Make marker (or use?) per arrow type, since refX can be different + id = id || arrowprefix + dir; + var data = pathdata[dir]; + + if (type === 'mid') { + data.refx = 5; + } + + var marker = svgCanvas.getElem(id); + + if (!marker) { + marker = addElem({ + element: 'marker', + attr: { + viewBox: '0 0 10 10', + id: id, + refY: 5, + markerUnits: 'strokeWidth', + markerWidth: 5, + markerHeight: 5, + orient: 'auto', + style: 'pointer-events:none' // Currently needed for Opera + + } + }); + var arrow = addElem({ + element: 'path', + attr: { + d: data.d, + fill: '#000000' + } + }); + marker.append(arrow); + svgCanvas.findDefs().append(marker); + } + + marker.setAttribute('refX', data.refx); + return marker; + }; + + resetMarker = function _resetMarker() { + var el = selElems[0]; + el.removeAttribute('marker-start'); + el.removeAttribute('marker-mid'); + el.removeAttribute('marker-end'); + }; + + showPanel = function _showPanel(on) { + $('#arrow_panel').toggle(on); + + if (on) { + var el = selElems[0]; + var end = el.getAttribute('marker-end'); + var start = el.getAttribute('marker-start'); + var mid = el.getAttribute('marker-mid'); + var val; + + if (end && start) { + val = 'both'; + } else if (end) { + val = 'end'; + } else if (start) { + val = 'start'; + } else if (mid) { + val = 'mid'; + + if (mid.includes('bk')) { + val = 'mid_bk'; + } + } + + if (!start && !mid && !end) { + val = 'none'; + } + + $('#arrow_list').val(val); + } + }; + + getLinked = function _getLinked(elem, attr) { + var str = elem.getAttribute(attr); + + if (!str) { + return null; + } + + var m = str.match(/\(#(.*)\)/); // const m = str.match(/\(#(?.+)\)/); + // if (!m || !m.groups.id) { + + if (!m || m.length !== 2) { + return null; + } + + return svgCanvas.getElem(m[1]); // return svgCanvas.getElem(m.groups.id); + }; + + unsetArrowNonce = function _unsetArrowNonce(win) { + randomizeIds = false; + arrowprefix = prefix; + pathdata.fw.id = arrowprefix + 'fw'; + pathdata.bk.id = arrowprefix + 'bk'; + }; + + setArrowNonce = function _setArrowNonce(win, n) { + randomizeIds = true; + arrowprefix = prefix + n + '_'; + pathdata.fw.id = arrowprefix + 'fw'; + pathdata.bk.id = arrowprefix + 'bk'; + }; + + _context2.next = 10; + return S.importLocale(); + + case 10: + strings = _context2.sent; + svgEditor = _this; + svgCanvas = svgEditor.canvas; + // {svgcontent} = S, + addElem = svgCanvas.addSVGElementFromJson, nonce = S.nonce, $ = S.$, prefix = 'se_arrow_'; + randomizeIds = S.randomize_ids; + /** + * @param {Window} win + * @param {!(string|Integer)} n + * @returns {void} + */ + + svgCanvas.bind('setnonce', setArrowNonce); + svgCanvas.bind('unsetnonce', unsetArrowNonce); + + if (randomizeIds) { + arrowprefix = prefix + nonce + '_'; + } else { + arrowprefix = prefix; + } + + pathdata = { + fw: { + d: 'm0,0l10,5l-10,5l5,-5l-5,-5z', + refx: 8, + id: arrowprefix + 'fw' + }, + bk: { + d: 'm10,0l-10,5l10,5l-5,-5l5,-5z', + refx: 2, + id: arrowprefix + 'bk' + } + }; + /** + * Gets linked element. + * @param {Element} elem + * @param {string} attr + * @returns {Element} + */ + + contextTools = [{ + type: 'select', + panel: 'arrow_panel', + id: 'arrow_list', + defval: 'none', + events: { + change: setArrow + } + }]; + return _context2.abrupt("return", { + name: strings.name, + context_tools: strings.contextTools.map(function (contextTool, i) { + return Object.assign(contextTools[i], contextTool); + }), + callback: function callback() { + $('#arrow_panel').hide(); // Set ID so it can be translated in locale file + + $('#arrow_list option')[0].id = 'connector_no_arrow'; + }, + addLangData: function addLangData(_ref) { + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var lang, importLocale, _yield$importLocale, langList; + + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + lang = _ref.lang, importLocale = _ref.importLocale; + _context.next = 3; + return importLocale(); + + case 3: + _yield$importLocale = _context.sent; + langList = _yield$importLocale.langList; + return _context.abrupt("return", { + data: langList + }); + + case 6: + case "end": + return _context.stop(); + } + } + }, _callee); + }))(); + }, + selectedChanged: function selectedChanged(opts) { + // Use this to update the current selected elements + selElems = opts.elems; + var markerElems = ['line', 'path', 'polyline', 'polygon']; + var i = selElems.length; + + while (i--) { + var elem = selElems[i]; + + if (elem && markerElems.includes(elem.tagName)) { + if (opts.selectedElement && !opts.multiselected) { + showPanel(true); + } else { + showPanel(false); + } + } else { + showPanel(false); + } + } + }, + elementChanged: function elementChanged(opts) { + var elem = opts.elems[0]; + + if (elem && (elem.getAttribute('marker-start') || elem.getAttribute('marker-mid') || elem.getAttribute('marker-end'))) { + // const start = elem.getAttribute('marker-start'); + // const mid = elem.getAttribute('marker-mid'); + // const end = elem.getAttribute('marker-end'); + // Has marker, so see if it should match color + colorChanged(elem); + } + } + }); + + case 21: + case "end": + return _context2.stop(); } } - - if (!start && !mid && !end) { - val = 'none'; - } - - $('#arrow_list').val(val); - } - } - - /** - * - * @returns {void} - */ - function resetMarker () { - const el = selElems[0]; - el.removeAttribute('marker-start'); - el.removeAttribute('marker-mid'); - el.removeAttribute('marker-end'); - } - - /** - * @param {"bk"|"fw"} dir - * @param {"both"|"mid"|"end"|"start"} type - * @param {string} id - * @returns {Element} - */ - function addMarker (dir, type, id) { - // TODO: Make marker (or use?) per arrow type, since refX can be different - id = id || arrowprefix + dir; - - const data = pathdata[dir]; - - if (type === 'mid') { - data.refx = 5; - } - - let marker = svgCanvas.getElem(id); - if (!marker) { - marker = addElem({ - element: 'marker', - attr: { - viewBox: '0 0 10 10', - id, - refY: 5, - markerUnits: 'strokeWidth', - markerWidth: 5, - markerHeight: 5, - orient: 'auto', - style: 'pointer-events:none' // Currently needed for Opera - } - }); - const arrow = addElem({ - element: 'path', - attr: { - d: data.d, - fill: '#000000' - } - }); - marker.append(arrow); - svgCanvas.findDefs().append(marker); - } - - marker.setAttribute('refX', data.refx); - - return marker; - } - - /** - * - * @returns {void} - */ - function setArrow () { - resetMarker(); - - let type = this.value; - if (type === 'none') { - return; - } - - // Set marker on element - let dir = 'fw'; - if (type === 'mid_bk') { - type = 'mid'; - dir = 'bk'; - } else if (type === 'both') { - addMarker('bk', type); - svgCanvas.changeSelectedAttribute('marker-start', 'url(#' + pathdata.bk.id + ')'); - type = 'end'; - dir = 'fw'; - } else if (type === 'start') { - dir = 'bk'; - } - - addMarker(dir, type); - svgCanvas.changeSelectedAttribute('marker-' + type, 'url(#' + pathdata[dir].id + ')'); - svgCanvas.call('changed', selElems); - } - - /** - * @param {Element} elem - * @returns {void} - */ - function colorChanged (elem) { - const color = elem.getAttribute('stroke'); - const mtypes = ['start', 'mid', 'end']; - const defs = svgCanvas.findDefs(); - - $.each(mtypes, function (i, type) { - const marker = getLinked(elem, 'marker-' + type); - if (!marker) { return; } - - const curColor = $(marker).children().attr('fill'); - const curD = $(marker).children().attr('d'); - if (curColor === color) { return; } - - const allMarkers = $(defs).find('marker'); - let newMarker = null; - // Different color, check if already made - allMarkers.each(function () { - const attrs = $(this).children().attr(['fill', 'd']); - if (attrs.fill === color && attrs.d === curD) { - // Found another marker with this color and this path - newMarker = this; - } - }); - - if (!newMarker) { - // Create a new marker with this color - const lastId = marker.id; - const dir = lastId.includes('_fw') ? 'fw' : 'bk'; - - newMarker = addMarker(dir, type, arrowprefix + dir + allMarkers.length); - - $(newMarker).children().attr('fill', color); - } - - $(elem).attr('marker-' + type, 'url(#' + newMarker.id + ')'); - - // Check if last marker can be removed - let remove = true; - $(S.svgcontent).find('line, polyline, path, polygon').each(function () { - const element = this; - $.each(mtypes, function (j, mtype) { - if ($(element).attr('marker-' + mtype) === 'url(#' + marker.id + ')') { - remove = false; - return remove; - } - return undefined; - }); - if (!remove) { return false; } - return undefined; - }); - - // Not found, so can safely remove - if (remove) { - $(marker).remove(); - } - }); - } - - const contextTools = [ - { - type: 'select', - panel: 'arrow_panel', - id: 'arrow_list', - defval: 'none', - events: { - change: setArrow - } - } - ]; - - return { - name: strings.name, - context_tools: strings.contextTools.map((contextTool, i) => { - return Object.assign(contextTools[i], contextTool); - }), - callback () { - $('#arrow_panel').hide(); - // Set ID so it can be translated in locale file - $('#arrow_list option')[0].id = 'connector_no_arrow'; - }, - async addLangData ({lang, importLocale}) { - const {langList} = await importLocale(); - return { - data: langList - }; - }, - selectedChanged (opts) { - // Use this to update the current selected elements - selElems = opts.elems; - - const markerElems = ['line', 'path', 'polyline', 'polygon']; - let i = selElems.length; - while (i--) { - const elem = selElems[i]; - if (elem && markerElems.includes(elem.tagName)) { - if (opts.selectedElement && !opts.multiselected) { - showPanel(true); - } else { - showPanel(false); - } - } else { - showPanel(false); - } - } - }, - elementChanged (opts) { - const elem = opts.elems[0]; - if (elem && ( - elem.getAttribute('marker-start') || - elem.getAttribute('marker-mid') || - elem.getAttribute('marker-end') - )) { - // const start = elem.getAttribute('marker-start'); - // const mid = elem.getAttribute('marker-mid'); - // const end = elem.getAttribute('marker-end'); - // Has marker, so see if it should match color - colorChanged(elem); - } - } - }; + }, _callee2); + }))(); } }; + +export default extArrows; +//# sourceMappingURL=ext-arrows.js.map diff --git a/dist/editor/extensions/ext-arrows.js.map b/dist/editor/extensions/ext-arrows.js.map new file mode 100644 index 00000000..66481559 --- /dev/null +++ b/dist/editor/extensions/ext-arrows.js.map @@ -0,0 +1 @@ +{"version":3,"file":"ext-arrows.js","sources":["../../../src/editor/extensions/ext-arrows.js"],"sourcesContent":["/**\n * @file ext-arrows.js\n *\n * @license MIT\n *\n * @copyright 2010 Alexis Deveria\n *\n */\n\nexport default {\n name: 'arrows',\n async init (S) {\n const strings = await S.importLocale();\n const svgEditor = this;\n const svgCanvas = svgEditor.canvas;\n const // {svgcontent} = S,\n addElem = svgCanvas.addSVGElementFromJson,\n {nonce, $} = S,\n prefix = 'se_arrow_';\n\n let selElems, arrowprefix, randomizeIds = S.randomize_ids;\n\n /**\n * @param {Window} win\n * @param {!(string|Integer)} n\n * @returns {void}\n */\n function setArrowNonce (win, n) {\n randomizeIds = true;\n arrowprefix = prefix + n + '_';\n pathdata.fw.id = arrowprefix + 'fw';\n pathdata.bk.id = arrowprefix + 'bk';\n }\n\n /**\n * @param {Window} win\n * @returns {void}\n */\n function unsetArrowNonce (win) {\n randomizeIds = false;\n arrowprefix = prefix;\n pathdata.fw.id = arrowprefix + 'fw';\n pathdata.bk.id = arrowprefix + 'bk';\n }\n\n svgCanvas.bind('setnonce', setArrowNonce);\n svgCanvas.bind('unsetnonce', unsetArrowNonce);\n\n if (randomizeIds) {\n arrowprefix = prefix + nonce + '_';\n } else {\n arrowprefix = prefix;\n }\n\n const pathdata = {\n fw: {d: 'm0,0l10,5l-10,5l5,-5l-5,-5z', refx: 8, id: arrowprefix + 'fw'},\n bk: {d: 'm10,0l-10,5l10,5l-5,-5l5,-5z', refx: 2, id: arrowprefix + 'bk'}\n };\n\n /**\n * Gets linked element.\n * @param {Element} elem\n * @param {string} attr\n * @returns {Element}\n */\n function getLinked (elem, attr) {\n const str = elem.getAttribute(attr);\n if (!str) { return null; }\n const m = str.match(/\\(#(.*)\\)/);\n // const m = str.match(/\\(#(?.+)\\)/);\n // if (!m || !m.groups.id) {\n if (!m || m.length !== 2) {\n return null;\n }\n return svgCanvas.getElem(m[1]);\n // return svgCanvas.getElem(m.groups.id);\n }\n\n /**\n * @param {boolean} on\n * @returns {void}\n */\n function showPanel (on) {\n $('#arrow_panel').toggle(on);\n if (on) {\n const el = selElems[0];\n const end = el.getAttribute('marker-end');\n const start = el.getAttribute('marker-start');\n const mid = el.getAttribute('marker-mid');\n let val;\n if (end && start) {\n val = 'both';\n } else if (end) {\n val = 'end';\n } else if (start) {\n val = 'start';\n } else if (mid) {\n val = 'mid';\n if (mid.includes('bk')) {\n val = 'mid_bk';\n }\n }\n\n if (!start && !mid && !end) {\n val = 'none';\n }\n\n $('#arrow_list').val(val);\n }\n }\n\n /**\n *\n * @returns {void}\n */\n function resetMarker () {\n const el = selElems[0];\n el.removeAttribute('marker-start');\n el.removeAttribute('marker-mid');\n el.removeAttribute('marker-end');\n }\n\n /**\n * @param {\"bk\"|\"fw\"} dir\n * @param {\"both\"|\"mid\"|\"end\"|\"start\"} type\n * @param {string} id\n * @returns {Element}\n */\n function addMarker (dir, type, id) {\n // TODO: Make marker (or use?) per arrow type, since refX can be different\n id = id || arrowprefix + dir;\n\n const data = pathdata[dir];\n\n if (type === 'mid') {\n data.refx = 5;\n }\n\n let marker = svgCanvas.getElem(id);\n if (!marker) {\n marker = addElem({\n element: 'marker',\n attr: {\n viewBox: '0 0 10 10',\n id,\n refY: 5,\n markerUnits: 'strokeWidth',\n markerWidth: 5,\n markerHeight: 5,\n orient: 'auto',\n style: 'pointer-events:none' // Currently needed for Opera\n }\n });\n const arrow = addElem({\n element: 'path',\n attr: {\n d: data.d,\n fill: '#000000'\n }\n });\n marker.append(arrow);\n svgCanvas.findDefs().append(marker);\n }\n\n marker.setAttribute('refX', data.refx);\n\n return marker;\n }\n\n /**\n *\n * @returns {void}\n */\n function setArrow () {\n resetMarker();\n\n let type = this.value;\n if (type === 'none') {\n return;\n }\n\n // Set marker on element\n let dir = 'fw';\n if (type === 'mid_bk') {\n type = 'mid';\n dir = 'bk';\n } else if (type === 'both') {\n addMarker('bk', type);\n svgCanvas.changeSelectedAttribute('marker-start', 'url(#' + pathdata.bk.id + ')');\n type = 'end';\n dir = 'fw';\n } else if (type === 'start') {\n dir = 'bk';\n }\n\n addMarker(dir, type);\n svgCanvas.changeSelectedAttribute('marker-' + type, 'url(#' + pathdata[dir].id + ')');\n svgCanvas.call('changed', selElems);\n }\n\n /**\n * @param {Element} elem\n * @returns {void}\n */\n function colorChanged (elem) {\n const color = elem.getAttribute('stroke');\n const mtypes = ['start', 'mid', 'end'];\n const defs = svgCanvas.findDefs();\n\n $.each(mtypes, function (i, type) {\n const marker = getLinked(elem, 'marker-' + type);\n if (!marker) { return; }\n\n const curColor = $(marker).children().attr('fill');\n const curD = $(marker).children().attr('d');\n if (curColor === color) { return; }\n\n const allMarkers = $(defs).find('marker');\n let newMarker = null;\n // Different color, check if already made\n allMarkers.each(function () {\n const attrs = $(this).children().attr(['fill', 'd']);\n if (attrs.fill === color && attrs.d === curD) {\n // Found another marker with this color and this path\n newMarker = this;\n }\n });\n\n if (!newMarker) {\n // Create a new marker with this color\n const lastId = marker.id;\n const dir = lastId.includes('_fw') ? 'fw' : 'bk';\n\n newMarker = addMarker(dir, type, arrowprefix + dir + allMarkers.length);\n\n $(newMarker).children().attr('fill', color);\n }\n\n $(elem).attr('marker-' + type, 'url(#' + newMarker.id + ')');\n\n // Check if last marker can be removed\n let remove = true;\n $(S.svgcontent).find('line, polyline, path, polygon').each(function () {\n const element = this;\n $.each(mtypes, function (j, mtype) {\n if ($(element).attr('marker-' + mtype) === 'url(#' + marker.id + ')') {\n remove = false;\n return remove;\n }\n return undefined;\n });\n if (!remove) { return false; }\n return undefined;\n });\n\n // Not found, so can safely remove\n if (remove) {\n $(marker).remove();\n }\n });\n }\n\n const contextTools = [\n {\n type: 'select',\n panel: 'arrow_panel',\n id: 'arrow_list',\n defval: 'none',\n events: {\n change: setArrow\n }\n }\n ];\n\n return {\n name: strings.name,\n context_tools: strings.contextTools.map((contextTool, i) => {\n return Object.assign(contextTools[i], contextTool);\n }),\n callback () {\n $('#arrow_panel').hide();\n // Set ID so it can be translated in locale file\n $('#arrow_list option')[0].id = 'connector_no_arrow';\n },\n async addLangData ({lang, importLocale}) {\n const {langList} = await importLocale();\n return {\n data: langList\n };\n },\n selectedChanged (opts) {\n // Use this to update the current selected elements\n selElems = opts.elems;\n\n const markerElems = ['line', 'path', 'polyline', 'polygon'];\n let i = selElems.length;\n while (i--) {\n const elem = selElems[i];\n if (elem && markerElems.includes(elem.tagName)) {\n if (opts.selectedElement && !opts.multiselected) {\n showPanel(true);\n } else {\n showPanel(false);\n }\n } else {\n showPanel(false);\n }\n }\n },\n elementChanged (opts) {\n const elem = opts.elems[0];\n if (elem && (\n elem.getAttribute('marker-start') ||\n elem.getAttribute('marker-mid') ||\n elem.getAttribute('marker-end')\n )) {\n // const start = elem.getAttribute('marker-start');\n // const mid = elem.getAttribute('marker-mid');\n // const end = elem.getAttribute('marker-end');\n // Has marker, so see if it should match color\n colorChanged(elem);\n }\n }\n };\n }\n};\n"],"names":["name","init","S","setArrowNonce","unsetArrowNonce","getLinked","showPanel","resetMarker","addMarker","setArrow","colorChanged","elem","color","getAttribute","mtypes","defs","svgCanvas","findDefs","$","each","i","type","marker","curColor","children","attr","curD","allMarkers","find","newMarker","attrs","fill","d","lastId","id","dir","includes","arrowprefix","length","remove","svgcontent","element","j","mtype","undefined","value","changeSelectedAttribute","pathdata","bk","call","selElems","data","refx","getElem","addElem","viewBox","refY","markerUnits","markerWidth","markerHeight","orient","style","arrow","append","setAttribute","el","removeAttribute","on","toggle","end","start","mid","val","str","m","match","win","randomizeIds","prefix","fw","n","importLocale","strings","svgEditor","canvas","addSVGElementFromJson","nonce","randomize_ids","bind","contextTools","panel","defval","events","change","context_tools","map","contextTool","Object","assign","callback","hide","addLangData","lang","langList","selectedChanged","opts","elems","markerElems","tagName","selectedElement","multiselected","elementChanged"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file diff --git a/dist/editor/extensions/ext-closepath.js b/dist/editor/extensions/ext-closepath.js index 137ec2aa..53a6a9cd 100644 --- a/dist/editor/extensions/ext-closepath.js +++ b/dist/editor/extensions/ext-closepath.js @@ -1,101 +1,4090 @@ -/** - * @file ext-closepath.js - * - * @license MIT - * - * @copyright 2010 Jeff Schiller - * - */ -import '../../common/svgpathseg.js'; +function _typeof(obj) { + "@babel/helpers - typeof"; -// This extension adds a simple button to the contextual panel for paths -// The button toggles whether the path is open or closed -export default { - name: 'closepath', - async init ({importLocale, $}) { - const strings = await importLocale(); - const svgEditor = this; - let selElems; - const updateButton = function (path) { - const seglist = path.pathSegList, - closed = seglist.getItem(seglist.numberOfItems - 1).pathSegType === 1, - showbutton = closed ? '#tool_openpath' : '#tool_closepath', - hidebutton = closed ? '#tool_closepath' : '#tool_openpath'; - $(hidebutton).hide(); - $(showbutton).show(); + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; }; - const showPanel = function (on) { - $('#closepath_panel').toggle(on); - if (on) { - const path = selElems[0]; - if (path) { updateButton(path); } - } - }; - const toggleClosed = function () { - const path = selElems[0]; - if (path) { - const seglist = path.pathSegList, - last = seglist.numberOfItems - 1; - // is closed - if (seglist.getItem(last).pathSegType === 1) { - seglist.removeItem(last); - } else { - seglist.appendItem(path.createSVGPathSegClosePath()); - } - updateButton(path); - } - }; - - const buttons = [ - { - id: 'tool_openpath', - icon: svgEditor.curConfig.extIconsPath + 'openpath.png', - type: 'context', - panel: 'closepath_panel', - events: { - click () { - toggleClosed(); - } - } - }, - { - id: 'tool_closepath', - icon: svgEditor.curConfig.extIconsPath + 'closepath.png', - type: 'context', - panel: 'closepath_panel', - events: { - click () { - toggleClosed(); - } - } - } - ]; - - return { - name: strings.name, - svgicons: svgEditor.curConfig.extIconsPath + 'closepath_icons.svg', - buttons: strings.buttons.map((button, i) => { - return Object.assign(buttons[i], button); - }), - callback () { - $('#closepath_panel').hide(); - }, - selectedChanged (opts) { - selElems = opts.elems; - let i = selElems.length; - while (i--) { - const elem = selElems[i]; - if (elem && elem.tagName === 'path') { - if (opts.selectedElement && !opts.multiselected) { - showPanel(true); - } else { - showPanel(false); - } - } else { - showPanel(false); - } - } - } + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } + + return _typeof(obj); +} + +var REACT_ELEMENT_TYPE; + +function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; +} + +function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); +} + +function _AwaitValue(value) { + this.wrapped = value; +} + +function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } +} + +if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; +} + +_AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); }; + +_AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); +}; + +_AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); +}; + +function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; +} + +function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); +} + +function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; +} + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} + +function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; +} + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} + +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} + +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} + +function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; +} + +function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); +} + +function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); +} + +function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; +} + +function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); +} + +function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); +} + +function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } +} + +function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); +} + +function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; +} + +function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); +} + +function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} + +function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; +} + +function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; +} + +function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } +} + +function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); +} + +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; +} + +function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); +} + +function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; +} + +function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; +} + +function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); +} + +function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); +} + +function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; +} + +function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); +} + +function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; +} + +function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); +} + +function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); +} + +function _temporalUndefined() {} + +function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); +} + +function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; +} + +function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); +} + +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} + +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); +} + +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); +} + +function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; +} + +function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; +} + +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} + +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; +} + +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; +} + +function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); +} + +function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; +} + +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); +} + +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); +} + +function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); +} + +function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); +} + +function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; +} + +var id = 0; + +function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; +} + +function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; +} + +function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } +} + +function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; +} + +function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); +} + +function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); +} + +function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; +} + +function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; +} + +function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } +} + +function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; +} + +function _hasDecorators(element) { + return element.decorators && element.decorators.length; +} + +function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); +} + +function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; +} + +function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; +} + +function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); +} + +function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); +} + +/* eslint-disable import/unambiguous, max-len */ + +/* globals SVGPathSeg, SVGPathSegMovetoRel, SVGPathSegMovetoAbs, + SVGPathSegMovetoRel, SVGPathSegLinetoRel, SVGPathSegLinetoAbs, + SVGPathSegLinetoHorizontalRel, SVGPathSegLinetoHorizontalAbs, + SVGPathSegLinetoVerticalRel, SVGPathSegLinetoVerticalAbs, + SVGPathSegClosePath, SVGPathSegCurvetoCubicRel, + SVGPathSegCurvetoCubicAbs, SVGPathSegCurvetoCubicSmoothRel, + SVGPathSegCurvetoCubicSmoothAbs, SVGPathSegCurvetoQuadraticRel, + SVGPathSegCurvetoQuadraticAbs, SVGPathSegCurvetoQuadraticSmoothRel, + SVGPathSegCurvetoQuadraticSmoothAbs, SVGPathSegArcRel, SVGPathSegArcAbs */ + +/** +* SVGPathSeg API polyfill +* https://github.com/progers/pathseg +* +* This is a drop-in replacement for the `SVGPathSeg` and `SVGPathSegList` APIs +* that were removed from SVG2 ({@link https://lists.w3.org/Archives/Public/www-svg/2015Jun/0044.html}), +* including the latest spec changes which were implemented in Firefox 43 and +* Chrome 46. +*/ + +/* eslint-disable no-shadow, class-methods-use-this, jsdoc/require-jsdoc */ +// Linting: We avoid `no-shadow` as ESLint thinks these are still available globals +// Linting: We avoid `class-methods-use-this` as this is a polyfill that must +// follow the conventions +(function () { + if (!('SVGPathSeg' in window)) { + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSeg + var _SVGPathSeg = /*#__PURE__*/function () { + function _SVGPathSeg(type, typeAsLetter, owningPathSegList) { + _classCallCheck(this, _SVGPathSeg); + + this.pathSegType = type; + this.pathSegTypeAsLetter = typeAsLetter; + this._owningPathSegList = owningPathSegList; + } // Notify owning PathSegList on any changes so they can be synchronized back to the path element. + + + _createClass(_SVGPathSeg, [{ + key: "_segmentChanged", + value: function _segmentChanged() { + if (this._owningPathSegList) { + this._owningPathSegList.segmentChanged(this); + } + } + }]); + + return _SVGPathSeg; + }(); + + _SVGPathSeg.prototype.classname = 'SVGPathSeg'; + _SVGPathSeg.PATHSEG_UNKNOWN = 0; + _SVGPathSeg.PATHSEG_CLOSEPATH = 1; + _SVGPathSeg.PATHSEG_MOVETO_ABS = 2; + _SVGPathSeg.PATHSEG_MOVETO_REL = 3; + _SVGPathSeg.PATHSEG_LINETO_ABS = 4; + _SVGPathSeg.PATHSEG_LINETO_REL = 5; + _SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS = 6; + _SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL = 7; + _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS = 8; + _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL = 9; + _SVGPathSeg.PATHSEG_ARC_ABS = 10; + _SVGPathSeg.PATHSEG_ARC_REL = 11; + _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS = 12; + _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL = 13; + _SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS = 14; + _SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL = 15; + _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16; + _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17; + _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18; + _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19; + + var _SVGPathSegClosePath = /*#__PURE__*/function (_SVGPathSeg2) { + _inherits(_SVGPathSegClosePath, _SVGPathSeg2); + + var _super = _createSuper(_SVGPathSegClosePath); + + function _SVGPathSegClosePath(owningPathSegList) { + _classCallCheck(this, _SVGPathSegClosePath); + + return _super.call(this, _SVGPathSeg.PATHSEG_CLOSEPATH, 'z', owningPathSegList); + } + + _createClass(_SVGPathSegClosePath, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegClosePath]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegClosePath(undefined); + } + }]); + + return _SVGPathSegClosePath; + }(_SVGPathSeg); + + var _SVGPathSegMovetoAbs = /*#__PURE__*/function (_SVGPathSeg3) { + _inherits(_SVGPathSegMovetoAbs, _SVGPathSeg3); + + var _super2 = _createSuper(_SVGPathSegMovetoAbs); + + function _SVGPathSegMovetoAbs(owningPathSegList, x, y) { + var _this; + + _classCallCheck(this, _SVGPathSegMovetoAbs); + + _this = _super2.call(this, _SVGPathSeg.PATHSEG_MOVETO_ABS, 'M', owningPathSegList); + _this._x = x; + _this._y = y; + return _this; + } + + _createClass(_SVGPathSegMovetoAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegMovetoAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegMovetoAbs(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegMovetoAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegMovetoAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegMovetoRel = /*#__PURE__*/function (_SVGPathSeg4) { + _inherits(_SVGPathSegMovetoRel, _SVGPathSeg4); + + var _super3 = _createSuper(_SVGPathSegMovetoRel); + + function _SVGPathSegMovetoRel(owningPathSegList, x, y) { + var _this2; + + _classCallCheck(this, _SVGPathSegMovetoRel); + + _this2 = _super3.call(this, _SVGPathSeg.PATHSEG_MOVETO_REL, 'm', owningPathSegList); + _this2._x = x; + _this2._y = y; + return _this2; + } + + _createClass(_SVGPathSegMovetoRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegMovetoRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegMovetoRel(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegMovetoRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegMovetoRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegLinetoAbs = /*#__PURE__*/function (_SVGPathSeg5) { + _inherits(_SVGPathSegLinetoAbs, _SVGPathSeg5); + + var _super4 = _createSuper(_SVGPathSegLinetoAbs); + + function _SVGPathSegLinetoAbs(owningPathSegList, x, y) { + var _this3; + + _classCallCheck(this, _SVGPathSegLinetoAbs); + + _this3 = _super4.call(this, _SVGPathSeg.PATHSEG_LINETO_ABS, 'L', owningPathSegList); + _this3._x = x; + _this3._y = y; + return _this3; + } + + _createClass(_SVGPathSegLinetoAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoAbs(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegLinetoAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegLinetoAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegLinetoRel = /*#__PURE__*/function (_SVGPathSeg6) { + _inherits(_SVGPathSegLinetoRel, _SVGPathSeg6); + + var _super5 = _createSuper(_SVGPathSegLinetoRel); + + function _SVGPathSegLinetoRel(owningPathSegList, x, y) { + var _this4; + + _classCallCheck(this, _SVGPathSegLinetoRel); + + _this4 = _super5.call(this, _SVGPathSeg.PATHSEG_LINETO_REL, 'l', owningPathSegList); + _this4._x = x; + _this4._y = y; + return _this4; + } + + _createClass(_SVGPathSegLinetoRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoRel(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegLinetoRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegLinetoRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoCubicAbs = /*#__PURE__*/function (_SVGPathSeg7) { + _inherits(_SVGPathSegCurvetoCubicAbs, _SVGPathSeg7); + + var _super6 = _createSuper(_SVGPathSegCurvetoCubicAbs); + + function _SVGPathSegCurvetoCubicAbs(owningPathSegList, x, y, x1, y1, x2, y2) { + var _this5; + + _classCallCheck(this, _SVGPathSegCurvetoCubicAbs); + + _this5 = _super6.call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS, 'C', owningPathSegList); + _this5._x = x; + _this5._y = y; + _this5._x1 = x1; + _this5._y1 = y1; + _this5._x2 = x2; + _this5._y2 = y2; + return _this5; + } + + _createClass(_SVGPathSegCurvetoCubicAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoCubicAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoCubicAbs(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2); + } + }]); + + return _SVGPathSegCurvetoCubicAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoCubicAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x1: { + get: function get() { + return this._x1; + }, + set: function set(x1) { + this._x1 = x1; + + this._segmentChanged(); + }, + enumerable: true + }, + y1: { + get: function get() { + return this._y1; + }, + set: function set(y1) { + this._y1 = y1; + + this._segmentChanged(); + }, + enumerable: true + }, + x2: { + get: function get() { + return this._x2; + }, + set: function set(x2) { + this._x2 = x2; + + this._segmentChanged(); + }, + enumerable: true + }, + y2: { + get: function get() { + return this._y2; + }, + set: function set(y2) { + this._y2 = y2; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoCubicRel = /*#__PURE__*/function (_SVGPathSeg8) { + _inherits(_SVGPathSegCurvetoCubicRel, _SVGPathSeg8); + + var _super7 = _createSuper(_SVGPathSegCurvetoCubicRel); + + function _SVGPathSegCurvetoCubicRel(owningPathSegList, x, y, x1, y1, x2, y2) { + var _this6; + + _classCallCheck(this, _SVGPathSegCurvetoCubicRel); + + _this6 = _super7.call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL, 'c', owningPathSegList); + _this6._x = x; + _this6._y = y; + _this6._x1 = x1; + _this6._y1 = y1; + _this6._x2 = x2; + _this6._y2 = y2; + return _this6; + } + + _createClass(_SVGPathSegCurvetoCubicRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoCubicRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoCubicRel(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2); + } + }]); + + return _SVGPathSegCurvetoCubicRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoCubicRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x1: { + get: function get() { + return this._x1; + }, + set: function set(x1) { + this._x1 = x1; + + this._segmentChanged(); + }, + enumerable: true + }, + y1: { + get: function get() { + return this._y1; + }, + set: function set(y1) { + this._y1 = y1; + + this._segmentChanged(); + }, + enumerable: true + }, + x2: { + get: function get() { + return this._x2; + }, + set: function set(x2) { + this._x2 = x2; + + this._segmentChanged(); + }, + enumerable: true + }, + y2: { + get: function get() { + return this._y2; + }, + set: function set(y2) { + this._y2 = y2; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoQuadraticAbs = /*#__PURE__*/function (_SVGPathSeg9) { + _inherits(_SVGPathSegCurvetoQuadraticAbs, _SVGPathSeg9); + + var _super8 = _createSuper(_SVGPathSegCurvetoQuadraticAbs); + + function _SVGPathSegCurvetoQuadraticAbs(owningPathSegList, x, y, x1, y1) { + var _this7; + + _classCallCheck(this, _SVGPathSegCurvetoQuadraticAbs); + + _this7 = _super8.call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS, 'Q', owningPathSegList); + _this7._x = x; + _this7._y = y; + _this7._x1 = x1; + _this7._y1 = y1; + return _this7; + } + + _createClass(_SVGPathSegCurvetoQuadraticAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoQuadraticAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoQuadraticAbs(undefined, this._x, this._y, this._x1, this._y1); + } + }]); + + return _SVGPathSegCurvetoQuadraticAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoQuadraticAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x1: { + get: function get() { + return this._x1; + }, + set: function set(x1) { + this._x1 = x1; + + this._segmentChanged(); + }, + enumerable: true + }, + y1: { + get: function get() { + return this._y1; + }, + set: function set(y1) { + this._y1 = y1; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoQuadraticRel = /*#__PURE__*/function (_SVGPathSeg10) { + _inherits(_SVGPathSegCurvetoQuadraticRel, _SVGPathSeg10); + + var _super9 = _createSuper(_SVGPathSegCurvetoQuadraticRel); + + function _SVGPathSegCurvetoQuadraticRel(owningPathSegList, x, y, x1, y1) { + var _this8; + + _classCallCheck(this, _SVGPathSegCurvetoQuadraticRel); + + _this8 = _super9.call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL, 'q', owningPathSegList); + _this8._x = x; + _this8._y = y; + _this8._x1 = x1; + _this8._y1 = y1; + return _this8; + } + + _createClass(_SVGPathSegCurvetoQuadraticRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoQuadraticRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoQuadraticRel(undefined, this._x, this._y, this._x1, this._y1); + } + }]); + + return _SVGPathSegCurvetoQuadraticRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoQuadraticRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x1: { + get: function get() { + return this._x1; + }, + set: function set(x1) { + this._x1 = x1; + + this._segmentChanged(); + }, + enumerable: true + }, + y1: { + get: function get() { + return this._y1; + }, + set: function set(y1) { + this._y1 = y1; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegArcAbs = /*#__PURE__*/function (_SVGPathSeg11) { + _inherits(_SVGPathSegArcAbs, _SVGPathSeg11); + + var _super10 = _createSuper(_SVGPathSegArcAbs); + + function _SVGPathSegArcAbs(owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) { + var _this9; + + _classCallCheck(this, _SVGPathSegArcAbs); + + _this9 = _super10.call(this, _SVGPathSeg.PATHSEG_ARC_ABS, 'A', owningPathSegList); + _this9._x = x; + _this9._y = y; + _this9._r1 = r1; + _this9._r2 = r2; + _this9._angle = angle; + _this9._largeArcFlag = largeArcFlag; + _this9._sweepFlag = sweepFlag; + return _this9; + } + + _createClass(_SVGPathSegArcAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegArcAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle + ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0') + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegArcAbs(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag); + } + }]); + + return _SVGPathSegArcAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegArcAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + r1: { + get: function get() { + return this._r1; + }, + set: function set(r1) { + this._r1 = r1; + + this._segmentChanged(); + }, + enumerable: true + }, + r2: { + get: function get() { + return this._r2; + }, + set: function set(r2) { + this._r2 = r2; + + this._segmentChanged(); + }, + enumerable: true + }, + angle: { + get: function get() { + return this._angle; + }, + set: function set(angle) { + this._angle = angle; + + this._segmentChanged(); + }, + enumerable: true + }, + largeArcFlag: { + get: function get() { + return this._largeArcFlag; + }, + set: function set(largeArcFlag) { + this._largeArcFlag = largeArcFlag; + + this._segmentChanged(); + }, + enumerable: true + }, + sweepFlag: { + get: function get() { + return this._sweepFlag; + }, + set: function set(sweepFlag) { + this._sweepFlag = sweepFlag; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegArcRel = /*#__PURE__*/function (_SVGPathSeg12) { + _inherits(_SVGPathSegArcRel, _SVGPathSeg12); + + var _super11 = _createSuper(_SVGPathSegArcRel); + + function _SVGPathSegArcRel(owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) { + var _this10; + + _classCallCheck(this, _SVGPathSegArcRel); + + _this10 = _super11.call(this, _SVGPathSeg.PATHSEG_ARC_REL, 'a', owningPathSegList); + _this10._x = x; + _this10._y = y; + _this10._r1 = r1; + _this10._r2 = r2; + _this10._angle = angle; + _this10._largeArcFlag = largeArcFlag; + _this10._sweepFlag = sweepFlag; + return _this10; + } + + _createClass(_SVGPathSegArcRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegArcRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle + ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0') + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegArcRel(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag); + } + }]); + + return _SVGPathSegArcRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegArcRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + r1: { + get: function get() { + return this._r1; + }, + set: function set(r1) { + this._r1 = r1; + + this._segmentChanged(); + }, + enumerable: true + }, + r2: { + get: function get() { + return this._r2; + }, + set: function set(r2) { + this._r2 = r2; + + this._segmentChanged(); + }, + enumerable: true + }, + angle: { + get: function get() { + return this._angle; + }, + set: function set(angle) { + this._angle = angle; + + this._segmentChanged(); + }, + enumerable: true + }, + largeArcFlag: { + get: function get() { + return this._largeArcFlag; + }, + set: function set(largeArcFlag) { + this._largeArcFlag = largeArcFlag; + + this._segmentChanged(); + }, + enumerable: true + }, + sweepFlag: { + get: function get() { + return this._sweepFlag; + }, + set: function set(sweepFlag) { + this._sweepFlag = sweepFlag; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegLinetoHorizontalAbs = /*#__PURE__*/function (_SVGPathSeg13) { + _inherits(_SVGPathSegLinetoHorizontalAbs, _SVGPathSeg13); + + var _super12 = _createSuper(_SVGPathSegLinetoHorizontalAbs); + + function _SVGPathSegLinetoHorizontalAbs(owningPathSegList, x) { + var _this11; + + _classCallCheck(this, _SVGPathSegLinetoHorizontalAbs); + + _this11 = _super12.call(this, _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS, 'H', owningPathSegList); + _this11._x = x; + return _this11; + } + + _createClass(_SVGPathSegLinetoHorizontalAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoHorizontalAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoHorizontalAbs(undefined, this._x); + } + }]); + + return _SVGPathSegLinetoHorizontalAbs; + }(_SVGPathSeg); + + Object.defineProperty(_SVGPathSegLinetoHorizontalAbs.prototype, 'x', { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }); + + var _SVGPathSegLinetoHorizontalRel = /*#__PURE__*/function (_SVGPathSeg14) { + _inherits(_SVGPathSegLinetoHorizontalRel, _SVGPathSeg14); + + var _super13 = _createSuper(_SVGPathSegLinetoHorizontalRel); + + function _SVGPathSegLinetoHorizontalRel(owningPathSegList, x) { + var _this12; + + _classCallCheck(this, _SVGPathSegLinetoHorizontalRel); + + _this12 = _super13.call(this, _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL, 'h', owningPathSegList); + _this12._x = x; + return _this12; + } + + _createClass(_SVGPathSegLinetoHorizontalRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoHorizontalRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoHorizontalRel(undefined, this._x); + } + }]); + + return _SVGPathSegLinetoHorizontalRel; + }(_SVGPathSeg); + + Object.defineProperty(_SVGPathSegLinetoHorizontalRel.prototype, 'x', { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }); + + var _SVGPathSegLinetoVerticalAbs = /*#__PURE__*/function (_SVGPathSeg15) { + _inherits(_SVGPathSegLinetoVerticalAbs, _SVGPathSeg15); + + var _super14 = _createSuper(_SVGPathSegLinetoVerticalAbs); + + function _SVGPathSegLinetoVerticalAbs(owningPathSegList, y) { + var _this13; + + _classCallCheck(this, _SVGPathSegLinetoVerticalAbs); + + _this13 = _super14.call(this, _SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS, 'V', owningPathSegList); + _this13._y = y; + return _this13; + } + + _createClass(_SVGPathSegLinetoVerticalAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoVerticalAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoVerticalAbs(undefined, this._y); + } + }]); + + return _SVGPathSegLinetoVerticalAbs; + }(_SVGPathSeg); + + Object.defineProperty(_SVGPathSegLinetoVerticalAbs.prototype, 'y', { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }); + + var _SVGPathSegLinetoVerticalRel = /*#__PURE__*/function (_SVGPathSeg16) { + _inherits(_SVGPathSegLinetoVerticalRel, _SVGPathSeg16); + + var _super15 = _createSuper(_SVGPathSegLinetoVerticalRel); + + function _SVGPathSegLinetoVerticalRel(owningPathSegList, y) { + var _this14; + + _classCallCheck(this, _SVGPathSegLinetoVerticalRel); + + _this14 = _super15.call(this, _SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL, 'v', owningPathSegList); + _this14._y = y; + return _this14; + } + + _createClass(_SVGPathSegLinetoVerticalRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoVerticalRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoVerticalRel(undefined, this._y); + } + }]); + + return _SVGPathSegLinetoVerticalRel; + }(_SVGPathSeg); + + Object.defineProperty(_SVGPathSegLinetoVerticalRel.prototype, 'y', { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }); + + var _SVGPathSegCurvetoCubicSmoothAbs = /*#__PURE__*/function (_SVGPathSeg17) { + _inherits(_SVGPathSegCurvetoCubicSmoothAbs, _SVGPathSeg17); + + var _super16 = _createSuper(_SVGPathSegCurvetoCubicSmoothAbs); + + function _SVGPathSegCurvetoCubicSmoothAbs(owningPathSegList, x, y, x2, y2) { + var _this15; + + _classCallCheck(this, _SVGPathSegCurvetoCubicSmoothAbs); + + _this15 = _super16.call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS, 'S', owningPathSegList); + _this15._x = x; + _this15._y = y; + _this15._x2 = x2; + _this15._y2 = y2; + return _this15; + } + + _createClass(_SVGPathSegCurvetoCubicSmoothAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoCubicSmoothAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoCubicSmoothAbs(undefined, this._x, this._y, this._x2, this._y2); + } + }]); + + return _SVGPathSegCurvetoCubicSmoothAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoCubicSmoothAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x2: { + get: function get() { + return this._x2; + }, + set: function set(x2) { + this._x2 = x2; + + this._segmentChanged(); + }, + enumerable: true + }, + y2: { + get: function get() { + return this._y2; + }, + set: function set(y2) { + this._y2 = y2; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoCubicSmoothRel = /*#__PURE__*/function (_SVGPathSeg18) { + _inherits(_SVGPathSegCurvetoCubicSmoothRel, _SVGPathSeg18); + + var _super17 = _createSuper(_SVGPathSegCurvetoCubicSmoothRel); + + function _SVGPathSegCurvetoCubicSmoothRel(owningPathSegList, x, y, x2, y2) { + var _this16; + + _classCallCheck(this, _SVGPathSegCurvetoCubicSmoothRel); + + _this16 = _super17.call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL, 's', owningPathSegList); + _this16._x = x; + _this16._y = y; + _this16._x2 = x2; + _this16._y2 = y2; + return _this16; + } + + _createClass(_SVGPathSegCurvetoCubicSmoothRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoCubicSmoothRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoCubicSmoothRel(undefined, this._x, this._y, this._x2, this._y2); + } + }]); + + return _SVGPathSegCurvetoCubicSmoothRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoCubicSmoothRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x2: { + get: function get() { + return this._x2; + }, + set: function set(x2) { + this._x2 = x2; + + this._segmentChanged(); + }, + enumerable: true + }, + y2: { + get: function get() { + return this._y2; + }, + set: function set(y2) { + this._y2 = y2; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoQuadraticSmoothAbs = /*#__PURE__*/function (_SVGPathSeg19) { + _inherits(_SVGPathSegCurvetoQuadraticSmoothAbs, _SVGPathSeg19); + + var _super18 = _createSuper(_SVGPathSegCurvetoQuadraticSmoothAbs); + + function _SVGPathSegCurvetoQuadraticSmoothAbs(owningPathSegList, x, y) { + var _this17; + + _classCallCheck(this, _SVGPathSegCurvetoQuadraticSmoothAbs); + + _this17 = _super18.call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS, 'T', owningPathSegList); + _this17._x = x; + _this17._y = y; + return _this17; + } + + _createClass(_SVGPathSegCurvetoQuadraticSmoothAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoQuadraticSmoothAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoQuadraticSmoothAbs(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegCurvetoQuadraticSmoothAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoQuadraticSmoothAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoQuadraticSmoothRel = /*#__PURE__*/function (_SVGPathSeg20) { + _inherits(_SVGPathSegCurvetoQuadraticSmoothRel, _SVGPathSeg20); + + var _super19 = _createSuper(_SVGPathSegCurvetoQuadraticSmoothRel); + + function _SVGPathSegCurvetoQuadraticSmoothRel(owningPathSegList, x, y) { + var _this18; + + _classCallCheck(this, _SVGPathSegCurvetoQuadraticSmoothRel); + + _this18 = _super19.call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL, 't', owningPathSegList); + _this18._x = x; + _this18._y = y; + return _this18; + } + + _createClass(_SVGPathSegCurvetoQuadraticSmoothRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoQuadraticSmoothRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoQuadraticSmoothRel(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegCurvetoQuadraticSmoothRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoQuadraticSmoothRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); // Add createSVGPathSeg* functions to SVGPathElement. + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathElement. + + SVGPathElement.prototype.createSVGPathSegClosePath = function () { + return new _SVGPathSegClosePath(undefined); + }; + + SVGPathElement.prototype.createSVGPathSegMovetoAbs = function (x, y) { + return new _SVGPathSegMovetoAbs(undefined, x, y); + }; + + SVGPathElement.prototype.createSVGPathSegMovetoRel = function (x, y) { + return new _SVGPathSegMovetoRel(undefined, x, y); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoAbs = function (x, y) { + return new _SVGPathSegLinetoAbs(undefined, x, y); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoRel = function (x, y) { + return new _SVGPathSegLinetoRel(undefined, x, y); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoCubicAbs = function (x, y, x1, y1, x2, y2) { + return new _SVGPathSegCurvetoCubicAbs(undefined, x, y, x1, y1, x2, y2); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoCubicRel = function (x, y, x1, y1, x2, y2) { + return new _SVGPathSegCurvetoCubicRel(undefined, x, y, x1, y1, x2, y2); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticAbs = function (x, y, x1, y1) { + return new _SVGPathSegCurvetoQuadraticAbs(undefined, x, y, x1, y1); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticRel = function (x, y, x1, y1) { + return new _SVGPathSegCurvetoQuadraticRel(undefined, x, y, x1, y1); + }; + + SVGPathElement.prototype.createSVGPathSegArcAbs = function (x, y, r1, r2, angle, largeArcFlag, sweepFlag) { + return new _SVGPathSegArcAbs(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag); + }; + + SVGPathElement.prototype.createSVGPathSegArcRel = function (x, y, r1, r2, angle, largeArcFlag, sweepFlag) { + return new _SVGPathSegArcRel(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoHorizontalAbs = function (x) { + return new _SVGPathSegLinetoHorizontalAbs(undefined, x); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoHorizontalRel = function (x) { + return new _SVGPathSegLinetoHorizontalRel(undefined, x); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoVerticalAbs = function (y) { + return new _SVGPathSegLinetoVerticalAbs(undefined, y); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoVerticalRel = function (y) { + return new _SVGPathSegLinetoVerticalRel(undefined, y); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothAbs = function (x, y, x2, y2) { + return new _SVGPathSegCurvetoCubicSmoothAbs(undefined, x, y, x2, y2); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothRel = function (x, y, x2, y2) { + return new _SVGPathSegCurvetoCubicSmoothRel(undefined, x, y, x2, y2); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothAbs = function (x, y) { + return new _SVGPathSegCurvetoQuadraticSmoothAbs(undefined, x, y); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothRel = function (x, y) { + return new _SVGPathSegCurvetoQuadraticSmoothRel(undefined, x, y); + }; + + if (!('getPathSegAtLength' in SVGPathElement.prototype)) { + // Add getPathSegAtLength to SVGPathElement. + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-__svg__SVGPathElement__getPathSegAtLength + // This polyfill requires SVGPathElement.getTotalLength to implement the distance-along-a-path algorithm. + SVGPathElement.prototype.getPathSegAtLength = function (distance) { + if (distance === undefined || !isFinite(distance)) { + throw new Error('Invalid arguments.'); + } + + var measurementElement = document.createElementNS('http://www.w3.org/2000/svg', 'path'); + measurementElement.setAttribute('d', this.getAttribute('d')); + var lastPathSegment = measurementElement.pathSegList.numberOfItems - 1; // If the path is empty, return 0. + + if (lastPathSegment <= 0) { + return 0; + } + + do { + measurementElement.pathSegList.removeItem(lastPathSegment); + + if (distance > measurementElement.getTotalLength()) { + break; + } + + lastPathSegment--; + } while (lastPathSegment > 0); + + return lastPathSegment; + }; + } + + window.SVGPathSeg = _SVGPathSeg; + window.SVGPathSegClosePath = _SVGPathSegClosePath; + window.SVGPathSegMovetoAbs = _SVGPathSegMovetoAbs; + window.SVGPathSegMovetoRel = _SVGPathSegMovetoRel; + window.SVGPathSegLinetoAbs = _SVGPathSegLinetoAbs; + window.SVGPathSegLinetoRel = _SVGPathSegLinetoRel; + window.SVGPathSegCurvetoCubicAbs = _SVGPathSegCurvetoCubicAbs; + window.SVGPathSegCurvetoCubicRel = _SVGPathSegCurvetoCubicRel; + window.SVGPathSegCurvetoQuadraticAbs = _SVGPathSegCurvetoQuadraticAbs; + window.SVGPathSegCurvetoQuadraticRel = _SVGPathSegCurvetoQuadraticRel; + window.SVGPathSegArcAbs = _SVGPathSegArcAbs; + window.SVGPathSegArcRel = _SVGPathSegArcRel; + window.SVGPathSegLinetoHorizontalAbs = _SVGPathSegLinetoHorizontalAbs; + window.SVGPathSegLinetoHorizontalRel = _SVGPathSegLinetoHorizontalRel; + window.SVGPathSegLinetoVerticalAbs = _SVGPathSegLinetoVerticalAbs; + window.SVGPathSegLinetoVerticalRel = _SVGPathSegLinetoVerticalRel; + window.SVGPathSegCurvetoCubicSmoothAbs = _SVGPathSegCurvetoCubicSmoothAbs; + window.SVGPathSegCurvetoCubicSmoothRel = _SVGPathSegCurvetoCubicSmoothRel; + window.SVGPathSegCurvetoQuadraticSmoothAbs = _SVGPathSegCurvetoQuadraticSmoothAbs; + window.SVGPathSegCurvetoQuadraticSmoothRel = _SVGPathSegCurvetoQuadraticSmoothRel; + } // Checking for SVGPathSegList in window checks for the case of an implementation without the + // SVGPathSegList API. + // The second check for appendItem is specific to Firefox 59+ which removed only parts of the + // SVGPathSegList API (e.g., appendItem). In this case we need to re-implement the entire API + // so the polyfill data (i.e., _list) is used throughout. + + + if (!('SVGPathSegList' in window) || !('appendItem' in window.SVGPathSegList.prototype)) { + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSegList + var SVGPathSegList = /*#__PURE__*/function () { + function SVGPathSegList(pathElement) { + _classCallCheck(this, SVGPathSegList); + + this._pathElement = pathElement; + this._list = this._parsePath(this._pathElement.getAttribute('d')); // Use a MutationObserver to catch changes to the path's "d" attribute. + + this._mutationObserverConfig = { + attributes: true, + attributeFilter: ['d'] + }; + this._pathElementMutationObserver = new MutationObserver(this._updateListFromPathMutations.bind(this)); + + this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig); + } // Process any pending mutations to the path element and update the list as needed. + // This should be the first call of all public functions and is needed because + // MutationObservers are not synchronous so we can have pending asynchronous mutations. + + + _createClass(SVGPathSegList, [{ + key: "_checkPathSynchronizedToList", + value: function _checkPathSynchronizedToList() { + this._updateListFromPathMutations(this._pathElementMutationObserver.takeRecords()); + } + }, { + key: "_updateListFromPathMutations", + value: function _updateListFromPathMutations(mutationRecords) { + if (!this._pathElement) { + return; + } + + var hasPathMutations = false; + mutationRecords.forEach(function (record) { + if (record.attributeName === 'd') { + hasPathMutations = true; + } + }); + + if (hasPathMutations) { + this._list = this._parsePath(this._pathElement.getAttribute('d')); + } + } // Serialize the list and update the path's 'd' attribute. + + }, { + key: "_writeListToPath", + value: function _writeListToPath() { + this._pathElementMutationObserver.disconnect(); + + this._pathElement.setAttribute('d', SVGPathSegList._pathSegArrayAsString(this._list)); + + this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig); + } // When a path segment changes the list needs to be synchronized back to the path element. + + }, { + key: "segmentChanged", + value: function segmentChanged(pathSeg) { + this._writeListToPath(); + } + }, { + key: "clear", + value: function clear() { + this._checkPathSynchronizedToList(); + + this._list.forEach(function (pathSeg) { + pathSeg._owningPathSegList = null; + }); + + this._list = []; + + this._writeListToPath(); + } + }, { + key: "initialize", + value: function initialize(newItem) { + this._checkPathSynchronizedToList(); + + this._list = [newItem]; + newItem._owningPathSegList = this; + + this._writeListToPath(); + + return newItem; + } + }, { + key: "_checkValidIndex", + value: function _checkValidIndex(index) { + if (isNaN(index) || index < 0 || index >= this.numberOfItems) { + throw new Error('INDEX_SIZE_ERR'); + } + } + }, { + key: "getItem", + value: function getItem(index) { + this._checkPathSynchronizedToList(); + + this._checkValidIndex(index); + + return this._list[index]; + } + }, { + key: "insertItemBefore", + value: function insertItemBefore(newItem, index) { + this._checkPathSynchronizedToList(); // Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list. + + + if (index > this.numberOfItems) { + index = this.numberOfItems; + } + + if (newItem._owningPathSegList) { + // SVG2 spec says to make a copy. + newItem = newItem.clone(); + } + + this._list.splice(index, 0, newItem); + + newItem._owningPathSegList = this; + + this._writeListToPath(); + + return newItem; + } + }, { + key: "replaceItem", + value: function replaceItem(newItem, index) { + this._checkPathSynchronizedToList(); + + if (newItem._owningPathSegList) { + // SVG2 spec says to make a copy. + newItem = newItem.clone(); + } + + this._checkValidIndex(index); + + this._list[index] = newItem; + newItem._owningPathSegList = this; + + this._writeListToPath(); + + return newItem; + } + }, { + key: "removeItem", + value: function removeItem(index) { + this._checkPathSynchronizedToList(); + + this._checkValidIndex(index); + + var item = this._list[index]; + + this._list.splice(index, 1); + + this._writeListToPath(); + + return item; + } + }, { + key: "appendItem", + value: function appendItem(newItem) { + this._checkPathSynchronizedToList(); + + if (newItem._owningPathSegList) { + // SVG2 spec says to make a copy. + newItem = newItem.clone(); + } + + this._list.push(newItem); + + newItem._owningPathSegList = this; // TODO: Optimize this to just append to the existing attribute. + + this._writeListToPath(); + + return newItem; + } // This closely follows SVGPathParser::parsePath from Source/core/svg/SVGPathParser.cpp. + + }, { + key: "_parsePath", + value: function _parsePath(string) { + if (!string || !string.length) { + return []; + } + + var owningPathSegList = this; + + var Builder = /*#__PURE__*/function () { + function Builder() { + _classCallCheck(this, Builder); + + this.pathSegList = []; + } + + _createClass(Builder, [{ + key: "appendSegment", + value: function appendSegment(pathSeg) { + this.pathSegList.push(pathSeg); + } + }]); + + return Builder; + }(); + + var Source = /*#__PURE__*/function () { + function Source(string) { + _classCallCheck(this, Source); + + this._string = string; + this._currentIndex = 0; + this._endIndex = this._string.length; + this._previousCommand = SVGPathSeg.PATHSEG_UNKNOWN; + + this._skipOptionalSpaces(); + } + + _createClass(Source, [{ + key: "_isCurrentSpace", + value: function _isCurrentSpace() { + var character = this._string[this._currentIndex]; + return character <= ' ' && (character === ' ' || character === '\n' || character === '\t' || character === '\r' || character === '\f'); + } + }, { + key: "_skipOptionalSpaces", + value: function _skipOptionalSpaces() { + while (this._currentIndex < this._endIndex && this._isCurrentSpace()) { + this._currentIndex++; + } + + return this._currentIndex < this._endIndex; + } + }, { + key: "_skipOptionalSpacesOrDelimiter", + value: function _skipOptionalSpacesOrDelimiter() { + if (this._currentIndex < this._endIndex && !this._isCurrentSpace() && this._string.charAt(this._currentIndex) !== ',') { + return false; + } + + if (this._skipOptionalSpaces()) { + if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === ',') { + this._currentIndex++; + + this._skipOptionalSpaces(); + } + } + + return this._currentIndex < this._endIndex; + } + }, { + key: "hasMoreData", + value: function hasMoreData() { + return this._currentIndex < this._endIndex; + } + }, { + key: "peekSegmentType", + value: function peekSegmentType() { + var lookahead = this._string[this._currentIndex]; + return this._pathSegTypeFromChar(lookahead); + } + }, { + key: "_pathSegTypeFromChar", + value: function _pathSegTypeFromChar(lookahead) { + switch (lookahead) { + case 'Z': + case 'z': + return SVGPathSeg.PATHSEG_CLOSEPATH; + + case 'M': + return SVGPathSeg.PATHSEG_MOVETO_ABS; + + case 'm': + return SVGPathSeg.PATHSEG_MOVETO_REL; + + case 'L': + return SVGPathSeg.PATHSEG_LINETO_ABS; + + case 'l': + return SVGPathSeg.PATHSEG_LINETO_REL; + + case 'C': + return SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS; + + case 'c': + return SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL; + + case 'Q': + return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS; + + case 'q': + return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL; + + case 'A': + return SVGPathSeg.PATHSEG_ARC_ABS; + + case 'a': + return SVGPathSeg.PATHSEG_ARC_REL; + + case 'H': + return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS; + + case 'h': + return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL; + + case 'V': + return SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS; + + case 'v': + return SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL; + + case 'S': + return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS; + + case 's': + return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL; + + case 'T': + return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS; + + case 't': + return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL; + + default: + return SVGPathSeg.PATHSEG_UNKNOWN; + } + } + }, { + key: "_nextCommandHelper", + value: function _nextCommandHelper(lookahead, previousCommand) { + // Check for remaining coordinates in the current command. + if ((lookahead === '+' || lookahead === '-' || lookahead === '.' || lookahead >= '0' && lookahead <= '9') && previousCommand !== SVGPathSeg.PATHSEG_CLOSEPATH) { + if (previousCommand === SVGPathSeg.PATHSEG_MOVETO_ABS) { + return SVGPathSeg.PATHSEG_LINETO_ABS; + } + + if (previousCommand === SVGPathSeg.PATHSEG_MOVETO_REL) { + return SVGPathSeg.PATHSEG_LINETO_REL; + } + + return previousCommand; + } + + return SVGPathSeg.PATHSEG_UNKNOWN; + } + }, { + key: "initialCommandIsMoveTo", + value: function initialCommandIsMoveTo() { + // If the path is empty it is still valid, so return true. + if (!this.hasMoreData()) { + return true; + } + + var command = this.peekSegmentType(); // Path must start with moveTo. + + return command === SVGPathSeg.PATHSEG_MOVETO_ABS || command === SVGPathSeg.PATHSEG_MOVETO_REL; + } // Parse a number from an SVG path. This very closely follows genericParseNumber(...) from Source/core/svg/SVGParserUtilities.cpp. + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-PathDataBNF + + }, { + key: "_parseNumber", + value: function _parseNumber() { + var exponent = 0; + var integer = 0; + var frac = 1; + var decimal = 0; + var sign = 1; + var expsign = 1; + var startIndex = this._currentIndex; + + this._skipOptionalSpaces(); // Read the sign. + + + if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '+') { + this._currentIndex++; + } else if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '-') { + this._currentIndex++; + sign = -1; + } + + if (this._currentIndex === this._endIndex || (this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') && this._string.charAt(this._currentIndex) !== '.') { + // The first character of a number must be one of [0-9+-.]. + return undefined; + } // Read the integer part, build right-to-left. + + + var startIntPartIndex = this._currentIndex; + + while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') { + this._currentIndex++; // Advance to first non-digit. + } + + if (this._currentIndex !== startIntPartIndex) { + var scanIntPartIndex = this._currentIndex - 1; + var multiplier = 1; + + while (scanIntPartIndex >= startIntPartIndex) { + integer += multiplier * (this._string.charAt(scanIntPartIndex--) - '0'); + multiplier *= 10; + } + } // Read the decimals. + + + if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '.') { + this._currentIndex++; // There must be a least one digit following the . + + if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') { + return undefined; + } + + while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') { + frac *= 10; + decimal += (this._string.charAt(this._currentIndex) - '0') / frac; + this._currentIndex += 1; + } + } // Read the exponent part. + + + if (this._currentIndex !== startIndex && this._currentIndex + 1 < this._endIndex && (this._string.charAt(this._currentIndex) === 'e' || this._string.charAt(this._currentIndex) === 'E') && this._string.charAt(this._currentIndex + 1) !== 'x' && this._string.charAt(this._currentIndex + 1) !== 'm') { + this._currentIndex++; // Read the sign of the exponent. + + if (this._string.charAt(this._currentIndex) === '+') { + this._currentIndex++; + } else if (this._string.charAt(this._currentIndex) === '-') { + this._currentIndex++; + expsign = -1; + } // There must be an exponent. + + + if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') { + return undefined; + } + + while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') { + exponent *= 10; + exponent += this._string.charAt(this._currentIndex) - '0'; + this._currentIndex++; + } + } + + var number = integer + decimal; + number *= sign; + + if (exponent) { + number *= Math.pow(10, expsign * exponent); + } + + if (startIndex === this._currentIndex) { + return undefined; + } + + this._skipOptionalSpacesOrDelimiter(); + + return number; + } + }, { + key: "_parseArcFlag", + value: function _parseArcFlag() { + if (this._currentIndex >= this._endIndex) { + return undefined; + } + + var flag = false; + + var flagChar = this._string.charAt(this._currentIndex++); + + if (flagChar === '0') { + flag = false; + } else if (flagChar === '1') { + flag = true; + } else { + return undefined; + } + + this._skipOptionalSpacesOrDelimiter(); + + return flag; + } + }, { + key: "parseSegment", + value: function parseSegment() { + var lookahead = this._string[this._currentIndex]; + + var command = this._pathSegTypeFromChar(lookahead); + + if (command === SVGPathSeg.PATHSEG_UNKNOWN) { + // Possibly an implicit command. Not allowed if this is the first command. + if (this._previousCommand === SVGPathSeg.PATHSEG_UNKNOWN) { + return null; + } + + command = this._nextCommandHelper(lookahead, this._previousCommand); + + if (command === SVGPathSeg.PATHSEG_UNKNOWN) { + return null; + } + } else { + this._currentIndex++; + } + + this._previousCommand = command; + + switch (command) { + case SVGPathSeg.PATHSEG_MOVETO_REL: + return new SVGPathSegMovetoRel(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_MOVETO_ABS: + return new SVGPathSegMovetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_REL: + return new SVGPathSegLinetoRel(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_ABS: + return new SVGPathSegLinetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL: + return new SVGPathSegLinetoHorizontalRel(owningPathSegList, this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS: + return new SVGPathSegLinetoHorizontalAbs(owningPathSegList, this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL: + return new SVGPathSegLinetoVerticalRel(owningPathSegList, this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS: + return new SVGPathSegLinetoVerticalAbs(owningPathSegList, this._parseNumber()); + + case SVGPathSeg.PATHSEG_CLOSEPATH: + this._skipOptionalSpaces(); + + return new SVGPathSegClosePath(owningPathSegList); + + case SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL: + { + var points = { + x1: this._parseNumber(), + y1: this._parseNumber(), + x2: this._parseNumber(), + y2: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoCubicRel(owningPathSegList, points.x, points.y, points.x1, points.y1, points.x2, points.y2); + } + + case SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS: + { + var _points = { + x1: this._parseNumber(), + y1: this._parseNumber(), + x2: this._parseNumber(), + y2: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoCubicAbs(owningPathSegList, _points.x, _points.y, _points.x1, _points.y1, _points.x2, _points.y2); + } + + case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL: + { + var _points2 = { + x2: this._parseNumber(), + y2: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoCubicSmoothRel(owningPathSegList, _points2.x, _points2.y, _points2.x2, _points2.y2); + } + + case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: + { + var _points3 = { + x2: this._parseNumber(), + y2: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoCubicSmoothAbs(owningPathSegList, _points3.x, _points3.y, _points3.x2, _points3.y2); + } + + case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL: + { + var _points4 = { + x1: this._parseNumber(), + y1: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoQuadraticRel(owningPathSegList, _points4.x, _points4.y, _points4.x1, _points4.y1); + } + + case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS: + { + var _points5 = { + x1: this._parseNumber(), + y1: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoQuadraticAbs(owningPathSegList, _points5.x, _points5.y, _points5.x1, _points5.y1); + } + + case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: + return new SVGPathSegCurvetoQuadraticSmoothRel(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: + return new SVGPathSegCurvetoQuadraticSmoothAbs(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_ARC_REL: + { + var _points6 = { + x1: this._parseNumber(), + y1: this._parseNumber(), + arcAngle: this._parseNumber(), + arcLarge: this._parseArcFlag(), + arcSweep: this._parseArcFlag(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegArcRel(owningPathSegList, _points6.x, _points6.y, _points6.x1, _points6.y1, _points6.arcAngle, _points6.arcLarge, _points6.arcSweep); + } + + case SVGPathSeg.PATHSEG_ARC_ABS: + { + var _points7 = { + x1: this._parseNumber(), + y1: this._parseNumber(), + arcAngle: this._parseNumber(), + arcLarge: this._parseArcFlag(), + arcSweep: this._parseArcFlag(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegArcAbs(owningPathSegList, _points7.x, _points7.y, _points7.x1, _points7.y1, _points7.arcAngle, _points7.arcLarge, _points7.arcSweep); + } + + default: + throw new Error('Unknown path seg type.'); + } + } + }]); + + return Source; + }(); + + var builder = new Builder(); + var source = new Source(string); + + if (!source.initialCommandIsMoveTo()) { + return []; + } + + while (source.hasMoreData()) { + var pathSeg = source.parseSegment(); + + if (!pathSeg) { + return []; + } + + builder.appendSegment(pathSeg); + } + + return builder.pathSegList; + } // STATIC + + }], [{ + key: "_pathSegArrayAsString", + value: function _pathSegArrayAsString(pathSegArray) { + var string = ''; + var first = true; + pathSegArray.forEach(function (pathSeg) { + if (first) { + first = false; + string += pathSeg._asPathString(); + } else { + string += ' ' + pathSeg._asPathString(); + } + }); + return string; + } + }]); + + return SVGPathSegList; + }(); + + SVGPathSegList.prototype.classname = 'SVGPathSegList'; + Object.defineProperty(SVGPathSegList.prototype, 'numberOfItems', { + get: function get() { + this._checkPathSynchronizedToList(); + + return this._list.length; + }, + enumerable: true + }); // Add the pathSegList accessors to SVGPathElement. + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGAnimatedPathData + + Object.defineProperties(SVGPathElement.prototype, { + pathSegList: { + get: function get() { + if (!this._pathSegList) { + this._pathSegList = new SVGPathSegList(this); + } + + return this._pathSegList; + }, + enumerable: true + }, + // TODO: The following are not implemented and simply return SVGPathElement.pathSegList. + normalizedPathSegList: { + get: function get() { + return this.pathSegList; + }, + enumerable: true + }, + animatedPathSegList: { + get: function get() { + return this.pathSegList; + }, + enumerable: true + }, + animatedNormalizedPathSegList: { + get: function get() { + return this.pathSegList; + }, + enumerable: true + } + }); + window.SVGPathSegList = SVGPathSegList; + } +})(); + +// The button toggles whether the path is open or closed + +var extClosepath = { + name: 'closepath', + init: function init(_ref) { + var _this = this; + + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var importLocale, $, strings, svgEditor, selElems, updateButton, showPanel, toggleClosed, buttons; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + importLocale = _ref.importLocale, $ = _ref.$; + _context.next = 3; + return importLocale(); + + case 3: + strings = _context.sent; + svgEditor = _this; + + updateButton = function updateButton(path) { + var seglist = path.pathSegList, + closed = seglist.getItem(seglist.numberOfItems - 1).pathSegType === 1, + showbutton = closed ? '#tool_openpath' : '#tool_closepath', + hidebutton = closed ? '#tool_closepath' : '#tool_openpath'; + $(hidebutton).hide(); + $(showbutton).show(); + }; + + showPanel = function showPanel(on) { + $('#closepath_panel').toggle(on); + + if (on) { + var path = selElems[0]; + + if (path) { + updateButton(path); + } + } + }; + + toggleClosed = function toggleClosed() { + var path = selElems[0]; + + if (path) { + var seglist = path.pathSegList, + last = seglist.numberOfItems - 1; // is closed + + if (seglist.getItem(last).pathSegType === 1) { + seglist.removeItem(last); + } else { + seglist.appendItem(path.createSVGPathSegClosePath()); + } + + updateButton(path); + } + }; + + buttons = [{ + id: 'tool_openpath', + icon: svgEditor.curConfig.extIconsPath + 'openpath.png', + type: 'context', + panel: 'closepath_panel', + events: { + click: function click() { + toggleClosed(); + } + } + }, { + id: 'tool_closepath', + icon: svgEditor.curConfig.extIconsPath + 'closepath.png', + type: 'context', + panel: 'closepath_panel', + events: { + click: function click() { + toggleClosed(); + } + } + }]; + return _context.abrupt("return", { + name: strings.name, + svgicons: svgEditor.curConfig.extIconsPath + 'closepath_icons.svg', + buttons: strings.buttons.map(function (button, i) { + return Object.assign(buttons[i], button); + }), + callback: function callback() { + $('#closepath_panel').hide(); + }, + selectedChanged: function selectedChanged(opts) { + selElems = opts.elems; + var i = selElems.length; + + while (i--) { + var elem = selElems[i]; + + if (elem && elem.tagName === 'path') { + if (opts.selectedElement && !opts.multiselected) { + showPanel(true); + } else { + showPanel(false); + } + } else { + showPanel(false); + } + } + } + }); + + case 10: + case "end": + return _context.stop(); + } + } + }, _callee); + }))(); + } +}; + +export default extClosepath; +//# sourceMappingURL=ext-closepath.js.map diff --git a/dist/editor/extensions/ext-closepath.js.map b/dist/editor/extensions/ext-closepath.js.map new file mode 100644 index 00000000..9eeda1d6 --- /dev/null +++ b/dist/editor/extensions/ext-closepath.js.map @@ -0,0 +1 @@ +{"version":3,"file":"ext-closepath.js","sources":["../../../src/common/svgpathseg.js","../../../src/editor/extensions/ext-closepath.js"],"sourcesContent":["/* eslint-disable import/unambiguous, max-len */\n/* globals SVGPathSeg, SVGPathSegMovetoRel, SVGPathSegMovetoAbs,\n SVGPathSegMovetoRel, SVGPathSegLinetoRel, SVGPathSegLinetoAbs,\n SVGPathSegLinetoHorizontalRel, SVGPathSegLinetoHorizontalAbs,\n SVGPathSegLinetoVerticalRel, SVGPathSegLinetoVerticalAbs,\n SVGPathSegClosePath, SVGPathSegCurvetoCubicRel,\n SVGPathSegCurvetoCubicAbs, SVGPathSegCurvetoCubicSmoothRel,\n SVGPathSegCurvetoCubicSmoothAbs, SVGPathSegCurvetoQuadraticRel,\n SVGPathSegCurvetoQuadraticAbs, SVGPathSegCurvetoQuadraticSmoothRel,\n SVGPathSegCurvetoQuadraticSmoothAbs, SVGPathSegArcRel, SVGPathSegArcAbs */\n/**\n* SVGPathSeg API polyfill\n* https://github.com/progers/pathseg\n*\n* This is a drop-in replacement for the `SVGPathSeg` and `SVGPathSegList` APIs\n* that were removed from SVG2 ({@link https://lists.w3.org/Archives/Public/www-svg/2015Jun/0044.html}),\n* including the latest spec changes which were implemented in Firefox 43 and\n* Chrome 46.\n*/\n/* eslint-disable no-shadow, class-methods-use-this, jsdoc/require-jsdoc */\n// Linting: We avoid `no-shadow` as ESLint thinks these are still available globals\n// Linting: We avoid `class-methods-use-this` as this is a polyfill that must\n// follow the conventions\n(() => {\nif (!('SVGPathSeg' in window)) {\n // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSeg\n class SVGPathSeg {\n constructor (type, typeAsLetter, owningPathSegList) {\n this.pathSegType = type;\n this.pathSegTypeAsLetter = typeAsLetter;\n this._owningPathSegList = owningPathSegList;\n }\n // Notify owning PathSegList on any changes so they can be synchronized back to the path element.\n _segmentChanged () {\n if (this._owningPathSegList) {\n this._owningPathSegList.segmentChanged(this);\n }\n }\n }\n SVGPathSeg.prototype.classname = 'SVGPathSeg';\n\n SVGPathSeg.PATHSEG_UNKNOWN = 0;\n SVGPathSeg.PATHSEG_CLOSEPATH = 1;\n SVGPathSeg.PATHSEG_MOVETO_ABS = 2;\n SVGPathSeg.PATHSEG_MOVETO_REL = 3;\n SVGPathSeg.PATHSEG_LINETO_ABS = 4;\n SVGPathSeg.PATHSEG_LINETO_REL = 5;\n SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS = 6;\n SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL = 7;\n SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS = 8;\n SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL = 9;\n SVGPathSeg.PATHSEG_ARC_ABS = 10;\n SVGPathSeg.PATHSEG_ARC_REL = 11;\n SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS = 12;\n SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL = 13;\n SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS = 14;\n SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL = 15;\n SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16;\n SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17;\n SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18;\n SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19;\n\n class SVGPathSegClosePath extends SVGPathSeg {\n constructor (owningPathSegList) {\n super(SVGPathSeg.PATHSEG_CLOSEPATH, 'z', owningPathSegList);\n }\n toString () { return '[object SVGPathSegClosePath]'; }\n _asPathString () { return this.pathSegTypeAsLetter; }\n clone () { return new SVGPathSegClosePath(undefined); }\n }\n\n class SVGPathSegMovetoAbs extends SVGPathSeg {\n constructor (owningPathSegList, x, y) {\n super(SVGPathSeg.PATHSEG_MOVETO_ABS, 'M', owningPathSegList);\n this._x = x;\n this._y = y;\n }\n toString () { return '[object SVGPathSegMovetoAbs]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegMovetoAbs(undefined, this._x, this._y); }\n }\n Object.defineProperties(SVGPathSegMovetoAbs.prototype, {\n x: {\n get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true\n },\n y: {\n get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true\n }\n });\n\n class SVGPathSegMovetoRel extends SVGPathSeg {\n constructor (owningPathSegList, x, y) {\n super(SVGPathSeg.PATHSEG_MOVETO_REL, 'm', owningPathSegList);\n this._x = x;\n this._y = y;\n }\n toString () { return '[object SVGPathSegMovetoRel]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegMovetoRel(undefined, this._x, this._y); }\n }\n Object.defineProperties(SVGPathSegMovetoRel.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegLinetoAbs extends SVGPathSeg {\n constructor (owningPathSegList, x, y) {\n super(SVGPathSeg.PATHSEG_LINETO_ABS, 'L', owningPathSegList);\n this._x = x;\n this._y = y;\n }\n toString () { return '[object SVGPathSegLinetoAbs]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegLinetoAbs(undefined, this._x, this._y); }\n }\n Object.defineProperties(SVGPathSegLinetoAbs.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegLinetoRel extends SVGPathSeg {\n constructor (owningPathSegList, x, y) {\n super(SVGPathSeg.PATHSEG_LINETO_REL, 'l', owningPathSegList);\n this._x = x;\n this._y = y;\n }\n toString () { return '[object SVGPathSegLinetoRel]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegLinetoRel(undefined, this._x, this._y); }\n }\n Object.defineProperties(SVGPathSegLinetoRel.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegCurvetoCubicAbs extends SVGPathSeg {\n constructor (owningPathSegList, x, y, x1, y1, x2, y2) {\n super(SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS, 'C', owningPathSegList);\n this._x = x;\n this._y = y;\n this._x1 = x1;\n this._y1 = y1;\n this._x2 = x2;\n this._y2 = y2;\n }\n toString () { return '[object SVGPathSegCurvetoCubicAbs]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegCurvetoCubicAbs(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2); }\n }\n Object.defineProperties(SVGPathSegCurvetoCubicAbs.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n x1: {get () { return this._x1; }, set (x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true},\n y1: {get () { return this._y1; }, set (y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true},\n x2: {get () { return this._x2; }, set (x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true},\n y2: {get () { return this._y2; }, set (y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegCurvetoCubicRel extends SVGPathSeg {\n constructor (owningPathSegList, x, y, x1, y1, x2, y2) {\n super(SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL, 'c', owningPathSegList);\n this._x = x;\n this._y = y;\n this._x1 = x1;\n this._y1 = y1;\n this._x2 = x2;\n this._y2 = y2;\n }\n toString () { return '[object SVGPathSegCurvetoCubicRel]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegCurvetoCubicRel(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2); }\n }\n Object.defineProperties(SVGPathSegCurvetoCubicRel.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n x1: {get () { return this._x1; }, set (x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true},\n y1: {get () { return this._y1; }, set (y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true},\n x2: {get () { return this._x2; }, set (x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true},\n y2: {get () { return this._y2; }, set (y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegCurvetoQuadraticAbs extends SVGPathSeg {\n constructor (owningPathSegList, x, y, x1, y1) {\n super(SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS, 'Q', owningPathSegList);\n this._x = x;\n this._y = y;\n this._x1 = x1;\n this._y1 = y1;\n }\n toString () { return '[object SVGPathSegCurvetoQuadraticAbs]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegCurvetoQuadraticAbs(undefined, this._x, this._y, this._x1, this._y1); }\n }\n Object.defineProperties(SVGPathSegCurvetoQuadraticAbs.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n x1: {get () { return this._x1; }, set (x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true},\n y1: {get () { return this._y1; }, set (y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegCurvetoQuadraticRel extends SVGPathSeg {\n constructor (owningPathSegList, x, y, x1, y1) {\n super(SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL, 'q', owningPathSegList);\n this._x = x;\n this._y = y;\n this._x1 = x1;\n this._y1 = y1;\n }\n toString () { return '[object SVGPathSegCurvetoQuadraticRel]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegCurvetoQuadraticRel(undefined, this._x, this._y, this._x1, this._y1); }\n }\n Object.defineProperties(SVGPathSegCurvetoQuadraticRel.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n x1: {get () { return this._x1; }, set (x1) { this._x1 = x1; this._segmentChanged(); }, enumerable: true},\n y1: {get () { return this._y1; }, set (y1) { this._y1 = y1; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegArcAbs extends SVGPathSeg {\n constructor (owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) {\n super(SVGPathSeg.PATHSEG_ARC_ABS, 'A', owningPathSegList);\n this._x = x;\n this._y = y;\n this._r1 = r1;\n this._r2 = r2;\n this._angle = angle;\n this._largeArcFlag = largeArcFlag;\n this._sweepFlag = sweepFlag;\n }\n toString () { return '[object SVGPathSegArcAbs]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle + ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0') + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegArcAbs(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag); }\n }\n Object.defineProperties(SVGPathSegArcAbs.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n r1: {get () { return this._r1; }, set (r1) { this._r1 = r1; this._segmentChanged(); }, enumerable: true},\n r2: {get () { return this._r2; }, set (r2) { this._r2 = r2; this._segmentChanged(); }, enumerable: true},\n angle: {get () { return this._angle; }, set (angle) { this._angle = angle; this._segmentChanged(); }, enumerable: true},\n largeArcFlag: {get () { return this._largeArcFlag; }, set (largeArcFlag) { this._largeArcFlag = largeArcFlag; this._segmentChanged(); }, enumerable: true},\n sweepFlag: {get () { return this._sweepFlag; }, set (sweepFlag) { this._sweepFlag = sweepFlag; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegArcRel extends SVGPathSeg {\n constructor (owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) {\n super(SVGPathSeg.PATHSEG_ARC_REL, 'a', owningPathSegList);\n this._x = x;\n this._y = y;\n this._r1 = r1;\n this._r2 = r2;\n this._angle = angle;\n this._largeArcFlag = largeArcFlag;\n this._sweepFlag = sweepFlag;\n }\n toString () { return '[object SVGPathSegArcRel]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle + ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0') + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegArcRel(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag); }\n }\n Object.defineProperties(SVGPathSegArcRel.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n r1: {get () { return this._r1; }, set (r1) { this._r1 = r1; this._segmentChanged(); }, enumerable: true},\n r2: {get () { return this._r2; }, set (r2) { this._r2 = r2; this._segmentChanged(); }, enumerable: true},\n angle: {get () { return this._angle; }, set (angle) { this._angle = angle; this._segmentChanged(); }, enumerable: true},\n largeArcFlag: {get () { return this._largeArcFlag; }, set (largeArcFlag) { this._largeArcFlag = largeArcFlag; this._segmentChanged(); }, enumerable: true},\n sweepFlag: {get () { return this._sweepFlag; }, set (sweepFlag) { this._sweepFlag = sweepFlag; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegLinetoHorizontalAbs extends SVGPathSeg {\n constructor (owningPathSegList, x) {\n super(SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS, 'H', owningPathSegList);\n this._x = x;\n }\n toString () { return '[object SVGPathSegLinetoHorizontalAbs]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x; }\n clone () { return new SVGPathSegLinetoHorizontalAbs(undefined, this._x); }\n }\n Object.defineProperty(SVGPathSegLinetoHorizontalAbs.prototype, 'x', {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true});\n\n class SVGPathSegLinetoHorizontalRel extends SVGPathSeg {\n constructor (owningPathSegList, x) {\n super(SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL, 'h', owningPathSegList);\n this._x = x;\n }\n toString () { return '[object SVGPathSegLinetoHorizontalRel]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x; }\n clone () { return new SVGPathSegLinetoHorizontalRel(undefined, this._x); }\n }\n Object.defineProperty(SVGPathSegLinetoHorizontalRel.prototype, 'x', {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true});\n\n class SVGPathSegLinetoVerticalAbs extends SVGPathSeg {\n constructor (owningPathSegList, y) {\n super(SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS, 'V', owningPathSegList);\n this._y = y;\n }\n toString () { return '[object SVGPathSegLinetoVerticalAbs]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._y; }\n clone () { return new SVGPathSegLinetoVerticalAbs(undefined, this._y); }\n }\n Object.defineProperty(SVGPathSegLinetoVerticalAbs.prototype, 'y', {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true});\n\n class SVGPathSegLinetoVerticalRel extends SVGPathSeg {\n constructor (owningPathSegList, y) {\n super(SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL, 'v', owningPathSegList);\n this._y = y;\n }\n toString () { return '[object SVGPathSegLinetoVerticalRel]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._y; }\n clone () { return new SVGPathSegLinetoVerticalRel(undefined, this._y); }\n }\n Object.defineProperty(SVGPathSegLinetoVerticalRel.prototype, 'y', {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true});\n\n class SVGPathSegCurvetoCubicSmoothAbs extends SVGPathSeg {\n constructor (owningPathSegList, x, y, x2, y2) {\n super(SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS, 'S', owningPathSegList);\n this._x = x;\n this._y = y;\n this._x2 = x2;\n this._y2 = y2;\n }\n toString () { return '[object SVGPathSegCurvetoCubicSmoothAbs]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegCurvetoCubicSmoothAbs(undefined, this._x, this._y, this._x2, this._y2); }\n }\n Object.defineProperties(SVGPathSegCurvetoCubicSmoothAbs.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n x2: {get () { return this._x2; }, set (x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true},\n y2: {get () { return this._y2; }, set (y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegCurvetoCubicSmoothRel extends SVGPathSeg {\n constructor (owningPathSegList, x, y, x2, y2) {\n super(SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL, 's', owningPathSegList);\n this._x = x;\n this._y = y;\n this._x2 = x2;\n this._y2 = y2;\n }\n toString () { return '[object SVGPathSegCurvetoCubicSmoothRel]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegCurvetoCubicSmoothRel(undefined, this._x, this._y, this._x2, this._y2); }\n }\n Object.defineProperties(SVGPathSegCurvetoCubicSmoothRel.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true},\n x2: {get () { return this._x2; }, set (x2) { this._x2 = x2; this._segmentChanged(); }, enumerable: true},\n y2: {get () { return this._y2; }, set (y2) { this._y2 = y2; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegCurvetoQuadraticSmoothAbs extends SVGPathSeg {\n constructor (owningPathSegList, x, y) {\n super(SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS, 'T', owningPathSegList);\n this._x = x;\n this._y = y;\n }\n toString () { return '[object SVGPathSegCurvetoQuadraticSmoothAbs]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegCurvetoQuadraticSmoothAbs(undefined, this._x, this._y); }\n }\n Object.defineProperties(SVGPathSegCurvetoQuadraticSmoothAbs.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true}\n });\n\n class SVGPathSegCurvetoQuadraticSmoothRel extends SVGPathSeg {\n constructor (owningPathSegList, x, y) {\n super(SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL, 't', owningPathSegList);\n this._x = x;\n this._y = y;\n }\n toString () { return '[object SVGPathSegCurvetoQuadraticSmoothRel]'; }\n _asPathString () { return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; }\n clone () { return new SVGPathSegCurvetoQuadraticSmoothRel(undefined, this._x, this._y); }\n }\n Object.defineProperties(SVGPathSegCurvetoQuadraticSmoothRel.prototype, {\n x: {get () { return this._x; }, set (x) { this._x = x; this._segmentChanged(); }, enumerable: true},\n y: {get () { return this._y; }, set (y) { this._y = y; this._segmentChanged(); }, enumerable: true}\n });\n\n // Add createSVGPathSeg* functions to SVGPathElement.\n // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathElement.\n SVGPathElement.prototype.createSVGPathSegClosePath = function () { return new SVGPathSegClosePath(undefined); };\n SVGPathElement.prototype.createSVGPathSegMovetoAbs = function (x, y) { return new SVGPathSegMovetoAbs(undefined, x, y); };\n SVGPathElement.prototype.createSVGPathSegMovetoRel = function (x, y) { return new SVGPathSegMovetoRel(undefined, x, y); };\n SVGPathElement.prototype.createSVGPathSegLinetoAbs = function (x, y) { return new SVGPathSegLinetoAbs(undefined, x, y); };\n SVGPathElement.prototype.createSVGPathSegLinetoRel = function (x, y) { return new SVGPathSegLinetoRel(undefined, x, y); };\n SVGPathElement.prototype.createSVGPathSegCurvetoCubicAbs = function (x, y, x1, y1, x2, y2) { return new SVGPathSegCurvetoCubicAbs(undefined, x, y, x1, y1, x2, y2); };\n SVGPathElement.prototype.createSVGPathSegCurvetoCubicRel = function (x, y, x1, y1, x2, y2) { return new SVGPathSegCurvetoCubicRel(undefined, x, y, x1, y1, x2, y2); };\n SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticAbs = function (x, y, x1, y1) { return new SVGPathSegCurvetoQuadraticAbs(undefined, x, y, x1, y1); };\n SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticRel = function (x, y, x1, y1) { return new SVGPathSegCurvetoQuadraticRel(undefined, x, y, x1, y1); };\n SVGPathElement.prototype.createSVGPathSegArcAbs = function (x, y, r1, r2, angle, largeArcFlag, sweepFlag) { return new SVGPathSegArcAbs(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag); };\n SVGPathElement.prototype.createSVGPathSegArcRel = function (x, y, r1, r2, angle, largeArcFlag, sweepFlag) { return new SVGPathSegArcRel(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag); };\n SVGPathElement.prototype.createSVGPathSegLinetoHorizontalAbs = function (x) { return new SVGPathSegLinetoHorizontalAbs(undefined, x); };\n SVGPathElement.prototype.createSVGPathSegLinetoHorizontalRel = function (x) { return new SVGPathSegLinetoHorizontalRel(undefined, x); };\n SVGPathElement.prototype.createSVGPathSegLinetoVerticalAbs = function (y) { return new SVGPathSegLinetoVerticalAbs(undefined, y); };\n SVGPathElement.prototype.createSVGPathSegLinetoVerticalRel = function (y) { return new SVGPathSegLinetoVerticalRel(undefined, y); };\n SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothAbs = function (x, y, x2, y2) { return new SVGPathSegCurvetoCubicSmoothAbs(undefined, x, y, x2, y2); };\n SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothRel = function (x, y, x2, y2) { return new SVGPathSegCurvetoCubicSmoothRel(undefined, x, y, x2, y2); };\n SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothAbs = function (x, y) { return new SVGPathSegCurvetoQuadraticSmoothAbs(undefined, x, y); };\n SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothRel = function (x, y) { return new SVGPathSegCurvetoQuadraticSmoothRel(undefined, x, y); };\n\n if (!('getPathSegAtLength' in SVGPathElement.prototype)) {\n // Add getPathSegAtLength to SVGPathElement.\n // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-__svg__SVGPathElement__getPathSegAtLength\n // This polyfill requires SVGPathElement.getTotalLength to implement the distance-along-a-path algorithm.\n SVGPathElement.prototype.getPathSegAtLength = function (distance) {\n if (distance === undefined || !isFinite(distance)) {\n throw new Error('Invalid arguments.');\n }\n\n const measurementElement = document.createElementNS('http://www.w3.org/2000/svg', 'path');\n measurementElement.setAttribute('d', this.getAttribute('d'));\n let lastPathSegment = measurementElement.pathSegList.numberOfItems - 1;\n\n // If the path is empty, return 0.\n if (lastPathSegment <= 0) {\n return 0;\n }\n\n do {\n measurementElement.pathSegList.removeItem(lastPathSegment);\n if (distance > measurementElement.getTotalLength()) {\n break;\n }\n lastPathSegment--;\n } while (lastPathSegment > 0);\n return lastPathSegment;\n };\n }\n\n window.SVGPathSeg = SVGPathSeg;\n window.SVGPathSegClosePath = SVGPathSegClosePath;\n window.SVGPathSegMovetoAbs = SVGPathSegMovetoAbs;\n window.SVGPathSegMovetoRel = SVGPathSegMovetoRel;\n window.SVGPathSegLinetoAbs = SVGPathSegLinetoAbs;\n window.SVGPathSegLinetoRel = SVGPathSegLinetoRel;\n window.SVGPathSegCurvetoCubicAbs = SVGPathSegCurvetoCubicAbs;\n window.SVGPathSegCurvetoCubicRel = SVGPathSegCurvetoCubicRel;\n window.SVGPathSegCurvetoQuadraticAbs = SVGPathSegCurvetoQuadraticAbs;\n window.SVGPathSegCurvetoQuadraticRel = SVGPathSegCurvetoQuadraticRel;\n window.SVGPathSegArcAbs = SVGPathSegArcAbs;\n window.SVGPathSegArcRel = SVGPathSegArcRel;\n window.SVGPathSegLinetoHorizontalAbs = SVGPathSegLinetoHorizontalAbs;\n window.SVGPathSegLinetoHorizontalRel = SVGPathSegLinetoHorizontalRel;\n window.SVGPathSegLinetoVerticalAbs = SVGPathSegLinetoVerticalAbs;\n window.SVGPathSegLinetoVerticalRel = SVGPathSegLinetoVerticalRel;\n window.SVGPathSegCurvetoCubicSmoothAbs = SVGPathSegCurvetoCubicSmoothAbs;\n window.SVGPathSegCurvetoCubicSmoothRel = SVGPathSegCurvetoCubicSmoothRel;\n window.SVGPathSegCurvetoQuadraticSmoothAbs = SVGPathSegCurvetoQuadraticSmoothAbs;\n window.SVGPathSegCurvetoQuadraticSmoothRel = SVGPathSegCurvetoQuadraticSmoothRel;\n}\n\n// Checking for SVGPathSegList in window checks for the case of an implementation without the\n// SVGPathSegList API.\n// The second check for appendItem is specific to Firefox 59+ which removed only parts of the\n// SVGPathSegList API (e.g., appendItem). In this case we need to re-implement the entire API\n// so the polyfill data (i.e., _list) is used throughout.\nif (!('SVGPathSegList' in window) || !('appendItem' in window.SVGPathSegList.prototype)) {\n // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSegList\n class SVGPathSegList {\n constructor (pathElement) {\n this._pathElement = pathElement;\n this._list = this._parsePath(this._pathElement.getAttribute('d'));\n\n // Use a MutationObserver to catch changes to the path's \"d\" attribute.\n this._mutationObserverConfig = {attributes: true, attributeFilter: ['d']};\n this._pathElementMutationObserver = new MutationObserver(this._updateListFromPathMutations.bind(this));\n this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig);\n }\n // Process any pending mutations to the path element and update the list as needed.\n // This should be the first call of all public functions and is needed because\n // MutationObservers are not synchronous so we can have pending asynchronous mutations.\n _checkPathSynchronizedToList () {\n this._updateListFromPathMutations(this._pathElementMutationObserver.takeRecords());\n }\n\n _updateListFromPathMutations (mutationRecords) {\n if (!this._pathElement) {\n return;\n }\n let hasPathMutations = false;\n mutationRecords.forEach((record) => {\n if (record.attributeName === 'd') {\n hasPathMutations = true;\n }\n });\n if (hasPathMutations) {\n this._list = this._parsePath(this._pathElement.getAttribute('d'));\n }\n }\n\n // Serialize the list and update the path's 'd' attribute.\n _writeListToPath () {\n this._pathElementMutationObserver.disconnect();\n this._pathElement.setAttribute('d', SVGPathSegList._pathSegArrayAsString(this._list));\n this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig);\n }\n\n // When a path segment changes the list needs to be synchronized back to the path element.\n segmentChanged (pathSeg) {\n this._writeListToPath();\n }\n\n clear () {\n this._checkPathSynchronizedToList();\n\n this._list.forEach((pathSeg) => {\n pathSeg._owningPathSegList = null;\n });\n this._list = [];\n this._writeListToPath();\n }\n\n initialize (newItem) {\n this._checkPathSynchronizedToList();\n\n this._list = [newItem];\n newItem._owningPathSegList = this;\n this._writeListToPath();\n return newItem;\n }\n\n _checkValidIndex (index) {\n if (isNaN(index) || index < 0 || index >= this.numberOfItems) {\n throw new Error('INDEX_SIZE_ERR');\n }\n }\n\n getItem (index) {\n this._checkPathSynchronizedToList();\n\n this._checkValidIndex(index);\n return this._list[index];\n }\n\n insertItemBefore (newItem, index) {\n this._checkPathSynchronizedToList();\n\n // Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list.\n if (index > this.numberOfItems) {\n index = this.numberOfItems;\n }\n if (newItem._owningPathSegList) {\n // SVG2 spec says to make a copy.\n newItem = newItem.clone();\n }\n this._list.splice(index, 0, newItem);\n newItem._owningPathSegList = this;\n this._writeListToPath();\n return newItem;\n }\n\n replaceItem (newItem, index) {\n this._checkPathSynchronizedToList();\n\n if (newItem._owningPathSegList) {\n // SVG2 spec says to make a copy.\n newItem = newItem.clone();\n }\n this._checkValidIndex(index);\n this._list[index] = newItem;\n newItem._owningPathSegList = this;\n this._writeListToPath();\n return newItem;\n }\n\n removeItem (index) {\n this._checkPathSynchronizedToList();\n\n this._checkValidIndex(index);\n const item = this._list[index];\n this._list.splice(index, 1);\n this._writeListToPath();\n return item;\n }\n\n appendItem (newItem) {\n this._checkPathSynchronizedToList();\n\n if (newItem._owningPathSegList) {\n // SVG2 spec says to make a copy.\n newItem = newItem.clone();\n }\n this._list.push(newItem);\n newItem._owningPathSegList = this;\n // TODO: Optimize this to just append to the existing attribute.\n this._writeListToPath();\n return newItem;\n }\n\n // This closely follows SVGPathParser::parsePath from Source/core/svg/SVGPathParser.cpp.\n _parsePath (string) {\n if (!string || !string.length) {\n return [];\n }\n\n const owningPathSegList = this;\n\n class Builder {\n constructor () {\n this.pathSegList = [];\n }\n appendSegment (pathSeg) {\n this.pathSegList.push(pathSeg);\n }\n }\n\n class Source {\n constructor (string) {\n this._string = string;\n this._currentIndex = 0;\n this._endIndex = this._string.length;\n this._previousCommand = SVGPathSeg.PATHSEG_UNKNOWN;\n\n this._skipOptionalSpaces();\n }\n _isCurrentSpace () {\n const character = this._string[this._currentIndex];\n return character <= ' ' && (character === ' ' || character === '\\n' || character === '\\t' || character === '\\r' || character === '\\f');\n }\n\n _skipOptionalSpaces () {\n while (this._currentIndex < this._endIndex && this._isCurrentSpace()) {\n this._currentIndex++;\n }\n return this._currentIndex < this._endIndex;\n }\n\n _skipOptionalSpacesOrDelimiter () {\n if (this._currentIndex < this._endIndex && !this._isCurrentSpace() && this._string.charAt(this._currentIndex) !== ',') {\n return false;\n }\n if (this._skipOptionalSpaces()) {\n if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === ',') {\n this._currentIndex++;\n this._skipOptionalSpaces();\n }\n }\n return this._currentIndex < this._endIndex;\n }\n\n hasMoreData () {\n return this._currentIndex < this._endIndex;\n }\n\n peekSegmentType () {\n const lookahead = this._string[this._currentIndex];\n return this._pathSegTypeFromChar(lookahead);\n }\n\n _pathSegTypeFromChar (lookahead) {\n switch (lookahead) {\n case 'Z':\n case 'z':\n return SVGPathSeg.PATHSEG_CLOSEPATH;\n case 'M':\n return SVGPathSeg.PATHSEG_MOVETO_ABS;\n case 'm':\n return SVGPathSeg.PATHSEG_MOVETO_REL;\n case 'L':\n return SVGPathSeg.PATHSEG_LINETO_ABS;\n case 'l':\n return SVGPathSeg.PATHSEG_LINETO_REL;\n case 'C':\n return SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS;\n case 'c':\n return SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL;\n case 'Q':\n return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS;\n case 'q':\n return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL;\n case 'A':\n return SVGPathSeg.PATHSEG_ARC_ABS;\n case 'a':\n return SVGPathSeg.PATHSEG_ARC_REL;\n case 'H':\n return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS;\n case 'h':\n return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL;\n case 'V':\n return SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS;\n case 'v':\n return SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL;\n case 'S':\n return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS;\n case 's':\n return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL;\n case 'T':\n return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS;\n case 't':\n return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL;\n default:\n return SVGPathSeg.PATHSEG_UNKNOWN;\n }\n }\n\n _nextCommandHelper (lookahead, previousCommand) {\n // Check for remaining coordinates in the current command.\n if ((lookahead === '+' || lookahead === '-' || lookahead === '.' || (lookahead >= '0' && lookahead <= '9')) && previousCommand !== SVGPathSeg.PATHSEG_CLOSEPATH) {\n if (previousCommand === SVGPathSeg.PATHSEG_MOVETO_ABS) {\n return SVGPathSeg.PATHSEG_LINETO_ABS;\n }\n if (previousCommand === SVGPathSeg.PATHSEG_MOVETO_REL) {\n return SVGPathSeg.PATHSEG_LINETO_REL;\n }\n return previousCommand;\n }\n return SVGPathSeg.PATHSEG_UNKNOWN;\n }\n\n initialCommandIsMoveTo () {\n // If the path is empty it is still valid, so return true.\n if (!this.hasMoreData()) {\n return true;\n }\n const command = this.peekSegmentType();\n // Path must start with moveTo.\n return command === SVGPathSeg.PATHSEG_MOVETO_ABS || command === SVGPathSeg.PATHSEG_MOVETO_REL;\n }\n\n // Parse a number from an SVG path. This very closely follows genericParseNumber(...) from Source/core/svg/SVGParserUtilities.cpp.\n // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-PathDataBNF\n _parseNumber () {\n let exponent = 0;\n let integer = 0;\n let frac = 1;\n let decimal = 0;\n let sign = 1;\n let expsign = 1;\n\n const startIndex = this._currentIndex;\n\n this._skipOptionalSpaces();\n\n // Read the sign.\n if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '+') {\n this._currentIndex++;\n } else if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '-') {\n this._currentIndex++;\n sign = -1;\n }\n\n if (this._currentIndex === this._endIndex || ((this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') && this._string.charAt(this._currentIndex) !== '.')) {\n // The first character of a number must be one of [0-9+-.].\n return undefined;\n }\n\n // Read the integer part, build right-to-left.\n const startIntPartIndex = this._currentIndex;\n while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') {\n this._currentIndex++; // Advance to first non-digit.\n }\n\n if (this._currentIndex !== startIntPartIndex) {\n let scanIntPartIndex = this._currentIndex - 1;\n let multiplier = 1;\n while (scanIntPartIndex >= startIntPartIndex) {\n integer += multiplier * (this._string.charAt(scanIntPartIndex--) - '0');\n multiplier *= 10;\n }\n }\n\n // Read the decimals.\n if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '.') {\n this._currentIndex++;\n\n // There must be a least one digit following the .\n if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') {\n return undefined;\n }\n while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') {\n frac *= 10;\n decimal += (this._string.charAt(this._currentIndex) - '0') / frac;\n this._currentIndex += 1;\n }\n }\n\n // Read the exponent part.\n if (this._currentIndex !== startIndex && this._currentIndex + 1 < this._endIndex && (this._string.charAt(this._currentIndex) === 'e' || this._string.charAt(this._currentIndex) === 'E') && (this._string.charAt(this._currentIndex + 1) !== 'x' && this._string.charAt(this._currentIndex + 1) !== 'm')) {\n this._currentIndex++;\n\n // Read the sign of the exponent.\n if (this._string.charAt(this._currentIndex) === '+') {\n this._currentIndex++;\n } else if (this._string.charAt(this._currentIndex) === '-') {\n this._currentIndex++;\n expsign = -1;\n }\n\n // There must be an exponent.\n if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') {\n return undefined;\n }\n\n while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') {\n exponent *= 10;\n exponent += (this._string.charAt(this._currentIndex) - '0');\n this._currentIndex++;\n }\n }\n\n let number = integer + decimal;\n number *= sign;\n\n if (exponent) {\n number *= 10 ** (expsign * exponent);\n }\n\n if (startIndex === this._currentIndex) {\n return undefined;\n }\n\n this._skipOptionalSpacesOrDelimiter();\n\n return number;\n }\n\n _parseArcFlag () {\n if (this._currentIndex >= this._endIndex) {\n return undefined;\n }\n let flag = false;\n const flagChar = this._string.charAt(this._currentIndex++);\n if (flagChar === '0') {\n flag = false;\n } else if (flagChar === '1') {\n flag = true;\n } else {\n return undefined;\n }\n\n this._skipOptionalSpacesOrDelimiter();\n return flag;\n }\n\n parseSegment () {\n const lookahead = this._string[this._currentIndex];\n let command = this._pathSegTypeFromChar(lookahead);\n if (command === SVGPathSeg.PATHSEG_UNKNOWN) {\n // Possibly an implicit command. Not allowed if this is the first command.\n if (this._previousCommand === SVGPathSeg.PATHSEG_UNKNOWN) {\n return null;\n }\n command = this._nextCommandHelper(lookahead, this._previousCommand);\n if (command === SVGPathSeg.PATHSEG_UNKNOWN) {\n return null;\n }\n } else {\n this._currentIndex++;\n }\n\n this._previousCommand = command;\n\n switch (command) {\n case SVGPathSeg.PATHSEG_MOVETO_REL:\n return new SVGPathSegMovetoRel(owningPathSegList, this._parseNumber(), this._parseNumber());\n case SVGPathSeg.PATHSEG_MOVETO_ABS:\n return new SVGPathSegMovetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber());\n case SVGPathSeg.PATHSEG_LINETO_REL:\n return new SVGPathSegLinetoRel(owningPathSegList, this._parseNumber(), this._parseNumber());\n case SVGPathSeg.PATHSEG_LINETO_ABS:\n return new SVGPathSegLinetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber());\n case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL:\n return new SVGPathSegLinetoHorizontalRel(owningPathSegList, this._parseNumber());\n case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS:\n return new SVGPathSegLinetoHorizontalAbs(owningPathSegList, this._parseNumber());\n case SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL:\n return new SVGPathSegLinetoVerticalRel(owningPathSegList, this._parseNumber());\n case SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS:\n return new SVGPathSegLinetoVerticalAbs(owningPathSegList, this._parseNumber());\n case SVGPathSeg.PATHSEG_CLOSEPATH:\n this._skipOptionalSpaces();\n return new SVGPathSegClosePath(owningPathSegList);\n case SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL: {\n const points = {x1: this._parseNumber(), y1: this._parseNumber(), x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n return new SVGPathSegCurvetoCubicRel(owningPathSegList, points.x, points.y, points.x1, points.y1, points.x2, points.y2);\n } case SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS: {\n const points = {x1: this._parseNumber(), y1: this._parseNumber(), x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n return new SVGPathSegCurvetoCubicAbs(owningPathSegList, points.x, points.y, points.x1, points.y1, points.x2, points.y2);\n } case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL: {\n const points = {x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n return new SVGPathSegCurvetoCubicSmoothRel(owningPathSegList, points.x, points.y, points.x2, points.y2);\n } case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: {\n const points = {x2: this._parseNumber(), y2: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n return new SVGPathSegCurvetoCubicSmoothAbs(owningPathSegList, points.x, points.y, points.x2, points.y2);\n } case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL: {\n const points = {x1: this._parseNumber(), y1: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n return new SVGPathSegCurvetoQuadraticRel(owningPathSegList, points.x, points.y, points.x1, points.y1);\n } case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS: {\n const points = {x1: this._parseNumber(), y1: this._parseNumber(), x: this._parseNumber(), y: this._parseNumber()};\n return new SVGPathSegCurvetoQuadraticAbs(owningPathSegList, points.x, points.y, points.x1, points.y1);\n } case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL:\n return new SVGPathSegCurvetoQuadraticSmoothRel(owningPathSegList, this._parseNumber(), this._parseNumber());\n case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS:\n return new SVGPathSegCurvetoQuadraticSmoothAbs(owningPathSegList, this._parseNumber(), this._parseNumber());\n case SVGPathSeg.PATHSEG_ARC_REL: {\n const points = {x1: this._parseNumber(), y1: this._parseNumber(), arcAngle: this._parseNumber(), arcLarge: this._parseArcFlag(), arcSweep: this._parseArcFlag(), x: this._parseNumber(), y: this._parseNumber()};\n return new SVGPathSegArcRel(owningPathSegList, points.x, points.y, points.x1, points.y1, points.arcAngle, points.arcLarge, points.arcSweep);\n } case SVGPathSeg.PATHSEG_ARC_ABS: {\n const points = {x1: this._parseNumber(), y1: this._parseNumber(), arcAngle: this._parseNumber(), arcLarge: this._parseArcFlag(), arcSweep: this._parseArcFlag(), x: this._parseNumber(), y: this._parseNumber()};\n return new SVGPathSegArcAbs(owningPathSegList, points.x, points.y, points.x1, points.y1, points.arcAngle, points.arcLarge, points.arcSweep);\n } default:\n throw new Error('Unknown path seg type.');\n }\n }\n }\n\n const builder = new Builder();\n const source = new Source(string);\n\n if (!source.initialCommandIsMoveTo()) {\n return [];\n }\n while (source.hasMoreData()) {\n const pathSeg = source.parseSegment();\n if (!pathSeg) {\n return [];\n }\n builder.appendSegment(pathSeg);\n }\n\n return builder.pathSegList;\n }\n\n // STATIC\n static _pathSegArrayAsString (pathSegArray) {\n let string = '';\n let first = true;\n pathSegArray.forEach((pathSeg) => {\n if (first) {\n first = false;\n string += pathSeg._asPathString();\n } else {\n string += ' ' + pathSeg._asPathString();\n }\n });\n return string;\n }\n }\n\n SVGPathSegList.prototype.classname = 'SVGPathSegList';\n\n Object.defineProperty(SVGPathSegList.prototype, 'numberOfItems', {\n get () {\n this._checkPathSynchronizedToList();\n return this._list.length;\n },\n enumerable: true\n });\n\n // Add the pathSegList accessors to SVGPathElement.\n // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGAnimatedPathData\n Object.defineProperties(SVGPathElement.prototype, {\n pathSegList: {\n get () {\n if (!this._pathSegList) {\n this._pathSegList = new SVGPathSegList(this);\n }\n return this._pathSegList;\n },\n enumerable: true\n },\n // TODO: The following are not implemented and simply return SVGPathElement.pathSegList.\n normalizedPathSegList: {get () { return this.pathSegList; }, enumerable: true},\n animatedPathSegList: {get () { return this.pathSegList; }, enumerable: true},\n animatedNormalizedPathSegList: {get () { return this.pathSegList; }, enumerable: true}\n });\n window.SVGPathSegList = SVGPathSegList;\n}\n})();\n","/**\n * @file ext-closepath.js\n *\n * @license MIT\n *\n * @copyright 2010 Jeff Schiller\n *\n */\nimport '../../common/svgpathseg.js';\n\n// This extension adds a simple button to the contextual panel for paths\n// The button toggles whether the path is open or closed\nexport default {\n name: 'closepath',\n async init ({importLocale, $}) {\n const strings = await importLocale();\n const svgEditor = this;\n let selElems;\n const updateButton = function (path) {\n const seglist = path.pathSegList,\n closed = seglist.getItem(seglist.numberOfItems - 1).pathSegType === 1,\n showbutton = closed ? '#tool_openpath' : '#tool_closepath',\n hidebutton = closed ? '#tool_closepath' : '#tool_openpath';\n $(hidebutton).hide();\n $(showbutton).show();\n };\n const showPanel = function (on) {\n $('#closepath_panel').toggle(on);\n if (on) {\n const path = selElems[0];\n if (path) { updateButton(path); }\n }\n };\n const toggleClosed = function () {\n const path = selElems[0];\n if (path) {\n const seglist = path.pathSegList,\n last = seglist.numberOfItems - 1;\n // is closed\n if (seglist.getItem(last).pathSegType === 1) {\n seglist.removeItem(last);\n } else {\n seglist.appendItem(path.createSVGPathSegClosePath());\n }\n updateButton(path);\n }\n };\n\n const buttons = [\n {\n id: 'tool_openpath',\n icon: svgEditor.curConfig.extIconsPath + 'openpath.png',\n type: 'context',\n panel: 'closepath_panel',\n events: {\n click () {\n toggleClosed();\n }\n }\n },\n {\n id: 'tool_closepath',\n icon: svgEditor.curConfig.extIconsPath + 'closepath.png',\n type: 'context',\n panel: 'closepath_panel',\n events: {\n click () {\n toggleClosed();\n }\n }\n }\n ];\n\n return {\n name: strings.name,\n svgicons: svgEditor.curConfig.extIconsPath + 'closepath_icons.svg',\n buttons: strings.buttons.map((button, i) => {\n return Object.assign(buttons[i], button);\n }),\n callback () {\n $('#closepath_panel').hide();\n },\n selectedChanged (opts) {\n selElems = opts.elems;\n let i = selElems.length;\n while (i--) {\n const elem = selElems[i];\n if (elem && elem.tagName === 'path') {\n if (opts.selectedElement && !opts.multiselected) {\n showPanel(true);\n } else {\n showPanel(false);\n }\n } else {\n showPanel(false);\n }\n }\n }\n };\n }\n};\n"],"names":["window","SVGPathSeg","type","typeAsLetter","owningPathSegList","pathSegType","pathSegTypeAsLetter","_owningPathSegList","segmentChanged","prototype","classname","PATHSEG_UNKNOWN","PATHSEG_CLOSEPATH","PATHSEG_MOVETO_ABS","PATHSEG_MOVETO_REL","PATHSEG_LINETO_ABS","PATHSEG_LINETO_REL","PATHSEG_CURVETO_CUBIC_ABS","PATHSEG_CURVETO_CUBIC_REL","PATHSEG_CURVETO_QUADRATIC_ABS","PATHSEG_CURVETO_QUADRATIC_REL","PATHSEG_ARC_ABS","PATHSEG_ARC_REL","PATHSEG_LINETO_HORIZONTAL_ABS","PATHSEG_LINETO_HORIZONTAL_REL","PATHSEG_LINETO_VERTICAL_ABS","PATHSEG_LINETO_VERTICAL_REL","PATHSEG_CURVETO_CUBIC_SMOOTH_ABS","PATHSEG_CURVETO_CUBIC_SMOOTH_REL","PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS","PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL","SVGPathSegClosePath","undefined","SVGPathSegMovetoAbs","x","y","_x","_y","Object","defineProperties","get","set","_segmentChanged","enumerable","SVGPathSegMovetoRel","SVGPathSegLinetoAbs","SVGPathSegLinetoRel","SVGPathSegCurvetoCubicAbs","x1","y1","x2","y2","_x1","_y1","_x2","_y2","SVGPathSegCurvetoCubicRel","SVGPathSegCurvetoQuadraticAbs","SVGPathSegCurvetoQuadraticRel","SVGPathSegArcAbs","r1","r2","angle","largeArcFlag","sweepFlag","_r1","_r2","_angle","_largeArcFlag","_sweepFlag","SVGPathSegArcRel","SVGPathSegLinetoHorizontalAbs","defineProperty","SVGPathSegLinetoHorizontalRel","SVGPathSegLinetoVerticalAbs","SVGPathSegLinetoVerticalRel","SVGPathSegCurvetoCubicSmoothAbs","SVGPathSegCurvetoCubicSmoothRel","SVGPathSegCurvetoQuadraticSmoothAbs","SVGPathSegCurvetoQuadraticSmoothRel","SVGPathElement","createSVGPathSegClosePath","createSVGPathSegMovetoAbs","createSVGPathSegMovetoRel","createSVGPathSegLinetoAbs","createSVGPathSegLinetoRel","createSVGPathSegCurvetoCubicAbs","createSVGPathSegCurvetoCubicRel","createSVGPathSegCurvetoQuadraticAbs","createSVGPathSegCurvetoQuadraticRel","createSVGPathSegArcAbs","createSVGPathSegArcRel","createSVGPathSegLinetoHorizontalAbs","createSVGPathSegLinetoHorizontalRel","createSVGPathSegLinetoVerticalAbs","createSVGPathSegLinetoVerticalRel","createSVGPathSegCurvetoCubicSmoothAbs","createSVGPathSegCurvetoCubicSmoothRel","createSVGPathSegCurvetoQuadraticSmoothAbs","createSVGPathSegCurvetoQuadraticSmoothRel","getPathSegAtLength","distance","isFinite","Error","measurementElement","document","createElementNS","setAttribute","getAttribute","lastPathSegment","pathSegList","numberOfItems","removeItem","getTotalLength","SVGPathSegList","pathElement","_pathElement","_list","_parsePath","_mutationObserverConfig","attributes","attributeFilter","_pathElementMutationObserver","MutationObserver","_updateListFromPathMutations","bind","observe","takeRecords","mutationRecords","hasPathMutations","forEach","record","attributeName","disconnect","_pathSegArrayAsString","pathSeg","_writeListToPath","_checkPathSynchronizedToList","newItem","index","isNaN","_checkValidIndex","clone","splice","item","push","string","length","Builder","Source","_string","_currentIndex","_endIndex","_previousCommand","_skipOptionalSpaces","character","_isCurrentSpace","charAt","lookahead","_pathSegTypeFromChar","previousCommand","hasMoreData","command","peekSegmentType","exponent","integer","frac","decimal","sign","expsign","startIndex","startIntPartIndex","scanIntPartIndex","multiplier","number","_skipOptionalSpacesOrDelimiter","flag","flagChar","_nextCommandHelper","_parseNumber","points","arcAngle","arcLarge","_parseArcFlag","arcSweep","builder","source","initialCommandIsMoveTo","parseSegment","appendSegment","pathSegArray","first","_asPathString","_pathSegList","normalizedPathSegList","animatedPathSegList","animatedNormalizedPathSegList","name","init","importLocale","$","strings","svgEditor","updateButton","path","seglist","closed","getItem","showbutton","hidebutton","hide","show","showPanel","on","toggle","selElems","toggleClosed","last","appendItem","buttons","id","icon","curConfig","extIconsPath","panel","events","click","svgicons","map","button","i","assign","callback","selectedChanged","opts","elems","elem","tagName","selectedElement","multiselected"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file diff --git a/dist/editor/extensions/ext-connector.js b/dist/editor/extensions/ext-connector.js index 13629d48..d43dbd98 100644 --- a/dist/editor/extensions/ext-connector.js +++ b/dist/editor/extensions/ext-connector.js @@ -1,3 +1,1651 @@ +function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); +} + +var REACT_ELEMENT_TYPE; + +function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; +} + +function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); +} + +function _AwaitValue(value) { + this.wrapped = value; +} + +function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } +} + +if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; +} + +_AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); +}; + +_AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); +}; + +_AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); +}; + +function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; +} + +function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); +} + +function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; +} + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} + +function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; +} + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} + +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} + +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} + +function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; +} + +function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); +} + +function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); +} + +function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; +} + +function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); +} + +function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); +} + +function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } +} + +function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); +} + +function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; +} + +function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); +} + +function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} + +function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; +} + +function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; +} + +function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } +} + +function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); +} + +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; +} + +function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); +} + +function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; +} + +function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; +} + +function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); +} + +function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); +} + +function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; +} + +function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); +} + +function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; +} + +function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); +} + +function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); +} + +function _temporalUndefined() {} + +function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); +} + +function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; +} + +function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); +} + +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} + +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); +} + +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); +} + +function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; +} + +function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; +} + +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} + +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; +} + +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; +} + +function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); +} + +function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; +} + +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); +} + +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); +} + +function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); +} + +function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); +} + +function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; +} + +var id = 0; + +function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; +} + +function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; +} + +function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } +} + +function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; +} + +function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); +} + +function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); +} + +function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; +} + +function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; +} + +function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } +} + +function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; +} + +function _hasDecorators(element) { + return element.decorators && element.decorators.length; +} + +function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); +} + +function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; +} + +function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; +} + +function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); +} + +function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); +} + /** * @file ext-connector.js * @@ -6,654 +1654,647 @@ * @copyright 2010 Alexis Deveria * */ - -export default { +var extConnector = { name: 'connector', - async init (S) { - const svgEditor = this; - const svgCanvas = svgEditor.canvas; - const {getElem} = svgCanvas; - const {$, svgroot, importLocale} = S, - addElem = svgCanvas.addSVGElementFromJson, - selManager = S.selectorManager, - connSel = '.se_connector', - // connect_str = '-SE_CONNECT-', - elData = $.data; - const strings = await importLocale(); + init: function init(S) { + var _this = this; - let startX, - startY, - curLine, - startElem, - endElem, - seNs, - {svgcontent} = S, - started = false, - connections = [], - selElems = []; + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var svgEditor, svgCanvas, getElem, $, svgroot, importLocale, addElem, selManager, connSel, elData, strings, startX, startY, curLine, startElem, endElem, seNs, svgcontent, started, connections, selElems, getBBintersect, getOffset, showPanel, setPoint, updateLine, findConnectors, updateConnectors, init, buttons; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + init = function _init() { + // Make sure all connectors have data set + $(svgcontent).find('*').each(function () { + var conn = this.getAttributeNS(seNs, 'connector'); - /** - * - * @param {Float} x - * @param {Float} y - * @param {module:utilities.BBoxObject} bb - * @param {Float} offset - * @returns {module:math.XYObject} - */ - function getBBintersect (x, y, bb, offset) { - if (offset) { - offset -= 0; - bb = $.extend({}, bb); - bb.width += offset; - bb.height += offset; - bb.x -= offset / 2; - bb.y -= offset / 2; - } + if (conn) { + this.setAttribute('class', connSel.substr(1)); + var connData = conn.split(' '); + var sbb = svgCanvas.getStrokedBBox([getElem(connData[0])]); + var ebb = svgCanvas.getStrokedBBox([getElem(connData[1])]); + $(this).data('c_start', connData[0]).data('c_end', connData[1]).data('start_bb', sbb).data('end_bb', ebb); + svgCanvas.getEditorNS(true); + } + }); // updateConnectors(); + }; - const midX = bb.x + bb.width / 2; - const midY = bb.y + bb.height / 2; - const lenX = x - midX; - const lenY = y - midY; + updateConnectors = function _updateConnectors(elems) { + // Updates connector lines based on selected elements + // Is not used on mousemove, as it runs getStrokedBBox every time, + // which isn't necessary there. + findConnectors(elems); - const slope = Math.abs(lenY / lenX); + if (connections.length) { + // Update line with element + var i = connections.length; - let ratio; - if (slope < bb.height / bb.width) { - ratio = (bb.width / 2) / Math.abs(lenX); - } else { - ratio = lenY - ? (bb.height / 2) / Math.abs(lenY) - : 0; - } + while (i--) { + var conn = connections[i]; + var line = conn.connector; + var elem = conn.elem; // const sw = line.getAttribute('stroke-width') * 5; - return { - x: midX + lenX * ratio, - y: midY + lenY * ratio - }; - } + var pre = conn.is_start ? 'start' : 'end'; // Update bbox for this element - /** - * @param {"start"|"end"} side - * @param {Element} line - * @returns {Float} - */ - function getOffset (side, line) { - const giveOffset = line.getAttribute('marker-' + side); - // const giveOffset = $(line).data(side+'_off'); + var bb = svgCanvas.getStrokedBBox([elem]); + bb.x = conn.start_x; + bb.y = conn.start_y; + elData(line, pre + '_bb', bb); + /* const addOffset = */ - // TODO: Make this number (5) be based on marker width/height - const size = line.getAttribute('stroke-width') * 5; - return giveOffset ? size : 0; - } + elData(line, pre + '_off'); + var altPre = conn.is_start ? 'end' : 'start'; // Get center pt of connected element - /** - * @param {boolean} on - * @returns {void} - */ - function showPanel (on) { - let connRules = $('#connector_rules'); - if (!connRules.length) { - connRules = $('').appendTo('head'); - } - connRules.text(!on ? '' : '#tool_clone, #tool_topath, #tool_angle, #xy_panel { display: none !important; }'); - $('#connector_panel').toggle(on); - } + var bb2 = elData(line, altPre + '_bb'); + var srcX = bb2.x + bb2.width / 2; + var srcY = bb2.y + bb2.height / 2; // Set point of element being moved - /** - * @param {Element} elem - * @param {Integer|"end"} pos - * @param {Float} x - * @param {Float} y - * @param {boolean} [setMid] - * @returns {void} - */ - function setPoint (elem, pos, x, y, setMid) { - const pts = elem.points; - const pt = svgroot.createSVGPoint(); - pt.x = x; - pt.y = y; - if (pos === 'end') { pos = pts.numberOfItems - 1; } - // TODO: Test for this on init, then use alt only if needed - try { - pts.replaceItem(pt, pos); - } catch (err) { - // Should only occur in FF which formats points attr as "n,n n,n", so just split - const ptArr = elem.getAttribute('points').split(' '); - for (let i = 0; i < ptArr.length; i++) { - if (i === pos) { - ptArr[i] = x + ',' + y; + var pt = getBBintersect(srcX, srcY, bb, getOffset(pre, line)); + setPoint(line, conn.is_start ? 0 : 'end', pt.x, pt.y, true); // Set point of connected element + + var pt2 = getBBintersect(pt.x, pt.y, elData(line, altPre + '_bb'), getOffset(altPre, line)); + setPoint(line, conn.is_start ? 'end' : 0, pt2.x, pt2.y, true); // Update points attribute manually for webkit + + if (navigator.userAgent.includes('AppleWebKit')) { + var pts = line.points; + var len = pts.numberOfItems; + var ptArr = []; + + for (var j = 0; j < len; j++) { + pt = pts.getItem(j); + ptArr[j] = pt.x + ',' + pt.y; + } + + line.setAttribute('points', ptArr.join(' ')); + } + } + } + }; + + findConnectors = function _findConnectors() { + var elems = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : selElems; + var connectors = $(svgcontent).find(connSel); + connections = []; // Loop through connectors to see if one is connected to the element + + connectors.each(function () { + var addThis; + /** + * + * @returns {void} + */ + + function add() { + if (elems.includes(this)) { + // Pretend this element is selected + addThis = true; + } + } // Grab the ends + + + var parts = []; + ['start', 'end'].forEach(function (pos, i) { + var key = 'c_' + pos; + var part = elData(this, key); + + if (part === null || part === undefined) { + // Does this ever return nullish values? + part = document.getElementById(this.attributes['se:connector'].value.split(' ')[i]); + elData(this, 'c_' + pos, part.id); + elData(this, pos + '_bb', svgCanvas.getStrokedBBox([part])); + } else part = document.getElementById(part); + + parts.push(part); + }, this); + + for (var i = 0; i < 2; i++) { + var cElem = parts[i]; + addThis = false; // The connected element might be part of a selected group + + $(cElem).parents().each(add); + + if (!cElem || !cElem.parentNode) { + $(this).remove(); + continue; + } + + if (elems.includes(cElem) || addThis) { + var bb = svgCanvas.getStrokedBBox([cElem]); + connections.push({ + elem: cElem, + connector: this, + is_start: i === 0, + start_x: bb.x, + start_y: bb.y + }); + } + } + }); + }; + + updateLine = function _updateLine(diffX, diffY) { + // Update line with element + var i = connections.length; + + while (i--) { + var conn = connections[i]; + var line = conn.connector; // const {elem} = conn; + + var pre = conn.is_start ? 'start' : 'end'; // const sw = line.getAttribute('stroke-width') * 5; + // Update bbox for this element + + var bb = elData(line, pre + '_bb'); + bb.x = conn.start_x + diffX; + bb.y = conn.start_y + diffY; + elData(line, pre + '_bb', bb); + var altPre = conn.is_start ? 'end' : 'start'; // Get center pt of connected element + + var bb2 = elData(line, altPre + '_bb'); + var srcX = bb2.x + bb2.width / 2; + var srcY = bb2.y + bb2.height / 2; // Set point of element being moved + + var pt = getBBintersect(srcX, srcY, bb, getOffset(pre, line)); // $(line).data(pre+'_off')?sw:0 + + setPoint(line, conn.is_start ? 0 : 'end', pt.x, pt.y, true); // Set point of connected element + + var pt2 = getBBintersect(pt.x, pt.y, elData(line, altPre + '_bb'), getOffset(altPre, line)); + setPoint(line, conn.is_start ? 'end' : 0, pt2.x, pt2.y, true); + } + }; + + setPoint = function _setPoint(elem, pos, x, y, setMid) { + var pts = elem.points; + var pt = svgroot.createSVGPoint(); + pt.x = x; + pt.y = y; + + if (pos === 'end') { + pos = pts.numberOfItems - 1; + } // TODO: Test for this on init, then use alt only if needed + + + try { + pts.replaceItem(pt, pos); + } catch (err) { + // Should only occur in FF which formats points attr as "n,n n,n", so just split + var ptArr = elem.getAttribute('points').split(' '); + + for (var i = 0; i < ptArr.length; i++) { + if (i === pos) { + ptArr[i] = x + ',' + y; + } + } + + elem.setAttribute('points', ptArr.join(' ')); + } + + if (setMid) { + // Add center point + var ptStart = pts.getItem(0); + var ptEnd = pts.getItem(pts.numberOfItems - 1); + setPoint(elem, 1, (ptEnd.x + ptStart.x) / 2, (ptEnd.y + ptStart.y) / 2); + } + }; + + showPanel = function _showPanel(on) { + var connRules = $('#connector_rules'); + + if (!connRules.length) { + connRules = $('').appendTo('head'); + } + + connRules.text(!on ? '' : '#tool_clone, #tool_topath, #tool_angle, #xy_panel { display: none !important; }'); + $('#connector_panel').toggle(on); + }; + + getOffset = function _getOffset(side, line) { + var giveOffset = line.getAttribute('marker-' + side); // const giveOffset = $(line).data(side+'_off'); + // TODO: Make this number (5) be based on marker width/height + + var size = line.getAttribute('stroke-width') * 5; + return giveOffset ? size : 0; + }; + + getBBintersect = function _getBBintersect(x, y, bb, offset) { + if (offset) { + offset -= 0; + bb = $.extend({}, bb); + bb.width += offset; + bb.height += offset; + bb.x -= offset / 2; + bb.y -= offset / 2; + } + + var midX = bb.x + bb.width / 2; + var midY = bb.y + bb.height / 2; + var lenX = x - midX; + var lenY = y - midY; + var slope = Math.abs(lenY / lenX); + var ratio; + + if (slope < bb.height / bb.width) { + ratio = bb.width / 2 / Math.abs(lenX); + } else { + ratio = lenY ? bb.height / 2 / Math.abs(lenY) : 0; + } + + return { + x: midX + lenX * ratio, + y: midY + lenY * ratio + }; + }; + + svgEditor = _this; + svgCanvas = svgEditor.canvas; + getElem = svgCanvas.getElem; + $ = S.$, svgroot = S.svgroot, importLocale = S.importLocale, addElem = svgCanvas.addSVGElementFromJson, selManager = S.selectorManager, connSel = '.se_connector', elData = $.data; + _context.next = 14; + return importLocale(); + + case 14: + strings = _context.sent; + svgcontent = S.svgcontent, started = false, connections = [], selElems = []; + /** + * + * @param {Float} x + * @param {Float} y + * @param {module:utilities.BBoxObject} bb + * @param {Float} offset + * @returns {module:math.XYObject} + */ + + // Do once + (function () { + var gse = svgCanvas.groupSelectedElements; + + svgCanvas.groupSelectedElements = function () { + svgCanvas.removeFromSelection($(connSel).toArray()); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return gse.apply(this, args); + }; + + var mse = svgCanvas.moveSelectedElements; + + svgCanvas.moveSelectedElements = function () { + for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + + var cmd = mse.apply(this, args); + updateConnectors(); + return cmd; + }; + + seNs = svgCanvas.getEditorNS(); + })(); + /** + * Do on reset. + * @returns {void} + */ + + + // $(svgroot).parent().mousemove(function (e) { + // // if (started + // // || svgCanvas.getMode() !== 'connector' + // // || e.target.parentNode.parentNode !== svgcontent) return; + // + // console.log('y') + // // if (e.target.parentNode.parentNode === svgcontent) { + // // + // // } + // }); + buttons = [{ + id: 'mode_connect', + type: 'mode', + icon: svgEditor.curConfig.imgPath + 'cut.png', + includeWith: { + button: '#tool_line', + isDefault: false, + position: 1 + }, + events: { + click: function click() { + svgCanvas.setMode('connector'); + } + } + }]; + return _context.abrupt("return", { + name: strings.name, + svgicons: svgEditor.curConfig.imgPath + 'conn.svg', + buttons: strings.buttons.map(function (button, i) { + return Object.assign(buttons[i], button); + }), + + /* async */ + addLangData: function addLangData(_ref) { + var lang = _ref.lang; + // , importLocale: importLoc + return { + data: strings.langList + }; + }, + mouseDown: function mouseDown(opts) { + var e = opts.event; + startX = opts.start_x; + startY = opts.start_y; + var mode = svgCanvas.getMode(); + var initStroke = svgEditor.curConfig.initStroke; + + if (mode === 'connector') { + if (started) { + return undefined; + } + + var mouseTarget = e.target; + var parents = $(mouseTarget).parents(); + + if ($.inArray(svgcontent, parents) !== -1) { + // Connectable element + // If child of foreignObject, use parent + var fo = $(mouseTarget).closest('foreignObject'); + startElem = fo.length ? fo[0] : mouseTarget; // Get center of source element + + var bb = svgCanvas.getStrokedBBox([startElem]); + var x = bb.x + bb.width / 2; + var y = bb.y + bb.height / 2; + started = true; + curLine = addElem({ + element: 'polyline', + attr: { + id: svgCanvas.getNextId(), + points: x + ',' + y + ' ' + x + ',' + y + ' ' + startX + ',' + startY, + stroke: '#' + initStroke.color, + 'stroke-width': !startElem.stroke_width || startElem.stroke_width === 0 ? initStroke.width : startElem.stroke_width, + fill: 'none', + opacity: initStroke.opacity, + style: 'pointer-events:none' + } + }); + elData(curLine, 'start_bb', bb); + } + + return { + started: true + }; + } + + if (mode === 'select') { + findConnectors(); + } + + return undefined; + }, + mouseMove: function mouseMove(opts) { + var zoom = svgCanvas.getZoom(); // const e = opts.event; + + var x = opts.mouse_x / zoom; + var y = opts.mouse_y / zoom; + var diffX = x - startX, + diffY = y - startY; + var mode = svgCanvas.getMode(); + + if (mode === 'connector' && started) { + // const sw = curLine.getAttribute('stroke-width') * 3; + // Set start point (adjusts based on bb) + var pt = getBBintersect(x, y, elData(curLine, 'start_bb'), getOffset('start', curLine)); + startX = pt.x; + startY = pt.y; + setPoint(curLine, 0, pt.x, pt.y, true); // Set end point + + setPoint(curLine, 'end', x, y, true); + } else if (mode === 'select') { + var slen = selElems.length; + + while (slen--) { + var elem = selElems[slen]; // Look for selected connector elements + + if (elem && elData(elem, 'c_start')) { + // Remove the "translate" transform given to move + svgCanvas.removeFromSelection([elem]); + svgCanvas.getTransformList(elem).clear(); + } + } + + if (connections.length) { + updateLine(diffX, diffY); + } + } + }, + mouseUp: function mouseUp(opts) { + // const zoom = svgCanvas.getZoom(); + var e = opts.event; // , x = opts.mouse_x / zoom, + // , y = opts.mouse_y / zoom, + + var mouseTarget = e.target; + + if (svgCanvas.getMode() !== 'connector') { + return undefined; + } + + var fo = $(mouseTarget).closest('foreignObject'); + + if (fo.length) { + mouseTarget = fo[0]; + } + + var parents = $(mouseTarget).parents(); + + if (mouseTarget === startElem) { + // Start line through click + started = true; + return { + keep: true, + element: null, + started: started + }; + } + + if ($.inArray(svgcontent, parents) === -1) { + // Not a valid target element, so remove line + $(curLine).remove(); + started = false; + return { + keep: false, + element: null, + started: started + }; + } // Valid end element + + + endElem = mouseTarget; + var startId = startElem.id, + endId = endElem.id; + var connStr = startId + ' ' + endId; + var altStr = endId + ' ' + startId; // Don't create connector if one already exists + + var dupe = $(svgcontent).find(connSel).filter(function () { + var conn = this.getAttributeNS(seNs, 'connector'); + + if (conn === connStr || conn === altStr) { + return true; + } + + return false; + }); + + if (dupe.length) { + $(curLine).remove(); + return { + keep: false, + element: null, + started: false + }; + } + + var bb = svgCanvas.getStrokedBBox([endElem]); + var pt = getBBintersect(startX, startY, bb, getOffset('start', curLine)); + setPoint(curLine, 'end', pt.x, pt.y, true); + $(curLine).data('c_start', startId).data('c_end', endId).data('end_bb', bb); + seNs = svgCanvas.getEditorNS(true); + curLine.setAttributeNS(seNs, 'se:connector', connStr); + curLine.setAttribute('class', connSel.substr(1)); + curLine.setAttribute('opacity', 1); + svgCanvas.addToSelection([curLine]); + svgCanvas.moveToBottomSelectedElement(); + selManager.requestSelector(curLine).showGrips(false); + started = false; + return { + keep: true, + element: curLine, + started: started + }; + }, + selectedChanged: function selectedChanged(opts) { + // TODO: Find better way to skip operations if no connectors are in use + if (!$(svgcontent).find(connSel).length) { + return; + } + + if (svgCanvas.getMode() === 'connector') { + svgCanvas.setMode('select'); + } // Use this to update the current selected elements + + + selElems = opts.elems; + var i = selElems.length; + + while (i--) { + var elem = selElems[i]; + + if (elem && elData(elem, 'c_start')) { + selManager.requestSelector(elem).showGrips(false); + + if (opts.selectedElement && !opts.multiselected) { + // TODO: Set up context tools and hide most regular line tools + showPanel(true); + } else { + showPanel(false); + } + } else { + showPanel(false); + } + } + + updateConnectors(); + }, + elementChanged: function elementChanged(opts) { + var elem = opts.elems[0]; + if (!elem) return; + + if (elem.tagName === 'svg' && elem.id === 'svgcontent') { + // Update svgcontent (can change on import) + svgcontent = elem; + init(); + } // Has marker, so change offset + + + if (elem.getAttribute('marker-start') || elem.getAttribute('marker-mid') || elem.getAttribute('marker-end')) { + var start = elem.getAttribute('marker-start'); + var mid = elem.getAttribute('marker-mid'); + var end = elem.getAttribute('marker-end'); + curLine = elem; + $(elem).data('start_off', Boolean(start)).data('end_off', Boolean(end)); + + if (elem.tagName === 'line' && mid) { + // Convert to polyline to accept mid-arrow + var x1 = Number(elem.getAttribute('x1')); + var x2 = Number(elem.getAttribute('x2')); + var y1 = Number(elem.getAttribute('y1')); + var y2 = Number(elem.getAttribute('y2')); + var _elem = elem, + id = _elem.id; + var midPt = ' ' + (x1 + x2) / 2 + ',' + (y1 + y2) / 2 + ' '; + var pline = addElem({ + element: 'polyline', + attr: { + points: x1 + ',' + y1 + midPt + x2 + ',' + y2, + stroke: elem.getAttribute('stroke'), + 'stroke-width': elem.getAttribute('stroke-width'), + 'marker-mid': mid, + fill: 'none', + opacity: elem.getAttribute('opacity') || 1 + } + }); + $(elem).after(pline).remove(); + svgCanvas.clearSelection(); + pline.id = id; + svgCanvas.addToSelection([pline]); + elem = pline; + } + } // Update line if it's a connector + + + if (elem.getAttribute('class') === connSel.substr(1)) { + var _start = getElem(elData(elem, 'c_start')); + + updateConnectors([_start]); + } else { + updateConnectors(); + } + }, + IDsUpdated: function IDsUpdated(input) { + var remove = []; + input.elems.forEach(function (elem) { + if ('se:connector' in elem.attr) { + elem.attr['se:connector'] = elem.attr['se:connector'].split(' ').map(function (oldID) { + return input.changes[oldID]; + }).join(' '); // Check validity - the field would be something like 'svg_21 svg_22', but + // if one end is missing, it would be 'svg_21' and therefore fail this test + + if (!/. ./.test(elem.attr['se:connector'])) { + remove.push(elem.attr.id); + } + } + }); + return { + remove: remove + }; + }, + toolButtonStateUpdate: function toolButtonStateUpdate(opts) { + if (opts.nostroke) { + if ($('#mode_connect').hasClass('tool_button_current')) { + svgEditor.clickSelect(); + } + } + + $('#mode_connect').toggleClass('disabled', opts.nostroke); + } + }); + + case 19: + case "end": + return _context.stop(); } } - elem.setAttribute('points', ptArr.join(' ')); - } - - if (setMid) { - // Add center point - const ptStart = pts.getItem(0); - const ptEnd = pts.getItem(pts.numberOfItems - 1); - setPoint(elem, 1, (ptEnd.x + ptStart.x) / 2, (ptEnd.y + ptStart.y) / 2); - } - } - - /** - * @param {Float} diffX - * @param {Float} diffY - * @returns {void} - */ - function updateLine (diffX, diffY) { - // Update line with element - let i = connections.length; - while (i--) { - const conn = connections[i]; - const line = conn.connector; - // const {elem} = conn; - - const pre = conn.is_start ? 'start' : 'end'; - // const sw = line.getAttribute('stroke-width') * 5; - - // Update bbox for this element - const bb = elData(line, pre + '_bb'); - bb.x = conn.start_x + diffX; - bb.y = conn.start_y + diffY; - elData(line, pre + '_bb', bb); - - const altPre = conn.is_start ? 'end' : 'start'; - - // Get center pt of connected element - const bb2 = elData(line, altPre + '_bb'); - const srcX = bb2.x + bb2.width / 2; - const srcY = bb2.y + bb2.height / 2; - - // Set point of element being moved - const pt = getBBintersect(srcX, srcY, bb, getOffset(pre, line)); // $(line).data(pre+'_off')?sw:0 - setPoint(line, conn.is_start ? 0 : 'end', pt.x, pt.y, true); - - // Set point of connected element - const pt2 = getBBintersect(pt.x, pt.y, elData(line, altPre + '_bb'), getOffset(altPre, line)); - setPoint(line, conn.is_start ? 'end' : 0, pt2.x, pt2.y, true); - } - } - - /** - * - * @param {Element[]} [elems=selElems] Array of elements - * @returns {void} - */ - function findConnectors (elems = selElems) { - const connectors = $(svgcontent).find(connSel); - connections = []; - - // Loop through connectors to see if one is connected to the element - connectors.each(function () { - let addThis; - /** - * - * @returns {void} - */ - function add () { - if (elems.includes(this)) { - // Pretend this element is selected - addThis = true; - } - } - - // Grab the ends - const parts = []; - ['start', 'end'].forEach(function (pos, i) { - const key = 'c_' + pos; - let part = elData(this, key); - if (part === null || part === undefined) { // Does this ever return nullish values? - part = document.getElementById( - this.attributes['se:connector'].value.split(' ')[i] - ); - elData(this, 'c_' + pos, part.id); - elData(this, pos + '_bb', svgCanvas.getStrokedBBox([part])); - } else part = document.getElementById(part); - parts.push(part); - }, this); - - for (let i = 0; i < 2; i++) { - const cElem = parts[i]; - - addThis = false; - // The connected element might be part of a selected group - $(cElem).parents().each(add); - - if (!cElem || !cElem.parentNode) { - $(this).remove(); - continue; - } - if (elems.includes(cElem) || addThis) { - const bb = svgCanvas.getStrokedBBox([cElem]); - connections.push({ - elem: cElem, - connector: this, - is_start: (i === 0), - start_x: bb.x, - start_y: bb.y - }); - } - } - }); - } - - /** - * @param {Element[]} [elems=selElems] - * @returns {void} - */ - function updateConnectors (elems) { - // Updates connector lines based on selected elements - // Is not used on mousemove, as it runs getStrokedBBox every time, - // which isn't necessary there. - findConnectors(elems); - if (connections.length) { - // Update line with element - let i = connections.length; - while (i--) { - const conn = connections[i]; - const line = conn.connector; - const {elem} = conn; - - // const sw = line.getAttribute('stroke-width') * 5; - const pre = conn.is_start ? 'start' : 'end'; - - // Update bbox for this element - const bb = svgCanvas.getStrokedBBox([elem]); - bb.x = conn.start_x; - bb.y = conn.start_y; - elData(line, pre + '_bb', bb); - /* const addOffset = */ elData(line, pre + '_off'); - - const altPre = conn.is_start ? 'end' : 'start'; - - // Get center pt of connected element - const bb2 = elData(line, altPre + '_bb'); - const srcX = bb2.x + bb2.width / 2; - const srcY = bb2.y + bb2.height / 2; - - // Set point of element being moved - let pt = getBBintersect(srcX, srcY, bb, getOffset(pre, line)); - setPoint(line, conn.is_start ? 0 : 'end', pt.x, pt.y, true); - - // Set point of connected element - const pt2 = getBBintersect(pt.x, pt.y, elData(line, altPre + '_bb'), getOffset(altPre, line)); - setPoint(line, conn.is_start ? 'end' : 0, pt2.x, pt2.y, true); - - // Update points attribute manually for webkit - if (navigator.userAgent.includes('AppleWebKit')) { - const pts = line.points; - const len = pts.numberOfItems; - const ptArr = []; - for (let j = 0; j < len; j++) { - pt = pts.getItem(j); - ptArr[j] = pt.x + ',' + pt.y; - } - line.setAttribute('points', ptArr.join(' ')); - } - } - } - } - - // Do once - (function () { - const gse = svgCanvas.groupSelectedElements; - - svgCanvas.groupSelectedElements = function (...args) { - svgCanvas.removeFromSelection($(connSel).toArray()); - return gse.apply(this, args); - }; - - const mse = svgCanvas.moveSelectedElements; - - svgCanvas.moveSelectedElements = function (...args) { - const cmd = mse.apply(this, args); - updateConnectors(); - return cmd; - }; - - seNs = svgCanvas.getEditorNS(); - }()); - - /** - * Do on reset. - * @returns {void} - */ - function init () { - // Make sure all connectors have data set - $(svgcontent).find('*').each(function () { - const conn = this.getAttributeNS(seNs, 'connector'); - if (conn) { - this.setAttribute('class', connSel.substr(1)); - const connData = conn.split(' '); - const sbb = svgCanvas.getStrokedBBox([getElem(connData[0])]); - const ebb = svgCanvas.getStrokedBBox([getElem(connData[1])]); - $(this).data('c_start', connData[0]) - .data('c_end', connData[1]) - .data('start_bb', sbb) - .data('end_bb', ebb); - svgCanvas.getEditorNS(true); - } - }); - // updateConnectors(); - } - - // $(svgroot).parent().mousemove(function (e) { - // // if (started - // // || svgCanvas.getMode() !== 'connector' - // // || e.target.parentNode.parentNode !== svgcontent) return; - // - // console.log('y') - // // if (e.target.parentNode.parentNode === svgcontent) { - // // - // // } - // }); - - const buttons = [{ - id: 'mode_connect', - type: 'mode', - icon: svgEditor.curConfig.imgPath + 'cut.png', - includeWith: { - button: '#tool_line', - isDefault: false, - position: 1 - }, - events: { - click () { - svgCanvas.setMode('connector'); - } - } - }]; - - return { - name: strings.name, - svgicons: svgEditor.curConfig.imgPath + 'conn.svg', - buttons: strings.buttons.map((button, i) => { - return Object.assign(buttons[i], button); - }), - /* async */ addLangData ({lang}) { // , importLocale: importLoc - return { - data: strings.langList - }; - }, - mouseDown (opts) { - const e = opts.event; - startX = opts.start_x; - startY = opts.start_y; - const mode = svgCanvas.getMode(); - const {curConfig: {initStroke}} = svgEditor; - - if (mode === 'connector') { - if (started) { return undefined; } - - const mouseTarget = e.target; - - const parents = $(mouseTarget).parents(); - - if ($.inArray(svgcontent, parents) !== -1) { - // Connectable element - - // If child of foreignObject, use parent - const fo = $(mouseTarget).closest('foreignObject'); - startElem = fo.length ? fo[0] : mouseTarget; - - // Get center of source element - const bb = svgCanvas.getStrokedBBox([startElem]); - const x = bb.x + bb.width / 2; - const y = bb.y + bb.height / 2; - - started = true; - curLine = addElem({ - element: 'polyline', - attr: { - id: svgCanvas.getNextId(), - points: (x + ',' + y + ' ' + x + ',' + y + ' ' + startX + ',' + startY), - stroke: '#' + initStroke.color, - 'stroke-width': (!startElem.stroke_width || startElem.stroke_width === 0) - ? initStroke.width - : startElem.stroke_width, - fill: 'none', - opacity: initStroke.opacity, - style: 'pointer-events:none' - } - }); - elData(curLine, 'start_bb', bb); - } - return { - started: true - }; - } - if (mode === 'select') { - findConnectors(); - } - return undefined; - }, - mouseMove (opts) { - const zoom = svgCanvas.getZoom(); - // const e = opts.event; - const x = opts.mouse_x / zoom; - const y = opts.mouse_y / zoom; - - const diffX = x - startX, - diffY = y - startY; - - const mode = svgCanvas.getMode(); - - if (mode === 'connector' && started) { - // const sw = curLine.getAttribute('stroke-width') * 3; - // Set start point (adjusts based on bb) - const pt = getBBintersect(x, y, elData(curLine, 'start_bb'), getOffset('start', curLine)); - startX = pt.x; - startY = pt.y; - - setPoint(curLine, 0, pt.x, pt.y, true); - - // Set end point - setPoint(curLine, 'end', x, y, true); - } else if (mode === 'select') { - let slen = selElems.length; - while (slen--) { - const elem = selElems[slen]; - // Look for selected connector elements - if (elem && elData(elem, 'c_start')) { - // Remove the "translate" transform given to move - svgCanvas.removeFromSelection([elem]); - svgCanvas.getTransformList(elem).clear(); - } - } - if (connections.length) { - updateLine(diffX, diffY); - } - } - }, - mouseUp (opts) { - // const zoom = svgCanvas.getZoom(); - const e = opts.event; - // , x = opts.mouse_x / zoom, - // , y = opts.mouse_y / zoom, - let mouseTarget = e.target; - - if (svgCanvas.getMode() !== 'connector') { - return undefined; - } - const fo = $(mouseTarget).closest('foreignObject'); - if (fo.length) { mouseTarget = fo[0]; } - - const parents = $(mouseTarget).parents(); - - if (mouseTarget === startElem) { - // Start line through click - started = true; - return { - keep: true, - element: null, - started - }; - } - if ($.inArray(svgcontent, parents) === -1) { - // Not a valid target element, so remove line - $(curLine).remove(); - started = false; - return { - keep: false, - element: null, - started - }; - } - // Valid end element - endElem = mouseTarget; - - const startId = startElem.id, endId = endElem.id; - const connStr = startId + ' ' + endId; - const altStr = endId + ' ' + startId; - // Don't create connector if one already exists - const dupe = $(svgcontent).find(connSel).filter(function () { - const conn = this.getAttributeNS(seNs, 'connector'); - if (conn === connStr || conn === altStr) { return true; } - return false; - }); - if (dupe.length) { - $(curLine).remove(); - return { - keep: false, - element: null, - started: false - }; - } - - const bb = svgCanvas.getStrokedBBox([endElem]); - - const pt = getBBintersect(startX, startY, bb, getOffset('start', curLine)); - setPoint(curLine, 'end', pt.x, pt.y, true); - $(curLine) - .data('c_start', startId) - .data('c_end', endId) - .data('end_bb', bb); - seNs = svgCanvas.getEditorNS(true); - curLine.setAttributeNS(seNs, 'se:connector', connStr); - curLine.setAttribute('class', connSel.substr(1)); - curLine.setAttribute('opacity', 1); - svgCanvas.addToSelection([curLine]); - svgCanvas.moveToBottomSelectedElement(); - selManager.requestSelector(curLine).showGrips(false); - started = false; - return { - keep: true, - element: curLine, - started - }; - }, - selectedChanged (opts) { - // TODO: Find better way to skip operations if no connectors are in use - if (!$(svgcontent).find(connSel).length) { return; } - - if (svgCanvas.getMode() === 'connector') { - svgCanvas.setMode('select'); - } - - // Use this to update the current selected elements - selElems = opts.elems; - - let i = selElems.length; - while (i--) { - const elem = selElems[i]; - if (elem && elData(elem, 'c_start')) { - selManager.requestSelector(elem).showGrips(false); - if (opts.selectedElement && !opts.multiselected) { - // TODO: Set up context tools and hide most regular line tools - showPanel(true); - } else { - showPanel(false); - } - } else { - showPanel(false); - } - } - updateConnectors(); - }, - elementChanged (opts) { - let elem = opts.elems[0]; - if (!elem) return; - if (elem.tagName === 'svg' && elem.id === 'svgcontent') { - // Update svgcontent (can change on import) - svgcontent = elem; - init(); - } - - // Has marker, so change offset - if ( - elem.getAttribute('marker-start') || - elem.getAttribute('marker-mid') || - elem.getAttribute('marker-end') - ) { - const start = elem.getAttribute('marker-start'); - const mid = elem.getAttribute('marker-mid'); - const end = elem.getAttribute('marker-end'); - curLine = elem; - $(elem) - .data('start_off', Boolean(start)) - .data('end_off', Boolean(end)); - - if (elem.tagName === 'line' && mid) { - // Convert to polyline to accept mid-arrow - - const x1 = Number(elem.getAttribute('x1')); - const x2 = Number(elem.getAttribute('x2')); - const y1 = Number(elem.getAttribute('y1')); - const y2 = Number(elem.getAttribute('y2')); - const {id} = elem; - - const midPt = (' ' + ((x1 + x2) / 2) + ',' + ((y1 + y2) / 2) + ' '); - const pline = addElem({ - element: 'polyline', - attr: { - points: (x1 + ',' + y1 + midPt + x2 + ',' + y2), - stroke: elem.getAttribute('stroke'), - 'stroke-width': elem.getAttribute('stroke-width'), - 'marker-mid': mid, - fill: 'none', - opacity: elem.getAttribute('opacity') || 1 - } - }); - $(elem).after(pline).remove(); - svgCanvas.clearSelection(); - pline.id = id; - svgCanvas.addToSelection([pline]); - elem = pline; - } - } - // Update line if it's a connector - if (elem.getAttribute('class') === connSel.substr(1)) { - const start = getElem(elData(elem, 'c_start')); - updateConnectors([start]); - } else { - updateConnectors(); - } - }, - IDsUpdated (input) { - const remove = []; - input.elems.forEach(function (elem) { - if ('se:connector' in elem.attr) { - elem.attr['se:connector'] = elem.attr['se:connector'].split(' ') - .map(function (oldID) { return input.changes[oldID]; }).join(' '); - - // Check validity - the field would be something like 'svg_21 svg_22', but - // if one end is missing, it would be 'svg_21' and therefore fail this test - if (!(/. ./).test(elem.attr['se:connector'])) { - remove.push(elem.attr.id); - } - } - }); - return {remove}; - }, - toolButtonStateUpdate (opts) { - if (opts.nostroke) { - if ($('#mode_connect').hasClass('tool_button_current')) { - svgEditor.clickSelect(); - } - } - $('#mode_connect') - .toggleClass('disabled', opts.nostroke); - } - }; + }, _callee); + }))(); } }; + +export default extConnector; +//# sourceMappingURL=ext-connector.js.map diff --git a/dist/editor/extensions/ext-connector.js.map b/dist/editor/extensions/ext-connector.js.map new file mode 100644 index 00000000..575f0436 --- /dev/null +++ b/dist/editor/extensions/ext-connector.js.map @@ -0,0 +1 @@ +{"version":3,"file":"ext-connector.js","sources":["../../../src/editor/extensions/ext-connector.js"],"sourcesContent":["/**\n * @file ext-connector.js\n *\n * @license MIT\n *\n * @copyright 2010 Alexis Deveria\n *\n */\n\nexport default {\n name: 'connector',\n async init (S) {\n const svgEditor = this;\n const svgCanvas = svgEditor.canvas;\n const {getElem} = svgCanvas;\n const {$, svgroot, importLocale} = S,\n addElem = svgCanvas.addSVGElementFromJson,\n selManager = S.selectorManager,\n connSel = '.se_connector',\n // connect_str = '-SE_CONNECT-',\n elData = $.data;\n const strings = await importLocale();\n\n let startX,\n startY,\n curLine,\n startElem,\n endElem,\n seNs,\n {svgcontent} = S,\n started = false,\n connections = [],\n selElems = [];\n\n /**\n *\n * @param {Float} x\n * @param {Float} y\n * @param {module:utilities.BBoxObject} bb\n * @param {Float} offset\n * @returns {module:math.XYObject}\n */\n function getBBintersect (x, y, bb, offset) {\n if (offset) {\n offset -= 0;\n bb = $.extend({}, bb);\n bb.width += offset;\n bb.height += offset;\n bb.x -= offset / 2;\n bb.y -= offset / 2;\n }\n\n const midX = bb.x + bb.width / 2;\n const midY = bb.y + bb.height / 2;\n const lenX = x - midX;\n const lenY = y - midY;\n\n const slope = Math.abs(lenY / lenX);\n\n let ratio;\n if (slope < bb.height / bb.width) {\n ratio = (bb.width / 2) / Math.abs(lenX);\n } else {\n ratio = lenY\n ? (bb.height / 2) / Math.abs(lenY)\n : 0;\n }\n\n return {\n x: midX + lenX * ratio,\n y: midY + lenY * ratio\n };\n }\n\n /**\n * @param {\"start\"|\"end\"} side\n * @param {Element} line\n * @returns {Float}\n */\n function getOffset (side, line) {\n const giveOffset = line.getAttribute('marker-' + side);\n // const giveOffset = $(line).data(side+'_off');\n\n // TODO: Make this number (5) be based on marker width/height\n const size = line.getAttribute('stroke-width') * 5;\n return giveOffset ? size : 0;\n }\n\n /**\n * @param {boolean} on\n * @returns {void}\n */\n function showPanel (on) {\n let connRules = $('#connector_rules');\n if (!connRules.length) {\n connRules = $('').appendTo('head');\n }\n connRules.text(!on ? '' : '#tool_clone, #tool_topath, #tool_angle, #xy_panel { display: none !important; }');\n $('#connector_panel').toggle(on);\n }\n\n /**\n * @param {Element} elem\n * @param {Integer|\"end\"} pos\n * @param {Float} x\n * @param {Float} y\n * @param {boolean} [setMid]\n * @returns {void}\n */\n function setPoint (elem, pos, x, y, setMid) {\n const pts = elem.points;\n const pt = svgroot.createSVGPoint();\n pt.x = x;\n pt.y = y;\n if (pos === 'end') { pos = pts.numberOfItems - 1; }\n // TODO: Test for this on init, then use alt only if needed\n try {\n pts.replaceItem(pt, pos);\n } catch (err) {\n // Should only occur in FF which formats points attr as \"n,n n,n\", so just split\n const ptArr = elem.getAttribute('points').split(' ');\n for (let i = 0; i < ptArr.length; i++) {\n if (i === pos) {\n ptArr[i] = x + ',' + y;\n }\n }\n elem.setAttribute('points', ptArr.join(' '));\n }\n\n if (setMid) {\n // Add center point\n const ptStart = pts.getItem(0);\n const ptEnd = pts.getItem(pts.numberOfItems - 1);\n setPoint(elem, 1, (ptEnd.x + ptStart.x) / 2, (ptEnd.y + ptStart.y) / 2);\n }\n }\n\n /**\n * @param {Float} diffX\n * @param {Float} diffY\n * @returns {void}\n */\n function updateLine (diffX, diffY) {\n // Update line with element\n let i = connections.length;\n while (i--) {\n const conn = connections[i];\n const line = conn.connector;\n // const {elem} = conn;\n\n const pre = conn.is_start ? 'start' : 'end';\n // const sw = line.getAttribute('stroke-width') * 5;\n\n // Update bbox for this element\n const bb = elData(line, pre + '_bb');\n bb.x = conn.start_x + diffX;\n bb.y = conn.start_y + diffY;\n elData(line, pre + '_bb', bb);\n\n const altPre = conn.is_start ? 'end' : 'start';\n\n // Get center pt of connected element\n const bb2 = elData(line, altPre + '_bb');\n const srcX = bb2.x + bb2.width / 2;\n const srcY = bb2.y + bb2.height / 2;\n\n // Set point of element being moved\n const pt = getBBintersect(srcX, srcY, bb, getOffset(pre, line)); // $(line).data(pre+'_off')?sw:0\n setPoint(line, conn.is_start ? 0 : 'end', pt.x, pt.y, true);\n\n // Set point of connected element\n const pt2 = getBBintersect(pt.x, pt.y, elData(line, altPre + '_bb'), getOffset(altPre, line));\n setPoint(line, conn.is_start ? 'end' : 0, pt2.x, pt2.y, true);\n }\n }\n\n /**\n *\n * @param {Element[]} [elems=selElems] Array of elements\n * @returns {void}\n */\n function findConnectors (elems = selElems) {\n const connectors = $(svgcontent).find(connSel);\n connections = [];\n\n // Loop through connectors to see if one is connected to the element\n connectors.each(function () {\n let addThis;\n /**\n *\n * @returns {void}\n */\n function add () {\n if (elems.includes(this)) {\n // Pretend this element is selected\n addThis = true;\n }\n }\n\n // Grab the ends\n const parts = [];\n ['start', 'end'].forEach(function (pos, i) {\n const key = 'c_' + pos;\n let part = elData(this, key);\n if (part === null || part === undefined) { // Does this ever return nullish values?\n part = document.getElementById(\n this.attributes['se:connector'].value.split(' ')[i]\n );\n elData(this, 'c_' + pos, part.id);\n elData(this, pos + '_bb', svgCanvas.getStrokedBBox([part]));\n } else part = document.getElementById(part);\n parts.push(part);\n }, this);\n\n for (let i = 0; i < 2; i++) {\n const cElem = parts[i];\n\n addThis = false;\n // The connected element might be part of a selected group\n $(cElem).parents().each(add);\n\n if (!cElem || !cElem.parentNode) {\n $(this).remove();\n continue;\n }\n if (elems.includes(cElem) || addThis) {\n const bb = svgCanvas.getStrokedBBox([cElem]);\n connections.push({\n elem: cElem,\n connector: this,\n is_start: (i === 0),\n start_x: bb.x,\n start_y: bb.y\n });\n }\n }\n });\n }\n\n /**\n * @param {Element[]} [elems=selElems]\n * @returns {void}\n */\n function updateConnectors (elems) {\n // Updates connector lines based on selected elements\n // Is not used on mousemove, as it runs getStrokedBBox every time,\n // which isn't necessary there.\n findConnectors(elems);\n if (connections.length) {\n // Update line with element\n let i = connections.length;\n while (i--) {\n const conn = connections[i];\n const line = conn.connector;\n const {elem} = conn;\n\n // const sw = line.getAttribute('stroke-width') * 5;\n const pre = conn.is_start ? 'start' : 'end';\n\n // Update bbox for this element\n const bb = svgCanvas.getStrokedBBox([elem]);\n bb.x = conn.start_x;\n bb.y = conn.start_y;\n elData(line, pre + '_bb', bb);\n /* const addOffset = */ elData(line, pre + '_off');\n\n const altPre = conn.is_start ? 'end' : 'start';\n\n // Get center pt of connected element\n const bb2 = elData(line, altPre + '_bb');\n const srcX = bb2.x + bb2.width / 2;\n const srcY = bb2.y + bb2.height / 2;\n\n // Set point of element being moved\n let pt = getBBintersect(srcX, srcY, bb, getOffset(pre, line));\n setPoint(line, conn.is_start ? 0 : 'end', pt.x, pt.y, true);\n\n // Set point of connected element\n const pt2 = getBBintersect(pt.x, pt.y, elData(line, altPre + '_bb'), getOffset(altPre, line));\n setPoint(line, conn.is_start ? 'end' : 0, pt2.x, pt2.y, true);\n\n // Update points attribute manually for webkit\n if (navigator.userAgent.includes('AppleWebKit')) {\n const pts = line.points;\n const len = pts.numberOfItems;\n const ptArr = [];\n for (let j = 0; j < len; j++) {\n pt = pts.getItem(j);\n ptArr[j] = pt.x + ',' + pt.y;\n }\n line.setAttribute('points', ptArr.join(' '));\n }\n }\n }\n }\n\n // Do once\n (function () {\n const gse = svgCanvas.groupSelectedElements;\n\n svgCanvas.groupSelectedElements = function (...args) {\n svgCanvas.removeFromSelection($(connSel).toArray());\n return gse.apply(this, args);\n };\n\n const mse = svgCanvas.moveSelectedElements;\n\n svgCanvas.moveSelectedElements = function (...args) {\n const cmd = mse.apply(this, args);\n updateConnectors();\n return cmd;\n };\n\n seNs = svgCanvas.getEditorNS();\n }());\n\n /**\n * Do on reset.\n * @returns {void}\n */\n function init () {\n // Make sure all connectors have data set\n $(svgcontent).find('*').each(function () {\n const conn = this.getAttributeNS(seNs, 'connector');\n if (conn) {\n this.setAttribute('class', connSel.substr(1));\n const connData = conn.split(' ');\n const sbb = svgCanvas.getStrokedBBox([getElem(connData[0])]);\n const ebb = svgCanvas.getStrokedBBox([getElem(connData[1])]);\n $(this).data('c_start', connData[0])\n .data('c_end', connData[1])\n .data('start_bb', sbb)\n .data('end_bb', ebb);\n svgCanvas.getEditorNS(true);\n }\n });\n // updateConnectors();\n }\n\n // $(svgroot).parent().mousemove(function (e) {\n // // if (started\n // // || svgCanvas.getMode() !== 'connector'\n // // || e.target.parentNode.parentNode !== svgcontent) return;\n //\n // console.log('y')\n // // if (e.target.parentNode.parentNode === svgcontent) {\n // //\n // // }\n // });\n\n const buttons = [{\n id: 'mode_connect',\n type: 'mode',\n icon: svgEditor.curConfig.imgPath + 'cut.png',\n includeWith: {\n button: '#tool_line',\n isDefault: false,\n position: 1\n },\n events: {\n click () {\n svgCanvas.setMode('connector');\n }\n }\n }];\n\n return {\n name: strings.name,\n svgicons: svgEditor.curConfig.imgPath + 'conn.svg',\n buttons: strings.buttons.map((button, i) => {\n return Object.assign(buttons[i], button);\n }),\n /* async */ addLangData ({lang}) { // , importLocale: importLoc\n return {\n data: strings.langList\n };\n },\n mouseDown (opts) {\n const e = opts.event;\n startX = opts.start_x;\n startY = opts.start_y;\n const mode = svgCanvas.getMode();\n const {curConfig: {initStroke}} = svgEditor;\n\n if (mode === 'connector') {\n if (started) { return undefined; }\n\n const mouseTarget = e.target;\n\n const parents = $(mouseTarget).parents();\n\n if ($.inArray(svgcontent, parents) !== -1) {\n // Connectable element\n\n // If child of foreignObject, use parent\n const fo = $(mouseTarget).closest('foreignObject');\n startElem = fo.length ? fo[0] : mouseTarget;\n\n // Get center of source element\n const bb = svgCanvas.getStrokedBBox([startElem]);\n const x = bb.x + bb.width / 2;\n const y = bb.y + bb.height / 2;\n\n started = true;\n curLine = addElem({\n element: 'polyline',\n attr: {\n id: svgCanvas.getNextId(),\n points: (x + ',' + y + ' ' + x + ',' + y + ' ' + startX + ',' + startY),\n stroke: '#' + initStroke.color,\n 'stroke-width': (!startElem.stroke_width || startElem.stroke_width === 0)\n ? initStroke.width\n : startElem.stroke_width,\n fill: 'none',\n opacity: initStroke.opacity,\n style: 'pointer-events:none'\n }\n });\n elData(curLine, 'start_bb', bb);\n }\n return {\n started: true\n };\n }\n if (mode === 'select') {\n findConnectors();\n }\n return undefined;\n },\n mouseMove (opts) {\n const zoom = svgCanvas.getZoom();\n // const e = opts.event;\n const x = opts.mouse_x / zoom;\n const y = opts.mouse_y / zoom;\n\n const diffX = x - startX,\n diffY = y - startY;\n\n const mode = svgCanvas.getMode();\n\n if (mode === 'connector' && started) {\n // const sw = curLine.getAttribute('stroke-width') * 3;\n // Set start point (adjusts based on bb)\n const pt = getBBintersect(x, y, elData(curLine, 'start_bb'), getOffset('start', curLine));\n startX = pt.x;\n startY = pt.y;\n\n setPoint(curLine, 0, pt.x, pt.y, true);\n\n // Set end point\n setPoint(curLine, 'end', x, y, true);\n } else if (mode === 'select') {\n let slen = selElems.length;\n while (slen--) {\n const elem = selElems[slen];\n // Look for selected connector elements\n if (elem && elData(elem, 'c_start')) {\n // Remove the \"translate\" transform given to move\n svgCanvas.removeFromSelection([elem]);\n svgCanvas.getTransformList(elem).clear();\n }\n }\n if (connections.length) {\n updateLine(diffX, diffY);\n }\n }\n },\n mouseUp (opts) {\n // const zoom = svgCanvas.getZoom();\n const e = opts.event;\n // , x = opts.mouse_x / zoom,\n // , y = opts.mouse_y / zoom,\n let mouseTarget = e.target;\n\n if (svgCanvas.getMode() !== 'connector') {\n return undefined;\n }\n const fo = $(mouseTarget).closest('foreignObject');\n if (fo.length) { mouseTarget = fo[0]; }\n\n const parents = $(mouseTarget).parents();\n\n if (mouseTarget === startElem) {\n // Start line through click\n started = true;\n return {\n keep: true,\n element: null,\n started\n };\n }\n if ($.inArray(svgcontent, parents) === -1) {\n // Not a valid target element, so remove line\n $(curLine).remove();\n started = false;\n return {\n keep: false,\n element: null,\n started\n };\n }\n // Valid end element\n endElem = mouseTarget;\n\n const startId = startElem.id, endId = endElem.id;\n const connStr = startId + ' ' + endId;\n const altStr = endId + ' ' + startId;\n // Don't create connector if one already exists\n const dupe = $(svgcontent).find(connSel).filter(function () {\n const conn = this.getAttributeNS(seNs, 'connector');\n if (conn === connStr || conn === altStr) { return true; }\n return false;\n });\n if (dupe.length) {\n $(curLine).remove();\n return {\n keep: false,\n element: null,\n started: false\n };\n }\n\n const bb = svgCanvas.getStrokedBBox([endElem]);\n\n const pt = getBBintersect(startX, startY, bb, getOffset('start', curLine));\n setPoint(curLine, 'end', pt.x, pt.y, true);\n $(curLine)\n .data('c_start', startId)\n .data('c_end', endId)\n .data('end_bb', bb);\n seNs = svgCanvas.getEditorNS(true);\n curLine.setAttributeNS(seNs, 'se:connector', connStr);\n curLine.setAttribute('class', connSel.substr(1));\n curLine.setAttribute('opacity', 1);\n svgCanvas.addToSelection([curLine]);\n svgCanvas.moveToBottomSelectedElement();\n selManager.requestSelector(curLine).showGrips(false);\n started = false;\n return {\n keep: true,\n element: curLine,\n started\n };\n },\n selectedChanged (opts) {\n // TODO: Find better way to skip operations if no connectors are in use\n if (!$(svgcontent).find(connSel).length) { return; }\n\n if (svgCanvas.getMode() === 'connector') {\n svgCanvas.setMode('select');\n }\n\n // Use this to update the current selected elements\n selElems = opts.elems;\n\n let i = selElems.length;\n while (i--) {\n const elem = selElems[i];\n if (elem && elData(elem, 'c_start')) {\n selManager.requestSelector(elem).showGrips(false);\n if (opts.selectedElement && !opts.multiselected) {\n // TODO: Set up context tools and hide most regular line tools\n showPanel(true);\n } else {\n showPanel(false);\n }\n } else {\n showPanel(false);\n }\n }\n updateConnectors();\n },\n elementChanged (opts) {\n let elem = opts.elems[0];\n if (!elem) return;\n if (elem.tagName === 'svg' && elem.id === 'svgcontent') {\n // Update svgcontent (can change on import)\n svgcontent = elem;\n init();\n }\n\n // Has marker, so change offset\n if (\n elem.getAttribute('marker-start') ||\n elem.getAttribute('marker-mid') ||\n elem.getAttribute('marker-end')\n ) {\n const start = elem.getAttribute('marker-start');\n const mid = elem.getAttribute('marker-mid');\n const end = elem.getAttribute('marker-end');\n curLine = elem;\n $(elem)\n .data('start_off', Boolean(start))\n .data('end_off', Boolean(end));\n\n if (elem.tagName === 'line' && mid) {\n // Convert to polyline to accept mid-arrow\n\n const x1 = Number(elem.getAttribute('x1'));\n const x2 = Number(elem.getAttribute('x2'));\n const y1 = Number(elem.getAttribute('y1'));\n const y2 = Number(elem.getAttribute('y2'));\n const {id} = elem;\n\n const midPt = (' ' + ((x1 + x2) / 2) + ',' + ((y1 + y2) / 2) + ' ');\n const pline = addElem({\n element: 'polyline',\n attr: {\n points: (x1 + ',' + y1 + midPt + x2 + ',' + y2),\n stroke: elem.getAttribute('stroke'),\n 'stroke-width': elem.getAttribute('stroke-width'),\n 'marker-mid': mid,\n fill: 'none',\n opacity: elem.getAttribute('opacity') || 1\n }\n });\n $(elem).after(pline).remove();\n svgCanvas.clearSelection();\n pline.id = id;\n svgCanvas.addToSelection([pline]);\n elem = pline;\n }\n }\n // Update line if it's a connector\n if (elem.getAttribute('class') === connSel.substr(1)) {\n const start = getElem(elData(elem, 'c_start'));\n updateConnectors([start]);\n } else {\n updateConnectors();\n }\n },\n IDsUpdated (input) {\n const remove = [];\n input.elems.forEach(function (elem) {\n if ('se:connector' in elem.attr) {\n elem.attr['se:connector'] = elem.attr['se:connector'].split(' ')\n .map(function (oldID) { return input.changes[oldID]; }).join(' ');\n\n // Check validity - the field would be something like 'svg_21 svg_22', but\n // if one end is missing, it would be 'svg_21' and therefore fail this test\n if (!(/. ./).test(elem.attr['se:connector'])) {\n remove.push(elem.attr.id);\n }\n }\n });\n return {remove};\n },\n toolButtonStateUpdate (opts) {\n if (opts.nostroke) {\n if ($('#mode_connect').hasClass('tool_button_current')) {\n svgEditor.clickSelect();\n }\n }\n $('#mode_connect')\n .toggleClass('disabled', opts.nostroke);\n }\n };\n }\n};\n"],"names":["name","init","S","getBBintersect","getOffset","showPanel","setPoint","updateLine","findConnectors","updateConnectors","$","svgcontent","find","each","conn","getAttributeNS","seNs","setAttribute","connSel","substr","connData","split","sbb","svgCanvas","getStrokedBBox","getElem","ebb","data","getEditorNS","elems","connections","length","i","line","connector","elem","pre","is_start","bb","x","start_x","y","start_y","elData","altPre","bb2","srcX","width","srcY","height","pt","pt2","navigator","userAgent","includes","pts","points","len","numberOfItems","ptArr","j","getItem","join","selElems","connectors","addThis","add","parts","forEach","pos","key","part","undefined","document","getElementById","attributes","value","id","push","cElem","parents","parentNode","remove","diffX","diffY","setMid","svgroot","createSVGPoint","replaceItem","err","getAttribute","ptStart","ptEnd","on","connRules","appendTo","text","toggle","side","giveOffset","size","offset","extend","midX","midY","lenX","lenY","slope","Math","abs","ratio","svgEditor","canvas","importLocale","addElem","addSVGElementFromJson","selManager","selectorManager","strings","started","gse","groupSelectedElements","removeFromSelection","toArray","args","apply","mse","moveSelectedElements","cmd","buttons","type","icon","curConfig","imgPath","includeWith","button","isDefault","position","events","click","setMode","svgicons","map","Object","assign","addLangData","lang","langList","mouseDown","opts","e","event","startX","startY","mode","getMode","initStroke","mouseTarget","target","inArray","fo","closest","startElem","curLine","element","attr","getNextId","stroke","color","stroke_width","fill","opacity","style","mouseMove","zoom","getZoom","mouse_x","mouse_y","slen","getTransformList","clear","mouseUp","keep","endElem","startId","endId","connStr","altStr","dupe","filter","setAttributeNS","addToSelection","moveToBottomSelectedElement","requestSelector","showGrips","selectedChanged","selectedElement","multiselected","elementChanged","tagName","start","mid","end","Boolean","x1","Number","x2","y1","y2","midPt","pline","after","clearSelection","IDsUpdated","input","oldID","changes","test","toolButtonStateUpdate","nostroke","hasClass","clickSelect","toggleClass"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file diff --git a/dist/editor/extensions/ext-eyedropper.js b/dist/editor/extensions/ext-eyedropper.js index 49a23e8a..d731f5c5 100644 --- a/dist/editor/extensions/ext-eyedropper.js +++ b/dist/editor/extensions/ext-eyedropper.js @@ -1,3 +1,1651 @@ +function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); +} + +var REACT_ELEMENT_TYPE; + +function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; +} + +function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); +} + +function _AwaitValue(value) { + this.wrapped = value; +} + +function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } +} + +if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; +} + +_AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); +}; + +_AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); +}; + +_AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); +}; + +function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; +} + +function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); +} + +function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; +} + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} + +function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; +} + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} + +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} + +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} + +function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; +} + +function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); +} + +function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); +} + +function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; +} + +function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); +} + +function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); +} + +function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } +} + +function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); +} + +function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; +} + +function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); +} + +function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} + +function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; +} + +function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; +} + +function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } +} + +function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); +} + +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; +} + +function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); +} + +function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; +} + +function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; +} + +function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); +} + +function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); +} + +function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; +} + +function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); +} + +function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; +} + +function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); +} + +function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); +} + +function _temporalUndefined() {} + +function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); +} + +function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; +} + +function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); +} + +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} + +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); +} + +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); +} + +function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; +} + +function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; +} + +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} + +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; +} + +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; +} + +function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); +} + +function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; +} + +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); +} + +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); +} + +function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); +} + +function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); +} + +function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; +} + +var id = 0; + +function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; +} + +function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; +} + +function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } +} + +function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; +} + +function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); +} + +function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); +} + +function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; +} + +function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; +} + +function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } +} + +function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; +} + +function _hasDecorators(element) { + return element.decorators && element.decorators.length; +} + +function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); +} + +function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; +} + +function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; +} + +function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); +} + +function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); +} + /** * @file ext-eyedropper.js * @@ -6,110 +1654,157 @@ * @copyright 2010 Jeff Schiller * */ - -export default { +var extEyedropper = { name: 'eyedropper', - async init (S) { - const strings = await S.importLocale(); - const svgEditor = this; - const {$, ChangeElementCommand} = S, // , svgcontent, - // svgdoc = S.svgroot.parentNode.ownerDocument, - svgCanvas = svgEditor.canvas, - addToHistory = function (cmd) { svgCanvas.undoMgr.addCommandToHistory(cmd); }, - currentStyle = { - fillPaint: 'red', fillOpacity: 1.0, - strokePaint: 'black', strokeOpacity: 1.0, - strokeWidth: 5, strokeDashArray: null, - opacity: 1.0, - strokeLinecap: 'butt', - strokeLinejoin: 'miter' - }; + init: function init(S) { + var _this = this; - /** - * - * @param {module:svgcanvas.SvgCanvas#event:ext_selectedChanged|module:svgcanvas.SvgCanvas#event:ext_elementChanged} opts - * @returns {void} - */ - function getStyle (opts) { - // if we are in eyedropper mode, we don't want to disable the eye-dropper tool - const mode = svgCanvas.getMode(); - if (mode === 'eyedropper') { return; } + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var strings, svgEditor, $, ChangeElementCommand, svgCanvas, addToHistory, currentStyle, getStyle, buttons; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + getStyle = function _getStyle(opts) { + // if we are in eyedropper mode, we don't want to disable the eye-dropper tool + var mode = svgCanvas.getMode(); - const tool = $('#tool_eyedropper'); - // enable-eye-dropper if one element is selected - let elem = null; - if (!opts.multiselected && opts.elems[0] && - !['svg', 'g', 'use'].includes(opts.elems[0].nodeName) - ) { - elem = opts.elems[0]; - tool.removeClass('disabled'); - // grab the current style - currentStyle.fillPaint = elem.getAttribute('fill') || 'black'; - currentStyle.fillOpacity = elem.getAttribute('fill-opacity') || 1.0; - currentStyle.strokePaint = elem.getAttribute('stroke'); - currentStyle.strokeOpacity = elem.getAttribute('stroke-opacity') || 1.0; - currentStyle.strokeWidth = elem.getAttribute('stroke-width'); - currentStyle.strokeDashArray = elem.getAttribute('stroke-dasharray'); - currentStyle.strokeLinecap = elem.getAttribute('stroke-linecap'); - currentStyle.strokeLinejoin = elem.getAttribute('stroke-linejoin'); - currentStyle.opacity = elem.getAttribute('opacity') || 1.0; - // disable eye-dropper tool - } else { - tool.addClass('disabled'); - } - } + if (mode === 'eyedropper') { + return; + } - const buttons = [ - { - id: 'tool_eyedropper', - icon: svgEditor.curConfig.extIconsPath + 'eyedropper.png', - type: 'mode', - events: { - click () { - svgCanvas.setMode('eyedropper'); + var tool = $('#tool_eyedropper'); // enable-eye-dropper if one element is selected + + var elem = null; + + if (!opts.multiselected && opts.elems[0] && !['svg', 'g', 'use'].includes(opts.elems[0].nodeName)) { + elem = opts.elems[0]; + tool.removeClass('disabled'); // grab the current style + + currentStyle.fillPaint = elem.getAttribute('fill') || 'black'; + currentStyle.fillOpacity = elem.getAttribute('fill-opacity') || 1.0; + currentStyle.strokePaint = elem.getAttribute('stroke'); + currentStyle.strokeOpacity = elem.getAttribute('stroke-opacity') || 1.0; + currentStyle.strokeWidth = elem.getAttribute('stroke-width'); + currentStyle.strokeDashArray = elem.getAttribute('stroke-dasharray'); + currentStyle.strokeLinecap = elem.getAttribute('stroke-linecap'); + currentStyle.strokeLinejoin = elem.getAttribute('stroke-linejoin'); + currentStyle.opacity = elem.getAttribute('opacity') || 1.0; // disable eye-dropper tool + } else { + tool.addClass('disabled'); + } + }; + + _context.next = 3; + return S.importLocale(); + + case 3: + strings = _context.sent; + svgEditor = _this; + $ = S.$, ChangeElementCommand = S.ChangeElementCommand, svgCanvas = svgEditor.canvas, addToHistory = function addToHistory(cmd) { + svgCanvas.undoMgr.addCommandToHistory(cmd); + }, currentStyle = { + fillPaint: 'red', + fillOpacity: 1.0, + strokePaint: 'black', + strokeOpacity: 1.0, + strokeWidth: 5, + strokeDashArray: null, + opacity: 1.0, + strokeLinecap: 'butt', + strokeLinejoin: 'miter' + }; + /** + * + * @param {module:svgcanvas.SvgCanvas#event:ext_selectedChanged|module:svgcanvas.SvgCanvas#event:ext_elementChanged} opts + * @returns {void} + */ + + buttons = [{ + id: 'tool_eyedropper', + icon: svgEditor.curConfig.extIconsPath + 'eyedropper.png', + type: 'mode', + events: { + click: function click() { + svgCanvas.setMode('eyedropper'); + } + } + }]; + return _context.abrupt("return", { + name: strings.name, + svgicons: svgEditor.curConfig.extIconsPath + 'eyedropper-icon.xml', + buttons: strings.buttons.map(function (button, i) { + return Object.assign(buttons[i], button); + }), + // if we have selected an element, grab its paint and enable the eye dropper button + selectedChanged: getStyle, + elementChanged: getStyle, + mouseDown: function mouseDown(opts) { + var mode = svgCanvas.getMode(); + + if (mode === 'eyedropper') { + var e = opts.event; + var target = e.target; + + if (!['svg', 'g', 'use'].includes(target.nodeName)) { + var changes = {}; + + var change = function change(elem, attrname, newvalue) { + changes[attrname] = elem.getAttribute(attrname); + elem.setAttribute(attrname, newvalue); + }; + + if (currentStyle.fillPaint) { + change(target, 'fill', currentStyle.fillPaint); + } + + if (currentStyle.fillOpacity) { + change(target, 'fill-opacity', currentStyle.fillOpacity); + } + + if (currentStyle.strokePaint) { + change(target, 'stroke', currentStyle.strokePaint); + } + + if (currentStyle.strokeOpacity) { + change(target, 'stroke-opacity', currentStyle.strokeOpacity); + } + + if (currentStyle.strokeWidth) { + change(target, 'stroke-width', currentStyle.strokeWidth); + } + + if (currentStyle.strokeDashArray) { + change(target, 'stroke-dasharray', currentStyle.strokeDashArray); + } + + if (currentStyle.opacity) { + change(target, 'opacity', currentStyle.opacity); + } + + if (currentStyle.strokeLinecap) { + change(target, 'stroke-linecap', currentStyle.strokeLinecap); + } + + if (currentStyle.strokeLinejoin) { + change(target, 'stroke-linejoin', currentStyle.strokeLinejoin); + } + + addToHistory(new ChangeElementCommand(target, changes)); + } + } + } + }); + + case 8: + case "end": + return _context.stop(); } } - } - ]; - - return { - name: strings.name, - svgicons: svgEditor.curConfig.extIconsPath + 'eyedropper-icon.xml', - buttons: strings.buttons.map((button, i) => { - return Object.assign(buttons[i], button); - }), - - // if we have selected an element, grab its paint and enable the eye dropper button - selectedChanged: getStyle, - elementChanged: getStyle, - - mouseDown (opts) { - const mode = svgCanvas.getMode(); - if (mode === 'eyedropper') { - const e = opts.event; - const {target} = e; - if (!['svg', 'g', 'use'].includes(target.nodeName)) { - const changes = {}; - - const change = function (elem, attrname, newvalue) { - changes[attrname] = elem.getAttribute(attrname); - elem.setAttribute(attrname, newvalue); - }; - - if (currentStyle.fillPaint) { change(target, 'fill', currentStyle.fillPaint); } - if (currentStyle.fillOpacity) { change(target, 'fill-opacity', currentStyle.fillOpacity); } - if (currentStyle.strokePaint) { change(target, 'stroke', currentStyle.strokePaint); } - if (currentStyle.strokeOpacity) { change(target, 'stroke-opacity', currentStyle.strokeOpacity); } - if (currentStyle.strokeWidth) { change(target, 'stroke-width', currentStyle.strokeWidth); } - if (currentStyle.strokeDashArray) { change(target, 'stroke-dasharray', currentStyle.strokeDashArray); } - if (currentStyle.opacity) { change(target, 'opacity', currentStyle.opacity); } - if (currentStyle.strokeLinecap) { change(target, 'stroke-linecap', currentStyle.strokeLinecap); } - if (currentStyle.strokeLinejoin) { change(target, 'stroke-linejoin', currentStyle.strokeLinejoin); } - - addToHistory(new ChangeElementCommand(target, changes)); - } - } - } - }; + }, _callee); + }))(); } }; + +export default extEyedropper; +//# sourceMappingURL=ext-eyedropper.js.map diff --git a/dist/editor/extensions/ext-eyedropper.js.map b/dist/editor/extensions/ext-eyedropper.js.map new file mode 100644 index 00000000..9466090b --- /dev/null +++ b/dist/editor/extensions/ext-eyedropper.js.map @@ -0,0 +1 @@ +{"version":3,"file":"ext-eyedropper.js","sources":["../../../src/editor/extensions/ext-eyedropper.js"],"sourcesContent":["/**\n * @file ext-eyedropper.js\n *\n * @license MIT\n *\n * @copyright 2010 Jeff Schiller\n *\n */\n\nexport default {\n name: 'eyedropper',\n async init (S) {\n const strings = await S.importLocale();\n const svgEditor = this;\n const {$, ChangeElementCommand} = S, // , svgcontent,\n // svgdoc = S.svgroot.parentNode.ownerDocument,\n svgCanvas = svgEditor.canvas,\n addToHistory = function (cmd) { svgCanvas.undoMgr.addCommandToHistory(cmd); },\n currentStyle = {\n fillPaint: 'red', fillOpacity: 1.0,\n strokePaint: 'black', strokeOpacity: 1.0,\n strokeWidth: 5, strokeDashArray: null,\n opacity: 1.0,\n strokeLinecap: 'butt',\n strokeLinejoin: 'miter'\n };\n\n /**\n *\n * @param {module:svgcanvas.SvgCanvas#event:ext_selectedChanged|module:svgcanvas.SvgCanvas#event:ext_elementChanged} opts\n * @returns {void}\n */\n function getStyle (opts) {\n // if we are in eyedropper mode, we don't want to disable the eye-dropper tool\n const mode = svgCanvas.getMode();\n if (mode === 'eyedropper') { return; }\n\n const tool = $('#tool_eyedropper');\n // enable-eye-dropper if one element is selected\n let elem = null;\n if (!opts.multiselected && opts.elems[0] &&\n !['svg', 'g', 'use'].includes(opts.elems[0].nodeName)\n ) {\n elem = opts.elems[0];\n tool.removeClass('disabled');\n // grab the current style\n currentStyle.fillPaint = elem.getAttribute('fill') || 'black';\n currentStyle.fillOpacity = elem.getAttribute('fill-opacity') || 1.0;\n currentStyle.strokePaint = elem.getAttribute('stroke');\n currentStyle.strokeOpacity = elem.getAttribute('stroke-opacity') || 1.0;\n currentStyle.strokeWidth = elem.getAttribute('stroke-width');\n currentStyle.strokeDashArray = elem.getAttribute('stroke-dasharray');\n currentStyle.strokeLinecap = elem.getAttribute('stroke-linecap');\n currentStyle.strokeLinejoin = elem.getAttribute('stroke-linejoin');\n currentStyle.opacity = elem.getAttribute('opacity') || 1.0;\n // disable eye-dropper tool\n } else {\n tool.addClass('disabled');\n }\n }\n\n const buttons = [\n {\n id: 'tool_eyedropper',\n icon: svgEditor.curConfig.extIconsPath + 'eyedropper.png',\n type: 'mode',\n events: {\n click () {\n svgCanvas.setMode('eyedropper');\n }\n }\n }\n ];\n\n return {\n name: strings.name,\n svgicons: svgEditor.curConfig.extIconsPath + 'eyedropper-icon.xml',\n buttons: strings.buttons.map((button, i) => {\n return Object.assign(buttons[i], button);\n }),\n\n // if we have selected an element, grab its paint and enable the eye dropper button\n selectedChanged: getStyle,\n elementChanged: getStyle,\n\n mouseDown (opts) {\n const mode = svgCanvas.getMode();\n if (mode === 'eyedropper') {\n const e = opts.event;\n const {target} = e;\n if (!['svg', 'g', 'use'].includes(target.nodeName)) {\n const changes = {};\n\n const change = function (elem, attrname, newvalue) {\n changes[attrname] = elem.getAttribute(attrname);\n elem.setAttribute(attrname, newvalue);\n };\n\n if (currentStyle.fillPaint) { change(target, 'fill', currentStyle.fillPaint); }\n if (currentStyle.fillOpacity) { change(target, 'fill-opacity', currentStyle.fillOpacity); }\n if (currentStyle.strokePaint) { change(target, 'stroke', currentStyle.strokePaint); }\n if (currentStyle.strokeOpacity) { change(target, 'stroke-opacity', currentStyle.strokeOpacity); }\n if (currentStyle.strokeWidth) { change(target, 'stroke-width', currentStyle.strokeWidth); }\n if (currentStyle.strokeDashArray) { change(target, 'stroke-dasharray', currentStyle.strokeDashArray); }\n if (currentStyle.opacity) { change(target, 'opacity', currentStyle.opacity); }\n if (currentStyle.strokeLinecap) { change(target, 'stroke-linecap', currentStyle.strokeLinecap); }\n if (currentStyle.strokeLinejoin) { change(target, 'stroke-linejoin', currentStyle.strokeLinejoin); }\n\n addToHistory(new ChangeElementCommand(target, changes));\n }\n }\n }\n };\n }\n};\n"],"names":["name","init","S","getStyle","opts","mode","svgCanvas","getMode","tool","$","elem","multiselected","elems","includes","nodeName","removeClass","currentStyle","fillPaint","getAttribute","fillOpacity","strokePaint","strokeOpacity","strokeWidth","strokeDashArray","strokeLinecap","strokeLinejoin","opacity","addClass","importLocale","strings","svgEditor","ChangeElementCommand","canvas","addToHistory","cmd","undoMgr","addCommandToHistory","buttons","id","icon","curConfig","extIconsPath","type","events","click","setMode","svgicons","map","button","i","Object","assign","selectedChanged","elementChanged","mouseDown","e","event","target","changes","change","attrname","newvalue","setAttribute"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file diff --git a/dist/editor/extensions/ext-foreignobject.js b/dist/editor/extensions/ext-foreignobject.js index 31a83693..3db58c38 100644 --- a/dist/editor/extensions/ext-foreignobject.js +++ b/dist/editor/extensions/ext-foreignobject.js @@ -1,3 +1,1651 @@ +function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); +} + +var REACT_ELEMENT_TYPE; + +function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; +} + +function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); +} + +function _AwaitValue(value) { + this.wrapped = value; +} + +function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } +} + +if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; +} + +_AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); +}; + +_AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); +}; + +_AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); +}; + +function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; +} + +function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); +} + +function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; +} + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} + +function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; +} + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} + +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} + +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} + +function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; +} + +function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); +} + +function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); +} + +function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; +} + +function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); +} + +function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); +} + +function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } +} + +function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); +} + +function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; +} + +function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); +} + +function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} + +function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; +} + +function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; +} + +function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } +} + +function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); +} + +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; +} + +function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); +} + +function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; +} + +function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; +} + +function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); +} + +function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); +} + +function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; +} + +function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); +} + +function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; +} + +function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); +} + +function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); +} + +function _temporalUndefined() {} + +function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); +} + +function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; +} + +function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); +} + +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} + +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); +} + +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); +} + +function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; +} + +function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; +} + +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} + +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; +} + +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; +} + +function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); +} + +function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; +} + +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); +} + +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); +} + +function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); +} + +function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); +} + +function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; +} + +var id = 0; + +function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; +} + +function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; +} + +function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } +} + +function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; +} + +function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); +} + +function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); +} + +function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; +} + +function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; +} + +function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } +} + +function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; +} + +function _hasDecorators(element) { + return element.decorators && element.decorators.length; +} + +function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); +} + +function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; +} + +function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; +} + +function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); +} + +function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); +} + /** * @file ext-foreignobject.js * @@ -6,275 +1654,318 @@ * @copyright 2010 Jacques Distler, 2010 Alexis Deveria * */ - -export default { +var extForeignobject = { name: 'foreignobject', - async init (S) { - const svgEditor = this; - const {$, text2xml, NS, importLocale} = S; - const svgCanvas = svgEditor.canvas; - const - // {svgcontent} = S, - // addElem = svgCanvas.addSVGElementFromJson, - svgdoc = S.svgroot.parentNode.ownerDocument; - const strings = await importLocale(); + init: function init(S) { + var _this = this; - const properlySourceSizeTextArea = function () { - // TODO: remove magic numbers here and get values from CSS - const height = $('#svg_source_container').height() - 80; - $('#svg_source_textarea').css('height', height); - }; + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() { + var svgEditor, $, text2xml, NS, importLocale, svgCanvas, svgdoc, strings, properlySourceSizeTextArea, showPanel, toggleSourceButtons, selElems, started, newFO, editingforeign, setForeignString, showForeignEditor, setAttr, buttons, contextTools; + return regeneratorRuntime.wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + setAttr = function _setAttr(attr, val) { + svgCanvas.changeSelectedAttribute(attr, val); + svgCanvas.call('changed', selElems); + }; - /** - * @param {boolean} on - * @returns {void} - */ - function showPanel (on) { - let fcRules = $('#fc_rules'); - if (!fcRules.length) { - fcRules = $('').appendTo('head'); - } - fcRules.text(!on ? '' : ' #tool_topath { display: none !important; }'); - $('#foreignObject_panel').toggle(on); - } + showForeignEditor = function _showForeignEditor() { + var elt = selElems[0]; - /** - * @param {boolean} on - * @returns {void} - */ - function toggleSourceButtons (on) { - $('#tool_source_save, #tool_source_cancel').toggle(!on); - $('#foreign_save, #foreign_cancel').toggle(on); - } + if (!elt || editingforeign) { + return; + } - let selElems, - started, - newFO, - editingforeign = false; + editingforeign = true; + toggleSourceButtons(true); + elt.removeAttribute('fill'); + var str = svgCanvas.svgToString(elt, 0); + $('#svg_source_textarea').val(str); + $('#svg_source_editor').fadeIn(); + properlySourceSizeTextArea(); + $('#svg_source_textarea').focus(); + }; - /** - * This function sets the content of element elt to the input XML. - * @param {string} xmlString - The XML text - * @returns {boolean} This function returns false if the set was unsuccessful, true otherwise. - */ - function setForeignString (xmlString) { - const elt = selElems[0]; // The parent `Element` to append to - try { - // convert string into XML document - const newDoc = text2xml('' + xmlString + ''); - // run it through our sanitizer to remove anything we do not support - svgCanvas.sanitizeSvg(newDoc.documentElement); - elt.replaceWith(svgdoc.importNode(newDoc.documentElement.firstChild, true)); - svgCanvas.call('changed', [elt]); - svgCanvas.clearSelection(); - } catch (e) { - // Todo: Surface error to user - console.log(e); // eslint-disable-line no-console - return false; - } + setForeignString = function _setForeignString(xmlString) { + var elt = selElems[0]; // The parent `Element` to append to - return true; - } + try { + // convert string into XML document + var newDoc = text2xml('' + xmlString + ''); // run it through our sanitizer to remove anything we do not support - /** - * - * @returns {void} - */ - function showForeignEditor () { - const elt = selElems[0]; - if (!elt || editingforeign) { return; } - editingforeign = true; - toggleSourceButtons(true); - elt.removeAttribute('fill'); + svgCanvas.sanitizeSvg(newDoc.documentElement); + elt.replaceWith(svgdoc.importNode(newDoc.documentElement.firstChild, true)); + svgCanvas.call('changed', [elt]); + svgCanvas.clearSelection(); + } catch (e) { + // Todo: Surface error to user + console.log(e); // eslint-disable-line no-console - const str = svgCanvas.svgToString(elt, 0); - $('#svg_source_textarea').val(str); - $('#svg_source_editor').fadeIn(); - properlySourceSizeTextArea(); - $('#svg_source_textarea').focus(); - } + return false; + } - /** - * @param {string} attr - * @param {string|Float} val - * @returns {void} - */ - function setAttr (attr, val) { - svgCanvas.changeSelectedAttribute(attr, val); - svgCanvas.call('changed', selElems); - } + return true; + }; - const buttons = [{ - id: 'tool_foreign', - icon: svgEditor.curConfig.extIconsPath + 'foreignobject-tool.png', - type: 'mode', - events: { - click () { - svgCanvas.setMode('foreign'); - } - } - }, { - id: 'edit_foreign', - icon: svgEditor.curConfig.extIconsPath + 'foreignobject-edit.png', - type: 'context', - panel: 'foreignObject_panel', - events: { - click () { - showForeignEditor(); - } - } - }]; + toggleSourceButtons = function _toggleSourceButtons(on) { + $('#tool_source_save, #tool_source_cancel').toggle(!on); + $('#foreign_save, #foreign_cancel').toggle(on); + }; - const contextTools = [ - { - type: 'input', - panel: 'foreignObject_panel', - id: 'foreign_width', - size: 3, - events: { - change () { - setAttr('width', this.value); + showPanel = function _showPanel(on) { + var fcRules = $('#fc_rules'); + + if (!fcRules.length) { + fcRules = $('').appendTo('head'); + } + + fcRules.text(!on ? '' : ' #tool_topath { display: none !important; }'); + $('#foreignObject_panel').toggle(on); + }; + + svgEditor = _this; + $ = S.$, text2xml = S.text2xml, NS = S.NS, importLocale = S.importLocale; + svgCanvas = svgEditor.canvas; + svgdoc = S.svgroot.parentNode.ownerDocument; + _context2.next = 11; + return importLocale(); + + case 11: + strings = _context2.sent; + + properlySourceSizeTextArea = function properlySourceSizeTextArea() { + // TODO: remove magic numbers here and get values from CSS + var height = $('#svg_source_container').height() - 80; + $('#svg_source_textarea').css('height', height); + }; + /** + * @param {boolean} on + * @returns {void} + */ + + + editingforeign = false; + /** + * This function sets the content of element elt to the input XML. + * @param {string} xmlString - The XML text + * @returns {boolean} This function returns false if the set was unsuccessful, true otherwise. + */ + + buttons = [{ + id: 'tool_foreign', + icon: svgEditor.curConfig.extIconsPath + 'foreignobject-tool.png', + type: 'mode', + events: { + click: function click() { + svgCanvas.setMode('foreign'); + } + } + }, { + id: 'edit_foreign', + icon: svgEditor.curConfig.extIconsPath + 'foreignobject-edit.png', + type: 'context', + panel: 'foreignObject_panel', + events: { + click: function click() { + showForeignEditor(); + } + } + }]; + contextTools = [{ + type: 'input', + panel: 'foreignObject_panel', + id: 'foreign_width', + size: 3, + events: { + change: function change() { + setAttr('width', this.value); + } + } + }, { + type: 'input', + panel: 'foreignObject_panel', + id: 'foreign_height', + events: { + change: function change() { + setAttr('height', this.value); + } + } + }, { + type: 'input', + panel: 'foreignObject_panel', + id: 'foreign_font_size', + size: 2, + defval: 16, + events: { + change: function change() { + setAttr('font-size', this.value); + } + } + }]; + return _context2.abrupt("return", { + name: strings.name, + svgicons: svgEditor.curConfig.extIconsPath + 'foreignobject-icons.xml', + buttons: strings.buttons.map(function (button, i) { + return Object.assign(buttons[i], button); + }), + context_tools: strings.contextTools.map(function (contextTool, i) { + return Object.assign(contextTools[i], contextTool); + }), + callback: function callback() { + $('#foreignObject_panel').hide(); + + var endChanges = function endChanges() { + $('#svg_source_editor').hide(); + editingforeign = false; + $('#svg_source_textarea').blur(); + toggleSourceButtons(false); + }; // TODO: Needs to be done after orig icon loads + + + setTimeout(function () { + // Create source save/cancel buttons + + /* const save = */ + $('#tool_source_save').clone().hide().attr('id', 'foreign_save').unbind().appendTo('#tool_source_back').click( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var ok; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + if (editingforeign) { + _context.next = 2; + break; + } + + return _context.abrupt("return"); + + case 2: + if (setForeignString($('#svg_source_textarea').val())) { + _context.next = 11; + break; + } + + _context.next = 5; + return $.confirm('Errors found. Revert to original?'); + + case 5: + ok = _context.sent; + + if (ok) { + _context.next = 8; + break; + } + + return _context.abrupt("return"); + + case 8: + endChanges(); + _context.next = 12; + break; + + case 11: + endChanges(); + + case 12: + case "end": + return _context.stop(); + } + } + }, _callee); + }))); + /* const cancel = */ + + $('#tool_source_cancel').clone().hide().attr('id', 'foreign_cancel').unbind().appendTo('#tool_source_back').click(function () { + endChanges(); + }); + }, 3000); + }, + mouseDown: function mouseDown(opts) { + // const e = opts.event; + if (svgCanvas.getMode() !== 'foreign') { + return undefined; + } + + started = true; + newFO = svgCanvas.addSVGElementFromJson({ + element: 'foreignObject', + attr: { + x: opts.start_x, + y: opts.start_y, + id: svgCanvas.getNextId(), + 'font-size': 16, + // cur_text.font_size, + width: '48', + height: '20', + style: 'pointer-events:inherit' + } + }); + var m = svgdoc.createElementNS(NS.MATH, 'math'); + m.setAttributeNS(NS.XMLNS, 'xmlns', NS.MATH); + m.setAttribute('display', 'inline'); + var mi = svgdoc.createElementNS(NS.MATH, 'mi'); + mi.setAttribute('mathvariant', 'normal'); + mi.textContent = "\u03A6"; + var mo = svgdoc.createElementNS(NS.MATH, 'mo'); + mo.textContent = "\u222A"; + var mi2 = svgdoc.createElementNS(NS.MATH, 'mi'); + mi2.textContent = "\u2133"; + m.append(mi, mo, mi2); + newFO.append(m); + return { + started: true + }; + }, + mouseUp: function mouseUp(opts) { + // const e = opts.event; + if (svgCanvas.getMode() !== 'foreign' || !started) { + return undefined; + } + + var attrs = $(newFO).attr(['width', 'height']); + var keep = attrs.width !== '0' || attrs.height !== '0'; + svgCanvas.addToSelection([newFO], true); + return { + keep: keep, + element: newFO + }; + }, + selectedChanged: function selectedChanged(opts) { + // Use this to update the current selected elements + selElems = opts.elems; + var i = selElems.length; + + while (i--) { + var elem = selElems[i]; + + if (elem && elem.tagName === 'foreignObject') { + if (opts.selectedElement && !opts.multiselected) { + $('#foreign_font_size').val(elem.getAttribute('font-size')); + $('#foreign_width').val(elem.getAttribute('width')); + $('#foreign_height').val(elem.getAttribute('height')); + showPanel(true); + } else { + showPanel(false); + } + } else { + showPanel(false); + } + } + }, + elementChanged: function elementChanged(opts) {// const elem = opts.elems[0]; + } + }); + + case 17: + case "end": + return _context2.stop(); } } - }, { - type: 'input', - panel: 'foreignObject_panel', - id: 'foreign_height', - events: { - change () { - setAttr('height', this.value); - } - } - }, { - type: 'input', - panel: 'foreignObject_panel', - id: 'foreign_font_size', - size: 2, - defval: 16, - events: { - change () { - setAttr('font-size', this.value); - } - } - } - ]; - - return { - name: strings.name, - svgicons: svgEditor.curConfig.extIconsPath + 'foreignobject-icons.xml', - buttons: strings.buttons.map((button, i) => { - return Object.assign(buttons[i], button); - }), - context_tools: strings.contextTools.map((contextTool, i) => { - return Object.assign(contextTools[i], contextTool); - }), - callback () { - $('#foreignObject_panel').hide(); - - const endChanges = function () { - $('#svg_source_editor').hide(); - editingforeign = false; - $('#svg_source_textarea').blur(); - toggleSourceButtons(false); - }; - - // TODO: Needs to be done after orig icon loads - setTimeout(function () { - // Create source save/cancel buttons - /* const save = */ $('#tool_source_save').clone() - .hide().attr('id', 'foreign_save').unbind() - .appendTo('#tool_source_back').click(async function () { - if (!editingforeign) { return; } - - if (!setForeignString($('#svg_source_textarea').val())) { - const ok = await $.confirm('Errors found. Revert to original?'); - if (!ok) { return; } - endChanges(); - } else { - endChanges(); - } - // setSelectMode(); - }); - - /* const cancel = */ $('#tool_source_cancel').clone() - .hide().attr('id', 'foreign_cancel').unbind() - .appendTo('#tool_source_back').click(function () { - endChanges(); - }); - }, 3000); - }, - mouseDown (opts) { - // const e = opts.event; - if (svgCanvas.getMode() !== 'foreign') { - return undefined; - } - started = true; - newFO = svgCanvas.addSVGElementFromJson({ - element: 'foreignObject', - attr: { - x: opts.start_x, - y: opts.start_y, - id: svgCanvas.getNextId(), - 'font-size': 16, // cur_text.font_size, - width: '48', - height: '20', - style: 'pointer-events:inherit' - } - }); - const m = svgdoc.createElementNS(NS.MATH, 'math'); - m.setAttributeNS(NS.XMLNS, 'xmlns', NS.MATH); - m.setAttribute('display', 'inline'); - const mi = svgdoc.createElementNS(NS.MATH, 'mi'); - mi.setAttribute('mathvariant', 'normal'); - mi.textContent = '\u03A6'; - const mo = svgdoc.createElementNS(NS.MATH, 'mo'); - mo.textContent = '\u222A'; - const mi2 = svgdoc.createElementNS(NS.MATH, 'mi'); - mi2.textContent = '\u2133'; - m.append(mi, mo, mi2); - newFO.append(m); - return { - started: true - }; - }, - mouseUp (opts) { - // const e = opts.event; - if (svgCanvas.getMode() !== 'foreign' || !started) { - return undefined; - } - const attrs = $(newFO).attr(['width', 'height']); - const keep = (attrs.width !== '0' || attrs.height !== '0'); - svgCanvas.addToSelection([newFO], true); - - return { - keep, - element: newFO - }; - }, - selectedChanged (opts) { - // Use this to update the current selected elements - selElems = opts.elems; - - let i = selElems.length; - while (i--) { - const elem = selElems[i]; - if (elem && elem.tagName === 'foreignObject') { - if (opts.selectedElement && !opts.multiselected) { - $('#foreign_font_size').val(elem.getAttribute('font-size')); - $('#foreign_width').val(elem.getAttribute('width')); - $('#foreign_height').val(elem.getAttribute('height')); - showPanel(true); - } else { - showPanel(false); - } - } else { - showPanel(false); - } - } - }, - elementChanged (opts) { - // const elem = opts.elems[0]; - } - }; + }, _callee2); + }))(); } }; + +export default extForeignobject; +//# sourceMappingURL=ext-foreignobject.js.map diff --git a/dist/editor/extensions/ext-foreignobject.js.map b/dist/editor/extensions/ext-foreignobject.js.map new file mode 100644 index 00000000..4e5414c9 --- /dev/null +++ b/dist/editor/extensions/ext-foreignobject.js.map @@ -0,0 +1 @@ +{"version":3,"file":"ext-foreignobject.js","sources":["../../../src/editor/extensions/ext-foreignobject.js"],"sourcesContent":["/**\n * @file ext-foreignobject.js\n *\n * @license Apache-2.0\n *\n * @copyright 2010 Jacques Distler, 2010 Alexis Deveria\n *\n */\n\nexport default {\n name: 'foreignobject',\n async init (S) {\n const svgEditor = this;\n const {$, text2xml, NS, importLocale} = S;\n const svgCanvas = svgEditor.canvas;\n const\n // {svgcontent} = S,\n // addElem = svgCanvas.addSVGElementFromJson,\n svgdoc = S.svgroot.parentNode.ownerDocument;\n const strings = await importLocale();\n\n const properlySourceSizeTextArea = function () {\n // TODO: remove magic numbers here and get values from CSS\n const height = $('#svg_source_container').height() - 80;\n $('#svg_source_textarea').css('height', height);\n };\n\n /**\n * @param {boolean} on\n * @returns {void}\n */\n function showPanel (on) {\n let fcRules = $('#fc_rules');\n if (!fcRules.length) {\n fcRules = $('').appendTo('head');\n }\n fcRules.text(!on ? '' : ' #tool_topath { display: none !important; }');\n $('#foreignObject_panel').toggle(on);\n }\n\n /**\n * @param {boolean} on\n * @returns {void}\n */\n function toggleSourceButtons (on) {\n $('#tool_source_save, #tool_source_cancel').toggle(!on);\n $('#foreign_save, #foreign_cancel').toggle(on);\n }\n\n let selElems,\n started,\n newFO,\n editingforeign = false;\n\n /**\n * This function sets the content of element elt to the input XML.\n * @param {string} xmlString - The XML text\n * @returns {boolean} This function returns false if the set was unsuccessful, true otherwise.\n */\n function setForeignString (xmlString) {\n const elt = selElems[0]; // The parent `Element` to append to\n try {\n // convert string into XML document\n const newDoc = text2xml('' + xmlString + '');\n // run it through our sanitizer to remove anything we do not support\n svgCanvas.sanitizeSvg(newDoc.documentElement);\n elt.replaceWith(svgdoc.importNode(newDoc.documentElement.firstChild, true));\n svgCanvas.call('changed', [elt]);\n svgCanvas.clearSelection();\n } catch (e) {\n // Todo: Surface error to user\n console.log(e); // eslint-disable-line no-console\n return false;\n }\n\n return true;\n }\n\n /**\n *\n * @returns {void}\n */\n function showForeignEditor () {\n const elt = selElems[0];\n if (!elt || editingforeign) { return; }\n editingforeign = true;\n toggleSourceButtons(true);\n elt.removeAttribute('fill');\n\n const str = svgCanvas.svgToString(elt, 0);\n $('#svg_source_textarea').val(str);\n $('#svg_source_editor').fadeIn();\n properlySourceSizeTextArea();\n $('#svg_source_textarea').focus();\n }\n\n /**\n * @param {string} attr\n * @param {string|Float} val\n * @returns {void}\n */\n function setAttr (attr, val) {\n svgCanvas.changeSelectedAttribute(attr, val);\n svgCanvas.call('changed', selElems);\n }\n\n const buttons = [{\n id: 'tool_foreign',\n icon: svgEditor.curConfig.extIconsPath + 'foreignobject-tool.png',\n type: 'mode',\n events: {\n click () {\n svgCanvas.setMode('foreign');\n }\n }\n }, {\n id: 'edit_foreign',\n icon: svgEditor.curConfig.extIconsPath + 'foreignobject-edit.png',\n type: 'context',\n panel: 'foreignObject_panel',\n events: {\n click () {\n showForeignEditor();\n }\n }\n }];\n\n const contextTools = [\n {\n type: 'input',\n panel: 'foreignObject_panel',\n id: 'foreign_width',\n size: 3,\n events: {\n change () {\n setAttr('width', this.value);\n }\n }\n }, {\n type: 'input',\n panel: 'foreignObject_panel',\n id: 'foreign_height',\n events: {\n change () {\n setAttr('height', this.value);\n }\n }\n }, {\n type: 'input',\n panel: 'foreignObject_panel',\n id: 'foreign_font_size',\n size: 2,\n defval: 16,\n events: {\n change () {\n setAttr('font-size', this.value);\n }\n }\n }\n ];\n\n return {\n name: strings.name,\n svgicons: svgEditor.curConfig.extIconsPath + 'foreignobject-icons.xml',\n buttons: strings.buttons.map((button, i) => {\n return Object.assign(buttons[i], button);\n }),\n context_tools: strings.contextTools.map((contextTool, i) => {\n return Object.assign(contextTools[i], contextTool);\n }),\n callback () {\n $('#foreignObject_panel').hide();\n\n const endChanges = function () {\n $('#svg_source_editor').hide();\n editingforeign = false;\n $('#svg_source_textarea').blur();\n toggleSourceButtons(false);\n };\n\n // TODO: Needs to be done after orig icon loads\n setTimeout(function () {\n // Create source save/cancel buttons\n /* const save = */ $('#tool_source_save').clone()\n .hide().attr('id', 'foreign_save').unbind()\n .appendTo('#tool_source_back').click(async function () {\n if (!editingforeign) { return; }\n\n if (!setForeignString($('#svg_source_textarea').val())) {\n const ok = await $.confirm('Errors found. Revert to original?');\n if (!ok) { return; }\n endChanges();\n } else {\n endChanges();\n }\n // setSelectMode();\n });\n\n /* const cancel = */ $('#tool_source_cancel').clone()\n .hide().attr('id', 'foreign_cancel').unbind()\n .appendTo('#tool_source_back').click(function () {\n endChanges();\n });\n }, 3000);\n },\n mouseDown (opts) {\n // const e = opts.event;\n if (svgCanvas.getMode() !== 'foreign') {\n return undefined;\n }\n started = true;\n newFO = svgCanvas.addSVGElementFromJson({\n element: 'foreignObject',\n attr: {\n x: opts.start_x,\n y: opts.start_y,\n id: svgCanvas.getNextId(),\n 'font-size': 16, // cur_text.font_size,\n width: '48',\n height: '20',\n style: 'pointer-events:inherit'\n }\n });\n const m = svgdoc.createElementNS(NS.MATH, 'math');\n m.setAttributeNS(NS.XMLNS, 'xmlns', NS.MATH);\n m.setAttribute('display', 'inline');\n const mi = svgdoc.createElementNS(NS.MATH, 'mi');\n mi.setAttribute('mathvariant', 'normal');\n mi.textContent = '\\u03A6';\n const mo = svgdoc.createElementNS(NS.MATH, 'mo');\n mo.textContent = '\\u222A';\n const mi2 = svgdoc.createElementNS(NS.MATH, 'mi');\n mi2.textContent = '\\u2133';\n m.append(mi, mo, mi2);\n newFO.append(m);\n return {\n started: true\n };\n },\n mouseUp (opts) {\n // const e = opts.event;\n if (svgCanvas.getMode() !== 'foreign' || !started) {\n return undefined;\n }\n const attrs = $(newFO).attr(['width', 'height']);\n const keep = (attrs.width !== '0' || attrs.height !== '0');\n svgCanvas.addToSelection([newFO], true);\n\n return {\n keep,\n element: newFO\n };\n },\n selectedChanged (opts) {\n // Use this to update the current selected elements\n selElems = opts.elems;\n\n let i = selElems.length;\n while (i--) {\n const elem = selElems[i];\n if (elem && elem.tagName === 'foreignObject') {\n if (opts.selectedElement && !opts.multiselected) {\n $('#foreign_font_size').val(elem.getAttribute('font-size'));\n $('#foreign_width').val(elem.getAttribute('width'));\n $('#foreign_height').val(elem.getAttribute('height'));\n showPanel(true);\n } else {\n showPanel(false);\n }\n } else {\n showPanel(false);\n }\n }\n },\n elementChanged (opts) {\n // const elem = opts.elems[0];\n }\n };\n }\n};\n"],"names":["name","init","S","showPanel","toggleSourceButtons","setForeignString","showForeignEditor","setAttr","attr","val","svgCanvas","changeSelectedAttribute","call","selElems","elt","editingforeign","removeAttribute","str","svgToString","$","fadeIn","properlySourceSizeTextArea","focus","xmlString","newDoc","text2xml","NS","SVG","XLINK","sanitizeSvg","documentElement","replaceWith","svgdoc","importNode","firstChild","clearSelection","e","console","log","on","toggle","fcRules","length","appendTo","text","svgEditor","importLocale","canvas","svgroot","parentNode","ownerDocument","strings","height","css","buttons","id","icon","curConfig","extIconsPath","type","events","click","setMode","panel","contextTools","size","change","value","defval","svgicons","map","button","i","Object","assign","context_tools","contextTool","callback","hide","endChanges","blur","setTimeout","clone","unbind","confirm","ok","mouseDown","opts","getMode","undefined","started","newFO","addSVGElementFromJson","element","x","start_x","y","start_y","getNextId","width","style","m","createElementNS","MATH","setAttributeNS","XMLNS","setAttribute","mi","textContent","mo","mi2","append","mouseUp","attrs","keep","addToSelection","selectedChanged","elems","elem","tagName","selectedElement","multiselected","getAttribute","elementChanged"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file diff --git a/dist/editor/extensions/ext-grid.js b/dist/editor/extensions/ext-grid.js index cba3eb91..fc00dc0b 100644 --- a/dist/editor/extensions/ext-grid.js +++ b/dist/editor/extensions/ext-grid.js @@ -1,3 +1,1651 @@ +function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); +} + +var REACT_ELEMENT_TYPE; + +function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; +} + +function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); +} + +function _AwaitValue(value) { + this.wrapped = value; +} + +function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } +} + +if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; +} + +_AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); +}; + +_AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); +}; + +_AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); +}; + +function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; +} + +function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); +} + +function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; +} + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} + +function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; +} + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} + +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} + +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} + +function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; +} + +function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); +} + +function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); +} + +function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; +} + +function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); +} + +function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); +} + +function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } +} + +function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); +} + +function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; +} + +function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); +} + +function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} + +function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; +} + +function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; +} + +function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } +} + +function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); +} + +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; +} + +function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); +} + +function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; +} + +function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; +} + +function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); +} + +function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); +} + +function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; +} + +function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); +} + +function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; +} + +function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); +} + +function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); +} + +function _temporalUndefined() {} + +function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); +} + +function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; +} + +function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); +} + +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} + +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); +} + +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); +} + +function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; +} + +function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; +} + +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} + +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; +} + +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; +} + +function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); +} + +function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; +} + +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); +} + +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); +} + +function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); +} + +function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); +} + +function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; +} + +var id = 0; + +function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; +} + +function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; +} + +function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } +} + +function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; +} + +function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); +} + +function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); +} + +function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; +} + +function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; +} + +function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } +} + +function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; +} + +function _hasDecorators(element) { + return element.decorators && element.decorators.length; +} + +function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); +} + +function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; +} + +function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; +} + +function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); +} + +function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); +} + /** * @file ext-grid.js * @@ -6,163 +1654,177 @@ * @copyright 2010 Redou Mine, 2010 Alexis Deveria * */ - -export default { +var extGrid = { name: 'grid', - async init ({$, NS, getTypeMap, importLocale}) { - const strings = await importLocale(); - const svgEditor = this; - const svgCanvas = svgEditor.canvas; - const svgdoc = document.getElementById('svgcanvas').ownerDocument, - {assignAttributes} = svgCanvas, - hcanvas = document.createElement('canvas'), - canvBG = $('#canvasBackground'), - units = getTypeMap(), // Assumes prior `init()` call on `units.js` module - intervals = [0.01, 0.1, 1, 10, 100, 1000]; - let showGrid = svgEditor.curConfig.showGrid || false; + init: function init(_ref) { + var _this = this; - $(hcanvas).hide().appendTo('body'); + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var $, NS, getTypeMap, importLocale, strings, svgEditor, svgCanvas, svgdoc, assignAttributes, hcanvas, canvBG, units, intervals, showGrid, canvasGrid, gridDefs, gridPattern, gridimg, gridBox, updateGrid, gridUpdate, buttons; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + gridUpdate = function _gridUpdate() { + if (showGrid) { + updateGrid(svgCanvas.getZoom()); + } - const canvasGrid = svgdoc.createElementNS(NS.SVG, 'svg'); - assignAttributes(canvasGrid, { - id: 'canvasGrid', - width: '100%', - height: '100%', - x: 0, - y: 0, - overflow: 'visible', - display: 'none' - }); - canvBG.append(canvasGrid); - const gridDefs = svgdoc.createElementNS(NS.SVG, 'defs'); - // grid-pattern - const gridPattern = svgdoc.createElementNS(NS.SVG, 'pattern'); - assignAttributes(gridPattern, { - id: 'gridpattern', - patternUnits: 'userSpaceOnUse', - x: 0, // -(value.strokeWidth / 2), // position for strokewidth - y: 0, // -(value.strokeWidth / 2), // position for strokewidth - width: 100, - height: 100 - }); + $('#canvasGrid').toggle(showGrid); + $('#view_grid').toggleClass('push_button_pressed tool_button'); + }; - const gridimg = svgdoc.createElementNS(NS.SVG, 'image'); - assignAttributes(gridimg, { - x: 0, - y: 0, - width: 100, - height: 100 - }); - gridPattern.append(gridimg); - gridDefs.append(gridPattern); - $('#canvasGrid').append(gridDefs); + updateGrid = function _updateGrid(zoom) { + // TODO: Try this with elements, then compare performance difference + var unit = units[svgEditor.curConfig.baseUnit]; // 1 = 1px - // grid-box - const gridBox = svgdoc.createElementNS(NS.SVG, 'rect'); - assignAttributes(gridBox, { - width: '100%', - height: '100%', - x: 0, - y: 0, - 'stroke-width': 0, - stroke: 'none', - fill: 'url(#gridpattern)', - style: 'pointer-events: none; display:visible;' - }); - $('#canvasGrid').append(gridBox); + var uMulti = unit * zoom; // Calculate the main number interval - /** - * - * @param {Float} zoom - * @returns {void} - */ - function updateGrid (zoom) { - // TODO: Try this with elements, then compare performance difference - const unit = units[svgEditor.curConfig.baseUnit]; // 1 = 1px - const uMulti = unit * zoom; - // Calculate the main number interval - const rawM = 100 / uMulti; - let multi = 1; - intervals.some((num) => { - multi = num; - return rawM <= num; - }); - const bigInt = multi * uMulti; + var rawM = 100 / uMulti; + var multi = 1; + intervals.some(function (num) { + multi = num; + return rawM <= num; + }); + var bigInt = multi * uMulti; // Set the canvas size to the width of the container - // Set the canvas size to the width of the container - hcanvas.width = bigInt; - hcanvas.height = bigInt; - const ctx = hcanvas.getContext('2d'); - const curD = 0.5; - const part = bigInt / 10; + hcanvas.width = bigInt; + hcanvas.height = bigInt; + var ctx = hcanvas.getContext('2d'); + var curD = 0.5; + var part = bigInt / 10; + ctx.globalAlpha = 0.2; + ctx.strokeStyle = svgEditor.curConfig.gridColor; - ctx.globalAlpha = 0.2; - ctx.strokeStyle = svgEditor.curConfig.gridColor; - for (let i = 1; i < 10; i++) { - const subD = Math.round(part * i) + 0.5; - // const lineNum = (i % 2)?12:10; - const lineNum = 0; - ctx.moveTo(subD, bigInt); - ctx.lineTo(subD, lineNum); - ctx.moveTo(bigInt, subD); - ctx.lineTo(lineNum, subD); - } - ctx.stroke(); - ctx.beginPath(); - ctx.globalAlpha = 0.5; - ctx.moveTo(curD, bigInt); - ctx.lineTo(curD, 0); + for (var i = 1; i < 10; i++) { + var subD = Math.round(part * i) + 0.5; // const lineNum = (i % 2)?12:10; - ctx.moveTo(bigInt, curD); - ctx.lineTo(0, curD); - ctx.stroke(); + var lineNum = 0; + ctx.moveTo(subD, bigInt); + ctx.lineTo(subD, lineNum); + ctx.moveTo(bigInt, subD); + ctx.lineTo(lineNum, subD); + } - const datauri = hcanvas.toDataURL('image/png'); - gridimg.setAttribute('width', bigInt); - gridimg.setAttribute('height', bigInt); - gridimg.parentNode.setAttribute('width', bigInt); - gridimg.parentNode.setAttribute('height', bigInt); - svgCanvas.setHref(gridimg, datauri); - } + ctx.stroke(); + ctx.beginPath(); + ctx.globalAlpha = 0.5; + ctx.moveTo(curD, bigInt); + ctx.lineTo(curD, 0); + ctx.moveTo(bigInt, curD); + ctx.lineTo(0, curD); + ctx.stroke(); + var datauri = hcanvas.toDataURL('image/png'); + gridimg.setAttribute('width', bigInt); + gridimg.setAttribute('height', bigInt); + gridimg.parentNode.setAttribute('width', bigInt); + gridimg.parentNode.setAttribute('height', bigInt); + svgCanvas.setHref(gridimg, datauri); + }; - /** - * - * @returns {void} - */ - function gridUpdate () { - if (showGrid) { - updateGrid(svgCanvas.getZoom()); - } - $('#canvasGrid').toggle(showGrid); - $('#view_grid').toggleClass('push_button_pressed tool_button'); - } - const buttons = [{ - id: 'view_grid', - icon: svgEditor.curConfig.extIconsPath + 'grid.png', - type: 'context', - panel: 'editor_panel', - events: { - click () { - svgEditor.curConfig.showGrid = showGrid = !showGrid; - gridUpdate(); + $ = _ref.$, NS = _ref.NS, getTypeMap = _ref.getTypeMap, importLocale = _ref.importLocale; + _context.next = 5; + return importLocale(); + + case 5: + strings = _context.sent; + svgEditor = _this; + svgCanvas = svgEditor.canvas; + svgdoc = document.getElementById('svgcanvas').ownerDocument, assignAttributes = svgCanvas.assignAttributes, hcanvas = document.createElement('canvas'), canvBG = $('#canvasBackground'), units = getTypeMap(), intervals = [0.01, 0.1, 1, 10, 100, 1000]; + showGrid = svgEditor.curConfig.showGrid || false; + $(hcanvas).hide().appendTo('body'); + canvasGrid = svgdoc.createElementNS(NS.SVG, 'svg'); + assignAttributes(canvasGrid, { + id: 'canvasGrid', + width: '100%', + height: '100%', + x: 0, + y: 0, + overflow: 'visible', + display: 'none' + }); + canvBG.append(canvasGrid); + gridDefs = svgdoc.createElementNS(NS.SVG, 'defs'); // grid-pattern + + gridPattern = svgdoc.createElementNS(NS.SVG, 'pattern'); + assignAttributes(gridPattern, { + id: 'gridpattern', + patternUnits: 'userSpaceOnUse', + x: 0, + // -(value.strokeWidth / 2), // position for strokewidth + y: 0, + // -(value.strokeWidth / 2), // position for strokewidth + width: 100, + height: 100 + }); + gridimg = svgdoc.createElementNS(NS.SVG, 'image'); + assignAttributes(gridimg, { + x: 0, + y: 0, + width: 100, + height: 100 + }); + gridPattern.append(gridimg); + gridDefs.append(gridPattern); + $('#canvasGrid').append(gridDefs); // grid-box + + gridBox = svgdoc.createElementNS(NS.SVG, 'rect'); + assignAttributes(gridBox, { + width: '100%', + height: '100%', + x: 0, + y: 0, + 'stroke-width': 0, + stroke: 'none', + fill: 'url(#gridpattern)', + style: 'pointer-events: none; display:visible;' + }); + $('#canvasGrid').append(gridBox); + /** + * + * @param {Float} zoom + * @returns {void} + */ + + buttons = [{ + id: 'view_grid', + icon: svgEditor.curConfig.extIconsPath + 'grid.png', + type: 'context', + panel: 'editor_panel', + events: { + click: function click() { + svgEditor.curConfig.showGrid = showGrid = !showGrid; + gridUpdate(); + } + } + }]; + return _context.abrupt("return", { + name: strings.name, + svgicons: svgEditor.curConfig.extIconsPath + 'grid-icon.xml', + zoomChanged: function zoomChanged(zoom) { + if (showGrid) { + updateGrid(zoom); + } + }, + callback: function callback() { + if (showGrid) { + gridUpdate(); + } + }, + buttons: strings.buttons.map(function (button, i) { + return Object.assign(buttons[i], button); + }) + }); + + case 27: + case "end": + return _context.stop(); + } } - } - }]; - return { - name: strings.name, - svgicons: svgEditor.curConfig.extIconsPath + 'grid-icon.xml', - - zoomChanged (zoom) { - if (showGrid) { updateGrid(zoom); } - }, - callback () { - if (showGrid) { - gridUpdate(); - } - }, - buttons: strings.buttons.map((button, i) => { - return Object.assign(buttons[i], button); - }) - }; + }, _callee); + }))(); } }; + +export default extGrid; +//# sourceMappingURL=ext-grid.js.map diff --git a/dist/editor/extensions/ext-grid.js.map b/dist/editor/extensions/ext-grid.js.map new file mode 100644 index 00000000..06cb7ad5 --- /dev/null +++ b/dist/editor/extensions/ext-grid.js.map @@ -0,0 +1 @@ +{"version":3,"file":"ext-grid.js","sources":["../../../src/editor/extensions/ext-grid.js"],"sourcesContent":["/**\n * @file ext-grid.js\n *\n * @license Apache-2.0\n *\n * @copyright 2010 Redou Mine, 2010 Alexis Deveria\n *\n */\n\nexport default {\n name: 'grid',\n async init ({$, NS, getTypeMap, importLocale}) {\n const strings = await importLocale();\n const svgEditor = this;\n const svgCanvas = svgEditor.canvas;\n const svgdoc = document.getElementById('svgcanvas').ownerDocument,\n {assignAttributes} = svgCanvas,\n hcanvas = document.createElement('canvas'),\n canvBG = $('#canvasBackground'),\n units = getTypeMap(), // Assumes prior `init()` call on `units.js` module\n intervals = [0.01, 0.1, 1, 10, 100, 1000];\n let showGrid = svgEditor.curConfig.showGrid || false;\n\n $(hcanvas).hide().appendTo('body');\n\n const canvasGrid = svgdoc.createElementNS(NS.SVG, 'svg');\n assignAttributes(canvasGrid, {\n id: 'canvasGrid',\n width: '100%',\n height: '100%',\n x: 0,\n y: 0,\n overflow: 'visible',\n display: 'none'\n });\n canvBG.append(canvasGrid);\n const gridDefs = svgdoc.createElementNS(NS.SVG, 'defs');\n // grid-pattern\n const gridPattern = svgdoc.createElementNS(NS.SVG, 'pattern');\n assignAttributes(gridPattern, {\n id: 'gridpattern',\n patternUnits: 'userSpaceOnUse',\n x: 0, // -(value.strokeWidth / 2), // position for strokewidth\n y: 0, // -(value.strokeWidth / 2), // position for strokewidth\n width: 100,\n height: 100\n });\n\n const gridimg = svgdoc.createElementNS(NS.SVG, 'image');\n assignAttributes(gridimg, {\n x: 0,\n y: 0,\n width: 100,\n height: 100\n });\n gridPattern.append(gridimg);\n gridDefs.append(gridPattern);\n $('#canvasGrid').append(gridDefs);\n\n // grid-box\n const gridBox = svgdoc.createElementNS(NS.SVG, 'rect');\n assignAttributes(gridBox, {\n width: '100%',\n height: '100%',\n x: 0,\n y: 0,\n 'stroke-width': 0,\n stroke: 'none',\n fill: 'url(#gridpattern)',\n style: 'pointer-events: none; display:visible;'\n });\n $('#canvasGrid').append(gridBox);\n\n /**\n *\n * @param {Float} zoom\n * @returns {void}\n */\n function updateGrid (zoom) {\n // TODO: Try this with elements, then compare performance difference\n const unit = units[svgEditor.curConfig.baseUnit]; // 1 = 1px\n const uMulti = unit * zoom;\n // Calculate the main number interval\n const rawM = 100 / uMulti;\n let multi = 1;\n intervals.some((num) => {\n multi = num;\n return rawM <= num;\n });\n const bigInt = multi * uMulti;\n\n // Set the canvas size to the width of the container\n hcanvas.width = bigInt;\n hcanvas.height = bigInt;\n const ctx = hcanvas.getContext('2d');\n const curD = 0.5;\n const part = bigInt / 10;\n\n ctx.globalAlpha = 0.2;\n ctx.strokeStyle = svgEditor.curConfig.gridColor;\n for (let i = 1; i < 10; i++) {\n const subD = Math.round(part * i) + 0.5;\n // const lineNum = (i % 2)?12:10;\n const lineNum = 0;\n ctx.moveTo(subD, bigInt);\n ctx.lineTo(subD, lineNum);\n ctx.moveTo(bigInt, subD);\n ctx.lineTo(lineNum, subD);\n }\n ctx.stroke();\n ctx.beginPath();\n ctx.globalAlpha = 0.5;\n ctx.moveTo(curD, bigInt);\n ctx.lineTo(curD, 0);\n\n ctx.moveTo(bigInt, curD);\n ctx.lineTo(0, curD);\n ctx.stroke();\n\n const datauri = hcanvas.toDataURL('image/png');\n gridimg.setAttribute('width', bigInt);\n gridimg.setAttribute('height', bigInt);\n gridimg.parentNode.setAttribute('width', bigInt);\n gridimg.parentNode.setAttribute('height', bigInt);\n svgCanvas.setHref(gridimg, datauri);\n }\n\n /**\n *\n * @returns {void}\n */\n function gridUpdate () {\n if (showGrid) {\n updateGrid(svgCanvas.getZoom());\n }\n $('#canvasGrid').toggle(showGrid);\n $('#view_grid').toggleClass('push_button_pressed tool_button');\n }\n const buttons = [{\n id: 'view_grid',\n icon: svgEditor.curConfig.extIconsPath + 'grid.png',\n type: 'context',\n panel: 'editor_panel',\n events: {\n click () {\n svgEditor.curConfig.showGrid = showGrid = !showGrid;\n gridUpdate();\n }\n }\n }];\n return {\n name: strings.name,\n svgicons: svgEditor.curConfig.extIconsPath + 'grid-icon.xml',\n\n zoomChanged (zoom) {\n if (showGrid) { updateGrid(zoom); }\n },\n callback () {\n if (showGrid) {\n gridUpdate();\n }\n },\n buttons: strings.buttons.map((button, i) => {\n return Object.assign(buttons[i], button);\n })\n };\n }\n};\n"],"names":["name","init","updateGrid","gridUpdate","showGrid","svgCanvas","getZoom","$","toggle","toggleClass","zoom","unit","units","svgEditor","curConfig","baseUnit","uMulti","rawM","multi","intervals","some","num","bigInt","hcanvas","width","height","ctx","getContext","curD","part","globalAlpha","strokeStyle","gridColor","i","subD","Math","round","lineNum","moveTo","lineTo","stroke","beginPath","datauri","toDataURL","gridimg","setAttribute","parentNode","setHref","NS","getTypeMap","importLocale","strings","canvas","svgdoc","document","getElementById","ownerDocument","assignAttributes","createElement","canvBG","hide","appendTo","canvasGrid","createElementNS","SVG","id","x","y","overflow","display","append","gridDefs","gridPattern","patternUnits","gridBox","fill","style","buttons","icon","extIconsPath","type","panel","events","click","svgicons","zoomChanged","callback","map","button","Object","assign"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file diff --git a/dist/editor/extensions/ext-helloworld.js b/dist/editor/extensions/ext-helloworld.js index fbe2dfa4..b9db0587 100644 --- a/dist/editor/extensions/ext-helloworld.js +++ b/dist/editor/extensions/ext-helloworld.js @@ -1,3 +1,1651 @@ +function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); +} + +var REACT_ELEMENT_TYPE; + +function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; +} + +function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); +} + +function _AwaitValue(value) { + this.wrapped = value; +} + +function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } +} + +if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; +} + +_AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); +}; + +_AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); +}; + +_AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); +}; + +function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; +} + +function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); +} + +function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; +} + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} + +function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; +} + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} + +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} + +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} + +function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; +} + +function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); +} + +function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); +} + +function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; +} + +function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); +} + +function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); +} + +function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } +} + +function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); +} + +function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; +} + +function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); +} + +function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} + +function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; +} + +function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; +} + +function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } +} + +function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); +} + +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; +} + +function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); +} + +function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; +} + +function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; +} + +function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); +} + +function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); +} + +function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; +} + +function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); +} + +function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; +} + +function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); +} + +function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); +} + +function _temporalUndefined() {} + +function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); +} + +function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; +} + +function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); +} + +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} + +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); +} + +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); +} + +function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; +} + +function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; +} + +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} + +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; +} + +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; +} + +function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); +} + +function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; +} + +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); +} + +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); +} + +function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); +} + +function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); +} + +function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; +} + +var id = 0; + +function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; +} + +function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; +} + +function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } +} + +function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; +} + +function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); +} + +function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); +} + +function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; +} + +function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; +} + +function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } +} + +function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; +} + +function _hasDecorators(element) { + return element.decorators && element.decorators.length; +} + +function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); +} + +function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; +} + +function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; +} + +function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); +} + +function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); +} + /** * @file ext-helloworld.js * @@ -12,80 +1660,98 @@ * the left ("mode") panel. Clicking on the button, and then the canvas * will show the user the point on the canvas that was clicked on. */ -export default { +var extHelloworld = { name: 'helloworld', - async init ({$, importLocale}) { - // See `/editor/extensions/ext-locale/helloworld/` - const strings = await importLocale(); - const svgEditor = this; - const svgCanvas = svgEditor.canvas; - return { - name: strings.name, - // For more notes on how to make an icon file, see the source of - // the helloworld-icon.xml - svgicons: svgEditor.curConfig.extIconsPath + 'helloworld-icon.xml', + init: function init(_ref) { + var _this = this; - // Multiple buttons can be added in this array - buttons: [{ - // Must match the icon ID in helloworld-icon.xml - id: 'hello_world', + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var $, importLocale, strings, svgEditor, svgCanvas; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + $ = _ref.$, importLocale = _ref.importLocale; + _context.next = 3; + return importLocale(); - // Fallback, e.g., for `file:///` access - icon: svgEditor.curConfig.extIconsPath + 'helloworld.png', + case 3: + strings = _context.sent; + svgEditor = _this; + svgCanvas = svgEditor.canvas; + return _context.abrupt("return", { + name: strings.name, + // For more notes on how to make an icon file, see the source of + // the helloworld-icon.xml + svgicons: svgEditor.curConfig.extIconsPath + 'helloworld-icon.xml', + // Multiple buttons can be added in this array + buttons: [{ + // Must match the icon ID in helloworld-icon.xml + id: 'hello_world', + // Fallback, e.g., for `file:///` access + icon: svgEditor.curConfig.extIconsPath + 'helloworld.png', + // This indicates that the button will be added to the "mode" + // button panel on the left side + type: 'mode', + // Tooltip text + title: strings.buttons[0].title, + // Events + events: { + click: function click() { + // The action taken when the button is clicked on. + // For "mode" buttons, any other button will + // automatically be de-pressed. + svgCanvas.setMode('hello_world'); + } + } + }], + // This is triggered when the main mouse button is pressed down + // on the editor canvas (not the tool panels) + mouseDown: function mouseDown() { + // Check the mode on mousedown + if (svgCanvas.getMode() === 'hello_world') { + // The returned object must include "started" with + // a value of true in order for mouseUp to be triggered + return { + started: true + }; + } - // This indicates that the button will be added to the "mode" - // button panel on the left side - type: 'mode', + return undefined; + }, + // This is triggered from anywhere, but "started" must have been set + // to true (see above). Note that "opts" is an object with event info + mouseUp: function mouseUp(opts) { + // Check the mode on mouseup + if (svgCanvas.getMode() === 'hello_world') { + var zoom = svgCanvas.getZoom(); // Get the actual coordinate by dividing by the zoom value - // Tooltip text - title: strings.buttons[0].title, + var x = opts.mouse_x / zoom; + var y = opts.mouse_y / zoom; // We do our own formatting - // Events - events: { - click () { - // The action taken when the button is clicked on. - // For "mode" buttons, any other button will - // automatically be de-pressed. - svgCanvas.setMode('hello_world'); + var text = strings.text; + [['x', x], ['y', y]].forEach(function (_ref2) { + var _ref3 = _slicedToArray(_ref2, 2), + prop = _ref3[0], + val = _ref3[1]; + + text = text.replace('{' + prop + '}', val); + }); // Show the text using the custom alert function + + $.alert(text); + } + } + }); + + case 7: + case "end": + return _context.stop(); } } - }], - // This is triggered when the main mouse button is pressed down - // on the editor canvas (not the tool panels) - mouseDown () { - // Check the mode on mousedown - if (svgCanvas.getMode() === 'hello_world') { - // The returned object must include "started" with - // a value of true in order for mouseUp to be triggered - return {started: true}; - } - return undefined; - }, - - // This is triggered from anywhere, but "started" must have been set - // to true (see above). Note that "opts" is an object with event info - mouseUp (opts) { - // Check the mode on mouseup - if (svgCanvas.getMode() === 'hello_world') { - const zoom = svgCanvas.getZoom(); - - // Get the actual coordinate by dividing by the zoom value - const x = opts.mouse_x / zoom; - const y = opts.mouse_y / zoom; - - // We do our own formatting - let {text} = strings; - [ - ['x', x], - ['y', y] - ].forEach(([prop, val]) => { - text = text.replace('{' + prop + '}', val); - }); - - // Show the text using the custom alert function - $.alert(text); - } - } - }; + }, _callee); + }))(); } }; + +export default extHelloworld; +//# sourceMappingURL=ext-helloworld.js.map diff --git a/dist/editor/extensions/ext-helloworld.js.map b/dist/editor/extensions/ext-helloworld.js.map new file mode 100644 index 00000000..4b7881b5 --- /dev/null +++ b/dist/editor/extensions/ext-helloworld.js.map @@ -0,0 +1 @@ +{"version":3,"file":"ext-helloworld.js","sources":["../../../src/editor/extensions/ext-helloworld.js"],"sourcesContent":["/**\n * @file ext-helloworld.js\n *\n * @license MIT\n *\n * @copyright 2010 Alexis Deveria\n *\n */\n\n/**\n* This is a very basic SVG-Edit extension. It adds a \"Hello World\" button in\n* the left (\"mode\") panel. Clicking on the button, and then the canvas\n* will show the user the point on the canvas that was clicked on.\n*/\nexport default {\n name: 'helloworld',\n async init ({$, importLocale}) {\n // See `/editor/extensions/ext-locale/helloworld/`\n const strings = await importLocale();\n const svgEditor = this;\n const svgCanvas = svgEditor.canvas;\n return {\n name: strings.name,\n // For more notes on how to make an icon file, see the source of\n // the helloworld-icon.xml\n svgicons: svgEditor.curConfig.extIconsPath + 'helloworld-icon.xml',\n\n // Multiple buttons can be added in this array\n buttons: [{\n // Must match the icon ID in helloworld-icon.xml\n id: 'hello_world',\n\n // Fallback, e.g., for `file:///` access\n icon: svgEditor.curConfig.extIconsPath + 'helloworld.png',\n\n // This indicates that the button will be added to the \"mode\"\n // button panel on the left side\n type: 'mode',\n\n // Tooltip text\n title: strings.buttons[0].title,\n\n // Events\n events: {\n click () {\n // The action taken when the button is clicked on.\n // For \"mode\" buttons, any other button will\n // automatically be de-pressed.\n svgCanvas.setMode('hello_world');\n }\n }\n }],\n // This is triggered when the main mouse button is pressed down\n // on the editor canvas (not the tool panels)\n mouseDown () {\n // Check the mode on mousedown\n if (svgCanvas.getMode() === 'hello_world') {\n // The returned object must include \"started\" with\n // a value of true in order for mouseUp to be triggered\n return {started: true};\n }\n return undefined;\n },\n\n // This is triggered from anywhere, but \"started\" must have been set\n // to true (see above). Note that \"opts\" is an object with event info\n mouseUp (opts) {\n // Check the mode on mouseup\n if (svgCanvas.getMode() === 'hello_world') {\n const zoom = svgCanvas.getZoom();\n\n // Get the actual coordinate by dividing by the zoom value\n const x = opts.mouse_x / zoom;\n const y = opts.mouse_y / zoom;\n\n // We do our own formatting\n let {text} = strings;\n [\n ['x', x],\n ['y', y]\n ].forEach(([prop, val]) => {\n text = text.replace('{' + prop + '}', val);\n });\n\n // Show the text using the custom alert function\n $.alert(text);\n }\n }\n };\n }\n};\n"],"names":["name","init","$","importLocale","strings","svgEditor","svgCanvas","canvas","svgicons","curConfig","extIconsPath","buttons","id","icon","type","title","events","click","setMode","mouseDown","getMode","started","undefined","mouseUp","opts","zoom","getZoom","x","mouse_x","y","mouse_y","text","forEach","prop","val","replace","alert"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;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"} \ No newline at end of file diff --git a/dist/editor/extensions/ext-imagelib.js b/dist/editor/extensions/ext-imagelib.js index 6ee0c2a7..1564ef28 100644 --- a/dist/editor/extensions/ext-imagelib.js +++ b/dist/editor/extensions/ext-imagelib.js @@ -1,3 +1,1651 @@ +function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); +} + +var REACT_ELEMENT_TYPE; + +function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; +} + +function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); +} + +function _AwaitValue(value) { + this.wrapped = value; +} + +function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } +} + +if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; +} + +_AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); +}; + +_AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); +}; + +_AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); +}; + +function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; +} + +function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); +} + +function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; +} + +function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } +} + +function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; +} + +function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } +} + +function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } +} + +function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; +} + +function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; +} + +function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; +} + +function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; +} + +function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); +} + +function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; +} + +function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; +} + +function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; +} + +function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); +} + +function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; +} + +function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); +} + +function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); +} + +function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } +} + +function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); +} + +function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; +} + +function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); +} + +function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } +} + +function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; +} + +function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; +} + +function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; +} + +function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } +} + +function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); +} + +function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; +} + +function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; +} + +function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; +} + +function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); +} + +function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; +} + +function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; +} + +function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); +} + +function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); +} + +function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; +} + +function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); +} + +function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; +} + +function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); +} + +function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); +} + +function _temporalUndefined() {} + +function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); +} + +function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; +} + +function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); +} + +function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); +} + +function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); +} + +function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); +} + +function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; +} + +function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); +} + +function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); +} + +function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; +} + +function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; +} + +function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); +} + +function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; +} + +function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); +} + +function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; +} + +function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); +} + +function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; +} + +function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); +} + +function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); +} + +function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); +} + +function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); +} + +function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; +} + +var id = 0; + +function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; +} + +function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; +} + +function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } +} + +function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; +} + +function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; +} + +function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; +} + +function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); +} + +function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); +} + +function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; +} + +function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; +} + +function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } +} + +function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; +} + +function _hasDecorators(element) { + return element.decorators && element.decorators.length; +} + +function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); +} + +function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; +} + +function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; +} + +function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); +} + +function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); +} + /** * @file ext-imagelib.js * @@ -6,552 +1654,523 @@ * @copyright 2010 Alexis Deveria * */ -export default { +var extImagelib = { name: 'imagelib', - async init ({$, decode64, importLocale, dropXMLInternalSubset}) { - const imagelibStrings = await importLocale(); + init: function init(_ref) { + var _this = this; - const modularVersion = !('svgEditor' in window) || - !window.svgEditor || - window.svgEditor.modules !== false; + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() { + var $, decode64, importLocale, dropXMLInternalSubset, imagelibStrings, modularVersion, svgEditor, uiStrings, svgCanvas, extIconsPath, allowedImageLibOrigins, closeBrowser, importImage, pending, mode, multiArr, transferStopped, preview, submit, onMessage, _onMessage, toggleMulti, showBrowser, buttons; - const svgEditor = this; + return regeneratorRuntime.wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + showBrowser = function _showBrowser() { + var browser = $('#imgbrowse'); - const {uiStrings, canvas: svgCanvas, curConfig: {extIconsPath}} = svgEditor; + if (!browser.length) { + $('
' + '
').insertAfter('#svg_docprops'); + browser = $('#imgbrowse'); + var allLibs = imagelibStrings.select_lib; + var libOpts = $('
    ').appendTo(browser); + var frame = $(' + + + diff --git a/dist/editor/system/embedapi.html b/dist/editor/system/embedapi.html new file mode 100644 index 00000000..dda45a19 --- /dev/null +++ b/dist/editor/system/embedapi.html @@ -0,0 +1,17 @@ + + + + + Embed API + + + + + + + + + +
    + + diff --git a/dist/editor/system/embedapi.js b/dist/editor/system/embedapi.js new file mode 100644 index 00000000..dd6459c4 --- /dev/null +++ b/dist/editor/system/embedapi.js @@ -0,0 +1,395 @@ +/** +* Handles underlying communication between the embedding window and the +* editor frame. +* @module EmbeddedSVGEdit +*/ + +let cbid = 0; + +/** +* @callback module:EmbeddedSVGEdit.CallbackSetter +* @param {GenericCallback} newCallback Callback to be stored (signature dependent on function) +* @returns {void} +*/ +/** +* @callback module:EmbeddedSVGEdit.CallbackSetGetter +* @param {...any} args Signature dependent on the function +* @returns {module:EmbeddedSVGEdit.CallbackSetter} +*/ + +/** +* @param {string} funcName +* @returns {module:EmbeddedSVGEdit.CallbackSetGetter} +*/ +function getCallbackSetter (funcName) { + return function (...args) { + const that = this, // New callback + callbackID = this.send(funcName, args, function () { /* */ }); // The callback (currently it's nothing, but will be set later) + + return function (newCallback) { + that.callbacks[callbackID] = newCallback; // Set callback + }; + }; +} + +/** +* Having this separate from messageListener allows us to +* avoid using JSON parsing (and its limitations) in the case +* of same domain control. +* @param {module:EmbeddedSVGEdit.EmbeddedSVGEdit} t The `this` value +* @param {PlainObject} data +* @param {JSON} data.result +* @param {string} data.error +* @param {Integer} data.id +* @returns {void} +*/ +function addCallback (t, {result, error, id: callbackID}) { + if (typeof callbackID === 'number' && t.callbacks[callbackID]) { + // These should be safe both because we check `cbid` is numeric and + // because the calls are from trusted origins + if (result) { + t.callbacks[callbackID](result); // lgtm [js/unvalidated-dynamic-method-call] + } else { + t.callbacks[callbackID](error, 'error'); // lgtm [js/unvalidated-dynamic-method-call] + } + } +} + +/** +* @param {Event} e +* @returns {void} +*/ +function messageListener (e) { + // We accept and post strings as opposed to objects for the sake of IE9 support; this + // will most likely be changed in the future + if (!e.data || !['string', 'object'].includes(typeof e.data)) { + return; + } + const {allowedOrigins} = this, + data = typeof e.data === 'object' ? e.data : JSON.parse(e.data); + if (!data || typeof data !== 'object' || data.namespace !== 'svg-edit' || + e.source !== this.frame.contentWindow || + (!allowedOrigins.includes('*') && !allowedOrigins.includes(e.origin)) + ) { + // eslint-disable-next-line no-console -- Info for developers + console.error( + `The origin ${e.origin} was not whitelisted as an origin from ` + + `which responses may be received by this ${window.origin} script.` + ); + return; + } + addCallback(this, data); +} + +/** +* @callback module:EmbeddedSVGEdit.MessageListener +* @param {MessageEvent} e +* @returns {void} +*/ +/** +* @param {module:EmbeddedSVGEdit.EmbeddedSVGEdit} t The `this` value +* @returns {module:EmbeddedSVGEdit.MessageListener} Event listener +*/ +function getMessageListener (t) { + return function (e) { + messageListener.call(t, e); + }; +} + +/** +* Embedded SVG-edit API. +* General usage: +* - Have an iframe somewhere pointing to a version of svg-edit > r1000. +* @example +// Initialize the magic with: +const svgCanvas = new EmbeddedSVGEdit(window.frames.svgedit); + +// Pass functions in this format: +svgCanvas.setSvgString('string'); + +// Or if a callback is needed: +svgCanvas.setSvgString('string')(function (data, error) { + if (error) { + // There was an error + } else { + // Handle data + } +}); + +// Everything is done with the same API as the real svg-edit, +// and all documentation is unchanged. + +// However, this file depends on the postMessage API which +// can only support JSON-serializable arguments and +// return values, so, for example, arguments whose value is +// 'undefined', a function, a non-finite number, or a built-in +// object like Date(), RegExp(), etc. will most likely not behave +// as expected. In such a case one may need to host +// the SVG editor on the same domain and reference the +// JavaScript methods on the frame itself. + +// The only other difference is when handling returns: +// the callback notation is used instead. +const blah = new EmbeddedSVGEdit(window.frames.svgedit); +blah.clearSelection('woot', 'blah', 1337, [1, 2, 3, 4, 5, 'moo'], -42, { + a: 'tree', b: 6, c: 9 +})(function () { console.log('GET DATA', args); }); +* +* @memberof module:EmbeddedSVGEdit +*/ +class EmbeddedSVGEdit { + /** + * @param {HTMLIFrameElement} frame + * @param {string[]} [allowedOrigins=[]] Array of origins from which incoming + * messages will be allowed when same origin is not used; defaults to none. + * If supplied, it should probably be the same as svgEditor's allowedOrigins + */ + constructor (frame, allowedOrigins) { + const that = this; + this.allowedOrigins = allowedOrigins || []; + // Initialize communication + this.frame = frame; + this.callbacks = {}; + // List of functions extracted with this: + // Run in firebug on http://svg-edit.googlecode.com/svn/trunk/docs/files/svgcanvas-js.html + + // for (const i=0,q=[],f = document.querySelectorAll('div.CFunction h3.CTitle a'); i < f.length; i++) { q.push(f[i].name); }; q + // const functions = ['clearSelection', 'addToSelection', 'removeFromSelection', 'open', 'save', 'getSvgString', 'setSvgString', + // 'createLayer', 'deleteCurrentLayer', 'setCurrentLayer', 'renameCurrentLayer', 'setCurrentLayerPosition', 'setLayerVisibility', + // 'moveSelectedToLayer', 'clear']; + + // Newer, well, it extracts things that aren't documented as well. All functions accessible through the normal thingy can now be accessed though the API + // const {svgCanvas} = frame.contentWindow; + // const l = []; + // for (const i in svgCanvas) { if (typeof svgCanvas[i] === 'function') { l.push(i);} }; + // alert("['" + l.join("', '") + "']"); + // Run in svgedit itself + const functions = [ + 'addExtension', + 'addSVGElementFromJson', + 'addToSelection', + 'alignSelectedElements', + 'assignAttributes', + 'bind', + 'call', + 'changeSelectedAttribute', + 'cleanupElement', + 'clear', + 'clearSelection', + 'clearSvgContentElement', + 'cloneLayer', + 'cloneSelectedElements', + 'convertGradients', + 'convertToGroup', + 'convertToNum', + 'convertToPath', + 'copySelectedElements', + 'createLayer', + 'cutSelectedElements', + 'cycleElement', + 'deleteCurrentLayer', + 'deleteSelectedElements', + 'embedImage', + 'exportPDF', + 'findDefs', + 'getBBox', + 'getBlur', + 'getBold', + 'getColor', + 'getContentElem', + 'getCurrentDrawing', + 'getDocumentTitle', + 'getEditorNS', + 'getElem', + 'getFillOpacity', + 'getFontColor', + 'getFontFamily', + 'getFontSize', + 'getHref', + 'getId', + 'getIntersectionList', + 'getItalic', + 'getMode', + 'getMouseTarget', + 'getNextId', + 'getOffset', + 'getOpacity', + 'getPaintOpacity', + 'getPrivateMethods', + 'getRefElem', + 'getResolution', + 'getRootElem', + 'getRotationAngle', + 'getSelectedElems', + 'getStrokeOpacity', + 'getStrokeWidth', + 'getStrokedBBox', + 'getStyle', + 'getSvgString', + 'getText', + 'getTitle', + 'getTransformList', + 'getUIStrings', + 'getUrlFromAttr', + 'getVersion', + 'getVisibleElements', + 'getVisibleElementsAndBBoxes', + 'getZoom', + 'groupSelectedElements', + 'groupSvgElem', + 'hasMatrixTransform', + 'identifyLayers', + 'importSvgString', + 'leaveContext', + 'linkControlPoints', + 'makeHyperlink', + 'matrixMultiply', + 'mergeAllLayers', + 'mergeLayer', + 'moveSelectedElements', + 'moveSelectedToLayer', + 'moveToBottomSelectedElement', + 'moveToTopSelectedElement', + 'moveUpDownSelected', + 'open', + 'pasteElements', + 'prepareSvg', + 'pushGroupProperties', + 'randomizeIds', + 'rasterExport', + 'ready', + 'recalculateAllSelectedDimensions', + 'recalculateDimensions', + 'remapElement', + 'removeFromSelection', + 'removeHyperlink', + 'removeUnusedDefElems', + 'renameCurrentLayer', + 'round', + 'runExtensions', + 'sanitizeSvg', + 'save', + 'selectAllInCurrentLayer', + 'selectOnly', + 'setBBoxZoom', + 'setBackground', + 'setBlur', + 'setBlurNoUndo', + 'setBlurOffsets', + 'setBold', + 'setColor', + 'setConfig', + 'setContext', + 'setCurrentLayer', + 'setCurrentLayerPosition', + 'setDocumentTitle', + 'setFillPaint', + 'setFontColor', + 'setFontFamily', + 'setFontSize', + 'setGoodImage', + 'setGradient', + 'setGroupTitle', + 'setHref', + 'setIdPrefix', + 'setImageURL', + 'setItalic', + 'setLayerVisibility', + 'setLinkURL', + 'setMode', + 'setOpacity', + 'setPaint', + 'setPaintOpacity', + 'setRectRadius', + 'setResolution', + 'setRotationAngle', + 'setSegType', + 'setStrokeAttr', + 'setStrokePaint', + 'setStrokeWidth', + 'setSvgString', + 'setTextContent', + 'setUiStrings', + 'setUseData', + 'setZoom', + 'svgCanvasToString', + 'svgToString', + 'transformListToTransform', + 'ungroupSelectedElement', + 'uniquifyElems', + 'updateCanvas', + 'zoomChanged' + ]; + + // TODO: rewrite the following, it's pretty scary. + for (const func of functions) { + this[func] = getCallbackSetter(func); + } + + // Older IE may need a polyfill for addEventListener, but so it would for SVG + window.addEventListener('message', getMessageListener(this)); + window.addEventListener('keydown', (e) => { + const {type, key} = e; + if (key === 'Backspace') { + e.preventDefault(); + const keyboardEvent = new KeyboardEvent(type, {key}); + that.frame.contentDocument.dispatchEvent(keyboardEvent); + } + }); + } + + /** + * @param {string} name + * @param {ArgumentsArray} args Signature dependent on function + * @param {GenericCallback} callback (This may be better than a promise in case adding an event.) + * @returns {Integer} + */ + send (name, args, callback) { // eslint-disable-line promise/prefer-await-to-callbacks + const that = this; + cbid++; + + this.callbacks[cbid] = callback; + setTimeout((function (callbackID) { + return function () { // Delay for the callback to be set in case its synchronous + /* + * Todo: Handle non-JSON arguments and return values (undefined, + * nonfinite numbers, functions, and built-in objects like Date, + * RegExp), etc.? Allow promises instead of callbacks? Review + * SVG-Edit functions for whether JSON-able parameters can be + * made compatile with all API functionality + */ + // We accept and post strings for the sake of IE9 support + let sameOriginWithGlobal = false; + try { + sameOriginWithGlobal = window.location.origin === that.frame.contentWindow.location.origin && + that.frame.contentWindow.svgEditor.canvas; + } catch (err) {} + + if (sameOriginWithGlobal) { + // Although we do not really need this API if we are working same + // domain, it could allow us to write in a way that would work + // cross-domain as well, assuming we stick to the argument limitations + // of the current JSON-based communication API (e.g., not passing + // callbacks). We might be able to address these shortcomings; see + // the todo elsewhere in this file. + const message = {id: callbackID}, + {svgEditor: {canvas: svgCanvas}} = that.frame.contentWindow; + try { + message.result = svgCanvas[name](...args); + } catch (err) { + message.error = err.message; + } + addCallback(that, message); + } else { // Requires the ext-xdomain-messaging.js extension + that.frame.contentWindow.postMessage(JSON.stringify({ + namespace: 'svgCanvas', id: callbackID, name, args + }), '*'); + } + }; + }(cbid)), 0); + + return cbid; + } +} + +export default EmbeddedSVGEdit; diff --git a/dist/editor/system/extensions/ext-arrows.js b/dist/editor/system/extensions/ext-arrows.js new file mode 100644 index 00000000..6fc1f8f2 --- /dev/null +++ b/dist/editor/system/extensions/ext-arrows.js @@ -0,0 +1,2012 @@ +System.register([], function (exports) { + 'use strict'; + return { + execute: function () { + + function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); + } + + var REACT_ELEMENT_TYPE; + + function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; + } + + function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); + } + + function _AwaitValue(value) { + this.wrapped = value; + } + + function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } + } + + if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; + } + + _AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); + }; + + _AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); + }; + + _AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); + }; + + function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; + } + + function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); + } + + function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; + } + + function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } + } + + function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; + } + + function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; + } + + function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; + } + + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; + } + + function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); + } + + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; + } + + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; + } + + function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); + } + + function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); + } + + function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); + } + + function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } + } + + function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); + } + + function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; + } + + function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); + } + + function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } + } + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; + } + + function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; + } + + function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } + } + + function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); + } + + function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; + } + + function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; + } + + function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); + } + + function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; + } + + function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; + } + + function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); + } + + function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); + } + + function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; + } + + function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); + } + + function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; + } + + function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); + } + + function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); + } + + function _temporalUndefined() {} + + function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); + } + + function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; + } + + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); + } + + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + + function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); + } + + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); + } + + function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; + } + + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; + } + + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; + } + + function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); + } + + function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; + } + + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); + } + + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); + } + + function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); + } + + function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); + } + + function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; + } + + var id = 0; + + function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; + } + + function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; + } + + function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } + } + + function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; + } + + function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); + } + + function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); + } + + function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; + } + + function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; + } + + function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } + } + + function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; + } + + function _hasDecorators(element) { + return element.decorators && element.decorators.length; + } + + function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); + } + + function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; + } + + function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; + } + + function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); + } + + function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); + } + + /** + * @file ext-arrows.js + * + * @license MIT + * + * @copyright 2010 Alexis Deveria + * + */ + var extArrows = exports('default', { + name: 'arrows', + init: function init(S) { + var _this = this; + + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() { + var strings, svgEditor, svgCanvas, addElem, nonce, $, prefix, selElems, arrowprefix, randomizeIds, setArrowNonce, unsetArrowNonce, pathdata, getLinked, showPanel, resetMarker, addMarker, setArrow, colorChanged, contextTools; + return regeneratorRuntime.wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + colorChanged = function _colorChanged(elem) { + var color = elem.getAttribute('stroke'); + var mtypes = ['start', 'mid', 'end']; + var defs = svgCanvas.findDefs(); + $.each(mtypes, function (i, type) { + var marker = getLinked(elem, 'marker-' + type); + + if (!marker) { + return; + } + + var curColor = $(marker).children().attr('fill'); + var curD = $(marker).children().attr('d'); + + if (curColor === color) { + return; + } + + var allMarkers = $(defs).find('marker'); + var newMarker = null; // Different color, check if already made + + allMarkers.each(function () { + var attrs = $(this).children().attr(['fill', 'd']); + + if (attrs.fill === color && attrs.d === curD) { + // Found another marker with this color and this path + newMarker = this; + } + }); + + if (!newMarker) { + // Create a new marker with this color + var lastId = marker.id; + var dir = lastId.includes('_fw') ? 'fw' : 'bk'; + newMarker = addMarker(dir, type, arrowprefix + dir + allMarkers.length); + $(newMarker).children().attr('fill', color); + } + + $(elem).attr('marker-' + type, 'url(#' + newMarker.id + ')'); // Check if last marker can be removed + + var remove = true; + $(S.svgcontent).find('line, polyline, path, polygon').each(function () { + var element = this; + $.each(mtypes, function (j, mtype) { + if ($(element).attr('marker-' + mtype) === 'url(#' + marker.id + ')') { + remove = false; + return remove; + } + + return undefined; + }); + + if (!remove) { + return false; + } + + return undefined; + }); // Not found, so can safely remove + + if (remove) { + $(marker).remove(); + } + }); + }; + + setArrow = function _setArrow() { + resetMarker(); + var type = this.value; + + if (type === 'none') { + return; + } // Set marker on element + + + var dir = 'fw'; + + if (type === 'mid_bk') { + type = 'mid'; + dir = 'bk'; + } else if (type === 'both') { + addMarker('bk', type); + svgCanvas.changeSelectedAttribute('marker-start', 'url(#' + pathdata.bk.id + ')'); + type = 'end'; + dir = 'fw'; + } else if (type === 'start') { + dir = 'bk'; + } + + addMarker(dir, type); + svgCanvas.changeSelectedAttribute('marker-' + type, 'url(#' + pathdata[dir].id + ')'); + svgCanvas.call('changed', selElems); + }; + + addMarker = function _addMarker(dir, type, id) { + // TODO: Make marker (or use?) per arrow type, since refX can be different + id = id || arrowprefix + dir; + var data = pathdata[dir]; + + if (type === 'mid') { + data.refx = 5; + } + + var marker = svgCanvas.getElem(id); + + if (!marker) { + marker = addElem({ + element: 'marker', + attr: { + viewBox: '0 0 10 10', + id: id, + refY: 5, + markerUnits: 'strokeWidth', + markerWidth: 5, + markerHeight: 5, + orient: 'auto', + style: 'pointer-events:none' // Currently needed for Opera + + } + }); + var arrow = addElem({ + element: 'path', + attr: { + d: data.d, + fill: '#000000' + } + }); + marker.append(arrow); + svgCanvas.findDefs().append(marker); + } + + marker.setAttribute('refX', data.refx); + return marker; + }; + + resetMarker = function _resetMarker() { + var el = selElems[0]; + el.removeAttribute('marker-start'); + el.removeAttribute('marker-mid'); + el.removeAttribute('marker-end'); + }; + + showPanel = function _showPanel(on) { + $('#arrow_panel').toggle(on); + + if (on) { + var el = selElems[0]; + var end = el.getAttribute('marker-end'); + var start = el.getAttribute('marker-start'); + var mid = el.getAttribute('marker-mid'); + var val; + + if (end && start) { + val = 'both'; + } else if (end) { + val = 'end'; + } else if (start) { + val = 'start'; + } else if (mid) { + val = 'mid'; + + if (mid.includes('bk')) { + val = 'mid_bk'; + } + } + + if (!start && !mid && !end) { + val = 'none'; + } + + $('#arrow_list').val(val); + } + }; + + getLinked = function _getLinked(elem, attr) { + var str = elem.getAttribute(attr); + + if (!str) { + return null; + } + + var m = str.match(/\(#(.*)\)/); // const m = str.match(/\(#(?.+)\)/); + // if (!m || !m.groups.id) { + + if (!m || m.length !== 2) { + return null; + } + + return svgCanvas.getElem(m[1]); // return svgCanvas.getElem(m.groups.id); + }; + + unsetArrowNonce = function _unsetArrowNonce(win) { + randomizeIds = false; + arrowprefix = prefix; + pathdata.fw.id = arrowprefix + 'fw'; + pathdata.bk.id = arrowprefix + 'bk'; + }; + + setArrowNonce = function _setArrowNonce(win, n) { + randomizeIds = true; + arrowprefix = prefix + n + '_'; + pathdata.fw.id = arrowprefix + 'fw'; + pathdata.bk.id = arrowprefix + 'bk'; + }; + + _context2.next = 10; + return S.importLocale(); + + case 10: + strings = _context2.sent; + svgEditor = _this; + svgCanvas = svgEditor.canvas; + // {svgcontent} = S, + addElem = svgCanvas.addSVGElementFromJson, nonce = S.nonce, $ = S.$, prefix = 'se_arrow_'; + randomizeIds = S.randomize_ids; + /** + * @param {Window} win + * @param {!(string|Integer)} n + * @returns {void} + */ + + svgCanvas.bind('setnonce', setArrowNonce); + svgCanvas.bind('unsetnonce', unsetArrowNonce); + + if (randomizeIds) { + arrowprefix = prefix + nonce + '_'; + } else { + arrowprefix = prefix; + } + + pathdata = { + fw: { + d: 'm0,0l10,5l-10,5l5,-5l-5,-5z', + refx: 8, + id: arrowprefix + 'fw' + }, + bk: { + d: 'm10,0l-10,5l10,5l-5,-5l5,-5z', + refx: 2, + id: arrowprefix + 'bk' + } + }; + /** + * Gets linked element. + * @param {Element} elem + * @param {string} attr + * @returns {Element} + */ + + contextTools = [{ + type: 'select', + panel: 'arrow_panel', + id: 'arrow_list', + defval: 'none', + events: { + change: setArrow + } + }]; + return _context2.abrupt("return", { + name: strings.name, + context_tools: strings.contextTools.map(function (contextTool, i) { + return Object.assign(contextTools[i], contextTool); + }), + callback: function callback() { + $('#arrow_panel').hide(); // Set ID so it can be translated in locale file + + $('#arrow_list option')[0].id = 'connector_no_arrow'; + }, + addLangData: function addLangData(_ref) { + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var lang, importLocale, _yield$importLocale, langList; + + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + lang = _ref.lang, importLocale = _ref.importLocale; + _context.next = 3; + return importLocale(); + + case 3: + _yield$importLocale = _context.sent; + langList = _yield$importLocale.langList; + return _context.abrupt("return", { + data: langList + }); + + case 6: + case "end": + return _context.stop(); + } + } + }, _callee); + }))(); + }, + selectedChanged: function selectedChanged(opts) { + // Use this to update the current selected elements + selElems = opts.elems; + var markerElems = ['line', 'path', 'polyline', 'polygon']; + var i = selElems.length; + + while (i--) { + var elem = selElems[i]; + + if (elem && markerElems.includes(elem.tagName)) { + if (opts.selectedElement && !opts.multiselected) { + showPanel(true); + } else { + showPanel(false); + } + } else { + showPanel(false); + } + } + }, + elementChanged: function elementChanged(opts) { + var elem = opts.elems[0]; + + if (elem && (elem.getAttribute('marker-start') || elem.getAttribute('marker-mid') || elem.getAttribute('marker-end'))) { + // const start = elem.getAttribute('marker-start'); + // const mid = elem.getAttribute('marker-mid'); + // const end = elem.getAttribute('marker-end'); + // Has marker, so see if it should match color + colorChanged(elem); + } + } + }); + + case 21: + case "end": + return _context2.stop(); + } + } + }, _callee2); + }))(); + } + }); + + } + }; +}); diff --git a/dist/editor/system/extensions/ext-closepath.js b/dist/editor/system/extensions/ext-closepath.js new file mode 100644 index 00000000..1b1a6212 --- /dev/null +++ b/dist/editor/system/extensions/ext-closepath.js @@ -0,0 +1,4096 @@ +System.register([], function (exports) { + 'use strict'; + return { + execute: function () { + + function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); + } + + var REACT_ELEMENT_TYPE; + + function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; + } + + function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); + } + + function _AwaitValue(value) { + this.wrapped = value; + } + + function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } + } + + if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; + } + + _AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); + }; + + _AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); + }; + + _AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); + }; + + function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; + } + + function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); + } + + function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; + } + + function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } + } + + function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; + } + + function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; + } + + function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; + } + + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; + } + + function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); + } + + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; + } + + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; + } + + function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); + } + + function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); + } + + function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); + } + + function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } + } + + function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); + } + + function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; + } + + function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); + } + + function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } + } + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; + } + + function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; + } + + function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } + } + + function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); + } + + function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; + } + + function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; + } + + function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); + } + + function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; + } + + function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; + } + + function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); + } + + function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); + } + + function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; + } + + function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); + } + + function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; + } + + function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); + } + + function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); + } + + function _temporalUndefined() {} + + function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); + } + + function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; + } + + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); + } + + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + + function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); + } + + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); + } + + function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; + } + + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; + } + + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; + } + + function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); + } + + function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; + } + + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); + } + + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); + } + + function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); + } + + function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); + } + + function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; + } + + var id = 0; + + function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; + } + + function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; + } + + function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } + } + + function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; + } + + function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); + } + + function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); + } + + function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; + } + + function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; + } + + function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } + } + + function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; + } + + function _hasDecorators(element) { + return element.decorators && element.decorators.length; + } + + function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); + } + + function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; + } + + function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; + } + + function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); + } + + function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); + } + + /* eslint-disable import/unambiguous, max-len */ + + /* globals SVGPathSeg, SVGPathSegMovetoRel, SVGPathSegMovetoAbs, + SVGPathSegMovetoRel, SVGPathSegLinetoRel, SVGPathSegLinetoAbs, + SVGPathSegLinetoHorizontalRel, SVGPathSegLinetoHorizontalAbs, + SVGPathSegLinetoVerticalRel, SVGPathSegLinetoVerticalAbs, + SVGPathSegClosePath, SVGPathSegCurvetoCubicRel, + SVGPathSegCurvetoCubicAbs, SVGPathSegCurvetoCubicSmoothRel, + SVGPathSegCurvetoCubicSmoothAbs, SVGPathSegCurvetoQuadraticRel, + SVGPathSegCurvetoQuadraticAbs, SVGPathSegCurvetoQuadraticSmoothRel, + SVGPathSegCurvetoQuadraticSmoothAbs, SVGPathSegArcRel, SVGPathSegArcAbs */ + + /** + * SVGPathSeg API polyfill + * https://github.com/progers/pathseg + * + * This is a drop-in replacement for the `SVGPathSeg` and `SVGPathSegList` APIs + * that were removed from SVG2 ({@link https://lists.w3.org/Archives/Public/www-svg/2015Jun/0044.html}), + * including the latest spec changes which were implemented in Firefox 43 and + * Chrome 46. + */ + + /* eslint-disable no-shadow, class-methods-use-this, jsdoc/require-jsdoc */ + // Linting: We avoid `no-shadow` as ESLint thinks these are still available globals + // Linting: We avoid `class-methods-use-this` as this is a polyfill that must + // follow the conventions + (function () { + if (!('SVGPathSeg' in window)) { + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSeg + var _SVGPathSeg = /*#__PURE__*/function () { + function _SVGPathSeg(type, typeAsLetter, owningPathSegList) { + _classCallCheck(this, _SVGPathSeg); + + this.pathSegType = type; + this.pathSegTypeAsLetter = typeAsLetter; + this._owningPathSegList = owningPathSegList; + } // Notify owning PathSegList on any changes so they can be synchronized back to the path element. + + + _createClass(_SVGPathSeg, [{ + key: "_segmentChanged", + value: function _segmentChanged() { + if (this._owningPathSegList) { + this._owningPathSegList.segmentChanged(this); + } + } + }]); + + return _SVGPathSeg; + }(); + + _SVGPathSeg.prototype.classname = 'SVGPathSeg'; + _SVGPathSeg.PATHSEG_UNKNOWN = 0; + _SVGPathSeg.PATHSEG_CLOSEPATH = 1; + _SVGPathSeg.PATHSEG_MOVETO_ABS = 2; + _SVGPathSeg.PATHSEG_MOVETO_REL = 3; + _SVGPathSeg.PATHSEG_LINETO_ABS = 4; + _SVGPathSeg.PATHSEG_LINETO_REL = 5; + _SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS = 6; + _SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL = 7; + _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS = 8; + _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL = 9; + _SVGPathSeg.PATHSEG_ARC_ABS = 10; + _SVGPathSeg.PATHSEG_ARC_REL = 11; + _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS = 12; + _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL = 13; + _SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS = 14; + _SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL = 15; + _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS = 16; + _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL = 17; + _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS = 18; + _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL = 19; + + var _SVGPathSegClosePath = /*#__PURE__*/function (_SVGPathSeg2) { + _inherits(_SVGPathSegClosePath, _SVGPathSeg2); + + var _super = _createSuper(_SVGPathSegClosePath); + + function _SVGPathSegClosePath(owningPathSegList) { + _classCallCheck(this, _SVGPathSegClosePath); + + return _super.call(this, _SVGPathSeg.PATHSEG_CLOSEPATH, 'z', owningPathSegList); + } + + _createClass(_SVGPathSegClosePath, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegClosePath]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegClosePath(undefined); + } + }]); + + return _SVGPathSegClosePath; + }(_SVGPathSeg); + + var _SVGPathSegMovetoAbs = /*#__PURE__*/function (_SVGPathSeg3) { + _inherits(_SVGPathSegMovetoAbs, _SVGPathSeg3); + + var _super2 = _createSuper(_SVGPathSegMovetoAbs); + + function _SVGPathSegMovetoAbs(owningPathSegList, x, y) { + var _this; + + _classCallCheck(this, _SVGPathSegMovetoAbs); + + _this = _super2.call(this, _SVGPathSeg.PATHSEG_MOVETO_ABS, 'M', owningPathSegList); + _this._x = x; + _this._y = y; + return _this; + } + + _createClass(_SVGPathSegMovetoAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegMovetoAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegMovetoAbs(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegMovetoAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegMovetoAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegMovetoRel = /*#__PURE__*/function (_SVGPathSeg4) { + _inherits(_SVGPathSegMovetoRel, _SVGPathSeg4); + + var _super3 = _createSuper(_SVGPathSegMovetoRel); + + function _SVGPathSegMovetoRel(owningPathSegList, x, y) { + var _this2; + + _classCallCheck(this, _SVGPathSegMovetoRel); + + _this2 = _super3.call(this, _SVGPathSeg.PATHSEG_MOVETO_REL, 'm', owningPathSegList); + _this2._x = x; + _this2._y = y; + return _this2; + } + + _createClass(_SVGPathSegMovetoRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegMovetoRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegMovetoRel(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegMovetoRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegMovetoRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegLinetoAbs = /*#__PURE__*/function (_SVGPathSeg5) { + _inherits(_SVGPathSegLinetoAbs, _SVGPathSeg5); + + var _super4 = _createSuper(_SVGPathSegLinetoAbs); + + function _SVGPathSegLinetoAbs(owningPathSegList, x, y) { + var _this3; + + _classCallCheck(this, _SVGPathSegLinetoAbs); + + _this3 = _super4.call(this, _SVGPathSeg.PATHSEG_LINETO_ABS, 'L', owningPathSegList); + _this3._x = x; + _this3._y = y; + return _this3; + } + + _createClass(_SVGPathSegLinetoAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoAbs(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegLinetoAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegLinetoAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegLinetoRel = /*#__PURE__*/function (_SVGPathSeg6) { + _inherits(_SVGPathSegLinetoRel, _SVGPathSeg6); + + var _super5 = _createSuper(_SVGPathSegLinetoRel); + + function _SVGPathSegLinetoRel(owningPathSegList, x, y) { + var _this4; + + _classCallCheck(this, _SVGPathSegLinetoRel); + + _this4 = _super5.call(this, _SVGPathSeg.PATHSEG_LINETO_REL, 'l', owningPathSegList); + _this4._x = x; + _this4._y = y; + return _this4; + } + + _createClass(_SVGPathSegLinetoRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoRel(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegLinetoRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegLinetoRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoCubicAbs = /*#__PURE__*/function (_SVGPathSeg7) { + _inherits(_SVGPathSegCurvetoCubicAbs, _SVGPathSeg7); + + var _super6 = _createSuper(_SVGPathSegCurvetoCubicAbs); + + function _SVGPathSegCurvetoCubicAbs(owningPathSegList, x, y, x1, y1, x2, y2) { + var _this5; + + _classCallCheck(this, _SVGPathSegCurvetoCubicAbs); + + _this5 = _super6.call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS, 'C', owningPathSegList); + _this5._x = x; + _this5._y = y; + _this5._x1 = x1; + _this5._y1 = y1; + _this5._x2 = x2; + _this5._y2 = y2; + return _this5; + } + + _createClass(_SVGPathSegCurvetoCubicAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoCubicAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoCubicAbs(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2); + } + }]); + + return _SVGPathSegCurvetoCubicAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoCubicAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x1: { + get: function get() { + return this._x1; + }, + set: function set(x1) { + this._x1 = x1; + + this._segmentChanged(); + }, + enumerable: true + }, + y1: { + get: function get() { + return this._y1; + }, + set: function set(y1) { + this._y1 = y1; + + this._segmentChanged(); + }, + enumerable: true + }, + x2: { + get: function get() { + return this._x2; + }, + set: function set(x2) { + this._x2 = x2; + + this._segmentChanged(); + }, + enumerable: true + }, + y2: { + get: function get() { + return this._y2; + }, + set: function set(y2) { + this._y2 = y2; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoCubicRel = /*#__PURE__*/function (_SVGPathSeg8) { + _inherits(_SVGPathSegCurvetoCubicRel, _SVGPathSeg8); + + var _super7 = _createSuper(_SVGPathSegCurvetoCubicRel); + + function _SVGPathSegCurvetoCubicRel(owningPathSegList, x, y, x1, y1, x2, y2) { + var _this6; + + _classCallCheck(this, _SVGPathSegCurvetoCubicRel); + + _this6 = _super7.call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL, 'c', owningPathSegList); + _this6._x = x; + _this6._y = y; + _this6._x1 = x1; + _this6._y1 = y1; + _this6._x2 = x2; + _this6._y2 = y2; + return _this6; + } + + _createClass(_SVGPathSegCurvetoCubicRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoCubicRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoCubicRel(undefined, this._x, this._y, this._x1, this._y1, this._x2, this._y2); + } + }]); + + return _SVGPathSegCurvetoCubicRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoCubicRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x1: { + get: function get() { + return this._x1; + }, + set: function set(x1) { + this._x1 = x1; + + this._segmentChanged(); + }, + enumerable: true + }, + y1: { + get: function get() { + return this._y1; + }, + set: function set(y1) { + this._y1 = y1; + + this._segmentChanged(); + }, + enumerable: true + }, + x2: { + get: function get() { + return this._x2; + }, + set: function set(x2) { + this._x2 = x2; + + this._segmentChanged(); + }, + enumerable: true + }, + y2: { + get: function get() { + return this._y2; + }, + set: function set(y2) { + this._y2 = y2; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoQuadraticAbs = /*#__PURE__*/function (_SVGPathSeg9) { + _inherits(_SVGPathSegCurvetoQuadraticAbs, _SVGPathSeg9); + + var _super8 = _createSuper(_SVGPathSegCurvetoQuadraticAbs); + + function _SVGPathSegCurvetoQuadraticAbs(owningPathSegList, x, y, x1, y1) { + var _this7; + + _classCallCheck(this, _SVGPathSegCurvetoQuadraticAbs); + + _this7 = _super8.call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS, 'Q', owningPathSegList); + _this7._x = x; + _this7._y = y; + _this7._x1 = x1; + _this7._y1 = y1; + return _this7; + } + + _createClass(_SVGPathSegCurvetoQuadraticAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoQuadraticAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoQuadraticAbs(undefined, this._x, this._y, this._x1, this._y1); + } + }]); + + return _SVGPathSegCurvetoQuadraticAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoQuadraticAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x1: { + get: function get() { + return this._x1; + }, + set: function set(x1) { + this._x1 = x1; + + this._segmentChanged(); + }, + enumerable: true + }, + y1: { + get: function get() { + return this._y1; + }, + set: function set(y1) { + this._y1 = y1; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoQuadraticRel = /*#__PURE__*/function (_SVGPathSeg10) { + _inherits(_SVGPathSegCurvetoQuadraticRel, _SVGPathSeg10); + + var _super9 = _createSuper(_SVGPathSegCurvetoQuadraticRel); + + function _SVGPathSegCurvetoQuadraticRel(owningPathSegList, x, y, x1, y1) { + var _this8; + + _classCallCheck(this, _SVGPathSegCurvetoQuadraticRel); + + _this8 = _super9.call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL, 'q', owningPathSegList); + _this8._x = x; + _this8._y = y; + _this8._x1 = x1; + _this8._y1 = y1; + return _this8; + } + + _createClass(_SVGPathSegCurvetoQuadraticRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoQuadraticRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x1 + ' ' + this._y1 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoQuadraticRel(undefined, this._x, this._y, this._x1, this._y1); + } + }]); + + return _SVGPathSegCurvetoQuadraticRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoQuadraticRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x1: { + get: function get() { + return this._x1; + }, + set: function set(x1) { + this._x1 = x1; + + this._segmentChanged(); + }, + enumerable: true + }, + y1: { + get: function get() { + return this._y1; + }, + set: function set(y1) { + this._y1 = y1; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegArcAbs = /*#__PURE__*/function (_SVGPathSeg11) { + _inherits(_SVGPathSegArcAbs, _SVGPathSeg11); + + var _super10 = _createSuper(_SVGPathSegArcAbs); + + function _SVGPathSegArcAbs(owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) { + var _this9; + + _classCallCheck(this, _SVGPathSegArcAbs); + + _this9 = _super10.call(this, _SVGPathSeg.PATHSEG_ARC_ABS, 'A', owningPathSegList); + _this9._x = x; + _this9._y = y; + _this9._r1 = r1; + _this9._r2 = r2; + _this9._angle = angle; + _this9._largeArcFlag = largeArcFlag; + _this9._sweepFlag = sweepFlag; + return _this9; + } + + _createClass(_SVGPathSegArcAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegArcAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle + ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0') + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegArcAbs(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag); + } + }]); + + return _SVGPathSegArcAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegArcAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + r1: { + get: function get() { + return this._r1; + }, + set: function set(r1) { + this._r1 = r1; + + this._segmentChanged(); + }, + enumerable: true + }, + r2: { + get: function get() { + return this._r2; + }, + set: function set(r2) { + this._r2 = r2; + + this._segmentChanged(); + }, + enumerable: true + }, + angle: { + get: function get() { + return this._angle; + }, + set: function set(angle) { + this._angle = angle; + + this._segmentChanged(); + }, + enumerable: true + }, + largeArcFlag: { + get: function get() { + return this._largeArcFlag; + }, + set: function set(largeArcFlag) { + this._largeArcFlag = largeArcFlag; + + this._segmentChanged(); + }, + enumerable: true + }, + sweepFlag: { + get: function get() { + return this._sweepFlag; + }, + set: function set(sweepFlag) { + this._sweepFlag = sweepFlag; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegArcRel = /*#__PURE__*/function (_SVGPathSeg12) { + _inherits(_SVGPathSegArcRel, _SVGPathSeg12); + + var _super11 = _createSuper(_SVGPathSegArcRel); + + function _SVGPathSegArcRel(owningPathSegList, x, y, r1, r2, angle, largeArcFlag, sweepFlag) { + var _this10; + + _classCallCheck(this, _SVGPathSegArcRel); + + _this10 = _super11.call(this, _SVGPathSeg.PATHSEG_ARC_REL, 'a', owningPathSegList); + _this10._x = x; + _this10._y = y; + _this10._r1 = r1; + _this10._r2 = r2; + _this10._angle = angle; + _this10._largeArcFlag = largeArcFlag; + _this10._sweepFlag = sweepFlag; + return _this10; + } + + _createClass(_SVGPathSegArcRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegArcRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._r1 + ' ' + this._r2 + ' ' + this._angle + ' ' + (this._largeArcFlag ? '1' : '0') + ' ' + (this._sweepFlag ? '1' : '0') + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegArcRel(undefined, this._x, this._y, this._r1, this._r2, this._angle, this._largeArcFlag, this._sweepFlag); + } + }]); + + return _SVGPathSegArcRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegArcRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + r1: { + get: function get() { + return this._r1; + }, + set: function set(r1) { + this._r1 = r1; + + this._segmentChanged(); + }, + enumerable: true + }, + r2: { + get: function get() { + return this._r2; + }, + set: function set(r2) { + this._r2 = r2; + + this._segmentChanged(); + }, + enumerable: true + }, + angle: { + get: function get() { + return this._angle; + }, + set: function set(angle) { + this._angle = angle; + + this._segmentChanged(); + }, + enumerable: true + }, + largeArcFlag: { + get: function get() { + return this._largeArcFlag; + }, + set: function set(largeArcFlag) { + this._largeArcFlag = largeArcFlag; + + this._segmentChanged(); + }, + enumerable: true + }, + sweepFlag: { + get: function get() { + return this._sweepFlag; + }, + set: function set(sweepFlag) { + this._sweepFlag = sweepFlag; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegLinetoHorizontalAbs = /*#__PURE__*/function (_SVGPathSeg13) { + _inherits(_SVGPathSegLinetoHorizontalAbs, _SVGPathSeg13); + + var _super12 = _createSuper(_SVGPathSegLinetoHorizontalAbs); + + function _SVGPathSegLinetoHorizontalAbs(owningPathSegList, x) { + var _this11; + + _classCallCheck(this, _SVGPathSegLinetoHorizontalAbs); + + _this11 = _super12.call(this, _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS, 'H', owningPathSegList); + _this11._x = x; + return _this11; + } + + _createClass(_SVGPathSegLinetoHorizontalAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoHorizontalAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoHorizontalAbs(undefined, this._x); + } + }]); + + return _SVGPathSegLinetoHorizontalAbs; + }(_SVGPathSeg); + + Object.defineProperty(_SVGPathSegLinetoHorizontalAbs.prototype, 'x', { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }); + + var _SVGPathSegLinetoHorizontalRel = /*#__PURE__*/function (_SVGPathSeg14) { + _inherits(_SVGPathSegLinetoHorizontalRel, _SVGPathSeg14); + + var _super13 = _createSuper(_SVGPathSegLinetoHorizontalRel); + + function _SVGPathSegLinetoHorizontalRel(owningPathSegList, x) { + var _this12; + + _classCallCheck(this, _SVGPathSegLinetoHorizontalRel); + + _this12 = _super13.call(this, _SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL, 'h', owningPathSegList); + _this12._x = x; + return _this12; + } + + _createClass(_SVGPathSegLinetoHorizontalRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoHorizontalRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoHorizontalRel(undefined, this._x); + } + }]); + + return _SVGPathSegLinetoHorizontalRel; + }(_SVGPathSeg); + + Object.defineProperty(_SVGPathSegLinetoHorizontalRel.prototype, 'x', { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }); + + var _SVGPathSegLinetoVerticalAbs = /*#__PURE__*/function (_SVGPathSeg15) { + _inherits(_SVGPathSegLinetoVerticalAbs, _SVGPathSeg15); + + var _super14 = _createSuper(_SVGPathSegLinetoVerticalAbs); + + function _SVGPathSegLinetoVerticalAbs(owningPathSegList, y) { + var _this13; + + _classCallCheck(this, _SVGPathSegLinetoVerticalAbs); + + _this13 = _super14.call(this, _SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS, 'V', owningPathSegList); + _this13._y = y; + return _this13; + } + + _createClass(_SVGPathSegLinetoVerticalAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoVerticalAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoVerticalAbs(undefined, this._y); + } + }]); + + return _SVGPathSegLinetoVerticalAbs; + }(_SVGPathSeg); + + Object.defineProperty(_SVGPathSegLinetoVerticalAbs.prototype, 'y', { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }); + + var _SVGPathSegLinetoVerticalRel = /*#__PURE__*/function (_SVGPathSeg16) { + _inherits(_SVGPathSegLinetoVerticalRel, _SVGPathSeg16); + + var _super15 = _createSuper(_SVGPathSegLinetoVerticalRel); + + function _SVGPathSegLinetoVerticalRel(owningPathSegList, y) { + var _this14; + + _classCallCheck(this, _SVGPathSegLinetoVerticalRel); + + _this14 = _super15.call(this, _SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL, 'v', owningPathSegList); + _this14._y = y; + return _this14; + } + + _createClass(_SVGPathSegLinetoVerticalRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegLinetoVerticalRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegLinetoVerticalRel(undefined, this._y); + } + }]); + + return _SVGPathSegLinetoVerticalRel; + }(_SVGPathSeg); + + Object.defineProperty(_SVGPathSegLinetoVerticalRel.prototype, 'y', { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }); + + var _SVGPathSegCurvetoCubicSmoothAbs = /*#__PURE__*/function (_SVGPathSeg17) { + _inherits(_SVGPathSegCurvetoCubicSmoothAbs, _SVGPathSeg17); + + var _super16 = _createSuper(_SVGPathSegCurvetoCubicSmoothAbs); + + function _SVGPathSegCurvetoCubicSmoothAbs(owningPathSegList, x, y, x2, y2) { + var _this15; + + _classCallCheck(this, _SVGPathSegCurvetoCubicSmoothAbs); + + _this15 = _super16.call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS, 'S', owningPathSegList); + _this15._x = x; + _this15._y = y; + _this15._x2 = x2; + _this15._y2 = y2; + return _this15; + } + + _createClass(_SVGPathSegCurvetoCubicSmoothAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoCubicSmoothAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoCubicSmoothAbs(undefined, this._x, this._y, this._x2, this._y2); + } + }]); + + return _SVGPathSegCurvetoCubicSmoothAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoCubicSmoothAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x2: { + get: function get() { + return this._x2; + }, + set: function set(x2) { + this._x2 = x2; + + this._segmentChanged(); + }, + enumerable: true + }, + y2: { + get: function get() { + return this._y2; + }, + set: function set(y2) { + this._y2 = y2; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoCubicSmoothRel = /*#__PURE__*/function (_SVGPathSeg18) { + _inherits(_SVGPathSegCurvetoCubicSmoothRel, _SVGPathSeg18); + + var _super17 = _createSuper(_SVGPathSegCurvetoCubicSmoothRel); + + function _SVGPathSegCurvetoCubicSmoothRel(owningPathSegList, x, y, x2, y2) { + var _this16; + + _classCallCheck(this, _SVGPathSegCurvetoCubicSmoothRel); + + _this16 = _super17.call(this, _SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL, 's', owningPathSegList); + _this16._x = x; + _this16._y = y; + _this16._x2 = x2; + _this16._y2 = y2; + return _this16; + } + + _createClass(_SVGPathSegCurvetoCubicSmoothRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoCubicSmoothRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x2 + ' ' + this._y2 + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoCubicSmoothRel(undefined, this._x, this._y, this._x2, this._y2); + } + }]); + + return _SVGPathSegCurvetoCubicSmoothRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoCubicSmoothRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + }, + x2: { + get: function get() { + return this._x2; + }, + set: function set(x2) { + this._x2 = x2; + + this._segmentChanged(); + }, + enumerable: true + }, + y2: { + get: function get() { + return this._y2; + }, + set: function set(y2) { + this._y2 = y2; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoQuadraticSmoothAbs = /*#__PURE__*/function (_SVGPathSeg19) { + _inherits(_SVGPathSegCurvetoQuadraticSmoothAbs, _SVGPathSeg19); + + var _super18 = _createSuper(_SVGPathSegCurvetoQuadraticSmoothAbs); + + function _SVGPathSegCurvetoQuadraticSmoothAbs(owningPathSegList, x, y) { + var _this17; + + _classCallCheck(this, _SVGPathSegCurvetoQuadraticSmoothAbs); + + _this17 = _super18.call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS, 'T', owningPathSegList); + _this17._x = x; + _this17._y = y; + return _this17; + } + + _createClass(_SVGPathSegCurvetoQuadraticSmoothAbs, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoQuadraticSmoothAbs]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoQuadraticSmoothAbs(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegCurvetoQuadraticSmoothAbs; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoQuadraticSmoothAbs.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); + + var _SVGPathSegCurvetoQuadraticSmoothRel = /*#__PURE__*/function (_SVGPathSeg20) { + _inherits(_SVGPathSegCurvetoQuadraticSmoothRel, _SVGPathSeg20); + + var _super19 = _createSuper(_SVGPathSegCurvetoQuadraticSmoothRel); + + function _SVGPathSegCurvetoQuadraticSmoothRel(owningPathSegList, x, y) { + var _this18; + + _classCallCheck(this, _SVGPathSegCurvetoQuadraticSmoothRel); + + _this18 = _super19.call(this, _SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL, 't', owningPathSegList); + _this18._x = x; + _this18._y = y; + return _this18; + } + + _createClass(_SVGPathSegCurvetoQuadraticSmoothRel, [{ + key: "toString", + value: function toString() { + return '[object SVGPathSegCurvetoQuadraticSmoothRel]'; + } + }, { + key: "_asPathString", + value: function _asPathString() { + return this.pathSegTypeAsLetter + ' ' + this._x + ' ' + this._y; + } + }, { + key: "clone", + value: function clone() { + return new _SVGPathSegCurvetoQuadraticSmoothRel(undefined, this._x, this._y); + } + }]); + + return _SVGPathSegCurvetoQuadraticSmoothRel; + }(_SVGPathSeg); + + Object.defineProperties(_SVGPathSegCurvetoQuadraticSmoothRel.prototype, { + x: { + get: function get() { + return this._x; + }, + set: function set(x) { + this._x = x; + + this._segmentChanged(); + }, + enumerable: true + }, + y: { + get: function get() { + return this._y; + }, + set: function set(y) { + this._y = y; + + this._segmentChanged(); + }, + enumerable: true + } + }); // Add createSVGPathSeg* functions to SVGPathElement. + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathElement. + + SVGPathElement.prototype.createSVGPathSegClosePath = function () { + return new _SVGPathSegClosePath(undefined); + }; + + SVGPathElement.prototype.createSVGPathSegMovetoAbs = function (x, y) { + return new _SVGPathSegMovetoAbs(undefined, x, y); + }; + + SVGPathElement.prototype.createSVGPathSegMovetoRel = function (x, y) { + return new _SVGPathSegMovetoRel(undefined, x, y); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoAbs = function (x, y) { + return new _SVGPathSegLinetoAbs(undefined, x, y); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoRel = function (x, y) { + return new _SVGPathSegLinetoRel(undefined, x, y); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoCubicAbs = function (x, y, x1, y1, x2, y2) { + return new _SVGPathSegCurvetoCubicAbs(undefined, x, y, x1, y1, x2, y2); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoCubicRel = function (x, y, x1, y1, x2, y2) { + return new _SVGPathSegCurvetoCubicRel(undefined, x, y, x1, y1, x2, y2); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticAbs = function (x, y, x1, y1) { + return new _SVGPathSegCurvetoQuadraticAbs(undefined, x, y, x1, y1); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticRel = function (x, y, x1, y1) { + return new _SVGPathSegCurvetoQuadraticRel(undefined, x, y, x1, y1); + }; + + SVGPathElement.prototype.createSVGPathSegArcAbs = function (x, y, r1, r2, angle, largeArcFlag, sweepFlag) { + return new _SVGPathSegArcAbs(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag); + }; + + SVGPathElement.prototype.createSVGPathSegArcRel = function (x, y, r1, r2, angle, largeArcFlag, sweepFlag) { + return new _SVGPathSegArcRel(undefined, x, y, r1, r2, angle, largeArcFlag, sweepFlag); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoHorizontalAbs = function (x) { + return new _SVGPathSegLinetoHorizontalAbs(undefined, x); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoHorizontalRel = function (x) { + return new _SVGPathSegLinetoHorizontalRel(undefined, x); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoVerticalAbs = function (y) { + return new _SVGPathSegLinetoVerticalAbs(undefined, y); + }; + + SVGPathElement.prototype.createSVGPathSegLinetoVerticalRel = function (y) { + return new _SVGPathSegLinetoVerticalRel(undefined, y); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothAbs = function (x, y, x2, y2) { + return new _SVGPathSegCurvetoCubicSmoothAbs(undefined, x, y, x2, y2); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoCubicSmoothRel = function (x, y, x2, y2) { + return new _SVGPathSegCurvetoCubicSmoothRel(undefined, x, y, x2, y2); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothAbs = function (x, y) { + return new _SVGPathSegCurvetoQuadraticSmoothAbs(undefined, x, y); + }; + + SVGPathElement.prototype.createSVGPathSegCurvetoQuadraticSmoothRel = function (x, y) { + return new _SVGPathSegCurvetoQuadraticSmoothRel(undefined, x, y); + }; + + if (!('getPathSegAtLength' in SVGPathElement.prototype)) { + // Add getPathSegAtLength to SVGPathElement. + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-__svg__SVGPathElement__getPathSegAtLength + // This polyfill requires SVGPathElement.getTotalLength to implement the distance-along-a-path algorithm. + SVGPathElement.prototype.getPathSegAtLength = function (distance) { + if (distance === undefined || !isFinite(distance)) { + throw new Error('Invalid arguments.'); + } + + var measurementElement = document.createElementNS('http://www.w3.org/2000/svg', 'path'); + measurementElement.setAttribute('d', this.getAttribute('d')); + var lastPathSegment = measurementElement.pathSegList.numberOfItems - 1; // If the path is empty, return 0. + + if (lastPathSegment <= 0) { + return 0; + } + + do { + measurementElement.pathSegList.removeItem(lastPathSegment); + + if (distance > measurementElement.getTotalLength()) { + break; + } + + lastPathSegment--; + } while (lastPathSegment > 0); + + return lastPathSegment; + }; + } + + window.SVGPathSeg = _SVGPathSeg; + window.SVGPathSegClosePath = _SVGPathSegClosePath; + window.SVGPathSegMovetoAbs = _SVGPathSegMovetoAbs; + window.SVGPathSegMovetoRel = _SVGPathSegMovetoRel; + window.SVGPathSegLinetoAbs = _SVGPathSegLinetoAbs; + window.SVGPathSegLinetoRel = _SVGPathSegLinetoRel; + window.SVGPathSegCurvetoCubicAbs = _SVGPathSegCurvetoCubicAbs; + window.SVGPathSegCurvetoCubicRel = _SVGPathSegCurvetoCubicRel; + window.SVGPathSegCurvetoQuadraticAbs = _SVGPathSegCurvetoQuadraticAbs; + window.SVGPathSegCurvetoQuadraticRel = _SVGPathSegCurvetoQuadraticRel; + window.SVGPathSegArcAbs = _SVGPathSegArcAbs; + window.SVGPathSegArcRel = _SVGPathSegArcRel; + window.SVGPathSegLinetoHorizontalAbs = _SVGPathSegLinetoHorizontalAbs; + window.SVGPathSegLinetoHorizontalRel = _SVGPathSegLinetoHorizontalRel; + window.SVGPathSegLinetoVerticalAbs = _SVGPathSegLinetoVerticalAbs; + window.SVGPathSegLinetoVerticalRel = _SVGPathSegLinetoVerticalRel; + window.SVGPathSegCurvetoCubicSmoothAbs = _SVGPathSegCurvetoCubicSmoothAbs; + window.SVGPathSegCurvetoCubicSmoothRel = _SVGPathSegCurvetoCubicSmoothRel; + window.SVGPathSegCurvetoQuadraticSmoothAbs = _SVGPathSegCurvetoQuadraticSmoothAbs; + window.SVGPathSegCurvetoQuadraticSmoothRel = _SVGPathSegCurvetoQuadraticSmoothRel; + } // Checking for SVGPathSegList in window checks for the case of an implementation without the + // SVGPathSegList API. + // The second check for appendItem is specific to Firefox 59+ which removed only parts of the + // SVGPathSegList API (e.g., appendItem). In this case we need to re-implement the entire API + // so the polyfill data (i.e., _list) is used throughout. + + + if (!('SVGPathSegList' in window) || !('appendItem' in window.SVGPathSegList.prototype)) { + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGPathSegList + var SVGPathSegList = /*#__PURE__*/function () { + function SVGPathSegList(pathElement) { + _classCallCheck(this, SVGPathSegList); + + this._pathElement = pathElement; + this._list = this._parsePath(this._pathElement.getAttribute('d')); // Use a MutationObserver to catch changes to the path's "d" attribute. + + this._mutationObserverConfig = { + attributes: true, + attributeFilter: ['d'] + }; + this._pathElementMutationObserver = new MutationObserver(this._updateListFromPathMutations.bind(this)); + + this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig); + } // Process any pending mutations to the path element and update the list as needed. + // This should be the first call of all public functions and is needed because + // MutationObservers are not synchronous so we can have pending asynchronous mutations. + + + _createClass(SVGPathSegList, [{ + key: "_checkPathSynchronizedToList", + value: function _checkPathSynchronizedToList() { + this._updateListFromPathMutations(this._pathElementMutationObserver.takeRecords()); + } + }, { + key: "_updateListFromPathMutations", + value: function _updateListFromPathMutations(mutationRecords) { + if (!this._pathElement) { + return; + } + + var hasPathMutations = false; + mutationRecords.forEach(function (record) { + if (record.attributeName === 'd') { + hasPathMutations = true; + } + }); + + if (hasPathMutations) { + this._list = this._parsePath(this._pathElement.getAttribute('d')); + } + } // Serialize the list and update the path's 'd' attribute. + + }, { + key: "_writeListToPath", + value: function _writeListToPath() { + this._pathElementMutationObserver.disconnect(); + + this._pathElement.setAttribute('d', SVGPathSegList._pathSegArrayAsString(this._list)); + + this._pathElementMutationObserver.observe(this._pathElement, this._mutationObserverConfig); + } // When a path segment changes the list needs to be synchronized back to the path element. + + }, { + key: "segmentChanged", + value: function segmentChanged(pathSeg) { + this._writeListToPath(); + } + }, { + key: "clear", + value: function clear() { + this._checkPathSynchronizedToList(); + + this._list.forEach(function (pathSeg) { + pathSeg._owningPathSegList = null; + }); + + this._list = []; + + this._writeListToPath(); + } + }, { + key: "initialize", + value: function initialize(newItem) { + this._checkPathSynchronizedToList(); + + this._list = [newItem]; + newItem._owningPathSegList = this; + + this._writeListToPath(); + + return newItem; + } + }, { + key: "_checkValidIndex", + value: function _checkValidIndex(index) { + if (isNaN(index) || index < 0 || index >= this.numberOfItems) { + throw new Error('INDEX_SIZE_ERR'); + } + } + }, { + key: "getItem", + value: function getItem(index) { + this._checkPathSynchronizedToList(); + + this._checkValidIndex(index); + + return this._list[index]; + } + }, { + key: "insertItemBefore", + value: function insertItemBefore(newItem, index) { + this._checkPathSynchronizedToList(); // Spec: If the index is greater than or equal to numberOfItems, then the new item is appended to the end of the list. + + + if (index > this.numberOfItems) { + index = this.numberOfItems; + } + + if (newItem._owningPathSegList) { + // SVG2 spec says to make a copy. + newItem = newItem.clone(); + } + + this._list.splice(index, 0, newItem); + + newItem._owningPathSegList = this; + + this._writeListToPath(); + + return newItem; + } + }, { + key: "replaceItem", + value: function replaceItem(newItem, index) { + this._checkPathSynchronizedToList(); + + if (newItem._owningPathSegList) { + // SVG2 spec says to make a copy. + newItem = newItem.clone(); + } + + this._checkValidIndex(index); + + this._list[index] = newItem; + newItem._owningPathSegList = this; + + this._writeListToPath(); + + return newItem; + } + }, { + key: "removeItem", + value: function removeItem(index) { + this._checkPathSynchronizedToList(); + + this._checkValidIndex(index); + + var item = this._list[index]; + + this._list.splice(index, 1); + + this._writeListToPath(); + + return item; + } + }, { + key: "appendItem", + value: function appendItem(newItem) { + this._checkPathSynchronizedToList(); + + if (newItem._owningPathSegList) { + // SVG2 spec says to make a copy. + newItem = newItem.clone(); + } + + this._list.push(newItem); + + newItem._owningPathSegList = this; // TODO: Optimize this to just append to the existing attribute. + + this._writeListToPath(); + + return newItem; + } // This closely follows SVGPathParser::parsePath from Source/core/svg/SVGPathParser.cpp. + + }, { + key: "_parsePath", + value: function _parsePath(string) { + if (!string || !string.length) { + return []; + } + + var owningPathSegList = this; + + var Builder = /*#__PURE__*/function () { + function Builder() { + _classCallCheck(this, Builder); + + this.pathSegList = []; + } + + _createClass(Builder, [{ + key: "appendSegment", + value: function appendSegment(pathSeg) { + this.pathSegList.push(pathSeg); + } + }]); + + return Builder; + }(); + + var Source = /*#__PURE__*/function () { + function Source(string) { + _classCallCheck(this, Source); + + this._string = string; + this._currentIndex = 0; + this._endIndex = this._string.length; + this._previousCommand = SVGPathSeg.PATHSEG_UNKNOWN; + + this._skipOptionalSpaces(); + } + + _createClass(Source, [{ + key: "_isCurrentSpace", + value: function _isCurrentSpace() { + var character = this._string[this._currentIndex]; + return character <= ' ' && (character === ' ' || character === '\n' || character === '\t' || character === '\r' || character === '\f'); + } + }, { + key: "_skipOptionalSpaces", + value: function _skipOptionalSpaces() { + while (this._currentIndex < this._endIndex && this._isCurrentSpace()) { + this._currentIndex++; + } + + return this._currentIndex < this._endIndex; + } + }, { + key: "_skipOptionalSpacesOrDelimiter", + value: function _skipOptionalSpacesOrDelimiter() { + if (this._currentIndex < this._endIndex && !this._isCurrentSpace() && this._string.charAt(this._currentIndex) !== ',') { + return false; + } + + if (this._skipOptionalSpaces()) { + if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === ',') { + this._currentIndex++; + + this._skipOptionalSpaces(); + } + } + + return this._currentIndex < this._endIndex; + } + }, { + key: "hasMoreData", + value: function hasMoreData() { + return this._currentIndex < this._endIndex; + } + }, { + key: "peekSegmentType", + value: function peekSegmentType() { + var lookahead = this._string[this._currentIndex]; + return this._pathSegTypeFromChar(lookahead); + } + }, { + key: "_pathSegTypeFromChar", + value: function _pathSegTypeFromChar(lookahead) { + switch (lookahead) { + case 'Z': + case 'z': + return SVGPathSeg.PATHSEG_CLOSEPATH; + + case 'M': + return SVGPathSeg.PATHSEG_MOVETO_ABS; + + case 'm': + return SVGPathSeg.PATHSEG_MOVETO_REL; + + case 'L': + return SVGPathSeg.PATHSEG_LINETO_ABS; + + case 'l': + return SVGPathSeg.PATHSEG_LINETO_REL; + + case 'C': + return SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS; + + case 'c': + return SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL; + + case 'Q': + return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS; + + case 'q': + return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL; + + case 'A': + return SVGPathSeg.PATHSEG_ARC_ABS; + + case 'a': + return SVGPathSeg.PATHSEG_ARC_REL; + + case 'H': + return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS; + + case 'h': + return SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL; + + case 'V': + return SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS; + + case 'v': + return SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL; + + case 'S': + return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS; + + case 's': + return SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL; + + case 'T': + return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS; + + case 't': + return SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL; + + default: + return SVGPathSeg.PATHSEG_UNKNOWN; + } + } + }, { + key: "_nextCommandHelper", + value: function _nextCommandHelper(lookahead, previousCommand) { + // Check for remaining coordinates in the current command. + if ((lookahead === '+' || lookahead === '-' || lookahead === '.' || lookahead >= '0' && lookahead <= '9') && previousCommand !== SVGPathSeg.PATHSEG_CLOSEPATH) { + if (previousCommand === SVGPathSeg.PATHSEG_MOVETO_ABS) { + return SVGPathSeg.PATHSEG_LINETO_ABS; + } + + if (previousCommand === SVGPathSeg.PATHSEG_MOVETO_REL) { + return SVGPathSeg.PATHSEG_LINETO_REL; + } + + return previousCommand; + } + + return SVGPathSeg.PATHSEG_UNKNOWN; + } + }, { + key: "initialCommandIsMoveTo", + value: function initialCommandIsMoveTo() { + // If the path is empty it is still valid, so return true. + if (!this.hasMoreData()) { + return true; + } + + var command = this.peekSegmentType(); // Path must start with moveTo. + + return command === SVGPathSeg.PATHSEG_MOVETO_ABS || command === SVGPathSeg.PATHSEG_MOVETO_REL; + } // Parse a number from an SVG path. This very closely follows genericParseNumber(...) from Source/core/svg/SVGParserUtilities.cpp. + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-PathDataBNF + + }, { + key: "_parseNumber", + value: function _parseNumber() { + var exponent = 0; + var integer = 0; + var frac = 1; + var decimal = 0; + var sign = 1; + var expsign = 1; + var startIndex = this._currentIndex; + + this._skipOptionalSpaces(); // Read the sign. + + + if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '+') { + this._currentIndex++; + } else if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '-') { + this._currentIndex++; + sign = -1; + } + + if (this._currentIndex === this._endIndex || (this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') && this._string.charAt(this._currentIndex) !== '.') { + // The first character of a number must be one of [0-9+-.]. + return undefined; + } // Read the integer part, build right-to-left. + + + var startIntPartIndex = this._currentIndex; + + while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') { + this._currentIndex++; // Advance to first non-digit. + } + + if (this._currentIndex !== startIntPartIndex) { + var scanIntPartIndex = this._currentIndex - 1; + var multiplier = 1; + + while (scanIntPartIndex >= startIntPartIndex) { + integer += multiplier * (this._string.charAt(scanIntPartIndex--) - '0'); + multiplier *= 10; + } + } // Read the decimals. + + + if (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) === '.') { + this._currentIndex++; // There must be a least one digit following the . + + if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') { + return undefined; + } + + while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') { + frac *= 10; + decimal += (this._string.charAt(this._currentIndex) - '0') / frac; + this._currentIndex += 1; + } + } // Read the exponent part. + + + if (this._currentIndex !== startIndex && this._currentIndex + 1 < this._endIndex && (this._string.charAt(this._currentIndex) === 'e' || this._string.charAt(this._currentIndex) === 'E') && this._string.charAt(this._currentIndex + 1) !== 'x' && this._string.charAt(this._currentIndex + 1) !== 'm') { + this._currentIndex++; // Read the sign of the exponent. + + if (this._string.charAt(this._currentIndex) === '+') { + this._currentIndex++; + } else if (this._string.charAt(this._currentIndex) === '-') { + this._currentIndex++; + expsign = -1; + } // There must be an exponent. + + + if (this._currentIndex >= this._endIndex || this._string.charAt(this._currentIndex) < '0' || this._string.charAt(this._currentIndex) > '9') { + return undefined; + } + + while (this._currentIndex < this._endIndex && this._string.charAt(this._currentIndex) >= '0' && this._string.charAt(this._currentIndex) <= '9') { + exponent *= 10; + exponent += this._string.charAt(this._currentIndex) - '0'; + this._currentIndex++; + } + } + + var number = integer + decimal; + number *= sign; + + if (exponent) { + number *= Math.pow(10, expsign * exponent); + } + + if (startIndex === this._currentIndex) { + return undefined; + } + + this._skipOptionalSpacesOrDelimiter(); + + return number; + } + }, { + key: "_parseArcFlag", + value: function _parseArcFlag() { + if (this._currentIndex >= this._endIndex) { + return undefined; + } + + var flag = false; + + var flagChar = this._string.charAt(this._currentIndex++); + + if (flagChar === '0') { + flag = false; + } else if (flagChar === '1') { + flag = true; + } else { + return undefined; + } + + this._skipOptionalSpacesOrDelimiter(); + + return flag; + } + }, { + key: "parseSegment", + value: function parseSegment() { + var lookahead = this._string[this._currentIndex]; + + var command = this._pathSegTypeFromChar(lookahead); + + if (command === SVGPathSeg.PATHSEG_UNKNOWN) { + // Possibly an implicit command. Not allowed if this is the first command. + if (this._previousCommand === SVGPathSeg.PATHSEG_UNKNOWN) { + return null; + } + + command = this._nextCommandHelper(lookahead, this._previousCommand); + + if (command === SVGPathSeg.PATHSEG_UNKNOWN) { + return null; + } + } else { + this._currentIndex++; + } + + this._previousCommand = command; + + switch (command) { + case SVGPathSeg.PATHSEG_MOVETO_REL: + return new SVGPathSegMovetoRel(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_MOVETO_ABS: + return new SVGPathSegMovetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_REL: + return new SVGPathSegLinetoRel(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_ABS: + return new SVGPathSegLinetoAbs(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_REL: + return new SVGPathSegLinetoHorizontalRel(owningPathSegList, this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_HORIZONTAL_ABS: + return new SVGPathSegLinetoHorizontalAbs(owningPathSegList, this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_VERTICAL_REL: + return new SVGPathSegLinetoVerticalRel(owningPathSegList, this._parseNumber()); + + case SVGPathSeg.PATHSEG_LINETO_VERTICAL_ABS: + return new SVGPathSegLinetoVerticalAbs(owningPathSegList, this._parseNumber()); + + case SVGPathSeg.PATHSEG_CLOSEPATH: + this._skipOptionalSpaces(); + + return new SVGPathSegClosePath(owningPathSegList); + + case SVGPathSeg.PATHSEG_CURVETO_CUBIC_REL: + { + var points = { + x1: this._parseNumber(), + y1: this._parseNumber(), + x2: this._parseNumber(), + y2: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoCubicRel(owningPathSegList, points.x, points.y, points.x1, points.y1, points.x2, points.y2); + } + + case SVGPathSeg.PATHSEG_CURVETO_CUBIC_ABS: + { + var _points = { + x1: this._parseNumber(), + y1: this._parseNumber(), + x2: this._parseNumber(), + y2: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoCubicAbs(owningPathSegList, _points.x, _points.y, _points.x1, _points.y1, _points.x2, _points.y2); + } + + case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_REL: + { + var _points2 = { + x2: this._parseNumber(), + y2: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoCubicSmoothRel(owningPathSegList, _points2.x, _points2.y, _points2.x2, _points2.y2); + } + + case SVGPathSeg.PATHSEG_CURVETO_CUBIC_SMOOTH_ABS: + { + var _points3 = { + x2: this._parseNumber(), + y2: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoCubicSmoothAbs(owningPathSegList, _points3.x, _points3.y, _points3.x2, _points3.y2); + } + + case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_REL: + { + var _points4 = { + x1: this._parseNumber(), + y1: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoQuadraticRel(owningPathSegList, _points4.x, _points4.y, _points4.x1, _points4.y1); + } + + case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_ABS: + { + var _points5 = { + x1: this._parseNumber(), + y1: this._parseNumber(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegCurvetoQuadraticAbs(owningPathSegList, _points5.x, _points5.y, _points5.x1, _points5.y1); + } + + case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_REL: + return new SVGPathSegCurvetoQuadraticSmoothRel(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_CURVETO_QUADRATIC_SMOOTH_ABS: + return new SVGPathSegCurvetoQuadraticSmoothAbs(owningPathSegList, this._parseNumber(), this._parseNumber()); + + case SVGPathSeg.PATHSEG_ARC_REL: + { + var _points6 = { + x1: this._parseNumber(), + y1: this._parseNumber(), + arcAngle: this._parseNumber(), + arcLarge: this._parseArcFlag(), + arcSweep: this._parseArcFlag(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegArcRel(owningPathSegList, _points6.x, _points6.y, _points6.x1, _points6.y1, _points6.arcAngle, _points6.arcLarge, _points6.arcSweep); + } + + case SVGPathSeg.PATHSEG_ARC_ABS: + { + var _points7 = { + x1: this._parseNumber(), + y1: this._parseNumber(), + arcAngle: this._parseNumber(), + arcLarge: this._parseArcFlag(), + arcSweep: this._parseArcFlag(), + x: this._parseNumber(), + y: this._parseNumber() + }; + return new SVGPathSegArcAbs(owningPathSegList, _points7.x, _points7.y, _points7.x1, _points7.y1, _points7.arcAngle, _points7.arcLarge, _points7.arcSweep); + } + + default: + throw new Error('Unknown path seg type.'); + } + } + }]); + + return Source; + }(); + + var builder = new Builder(); + var source = new Source(string); + + if (!source.initialCommandIsMoveTo()) { + return []; + } + + while (source.hasMoreData()) { + var pathSeg = source.parseSegment(); + + if (!pathSeg) { + return []; + } + + builder.appendSegment(pathSeg); + } + + return builder.pathSegList; + } // STATIC + + }], [{ + key: "_pathSegArrayAsString", + value: function _pathSegArrayAsString(pathSegArray) { + var string = ''; + var first = true; + pathSegArray.forEach(function (pathSeg) { + if (first) { + first = false; + string += pathSeg._asPathString(); + } else { + string += ' ' + pathSeg._asPathString(); + } + }); + return string; + } + }]); + + return SVGPathSegList; + }(); + + SVGPathSegList.prototype.classname = 'SVGPathSegList'; + Object.defineProperty(SVGPathSegList.prototype, 'numberOfItems', { + get: function get() { + this._checkPathSynchronizedToList(); + + return this._list.length; + }, + enumerable: true + }); // Add the pathSegList accessors to SVGPathElement. + // Spec: https://www.w3.org/TR/SVG11/single-page.html#paths-InterfaceSVGAnimatedPathData + + Object.defineProperties(SVGPathElement.prototype, { + pathSegList: { + get: function get() { + if (!this._pathSegList) { + this._pathSegList = new SVGPathSegList(this); + } + + return this._pathSegList; + }, + enumerable: true + }, + // TODO: The following are not implemented and simply return SVGPathElement.pathSegList. + normalizedPathSegList: { + get: function get() { + return this.pathSegList; + }, + enumerable: true + }, + animatedPathSegList: { + get: function get() { + return this.pathSegList; + }, + enumerable: true + }, + animatedNormalizedPathSegList: { + get: function get() { + return this.pathSegList; + }, + enumerable: true + } + }); + window.SVGPathSegList = SVGPathSegList; + } + })(); + + // The button toggles whether the path is open or closed + + var extClosepath = exports('default', { + name: 'closepath', + init: function init(_ref) { + var _this = this; + + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var importLocale, $, strings, svgEditor, selElems, updateButton, showPanel, toggleClosed, buttons; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + importLocale = _ref.importLocale, $ = _ref.$; + _context.next = 3; + return importLocale(); + + case 3: + strings = _context.sent; + svgEditor = _this; + + updateButton = function updateButton(path) { + var seglist = path.pathSegList, + closed = seglist.getItem(seglist.numberOfItems - 1).pathSegType === 1, + showbutton = closed ? '#tool_openpath' : '#tool_closepath', + hidebutton = closed ? '#tool_closepath' : '#tool_openpath'; + $(hidebutton).hide(); + $(showbutton).show(); + }; + + showPanel = function showPanel(on) { + $('#closepath_panel').toggle(on); + + if (on) { + var path = selElems[0]; + + if (path) { + updateButton(path); + } + } + }; + + toggleClosed = function toggleClosed() { + var path = selElems[0]; + + if (path) { + var seglist = path.pathSegList, + last = seglist.numberOfItems - 1; // is closed + + if (seglist.getItem(last).pathSegType === 1) { + seglist.removeItem(last); + } else { + seglist.appendItem(path.createSVGPathSegClosePath()); + } + + updateButton(path); + } + }; + + buttons = [{ + id: 'tool_openpath', + icon: svgEditor.curConfig.extIconsPath + 'openpath.png', + type: 'context', + panel: 'closepath_panel', + events: { + click: function click() { + toggleClosed(); + } + } + }, { + id: 'tool_closepath', + icon: svgEditor.curConfig.extIconsPath + 'closepath.png', + type: 'context', + panel: 'closepath_panel', + events: { + click: function click() { + toggleClosed(); + } + } + }]; + return _context.abrupt("return", { + name: strings.name, + svgicons: svgEditor.curConfig.extIconsPath + 'closepath_icons.svg', + buttons: strings.buttons.map(function (button, i) { + return Object.assign(buttons[i], button); + }), + callback: function callback() { + $('#closepath_panel').hide(); + }, + selectedChanged: function selectedChanged(opts) { + selElems = opts.elems; + var i = selElems.length; + + while (i--) { + var elem = selElems[i]; + + if (elem && elem.tagName === 'path') { + if (opts.selectedElement && !opts.multiselected) { + showPanel(true); + } else { + showPanel(false); + } + } else { + showPanel(false); + } + } + } + }); + + case 10: + case "end": + return _context.stop(); + } + } + }, _callee); + }))(); + } + }); + + } + }; +}); diff --git a/dist/editor/system/extensions/ext-connector.js b/dist/editor/system/extensions/ext-connector.js new file mode 100644 index 00000000..c4b256a9 --- /dev/null +++ b/dist/editor/system/extensions/ext-connector.js @@ -0,0 +1,2306 @@ +System.register([], function (exports) { + 'use strict'; + return { + execute: function () { + + function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); + } + + var REACT_ELEMENT_TYPE; + + function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; + } + + function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); + } + + function _AwaitValue(value) { + this.wrapped = value; + } + + function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } + } + + if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; + } + + _AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); + }; + + _AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); + }; + + _AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); + }; + + function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; + } + + function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); + } + + function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; + } + + function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } + } + + function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; + } + + function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; + } + + function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; + } + + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; + } + + function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); + } + + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; + } + + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; + } + + function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); + } + + function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); + } + + function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); + } + + function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } + } + + function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); + } + + function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; + } + + function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); + } + + function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } + } + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; + } + + function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; + } + + function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } + } + + function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); + } + + function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; + } + + function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; + } + + function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); + } + + function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; + } + + function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; + } + + function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); + } + + function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); + } + + function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; + } + + function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); + } + + function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; + } + + function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); + } + + function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); + } + + function _temporalUndefined() {} + + function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); + } + + function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; + } + + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); + } + + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + + function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); + } + + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); + } + + function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; + } + + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; + } + + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; + } + + function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); + } + + function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; + } + + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); + } + + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); + } + + function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); + } + + function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); + } + + function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; + } + + var id = 0; + + function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; + } + + function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; + } + + function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } + } + + function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; + } + + function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); + } + + function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); + } + + function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; + } + + function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; + } + + function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } + } + + function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; + } + + function _hasDecorators(element) { + return element.decorators && element.decorators.length; + } + + function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); + } + + function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; + } + + function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; + } + + function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); + } + + function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); + } + + /** + * @file ext-connector.js + * + * @license MIT + * + * @copyright 2010 Alexis Deveria + * + */ + var extConnector = exports('default', { + name: 'connector', + init: function init(S) { + var _this = this; + + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var svgEditor, svgCanvas, getElem, $, svgroot, importLocale, addElem, selManager, connSel, elData, strings, startX, startY, curLine, startElem, endElem, seNs, svgcontent, started, connections, selElems, getBBintersect, getOffset, showPanel, setPoint, updateLine, findConnectors, updateConnectors, init, buttons; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + init = function _init() { + // Make sure all connectors have data set + $(svgcontent).find('*').each(function () { + var conn = this.getAttributeNS(seNs, 'connector'); + + if (conn) { + this.setAttribute('class', connSel.substr(1)); + var connData = conn.split(' '); + var sbb = svgCanvas.getStrokedBBox([getElem(connData[0])]); + var ebb = svgCanvas.getStrokedBBox([getElem(connData[1])]); + $(this).data('c_start', connData[0]).data('c_end', connData[1]).data('start_bb', sbb).data('end_bb', ebb); + svgCanvas.getEditorNS(true); + } + }); // updateConnectors(); + }; + + updateConnectors = function _updateConnectors(elems) { + // Updates connector lines based on selected elements + // Is not used on mousemove, as it runs getStrokedBBox every time, + // which isn't necessary there. + findConnectors(elems); + + if (connections.length) { + // Update line with element + var i = connections.length; + + while (i--) { + var conn = connections[i]; + var line = conn.connector; + var elem = conn.elem; // const sw = line.getAttribute('stroke-width') * 5; + + var pre = conn.is_start ? 'start' : 'end'; // Update bbox for this element + + var bb = svgCanvas.getStrokedBBox([elem]); + bb.x = conn.start_x; + bb.y = conn.start_y; + elData(line, pre + '_bb', bb); + /* const addOffset = */ + + elData(line, pre + '_off'); + var altPre = conn.is_start ? 'end' : 'start'; // Get center pt of connected element + + var bb2 = elData(line, altPre + '_bb'); + var srcX = bb2.x + bb2.width / 2; + var srcY = bb2.y + bb2.height / 2; // Set point of element being moved + + var pt = getBBintersect(srcX, srcY, bb, getOffset(pre, line)); + setPoint(line, conn.is_start ? 0 : 'end', pt.x, pt.y, true); // Set point of connected element + + var pt2 = getBBintersect(pt.x, pt.y, elData(line, altPre + '_bb'), getOffset(altPre, line)); + setPoint(line, conn.is_start ? 'end' : 0, pt2.x, pt2.y, true); // Update points attribute manually for webkit + + if (navigator.userAgent.includes('AppleWebKit')) { + var pts = line.points; + var len = pts.numberOfItems; + var ptArr = []; + + for (var j = 0; j < len; j++) { + pt = pts.getItem(j); + ptArr[j] = pt.x + ',' + pt.y; + } + + line.setAttribute('points', ptArr.join(' ')); + } + } + } + }; + + findConnectors = function _findConnectors() { + var elems = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : selElems; + var connectors = $(svgcontent).find(connSel); + connections = []; // Loop through connectors to see if one is connected to the element + + connectors.each(function () { + var addThis; + /** + * + * @returns {void} + */ + + function add() { + if (elems.includes(this)) { + // Pretend this element is selected + addThis = true; + } + } // Grab the ends + + + var parts = []; + ['start', 'end'].forEach(function (pos, i) { + var key = 'c_' + pos; + var part = elData(this, key); + + if (part === null || part === undefined) { + // Does this ever return nullish values? + part = document.getElementById(this.attributes['se:connector'].value.split(' ')[i]); + elData(this, 'c_' + pos, part.id); + elData(this, pos + '_bb', svgCanvas.getStrokedBBox([part])); + } else part = document.getElementById(part); + + parts.push(part); + }, this); + + for (var i = 0; i < 2; i++) { + var cElem = parts[i]; + addThis = false; // The connected element might be part of a selected group + + $(cElem).parents().each(add); + + if (!cElem || !cElem.parentNode) { + $(this).remove(); + continue; + } + + if (elems.includes(cElem) || addThis) { + var bb = svgCanvas.getStrokedBBox([cElem]); + connections.push({ + elem: cElem, + connector: this, + is_start: i === 0, + start_x: bb.x, + start_y: bb.y + }); + } + } + }); + }; + + updateLine = function _updateLine(diffX, diffY) { + // Update line with element + var i = connections.length; + + while (i--) { + var conn = connections[i]; + var line = conn.connector; // const {elem} = conn; + + var pre = conn.is_start ? 'start' : 'end'; // const sw = line.getAttribute('stroke-width') * 5; + // Update bbox for this element + + var bb = elData(line, pre + '_bb'); + bb.x = conn.start_x + diffX; + bb.y = conn.start_y + diffY; + elData(line, pre + '_bb', bb); + var altPre = conn.is_start ? 'end' : 'start'; // Get center pt of connected element + + var bb2 = elData(line, altPre + '_bb'); + var srcX = bb2.x + bb2.width / 2; + var srcY = bb2.y + bb2.height / 2; // Set point of element being moved + + var pt = getBBintersect(srcX, srcY, bb, getOffset(pre, line)); // $(line).data(pre+'_off')?sw:0 + + setPoint(line, conn.is_start ? 0 : 'end', pt.x, pt.y, true); // Set point of connected element + + var pt2 = getBBintersect(pt.x, pt.y, elData(line, altPre + '_bb'), getOffset(altPre, line)); + setPoint(line, conn.is_start ? 'end' : 0, pt2.x, pt2.y, true); + } + }; + + setPoint = function _setPoint(elem, pos, x, y, setMid) { + var pts = elem.points; + var pt = svgroot.createSVGPoint(); + pt.x = x; + pt.y = y; + + if (pos === 'end') { + pos = pts.numberOfItems - 1; + } // TODO: Test for this on init, then use alt only if needed + + + try { + pts.replaceItem(pt, pos); + } catch (err) { + // Should only occur in FF which formats points attr as "n,n n,n", so just split + var ptArr = elem.getAttribute('points').split(' '); + + for (var i = 0; i < ptArr.length; i++) { + if (i === pos) { + ptArr[i] = x + ',' + y; + } + } + + elem.setAttribute('points', ptArr.join(' ')); + } + + if (setMid) { + // Add center point + var ptStart = pts.getItem(0); + var ptEnd = pts.getItem(pts.numberOfItems - 1); + setPoint(elem, 1, (ptEnd.x + ptStart.x) / 2, (ptEnd.y + ptStart.y) / 2); + } + }; + + showPanel = function _showPanel(on) { + var connRules = $('#connector_rules'); + + if (!connRules.length) { + connRules = $('').appendTo('head'); + } + + connRules.text(!on ? '' : '#tool_clone, #tool_topath, #tool_angle, #xy_panel { display: none !important; }'); + $('#connector_panel').toggle(on); + }; + + getOffset = function _getOffset(side, line) { + var giveOffset = line.getAttribute('marker-' + side); // const giveOffset = $(line).data(side+'_off'); + // TODO: Make this number (5) be based on marker width/height + + var size = line.getAttribute('stroke-width') * 5; + return giveOffset ? size : 0; + }; + + getBBintersect = function _getBBintersect(x, y, bb, offset) { + if (offset) { + offset -= 0; + bb = $.extend({}, bb); + bb.width += offset; + bb.height += offset; + bb.x -= offset / 2; + bb.y -= offset / 2; + } + + var midX = bb.x + bb.width / 2; + var midY = bb.y + bb.height / 2; + var lenX = x - midX; + var lenY = y - midY; + var slope = Math.abs(lenY / lenX); + var ratio; + + if (slope < bb.height / bb.width) { + ratio = bb.width / 2 / Math.abs(lenX); + } else { + ratio = lenY ? bb.height / 2 / Math.abs(lenY) : 0; + } + + return { + x: midX + lenX * ratio, + y: midY + lenY * ratio + }; + }; + + svgEditor = _this; + svgCanvas = svgEditor.canvas; + getElem = svgCanvas.getElem; + $ = S.$, svgroot = S.svgroot, importLocale = S.importLocale, addElem = svgCanvas.addSVGElementFromJson, selManager = S.selectorManager, connSel = '.se_connector', elData = $.data; + _context.next = 14; + return importLocale(); + + case 14: + strings = _context.sent; + svgcontent = S.svgcontent, started = false, connections = [], selElems = []; + /** + * + * @param {Float} x + * @param {Float} y + * @param {module:utilities.BBoxObject} bb + * @param {Float} offset + * @returns {module:math.XYObject} + */ + + // Do once + (function () { + var gse = svgCanvas.groupSelectedElements; + + svgCanvas.groupSelectedElements = function () { + svgCanvas.removeFromSelection($(connSel).toArray()); + + for (var _len = arguments.length, args = new Array(_len), _key = 0; _key < _len; _key++) { + args[_key] = arguments[_key]; + } + + return gse.apply(this, args); + }; + + var mse = svgCanvas.moveSelectedElements; + + svgCanvas.moveSelectedElements = function () { + for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) { + args[_key2] = arguments[_key2]; + } + + var cmd = mse.apply(this, args); + updateConnectors(); + return cmd; + }; + + seNs = svgCanvas.getEditorNS(); + })(); + /** + * Do on reset. + * @returns {void} + */ + + + // $(svgroot).parent().mousemove(function (e) { + // // if (started + // // || svgCanvas.getMode() !== 'connector' + // // || e.target.parentNode.parentNode !== svgcontent) return; + // + // console.log('y') + // // if (e.target.parentNode.parentNode === svgcontent) { + // // + // // } + // }); + buttons = [{ + id: 'mode_connect', + type: 'mode', + icon: svgEditor.curConfig.imgPath + 'cut.png', + includeWith: { + button: '#tool_line', + isDefault: false, + position: 1 + }, + events: { + click: function click() { + svgCanvas.setMode('connector'); + } + } + }]; + return _context.abrupt("return", { + name: strings.name, + svgicons: svgEditor.curConfig.imgPath + 'conn.svg', + buttons: strings.buttons.map(function (button, i) { + return Object.assign(buttons[i], button); + }), + + /* async */ + addLangData: function addLangData(_ref) { + var lang = _ref.lang; + // , importLocale: importLoc + return { + data: strings.langList + }; + }, + mouseDown: function mouseDown(opts) { + var e = opts.event; + startX = opts.start_x; + startY = opts.start_y; + var mode = svgCanvas.getMode(); + var initStroke = svgEditor.curConfig.initStroke; + + if (mode === 'connector') { + if (started) { + return undefined; + } + + var mouseTarget = e.target; + var parents = $(mouseTarget).parents(); + + if ($.inArray(svgcontent, parents) !== -1) { + // Connectable element + // If child of foreignObject, use parent + var fo = $(mouseTarget).closest('foreignObject'); + startElem = fo.length ? fo[0] : mouseTarget; // Get center of source element + + var bb = svgCanvas.getStrokedBBox([startElem]); + var x = bb.x + bb.width / 2; + var y = bb.y + bb.height / 2; + started = true; + curLine = addElem({ + element: 'polyline', + attr: { + id: svgCanvas.getNextId(), + points: x + ',' + y + ' ' + x + ',' + y + ' ' + startX + ',' + startY, + stroke: '#' + initStroke.color, + 'stroke-width': !startElem.stroke_width || startElem.stroke_width === 0 ? initStroke.width : startElem.stroke_width, + fill: 'none', + opacity: initStroke.opacity, + style: 'pointer-events:none' + } + }); + elData(curLine, 'start_bb', bb); + } + + return { + started: true + }; + } + + if (mode === 'select') { + findConnectors(); + } + + return undefined; + }, + mouseMove: function mouseMove(opts) { + var zoom = svgCanvas.getZoom(); // const e = opts.event; + + var x = opts.mouse_x / zoom; + var y = opts.mouse_y / zoom; + var diffX = x - startX, + diffY = y - startY; + var mode = svgCanvas.getMode(); + + if (mode === 'connector' && started) { + // const sw = curLine.getAttribute('stroke-width') * 3; + // Set start point (adjusts based on bb) + var pt = getBBintersect(x, y, elData(curLine, 'start_bb'), getOffset('start', curLine)); + startX = pt.x; + startY = pt.y; + setPoint(curLine, 0, pt.x, pt.y, true); // Set end point + + setPoint(curLine, 'end', x, y, true); + } else if (mode === 'select') { + var slen = selElems.length; + + while (slen--) { + var elem = selElems[slen]; // Look for selected connector elements + + if (elem && elData(elem, 'c_start')) { + // Remove the "translate" transform given to move + svgCanvas.removeFromSelection([elem]); + svgCanvas.getTransformList(elem).clear(); + } + } + + if (connections.length) { + updateLine(diffX, diffY); + } + } + }, + mouseUp: function mouseUp(opts) { + // const zoom = svgCanvas.getZoom(); + var e = opts.event; // , x = opts.mouse_x / zoom, + // , y = opts.mouse_y / zoom, + + var mouseTarget = e.target; + + if (svgCanvas.getMode() !== 'connector') { + return undefined; + } + + var fo = $(mouseTarget).closest('foreignObject'); + + if (fo.length) { + mouseTarget = fo[0]; + } + + var parents = $(mouseTarget).parents(); + + if (mouseTarget === startElem) { + // Start line through click + started = true; + return { + keep: true, + element: null, + started: started + }; + } + + if ($.inArray(svgcontent, parents) === -1) { + // Not a valid target element, so remove line + $(curLine).remove(); + started = false; + return { + keep: false, + element: null, + started: started + }; + } // Valid end element + + + endElem = mouseTarget; + var startId = startElem.id, + endId = endElem.id; + var connStr = startId + ' ' + endId; + var altStr = endId + ' ' + startId; // Don't create connector if one already exists + + var dupe = $(svgcontent).find(connSel).filter(function () { + var conn = this.getAttributeNS(seNs, 'connector'); + + if (conn === connStr || conn === altStr) { + return true; + } + + return false; + }); + + if (dupe.length) { + $(curLine).remove(); + return { + keep: false, + element: null, + started: false + }; + } + + var bb = svgCanvas.getStrokedBBox([endElem]); + var pt = getBBintersect(startX, startY, bb, getOffset('start', curLine)); + setPoint(curLine, 'end', pt.x, pt.y, true); + $(curLine).data('c_start', startId).data('c_end', endId).data('end_bb', bb); + seNs = svgCanvas.getEditorNS(true); + curLine.setAttributeNS(seNs, 'se:connector', connStr); + curLine.setAttribute('class', connSel.substr(1)); + curLine.setAttribute('opacity', 1); + svgCanvas.addToSelection([curLine]); + svgCanvas.moveToBottomSelectedElement(); + selManager.requestSelector(curLine).showGrips(false); + started = false; + return { + keep: true, + element: curLine, + started: started + }; + }, + selectedChanged: function selectedChanged(opts) { + // TODO: Find better way to skip operations if no connectors are in use + if (!$(svgcontent).find(connSel).length) { + return; + } + + if (svgCanvas.getMode() === 'connector') { + svgCanvas.setMode('select'); + } // Use this to update the current selected elements + + + selElems = opts.elems; + var i = selElems.length; + + while (i--) { + var elem = selElems[i]; + + if (elem && elData(elem, 'c_start')) { + selManager.requestSelector(elem).showGrips(false); + + if (opts.selectedElement && !opts.multiselected) { + // TODO: Set up context tools and hide most regular line tools + showPanel(true); + } else { + showPanel(false); + } + } else { + showPanel(false); + } + } + + updateConnectors(); + }, + elementChanged: function elementChanged(opts) { + var elem = opts.elems[0]; + if (!elem) return; + + if (elem.tagName === 'svg' && elem.id === 'svgcontent') { + // Update svgcontent (can change on import) + svgcontent = elem; + init(); + } // Has marker, so change offset + + + if (elem.getAttribute('marker-start') || elem.getAttribute('marker-mid') || elem.getAttribute('marker-end')) { + var start = elem.getAttribute('marker-start'); + var mid = elem.getAttribute('marker-mid'); + var end = elem.getAttribute('marker-end'); + curLine = elem; + $(elem).data('start_off', Boolean(start)).data('end_off', Boolean(end)); + + if (elem.tagName === 'line' && mid) { + // Convert to polyline to accept mid-arrow + var x1 = Number(elem.getAttribute('x1')); + var x2 = Number(elem.getAttribute('x2')); + var y1 = Number(elem.getAttribute('y1')); + var y2 = Number(elem.getAttribute('y2')); + var _elem = elem, + id = _elem.id; + var midPt = ' ' + (x1 + x2) / 2 + ',' + (y1 + y2) / 2 + ' '; + var pline = addElem({ + element: 'polyline', + attr: { + points: x1 + ',' + y1 + midPt + x2 + ',' + y2, + stroke: elem.getAttribute('stroke'), + 'stroke-width': elem.getAttribute('stroke-width'), + 'marker-mid': mid, + fill: 'none', + opacity: elem.getAttribute('opacity') || 1 + } + }); + $(elem).after(pline).remove(); + svgCanvas.clearSelection(); + pline.id = id; + svgCanvas.addToSelection([pline]); + elem = pline; + } + } // Update line if it's a connector + + + if (elem.getAttribute('class') === connSel.substr(1)) { + var _start = getElem(elData(elem, 'c_start')); + + updateConnectors([_start]); + } else { + updateConnectors(); + } + }, + IDsUpdated: function IDsUpdated(input) { + var remove = []; + input.elems.forEach(function (elem) { + if ('se:connector' in elem.attr) { + elem.attr['se:connector'] = elem.attr['se:connector'].split(' ').map(function (oldID) { + return input.changes[oldID]; + }).join(' '); // Check validity - the field would be something like 'svg_21 svg_22', but + // if one end is missing, it would be 'svg_21' and therefore fail this test + + if (!/. ./.test(elem.attr['se:connector'])) { + remove.push(elem.attr.id); + } + } + }); + return { + remove: remove + }; + }, + toolButtonStateUpdate: function toolButtonStateUpdate(opts) { + if (opts.nostroke) { + if ($('#mode_connect').hasClass('tool_button_current')) { + svgEditor.clickSelect(); + } + } + + $('#mode_connect').toggleClass('disabled', opts.nostroke); + } + }); + + case 19: + case "end": + return _context.stop(); + } + } + }, _callee); + }))(); + } + }); + + } + }; +}); diff --git a/dist/editor/system/extensions/ext-eyedropper.js b/dist/editor/system/extensions/ext-eyedropper.js new file mode 100644 index 00000000..6feb707d --- /dev/null +++ b/dist/editor/system/extensions/ext-eyedropper.js @@ -0,0 +1,1816 @@ +System.register([], function (exports) { + 'use strict'; + return { + execute: function () { + + function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); + } + + var REACT_ELEMENT_TYPE; + + function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; + } + + function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); + } + + function _AwaitValue(value) { + this.wrapped = value; + } + + function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } + } + + if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; + } + + _AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); + }; + + _AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); + }; + + _AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); + }; + + function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; + } + + function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); + } + + function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; + } + + function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } + } + + function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; + } + + function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; + } + + function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; + } + + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; + } + + function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); + } + + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; + } + + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; + } + + function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); + } + + function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); + } + + function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); + } + + function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } + } + + function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); + } + + function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; + } + + function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); + } + + function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } + } + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; + } + + function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; + } + + function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } + } + + function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); + } + + function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; + } + + function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; + } + + function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); + } + + function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; + } + + function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; + } + + function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); + } + + function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); + } + + function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; + } + + function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); + } + + function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; + } + + function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); + } + + function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); + } + + function _temporalUndefined() {} + + function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); + } + + function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; + } + + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); + } + + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + + function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); + } + + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); + } + + function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; + } + + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; + } + + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; + } + + function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); + } + + function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; + } + + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); + } + + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); + } + + function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); + } + + function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); + } + + function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; + } + + var id = 0; + + function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; + } + + function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; + } + + function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } + } + + function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; + } + + function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); + } + + function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); + } + + function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; + } + + function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; + } + + function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } + } + + function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; + } + + function _hasDecorators(element) { + return element.decorators && element.decorators.length; + } + + function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); + } + + function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; + } + + function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; + } + + function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); + } + + function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); + } + + /** + * @file ext-eyedropper.js + * + * @license MIT + * + * @copyright 2010 Jeff Schiller + * + */ + var extEyedropper = exports('default', { + name: 'eyedropper', + init: function init(S) { + var _this = this; + + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var strings, svgEditor, $, ChangeElementCommand, svgCanvas, addToHistory, currentStyle, getStyle, buttons; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + getStyle = function _getStyle(opts) { + // if we are in eyedropper mode, we don't want to disable the eye-dropper tool + var mode = svgCanvas.getMode(); + + if (mode === 'eyedropper') { + return; + } + + var tool = $('#tool_eyedropper'); // enable-eye-dropper if one element is selected + + var elem = null; + + if (!opts.multiselected && opts.elems[0] && !['svg', 'g', 'use'].includes(opts.elems[0].nodeName)) { + elem = opts.elems[0]; + tool.removeClass('disabled'); // grab the current style + + currentStyle.fillPaint = elem.getAttribute('fill') || 'black'; + currentStyle.fillOpacity = elem.getAttribute('fill-opacity') || 1.0; + currentStyle.strokePaint = elem.getAttribute('stroke'); + currentStyle.strokeOpacity = elem.getAttribute('stroke-opacity') || 1.0; + currentStyle.strokeWidth = elem.getAttribute('stroke-width'); + currentStyle.strokeDashArray = elem.getAttribute('stroke-dasharray'); + currentStyle.strokeLinecap = elem.getAttribute('stroke-linecap'); + currentStyle.strokeLinejoin = elem.getAttribute('stroke-linejoin'); + currentStyle.opacity = elem.getAttribute('opacity') || 1.0; // disable eye-dropper tool + } else { + tool.addClass('disabled'); + } + }; + + _context.next = 3; + return S.importLocale(); + + case 3: + strings = _context.sent; + svgEditor = _this; + $ = S.$, ChangeElementCommand = S.ChangeElementCommand, svgCanvas = svgEditor.canvas, addToHistory = function addToHistory(cmd) { + svgCanvas.undoMgr.addCommandToHistory(cmd); + }, currentStyle = { + fillPaint: 'red', + fillOpacity: 1.0, + strokePaint: 'black', + strokeOpacity: 1.0, + strokeWidth: 5, + strokeDashArray: null, + opacity: 1.0, + strokeLinecap: 'butt', + strokeLinejoin: 'miter' + }; + /** + * + * @param {module:svgcanvas.SvgCanvas#event:ext_selectedChanged|module:svgcanvas.SvgCanvas#event:ext_elementChanged} opts + * @returns {void} + */ + + buttons = [{ + id: 'tool_eyedropper', + icon: svgEditor.curConfig.extIconsPath + 'eyedropper.png', + type: 'mode', + events: { + click: function click() { + svgCanvas.setMode('eyedropper'); + } + } + }]; + return _context.abrupt("return", { + name: strings.name, + svgicons: svgEditor.curConfig.extIconsPath + 'eyedropper-icon.xml', + buttons: strings.buttons.map(function (button, i) { + return Object.assign(buttons[i], button); + }), + // if we have selected an element, grab its paint and enable the eye dropper button + selectedChanged: getStyle, + elementChanged: getStyle, + mouseDown: function mouseDown(opts) { + var mode = svgCanvas.getMode(); + + if (mode === 'eyedropper') { + var e = opts.event; + var target = e.target; + + if (!['svg', 'g', 'use'].includes(target.nodeName)) { + var changes = {}; + + var change = function change(elem, attrname, newvalue) { + changes[attrname] = elem.getAttribute(attrname); + elem.setAttribute(attrname, newvalue); + }; + + if (currentStyle.fillPaint) { + change(target, 'fill', currentStyle.fillPaint); + } + + if (currentStyle.fillOpacity) { + change(target, 'fill-opacity', currentStyle.fillOpacity); + } + + if (currentStyle.strokePaint) { + change(target, 'stroke', currentStyle.strokePaint); + } + + if (currentStyle.strokeOpacity) { + change(target, 'stroke-opacity', currentStyle.strokeOpacity); + } + + if (currentStyle.strokeWidth) { + change(target, 'stroke-width', currentStyle.strokeWidth); + } + + if (currentStyle.strokeDashArray) { + change(target, 'stroke-dasharray', currentStyle.strokeDashArray); + } + + if (currentStyle.opacity) { + change(target, 'opacity', currentStyle.opacity); + } + + if (currentStyle.strokeLinecap) { + change(target, 'stroke-linecap', currentStyle.strokeLinecap); + } + + if (currentStyle.strokeLinejoin) { + change(target, 'stroke-linejoin', currentStyle.strokeLinejoin); + } + + addToHistory(new ChangeElementCommand(target, changes)); + } + } + } + }); + + case 8: + case "end": + return _context.stop(); + } + } + }, _callee); + }))(); + } + }); + + } + }; +}); diff --git a/dist/editor/system/extensions/ext-foreignobject.js b/dist/editor/system/extensions/ext-foreignobject.js new file mode 100644 index 00000000..892ce44b --- /dev/null +++ b/dist/editor/system/extensions/ext-foreignobject.js @@ -0,0 +1,1977 @@ +System.register([], function (exports) { + 'use strict'; + return { + execute: function () { + + function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); + } + + var REACT_ELEMENT_TYPE; + + function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; + } + + function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); + } + + function _AwaitValue(value) { + this.wrapped = value; + } + + function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } + } + + if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; + } + + _AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); + }; + + _AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); + }; + + _AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); + }; + + function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; + } + + function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); + } + + function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; + } + + function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } + } + + function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; + } + + function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; + } + + function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; + } + + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; + } + + function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); + } + + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; + } + + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; + } + + function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); + } + + function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); + } + + function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); + } + + function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } + } + + function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); + } + + function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; + } + + function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); + } + + function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } + } + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; + } + + function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; + } + + function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } + } + + function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); + } + + function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; + } + + function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; + } + + function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); + } + + function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; + } + + function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; + } + + function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); + } + + function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); + } + + function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; + } + + function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); + } + + function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; + } + + function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); + } + + function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); + } + + function _temporalUndefined() {} + + function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); + } + + function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; + } + + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); + } + + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + + function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); + } + + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); + } + + function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; + } + + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; + } + + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; + } + + function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); + } + + function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; + } + + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); + } + + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); + } + + function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); + } + + function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); + } + + function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; + } + + var id = 0; + + function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; + } + + function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; + } + + function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } + } + + function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; + } + + function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); + } + + function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); + } + + function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; + } + + function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; + } + + function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } + } + + function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; + } + + function _hasDecorators(element) { + return element.decorators && element.decorators.length; + } + + function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); + } + + function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; + } + + function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; + } + + function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); + } + + function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); + } + + /** + * @file ext-foreignobject.js + * + * @license Apache-2.0 + * + * @copyright 2010 Jacques Distler, 2010 Alexis Deveria + * + */ + var extForeignobject = exports('default', { + name: 'foreignobject', + init: function init(S) { + var _this = this; + + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() { + var svgEditor, $, text2xml, NS, importLocale, svgCanvas, svgdoc, strings, properlySourceSizeTextArea, showPanel, toggleSourceButtons, selElems, started, newFO, editingforeign, setForeignString, showForeignEditor, setAttr, buttons, contextTools; + return regeneratorRuntime.wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + setAttr = function _setAttr(attr, val) { + svgCanvas.changeSelectedAttribute(attr, val); + svgCanvas.call('changed', selElems); + }; + + showForeignEditor = function _showForeignEditor() { + var elt = selElems[0]; + + if (!elt || editingforeign) { + return; + } + + editingforeign = true; + toggleSourceButtons(true); + elt.removeAttribute('fill'); + var str = svgCanvas.svgToString(elt, 0); + $('#svg_source_textarea').val(str); + $('#svg_source_editor').fadeIn(); + properlySourceSizeTextArea(); + $('#svg_source_textarea').focus(); + }; + + setForeignString = function _setForeignString(xmlString) { + var elt = selElems[0]; // The parent `Element` to append to + + try { + // convert string into XML document + var newDoc = text2xml('' + xmlString + ''); // run it through our sanitizer to remove anything we do not support + + svgCanvas.sanitizeSvg(newDoc.documentElement); + elt.replaceWith(svgdoc.importNode(newDoc.documentElement.firstChild, true)); + svgCanvas.call('changed', [elt]); + svgCanvas.clearSelection(); + } catch (e) { + // Todo: Surface error to user + console.log(e); // eslint-disable-line no-console + + return false; + } + + return true; + }; + + toggleSourceButtons = function _toggleSourceButtons(on) { + $('#tool_source_save, #tool_source_cancel').toggle(!on); + $('#foreign_save, #foreign_cancel').toggle(on); + }; + + showPanel = function _showPanel(on) { + var fcRules = $('#fc_rules'); + + if (!fcRules.length) { + fcRules = $('').appendTo('head'); + } + + fcRules.text(!on ? '' : ' #tool_topath { display: none !important; }'); + $('#foreignObject_panel').toggle(on); + }; + + svgEditor = _this; + $ = S.$, text2xml = S.text2xml, NS = S.NS, importLocale = S.importLocale; + svgCanvas = svgEditor.canvas; + svgdoc = S.svgroot.parentNode.ownerDocument; + _context2.next = 11; + return importLocale(); + + case 11: + strings = _context2.sent; + + properlySourceSizeTextArea = function properlySourceSizeTextArea() { + // TODO: remove magic numbers here and get values from CSS + var height = $('#svg_source_container').height() - 80; + $('#svg_source_textarea').css('height', height); + }; + /** + * @param {boolean} on + * @returns {void} + */ + + + editingforeign = false; + /** + * This function sets the content of element elt to the input XML. + * @param {string} xmlString - The XML text + * @returns {boolean} This function returns false if the set was unsuccessful, true otherwise. + */ + + buttons = [{ + id: 'tool_foreign', + icon: svgEditor.curConfig.extIconsPath + 'foreignobject-tool.png', + type: 'mode', + events: { + click: function click() { + svgCanvas.setMode('foreign'); + } + } + }, { + id: 'edit_foreign', + icon: svgEditor.curConfig.extIconsPath + 'foreignobject-edit.png', + type: 'context', + panel: 'foreignObject_panel', + events: { + click: function click() { + showForeignEditor(); + } + } + }]; + contextTools = [{ + type: 'input', + panel: 'foreignObject_panel', + id: 'foreign_width', + size: 3, + events: { + change: function change() { + setAttr('width', this.value); + } + } + }, { + type: 'input', + panel: 'foreignObject_panel', + id: 'foreign_height', + events: { + change: function change() { + setAttr('height', this.value); + } + } + }, { + type: 'input', + panel: 'foreignObject_panel', + id: 'foreign_font_size', + size: 2, + defval: 16, + events: { + change: function change() { + setAttr('font-size', this.value); + } + } + }]; + return _context2.abrupt("return", { + name: strings.name, + svgicons: svgEditor.curConfig.extIconsPath + 'foreignobject-icons.xml', + buttons: strings.buttons.map(function (button, i) { + return Object.assign(buttons[i], button); + }), + context_tools: strings.contextTools.map(function (contextTool, i) { + return Object.assign(contextTools[i], contextTool); + }), + callback: function callback() { + $('#foreignObject_panel').hide(); + + var endChanges = function endChanges() { + $('#svg_source_editor').hide(); + editingforeign = false; + $('#svg_source_textarea').blur(); + toggleSourceButtons(false); + }; // TODO: Needs to be done after orig icon loads + + + setTimeout(function () { + // Create source save/cancel buttons + + /* const save = */ + $('#tool_source_save').clone().hide().attr('id', 'foreign_save').unbind().appendTo('#tool_source_back').click( /*#__PURE__*/_asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var ok; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + if (editingforeign) { + _context.next = 2; + break; + } + + return _context.abrupt("return"); + + case 2: + if (setForeignString($('#svg_source_textarea').val())) { + _context.next = 11; + break; + } + + _context.next = 5; + return $.confirm('Errors found. Revert to original?'); + + case 5: + ok = _context.sent; + + if (ok) { + _context.next = 8; + break; + } + + return _context.abrupt("return"); + + case 8: + endChanges(); + _context.next = 12; + break; + + case 11: + endChanges(); + + case 12: + case "end": + return _context.stop(); + } + } + }, _callee); + }))); + /* const cancel = */ + + $('#tool_source_cancel').clone().hide().attr('id', 'foreign_cancel').unbind().appendTo('#tool_source_back').click(function () { + endChanges(); + }); + }, 3000); + }, + mouseDown: function mouseDown(opts) { + // const e = opts.event; + if (svgCanvas.getMode() !== 'foreign') { + return undefined; + } + + started = true; + newFO = svgCanvas.addSVGElementFromJson({ + element: 'foreignObject', + attr: { + x: opts.start_x, + y: opts.start_y, + id: svgCanvas.getNextId(), + 'font-size': 16, + // cur_text.font_size, + width: '48', + height: '20', + style: 'pointer-events:inherit' + } + }); + var m = svgdoc.createElementNS(NS.MATH, 'math'); + m.setAttributeNS(NS.XMLNS, 'xmlns', NS.MATH); + m.setAttribute('display', 'inline'); + var mi = svgdoc.createElementNS(NS.MATH, 'mi'); + mi.setAttribute('mathvariant', 'normal'); + mi.textContent = "\u03A6"; + var mo = svgdoc.createElementNS(NS.MATH, 'mo'); + mo.textContent = "\u222A"; + var mi2 = svgdoc.createElementNS(NS.MATH, 'mi'); + mi2.textContent = "\u2133"; + m.append(mi, mo, mi2); + newFO.append(m); + return { + started: true + }; + }, + mouseUp: function mouseUp(opts) { + // const e = opts.event; + if (svgCanvas.getMode() !== 'foreign' || !started) { + return undefined; + } + + var attrs = $(newFO).attr(['width', 'height']); + var keep = attrs.width !== '0' || attrs.height !== '0'; + svgCanvas.addToSelection([newFO], true); + return { + keep: keep, + element: newFO + }; + }, + selectedChanged: function selectedChanged(opts) { + // Use this to update the current selected elements + selElems = opts.elems; + var i = selElems.length; + + while (i--) { + var elem = selElems[i]; + + if (elem && elem.tagName === 'foreignObject') { + if (opts.selectedElement && !opts.multiselected) { + $('#foreign_font_size').val(elem.getAttribute('font-size')); + $('#foreign_width').val(elem.getAttribute('width')); + $('#foreign_height').val(elem.getAttribute('height')); + showPanel(true); + } else { + showPanel(false); + } + } else { + showPanel(false); + } + } + }, + elementChanged: function elementChanged(opts) {// const elem = opts.elems[0]; + } + }); + + case 17: + case "end": + return _context2.stop(); + } + } + }, _callee2); + }))(); + } + }); + + } + }; +}); diff --git a/dist/editor/system/extensions/ext-grid.js b/dist/editor/system/extensions/ext-grid.js new file mode 100644 index 00000000..ed231468 --- /dev/null +++ b/dist/editor/system/extensions/ext-grid.js @@ -0,0 +1,1836 @@ +System.register([], function (exports) { + 'use strict'; + return { + execute: function () { + + function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); + } + + var REACT_ELEMENT_TYPE; + + function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; + } + + function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); + } + + function _AwaitValue(value) { + this.wrapped = value; + } + + function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } + } + + if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; + } + + _AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); + }; + + _AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); + }; + + _AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); + }; + + function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; + } + + function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); + } + + function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; + } + + function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } + } + + function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; + } + + function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; + } + + function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; + } + + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; + } + + function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); + } + + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; + } + + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; + } + + function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); + } + + function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); + } + + function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); + } + + function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } + } + + function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); + } + + function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; + } + + function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); + } + + function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } + } + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; + } + + function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; + } + + function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } + } + + function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); + } + + function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; + } + + function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; + } + + function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); + } + + function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; + } + + function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; + } + + function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); + } + + function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); + } + + function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; + } + + function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); + } + + function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; + } + + function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); + } + + function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); + } + + function _temporalUndefined() {} + + function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); + } + + function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; + } + + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); + } + + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + + function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); + } + + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); + } + + function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; + } + + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; + } + + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; + } + + function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); + } + + function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; + } + + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); + } + + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); + } + + function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); + } + + function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); + } + + function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; + } + + var id = 0; + + function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; + } + + function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; + } + + function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } + } + + function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; + } + + function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); + } + + function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); + } + + function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; + } + + function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; + } + + function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } + } + + function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; + } + + function _hasDecorators(element) { + return element.decorators && element.decorators.length; + } + + function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); + } + + function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; + } + + function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; + } + + function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); + } + + function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); + } + + /** + * @file ext-grid.js + * + * @license Apache-2.0 + * + * @copyright 2010 Redou Mine, 2010 Alexis Deveria + * + */ + var extGrid = exports('default', { + name: 'grid', + init: function init(_ref) { + var _this = this; + + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var $, NS, getTypeMap, importLocale, strings, svgEditor, svgCanvas, svgdoc, assignAttributes, hcanvas, canvBG, units, intervals, showGrid, canvasGrid, gridDefs, gridPattern, gridimg, gridBox, updateGrid, gridUpdate, buttons; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + gridUpdate = function _gridUpdate() { + if (showGrid) { + updateGrid(svgCanvas.getZoom()); + } + + $('#canvasGrid').toggle(showGrid); + $('#view_grid').toggleClass('push_button_pressed tool_button'); + }; + + updateGrid = function _updateGrid(zoom) { + // TODO: Try this with elements, then compare performance difference + var unit = units[svgEditor.curConfig.baseUnit]; // 1 = 1px + + var uMulti = unit * zoom; // Calculate the main number interval + + var rawM = 100 / uMulti; + var multi = 1; + intervals.some(function (num) { + multi = num; + return rawM <= num; + }); + var bigInt = multi * uMulti; // Set the canvas size to the width of the container + + hcanvas.width = bigInt; + hcanvas.height = bigInt; + var ctx = hcanvas.getContext('2d'); + var curD = 0.5; + var part = bigInt / 10; + ctx.globalAlpha = 0.2; + ctx.strokeStyle = svgEditor.curConfig.gridColor; + + for (var i = 1; i < 10; i++) { + var subD = Math.round(part * i) + 0.5; // const lineNum = (i % 2)?12:10; + + var lineNum = 0; + ctx.moveTo(subD, bigInt); + ctx.lineTo(subD, lineNum); + ctx.moveTo(bigInt, subD); + ctx.lineTo(lineNum, subD); + } + + ctx.stroke(); + ctx.beginPath(); + ctx.globalAlpha = 0.5; + ctx.moveTo(curD, bigInt); + ctx.lineTo(curD, 0); + ctx.moveTo(bigInt, curD); + ctx.lineTo(0, curD); + ctx.stroke(); + var datauri = hcanvas.toDataURL('image/png'); + gridimg.setAttribute('width', bigInt); + gridimg.setAttribute('height', bigInt); + gridimg.parentNode.setAttribute('width', bigInt); + gridimg.parentNode.setAttribute('height', bigInt); + svgCanvas.setHref(gridimg, datauri); + }; + + $ = _ref.$, NS = _ref.NS, getTypeMap = _ref.getTypeMap, importLocale = _ref.importLocale; + _context.next = 5; + return importLocale(); + + case 5: + strings = _context.sent; + svgEditor = _this; + svgCanvas = svgEditor.canvas; + svgdoc = document.getElementById('svgcanvas').ownerDocument, assignAttributes = svgCanvas.assignAttributes, hcanvas = document.createElement('canvas'), canvBG = $('#canvasBackground'), units = getTypeMap(), intervals = [0.01, 0.1, 1, 10, 100, 1000]; + showGrid = svgEditor.curConfig.showGrid || false; + $(hcanvas).hide().appendTo('body'); + canvasGrid = svgdoc.createElementNS(NS.SVG, 'svg'); + assignAttributes(canvasGrid, { + id: 'canvasGrid', + width: '100%', + height: '100%', + x: 0, + y: 0, + overflow: 'visible', + display: 'none' + }); + canvBG.append(canvasGrid); + gridDefs = svgdoc.createElementNS(NS.SVG, 'defs'); // grid-pattern + + gridPattern = svgdoc.createElementNS(NS.SVG, 'pattern'); + assignAttributes(gridPattern, { + id: 'gridpattern', + patternUnits: 'userSpaceOnUse', + x: 0, + // -(value.strokeWidth / 2), // position for strokewidth + y: 0, + // -(value.strokeWidth / 2), // position for strokewidth + width: 100, + height: 100 + }); + gridimg = svgdoc.createElementNS(NS.SVG, 'image'); + assignAttributes(gridimg, { + x: 0, + y: 0, + width: 100, + height: 100 + }); + gridPattern.append(gridimg); + gridDefs.append(gridPattern); + $('#canvasGrid').append(gridDefs); // grid-box + + gridBox = svgdoc.createElementNS(NS.SVG, 'rect'); + assignAttributes(gridBox, { + width: '100%', + height: '100%', + x: 0, + y: 0, + 'stroke-width': 0, + stroke: 'none', + fill: 'url(#gridpattern)', + style: 'pointer-events: none; display:visible;' + }); + $('#canvasGrid').append(gridBox); + /** + * + * @param {Float} zoom + * @returns {void} + */ + + buttons = [{ + id: 'view_grid', + icon: svgEditor.curConfig.extIconsPath + 'grid.png', + type: 'context', + panel: 'editor_panel', + events: { + click: function click() { + svgEditor.curConfig.showGrid = showGrid = !showGrid; + gridUpdate(); + } + } + }]; + return _context.abrupt("return", { + name: strings.name, + svgicons: svgEditor.curConfig.extIconsPath + 'grid-icon.xml', + zoomChanged: function zoomChanged(zoom) { + if (showGrid) { + updateGrid(zoom); + } + }, + callback: function callback() { + if (showGrid) { + gridUpdate(); + } + }, + buttons: strings.buttons.map(function (button, i) { + return Object.assign(buttons[i], button); + }) + }); + + case 27: + case "end": + return _context.stop(); + } + } + }, _callee); + }))(); + } + }); + + } + }; +}); diff --git a/dist/editor/system/extensions/ext-helloworld.js b/dist/editor/system/extensions/ext-helloworld.js new file mode 100644 index 00000000..14f91994 --- /dev/null +++ b/dist/editor/system/extensions/ext-helloworld.js @@ -0,0 +1,1763 @@ +System.register([], function (exports) { + 'use strict'; + return { + execute: function () { + + function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); + } + + var REACT_ELEMENT_TYPE; + + function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; + } + + function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); + } + + function _AwaitValue(value) { + this.wrapped = value; + } + + function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } + } + + if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; + } + + _AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); + }; + + _AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); + }; + + _AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); + }; + + function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; + } + + function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); + } + + function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; + } + + function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } + } + + function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; + } + + function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; + } + + function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; + } + + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; + } + + function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); + } + + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; + } + + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; + } + + function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); + } + + function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); + } + + function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); + } + + function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } + } + + function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); + } + + function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; + } + + function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); + } + + function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } + } + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; + } + + function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; + } + + function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } + } + + function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); + } + + function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; + } + + function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; + } + + function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); + } + + function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; + } + + function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; + } + + function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); + } + + function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); + } + + function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; + } + + function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); + } + + function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; + } + + function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); + } + + function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); + } + + function _temporalUndefined() {} + + function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); + } + + function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; + } + + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); + } + + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + + function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); + } + + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); + } + + function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; + } + + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; + } + + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; + } + + function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); + } + + function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; + } + + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); + } + + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); + } + + function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); + } + + function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); + } + + function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; + } + + var id = 0; + + function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; + } + + function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; + } + + function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } + } + + function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; + } + + function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); + } + + function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); + } + + function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; + } + + function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; + } + + function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } + } + + function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; + } + + function _hasDecorators(element) { + return element.decorators && element.decorators.length; + } + + function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); + } + + function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; + } + + function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; + } + + function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); + } + + function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); + } + + /** + * @file ext-helloworld.js + * + * @license MIT + * + * @copyright 2010 Alexis Deveria + * + */ + + /** + * This is a very basic SVG-Edit extension. It adds a "Hello World" button in + * the left ("mode") panel. Clicking on the button, and then the canvas + * will show the user the point on the canvas that was clicked on. + */ + var extHelloworld = exports('default', { + name: 'helloworld', + init: function init(_ref) { + var _this = this; + + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee() { + var $, importLocale, strings, svgEditor, svgCanvas; + return regeneratorRuntime.wrap(function _callee$(_context) { + while (1) { + switch (_context.prev = _context.next) { + case 0: + $ = _ref.$, importLocale = _ref.importLocale; + _context.next = 3; + return importLocale(); + + case 3: + strings = _context.sent; + svgEditor = _this; + svgCanvas = svgEditor.canvas; + return _context.abrupt("return", { + name: strings.name, + // For more notes on how to make an icon file, see the source of + // the helloworld-icon.xml + svgicons: svgEditor.curConfig.extIconsPath + 'helloworld-icon.xml', + // Multiple buttons can be added in this array + buttons: [{ + // Must match the icon ID in helloworld-icon.xml + id: 'hello_world', + // Fallback, e.g., for `file:///` access + icon: svgEditor.curConfig.extIconsPath + 'helloworld.png', + // This indicates that the button will be added to the "mode" + // button panel on the left side + type: 'mode', + // Tooltip text + title: strings.buttons[0].title, + // Events + events: { + click: function click() { + // The action taken when the button is clicked on. + // For "mode" buttons, any other button will + // automatically be de-pressed. + svgCanvas.setMode('hello_world'); + } + } + }], + // This is triggered when the main mouse button is pressed down + // on the editor canvas (not the tool panels) + mouseDown: function mouseDown() { + // Check the mode on mousedown + if (svgCanvas.getMode() === 'hello_world') { + // The returned object must include "started" with + // a value of true in order for mouseUp to be triggered + return { + started: true + }; + } + + return undefined; + }, + // This is triggered from anywhere, but "started" must have been set + // to true (see above). Note that "opts" is an object with event info + mouseUp: function mouseUp(opts) { + // Check the mode on mouseup + if (svgCanvas.getMode() === 'hello_world') { + var zoom = svgCanvas.getZoom(); // Get the actual coordinate by dividing by the zoom value + + var x = opts.mouse_x / zoom; + var y = opts.mouse_y / zoom; // We do our own formatting + + var text = strings.text; + [['x', x], ['y', y]].forEach(function (_ref2) { + var _ref3 = _slicedToArray(_ref2, 2), + prop = _ref3[0], + val = _ref3[1]; + + text = text.replace('{' + prop + '}', val); + }); // Show the text using the custom alert function + + $.alert(text); + } + } + }); + + case 7: + case "end": + return _context.stop(); + } + } + }, _callee); + }))(); + } + }); + + } + }; +}); diff --git a/dist/editor/system/extensions/ext-imagelib.js b/dist/editor/system/extensions/ext-imagelib.js new file mode 100644 index 00000000..8e38b496 --- /dev/null +++ b/dist/editor/system/extensions/ext-imagelib.js @@ -0,0 +1,2182 @@ +System.register([], function (exports) { + 'use strict'; + return { + execute: function () { + + function _typeof(obj) { + "@babel/helpers - typeof"; + + if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { + _typeof = function (obj) { + return typeof obj; + }; + } else { + _typeof = function (obj) { + return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; + }; + } + + return _typeof(obj); + } + + var REACT_ELEMENT_TYPE; + + function _jsx(type, props, key, children) { + if (!REACT_ELEMENT_TYPE) { + REACT_ELEMENT_TYPE = typeof Symbol === "function" && Symbol["for"] && Symbol["for"]("react.element") || 0xeac7; + } + + var defaultProps = type && type.defaultProps; + var childrenLength = arguments.length - 3; + + if (!props && childrenLength !== 0) { + props = { + children: void 0 + }; + } + + if (childrenLength === 1) { + props.children = children; + } else if (childrenLength > 1) { + var childArray = new Array(childrenLength); + + for (var i = 0; i < childrenLength; i++) { + childArray[i] = arguments[i + 3]; + } + + props.children = childArray; + } + + if (props && defaultProps) { + for (var propName in defaultProps) { + if (props[propName] === void 0) { + props[propName] = defaultProps[propName]; + } + } + } else if (!props) { + props = defaultProps || {}; + } + + return { + $$typeof: REACT_ELEMENT_TYPE, + type: type, + key: key === undefined ? null : '' + key, + ref: null, + props: props, + _owner: null + }; + } + + function _asyncIterator(iterable) { + var method; + + if (typeof Symbol !== "undefined") { + if (Symbol.asyncIterator) { + method = iterable[Symbol.asyncIterator]; + if (method != null) return method.call(iterable); + } + + if (Symbol.iterator) { + method = iterable[Symbol.iterator]; + if (method != null) return method.call(iterable); + } + } + + throw new TypeError("Object is not async iterable"); + } + + function _AwaitValue(value) { + this.wrapped = value; + } + + function _AsyncGenerator(gen) { + var front, back; + + function send(key, arg) { + return new Promise(function (resolve, reject) { + var request = { + key: key, + arg: arg, + resolve: resolve, + reject: reject, + next: null + }; + + if (back) { + back = back.next = request; + } else { + front = back = request; + resume(key, arg); + } + }); + } + + function resume(key, arg) { + try { + var result = gen[key](arg); + var value = result.value; + var wrappedAwait = value instanceof _AwaitValue; + Promise.resolve(wrappedAwait ? value.wrapped : value).then(function (arg) { + if (wrappedAwait) { + resume(key === "return" ? "return" : "next", arg); + return; + } + + settle(result.done ? "return" : "normal", arg); + }, function (err) { + resume("throw", err); + }); + } catch (err) { + settle("throw", err); + } + } + + function settle(type, value) { + switch (type) { + case "return": + front.resolve({ + value: value, + done: true + }); + break; + + case "throw": + front.reject(value); + break; + + default: + front.resolve({ + value: value, + done: false + }); + break; + } + + front = front.next; + + if (front) { + resume(front.key, front.arg); + } else { + back = null; + } + } + + this._invoke = send; + + if (typeof gen.return !== "function") { + this.return = undefined; + } + } + + if (typeof Symbol === "function" && Symbol.asyncIterator) { + _AsyncGenerator.prototype[Symbol.asyncIterator] = function () { + return this; + }; + } + + _AsyncGenerator.prototype.next = function (arg) { + return this._invoke("next", arg); + }; + + _AsyncGenerator.prototype.throw = function (arg) { + return this._invoke("throw", arg); + }; + + _AsyncGenerator.prototype.return = function (arg) { + return this._invoke("return", arg); + }; + + function _wrapAsyncGenerator(fn) { + return function () { + return new _AsyncGenerator(fn.apply(this, arguments)); + }; + } + + function _awaitAsyncGenerator(value) { + return new _AwaitValue(value); + } + + function _asyncGeneratorDelegate(inner, awaitWrap) { + var iter = {}, + waiting = false; + + function pump(key, value) { + waiting = true; + value = new Promise(function (resolve) { + resolve(inner[key](value)); + }); + return { + done: false, + value: awaitWrap(value) + }; + } + + ; + + if (typeof Symbol === "function" && Symbol.iterator) { + iter[Symbol.iterator] = function () { + return this; + }; + } + + iter.next = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("next", value); + }; + + if (typeof inner.throw === "function") { + iter.throw = function (value) { + if (waiting) { + waiting = false; + throw value; + } + + return pump("throw", value); + }; + } + + if (typeof inner.return === "function") { + iter.return = function (value) { + if (waiting) { + waiting = false; + return value; + } + + return pump("return", value); + }; + } + + return iter; + } + + function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) { + try { + var info = gen[key](arg); + var value = info.value; + } catch (error) { + reject(error); + return; + } + + if (info.done) { + resolve(value); + } else { + Promise.resolve(value).then(_next, _throw); + } + } + + function _asyncToGenerator(fn) { + return function () { + var self = this, + args = arguments; + return new Promise(function (resolve, reject) { + var gen = fn.apply(self, args); + + function _next(value) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value); + } + + function _throw(err) { + asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err); + } + + _next(undefined); + }); + }; + } + + function _classCallCheck(instance, Constructor) { + if (!(instance instanceof Constructor)) { + throw new TypeError("Cannot call a class as a function"); + } + } + + function _defineProperties(target, props) { + for (var i = 0; i < props.length; i++) { + var descriptor = props[i]; + descriptor.enumerable = descriptor.enumerable || false; + descriptor.configurable = true; + if ("value" in descriptor) descriptor.writable = true; + Object.defineProperty(target, descriptor.key, descriptor); + } + } + + function _createClass(Constructor, protoProps, staticProps) { + if (protoProps) _defineProperties(Constructor.prototype, protoProps); + if (staticProps) _defineProperties(Constructor, staticProps); + return Constructor; + } + + function _defineEnumerableProperties(obj, descs) { + for (var key in descs) { + var desc = descs[key]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, key, desc); + } + + if (Object.getOwnPropertySymbols) { + var objectSymbols = Object.getOwnPropertySymbols(descs); + + for (var i = 0; i < objectSymbols.length; i++) { + var sym = objectSymbols[i]; + var desc = descs[sym]; + desc.configurable = desc.enumerable = true; + if ("value" in desc) desc.writable = true; + Object.defineProperty(obj, sym, desc); + } + } + + return obj; + } + + function _defaults(obj, defaults) { + var keys = Object.getOwnPropertyNames(defaults); + + for (var i = 0; i < keys.length; i++) { + var key = keys[i]; + var value = Object.getOwnPropertyDescriptor(defaults, key); + + if (value && value.configurable && obj[key] === undefined) { + Object.defineProperty(obj, key, value); + } + } + + return obj; + } + + function _defineProperty(obj, key, value) { + if (key in obj) { + Object.defineProperty(obj, key, { + value: value, + enumerable: true, + configurable: true, + writable: true + }); + } else { + obj[key] = value; + } + + return obj; + } + + function _extends() { + _extends = Object.assign || function (target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i]; + + for (var key in source) { + if (Object.prototype.hasOwnProperty.call(source, key)) { + target[key] = source[key]; + } + } + } + + return target; + }; + + return _extends.apply(this, arguments); + } + + function _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? Object(arguments[i]) : {}; + var ownKeys = Object.keys(source); + + if (typeof Object.getOwnPropertySymbols === 'function') { + ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) { + return Object.getOwnPropertyDescriptor(source, sym).enumerable; + })); + } + + ownKeys.forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } + + return target; + } + + function ownKeys(object, enumerableOnly) { + var keys = Object.keys(object); + + if (Object.getOwnPropertySymbols) { + var symbols = Object.getOwnPropertySymbols(object); + if (enumerableOnly) symbols = symbols.filter(function (sym) { + return Object.getOwnPropertyDescriptor(object, sym).enumerable; + }); + keys.push.apply(keys, symbols); + } + + return keys; + } + + function _objectSpread2(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? arguments[i] : {}; + + if (i % 2) { + ownKeys(Object(source), true).forEach(function (key) { + _defineProperty(target, key, source[key]); + }); + } else if (Object.getOwnPropertyDescriptors) { + Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); + } else { + ownKeys(Object(source)).forEach(function (key) { + Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); + }); + } + } + + return target; + } + + function _inherits(subClass, superClass) { + if (typeof superClass !== "function" && superClass !== null) { + throw new TypeError("Super expression must either be null or a function"); + } + + subClass.prototype = Object.create(superClass && superClass.prototype, { + constructor: { + value: subClass, + writable: true, + configurable: true + } + }); + if (superClass) _setPrototypeOf(subClass, superClass); + } + + function _inheritsLoose(subClass, superClass) { + subClass.prototype = Object.create(superClass.prototype); + subClass.prototype.constructor = subClass; + subClass.__proto__ = superClass; + } + + function _getPrototypeOf(o) { + _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { + return o.__proto__ || Object.getPrototypeOf(o); + }; + return _getPrototypeOf(o); + } + + function _setPrototypeOf(o, p) { + _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { + o.__proto__ = p; + return o; + }; + + return _setPrototypeOf(o, p); + } + + function _isNativeReflectConstruct() { + if (typeof Reflect === "undefined" || !Reflect.construct) return false; + if (Reflect.construct.sham) return false; + if (typeof Proxy === "function") return true; + + try { + Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); + return true; + } catch (e) { + return false; + } + } + + function _construct(Parent, args, Class) { + if (_isNativeReflectConstruct()) { + _construct = Reflect.construct; + } else { + _construct = function _construct(Parent, args, Class) { + var a = [null]; + a.push.apply(a, args); + var Constructor = Function.bind.apply(Parent, a); + var instance = new Constructor(); + if (Class) _setPrototypeOf(instance, Class.prototype); + return instance; + }; + } + + return _construct.apply(null, arguments); + } + + function _isNativeFunction(fn) { + return Function.toString.call(fn).indexOf("[native code]") !== -1; + } + + function _wrapNativeSuper(Class) { + var _cache = typeof Map === "function" ? new Map() : undefined; + + _wrapNativeSuper = function _wrapNativeSuper(Class) { + if (Class === null || !_isNativeFunction(Class)) return Class; + + if (typeof Class !== "function") { + throw new TypeError("Super expression must either be null or a function"); + } + + if (typeof _cache !== "undefined") { + if (_cache.has(Class)) return _cache.get(Class); + + _cache.set(Class, Wrapper); + } + + function Wrapper() { + return _construct(Class, arguments, _getPrototypeOf(this).constructor); + } + + Wrapper.prototype = Object.create(Class.prototype, { + constructor: { + value: Wrapper, + enumerable: false, + writable: true, + configurable: true + } + }); + return _setPrototypeOf(Wrapper, Class); + }; + + return _wrapNativeSuper(Class); + } + + function _instanceof(left, right) { + if (right != null && typeof Symbol !== "undefined" && right[Symbol.hasInstance]) { + return !!right[Symbol.hasInstance](left); + } else { + return left instanceof right; + } + } + + function _interopRequireDefault(obj) { + return obj && obj.__esModule ? obj : { + default: obj + }; + } + + function _getRequireWildcardCache() { + if (typeof WeakMap !== "function") return null; + var cache = new WeakMap(); + + _getRequireWildcardCache = function () { + return cache; + }; + + return cache; + } + + function _interopRequireWildcard(obj) { + if (obj && obj.__esModule) { + return obj; + } + + if (obj === null || typeof obj !== "object" && typeof obj !== "function") { + return { + default: obj + }; + } + + var cache = _getRequireWildcardCache(); + + if (cache && cache.has(obj)) { + return cache.get(obj); + } + + var newObj = {}; + var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; + + for (var key in obj) { + if (Object.prototype.hasOwnProperty.call(obj, key)) { + var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; + + if (desc && (desc.get || desc.set)) { + Object.defineProperty(newObj, key, desc); + } else { + newObj[key] = obj[key]; + } + } + } + + newObj.default = obj; + + if (cache) { + cache.set(obj, newObj); + } + + return newObj; + } + + function _newArrowCheck(innerThis, boundThis) { + if (innerThis !== boundThis) { + throw new TypeError("Cannot instantiate an arrow function"); + } + } + + function _objectDestructuringEmpty(obj) { + if (obj == null) throw new TypeError("Cannot destructure undefined"); + } + + function _objectWithoutPropertiesLoose(source, excluded) { + if (source == null) return {}; + var target = {}; + var sourceKeys = Object.keys(source); + var key, i; + + for (i = 0; i < sourceKeys.length; i++) { + key = sourceKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + target[key] = source[key]; + } + + return target; + } + + function _objectWithoutProperties(source, excluded) { + if (source == null) return {}; + + var target = _objectWithoutPropertiesLoose(source, excluded); + + var key, i; + + if (Object.getOwnPropertySymbols) { + var sourceSymbolKeys = Object.getOwnPropertySymbols(source); + + for (i = 0; i < sourceSymbolKeys.length; i++) { + key = sourceSymbolKeys[i]; + if (excluded.indexOf(key) >= 0) continue; + if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; + target[key] = source[key]; + } + } + + return target; + } + + function _assertThisInitialized(self) { + if (self === void 0) { + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + } + + return self; + } + + function _possibleConstructorReturn(self, call) { + if (call && (typeof call === "object" || typeof call === "function")) { + return call; + } + + return _assertThisInitialized(self); + } + + function _createSuper(Derived) { + var hasNativeReflectConstruct = _isNativeReflectConstruct(); + + return function _createSuperInternal() { + var Super = _getPrototypeOf(Derived), + result; + + if (hasNativeReflectConstruct) { + var NewTarget = _getPrototypeOf(this).constructor; + + result = Reflect.construct(Super, arguments, NewTarget); + } else { + result = Super.apply(this, arguments); + } + + return _possibleConstructorReturn(this, result); + }; + } + + function _superPropBase(object, property) { + while (!Object.prototype.hasOwnProperty.call(object, property)) { + object = _getPrototypeOf(object); + if (object === null) break; + } + + return object; + } + + function _get(target, property, receiver) { + if (typeof Reflect !== "undefined" && Reflect.get) { + _get = Reflect.get; + } else { + _get = function _get(target, property, receiver) { + var base = _superPropBase(target, property); + + if (!base) return; + var desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.get) { + return desc.get.call(receiver); + } + + return desc.value; + }; + } + + return _get(target, property, receiver || target); + } + + function set(target, property, value, receiver) { + if (typeof Reflect !== "undefined" && Reflect.set) { + set = Reflect.set; + } else { + set = function set(target, property, value, receiver) { + var base = _superPropBase(target, property); + + var desc; + + if (base) { + desc = Object.getOwnPropertyDescriptor(base, property); + + if (desc.set) { + desc.set.call(receiver, value); + return true; + } else if (!desc.writable) { + return false; + } + } + + desc = Object.getOwnPropertyDescriptor(receiver, property); + + if (desc) { + if (!desc.writable) { + return false; + } + + desc.value = value; + Object.defineProperty(receiver, property, desc); + } else { + _defineProperty(receiver, property, value); + } + + return true; + }; + } + + return set(target, property, value, receiver); + } + + function _set(target, property, value, receiver, isStrict) { + var s = set(target, property, value, receiver || target); + + if (!s && isStrict) { + throw new Error('failed to set property'); + } + + return value; + } + + function _taggedTemplateLiteral(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + return Object.freeze(Object.defineProperties(strings, { + raw: { + value: Object.freeze(raw) + } + })); + } + + function _taggedTemplateLiteralLoose(strings, raw) { + if (!raw) { + raw = strings.slice(0); + } + + strings.raw = raw; + return strings; + } + + function _readOnlyError(name) { + throw new Error("\"" + name + "\" is read-only"); + } + + function _classNameTDZError(name) { + throw new Error("Class \"" + name + "\" cannot be referenced in computed property keys."); + } + + function _temporalUndefined() {} + + function _tdz(name) { + throw new ReferenceError(name + " is not defined - temporal dead zone"); + } + + function _temporalRef(val, name) { + return val === _temporalUndefined ? _tdz(name) : val; + } + + function _slicedToArray(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _slicedToArrayLoose(arr, i) { + return _arrayWithHoles(arr) || _iterableToArrayLimitLoose(arr, i) || _unsupportedIterableToArray(arr, i) || _nonIterableRest(); + } + + function _toArray(arr) { + return _arrayWithHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableRest(); + } + + function _toConsumableArray(arr) { + return _arrayWithoutHoles(arr) || _iterableToArray(arr) || _unsupportedIterableToArray(arr) || _nonIterableSpread(); + } + + function _arrayWithoutHoles(arr) { + if (Array.isArray(arr)) return _arrayLikeToArray(arr); + } + + function _arrayWithHoles(arr) { + if (Array.isArray(arr)) return arr; + } + + function _maybeArrayLike(next, arr, i) { + if (arr && !Array.isArray(arr) && typeof arr.length === "number") { + var len = arr.length; + return _arrayLikeToArray(arr, i !== void 0 && i < len ? i : len); + } + + return next(arr, i); + } + + function _iterableToArray(iter) { + if (typeof Symbol !== "undefined" && Symbol.iterator in Object(iter)) return Array.from(iter); + } + + function _iterableToArrayLimit(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + var _n = true; + var _d = false; + var _e = undefined; + + try { + for (var _i = arr[Symbol.iterator](), _s; !(_n = (_s = _i.next()).done); _n = true) { + _arr.push(_s.value); + + if (i && _arr.length === i) break; + } + } catch (err) { + _d = true; + _e = err; + } finally { + try { + if (!_n && _i["return"] != null) _i["return"](); + } finally { + if (_d) throw _e; + } + } + + return _arr; + } + + function _iterableToArrayLimitLoose(arr, i) { + if (typeof Symbol === "undefined" || !(Symbol.iterator in Object(arr))) return; + var _arr = []; + + for (var _iterator = arr[Symbol.iterator](), _step; !(_step = _iterator.next()).done;) { + _arr.push(_step.value); + + if (i && _arr.length === i) break; + } + + return _arr; + } + + function _unsupportedIterableToArray(o, minLen) { + if (!o) return; + if (typeof o === "string") return _arrayLikeToArray(o, minLen); + var n = Object.prototype.toString.call(o).slice(8, -1); + if (n === "Object" && o.constructor) n = o.constructor.name; + if (n === "Map" || n === "Set") return Array.from(o); + if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); + } + + function _arrayLikeToArray(arr, len) { + if (len == null || len > arr.length) len = arr.length; + + for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; + + return arr2; + } + + function _nonIterableSpread() { + throw new TypeError("Invalid attempt to spread non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _nonIterableRest() { + throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + function _createForOfIteratorHelper(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + + var F = function () {}; + + return { + s: F, + n: function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }, + e: function (e) { + throw e; + }, + f: F + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + var normalCompletion = true, + didErr = false, + err; + return { + s: function () { + it = o[Symbol.iterator](); + }, + n: function () { + var step = it.next(); + normalCompletion = step.done; + return step; + }, + e: function (e) { + didErr = true; + err = e; + }, + f: function () { + try { + if (!normalCompletion && it.return != null) it.return(); + } finally { + if (didErr) throw err; + } + } + }; + } + + function _createForOfIteratorHelperLoose(o, allowArrayLike) { + var it; + + if (typeof Symbol === "undefined" || o[Symbol.iterator] == null) { + if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { + if (it) o = it; + var i = 0; + return function () { + if (i >= o.length) return { + done: true + }; + return { + done: false, + value: o[i++] + }; + }; + } + + throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); + } + + it = o[Symbol.iterator](); + return it.next.bind(it); + } + + function _skipFirstGeneratorNext(fn) { + return function () { + var it = fn.apply(this, arguments); + it.next(); + return it; + }; + } + + function _toPrimitive(input, hint) { + if (typeof input !== "object" || input === null) return input; + var prim = input[Symbol.toPrimitive]; + + if (prim !== undefined) { + var res = prim.call(input, hint || "default"); + if (typeof res !== "object") return res; + throw new TypeError("@@toPrimitive must return a primitive value."); + } + + return (hint === "string" ? String : Number)(input); + } + + function _toPropertyKey(arg) { + var key = _toPrimitive(arg, "string"); + + return typeof key === "symbol" ? key : String(key); + } + + function _initializerWarningHelper(descriptor, context) { + throw new Error('Decorating class property failed. Please ensure that ' + 'proposal-class-properties is enabled and runs after the decorators transform.'); + } + + function _initializerDefineProperty(target, property, descriptor, context) { + if (!descriptor) return; + Object.defineProperty(target, property, { + enumerable: descriptor.enumerable, + configurable: descriptor.configurable, + writable: descriptor.writable, + value: descriptor.initializer ? descriptor.initializer.call(context) : void 0 + }); + } + + function _applyDecoratedDescriptor(target, property, decorators, descriptor, context) { + var desc = {}; + Object.keys(descriptor).forEach(function (key) { + desc[key] = descriptor[key]; + }); + desc.enumerable = !!desc.enumerable; + desc.configurable = !!desc.configurable; + + if ('value' in desc || desc.initializer) { + desc.writable = true; + } + + desc = decorators.slice().reverse().reduce(function (desc, decorator) { + return decorator(target, property, desc) || desc; + }, desc); + + if (context && desc.initializer !== void 0) { + desc.value = desc.initializer ? desc.initializer.call(context) : void 0; + desc.initializer = undefined; + } + + if (desc.initializer === void 0) { + Object.defineProperty(target, property, desc); + desc = null; + } + + return desc; + } + + var id = 0; + + function _classPrivateFieldLooseKey(name) { + return "__private_" + id++ + "_" + name; + } + + function _classPrivateFieldLooseBase(receiver, privateKey) { + if (!Object.prototype.hasOwnProperty.call(receiver, privateKey)) { + throw new TypeError("attempted to use private field on non-instance"); + } + + return receiver; + } + + function _classPrivateFieldGet(receiver, privateMap) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to get private field on non-instance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classPrivateFieldSet(receiver, privateMap, value) { + var descriptor = privateMap.get(receiver); + + if (!descriptor) { + throw new TypeError("attempted to set private field on non-instance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classPrivateFieldDestructureSet(receiver, privateMap) { + if (!privateMap.has(receiver)) { + throw new TypeError("attempted to set private field on non-instance"); + } + + var descriptor = privateMap.get(receiver); + + if (descriptor.set) { + if (!("__destrObj" in descriptor)) { + descriptor.__destrObj = { + set value(v) { + descriptor.set.call(receiver, v); + } + + }; + } + + return descriptor.__destrObj; + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + return descriptor; + } + } + + function _classStaticPrivateFieldSpecGet(receiver, classConstructor, descriptor) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.get) { + return descriptor.get.call(receiver); + } + + return descriptor.value; + } + + function _classStaticPrivateFieldSpecSet(receiver, classConstructor, descriptor, value) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + if (descriptor.set) { + descriptor.set.call(receiver, value); + } else { + if (!descriptor.writable) { + throw new TypeError("attempted to set read only private field"); + } + + descriptor.value = value; + } + + return value; + } + + function _classStaticPrivateMethodGet(receiver, classConstructor, method) { + if (receiver !== classConstructor) { + throw new TypeError("Private static access of wrong provenance"); + } + + return method; + } + + function _classStaticPrivateMethodSet() { + throw new TypeError("attempted to set read only static private field"); + } + + function _decorate(decorators, factory, superClass, mixins) { + var api = _getDecoratorsApi(); + + if (mixins) { + for (var i = 0; i < mixins.length; i++) { + api = mixins[i](api); + } + } + + var r = factory(function initialize(O) { + api.initializeInstanceElements(O, decorated.elements); + }, superClass); + var decorated = api.decorateClass(_coalesceClassElements(r.d.map(_createElementDescriptor)), decorators); + api.initializeClassElements(r.F, decorated.elements); + return api.runClassFinishers(r.F, decorated.finishers); + } + + function _getDecoratorsApi() { + _getDecoratorsApi = function () { + return api; + }; + + var api = { + elementsDefinitionOrder: [["method"], ["field"]], + initializeInstanceElements: function (O, elements) { + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + if (element.kind === kind && element.placement === "own") { + this.defineClassElement(O, element); + } + }, this); + }, this); + }, + initializeClassElements: function (F, elements) { + var proto = F.prototype; + ["method", "field"].forEach(function (kind) { + elements.forEach(function (element) { + var placement = element.placement; + + if (element.kind === kind && (placement === "static" || placement === "prototype")) { + var receiver = placement === "static" ? F : proto; + this.defineClassElement(receiver, element); + } + }, this); + }, this); + }, + defineClassElement: function (receiver, element) { + var descriptor = element.descriptor; + + if (element.kind === "field") { + var initializer = element.initializer; + descriptor = { + enumerable: descriptor.enumerable, + writable: descriptor.writable, + configurable: descriptor.configurable, + value: initializer === void 0 ? void 0 : initializer.call(receiver) + }; + } + + Object.defineProperty(receiver, element.key, descriptor); + }, + decorateClass: function (elements, decorators) { + var newElements = []; + var finishers = []; + var placements = { + static: [], + prototype: [], + own: [] + }; + elements.forEach(function (element) { + this.addElementPlacement(element, placements); + }, this); + elements.forEach(function (element) { + if (!_hasDecorators(element)) return newElements.push(element); + var elementFinishersExtras = this.decorateElement(element, placements); + newElements.push(elementFinishersExtras.element); + newElements.push.apply(newElements, elementFinishersExtras.extras); + finishers.push.apply(finishers, elementFinishersExtras.finishers); + }, this); + + if (!decorators) { + return { + elements: newElements, + finishers: finishers + }; + } + + var result = this.decorateConstructor(newElements, decorators); + finishers.push.apply(finishers, result.finishers); + result.finishers = finishers; + return result; + }, + addElementPlacement: function (element, placements, silent) { + var keys = placements[element.placement]; + + if (!silent && keys.indexOf(element.key) !== -1) { + throw new TypeError("Duplicated element (" + element.key + ")"); + } + + keys.push(element.key); + }, + decorateElement: function (element, placements) { + var extras = []; + var finishers = []; + + for (var decorators = element.decorators, i = decorators.length - 1; i >= 0; i--) { + var keys = placements[element.placement]; + keys.splice(keys.indexOf(element.key), 1); + var elementObject = this.fromElementDescriptor(element); + var elementFinisherExtras = this.toElementFinisherExtras((0, decorators[i])(elementObject) || elementObject); + element = elementFinisherExtras.element; + this.addElementPlacement(element, placements); + + if (elementFinisherExtras.finisher) { + finishers.push(elementFinisherExtras.finisher); + } + + var newExtras = elementFinisherExtras.extras; + + if (newExtras) { + for (var j = 0; j < newExtras.length; j++) { + this.addElementPlacement(newExtras[j], placements); + } + + extras.push.apply(extras, newExtras); + } + } + + return { + element: element, + finishers: finishers, + extras: extras + }; + }, + decorateConstructor: function (elements, decorators) { + var finishers = []; + + for (var i = decorators.length - 1; i >= 0; i--) { + var obj = this.fromClassDescriptor(elements); + var elementsAndFinisher = this.toClassDescriptor((0, decorators[i])(obj) || obj); + + if (elementsAndFinisher.finisher !== undefined) { + finishers.push(elementsAndFinisher.finisher); + } + + if (elementsAndFinisher.elements !== undefined) { + elements = elementsAndFinisher.elements; + + for (var j = 0; j < elements.length - 1; j++) { + for (var k = j + 1; k < elements.length; k++) { + if (elements[j].key === elements[k].key && elements[j].placement === elements[k].placement) { + throw new TypeError("Duplicated element (" + elements[j].key + ")"); + } + } + } + } + } + + return { + elements: elements, + finishers: finishers + }; + }, + fromElementDescriptor: function (element) { + var obj = { + kind: element.kind, + key: element.key, + placement: element.placement, + descriptor: element.descriptor + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + if (element.kind === "field") obj.initializer = element.initializer; + return obj; + }, + toElementDescriptors: function (elementObjects) { + if (elementObjects === undefined) return; + return _toArray(elementObjects).map(function (elementObject) { + var element = this.toElementDescriptor(elementObject); + this.disallowProperty(elementObject, "finisher", "An element descriptor"); + this.disallowProperty(elementObject, "extras", "An element descriptor"); + return element; + }, this); + }, + toElementDescriptor: function (elementObject) { + var kind = String(elementObject.kind); + + if (kind !== "method" && kind !== "field") { + throw new TypeError('An element descriptor\'s .kind property must be either "method" or' + ' "field", but a decorator created an element descriptor with' + ' .kind "' + kind + '"'); + } + + var key = _toPropertyKey(elementObject.key); + + var placement = String(elementObject.placement); + + if (placement !== "static" && placement !== "prototype" && placement !== "own") { + throw new TypeError('An element descriptor\'s .placement property must be one of "static",' + ' "prototype" or "own", but a decorator created an element descriptor' + ' with .placement "' + placement + '"'); + } + + var descriptor = elementObject.descriptor; + this.disallowProperty(elementObject, "elements", "An element descriptor"); + var element = { + kind: kind, + key: key, + placement: placement, + descriptor: Object.assign({}, descriptor) + }; + + if (kind !== "field") { + this.disallowProperty(elementObject, "initializer", "A method descriptor"); + } else { + this.disallowProperty(descriptor, "get", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "set", "The property descriptor of a field descriptor"); + this.disallowProperty(descriptor, "value", "The property descriptor of a field descriptor"); + element.initializer = elementObject.initializer; + } + + return element; + }, + toElementFinisherExtras: function (elementObject) { + var element = this.toElementDescriptor(elementObject); + + var finisher = _optionalCallableProperty(elementObject, "finisher"); + + var extras = this.toElementDescriptors(elementObject.extras); + return { + element: element, + finisher: finisher, + extras: extras + }; + }, + fromClassDescriptor: function (elements) { + var obj = { + kind: "class", + elements: elements.map(this.fromElementDescriptor, this) + }; + var desc = { + value: "Descriptor", + configurable: true + }; + Object.defineProperty(obj, Symbol.toStringTag, desc); + return obj; + }, + toClassDescriptor: function (obj) { + var kind = String(obj.kind); + + if (kind !== "class") { + throw new TypeError('A class descriptor\'s .kind property must be "class", but a decorator' + ' created a class descriptor with .kind "' + kind + '"'); + } + + this.disallowProperty(obj, "key", "A class descriptor"); + this.disallowProperty(obj, "placement", "A class descriptor"); + this.disallowProperty(obj, "descriptor", "A class descriptor"); + this.disallowProperty(obj, "initializer", "A class descriptor"); + this.disallowProperty(obj, "extras", "A class descriptor"); + + var finisher = _optionalCallableProperty(obj, "finisher"); + + var elements = this.toElementDescriptors(obj.elements); + return { + elements: elements, + finisher: finisher + }; + }, + runClassFinishers: function (constructor, finishers) { + for (var i = 0; i < finishers.length; i++) { + var newConstructor = (0, finishers[i])(constructor); + + if (newConstructor !== undefined) { + if (typeof newConstructor !== "function") { + throw new TypeError("Finishers must return a constructor."); + } + + constructor = newConstructor; + } + } + + return constructor; + }, + disallowProperty: function (obj, name, objectType) { + if (obj[name] !== undefined) { + throw new TypeError(objectType + " can't have a ." + name + " property."); + } + } + }; + return api; + } + + function _createElementDescriptor(def) { + var key = _toPropertyKey(def.key); + + var descriptor; + + if (def.kind === "method") { + descriptor = { + value: def.value, + writable: true, + configurable: true, + enumerable: false + }; + } else if (def.kind === "get") { + descriptor = { + get: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "set") { + descriptor = { + set: def.value, + configurable: true, + enumerable: false + }; + } else if (def.kind === "field") { + descriptor = { + configurable: true, + writable: true, + enumerable: true + }; + } + + var element = { + kind: def.kind === "field" ? "field" : "method", + key: key, + placement: def.static ? "static" : def.kind === "field" ? "own" : "prototype", + descriptor: descriptor + }; + if (def.decorators) element.decorators = def.decorators; + if (def.kind === "field") element.initializer = def.value; + return element; + } + + function _coalesceGetterSetter(element, other) { + if (element.descriptor.get !== undefined) { + other.descriptor.get = element.descriptor.get; + } else { + other.descriptor.set = element.descriptor.set; + } + } + + function _coalesceClassElements(elements) { + var newElements = []; + + var isSameElement = function (other) { + return other.kind === "method" && other.key === element.key && other.placement === element.placement; + }; + + for (var i = 0; i < elements.length; i++) { + var element = elements[i]; + var other; + + if (element.kind === "method" && (other = newElements.find(isSameElement))) { + if (_isDataDescriptor(element.descriptor) || _isDataDescriptor(other.descriptor)) { + if (_hasDecorators(element) || _hasDecorators(other)) { + throw new ReferenceError("Duplicated methods (" + element.key + ") can't be decorated."); + } + + other.descriptor = element.descriptor; + } else { + if (_hasDecorators(element)) { + if (_hasDecorators(other)) { + throw new ReferenceError("Decorators can't be placed on different accessors with for " + "the same property (" + element.key + ")."); + } + + other.decorators = element.decorators; + } + + _coalesceGetterSetter(element, other); + } + } else { + newElements.push(element); + } + } + + return newElements; + } + + function _hasDecorators(element) { + return element.decorators && element.decorators.length; + } + + function _isDataDescriptor(desc) { + return desc !== undefined && !(desc.value === undefined && desc.writable === undefined); + } + + function _optionalCallableProperty(obj, name) { + var value = obj[name]; + + if (value !== undefined && typeof value !== "function") { + throw new TypeError("Expected '" + name + "' to be a function"); + } + + return value; + } + + function _classPrivateMethodGet(receiver, privateSet, fn) { + if (!privateSet.has(receiver)) { + throw new TypeError("attempted to get private field on non-instance"); + } + + return fn; + } + + function _classPrivateMethodSet() { + throw new TypeError("attempted to reassign private method"); + } + + function _wrapRegExp(re, groups) { + _wrapRegExp = function (re, groups) { + return new BabelRegExp(re, undefined, groups); + }; + + var _RegExp = _wrapNativeSuper(RegExp); + + var _super = RegExp.prototype; + + var _groups = new WeakMap(); + + function BabelRegExp(re, flags, groups) { + var _this = _RegExp.call(this, re, flags); + + _groups.set(_this, groups || _groups.get(re)); + + return _this; + } + + _inherits(BabelRegExp, _RegExp); + + BabelRegExp.prototype.exec = function (str) { + var result = _super.exec.call(this, str); + + if (result) result.groups = buildGroups(result, this); + return result; + }; + + BabelRegExp.prototype[Symbol.replace] = function (str, substitution) { + if (typeof substitution === "string") { + var groups = _groups.get(this); + + return _super[Symbol.replace].call(this, str, substitution.replace(/\$<([^>]+)>/g, function (_, name) { + return "$" + groups[name]; + })); + } else if (typeof substitution === "function") { + var _this = this; + + return _super[Symbol.replace].call(this, str, function () { + var args = []; + args.push.apply(args, arguments); + + if (typeof args[args.length - 1] !== "object") { + args.push(buildGroups(args, _this)); + } + + return substitution.apply(this, args); + }); + } else { + return _super[Symbol.replace].call(this, str, substitution); + } + }; + + function buildGroups(result, re) { + var g = _groups.get(re); + + return Object.keys(g).reduce(function (groups, name) { + groups[name] = result[g[name]]; + return groups; + }, Object.create(null)); + } + + return _wrapRegExp.apply(this, arguments); + } + + /** + * @file ext-imagelib.js + * + * @license MIT + * + * @copyright 2010 Alexis Deveria + * + */ + var extImagelib = exports('default', { + name: 'imagelib', + init: function init(_ref) { + var _this = this; + + return _asyncToGenerator( /*#__PURE__*/regeneratorRuntime.mark(function _callee2() { + var $, decode64, importLocale, dropXMLInternalSubset, imagelibStrings, modularVersion, svgEditor, uiStrings, svgCanvas, extIconsPath, allowedImageLibOrigins, closeBrowser, importImage, pending, mode, multiArr, transferStopped, preview, submit, onMessage, _onMessage, toggleMulti, showBrowser, buttons; + + return regeneratorRuntime.wrap(function _callee2$(_context2) { + while (1) { + switch (_context2.prev = _context2.next) { + case 0: + showBrowser = function _showBrowser() { + var browser = $('#imgbrowse'); + + if (!browser.length) { + $('
    ' + '
    ').insertAfter('#svg_docprops'); + browser = $('#imgbrowse'); + var allLibs = imagelibStrings.select_lib; + var libOpts = $('
      ').appendTo(browser); + var frame = $('