From 20bdde3220283e4cd1db216651cfbc530b47a4f8 Mon Sep 17 00:00:00 2001 From: sanborn Date: Thu, 13 Dec 2018 13:28:13 -0500 Subject: [PATCH] Run Flare-JS in a WebWorker with an offscreencanvas The key change here is swapping in svg.js for createElementNS in order to decouple Flare-JS from the DOM. The rest is fairly straightforward. --- example/example.build.js | 23667 +++++++++++++++++++++++++++++++++ example/example.build.js.map | 1 + example/example.html | 63 +- example/example.js | 281 +- example/minion.flr | 5133 +++++++ package-lock.json | 7 +- package.json | 1 + source/PathMatrix.js | 4 +- source/Readers/JSONReader.js | 12 +- webpack.config.js | 11 +- 10 files changed, 28987 insertions(+), 193 deletions(-) create mode 100644 example/example.build.js create mode 100644 example/example.build.js.map create mode 100644 example/minion.flr diff --git a/example/example.build.js b/example/example.build.js new file mode 100644 index 0000000..f5891d0 --- /dev/null +++ b/example/example.build.js @@ -0,0 +1,23667 @@ +/******/ (function(modules) { // webpackBootstrap +/******/ // The module cache +/******/ var installedModules = {}; +/******/ +/******/ // The require function +/******/ function __webpack_require__(moduleId) { +/******/ +/******/ // Check if module is in cache +/******/ if(installedModules[moduleId]) { +/******/ return installedModules[moduleId].exports; +/******/ } +/******/ // Create a new module (and put it into the cache) +/******/ var module = installedModules[moduleId] = { +/******/ i: moduleId, +/******/ l: false, +/******/ exports: {} +/******/ }; +/******/ +/******/ // Execute the module function +/******/ modules[moduleId].call(module.exports, module, module.exports, __webpack_require__); +/******/ +/******/ // Flag the module as loaded +/******/ module.l = true; +/******/ +/******/ // Return the exports of the module +/******/ return module.exports; +/******/ } +/******/ +/******/ +/******/ // expose the modules object (__webpack_modules__) +/******/ __webpack_require__.m = modules; +/******/ +/******/ // expose the module cache +/******/ __webpack_require__.c = installedModules; +/******/ +/******/ // define getter function for harmony exports +/******/ __webpack_require__.d = function(exports, name, getter) { +/******/ if(!__webpack_require__.o(exports, name)) { +/******/ Object.defineProperty(exports, name, { enumerable: true, get: getter }); +/******/ } +/******/ }; +/******/ +/******/ // define __esModule on exports +/******/ __webpack_require__.r = function(exports) { +/******/ if(typeof Symbol !== 'undefined' && Symbol.toStringTag) { +/******/ Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' }); +/******/ } +/******/ Object.defineProperty(exports, '__esModule', { value: true }); +/******/ }; +/******/ +/******/ // create a fake namespace object +/******/ // mode & 1: value is a module id, require it +/******/ // mode & 2: merge all properties of value into the ns +/******/ // mode & 4: return value when already ns object +/******/ // mode & 8|1: behave like require +/******/ __webpack_require__.t = function(value, mode) { +/******/ if(mode & 1) value = __webpack_require__(value); +/******/ if(mode & 8) return value; +/******/ if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value; +/******/ var ns = Object.create(null); +/******/ __webpack_require__.r(ns); +/******/ Object.defineProperty(ns, 'default', { enumerable: true, value: value }); +/******/ if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key)); +/******/ return ns; +/******/ }; +/******/ +/******/ // getDefaultExport function for compatibility with non-harmony modules +/******/ __webpack_require__.n = function(module) { +/******/ var getter = module && module.__esModule ? +/******/ function getDefault() { return module['default']; } : +/******/ function getModuleExports() { return module; }; +/******/ __webpack_require__.d(getter, 'a', getter); +/******/ return getter; +/******/ }; +/******/ +/******/ // Object.prototype.hasOwnProperty.call +/******/ __webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); }; +/******/ +/******/ // __webpack_public_path__ +/******/ __webpack_require__.p = ""; +/******/ +/******/ +/******/ // Load entry module and return exports +/******/ return __webpack_require__(__webpack_require__.s = "./example/example.js"); +/******/ }) +/************************************************************************/ +/******/ ({ + +/***/ "./example/example.js": +/*!****************************!*\ + !*** ./example/example.js ***! + \****************************/ +/*! no exports provided */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + +const Flare = __webpack_require__(/*! ../source/Flare.js */ "./source/Flare.js") + +const _ViewCenter = [500.0, 500.0]; +const _Scale = 0.5; + +function FlareExample(canvas) +{ + this._Graphics = new Flare.Graphics(canvas); + this._LastAdvanceTime = Date.now(); + this._ViewTransform = gl_matrix__WEBPACK_IMPORTED_MODULE_0__["mat2d"].create(); + this._AnimationInstance = null; + this._Animation = null; + this._SoloSkaterAnimation = null; + + const _This = this; + + _ScheduleAdvance(_This); + _Advance(_This); +} + +function _Advance(_This) +{ + _ScheduleAdvance(_This); + + _This.setSize(self.innerWidth, self.innerHeight); + + const now = Date.now(); + const elapsed = (now - _This._LastAdvanceTime)/1000.0; + _This._LastAdvanceTime = now; + + const actor = _This._ActorInstance; + + if(_This._AnimationInstance) + { + const ai = _This._AnimationInstance; + ai.time = ai.time + elapsed; + ai.apply(_This._ActorInstance, 1.0); + } + + if(actor) + { + const graphics = _This._Graphics; + + const w = graphics.viewportWidth; + const h = graphics.viewportHeight; + + const vt = _This._ViewTransform; + vt[0] = _Scale; + vt[3] = _Scale; + vt[4] = (-_ViewCenter[0] * _Scale + w/2); + vt[5] = (-_ViewCenter[1] * _Scale + h/2); + + actor.advance(elapsed); + } + + _Draw(_This, _This._Graphics); +} + +let count = 0 + +setInterval(() => { + console.log(count) + + count = 0 +}, 1000) + +function _Draw(viewer, graphics) +{ + if(!viewer._Actor) + { + return; + } + + count++ + + graphics.clear([0.3628, 0.3628, 0.3628, 1.0]); + graphics.setView(viewer._ViewTransform); + viewer._ActorInstance.draw(graphics); +} + +function _ScheduleAdvance(viewer) +{ + { + self.requestAnimationFrame(function() + { + _Advance(viewer); + }); + } +} + +FlareExample.prototype.load = function(url, callback) +{ + const loader = new Flare.ActorLoader(); + const _This = this; + loader.load(url, function(actor) + { + if(!actor || actor.error) + { + callback(!actor ? null : actor.error); + } + else + { + _This.setActor(actor); + callback(); + } + }); +}; + +FlareExample.prototype.setActor = function(actor) +{ + if(this._Actor) + { + this._Actor.dispose(this._Graphics); + } + if(this._ActorInstance) + { + this._ActorInstance.dispose(this._Graphics); + } + actor.initialize(this._Graphics); + + const actorInstance = actor.makeInstance(); + actorInstance.initialize(this._Graphics); + + this._Actor = actor; + this._ActorInstance = actorInstance; + + if(actorInstance) + { + actorInstance.initialize(this._Graphics); + if(actorInstance._Animations.length) + { + this._Animation = actorInstance._Animations[0]; + this._AnimationInstance = new Flare.AnimationInstance(this._Animation._Actor, this._Animation); + + if(!this._AnimationInstance) + { + console.log("NO ANIMATION IN HERE!?"); + return; + } + + } + } +}; + +FlareExample.prototype.setSize = function(width, height) +{ + this._Graphics.setSize(width, height); +}; + +let flareExample; + +self.addEventListener("message", (event) => { + switch (event.data.type) + { + case "INIT": + /* + * Window isn't available in WW so we're getting this info + * passed from the main thread and then mocking it. IRL it + * would make sense for the app to have no refs to window. + */ + self.innerWidth = event.data.innerWidth + self.innerHeight = event.data.innerHeight + flareExample = new FlareExample(event.data.canvas); + break; + + case "LOAD": + flareExample.load(event.data.url, function (error) { + if (error) { + console.log("failed to load actor file...", error); + } + }); + break; + + case "SET_SIZE": + flareExample.setSize(event.data.width, event.data.height) + } +}); + +/***/ }), + +/***/ "./node_modules/@svgdotjs/svg.js/dist/svg.node.js": +/*!********************************************************!*\ + !*** ./node_modules/@svgdotjs/svg.js/dist/svg.node.js ***! + \********************************************************/ +/*! no static exports found */ +/***/ (function(module, exports) { + +/*! +* @svgdotjs/svg.js - A lightweight library for manipulating and animating SVG. +* @version 3.0.5 +* https://svgdotjs.github.io/ +* +* @copyright Wout Fierens +* @license MIT +* +* BUILT: Wed Dec 12 2018 23:21:54 GMT+0100 (GMT+01:00) +*/; +'use strict'; + +Object.defineProperty(exports, '__esModule', { value: true }); + +const methods = {}; +const names = []; +function registerMethods(name, m) { + if (Array.isArray(name)) { + for (let _name of name) { + registerMethods(_name, m); + } + + return; + } + + if (typeof name === 'object') { + for (let _name in name) { + registerMethods(_name, name[_name]); + } + + return; + } + + addMethodNames(Object.getOwnPropertyNames(m)); + methods[name] = Object.assign(methods[name] || {}, m); +} +function getMethodsFor(name) { + return methods[name] || {}; +} +function getMethodNames() { + return [...new Set(names)]; +} +function addMethodNames(_names) { + names.push(..._names); +} + +// Map function +function map(array, block) { + var i; + var il = array.length; + var result = []; + + for (i = 0; i < il; i++) { + result.push(block(array[i])); + } + + return result; +} // Filter function + +function filter(array, block) { + var i; + var il = array.length; + var result = []; + + for (i = 0; i < il; i++) { + if (block(array[i])) { + result.push(array[i]); + } + } + + return result; +} // Degrees to radians + +function radians(d) { + return d % 360 * Math.PI / 180; +} // Radians to degrees + +function degrees(r) { + return r * 180 / Math.PI % 360; +} // Convert dash-separated-string to camelCase + +function camelCase(s) { + return s.toLowerCase().replace(/-(.)/g, function (m, g) { + return g.toUpperCase(); + }); +} // Convert camel cased string to string seperated + +function unCamelCase(s) { + return s.replace(/([A-Z])/g, function (m, g) { + return '-' + g.toLowerCase(); + }); +} // Capitalize first letter of a string + +function capitalize(s) { + return s.charAt(0).toUpperCase() + s.slice(1); +} // Calculate proportional width and height values when necessary + +function proportionalSize(element, width, height, box) { + if (width == null || height == null) { + box = box || element.bbox(); + + if (width == null) { + width = box.width / box.height * height; + } else if (height == null) { + height = box.height / box.width * width; + } + } + + return { + width: width, + height: height + }; +} +function getOrigin(o, element) { + // Allow origin or around as the names + let origin = o.origin; // o.around == null ? o.origin : o.around + + let ox, oy; // Allow the user to pass a string to rotate around a given point + + if (typeof origin === 'string' || origin == null) { + // Get the bounding box of the element with no transformations applied + const string = (origin || 'center').toLowerCase().trim(); + const { + height, + width, + x, + y + } = element.bbox(); // Calculate the transformed x and y coordinates + + let bx = string.includes('left') ? x : string.includes('right') ? x + width : x + width / 2; + let by = string.includes('top') ? y : string.includes('bottom') ? y + height : y + height / 2; // Set the bounds eg : "bottom-left", "Top right", "middle" etc... + + ox = o.ox != null ? o.ox : bx; + oy = o.oy != null ? o.oy : by; + } else { + ox = origin[0]; + oy = origin[1]; + } // Return the origin as it is if it wasn't a string + + + return [ox, oy]; +} + +var utils = ({ + map: map, + filter: filter, + radians: radians, + degrees: degrees, + camelCase: camelCase, + unCamelCase: unCamelCase, + capitalize: capitalize, + proportionalSize: proportionalSize, + getOrigin: getOrigin +}); + +// Default namespaces +let ns = 'http://www.w3.org/2000/svg'; +let xmlns = 'http://www.w3.org/2000/xmlns/'; +let xlink = 'http://www.w3.org/1999/xlink'; +let svgjs = 'http://svgjs.com/svgjs'; + +var namespaces = ({ + ns: ns, + xmlns: xmlns, + xlink: xlink, + svgjs: svgjs +}); + +const globals = { + window: typeof window === 'undefined' ? null : window, + document: typeof document === 'undefined' ? null : document +}; +function registerWindow(win = null, doc = null) { + globals.window = win; + globals.document = doc; +} + +class Base {// constructor (node/*, {extensions = []} */) { + // // this.tags = [] + // // + // // for (let extension of extensions) { + // // extension.setup.call(this, node) + // // this.tags.push(extension.name) + // // } + // } +} + +const elements = {}; +const root = '___SYMBOL___ROOT___'; // Method for element creation + +function create(name) { + // create element + return globals.document.createElementNS(ns, name); +} +function makeInstance(element) { + if (element instanceof Base) return element; + + if (typeof element === 'object') { + return adopter(element); + } + + if (element == null) { + return new elements[root](); + } + + if (typeof element === 'string' && element.charAt(0) !== '<') { + return adopter(globals.document.querySelector(element)); + } + + var node = create('svg'); + node.innerHTML = element; // We can use firstChild here because we know, + // that the first char is < and thus an element + + element = adopter(node.firstChild); + return element; +} +function nodeOrNew(name, node) { + return node instanceof globals.window.Node ? node : create(name); +} // Adopt existing svg elements + +function adopt(node) { + // check for presence of node + if (!node) return null; // make sure a node isn't already adopted + + if (node.instance instanceof Base) return node.instance; // initialize variables + + var className = capitalize(node.nodeName || 'Dom'); // Make sure that gradients are adopted correctly + + if (className === 'LinearGradient' || className === 'RadialGradient') { + className = 'Gradient'; // Fallback to Dom if element is not known + } else if (!elements[className]) { + className = 'Dom'; + } + + return new elements[className](node); +} +let adopter = adopt; +function mockAdopt(mock = adopt) { + adopter = mock; +} +function register(element, name = element.name, asRoot = false) { + elements[name] = element; + if (asRoot) elements[root] = element; + addMethodNames(Object.getOwnPropertyNames(element.prototype)); + return element; +} +function getClass(name) { + return elements[name]; +} // Element id sequence + +let did = 1000; // Get next named element id + +function eid(name) { + return 'Svgjs' + capitalize(name) + did++; +} // Deep new id assignment + +function assignNewId(node) { + // do the same for SVG child nodes as well + for (var i = node.children.length - 1; i >= 0; i--) { + assignNewId(node.children[i]); + } + + if (node.id) { + return adopt(node).id(eid(node.nodeName)); + } + + return adopt(node); +} // Method for extending objects + +function extend(modules, methods, attrCheck) { + var key, i; + modules = Array.isArray(modules) ? modules : [modules]; + + for (i = modules.length - 1; i >= 0; i--) { + for (key in methods) { + let method = methods[key]; + + if (attrCheck) { + method = wrapWithAttrCheck(methods[key]); + } + + modules[i].prototype[key] = method; + } + } +} // export function extendWithAttrCheck (...args) { +// extend(...args, true) +// } + +function wrapWithAttrCheck(fn) { + return function (...args) { + let o = args[args.length - 1]; + + if (o && o.constructor === Object && !(o instanceof Array)) { + return fn.apply(this, args.slice(0, -1)).attr(o); + } else { + return fn.apply(this, args); + } + }; +} + +function siblings() { + return this.parent().children(); +} // Get the curent position siblings + +function position() { + return this.parent().index(this); +} // Get the next element (will return null if there is none) + +function next() { + return this.siblings()[this.position() + 1]; +} // Get the next element (will return null if there is none) + +function prev() { + return this.siblings()[this.position() - 1]; +} // Send given element one step forward + +function forward() { + var i = this.position() + 1; + var p = this.parent(); // move node one step forward + + p.removeElement(this).add(this, i); // make sure defs node is always at the top + + if (typeof p.isRoot === 'function' && p.isRoot()) { + p.node.appendChild(p.defs().node); + } + + return this; +} // Send given element one step backward + +function backward() { + var i = this.position(); + + if (i > 0) { + this.parent().removeElement(this).add(this, i - 1); + } + + return this; +} // Send given element all the way to the front + +function front() { + var p = this.parent(); // Move node forward + + p.node.appendChild(this.node); // Make sure defs node is always at the top + + if (typeof p.isRoot === 'function' && p.isRoot()) { + p.node.appendChild(p.defs().node); + } + + return this; +} // Send given element all the way to the back + +function back() { + if (this.position() > 0) { + this.parent().removeElement(this).add(this, 0); + } + + return this; +} // Inserts a given element before the targeted element + +function before(element) { + element = makeInstance(element); + element.remove(); + var i = this.position(); + this.parent().add(element, i); + return this; +} // Inserts a given element after the targeted element + +function after(element) { + element = makeInstance(element); + element.remove(); + var i = this.position(); + this.parent().add(element, i + 1); + return this; +} +function insertBefore(element) { + element = makeInstance(element); + element.before(this); + return this; +} +function insertAfter(element) { + element = makeInstance(element); + element.after(this); + return this; +} +registerMethods('Dom', { + siblings, + position, + next, + prev, + forward, + backward, + front, + back, + before, + after, + insertBefore, + insertAfter +}); + +// Parse unit value +let numberAndUnit = /^([+-]?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?)([a-z%]*)$/i; // Parse hex value + +let hex = /^#?([a-f\d]{2})([a-f\d]{2})([a-f\d]{2})$/i; // Parse rgb value + +let rgb = /rgb\((\d+),(\d+),(\d+)\)/; // Parse reference id + +let reference = /(#[a-z0-9\-_]+)/i; // splits a transformation chain + +let transforms = /\)\s*,?\s*/; // Whitespace + +let whitespace = /\s/g; // Test hex value + +let isHex = /^#[a-f0-9]{3,6}$/i; // Test rgb value + +let isRgb = /^rgb\(/; // Test css declaration + +let isCss = /[^:]+:[^;]+;?/; // Test for blank string + +let isBlank = /^(\s+)?$/; // Test for numeric string + +let isNumber = /^[+-]?(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i; // Test for percent value + +let isPercent = /^-?[\d.]+%$/; // Test for image url + +let isImage = /\.(jpg|jpeg|png|gif|svg)(\?[^=]+.*)?/i; // split at whitespace and comma + +let delimiter = /[\s,]+/; // The following regex are used to parse the d attribute of a path +// Matches all hyphens which are not after an exponent + +let hyphen = /([^e])-/gi; // Replaces and tests for all path letters + +let pathLetters = /[MLHVCSQTAZ]/gi; // yes we need this one, too + +let isPathLetter = /[MLHVCSQTAZ]/i; // matches 0.154.23.45 + +let numbersWithDots = /((\d?\.\d+(?:e[+-]?\d+)?)((?:\.\d+(?:e[+-]?\d+)?)+))+/gi; // matches . + +let dots = /\./g; + +var regex = ({ + numberAndUnit: numberAndUnit, + hex: hex, + rgb: rgb, + reference: reference, + transforms: transforms, + whitespace: whitespace, + isHex: isHex, + isRgb: isRgb, + isCss: isCss, + isBlank: isBlank, + isNumber: isNumber, + isPercent: isPercent, + isImage: isImage, + delimiter: delimiter, + hyphen: hyphen, + pathLetters: pathLetters, + isPathLetter: isPathLetter, + numbersWithDots: numbersWithDots, + dots: dots +}); + +function classes() { + var attr = this.attr('class'); + return attr == null ? [] : attr.trim().split(delimiter); +} // Return true if class exists on the node, false otherwise + +function hasClass(name) { + return this.classes().indexOf(name) !== -1; +} // Add class to the node + +function addClass(name) { + if (!this.hasClass(name)) { + var array = this.classes(); + array.push(name); + this.attr('class', array.join(' ')); + } + + return this; +} // Remove class from the node + +function removeClass(name) { + if (this.hasClass(name)) { + this.attr('class', this.classes().filter(function (c) { + return c !== name; + }).join(' ')); + } + + return this; +} // Toggle the presence of a class on the node + +function toggleClass(name) { + return this.hasClass(name) ? this.removeClass(name) : this.addClass(name); +} +registerMethods('Dom', { + classes, + hasClass, + addClass, + removeClass, + toggleClass +}); + +function css(style, val) { + let ret = {}; + + if (arguments.length === 0) { + // get full style as object + this.node.style.cssText.split(/\s*;\s*/).filter(function (el) { + return !!el.length; + }).forEach(function (el) { + let t = el.split(/\s*:\s*/); + ret[t[0]] = t[1]; + }); + return ret; + } + + if (arguments.length < 2) { + // get style properties in the array + if (Array.isArray(style)) { + for (let name of style) { + let cased = camelCase(name); + ret[cased] = this.node.style[cased]; + } + + return ret; + } // get style for property + + + if (typeof style === 'string') { + return this.node.style[camelCase(style)]; + } // set styles in object + + + if (typeof style === 'object') { + for (let name in style) { + // set empty string if null/undefined/'' was given + this.node.style[camelCase(name)] = style[name] == null || isBlank.test(style[name]) ? '' : style[name]; + } + } + } // set style for property + + + if (arguments.length === 2) { + this.node.style[camelCase(style)] = val == null || isBlank.test(val) ? '' : val; + } + + return this; +} // Show element + +function show() { + return this.css('display', ''); +} // Hide element + +function hide() { + return this.css('display', 'none'); +} // Is element visible? + +function visible() { + return this.css('display') !== 'none'; +} +registerMethods('Dom', { + css, + show, + hide, + visible +}); + +function data(a, v, r) { + if (typeof a === 'object') { + for (v in a) { + this.data(v, a[v]); + } + } else if (arguments.length < 2) { + try { + return JSON.parse(this.attr('data-' + a)); + } catch (e) { + return this.attr('data-' + a); + } + } else { + this.attr('data-' + a, v === null ? null : r === true || typeof v === 'string' || typeof v === 'number' ? v : JSON.stringify(v)); + } + + return this; +} +registerMethods('Dom', { + data +}); + +function remember(k, v) { + // remember every item in an object individually + if (typeof arguments[0] === 'object') { + for (var key in k) { + this.remember(key, k[key]); + } + } else if (arguments.length === 1) { + // retrieve memory + return this.memory()[k]; + } else { + // store memory + this.memory()[k] = v; + } + + return this; +} // Erase a given memory + +function forget() { + if (arguments.length === 0) { + this._memory = {}; + } else { + for (var i = arguments.length - 1; i >= 0; i--) { + delete this.memory()[arguments[i]]; + } + } + + return this; +} // This triggers creation of a new hidden class which is not performant +// However, this function is not rarely used so it will not happen frequently +// Return local memory object + +function memory() { + return this._memory = this._memory || {}; +} +registerMethods('Dom', { + remember, + forget, + memory +}); + +let listenerId = 0; +let windowEvents = {}; + +function getEvents(instance) { + let n = instance.getEventHolder(); // We dont want to save events in global space + + if (n === globals.window) n = windowEvents; + if (!n.events) n.events = {}; + return n.events; +} + +function getEventTarget(instance) { + return instance.getEventTarget(); +} + +function clearEvents(instance) { + const n = instance.getEventHolder(); + if (n.events) n.events = {}; +} // Add event binder in the SVG namespace + + +function on(node, events, listener, binding, options) { + var l = listener.bind(binding || node); + var instance = makeInstance(node); + var bag = getEvents(instance); + var n = getEventTarget(instance); // events can be an array of events or a string of events + + events = Array.isArray(events) ? events : events.split(delimiter); // add id to listener + + if (!listener._svgjsListenerId) { + listener._svgjsListenerId = ++listenerId; + } + + events.forEach(function (event) { + var ev = event.split('.')[0]; + var ns = event.split('.')[1] || '*'; // ensure valid object + + bag[ev] = bag[ev] || {}; + bag[ev][ns] = bag[ev][ns] || {}; // reference listener + + bag[ev][ns][listener._svgjsListenerId] = l; // add listener + + n.addEventListener(ev, l, options || false); + }); +} // Add event unbinder in the SVG namespace + +function off(node, events, listener, options) { + var instance = makeInstance(node); + var bag = getEvents(instance); + var n = getEventTarget(instance); // listener can be a function or a number + + if (typeof listener === 'function') { + listener = listener._svgjsListenerId; + if (!listener) return; + } // events can be an array of events or a string or undefined + + + events = Array.isArray(events) ? events : (events || '').split(delimiter); + events.forEach(function (event) { + var ev = event && event.split('.')[0]; + var ns = event && event.split('.')[1]; + var namespace, l; + + if (listener) { + // remove listener reference + if (bag[ev] && bag[ev][ns || '*']) { + // removeListener + n.removeEventListener(ev, bag[ev][ns || '*'][listener], options || false); + delete bag[ev][ns || '*'][listener]; + } + } else if (ev && ns) { + // remove all listeners for a namespaced event + if (bag[ev] && bag[ev][ns]) { + for (l in bag[ev][ns]) { + off(n, [ev, ns].join('.'), l); + } + + delete bag[ev][ns]; + } + } else if (ns) { + // remove all listeners for a specific namespace + for (event in bag) { + for (namespace in bag[event]) { + if (ns === namespace) { + off(n, [event, ns].join('.')); + } + } + } + } else if (ev) { + // remove all listeners for the event + if (bag[ev]) { + for (namespace in bag[ev]) { + off(n, [ev, namespace].join('.')); + } + + delete bag[ev]; + } + } else { + // remove all listeners on a given node + for (event in bag) { + off(n, event); + } + + clearEvents(instance); + } + }); +} +function dispatch(node, event, data) { + var n = getEventTarget(node); // Dispatch event + + if (event instanceof globals.window.Event) { + n.dispatchEvent(event); + } else { + event = new globals.window.CustomEvent(event, { + detail: data, + cancelable: true + }); + n.dispatchEvent(event); + } + + return event; +} + +function sixDigitHex(hex$$1) { + return hex$$1.length === 4 ? ['#', hex$$1.substring(1, 2), hex$$1.substring(1, 2), hex$$1.substring(2, 3), hex$$1.substring(2, 3), hex$$1.substring(3, 4), hex$$1.substring(3, 4)].join('') : hex$$1; +} + +function componentHex(component) { + const integer = Math.round(component); + const bounded = Math.max(0, Math.min(255, integer)); + const hex$$1 = bounded.toString(16); + return hex$$1.length === 1 ? '0' + hex$$1 : hex$$1; +} + +function is(object, space) { + for (let i = space.length; i--;) { + if (object[space[i]] == null) { + return false; + } + } + + return true; +} + +function getParameters(a, b) { + const params = is(a, 'rgb') ? { + _a: a.r, + _b: a.g, + _c: a.b, + space: 'rgb' + } : is(a, 'xyz') ? { + _a: a.x, + _b: a.y, + _c: a.z, + _d: 0, + space: 'xyz' + } : is(a, 'hsl') ? { + _a: a.h, + _b: a.s, + _c: a.l, + _d: 0, + space: 'hsl' + } : is(a, 'lab') ? { + _a: a.l, + _b: a.a, + _c: a.b, + _d: 0, + space: 'lab' + } : is(a, 'lch') ? { + _a: a.l, + _b: a.c, + _c: a.h, + _d: 0, + space: 'lch' + } : is(a, 'cmyk') ? { + _a: a.c, + _b: a.m, + _c: a.y, + _d: a.k, + space: 'cmyk' + } : { + _a: 0, + _b: 0, + _c: 0, + space: 'rgb' + }; + params.space = b || params.space; + return params; +} + +function cieSpace(space) { + if (space === 'lab' || space === 'xyz' || space === 'lch') { + return true; + } else { + return false; + } +} + +function hueToRgb(p, q, t) { + if (t < 0) t += 1; + if (t > 1) t -= 1; + if (t < 1 / 6) return p + (q - p) * 6 * t; + if (t < 1 / 2) return q; + if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6; + return p; +} + +class Color { + constructor(...inputs) { + this.init(...inputs); + } + + init(a = 0, b = 0, c = 0, d = 0, space = 'rgb') { + // This catches the case when a falsy value is passed like '' + a = !a ? 0 : a; // Reset all values in case the init function is rerun with new color space + + if (this.space) { + for (let component in this.space) { + delete this[this.space[component]]; + } + } + + if (typeof a === 'number') { + // Allow for the case that we don't need d... + space = typeof d === 'string' ? d : space; + d = typeof d === 'string' ? 0 : d; // Assign the values straight to the color + + Object.assign(this, { + _a: a, + _b: b, + _c: c, + _d: d, + space + }); // If the user gave us an array, make the color from it + } else if (a instanceof Array) { + this.space = b || (typeof a[3] === 'string' ? a[3] : a[4]) || 'rgb'; + Object.assign(this, { + _a: a[0], + _b: a[1], + _c: a[2], + _d: a[3] || 0 + }); + } else if (a instanceof Object) { + // Set the object up and assign its values directly + const values = getParameters(a, b); + Object.assign(this, values); + } else if (typeof a === 'string') { + if (isRgb.test(a)) { + const noWhitespace = a.replace(whitespace, ''); + const [_a, _b, _c] = rgb.exec(noWhitespace).slice(1, 4).map(v => parseInt(v)); + Object.assign(this, { + _a, + _b, + _c, + _d: 0, + space: 'rgb' + }); + } else if (isHex.test(a)) { + const hexParse = v => parseInt(v, 16); + + const [, _a, _b, _c] = hex.exec(sixDigitHex(a)).map(hexParse); + Object.assign(this, { + _a, + _b, + _c, + _d: 0, + space: 'rgb' + }); + } else throw Error(`Unsupported string format, can't construct Color`); + } // Now add the components as a convenience + + + const { + _a, + _b, + _c, + _d + } = this; + const components = this.space === 'rgb' ? { + r: _a, + g: _b, + b: _c + } : this.space === 'xyz' ? { + x: _a, + y: _b, + z: _c + } : this.space === 'hsl' ? { + h: _a, + s: _b, + l: _c + } : this.space === 'lab' ? { + l: _a, + a: _b, + b: _c + } : this.space === 'lch' ? { + l: _a, + c: _b, + h: _c + } : this.space === 'cmyk' ? { + c: _a, + m: _b, + y: _c, + k: _d + } : {}; + Object.assign(this, components); + } + /* + Conversion Methods + */ + + + rgb() { + if (this.space === 'rgb') { + return this; + } else if (cieSpace(this.space)) { + // Convert to the xyz color space + let { + x, + y, + z + } = this; + + if (this.space === 'lab' || this.space === 'lch') { + // Get the values in the lab space + let { + l, + a, + b + } = this; + + if (this.space === 'lch') { + let { + c, + h + } = this; + const dToR = Math.PI / 180; + a = c * Math.cos(dToR * h); + b = c * Math.sin(dToR * h); + } // Undo the nonlinear function + + + const yL = (l + 16) / 116; + const xL = a / 500 + yL; + const zL = yL - b / 200; // Get the xyz values + + const ct = 16 / 116; + const mx = 0.008856; + const nm = 7.787; + x = 0.95047 * (Math.pow(xL, 3) > mx ? Math.pow(xL, 3) : (xL - ct) / nm); + y = 1.00000 * (Math.pow(yL, 3) > mx ? Math.pow(yL, 3) : (yL - ct) / nm); + z = 1.08883 * (Math.pow(zL, 3) > mx ? Math.pow(zL, 3) : (zL - ct) / nm); + } // Convert xyz to unbounded rgb values + + + const rU = x * 3.2406 + y * -1.5372 + z * -0.4986; + const gU = x * -0.9689 + y * 1.8758 + z * 0.0415; + const bU = x * 0.0557 + y * -0.2040 + z * 1.0570; // Convert the values to true rgb values + + let pow = Math.pow; + let bd = 0.0031308; + const r = rU > bd ? 1.055 * pow(rU, 1 / 2.4) - 0.055 : 12.92 * rU; + const g = gU > bd ? 1.055 * pow(gU, 1 / 2.4) - 0.055 : 12.92 * gU; + const b = bU > bd ? 1.055 * pow(bU, 1 / 2.4) - 0.055 : 12.92 * bU; // Make and return the color + + const color = new Color(255 * r, 255 * g, 255 * b); + return color; + } else if (this.space === 'hsl') { + // https://bgrins.github.io/TinyColor/docs/tinycolor.html + // Get the current hsl values + let { + h, + s, + l + } = this; + h /= 360; + s /= 100; + l /= 100; // If we are grey, then just make the color directly + + if (s === 0) { + l *= 255; + let color = new Color(l, l, l); + return color; + } // TODO I have no idea what this does :D If you figure it out, tell me! + + + const q = l < 0.5 ? l * (1 + s) : l + s - l * s; + const p = 2 * l - q; // Get the rgb values + + const r = 255 * hueToRgb(p, q, h + 1 / 3); + const g = 255 * hueToRgb(p, q, h); + const b = 255 * hueToRgb(p, q, h - 1 / 3); // Make a new color + + const color = new Color(r, g, b); + return color; + } else if (this.space === 'cmyk') { + // https://gist.github.com/felipesabino/5066336 + // Get the normalised cmyk values + const { + c, + m, + y, + k + } = this; // Get the rgb values + + const r = 255 * (1 - Math.min(1, c * (1 - k) + k)); + const g = 255 * (1 - Math.min(1, m * (1 - k) + k)); + const b = 255 * (1 - Math.min(1, y * (1 - k) + k)); // Form the color and return it + + const color = new Color(r, g, b); + return color; + } else { + return this; + } + } + + lab() { + // Get the xyz color + const { + x, + y, + z + } = this.xyz(); // Get the lab components + + const l = 116 * y - 16; + const a = 500 * (x - y); + const b = 200 * (y - z); // Construct and return a new color + + const color = new Color(l, a, b, 'lab'); + return color; + } + + xyz() { + // Normalise the red, green and blue values + const { + _a: r255, + _b: g255, + _c: b255 + } = this.rgb(); + const [r, g, b] = [r255, g255, b255].map(v => v / 255); // Convert to the lab rgb space + + const rL = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92; + const gL = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92; + const bL = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92; // Convert to the xyz color space without bounding the values + + const xU = (rL * 0.4124 + gL * 0.3576 + bL * 0.1805) / 0.95047; + const yU = (rL * 0.2126 + gL * 0.7152 + bL * 0.0722) / 1.00000; + const zU = (rL * 0.0193 + gL * 0.1192 + bL * 0.9505) / 1.08883; // Get the proper xyz values by applying the bounding + + const x = xU > 0.008856 ? Math.pow(xU, 1 / 3) : 7.787 * xU + 16 / 116; + const y = yU > 0.008856 ? Math.pow(yU, 1 / 3) : 7.787 * yU + 16 / 116; + const z = zU > 0.008856 ? Math.pow(zU, 1 / 3) : 7.787 * zU + 16 / 116; // Make and return the color + + const color = new Color(x, y, z, 'xyz'); + return color; + } + + lch() { + // Get the lab color directly + const { + l, + a, + b + } = this.lab(); // Get the chromaticity and the hue using polar coordinates + + const c = Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2)); + let h = 180 * Math.atan2(b, a) / Math.PI; + + if (h < 0) { + h *= -1; + h = 360 - h; + } // Make a new color and return it + + + const color = new Color(l, c, h, 'lch'); + return color; + } + + hsl() { + // Get the rgb values + const { + _a, + _b, + _c + } = this.rgb(); + const [r, g, b] = [_a, _b, _c].map(v => v / 255); // Find the maximum and minimum values to get the lightness + + const max = Math.max(r, g, b); + const min = Math.min(r, g, b); + const l = (max + min) / 2; // If the r, g, v values are identical then we are grey + + const isGrey = max === min; // Calculate the hue and saturation + + const delta = max - min; + const s = isGrey ? 0 : l > 0.5 ? delta / (2 - max - min) : delta / (max + min); + const h = isGrey ? 0 : max === r ? ((g - b) / delta + (g < b ? 6 : 0)) / 6 : max === g ? ((b - r) / delta + 2) / 6 : max === b ? ((r - g) / delta + 4) / 6 : 0; // Construct and return the new color + + const color = new Color(360 * h, 100 * s, 100 * l, 'hsl'); + return color; + } + + cmyk() { + // Get the rgb values for the current color + const { + _a, + _b, + _c + } = this.rgb(); + const [r, g, b] = [_a, _b, _c].map(v => v / 255); // Get the cmyk values in an unbounded format + + const k = Math.min(1 - r, 1 - g, 1 - b); + + if (k === 1) { + // Catch the black case + return new Color(0, 0, 0, 1, 'cmyk'); + } + + const c = (1 - r - k) / (1 - k); + const m = (1 - g - k) / (1 - k); + const y = (1 - b - k) / (1 - k); // Construct the new color + + const color = new Color(c, m, y, k, 'cmyk'); + return color; + } + /* + Input and Output methods + */ + + + _clamped() { + let { + _a, + _b, + _c + } = this.rgb(); + let { + max, + min, + round + } = Math; + + let format = v => max(0, min(round(v), 255)); + + return [_a, _b, _c].map(format); + } + + toHex() { + let [r, g, b] = this._clamped().map(componentHex); + + return `#${r}${g}${b}`; + } + + toString() { + return this.toHex(); + } + + toRgb() { + let [rV, gV, bV] = this._clamped(); + + let string = `rgb(${rV},${gV},${bV})`; + return string; + } + + toArray() { + let { + _a, + _b, + _c, + _d, + space + } = this; + return [_a, _b, _c, _d, space]; + } + /* + Generating random colors + */ + + + static random(mode = 'vibrant', t, u) { + // Get the math modules + const { + random, + round, + sin, + PI: pi + } = Math; // Run the correct generator + + if (mode === 'vibrant') { + const l = (81 - 57) * random() + 57; + const c = (83 - 45) * random() + 45; + const h = 360 * random(); + const color = new Color(l, c, h, 'lch'); + return color; + } else if (mode === 'sine') { + t = t == null ? random() : t; + const r = round(80 * sin(2 * pi * t / 0.5 + 0.01) + 150); + const g = round(50 * sin(2 * pi * t / 0.5 + 4.6) + 200); + const b = round(100 * sin(2 * pi * t / 0.5 + 2.3) + 150); + const color = new Color(r, g, b); + return color; + } else if (mode === 'pastel') { + const l = (94 - 86) * random() + 86; + const c = (26 - 9) * random() + 9; + const h = 360 * random(); + const color = new Color(l, c, h, 'lch'); + return color; + } else if (mode === 'dark') { + const l = 10 + 10 * random(); + const c = (125 - 75) * random() + 86; + const h = 360 * random(); + const color = new Color(l, c, h, 'lch'); + return color; + } else if (mode === 'rgb') { + const r = 255 * random(); + const g = 255 * random(); + const b = 255 * random(); + const color = new Color(r, g, b); + return color; + } else if (mode === 'lab') { + const l = 100 * random(); + const a = 256 * random() - 128; + const b = 256 * random() - 128; + const color = new Color(l, a, b, 'lab'); + return color; + } else if (mode === 'grey') { + const grey = 255 * random(); + const color = new Color(grey, grey, grey); + return color; + } + } + /* + Constructing colors + */ + // Test if given value is a color string + + + static test(color) { + color += ''; + return isHex.test(color) || isRgb.test(color); + } // Test if given value is a rgb object + + + static isRgb(color) { + return color && typeof color.r === 'number' && typeof color.g === 'number' && typeof color.b === 'number'; + } // Test if given value is a color + + + static isColor(color) { + return this.isRgb(color) || this.test(color); + } + +} + +class Point { + // Initialize + constructor(...args) { + this.init(...args); + } + + init(x, y) { + let source; + let base = { + x: 0, + y: 0 // ensure source as object + + }; + source = Array.isArray(x) ? { + x: x[0], + y: x[1] + } : typeof x === 'object' ? { + x: x.x, + y: x.y + } : { + x: x, + y: y // merge source + + }; + this.x = source.x == null ? base.x : source.x; + this.y = source.y == null ? base.y : source.y; + return this; + } // Clone point + + + clone() { + return new Point(this); + } // transform point with matrix + + + transform(m) { + // Perform the matrix multiplication + var x = m.a * this.x + m.c * this.y + m.e; + var y = m.b * this.x + m.d * this.y + m.f; // Return the required point + + return new Point(x, y); + } + + toArray() { + return [this.x, this.y]; + } + +} +function point(x, y) { + return new Point(x, y).transform(this.screenCTM().inverse()); +} + +function closeEnough(a, b, threshold) { + return Math.abs(b - a) < (threshold || 1e-6); +} + +class Matrix { + constructor(...args) { + this.init(...args); + } // Initialize + + + init(source) { + var base = Matrix.fromArray([1, 0, 0, 1, 0, 0]); // ensure source as object + + source = source instanceof Element ? source.matrixify() : typeof source === 'string' ? Matrix.fromArray(source.split(delimiter).map(parseFloat)) : Array.isArray(source) ? Matrix.fromArray(source) : typeof source === 'object' && Matrix.isMatrixLike(source) ? source : typeof source === 'object' ? new Matrix().transform(source) : arguments.length === 6 ? Matrix.fromArray([].slice.call(arguments)) : base; // Merge the source matrix with the base matrix + + this.a = source.a != null ? source.a : base.a; + this.b = source.b != null ? source.b : base.b; + this.c = source.c != null ? source.c : base.c; + this.d = source.d != null ? source.d : base.d; + this.e = source.e != null ? source.e : base.e; + this.f = source.f != null ? source.f : base.f; + return this; + } // Clones this matrix + + + clone() { + return new Matrix(this); + } // Transform a matrix into another matrix by manipulating the space + + + transform(o) { + // Check if o is a matrix and then left multiply it directly + if (Matrix.isMatrixLike(o)) { + var matrix = new Matrix(o); + return matrix.multiplyO(this); + } // Get the proposed transformations and the current transformations + + + var t = Matrix.formatTransforms(o); + var current = this; + let { + x: ox, + y: oy + } = new Point(t.ox, t.oy).transform(current); // Construct the resulting matrix + + var transformer = new Matrix().translateO(t.rx, t.ry).lmultiplyO(current).translateO(-ox, -oy).scaleO(t.scaleX, t.scaleY).skewO(t.skewX, t.skewY).shearO(t.shear).rotateO(t.theta).translateO(ox, oy); // If we want the origin at a particular place, we force it there + + if (isFinite(t.px) || isFinite(t.py)) { + const origin = new Point(ox, oy).transform(transformer); // TODO: Replace t.px with isFinite(t.px) + + const dx = t.px ? t.px - origin.x : 0; + const dy = t.py ? t.py - origin.y : 0; + transformer.translateO(dx, dy); + } // Translate now after positioning + + + transformer.translateO(t.tx, t.ty); + return transformer; + } // Applies a matrix defined by its affine parameters + + + compose(o) { + if (o.origin) { + o.originX = o.origin[0]; + o.originY = o.origin[1]; + } // Get the parameters + + + var ox = o.originX || 0; + var oy = o.originY || 0; + var sx = o.scaleX || 1; + var sy = o.scaleY || 1; + var lam = o.shear || 0; + var theta = o.rotate || 0; + var tx = o.translateX || 0; + var ty = o.translateY || 0; // Apply the standard matrix + + var result = new Matrix().translateO(-ox, -oy).scaleO(sx, sy).shearO(lam).rotateO(theta).translateO(tx, ty).lmultiplyO(this).translateO(ox, oy); + return result; + } // Decomposes this matrix into its affine parameters + + + decompose(cx = 0, cy = 0) { + // Get the parameters from the matrix + var a = this.a; + var b = this.b; + var c = this.c; + var d = this.d; + var e = this.e; + var f = this.f; // Figure out if the winding direction is clockwise or counterclockwise + + var determinant = a * d - b * c; + var ccw = determinant > 0 ? 1 : -1; // Since we only shear in x, we can use the x basis to get the x scale + // and the rotation of the resulting matrix + + var sx = ccw * Math.sqrt(a * a + b * b); + var thetaRad = Math.atan2(ccw * b, ccw * a); + var theta = 180 / Math.PI * thetaRad; + var ct = Math.cos(thetaRad); + var st = Math.sin(thetaRad); // We can then solve the y basis vector simultaneously to get the other + // two affine parameters directly from these parameters + + var lam = (a * c + b * d) / determinant; + var sy = c * sx / (lam * a - b) || d * sx / (lam * b + a); // Use the translations + + let tx = e - cx + cx * ct * sx + cy * (lam * ct * sx - st * sy); + let ty = f - cy + cx * st * sx + cy * (lam * st * sx + ct * sy); // Construct the decomposition and return it + + return { + // Return the affine parameters + scaleX: sx, + scaleY: sy, + shear: lam, + rotate: theta, + translateX: tx, + translateY: ty, + originX: cx, + originY: cy, + // Return the matrix parameters + a: this.a, + b: this.b, + c: this.c, + d: this.d, + e: this.e, + f: this.f + }; + } // Left multiplies by the given matrix + + + multiply(matrix) { + return this.clone().multiplyO(matrix); + } + + multiplyO(matrix) { + // Get the matrices + var l = this; + var r = matrix instanceof Matrix ? matrix : new Matrix(matrix); + return Matrix.matrixMultiply(l, r, this); + } + + lmultiply(matrix) { + return this.clone().lmultiplyO(matrix); + } + + lmultiplyO(matrix) { + var r = this; + var l = matrix instanceof Matrix ? matrix : new Matrix(matrix); + return Matrix.matrixMultiply(l, r, this); + } // Inverses matrix + + + inverseO() { + // Get the current parameters out of the matrix + var a = this.a; + var b = this.b; + var c = this.c; + var d = this.d; + var e = this.e; + var f = this.f; // Invert the 2x2 matrix in the top left + + var det = a * d - b * c; + if (!det) throw new Error('Cannot invert ' + this); // Calculate the top 2x2 matrix + + var na = d / det; + var nb = -b / det; + var nc = -c / det; + var nd = a / det; // Apply the inverted matrix to the top right + + var ne = -(na * e + nc * f); + var nf = -(nb * e + nd * f); // Construct the inverted matrix + + this.a = na; + this.b = nb; + this.c = nc; + this.d = nd; + this.e = ne; + this.f = nf; + return this; + } + + inverse() { + return this.clone().inverseO(); + } // Translate matrix + + + translate(x, y) { + return this.clone().translateO(x, y); + } + + translateO(x, y) { + this.e += x || 0; + this.f += y || 0; + return this; + } // Scale matrix + + + scale(x, y, cx, cy) { + return this.clone().scaleO(...arguments); + } + + scaleO(x, y = x, cx = 0, cy = 0) { + // Support uniform scaling + if (arguments.length === 3) { + cy = cx; + cx = y; + y = x; + } + + let { + a, + b, + c, + d, + e, + f + } = this; + this.a = a * x; + this.b = b * y; + this.c = c * x; + this.d = d * y; + this.e = e * x - cx * x + cx; + this.f = f * y - cy * y + cy; + return this; + } // Rotate matrix + + + rotate(r, cx, cy) { + return this.clone().rotateO(r, cx, cy); + } + + rotateO(r, cx = 0, cy = 0) { + // Convert degrees to radians + r = radians(r); + let cos = Math.cos(r); + let sin = Math.sin(r); + let { + a, + b, + c, + d, + e, + f + } = this; + this.a = a * cos - b * sin; + this.b = b * cos + a * sin; + this.c = c * cos - d * sin; + this.d = d * cos + c * sin; + this.e = e * cos - f * sin + cy * sin - cx * cos + cx; + this.f = f * cos + e * sin - cx * sin - cy * cos + cy; + return this; + } // Flip matrix on x or y, at a given offset + + + flip(axis, around) { + return this.clone().flipO(axis, around); + } + + flipO(axis, around) { + return axis === 'x' ? this.scaleO(-1, 1, around, 0) : axis === 'y' ? this.scaleO(1, -1, 0, around) : this.scaleO(-1, -1, axis, around || axis); // Define an x, y flip point + } // Shear matrix + + + shear(a, cx, cy) { + return this.clone().shearO(a, cx, cy); + } + + shearO(lx, cx = 0, cy = 0) { + let { + a, + b, + c, + d, + e, + f + } = this; + this.a = a + b * lx; + this.c = c + d * lx; + this.e = e + f * lx - cy * lx; + return this; + } // Skew Matrix + + + skew(x, y, cx, cy) { + return this.clone().skewO(...arguments); + } + + skewO(x, y = x, cx = 0, cy = 0) { + // support uniformal skew + if (arguments.length === 3) { + cy = cx; + cx = y; + y = x; + } // Convert degrees to radians + + + x = radians(x); + y = radians(y); + let lx = Math.tan(x); + let ly = Math.tan(y); + let { + a, + b, + c, + d, + e, + f + } = this; + this.a = a + b * lx; + this.b = b + a * ly; + this.c = c + d * lx; + this.d = d + c * ly; + this.e = e + f * lx - cy * lx; + this.f = f + e * ly - cx * ly; + return this; + } // SkewX + + + skewX(x, cx, cy) { + return this.skew(x, 0, cx, cy); + } + + skewXO(x, cx, cy) { + return this.skewO(x, 0, cx, cy); + } // SkewY + + + skewY(y, cx, cy) { + return this.skew(0, y, cx, cy); + } + + skewYO(y, cx, cy) { + return this.skewO(0, y, cx, cy); + } // Transform around a center point + + + aroundO(cx, cy, matrix) { + var dx = cx || 0; + var dy = cy || 0; + return this.translateO(-dx, -dy).lmultiplyO(matrix).translateO(dx, dy); + } + + around(cx, cy, matrix) { + return this.clone().aroundO(cx, cy, matrix); + } // Check if two matrices are equal + + + equals(other) { + var comp = new Matrix(other); + return closeEnough(this.a, comp.a) && closeEnough(this.b, comp.b) && closeEnough(this.c, comp.c) && closeEnough(this.d, comp.d) && closeEnough(this.e, comp.e) && closeEnough(this.f, comp.f); + } // Convert matrix to string + + + toString() { + return 'matrix(' + this.a + ',' + this.b + ',' + this.c + ',' + this.d + ',' + this.e + ',' + this.f + ')'; + } + + toArray() { + return [this.a, this.b, this.c, this.d, this.e, this.f]; + } + + valueOf() { + return { + a: this.a, + b: this.b, + c: this.c, + d: this.d, + e: this.e, + f: this.f + }; + } + + static fromArray(a) { + return { + a: a[0], + b: a[1], + c: a[2], + d: a[3], + e: a[4], + f: a[5] + }; + } + + static isMatrixLike(o) { + return o.a != null || o.b != null || o.c != null || o.d != null || o.e != null || o.f != null; + } + + static formatTransforms(o) { + // Get all of the parameters required to form the matrix + var flipBoth = o.flip === 'both' || o.flip === true; + var flipX = o.flip && (flipBoth || o.flip === 'x') ? -1 : 1; + var flipY = o.flip && (flipBoth || o.flip === 'y') ? -1 : 1; + var skewX = o.skew && o.skew.length ? o.skew[0] : isFinite(o.skew) ? o.skew : isFinite(o.skewX) ? o.skewX : 0; + var skewY = o.skew && o.skew.length ? o.skew[1] : isFinite(o.skew) ? o.skew : isFinite(o.skewY) ? o.skewY : 0; + var scaleX = o.scale && o.scale.length ? o.scale[0] * flipX : isFinite(o.scale) ? o.scale * flipX : isFinite(o.scaleX) ? o.scaleX * flipX : flipX; + var scaleY = o.scale && o.scale.length ? o.scale[1] * flipY : isFinite(o.scale) ? o.scale * flipY : isFinite(o.scaleY) ? o.scaleY * flipY : flipY; + var shear = o.shear || 0; + var theta = o.rotate || o.theta || 0; + var origin = new Point(o.origin || o.around || o.ox || o.originX, o.oy || o.originY); + var ox = origin.x; + var oy = origin.y; + var position = new Point(o.position || o.px || o.positionX, o.py || o.positionY); + var px = position.x; + var py = position.y; + var translate = new Point(o.translate || o.tx || o.translateX, o.ty || o.translateY); + var tx = translate.x; + var ty = translate.y; + var relative = new Point(o.relative || o.rx || o.relativeX, o.ry || o.relativeY); + var rx = relative.x; + var ry = relative.y; // Populate all of the values + + return { + scaleX, + scaleY, + skewX, + skewY, + shear, + theta, + rx, + ry, + tx, + ty, + ox, + oy, + px, + py + }; + } // left matrix, right matrix, target matrix which is overwritten + + + static matrixMultiply(l, r, o) { + // Work out the product directly + var a = l.a * r.a + l.c * r.b; + var b = l.b * r.a + l.d * r.b; + var c = l.a * r.c + l.c * r.d; + var d = l.b * r.c + l.d * r.d; + var e = l.e + l.a * r.e + l.c * r.f; + var f = l.f + l.b * r.e + l.d * r.f; // make sure to use local variables because l/r and o could be the same + + o.a = a; + o.b = b; + o.c = c; + o.d = d; + o.e = e; + o.f = f; + return o; + } + +} +function ctm() { + return new Matrix(this.node.getCTM()); +} +function screenCTM() { + /* https://bugzilla.mozilla.org/show_bug.cgi?id=1344537 + This is needed because FF does not return the transformation matrix + for the inner coordinate system when getScreenCTM() is called on nested svgs. + However all other Browsers do that */ + if (typeof this.isRoot === 'function' && !this.isRoot()) { + var rect = this.rect(1, 1); + var m = rect.node.getScreenCTM(); + rect.remove(); + return new Matrix(m); + } + + return new Matrix(this.node.getScreenCTM()); +} +register(Matrix); + +function parser() { + // Reuse cached element if possible + if (!parser.nodes) { + let svg = makeInstance().size(2, 0); + svg.node.style.cssText = ['opacity: 0', 'position: absolute', 'left: -100%', 'top: -100%', 'overflow: hidden'].join(';'); + svg.attr('focusable', 'false'); + let path = svg.path().node; + parser.nodes = { + svg, + path + }; + } + + if (!parser.nodes.svg.node.parentNode) { + let b = globals.document.body || globals.document.documentElement; + parser.nodes.svg.addTo(b); + } + + return parser.nodes; +} + +function isNulledBox(box) { + return !box.w && !box.h && !box.x && !box.y; +} + +function domContains(node) { + return (globals.document.documentElement.contains || function (node) { + // This is IE - it does not support contains() for top-level SVGs + while (node.parentNode) { + node = node.parentNode; + } + + return node === document; + }).call(globals.document.documentElement, node); +} + +class Box { + constructor(...args) { + this.init(...args); + } + + init(source) { + var base = [0, 0, 0, 0]; + source = typeof source === 'string' ? source.split(delimiter).map(parseFloat) : Array.isArray(source) ? source : typeof source === 'object' ? [source.left != null ? source.left : source.x, source.top != null ? source.top : source.y, source.width, source.height] : arguments.length === 4 ? [].slice.call(arguments) : base; + this.x = source[0] || 0; + this.y = source[1] || 0; + this.width = this.w = source[2] || 0; + this.height = this.h = source[3] || 0; // Add more bounding box properties + + this.x2 = this.x + this.w; + this.y2 = this.y + this.h; + this.cx = this.x + this.w / 2; + this.cy = this.y + this.h / 2; + return this; + } // Merge rect box with another, return a new instance + + + merge(box) { + let x = Math.min(this.x, box.x); + let y = Math.min(this.y, box.y); + let width = Math.max(this.x + this.width, box.x + box.width) - x; + let height = Math.max(this.y + this.height, box.y + box.height) - y; + return new Box(x, y, width, height); + } + + transform(m) { + let xMin = Infinity; + let xMax = -Infinity; + let yMin = Infinity; + let yMax = -Infinity; + let pts = [new Point(this.x, this.y), new Point(this.x2, this.y), new Point(this.x, this.y2), new Point(this.x2, this.y2)]; + pts.forEach(function (p) { + p = p.transform(m); + xMin = Math.min(xMin, p.x); + xMax = Math.max(xMax, p.x); + yMin = Math.min(yMin, p.y); + yMax = Math.max(yMax, p.y); + }); + return new Box(xMin, yMin, xMax - xMin, yMax - yMin); + } + + addOffset() { + // offset by window scroll position, because getBoundingClientRect changes when window is scrolled + this.x += globals.window.pageXOffset; + this.y += globals.window.pageYOffset; + return this; + } + + toString() { + return this.x + ' ' + this.y + ' ' + this.width + ' ' + this.height; + } + + toArray() { + return [this.x, this.y, this.width, this.height]; + } + + isNulled() { + return isNulledBox(this); + } + +} + +function getBox(cb, retry) { + let box; + + try { + box = cb(this.node); + + if (isNulledBox(box) && !domContains(this.node)) { + throw new Error('Element not in the dom'); + } + } catch (e) { + box = retry(this); + } + + return box; +} + +function bbox() { + return new Box(getBox.call(this, node => node.getBBox(), el => { + try { + let clone = el.clone().addTo(parser().svg).show(); + let box = clone.node.getBBox(); + clone.remove(); + return box; + } catch (e) { + throw new Error('Getting bbox of element "' + el.node.nodeName + '" is not possible'); + } + })); +} +function rbox(el) { + let box = new Box(getBox.call(this, node => node.getBoundingClientRect(), el => { + throw new Error('Getting rbox of element "' + el.node.nodeName + '" is not possible'); + })); + if (el) return box.transform(el.screenCTM().inverse()); + return box.addOffset(); +} +registerMethods({ + viewbox: { + viewbox(x, y, width, height) { + // act as getter + if (x == null) return new Box(this.attr('viewBox')); // act as setter + + return this.attr('viewBox', new Box(x, y, width, height)); + }, + + zoom(level, point$$1) { + var style = window.getComputedStyle(this.node); + var width = parseFloat(style.getPropertyValue('width')); + var height = parseFloat(style.getPropertyValue('height')); + var v = this.viewbox(); + var zoomX = width / v.width; + var zoomY = height / v.height; + var zoom = Math.min(zoomX, zoomY); + + if (level == null) { + return zoom; + } + + var zoomAmount = zoom / level; + if (zoomAmount === Infinity) zoomAmount = Number.MIN_VALUE; + point$$1 = point$$1 || new Point(width / 2 / zoomX + v.x, height / 2 / zoomY + v.y); + var box = new Box(v).transform(new Matrix({ + scale: zoomAmount, + origin: point$$1 + })); + return this.viewbox(box); + } + + } +}); +register(Box); + +/* eslint no-new-func: "off" */ +const subClassArray = function () { + try { + // try es6 subclassing + return Function('name', 'baseClass', '_constructor', ['baseClass = baseClass || Array', 'return {', ' [name]: class extends baseClass {', ' constructor (...args) {', ' super(...args)', ' _constructor && _constructor.apply(this, args)', ' }', ' }', '}[name]'].join('\n')); + } catch (e) { + // Use es5 approach + return (name, baseClass = Array, _constructor) => { + const Arr = function () { + baseClass.apply(this, arguments); + _constructor && _constructor.apply(this, arguments); + }; + + Arr.prototype = Object.create(baseClass.prototype); + Arr.prototype.constructor = Arr; + + Arr.prototype.map = function (fn) { + const arr = new Arr(); + arr.push.apply(arr, Array.prototype.map.call(this, fn)); + return arr; + }; + + return Arr; + }; + } +}(); + +const List = subClassArray('List', Array, function (arr = []) { + // This catches the case, that native map tries to create an array with new Array(1) + if (typeof arr === 'number') return this; + this.length = 0; + this.push(...arr); +}); +extend(List, { + each(fnOrMethodName, ...args) { + if (typeof fnOrMethodName === 'function') { + return this.map(el => { + return fnOrMethodName.call(el, el); + }); + } else { + return this.map(el => { + return el[fnOrMethodName](...args); + }); + } + }, + + toArray() { + return Array.prototype.concat.apply([], this); + } + +}); +const reserved = ['toArray', 'constructor', 'each']; + +List.extend = function (methods) { + methods = methods.reduce((obj, name) => { + // Don't overwrite own methods + if (reserved.includes(name)) return obj; // Don't add private methods + + if (name[0] === '_') return obj; // Relay every call to each() + + obj[name] = function (...attrs) { + return this.each(name, ...attrs); + }; + + return obj; + }, {}); + extend(List, methods); +}; + +function baseFind(query, parent) { + return new List(map((parent || globals.document).querySelectorAll(query), function (node) { + return adopt(node); + })); +} // Scoped find method + +function find(query) { + return baseFind(query, this.node); +} + +class EventTarget extends Base { + constructor({ + events = {} + } = {}) { + super(); + this.events = events; + } + + addEventListener() {} + + dispatch(event, data) { + return dispatch(this, event, data); + } + + dispatchEvent(event) { + const bag = this.getEventHolder().events; + if (!bag) return true; + const events = bag[event.type]; + + for (let i in events) { + for (let j in events[i]) { + events[i][j](event); + } + } + + return !event.defaultPrevented; + } // Fire given event + + + fire(event, data) { + this.dispatch(event, data); + return this; + } + + getEventHolder() { + return this; + } + + getEventTarget() { + return this; + } // Unbind event from listener + + + off(event, listener) { + off(this, event, listener); + return this; + } // Bind given event to listener + + + on(event, listener, binding, options) { + on(this, event, listener, binding, options); + return this; + } + + removeEventListener() {} + +} +register(EventTarget); + +function noop() {} // Default animation values + +let timeline = { + duration: 400, + ease: '>', + delay: 0 // Default attribute values + +}; +let attrs = { + // fill and stroke + 'fill-opacity': 1, + 'stroke-opacity': 1, + 'stroke-width': 0, + 'stroke-linejoin': 'miter', + 'stroke-linecap': 'butt', + fill: '#000000', + stroke: '#000000', + opacity: 1, + // position + x: 0, + y: 0, + cx: 0, + cy: 0, + // size + width: 0, + height: 0, + // radius + r: 0, + rx: 0, + ry: 0, + // gradient + offset: 0, + 'stop-opacity': 1, + 'stop-color': '#000000', + // text + 'font-size': 16, + 'font-family': 'Helvetica, Arial, sans-serif', + 'text-anchor': 'start' +}; + +var defaults = ({ + noop: noop, + timeline: timeline, + attrs: attrs +}); + +const SVGArray = subClassArray('SVGArray', Array, function (arr) { + this.init(arr); +}); +extend(SVGArray, { + init(arr) { + // This catches the case, that native map tries to create an array with new Array(1) + if (typeof arr === 'number') return this; + this.length = 0; + this.push(...this.parse(arr)); + return this; + }, + + toArray() { + return Array.prototype.concat.apply([], this); + }, + + toString() { + return this.join(' '); + }, + + // Flattens the array if needed + valueOf() { + const ret = []; + ret.push(...this); + return ret; + }, + + // Parse whitespace separated string + parse(array = []) { + // If already is an array, no need to parse it + if (array instanceof Array) return array; + return array.trim().split(delimiter).map(parseFloat); + }, + + clone() { + return new this.constructor(this); + }, + + toSet() { + return new Set(this); + } + +}); + +class SVGNumber { + // Initialize + constructor(...args) { + this.init(...args); + } + + init(value, unit) { + unit = Array.isArray(value) ? value[1] : unit; + value = Array.isArray(value) ? value[0] : value; // initialize defaults + + this.value = 0; + this.unit = unit || ''; // parse value + + if (typeof value === 'number') { + // ensure a valid numeric value + this.value = isNaN(value) ? 0 : !isFinite(value) ? value < 0 ? -3.4e+38 : +3.4e+38 : value; + } else if (typeof value === 'string') { + unit = value.match(numberAndUnit); + + if (unit) { + // make value numeric + this.value = parseFloat(unit[1]); // normalize + + if (unit[5] === '%') { + this.value /= 100; + } else if (unit[5] === 's') { + this.value *= 1000; + } // store unit + + + this.unit = unit[5]; + } + } else { + if (value instanceof SVGNumber) { + this.value = value.valueOf(); + this.unit = value.unit; + } + } + + return this; + } + + toString() { + return (this.unit === '%' ? ~~(this.value * 1e8) / 1e6 : this.unit === 's' ? this.value / 1e3 : this.value) + this.unit; + } + + toJSON() { + return this.toString(); + } + + toArray() { + return [this.value, this.unit]; + } + + valueOf() { + return this.value; + } // Add number + + + plus(number) { + number = new SVGNumber(number); + return new SVGNumber(this + number, this.unit || number.unit); + } // Subtract number + + + minus(number) { + number = new SVGNumber(number); + return new SVGNumber(this - number, this.unit || number.unit); + } // Multiply number + + + times(number) { + number = new SVGNumber(number); + return new SVGNumber(this * number, this.unit || number.unit); + } // Divide number + + + divide(number) { + number = new SVGNumber(number); + return new SVGNumber(this / number, this.unit || number.unit); + } + +} + +const hooks = []; +function registerAttrHook(fn) { + hooks.push(fn); +} // Set svg element attribute + +function attr(attr, val, ns) { + // act as full getter + if (attr == null) { + // get an object of attributes + attr = {}; + val = this.node.attributes; + + for (let node of val) { + attr[node.nodeName] = isNumber.test(node.nodeValue) ? parseFloat(node.nodeValue) : node.nodeValue; + } + + return attr; + } else if (attr instanceof Array) { + // loop through array and get all values + return attr.reduce((last, curr) => { + last[curr] = this.attr(curr); + return last; + }, {}); + } else if (typeof attr === 'object' && attr.constructor === Object) { + // apply every attribute individually if an object is passed + for (val in attr) this.attr(val, attr[val]); + } else if (val === null) { + // remove value + this.node.removeAttribute(attr); + } else if (val == null) { + // act as a getter if the first and only argument is not an object + val = this.node.getAttribute(attr); + return val == null ? attrs[attr] : isNumber.test(val) ? parseFloat(val) : val; + } else { + // Loop through hooks and execute them to convert value + val = hooks.reduce((_val, hook) => { + return hook(attr, _val, this); + }, val); // ensure correct numeric values (also accepts NaN and Infinity) + + if (typeof val === 'number') { + val = new SVGNumber(val); + } else if (Color.isColor(val)) { + // ensure full hex color + val = new Color(val); + } else if (val.constructor === Array) { + // Check for plain arrays and parse array values + val = new SVGArray(val); + } // if the passed attribute is leading... + + + if (attr === 'leading') { + // ... call the leading method instead + if (this.leading) { + this.leading(val); + } + } else { + // set given attribute on node + typeof ns === 'string' ? this.node.setAttributeNS(ns, attr, val.toString()) : this.node.setAttribute(attr, val.toString()); + } // rebuild if required + + + if (this.rebuild && (attr === 'font-size' || attr === 'x')) { + this.rebuild(); + } + } + + return this; +} + +class Dom extends EventTarget { + constructor(node, attrs) { + super(node); + this.node = node; + this.type = node.nodeName; + + if (attrs && node !== attrs) { + this.attr(attrs); + } + } // Add given element at a position + + + add(element, i) { + element = makeInstance(element); + + if (i == null) { + this.node.appendChild(element.node); + } else if (element.node !== this.node.childNodes[i]) { + this.node.insertBefore(element.node, this.node.childNodes[i]); + } + + return this; + } // Add element to given container and return self + + + addTo(parent) { + return makeInstance(parent).put(this); + } // Returns all child elements + + + children() { + return new List(map(this.node.children, function (node) { + return adopt(node); + })); + } // Remove all elements in this container + + + clear() { + // remove children + while (this.node.hasChildNodes()) { + this.node.removeChild(this.node.lastChild); + } + + return this; + } // Clone element + + + clone() { + // write dom data to the dom so the clone can pickup the data + this.writeDataToDom(); // clone element and assign new id + + return assignNewId(this.node.cloneNode(true)); + } // Iterates over all children and invokes a given block + + + each(block, deep) { + var children = this.children(); + var i, il; + + for (i = 0, il = children.length; i < il; i++) { + block.apply(children[i], [i, children]); + + if (deep) { + children[i].each(block, deep); + } + } + + return this; + } + + element(nodeName) { + return this.put(new Dom(create(nodeName))); + } // Get first child + + + first() { + return adopt(this.node.firstChild); + } // Get a element at the given index + + + get(i) { + return adopt(this.node.childNodes[i]); + } + + getEventHolder() { + return this.node; + } + + getEventTarget() { + return this.node; + } // Checks if the given element is a child + + + has(element) { + return this.index(element) >= 0; + } // Get / set id + + + id(id) { + // generate new id if no id set + if (typeof id === 'undefined' && !this.node.id) { + this.node.id = eid(this.type); + } // dont't set directly width this.node.id to make `null` work correctly + + + return this.attr('id', id); + } // Gets index of given element + + + index(element) { + return [].slice.call(this.node.childNodes).indexOf(element.node); + } // Get the last child + + + last() { + return adopt(this.node.lastChild); + } // matches the element vs a css selector + + + matches(selector) { + const el = this.node; + return (el.matches || el.matchesSelector || el.msMatchesSelector || el.mozMatchesSelector || el.webkitMatchesSelector || el.oMatchesSelector).call(el, selector); + } // Returns the parent element instance + + + parent(type) { + var parent = this; // check for parent + + if (!parent.node.parentNode) return null; // get parent element + + parent = adopt(parent.node.parentNode); + if (!type) return parent; // loop trough ancestors if type is given + + while (parent) { + if (typeof type === 'string' ? parent.matches(type) : parent instanceof type) return parent; + if (!parent.node.parentNode || parent.node.parentNode.nodeName === '#document' || parent.node.parentNode.nodeName === '#document-fragment') return null; // #759, #720 + + parent = adopt(parent.node.parentNode); + } + } // Basically does the same as `add()` but returns the added element instead + + + put(element, i) { + this.add(element, i); + return element; + } // Add element to given container and return container + + + putIn(parent) { + return makeInstance(parent).add(this); + } // Remove element + + + remove() { + if (this.parent()) { + this.parent().removeElement(this); + } + + return this; + } // Remove a given child + + + removeElement(element) { + this.node.removeChild(element.node); + return this; + } // Replace this with element + + + replace(element) { + element = makeInstance(element); + this.node.parentNode.replaceChild(element.node, this.node); + return element; + } + + round(precision = 2, map$$1) { + const factor = Math.pow(10, precision); + const attrs = this.attr(); // If we have no map, build one from attrs + + if (!map$$1) { + map$$1 = Object.keys(attrs); + } // Holds rounded attributes + + + const newAttrs = {}; + map$$1.forEach(key => { + newAttrs[key] = Math.round(attrs[key] * factor) / factor; + }); + this.attr(newAttrs); + return this; + } // Return id on string conversion + + + toString() { + return this.id(); + } // Import raw svg + + + svg(svgOrFn, outerHTML) { + var well, len, fragment; + + if (svgOrFn === false) { + outerHTML = false; + svgOrFn = null; + } // act as getter if no svg string is given + + + if (svgOrFn == null || typeof svgOrFn === 'function') { + // The default for exports is, that the outerNode is included + outerHTML = outerHTML == null ? true : outerHTML; // write svgjs data to the dom + + this.writeDataToDom(); + let current = this; // An export modifier was passed + + if (svgOrFn != null) { + current = adopt(current.node.cloneNode(true)); // If the user wants outerHTML we need to process this node, too + + if (outerHTML) { + let result = svgOrFn(current); + current = result || current; // The user does not want this node? Well, then he gets nothing + + if (result === false) return ''; + } // Deep loop through all children and apply modifier + + + current.each(function () { + let result = svgOrFn(this); + + let _this = result || this; // If modifier returns false, discard node + + + if (result === false) { + this.remove(); // If modifier returns new node, use it + } else if (result && this !== _this) { + this.replace(_this); + } + }, true); + } // Return outer or inner content + + + return outerHTML ? current.node.outerHTML : current.node.innerHTML; + } // Act as setter if we got a string + // The default for import is, that the current node is not replaced + + + outerHTML = outerHTML == null ? false : outerHTML; // Create temporary holder + + well = globals.document.createElementNS(ns, 'svg'); + fragment = globals.document.createDocumentFragment(); // Dump raw svg + + well.innerHTML = svgOrFn; // Transplant nodes into the fragment + + for (len = well.children.length; len--;) { + fragment.appendChild(well.firstElementChild); + } + + let parent = this.parent(); // Add the whole fragment at once + + return outerHTML ? this.replace(fragment) && parent : this.add(fragment); + } + + words(text) { + // This is faster than removing all children and adding a new one + this.node.textContent = text; + return this; + } // write svgjs data to the dom + + + writeDataToDom() { + // dump variables recursively + this.each(function () { + this.writeDataToDom(); + }); + return this; + } + +} +extend(Dom, { + attr, + find +}); +register(Dom); + +const Svg = getClass(root); +class Element extends Dom { + constructor(node, attrs) { + super(node, attrs); // initialize data object + + this.dom = {}; // create circular reference + + this.node.instance = this; + + if (node.hasAttribute('svgjs:data')) { + // pull svgjs data from the dom (getAttributeNS doesn't work in html5) + this.setData(JSON.parse(node.getAttribute('svgjs:data')) || {}); + } + } // Move element by its center + + + center(x, y) { + return this.cx(x).cy(y); + } // Move by center over x-axis + + + cx(x) { + return x == null ? this.x() + this.width() / 2 : this.x(x - this.width() / 2); + } // Move by center over y-axis + + + cy(y) { + return y == null ? this.y() + this.height() / 2 : this.y(y - this.height() / 2); + } // Get defs + + + defs() { + return this.root().defs(); + } // Relative move over x axis + + + dx(x) { + return this.x(new SVGNumber(x).plus(this.x())); + } // Relative move over y axis + + + dy(y) { + return this.y(new SVGNumber(y).plus(this.y())); + } // Get parent document + + + root() { + let p = this.parent(Svg); + return p && p.root(); + } + + getEventHolder() { + return this; + } // Set height of element + + + height(height) { + return this.attr('height', height); + } // Checks whether the given point inside the bounding box of the element + + + inside(x, y) { + let box = this.bbox(); + return x > box.x && y > box.y && x < box.x + box.width && y < box.y + box.height; + } // Move element to given x and y values + + + move(x, y) { + return this.x(x).y(y); + } // return array of all ancestors of given type up to the root svg + + + parents(until = globals.document) { + until = makeInstance(until); + let parents = new List(); + let parent = this; + + while ((parent = parent.parent()) && parent.node !== until.node && parent.node !== globals.document) { + parents.push(parent); + } + + return parents; + } // Get referenced element form attribute value + + + reference(attr) { + attr = this.attr(attr); + if (!attr) return null; + const m = attr.match(reference); + return m ? makeInstance(m[1]) : null; + } // set given data to the elements data property + + + setData(o) { + this.dom = o; + return this; + } // Set element size to given width and height + + + size(width, height) { + let p = proportionalSize(this, width, height); + return this.width(new SVGNumber(p.width)).height(new SVGNumber(p.height)); + } // Set width of element + + + width(width) { + return this.attr('width', width); + } // write svgjs data to the dom + + + writeDataToDom() { + // remove previously set data + this.node.removeAttribute('svgjs:data'); + + if (Object.keys(this.dom).length) { + this.node.setAttribute('svgjs:data', JSON.stringify(this.dom)); // see #428 + } + + return super.writeDataToDom(); + } // Move over x-axis + + + x(x) { + return this.attr('x', x); + } // Move over y-axis + + + y(y) { + return this.attr('y', y); + } + +} +extend(Element, { + bbox, + rbox, + point, + ctm, + screenCTM +}); +register(Element); + +var sugar = { + stroke: ['color', 'width', 'opacity', 'linecap', 'linejoin', 'miterlimit', 'dasharray', 'dashoffset'], + fill: ['color', 'opacity', 'rule'], + prefix: function (t, a) { + return a === 'color' ? t : t + '-' + a; + } // Add sugar for fill and stroke + +}; +['fill', 'stroke'].forEach(function (m) { + var extension = {}; + var i; + + extension[m] = function (o) { + if (typeof o === 'undefined') { + return this.attr(m); + } + + if (typeof o === 'string' || o instanceof Color || Color.isRgb(o) || o instanceof Element) { + this.attr(m, o); + } else { + // set all attributes from sugar.fill and sugar.stroke list + for (i = sugar[m].length - 1; i >= 0; i--) { + if (o[sugar[m][i]] != null) { + this.attr(sugar.prefix(m, sugar[m][i]), o[sugar[m][i]]); + } + } + } + + return this; + }; + + registerMethods(['Element', 'Runner'], extension); +}); +registerMethods(['Element', 'Runner'], { + // Let the user set the matrix directly + matrix: function (mat, b, c, d, e, f) { + // Act as a getter + if (mat == null) { + return new Matrix(this); + } // Act as a setter, the user can pass a matrix or a set of numbers + + + return this.attr('transform', new Matrix(mat, b, c, d, e, f)); + }, + // Map rotation to transform + rotate: function (angle, cx, cy) { + return this.transform({ + rotate: angle, + ox: cx, + oy: cy + }, true); + }, + // Map skew to transform + skew: function (x, y, cx, cy) { + return arguments.length === 1 || arguments.length === 3 ? this.transform({ + skew: x, + ox: y, + oy: cx + }, true) : this.transform({ + skew: [x, y], + ox: cx, + oy: cy + }, true); + }, + shear: function (lam, cx, cy) { + return this.transform({ + shear: lam, + ox: cx, + oy: cy + }, true); + }, + // Map scale to transform + scale: function (x, y, cx, cy) { + return arguments.length === 1 || arguments.length === 3 ? this.transform({ + scale: x, + ox: y, + oy: cx + }, true) : this.transform({ + scale: [x, y], + ox: cx, + oy: cy + }, true); + }, + // Map translate to transform + translate: function (x, y) { + return this.transform({ + translate: [x, y] + }, true); + }, + // Map relative translations to transform + relative: function (x, y) { + return this.transform({ + relative: [x, y] + }, true); + }, + // Map flip to transform + flip: function (direction, around) { + var directionString = typeof direction === 'string' ? direction : isFinite(direction) ? 'both' : 'both'; + var origin = direction === 'both' && isFinite(around) ? [around, around] : direction === 'x' ? [around, 0] : direction === 'y' ? [0, around] : isFinite(direction) ? [direction, direction] : [0, 0]; + return this.transform({ + flip: directionString, + origin: origin + }, true); + }, + // Opacity + opacity: function (value) { + return this.attr('opacity', value); + }, + // Relative move over x and y axes + dmove: function (x, y) { + return this.dx(x).dy(y); + } +}); +registerMethods('radius', { + // Add x and y radius + radius: function (x, y) { + var type = (this._element || this).type; + return type === 'radialGradient' || type === 'radialGradient' ? this.attr('r', new SVGNumber(x)) : this.rx(x).ry(y == null ? x : y); + } +}); +registerMethods('Path', { + // Get path length + length: function () { + return this.node.getTotalLength(); + }, + // Get point at length + pointAt: function (length) { + return new Point(this.node.getPointAtLength(length)); + } +}); +registerMethods(['Element', 'Runner'], { + // Set font + font: function (a, v) { + if (typeof a === 'object') { + for (v in a) this.font(v, a[v]); + } + + return a === 'leading' ? this.leading(v) : a === 'anchor' ? this.attr('text-anchor', v) : a === 'size' || a === 'family' || a === 'weight' || a === 'stretch' || a === 'variant' || a === 'style' ? this.attr('font-' + a, v) : this.attr(a, v); + } +}); +registerMethods('Text', { + ax(x) { + return this.attr('x', x); + }, + + ay(y) { + return this.attr('y', y); + }, + + amove(x, y) { + return this.ax(x).ay(y); + } + +}); // Add events to elements + +const methods$1 = ['click', 'dblclick', 'mousedown', 'mouseup', 'mouseover', 'mouseout', 'mousemove', 'mouseenter', 'mouseleave', 'touchstart', 'touchmove', 'touchleave', 'touchend', 'touchcancel'].reduce(function (last, event) { + // add event to Element + const fn = function (f) { + if (f === null) { + off(this, event); + } else { + on(this, event, f); + } + + return this; + }; + + last[event] = fn; + return last; +}, {}); +registerMethods('Element', methods$1); + +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 _objectSpread(target) { + for (var i = 1; i < arguments.length; i++) { + var source = arguments[i] != null ? 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 untransform() { + return this.attr('transform', null); +} // merge the whole transformation chain into one matrix and returns it + +function matrixify() { + var matrix = (this.attr('transform') || ''). // split transformations + split(transforms).slice(0, -1).map(function (str) { + // generate key => value pairs + var kv = str.trim().split('('); + return [kv[0], kv[1].split(delimiter).map(function (str) { + return parseFloat(str); + })]; + }).reverse() // merge every transformation into one matrix + .reduce(function (matrix, transform) { + if (transform[0] === 'matrix') { + return matrix.lmultiply(Matrix.fromArray(transform[1])); + } + + return matrix[transform[0]].apply(matrix, transform[1]); + }, new Matrix()); + return matrix; +} // add an element to another parent without changing the visual representation on the screen + +function toParent(parent) { + if (this === parent) return this; + var ctm$$1 = this.screenCTM(); + var pCtm = parent.screenCTM().inverse(); + this.addTo(parent).untransform().transform(pCtm.multiply(ctm$$1)); + return this; +} // same as above with parent equals root-svg + +function toRoot() { + return this.toParent(this.root()); +} // Add transformations + +function transform(o, relative) { + // Act as a getter if no object was passed + if (o == null || typeof o === 'string') { + var decomposed = new Matrix(this).decompose(); + return decomposed[o] || decomposed; + } + + if (!Matrix.isMatrixLike(o)) { + // Set the origin according to the defined transform + o = _objectSpread({}, o, { + origin: getOrigin(o, this) + }); + } // The user can pass a boolean, an Element or an Matrix or nothing + + + var cleanRelative = relative === true ? this : relative || false; + var result = new Matrix(cleanRelative).transform(o); + return this.attr('transform', result); +} +registerMethods('Element', { + untransform, + matrixify, + toParent, + toRoot, + transform +}); + +function rx(rx) { + return this.attr('rx', rx); +} // Radius y value + +function ry(ry) { + return this.attr('ry', ry); +} // Move over x-axis + +function x(x) { + return x == null ? this.cx() - this.rx() : this.cx(x + this.rx()); +} // Move over y-axis + +function y(y) { + return y == null ? this.cy() - this.ry() : this.cy(y + this.ry()); +} // Move by center over x-axis + +function cx(x) { + return x == null ? this.attr('cx') : this.attr('cx', x); +} // Move by center over y-axis + +function cy(y) { + return y == null ? this.attr('cy') : this.attr('cy', y); +} // Set width of element + +function width(width) { + return width == null ? this.rx() * 2 : this.rx(new SVGNumber(width).divide(2)); +} // Set height of element + +function height(height) { + return height == null ? this.ry() * 2 : this.ry(new SVGNumber(height).divide(2)); +} + +var circled = ({ + rx: rx, + ry: ry, + x: x, + y: y, + cx: cx, + cy: cy, + width: width, + height: height +}); + +class Shape extends Element {} +register(Shape); + +class Circle extends Shape { + constructor(node) { + super(nodeOrNew('circle', node), node); + } + + radius(r) { + return this.attr('r', r); + } // Radius x value + + + rx(rx$$1) { + return this.attr('r', rx$$1); + } // Alias radius x value + + + ry(ry$$1) { + return this.rx(ry$$1); + } + + size(size) { + return this.radius(new SVGNumber(size).divide(2)); + } + +} +extend(Circle, { + x, + y, + cx, + cy, + width, + height +}); +registerMethods({ + Element: { + // Create circle element + circle: wrapWithAttrCheck(function (size) { + return this.put(new Circle()).size(size).move(0, 0); + }) + } +}); +register(Circle); + +class Container extends Element { + flatten(parent) { + this.each(function () { + if (this instanceof Container) return this.flatten(parent).ungroup(parent); + return this.toParent(parent); + }); // we need this so that the root does not get removed + + this.node.firstElementChild || this.remove(); + return this; + } + + ungroup(parent) { + parent = parent || this.parent(); + this.each(function () { + return this.toParent(parent); + }); + this.remove(); + return this; + } + +} +register(Container); + +class Defs extends Container { + constructor(node) { + super(nodeOrNew('defs', node), node); + } + + flatten() { + return this; + } + + ungroup() { + return this; + } + +} +register(Defs); + +class Ellipse extends Shape { + constructor(node) { + super(nodeOrNew('ellipse', node), node); + } + + size(width$$1, height$$1) { + var p = proportionalSize(this, width$$1, height$$1); + return this.rx(new SVGNumber(p.width).divide(2)).ry(new SVGNumber(p.height).divide(2)); + } + +} +extend(Ellipse, circled); +registerMethods('Container', { + // Create an ellipse + ellipse: wrapWithAttrCheck(function (width$$1, height$$1) { + return this.put(new Ellipse()).size(width$$1, height$$1).move(0, 0); + }) +}); +register(Ellipse); + +class Stop extends Element { + constructor(node) { + super(nodeOrNew('stop', node), node); + } // add color stops + + + update(o) { + if (typeof o === 'number' || o instanceof SVGNumber) { + o = { + offset: arguments[0], + color: arguments[1], + opacity: arguments[2] + }; + } // set attributes + + + if (o.opacity != null) this.attr('stop-opacity', o.opacity); + if (o.color != null) this.attr('stop-color', o.color); + if (o.offset != null) this.attr('offset', new SVGNumber(o.offset)); + return this; + } + +} +register(Stop); + +function from(x, y) { + return (this._element || this).type === 'radialGradient' ? this.attr({ + fx: new SVGNumber(x), + fy: new SVGNumber(y) + }) : this.attr({ + x1: new SVGNumber(x), + y1: new SVGNumber(y) + }); +} +function to(x, y) { + return (this._element || this).type === 'radialGradient' ? this.attr({ + cx: new SVGNumber(x), + cy: new SVGNumber(y) + }) : this.attr({ + x2: new SVGNumber(x), + y2: new SVGNumber(y) + }); +} + +var gradiented = ({ + from: from, + to: to +}); + +class Gradient extends Container { + constructor(type, attrs) { + super(nodeOrNew(type + 'Gradient', typeof type === 'string' ? null : type), attrs); + } // Add a color stop + + + stop(offset, color, opacity) { + return this.put(new Stop()).update(offset, color, opacity); + } // Update gradient + + + update(block) { + // remove all stops + this.clear(); // invoke passed block + + if (typeof block === 'function') { + block.call(this, this); + } + + return this; + } // Return the fill id + + + url() { + return 'url(#' + this.id() + ')'; + } // Alias string convertion to fill + + + toString() { + return this.url(); + } // custom attr to handle transform + + + attr(a, b, c) { + if (a === 'transform') a = 'gradientTransform'; + return super.attr(a, b, c); + } + + targets() { + return baseFind('svg [fill*="' + this.id() + '"]'); + } + + bbox() { + return new Box(); + } + +} +extend(Gradient, gradiented); +registerMethods({ + Container: { + // Create gradient element in defs + gradient: wrapWithAttrCheck(function (type, block) { + return this.defs().gradient(type, block); + }) + }, + // define gradient + Defs: { + gradient: wrapWithAttrCheck(function (type, block) { + return this.put(new Gradient(type)).update(block); + }) + } +}); +register(Gradient); + +class Pattern extends Container { + // Initialize node + constructor(node) { + super(nodeOrNew('pattern', node), node); + } // Return the fill id + + + url() { + return 'url(#' + this.id() + ')'; + } // Update pattern by rebuilding + + + update(block) { + // remove content + this.clear(); // invoke passed block + + if (typeof block === 'function') { + block.call(this, this); + } + + return this; + } // Alias string convertion to fill + + + toString() { + return this.url(); + } // custom attr to handle transform + + + attr(a, b, c) { + if (a === 'transform') a = 'patternTransform'; + return super.attr(a, b, c); + } + + targets() { + return baseFind('svg [fill*="' + this.id() + '"]'); + } + + bbox() { + return new Box(); + } + +} +registerMethods({ + Container: { + // Create pattern element in defs + pattern(...args) { + return this.defs().pattern(...args); + } + + }, + Defs: { + pattern: wrapWithAttrCheck(function (width, height, block) { + return this.put(new Pattern()).update(block).attr({ + x: 0, + y: 0, + width: width, + height: height, + patternUnits: 'userSpaceOnUse' + }); + }) + } +}); +register(Pattern); + +class Image extends Shape { + constructor(node) { + super(nodeOrNew('image', node), node); + } // (re)load image + + + load(url, callback) { + if (!url) return this; + var img = new globals.window.Image(); + on(img, 'load', function (e) { + var p = this.parent(Pattern); // ensure image size + + if (this.width() === 0 && this.height() === 0) { + this.size(img.width, img.height); + } + + if (p instanceof Pattern) { + // ensure pattern size if not set + if (p.width() === 0 && p.height() === 0) { + p.size(this.width(), this.height()); + } + } + + if (typeof callback === 'function') { + callback.call(this, e); + } + }, this); + on(img, 'load error', function () { + // dont forget to unbind memory leaking events + off(img); + }); + return this.attr('href', img.src = url, xlink); + } + +} +registerAttrHook(function (attr$$1, val, _this) { + // convert image fill and stroke to patterns + if (attr$$1 === 'fill' || attr$$1 === 'stroke') { + if (isImage.test(val)) { + val = _this.root().defs().image(val); + } + } + + if (val instanceof Image) { + val = _this.root().defs().pattern(0, 0, pattern => { + pattern.add(val); + }); + } + + return val; +}); +registerMethods({ + Container: { + // create image element, load image and set its size + image: wrapWithAttrCheck(function (source, callback) { + return this.put(new Image()).size(0, 0).load(source, callback); + }) + } +}); +register(Image); + +const PointArray = subClassArray('PointArray', SVGArray); +extend(PointArray, { + // Convert array to string + toString() { + // convert to a poly point string + for (var i = 0, il = this.length, array = []; i < il; i++) { + array.push(this[i].join(',')); + } + + return array.join(' '); + }, + + // Convert array to line object + toLine() { + return { + x1: this[0][0], + y1: this[0][1], + x2: this[1][0], + y2: this[1][1] + }; + }, + + // Get morphed array at given position + at(pos) { + // make sure a destination is defined + if (!this.destination) return this; // generate morphed point string + + for (var i = 0, il = this.length, array = []; i < il; i++) { + array.push([this[i][0] + (this.destination[i][0] - this[i][0]) * pos, this[i][1] + (this.destination[i][1] - this[i][1]) * pos]); + } + + return new PointArray(array); + }, + + // Parse point string and flat array + parse(array = [[0, 0]]) { + var points = []; // if it is an array + + if (array instanceof Array) { + // and it is not flat, there is no need to parse it + if (array[0] instanceof Array) { + return array; + } + } else { + // Else, it is considered as a string + // parse points + array = array.trim().split(delimiter).map(parseFloat); + } // validate points - https://svgwg.org/svg2-draft/shapes.html#DataTypePoints + // Odd number of coordinates is an error. In such cases, drop the last odd coordinate. + + + if (array.length % 2 !== 0) array.pop(); // wrap points in two-tuples and parse points as floats + + for (var i = 0, len = array.length; i < len; i = i + 2) { + points.push([array[i], array[i + 1]]); + } + + return points; + }, + + // Move point string + move(x, y) { + var box = this.bbox(); // get relative offset + + x -= box.x; + y -= box.y; // move every point + + if (!isNaN(x) && !isNaN(y)) { + for (var i = this.length - 1; i >= 0; i--) { + this[i] = [this[i][0] + x, this[i][1] + y]; + } + } + + return this; + }, + + // Resize poly string + size(width, height) { + var i; + var box = this.bbox(); // recalculate position of all points according to new size + + for (i = this.length - 1; i >= 0; i--) { + if (box.width) this[i][0] = (this[i][0] - box.x) * width / box.width + box.x; + if (box.height) this[i][1] = (this[i][1] - box.y) * height / box.height + box.y; + } + + return this; + }, + + // Get bounding box of points + bbox() { + var maxX = -Infinity; + var maxY = -Infinity; + var minX = Infinity; + var minY = Infinity; + this.forEach(function (el) { + maxX = Math.max(el[0], maxX); + maxY = Math.max(el[1], maxY); + minX = Math.min(el[0], minX); + minY = Math.min(el[1], minY); + }); + return { + x: minX, + y: minY, + width: maxX - minX, + height: maxY - minY + }; + } + +}); + +let MorphArray = PointArray; // Move by left top corner over x-axis + +function x$1(x) { + return x == null ? this.bbox().x : this.move(x, this.bbox().y); +} // Move by left top corner over y-axis + +function y$1(y) { + return y == null ? this.bbox().y : this.move(this.bbox().x, y); +} // Set width of element + +function width$1(width) { + let b = this.bbox(); + return width == null ? b.width : this.size(width, b.height); +} // Set height of element + +function height$1(height) { + let b = this.bbox(); + return height == null ? b.height : this.size(b.width, height); +} + +var pointed = ({ + MorphArray: MorphArray, + x: x$1, + y: y$1, + width: width$1, + height: height$1 +}); + +class Line extends Shape { + // Initialize node + constructor(node) { + super(nodeOrNew('line', node), node); + } // Get array + + + array() { + return new PointArray([[this.attr('x1'), this.attr('y1')], [this.attr('x2'), this.attr('y2')]]); + } // Overwrite native plot() method + + + plot(x1, y1, x2, y2) { + if (x1 == null) { + return this.array(); + } else if (typeof y1 !== 'undefined') { + x1 = { + x1: x1, + y1: y1, + x2: x2, + y2: y2 + }; + } else { + x1 = new PointArray(x1).toLine(); + } + + return this.attr(x1); + } // Move by left top corner + + + move(x, y) { + return this.attr(this.array().move(x, y).toLine()); + } // Set element size to given width and height + + + size(width, height) { + var p = proportionalSize(this, width, height); + return this.attr(this.array().size(p.width, p.height).toLine()); + } + +} +extend(Line, pointed); +registerMethods({ + Container: { + // Create a line element + line: wrapWithAttrCheck(function (...args) { + // make sure plot is called as a setter + // x1 is not necessarily a number, it can also be an array, a string and a PointArray + return Line.prototype.plot.apply(this.put(new Line()), args[0] != null ? args : [0, 0, 0, 0]); + }) + } +}); +register(Line); + +class Marker extends Container { + // Initialize node + constructor(node) { + super(nodeOrNew('marker', node), node); + } // Set width of element + + + width(width) { + return this.attr('markerWidth', width); + } // Set height of element + + + height(height) { + return this.attr('markerHeight', height); + } // Set marker refX and refY + + + ref(x, y) { + return this.attr('refX', x).attr('refY', y); + } // Update marker + + + update(block) { + // remove all content + this.clear(); // invoke passed block + + if (typeof block === 'function') { + block.call(this, this); + } + + return this; + } // Return the fill id + + + toString() { + return 'url(#' + this.id() + ')'; + } + +} +registerMethods({ + Container: { + marker(...args) { + // Create marker element in defs + return this.defs().marker(...args); + } + + }, + Defs: { + // Create marker + marker: wrapWithAttrCheck(function (width, height, block) { + // Set default viewbox to match the width and height, set ref to cx and cy and set orient to auto + return this.put(new Marker()).size(width, height).ref(width / 2, height / 2).viewbox(0, 0, width, height).attr('orient', 'auto').update(block); + }) + }, + marker: { + // Create and attach markers + marker(marker, width, height, block) { + var attr = ['marker']; // Build attribute name + + if (marker !== 'all') attr.push(marker); + attr = attr.join('-'); // Set marker attribute + + marker = arguments[1] instanceof Marker ? arguments[1] : this.defs().marker(width, height, block); + return this.attr(attr, marker); + } + + } +}); +register(Marker); + +function createCommonjsModule(fn, module) { + return module = { exports: {} }, fn(module, module.exports), module.exports; +} + +var _global = createCommonjsModule(function (module) { +// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028 +var global = module.exports = typeof window != 'undefined' && window.Math == Math + ? window : typeof self != 'undefined' && self.Math == Math ? self + // eslint-disable-next-line no-new-func + : Function('return this')(); +if (typeof __g == 'number') __g = global; // eslint-disable-line no-undef +}); + +var _core = createCommonjsModule(function (module) { +var core = module.exports = { version: '2.5.7' }; +if (typeof __e == 'number') __e = core; // eslint-disable-line no-undef +}); + +var _isObject = function (it) { + return typeof it === 'object' ? it !== null : typeof it === 'function'; +}; + +var _anObject = function (it) { + if (!_isObject(it)) throw TypeError(it + ' is not an object!'); + return it; +}; + +var _fails = function (exec) { + try { + return !!exec(); + } catch (e) { + return true; + } +}; + +// Thank's IE8 for his funny defineProperty +var _descriptors = !_fails(function () { + return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7; +}); + +var document$1 = _global.document; +// typeof document.createElement is 'object' in old IE +var is$1 = _isObject(document$1) && _isObject(document$1.createElement); +var _domCreate = function (it) { + return is$1 ? document$1.createElement(it) : {}; +}; + +var _ie8DomDefine = !_descriptors && !_fails(function () { + return Object.defineProperty(_domCreate('div'), 'a', { get: function () { return 7; } }).a != 7; +}); + +// 7.1.1 ToPrimitive(input [, PreferredType]) + +// instead of the ES6 spec version, we didn't implement @@toPrimitive case +// and the second argument - flag - preferred type is a string +var _toPrimitive = function (it, S) { + if (!_isObject(it)) return it; + var fn, val; + if (S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val; + if (typeof (fn = it.valueOf) == 'function' && !_isObject(val = fn.call(it))) return val; + if (!S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val; + throw TypeError("Can't convert object to primitive value"); +}; + +var dP = Object.defineProperty; + +var f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) { + _anObject(O); + P = _toPrimitive(P, true); + _anObject(Attributes); + if (_ie8DomDefine) try { + return dP(O, P, Attributes); + } catch (e) { /* empty */ } + if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!'); + if ('value' in Attributes) O[P] = Attributes.value; + return O; +}; + +var _objectDp = { + f: f +}; + +var _propertyDesc = function (bitmap, value) { + return { + enumerable: !(bitmap & 1), + configurable: !(bitmap & 2), + writable: !(bitmap & 4), + value: value + }; +}; + +var _hide = _descriptors ? function (object, key, value) { + return _objectDp.f(object, key, _propertyDesc(1, value)); +} : function (object, key, value) { + object[key] = value; + return object; +}; + +var hasOwnProperty = {}.hasOwnProperty; +var _has = function (it, key) { + return hasOwnProperty.call(it, key); +}; + +var id = 0; +var px = Math.random(); +var _uid = function (key) { + return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36)); +}; + +var _redefine = createCommonjsModule(function (module) { +var SRC = _uid('src'); +var TO_STRING = 'toString'; +var $toString = Function[TO_STRING]; +var TPL = ('' + $toString).split(TO_STRING); + +_core.inspectSource = function (it) { + return $toString.call(it); +}; + +(module.exports = function (O, key, val, safe) { + var isFunction = typeof val == 'function'; + if (isFunction) _has(val, 'name') || _hide(val, 'name', key); + if (O[key] === val) return; + if (isFunction) _has(val, SRC) || _hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key))); + if (O === _global) { + O[key] = val; + } else if (!safe) { + delete O[key]; + _hide(O, key, val); + } else if (O[key]) { + O[key] = val; + } else { + _hide(O, key, val); + } +// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative +})(Function.prototype, TO_STRING, function toString() { + return typeof this == 'function' && this[SRC] || $toString.call(this); +}); +}); + +var _aFunction = function (it) { + if (typeof it != 'function') throw TypeError(it + ' is not a function!'); + return it; +}; + +// optional / simple context binding + +var _ctx = function (fn, that, length) { + _aFunction(fn); + if (that === undefined) return fn; + switch (length) { + case 1: return function (a) { + return fn.call(that, a); + }; + case 2: return function (a, b) { + return fn.call(that, a, b); + }; + case 3: return function (a, b, c) { + return fn.call(that, a, b, c); + }; + } + return function (/* ...args */) { + return fn.apply(that, arguments); + }; +}; + +var PROTOTYPE = 'prototype'; + +var $export = function (type, name, source) { + var IS_FORCED = type & $export.F; + var IS_GLOBAL = type & $export.G; + var IS_STATIC = type & $export.S; + var IS_PROTO = type & $export.P; + var IS_BIND = type & $export.B; + var target = IS_GLOBAL ? _global : IS_STATIC ? _global[name] || (_global[name] = {}) : (_global[name] || {})[PROTOTYPE]; + var exports = IS_GLOBAL ? _core : _core[name] || (_core[name] = {}); + var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {}); + var key, own, out, exp; + if (IS_GLOBAL) source = name; + for (key in source) { + // contains in native + own = !IS_FORCED && target && target[key] !== undefined; + // export native or passed + out = (own ? target : source)[key]; + // bind timers to global for call from export context + exp = IS_BIND && own ? _ctx(out, _global) : IS_PROTO && typeof out == 'function' ? _ctx(Function.call, out) : out; + // extend global + if (target) _redefine(target, key, out, type & $export.U); + // export + if (exports[key] != out) _hide(exports, key, exp); + if (IS_PROTO && expProto[key] != out) expProto[key] = out; + } +}; +_global.core = _core; +// type bitmap +$export.F = 1; // forced +$export.G = 2; // global +$export.S = 4; // static +$export.P = 8; // proto +$export.B = 16; // bind +$export.W = 32; // wrap +$export.U = 64; // safe +$export.R = 128; // real proto method for `library` +var _export = $export; + +// 7.2.1 RequireObjectCoercible(argument) +var _defined = function (it) { + if (it == undefined) throw TypeError("Can't call method on " + it); + return it; +}; + +// 7.1.13 ToObject(argument) + +var _toObject = function (it) { + return Object(_defined(it)); +}; + +var _strictMethod = function (method, arg) { + return !!method && _fails(function () { + // eslint-disable-next-line no-useless-call + arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null); + }); +}; + +var $sort = [].sort; +var test = [1, 2, 3]; + +_export(_export.P + _export.F * (_fails(function () { + // IE8- + test.sort(undefined); +}) || !_fails(function () { + // V8 bug + test.sort(null); + // Old WebKit +}) || !_strictMethod($sort)), 'Array', { + // 22.1.3.25 Array.prototype.sort(comparefn) + sort: function sort(comparefn) { + return comparefn === undefined + ? $sort.call(_toObject(this)) + : $sort.call(_toObject(this), _aFunction(comparefn)); + } +}); + +/*** +Base Class +========== +The base stepper class that will be +***/ + +function makeSetterGetter(k, f) { + return function (v) { + if (v == null) return this[v]; + this[k] = v; + if (f) f.call(this); + return this; + }; +} + +let easing = { + '-': function (pos) { + return pos; + }, + '<>': function (pos) { + return -Math.cos(pos * Math.PI) / 2 + 0.5; + }, + '>': function (pos) { + return Math.sin(pos * Math.PI / 2); + }, + '<': function (pos) { + return -Math.cos(pos * Math.PI / 2) + 1; + }, + bezier: function (x1, y1, x2, y2) { + // see https://www.w3.org/TR/css-easing-1/#cubic-bezier-algo + return function (t) { + if (t < 0) { + if (x1 > 0) { + return y1 / x1 * t; + } else if (x2 > 0) { + return y2 / x2 * t; + } else { + return 0; + } + } else if (t > 1) { + if (x2 < 1) { + return (1 - y2) / (1 - x2) * t + (y2 - x2) / (1 - x2); + } else if (x1 < 1) { + return (1 - y1) / (1 - x1) * t + (y1 - x1) / (1 - x1); + } else { + return 1; + } + } else { + return 3 * t * Math.pow(1 - t, 2) * y1 + 3 * Math.pow(t, 2) * (1 - t) * y2 + Math.pow(t, 3); + } + }; + }, + // see https://www.w3.org/TR/css-easing-1/#step-timing-function-algo + steps: function (steps, stepPosition = 'end') { + // deal with "jump-" prefix + stepPosition = stepPosition.split('-').reverse()[0]; + let jumps = steps; + + if (stepPosition === 'none') { + --jumps; + } else if (stepPosition === 'both') { + ++jumps; + } // The beforeFlag is essentially useless + + + return (t, beforeFlag = false) => { + // Step is called currentStep in referenced url + let step = Math.floor(t * steps); + const jumping = t * step % 1 === 0; + + if (stepPosition === 'start' || stepPosition === 'both') { + ++step; + } + + if (beforeFlag && jumping) { + --step; + } + + if (t >= 0 && step < 0) { + step = 0; + } + + if (t <= 1 && step > jumps) { + step = jumps; + } + + return step / jumps; + }; + } +}; +class Stepper { + done() { + return false; + } + +} +/*** +Easing Functions +================ +***/ + +class Ease extends Stepper { + constructor(fn) { + super(); + this.ease = easing[fn || timeline.ease] || fn; + } + + step(from, to, pos) { + if (typeof from !== 'number') { + return pos < 1 ? from : to; + } + + return from + (to - from) * this.ease(pos); + } + +} +/*** +Controller Types +================ +***/ + +class Controller extends Stepper { + constructor(fn) { + super(); + this.stepper = fn; + } + + step(current, target, dt, c) { + return this.stepper(current, target, dt, c); + } + + done(c) { + return c.done; + } + +} + +function recalculate() { + // Apply the default parameters + var duration = (this._duration || 500) / 1000; + var overshoot = this._overshoot || 0; // Calculate the PID natural response + + var eps = 1e-10; + var pi = Math.PI; + var os = Math.log(overshoot / 100 + eps); + var zeta = -os / Math.sqrt(pi * pi + os * os); + var wn = 3.9 / (zeta * duration); // Calculate the Spring values + + this.d = 2 * zeta * wn; + this.k = wn * wn; +} + +class Spring extends Controller { + constructor(duration, overshoot) { + super(); + this.duration(duration || 500).overshoot(overshoot || 0); + } + + step(current, target, dt, c) { + if (typeof current === 'string') return current; + c.done = dt === Infinity; + if (dt === Infinity) return target; + if (dt === 0) return current; + if (dt > 100) dt = 16; + dt /= 1000; // Get the previous velocity + + var velocity = c.velocity || 0; // Apply the control to get the new position and store it + + var acceleration = -this.d * velocity - this.k * (current - target); + var newPosition = current + velocity * dt + acceleration * dt * dt / 2; // Store the velocity + + c.velocity = velocity + acceleration * dt; // Figure out if we have converged, and if so, pass the value + + c.done = Math.abs(target - newPosition) + Math.abs(velocity) < 0.002; + return c.done ? target : newPosition; + } + +} +extend(Spring, { + duration: makeSetterGetter('_duration', recalculate), + overshoot: makeSetterGetter('_overshoot', recalculate) +}); +class PID extends Controller { + constructor(p, i, d, windup) { + super(); + p = p == null ? 0.1 : p; + i = i == null ? 0.01 : i; + d = d == null ? 0 : d; + windup = windup == null ? 1000 : windup; + this.p(p).i(i).d(d).windup(windup); + } + + step(current, target, dt, c) { + if (typeof current === 'string') return current; + c.done = dt === Infinity; + if (dt === Infinity) return target; + if (dt === 0) return current; + var p = target - current; + var i = (c.integral || 0) + p * dt; + var d = (p - (c.error || 0)) / dt; + var windup = this.windup; // antiwindup + + if (windup !== false) { + i = Math.max(-windup, Math.min(i, windup)); + } + + c.error = p; + c.integral = i; + c.done = Math.abs(p) < 0.001; + return c.done ? target : current + (this.P * p + this.I * i + this.D * d); + } + +} +extend(PID, { + windup: makeSetterGetter('windup'), + p: makeSetterGetter('P'), + i: makeSetterGetter('I'), + d: makeSetterGetter('D') +}); + +const PathArray = subClassArray('PathArray', SVGArray); +function pathRegReplace(a, b, c, d) { + return c + d.replace(dots, ' .'); +} + +function arrayToString(a) { + for (var i = 0, il = a.length, s = ''; i < il; i++) { + s += a[i][0]; + + if (a[i][1] != null) { + s += a[i][1]; + + if (a[i][2] != null) { + s += ' '; + s += a[i][2]; + + if (a[i][3] != null) { + s += ' '; + s += a[i][3]; + s += ' '; + s += a[i][4]; + + if (a[i][5] != null) { + s += ' '; + s += a[i][5]; + s += ' '; + s += a[i][6]; + + if (a[i][7] != null) { + s += ' '; + s += a[i][7]; + } + } + } + } + } + } + + return s + ' '; +} + +const pathHandlers = { + M: function (c, p, p0) { + p.x = p0.x = c[0]; + p.y = p0.y = c[1]; + return ['M', p.x, p.y]; + }, + L: function (c, p) { + p.x = c[0]; + p.y = c[1]; + return ['L', c[0], c[1]]; + }, + H: function (c, p) { + p.x = c[0]; + return ['H', c[0]]; + }, + V: function (c, p) { + p.y = c[0]; + return ['V', c[0]]; + }, + C: function (c, p) { + p.x = c[4]; + p.y = c[5]; + return ['C', c[0], c[1], c[2], c[3], c[4], c[5]]; + }, + S: function (c, p) { + p.x = c[2]; + p.y = c[3]; + return ['S', c[0], c[1], c[2], c[3]]; + }, + Q: function (c, p) { + p.x = c[2]; + p.y = c[3]; + return ['Q', c[0], c[1], c[2], c[3]]; + }, + T: function (c, p) { + p.x = c[0]; + p.y = c[1]; + return ['T', c[0], c[1]]; + }, + Z: function (c, p, p0) { + p.x = p0.x; + p.y = p0.y; + return ['Z']; + }, + A: function (c, p) { + p.x = c[5]; + p.y = c[6]; + return ['A', c[0], c[1], c[2], c[3], c[4], c[5], c[6]]; + } +}; +let mlhvqtcsaz = 'mlhvqtcsaz'.split(''); + +for (var i = 0, il = mlhvqtcsaz.length; i < il; ++i) { + pathHandlers[mlhvqtcsaz[i]] = function (i) { + return function (c, p, p0) { + if (i === 'H') c[0] = c[0] + p.x;else if (i === 'V') c[0] = c[0] + p.y;else if (i === 'A') { + c[5] = c[5] + p.x; + c[6] = c[6] + p.y; + } else { + for (var j = 0, jl = c.length; j < jl; ++j) { + c[j] = c[j] + (j % 2 ? p.y : p.x); + } + } + return pathHandlers[i](c, p, p0); + }; + }(mlhvqtcsaz[i].toUpperCase()); +} + +extend(PathArray, { + // Convert array to string + toString() { + return arrayToString(this); + }, + + // Move path string + move(x, y) { + // get bounding box of current situation + var box = this.bbox(); // get relative offset + + x -= box.x; + y -= box.y; + + if (!isNaN(x) && !isNaN(y)) { + // move every point + for (var l, i = this.length - 1; i >= 0; i--) { + l = this[i][0]; + + if (l === 'M' || l === 'L' || l === 'T') { + this[i][1] += x; + this[i][2] += y; + } else if (l === 'H') { + this[i][1] += x; + } else if (l === 'V') { + this[i][1] += y; + } else if (l === 'C' || l === 'S' || l === 'Q') { + this[i][1] += x; + this[i][2] += y; + this[i][3] += x; + this[i][4] += y; + + if (l === 'C') { + this[i][5] += x; + this[i][6] += y; + } + } else if (l === 'A') { + this[i][6] += x; + this[i][7] += y; + } + } + } + + return this; + }, + + // Resize path string + size(width, height) { + // get bounding box of current situation + var box = this.bbox(); + var i, l; // recalculate position of all points according to new size + + for (i = this.length - 1; i >= 0; i--) { + l = this[i][0]; + + if (l === 'M' || l === 'L' || l === 'T') { + this[i][1] = (this[i][1] - box.x) * width / box.width + box.x; + this[i][2] = (this[i][2] - box.y) * height / box.height + box.y; + } else if (l === 'H') { + this[i][1] = (this[i][1] - box.x) * width / box.width + box.x; + } else if (l === 'V') { + this[i][1] = (this[i][1] - box.y) * height / box.height + box.y; + } else if (l === 'C' || l === 'S' || l === 'Q') { + this[i][1] = (this[i][1] - box.x) * width / box.width + box.x; + this[i][2] = (this[i][2] - box.y) * height / box.height + box.y; + this[i][3] = (this[i][3] - box.x) * width / box.width + box.x; + this[i][4] = (this[i][4] - box.y) * height / box.height + box.y; + + if (l === 'C') { + this[i][5] = (this[i][5] - box.x) * width / box.width + box.x; + this[i][6] = (this[i][6] - box.y) * height / box.height + box.y; + } + } else if (l === 'A') { + // resize radii + this[i][1] = this[i][1] * width / box.width; + this[i][2] = this[i][2] * height / box.height; // move position values + + this[i][6] = (this[i][6] - box.x) * width / box.width + box.x; + this[i][7] = (this[i][7] - box.y) * height / box.height + box.y; + } + } + + return this; + }, + + // Test if the passed path array use the same path data commands as this path array + equalCommands(pathArray) { + var i, il, equalCommands; + pathArray = new PathArray(pathArray); + equalCommands = this.length === pathArray.length; + + for (i = 0, il = this.length; equalCommands && i < il; i++) { + equalCommands = this[i][0] === pathArray[i][0]; + } + + return equalCommands; + }, + + // Make path array morphable + morph(pathArray) { + pathArray = new PathArray(pathArray); + + if (this.equalCommands(pathArray)) { + this.destination = pathArray; + } else { + this.destination = null; + } + + return this; + }, + + // Get morphed path array at given position + at(pos) { + // make sure a destination is defined + if (!this.destination) return this; + var sourceArray = this; + var destinationArray = this.destination.value; + var array = []; + var pathArray = new PathArray(); + var i, il, j, jl; // Animate has specified in the SVG spec + // See: https://www.w3.org/TR/SVG11/paths.html#PathElement + + for (i = 0, il = sourceArray.length; i < il; i++) { + array[i] = [sourceArray[i][0]]; + + for (j = 1, jl = sourceArray[i].length; j < jl; j++) { + array[i][j] = sourceArray[i][j] + (destinationArray[i][j] - sourceArray[i][j]) * pos; + } // For the two flags of the elliptical arc command, the SVG spec say: + // Flags and booleans are interpolated as fractions between zero and one, with any non-zero value considered to be a value of one/true + // Elliptical arc command as an array followed by corresponding indexes: + // ['A', rx, ry, x-axis-rotation, large-arc-flag, sweep-flag, x, y] + // 0 1 2 3 4 5 6 7 + + + if (array[i][0] === 'A') { + array[i][4] = +(array[i][4] !== 0); + array[i][5] = +(array[i][5] !== 0); + } + } // Directly modify the value of a path array, this is done this way for performance + + + pathArray.value = array; + return pathArray; + }, + + // Absolutize and parse path to array + parse(array = [['M', 0, 0]]) { + // if it's already a patharray, no need to parse it + if (array instanceof PathArray) return array; // prepare for parsing + + var s; + var paramCnt = { + 'M': 2, + 'L': 2, + 'H': 1, + 'V': 1, + 'C': 6, + 'S': 4, + 'Q': 4, + 'T': 2, + 'A': 7, + 'Z': 0 + }; + + if (typeof array === 'string') { + array = array.replace(numbersWithDots, pathRegReplace) // convert 45.123.123 to 45.123 .123 + .replace(pathLetters, ' $& ') // put some room between letters and numbers + .replace(hyphen, '$1 -') // add space before hyphen + .trim() // trim + .split(delimiter); // split into array + } else { + array = array.reduce(function (prev, curr) { + return [].concat.call(prev, curr); + }, []); + } // array now is an array containing all parts of a path e.g. ['M', '0', '0', 'L', '30', '30' ...] + + + var result = []; + var p = new Point(); + var p0 = new Point(); + var index = 0; + var len = array.length; + + do { + // Test if we have a path letter + if (isPathLetter.test(array[index])) { + s = array[index]; + ++index; // If last letter was a move command and we got no new, it defaults to [L]ine + } else if (s === 'M') { + s = 'L'; + } else if (s === 'm') { + s = 'l'; + } + + result.push(pathHandlers[s].call(null, array.slice(index, index = index + paramCnt[s.toUpperCase()]).map(parseFloat), p, p0)); + } while (len > index); + + return result; + }, + + // Get bounding box of path + bbox() { + parser().path.setAttribute('d', this.toString()); + return parser.nodes.path.getBBox(); + } + +}); + +class Morphable { + constructor(stepper) { + this._stepper = stepper || new Ease('-'); + this._from = null; + this._to = null; + this._type = null; + this._context = null; + this._morphObj = null; + } + + from(val) { + if (val == null) { + return this._from; + } + + this._from = this._set(val); + return this; + } + + to(val) { + if (val == null) { + return this._to; + } + + this._to = this._set(val); + return this; + } + + type(type) { + // getter + if (type == null) { + return this._type; + } // setter + + + this._type = type; + return this; + } + + _set(value) { + if (!this._type) { + var type = typeof value; + + if (type === 'number') { + this.type(SVGNumber); + } else if (type === 'string') { + if (Color.isColor(value)) { + this.type(Color); + } else if (delimiter.test(value)) { + this.type(pathLetters.test(value) ? PathArray : SVGArray); + } else if (numberAndUnit.test(value)) { + this.type(SVGNumber); + } else { + this.type(NonMorphable); + } + } else if (morphableTypes.indexOf(value.constructor) > -1) { + this.type(value.constructor); + } else if (Array.isArray(value)) { + this.type(SVGArray); + } else if (type === 'object') { + this.type(ObjectBag); + } else { + this.type(NonMorphable); + } + } + + var result = new this._type(value); + + if (this._type === Color) { + result = this._to ? result[this._to[4]]() : this._from ? result[this._from[4]]() : result; + } + + result = result.toArray(); + this._morphObj = this._morphObj || new this._type(); + this._context = this._context || Array.apply(null, Array(result.length)).map(Object).map(function (o) { + o.done = true; + return o; + }); + return result; + } + + stepper(stepper) { + if (stepper == null) return this._stepper; + this._stepper = stepper; + return this; + } + + done() { + var complete = this._context.map(this._stepper.done).reduce(function (last, curr) { + return last && curr; + }, true); + + return complete; + } + + at(pos) { + var _this = this; + + return this._morphObj.fromArray(this._from.map(function (i, index) { + return _this._stepper.step(i, _this._to[index], pos, _this._context[index], _this._context); + })); + } + +} +class NonMorphable { + constructor(...args) { + this.init(...args); + } + + init(val) { + val = Array.isArray(val) ? val[0] : val; + this.value = val; + return this; + } + + valueOf() { + return this.value; + } + + toArray() { + return [this.value]; + } + +} +class TransformBag { + constructor(...args) { + this.init(...args); + } + + init(obj) { + if (Array.isArray(obj)) { + obj = { + scaleX: obj[0], + scaleY: obj[1], + shear: obj[2], + rotate: obj[3], + translateX: obj[4], + translateY: obj[5], + originX: obj[6], + originY: obj[7] + }; + } + + Object.assign(this, TransformBag.defaults, obj); + return this; + } + + toArray() { + var v = this; + return [v.scaleX, v.scaleY, v.shear, v.rotate, v.translateX, v.translateY, v.originX, v.originY]; + } + +} +TransformBag.defaults = { + scaleX: 1, + scaleY: 1, + shear: 0, + rotate: 0, + translateX: 0, + translateY: 0, + originX: 0, + originY: 0 +}; +class ObjectBag { + constructor(...args) { + this.init(...args); + } + + init(objOrArr) { + this.values = []; + + if (Array.isArray(objOrArr)) { + this.values = objOrArr; + return; + } + + objOrArr = objOrArr || {}; + var entries = []; + + for (let i in objOrArr) { + entries.push([i, objOrArr[i]]); + } + + entries.sort((a, b) => { + return a[0] - b[0]; + }); + this.values = entries.reduce((last, curr) => last.concat(curr), []); + return this; + } + + valueOf() { + var obj = {}; + var arr = this.values; + + for (var i = 0, len = arr.length; i < len; i += 2) { + obj[arr[i]] = arr[i + 1]; + } + + return obj; + } + + toArray() { + return this.values; + } + +} +const morphableTypes = [NonMorphable, TransformBag, ObjectBag]; +function registerMorphableType(type = []) { + morphableTypes.push(...[].concat(type)); +} +function makeMorphable() { + extend(morphableTypes, { + to(val) { + return new Morphable().type(this.constructor).from(this.valueOf()).to(val); + }, + + fromArray(arr) { + this.init(arr); + return this; + } + + }); +} + +class Path extends Shape { + // Initialize node + constructor(node) { + super(nodeOrNew('path', node), node); + } // Get array + + + array() { + return this._array || (this._array = new PathArray(this.attr('d'))); + } // Plot new path + + + plot(d) { + return d == null ? this.array() : this.clear().attr('d', typeof d === 'string' ? d : this._array = new PathArray(d)); + } // Clear array cache + + + clear() { + delete this._array; + return this; + } // Move by left top corner + + + move(x, y) { + return this.attr('d', this.array().move(x, y)); + } // Move by left top corner over x-axis + + + x(x) { + return x == null ? this.bbox().x : this.move(x, this.bbox().y); + } // Move by left top corner over y-axis + + + y(y) { + return y == null ? this.bbox().y : this.move(this.bbox().x, y); + } // Set element size to given width and height + + + size(width, height) { + var p = proportionalSize(this, width, height); + return this.attr('d', this.array().size(p.width, p.height)); + } // Set width of element + + + width(width) { + return width == null ? this.bbox().width : this.size(width, this.bbox().height); + } // Set height of element + + + height(height) { + return height == null ? this.bbox().height : this.size(this.bbox().width, height); + } + + targets() { + return baseFind('svg textpath [href*="' + this.id() + '"]'); + } + +} // Define morphable array + +Path.prototype.MorphArray = PathArray; // Add parent method + +registerMethods({ + Container: { + // Create a wrapped path element + path: wrapWithAttrCheck(function (d) { + // make sure plot is called as a setter + return this.put(new Path()).plot(d || new PathArray()); + }) + } +}); +register(Path); + +function array() { + return this._array || (this._array = new PointArray(this.attr('points'))); +} // Plot new path + +function plot(p) { + return p == null ? this.array() : this.clear().attr('points', typeof p === 'string' ? p : this._array = new PointArray(p)); +} // Clear array cache + +function clear() { + delete this._array; + return this; +} // Move by left top corner + +function move(x, y) { + return this.attr('points', this.array().move(x, y)); +} // Set element size to given width and height + +function size(width, height) { + let p = proportionalSize(this, width, height); + return this.attr('points', this.array().size(p.width, p.height)); +} + +var poly = ({ + array: array, + plot: plot, + clear: clear, + move: move, + size: size +}); + +class Polygon extends Shape { + // Initialize node + constructor(node) { + super(nodeOrNew('polygon', node), node); + } + +} +registerMethods({ + Container: { + // Create a wrapped polygon element + polygon: wrapWithAttrCheck(function (p) { + // make sure plot is called as a setter + return this.put(new Polygon()).plot(p || new PointArray()); + }) + } +}); +extend(Polygon, pointed); +extend(Polygon, poly); +register(Polygon); + +class Polyline extends Shape { + // Initialize node + constructor(node) { + super(nodeOrNew('polyline', node), node); + } + +} +registerMethods({ + Container: { + // Create a wrapped polygon element + polyline: wrapWithAttrCheck(function (p) { + // make sure plot is called as a setter + return this.put(new Polyline()).plot(p || new PointArray()); + }) + } +}); +extend(Polyline, pointed); +extend(Polyline, poly); +register(Polyline); + +class Rect extends Shape { + // Initialize node + constructor(node) { + super(nodeOrNew('rect', node), node); + } + +} +extend(Rect, { + rx, + ry +}); +registerMethods({ + Container: { + // Create a rect element + rect: wrapWithAttrCheck(function (width$$1, height$$1) { + return this.put(new Rect()).size(width$$1, height$$1); + }) + } +}); +register(Rect); + +class Queue { + constructor() { + this._first = null; + this._last = null; + } + + push(value) { + // An item stores an id and the provided value + var item = value.next ? value : { + value: value, + next: null, + prev: null // Deal with the queue being empty or populated + + }; + + if (this._last) { + item.prev = this._last; + this._last.next = item; + this._last = item; + } else { + this._last = item; + this._first = item; + } // Return the current item + + + return item; + } + + shift() { + // Check if we have a value + var remove = this._first; + if (!remove) return null; // If we do, remove it and relink things + + this._first = remove.next; + if (this._first) this._first.prev = null; + this._last = this._first ? this._last : null; + return remove.value; + } // Shows us the first item in the list + + + first() { + return this._first && this._first.value; + } // Shows us the last item in the list + + + last() { + return this._last && this._last.value; + } // Removes the item that was returned from the push + + + remove(item) { + // Relink the previous item + if (item.prev) item.prev.next = item.next; + if (item.next) item.next.prev = item.prev; + if (item === this._last) this._last = item.prev; + if (item === this._first) this._first = item.next; // Invalidate item + + item.prev = null; + item.next = null; + } + +} + +const Animator = { + nextDraw: null, + frames: new Queue(), + timeouts: new Queue(), + immediates: new Queue(), + timer: () => globals.window.performance || globals.window.Date, + transforms: [], + + frame(fn) { + // Store the node + var node = Animator.frames.push({ + run: fn + }); // Request an animation frame if we don't have one + + if (Animator.nextDraw === null) { + Animator.nextDraw = globals.window.requestAnimationFrame(Animator._draw); + } // Return the node so we can remove it easily + + + return node; + }, + + timeout(fn, delay) { + delay = delay || 0; // Work out when the event should fire + + var time = Animator.timer().now() + delay; // Add the timeout to the end of the queue + + var node = Animator.timeouts.push({ + run: fn, + time: time + }); // Request another animation frame if we need one + + if (Animator.nextDraw === null) { + Animator.nextDraw = globals.window.requestAnimationFrame(Animator._draw); + } + + return node; + }, + + immediate(fn) { + // Add the immediate fn to the end of the queue + var node = Animator.immediates.push(fn); // Request another animation frame if we need one + + if (Animator.nextDraw === null) { + Animator.nextDraw = globals.window.requestAnimationFrame(Animator._draw); + } + + return node; + }, + + cancelFrame(node) { + node != null && Animator.frames.remove(node); + }, + + clearTimeout(node) { + node != null && Animator.timeouts.remove(node); + }, + + cancelImmediate(node) { + node != null && Animator.immediates.remove(node); + }, + + _draw(now) { + // Run all the timeouts we can run, if they are not ready yet, add them + // to the end of the queue immediately! (bad timeouts!!! [sarcasm]) + var nextTimeout = null; + var lastTimeout = Animator.timeouts.last(); + + while (nextTimeout = Animator.timeouts.shift()) { + // Run the timeout if its time, or push it to the end + if (now >= nextTimeout.time) { + nextTimeout.run(); + } else { + Animator.timeouts.push(nextTimeout); + } // If we hit the last item, we should stop shifting out more items + + + if (nextTimeout === lastTimeout) break; + } // Run all of the animation frames + + + var nextFrame = null; + var lastFrame = Animator.frames.last(); + + while (nextFrame !== lastFrame && (nextFrame = Animator.frames.shift())) { + nextFrame.run(now); + } + + var nextImmediate = null; + + while (nextImmediate = Animator.immediates.shift()) { + nextImmediate(); + } // If we have remaining timeouts or frames, draw until we don't anymore + + + Animator.nextDraw = Animator.timeouts.first() || Animator.frames.first() ? globals.window.requestAnimationFrame(Animator._draw) : null; + } + +}; + +var makeSchedule = function (runnerInfo) { + var start = runnerInfo.start; + var duration = runnerInfo.runner.duration(); + var end = start + duration; + return { + start: start, + duration: duration, + end: end, + runner: runnerInfo.runner + }; +}; + +const defaultSource = function () { + let w = globals.window; + return (w.performance || w.Date).now(); +}; + +class Timeline extends EventTarget { + // Construct a new timeline on the given element + constructor(timeSource = defaultSource) { + super(); + this._timeSource = timeSource; // Store the timing variables + + this._startTime = 0; + this._speed = 1.0; // Determines how long a runner is hold in memory. Can be a dt or true/false + + this._persist = 0; // Keep track of the running animations and their starting parameters + + this._nextFrame = null; + this._paused = true; + this._runners = []; + this._runnerIds = []; + this._lastRunnerId = -1; + this._time = 0; + this._lastSourceTime = 0; + this._lastStepTime = 0; // Make sure that step is always called in class context + + this._step = this._stepFn.bind(this, false); + this._stepImmediate = this._stepFn.bind(this, true); + } // schedules a runner on the timeline + + + schedule(runner, delay, when) { + if (runner == null) { + return this._runners.map(makeSchedule); + } // The start time for the next animation can either be given explicitly, + // derived from the current timeline time or it can be relative to the + // last start time to chain animations direclty + + + var absoluteStartTime = 0; + var endTime = this.getEndTime(); + delay = delay || 0; // Work out when to start the animation + + if (when == null || when === 'last' || when === 'after') { + // Take the last time and increment + absoluteStartTime = endTime; + } else if (when === 'absolute' || when === 'start') { + absoluteStartTime = delay; + delay = 0; + } else if (when === 'now') { + absoluteStartTime = this._time; + } else if (when === 'relative') { + let runnerInfo = this._runners[runner.id]; + + if (runnerInfo) { + absoluteStartTime = runnerInfo.start + delay; + delay = 0; + } + } else { + throw new Error('Invalid value for the "when" parameter'); + } // Manage runner + + + runner.unschedule(); + runner.timeline(this); + const persist = runner.persist(); + const runnerInfo = { + persist: persist === null ? this._persist : persist, + start: absoluteStartTime + delay, + runner + }; + this._lastRunnerId = runner.id; + + this._runners.push(runnerInfo); + + this._runners.sort((a, b) => a.start - b.start); + + this._runnerIds = this._runners.map(info => info.runner.id); + + this.updateTime()._continue(); + + return this; + } // Remove the runner from this timeline + + + unschedule(runner) { + var index = this._runnerIds.indexOf(runner.id); + + if (index < 0) return this; + + this._runners.splice(index, 1); + + this._runnerIds.splice(index, 1); + + runner.timeline(null); + return this; + } // Calculates the end of the timeline + + + getEndTime() { + var lastRunnerInfo = this._runners[this._runnerIds.indexOf(this._lastRunnerId)]; + + var lastDuration = lastRunnerInfo ? lastRunnerInfo.runner.duration() : 0; + var lastStartTime = lastRunnerInfo ? lastRunnerInfo.start : 0; + return lastStartTime + lastDuration; + } // Makes sure, that after pausing the time doesn't jump + + + updateTime() { + if (!this.active()) { + this._lastSourceTime = this._timeSource(); + } + + return this; + } + + play() { + // Now make sure we are not paused and continue the animation + this._paused = false; + return this.updateTime()._continue(); + } + + pause() { + this._paused = true; + return this._continue(); + } + + stop() { + // Go to start and pause + this.time(0); + return this.pause(); + } + + finish() { + // Go to end and pause + this.time(this.getEndTime() + 1); + return this.pause(); + } + + speed(speed) { + if (speed == null) return this._speed; + this._speed = speed; + return this; + } + + reverse(yes) { + var currentSpeed = this.speed(); + if (yes == null) return this.speed(-currentSpeed); + var positive = Math.abs(currentSpeed); + return this.speed(yes ? positive : -positive); + } + + seek(dt) { + return this.time(this._time + dt); + } + + time(time) { + if (time == null) return this._time; + this._time = time; + return this._continue(true); + } + + persist(dtOrForever) { + if (dtOrForever == null) return this._persist; + this._persist = dtOrForever; + return this; + } + + source(fn) { + if (fn == null) return this._timeSource; + this._timeSource = fn; + return this; + } + + _stepFn(immediateStep = false) { + // Get the time delta from the last time and update the time + var time = this._timeSource(); + + var dtSource = time - this._lastSourceTime; + if (immediateStep) dtSource = 0; + var dtTime = this._speed * dtSource + (this._time - this._lastStepTime); + this._lastSourceTime = time; // Only update the time if we use the timeSource. + // Otherwise use the current time + + if (!immediateStep) { + // Update the time + this._time += dtTime; + this._time = this._time < 0 ? 0 : this._time; + } + + this._lastStepTime = this._time; + this.fire('time', this._time); // This is for the case that the timeline was seeked so that the time + // is now before the startTime of the runner. Thats why we need to set + // the runner to position 0 + // FIXME: + // However, reseting in insertion order leads to bugs. Considering the case, + // where 2 runners change the same attriute but in different times, + // reseting both of them will lead to the case where the later defined + // runner always wins the reset even if the other runner started earlier + // and therefore should win the attribute battle + // this can be solved by reseting them backwards + + for (var k = this._runners.length; k--;) { + // Get and run the current runner and ignore it if its inactive + let runnerInfo = this._runners[k]; + let runner = runnerInfo.runner; // Make sure that we give the actual difference + // between runner start time and now + + let dtToStart = this._time - runnerInfo.start; // Dont run runner if not started yet + // and try to reset it + + if (dtToStart <= 0) { + runner.reset(); + } + } // Run all of the runners directly + + + var runnersLeft = false; + + for (var i = 0, len = this._runners.length; i < len; i++) { + // Get and run the current runner and ignore it if its inactive + let runnerInfo = this._runners[i]; + let runner = runnerInfo.runner; + let dt = dtTime; // Make sure that we give the actual difference + // between runner start time and now + + let dtToStart = this._time - runnerInfo.start; // Dont run runner if not started yet + + if (dtToStart <= 0) { + runnersLeft = true; + continue; + } else if (dtToStart < dt) { + // Adjust dt to make sure that animation is on point + dt = dtToStart; + } + + if (!runner.active()) continue; // If this runner is still going, signal that we need another animation + // frame, otherwise, remove the completed runner + + var finished = runner.step(dt).done; + + if (!finished) { + runnersLeft = true; // continue + } else if (runnerInfo.persist !== true) { + // runner is finished. And runner might get removed + var endTime = runner.duration() - runner.time() + this._time; + + if (endTime + runnerInfo.persist < this._time) { + // Delete runner and correct index + runner.unschedule(); + --i; + --len; + } + } + } // Basically: we continue when there are runners right from us in time + // when -->, and when runners are left from us when <-- + + + if (runnersLeft && !(this._speed < 0 && this._time === 0) || this._runnerIds.length && this._speed < 0 && this._time > 0) { + this._continue(); + } else { + this.pause(); + this.fire('finished'); + } + + return this; + } // Checks if we are running and continues the animation + + + _continue(immediateStep = false) { + Animator.cancelFrame(this._nextFrame); + this._nextFrame = null; + if (immediateStep) return this._stepImmediate(); + if (this._paused) return this; + this._nextFrame = Animator.frame(this._step); + return this; + } + + active() { + return !!this._nextFrame; + } + +} +registerMethods({ + Element: { + timeline: function (timeline) { + if (timeline == null) { + this._timeline = this._timeline || new Timeline(); + return this._timeline; + } else { + this._timeline = timeline; + return this; + } + } + } +}); + +class Runner extends EventTarget { + constructor(options) { + super(); // Store a unique id on the runner, so that we can identify it later + + this.id = Runner.id++; // Ensure a default value + + options = options == null ? timeline.duration : options; // Ensure that we get a controller + + options = typeof options === 'function' ? new Controller(options) : options; // Declare all of the variables + + this._element = null; + this._timeline = null; + this.done = false; + this._queue = []; // Work out the stepper and the duration + + this._duration = typeof options === 'number' && options; + this._isDeclarative = options instanceof Controller; + this._stepper = this._isDeclarative ? options : new Ease(); // We copy the current values from the timeline because they can change + + this._history = {}; // Store the state of the runner + + this.enabled = true; + this._time = 0; + this._lastTime = 0; // At creation, the runner is in reseted state + + this._reseted = true; // Save transforms applied to this runner + + this.transforms = new Matrix(); + this.transformId = 1; // Looping variables + + this._haveReversed = false; + this._reverse = false; + this._loopsDone = 0; + this._swing = false; + this._wait = 0; + this._times = 1; + this._frameId = null; // Stores how long a runner is stored after beeing done + + this._persist = this._isDeclarative ? true : null; + } + /* + Runner Definitions + ================== + These methods help us define the runtime behaviour of the Runner or they + help us make new runners from the current runner + */ + + + element(element) { + if (element == null) return this._element; + this._element = element; + + element._prepareRunner(); + + return this; + } + + timeline(timeline$$1) { + // check explicitly for undefined so we can set the timeline to null + if (typeof timeline$$1 === 'undefined') return this._timeline; + this._timeline = timeline$$1; + return this; + } + + animate(duration, delay, when) { + var o = Runner.sanitise(duration, delay, when); + var runner = new Runner(o.duration); + if (this._timeline) runner.timeline(this._timeline); + if (this._element) runner.element(this._element); + return runner.loop(o).schedule(delay, when); + } + + schedule(timeline$$1, delay, when) { + // The user doesn't need to pass a timeline if we already have one + if (!(timeline$$1 instanceof Timeline)) { + when = delay; + delay = timeline$$1; + timeline$$1 = this.timeline(); + } // If there is no timeline, yell at the user... + + + if (!timeline$$1) { + throw Error('Runner cannot be scheduled without timeline'); + } // Schedule the runner on the timeline provided + + + timeline$$1.schedule(this, delay, when); + return this; + } + + unschedule() { + var timeline$$1 = this.timeline(); + timeline$$1 && timeline$$1.unschedule(this); + return this; + } + + loop(times, swing, wait) { + // Deal with the user passing in an object + if (typeof times === 'object') { + swing = times.swing; + wait = times.wait; + times = times.times; + } // Sanitise the values and store them + + + this._times = times || Infinity; + this._swing = swing || false; + this._wait = wait || 0; // Allow true to be passed + + if (this._times === true) { + this._times = Infinity; + } + + return this; + } + + delay(delay) { + return this.animate(0, delay); + } + /* + Basic Functionality + =================== + These methods allow us to attach basic functions to the runner directly + */ + + + queue(initFn, runFn, retargetFn, isTransform) { + this._queue.push({ + initialiser: initFn || noop, + runner: runFn || noop, + retarget: retargetFn, + isTransform: isTransform, + initialised: false, + finished: false + }); + + var timeline$$1 = this.timeline(); + timeline$$1 && this.timeline()._continue(); + return this; + } + + during(fn) { + return this.queue(null, fn); + } + + after(fn) { + return this.on('finished', fn); + } + /* + Runner animation methods + ======================== + Control how the animation plays + */ + + + time(time) { + if (time == null) { + return this._time; + } + + let dt = time - this._time; + this.step(dt); + return this; + } + + duration() { + return this._times * (this._wait + this._duration) - this._wait; + } + + loops(p) { + var loopDuration = this._duration + this._wait; + + if (p == null) { + var loopsDone = Math.floor(this._time / loopDuration); + var relativeTime = this._time - loopsDone * loopDuration; + var position = relativeTime / this._duration; + return Math.min(loopsDone + position, this._times); + } + + var whole = Math.floor(p); + var partial = p % 1; + var time = loopDuration * whole + this._duration * partial; + return this.time(time); + } + + persist(dtOrForever) { + if (dtOrForever == null) return this._persist; + this._persist = dtOrForever; + return this; + } + + position(p) { + // Get all of the variables we need + var x$$1 = this._time; + var d = this._duration; + var w = this._wait; + var t = this._times; + var s = this._swing; + var r = this._reverse; + var position; + + if (p == null) { + /* + This function converts a time to a position in the range [0, 1] + The full explanation can be found in this desmos demonstration + https://www.desmos.com/calculator/u4fbavgche + The logic is slightly simplified here because we can use booleans + */ + // Figure out the value without thinking about the start or end time + const f = function (x$$1) { + var swinging = s * Math.floor(x$$1 % (2 * (w + d)) / (w + d)); + var backwards = swinging && !r || !swinging && r; + var uncliped = Math.pow(-1, backwards) * (x$$1 % (w + d)) / d + backwards; + var clipped = Math.max(Math.min(uncliped, 1), 0); + return clipped; + }; // Figure out the value by incorporating the start time + + + var endTime = t * (w + d) - w; + position = x$$1 <= 0 ? Math.round(f(1e-5)) : x$$1 < endTime ? f(x$$1) : Math.round(f(endTime - 1e-5)); + return position; + } // Work out the loops done and add the position to the loops done + + + var loopsDone = Math.floor(this.loops()); + var swingForward = s && loopsDone % 2 === 0; + var forwards = swingForward && !r || r && swingForward; + position = loopsDone + (forwards ? p : 1 - p); + return this.loops(position); + } + + progress(p) { + if (p == null) { + return Math.min(1, this._time / this.duration()); + } + + return this.time(p * this.duration()); + } + + step(dt) { + // If we are inactive, this stepper just gets skipped + if (!this.enabled) return this; // Update the time and get the new position + + dt = dt == null ? 16 : dt; + this._time += dt; + var position = this.position(); // Figure out if we need to run the stepper in this frame + + var running = this._lastPosition !== position && this._time >= 0; + this._lastPosition = position; // Figure out if we just started + + var duration = this.duration(); + var justStarted = this._lastTime <= 0 && this._time > 0; + var justFinished = this._lastTime < duration && this._time >= duration; + this._lastTime = this._time; + + if (justStarted) { + this.fire('start', this); + } // Work out if the runner is finished set the done flag here so animations + // know, that they are running in the last step (this is good for + // transformations which can be merged) + + + var declarative = this._isDeclarative; + this.done = !declarative && !justFinished && this._time >= duration; // Runner is running. So its not in reseted state anymore + + this._reseted = false; // Call initialise and the run function + + if (running || declarative) { + this._initialise(running); // clear the transforms on this runner so they dont get added again and again + + + this.transforms = new Matrix(); + + var converged = this._run(declarative ? dt : position); + + this.fire('step', this); + } // correct the done flag here + // declaritive animations itself know when they converged + + + this.done = this.done || converged && declarative; + + if (justFinished) { + this.fire('finished', this); + } + + return this; + } + + reset() { + if (this._reseted) return this; + this.time(0); + this._reseted = true; + return this; + } + + finish() { + return this.step(Infinity); + } + + reverse(reverse) { + this._reverse = reverse == null ? !this._reverse : reverse; + return this; + } + + ease(fn) { + this._stepper = new Ease(fn); + return this; + } + + active(enabled) { + if (enabled == null) return this.enabled; + this.enabled = enabled; + return this; + } + /* + Private Methods + =============== + Methods that shouldn't be used externally + */ + // Save a morpher to the morpher list so that we can retarget it later + + + _rememberMorpher(method, morpher) { + this._history[method] = { + morpher: morpher, + caller: this._queue[this._queue.length - 1] // We have to resume the timeline in case a controller + // is already done without beeing ever run + // This can happen when e.g. this is done: + // anim = el.animate(new SVG.Spring) + // and later + // anim.move(...) + + }; + + if (this._isDeclarative) { + var timeline$$1 = this.timeline(); + timeline$$1 && timeline$$1.play(); + } + } // Try to set the target for a morpher if the morpher exists, otherwise + // do nothing and return false + + + _tryRetarget(method, target, extra) { + if (this._history[method]) { + // if the last method wasnt even initialised, throw it away + if (!this._history[method].caller.initialised) { + let index = this._queue.indexOf(this._history[method].caller); + + this._queue.splice(index, 1); + + return false; + } // for the case of transformations, we use the special retarget function + // which has access to the outer scope + + + if (this._history[method].caller.retarget) { + this._history[method].caller.retarget(target, extra); // for everything else a simple morpher change is sufficient + + } else { + this._history[method].morpher.to(target); + } + + this._history[method].caller.finished = false; + var timeline$$1 = this.timeline(); + timeline$$1 && timeline$$1.play(); + return true; + } + + return false; + } // Run each initialise function in the runner if required + + + _initialise(running) { + // If we aren't running, we shouldn't initialise when not declarative + if (!running && !this._isDeclarative) return; // Loop through all of the initialisers + + for (var i = 0, len = this._queue.length; i < len; ++i) { + // Get the current initialiser + var current = this._queue[i]; // Determine whether we need to initialise + + var needsIt = this._isDeclarative || !current.initialised && running; + running = !current.finished; // Call the initialiser if we need to + + if (needsIt && running) { + current.initialiser.call(this); + current.initialised = true; + } + } + } // Run each run function for the position or dt given + + + _run(positionOrDt) { + // Run all of the _queue directly + var allfinished = true; + + for (var i = 0, len = this._queue.length; i < len; ++i) { + // Get the current function to run + var current = this._queue[i]; // Run the function if its not finished, we keep track of the finished + // flag for the sake of declarative _queue + + var converged = current.runner.call(this, positionOrDt); + current.finished = current.finished || converged === true; + allfinished = allfinished && current.finished; + } // We report when all of the constructors are finished + + + return allfinished; + } + + addTransform(transform, index) { + this.transforms.lmultiplyO(transform); + return this; + } + + clearTransform() { + this.transforms = new Matrix(); + return this; + } // TODO: Keep track of all transformations so that deletion is faster + + + clearTransformsFromQueue() { + if (!this.done || !this._timeline || !this._timeline._runnerIds.includes(this.id)) { + this._queue = this._queue.filter(item => { + return !item.isTransform; + }); + } + } + + static sanitise(duration, delay, when) { + // Initialise the default parameters + var times = 1; + var swing = false; + var wait = 0; + duration = duration || timeline.duration; + delay = delay || timeline.delay; + when = when || 'last'; // If we have an object, unpack the values + + if (typeof duration === 'object' && !(duration instanceof Stepper)) { + delay = duration.delay || delay; + when = duration.when || when; + swing = duration.swing || swing; + times = duration.times || times; + wait = duration.wait || wait; + duration = duration.duration || timeline.duration; + } + + return { + duration: duration, + delay: delay, + swing: swing, + times: times, + wait: wait, + when: when + }; + } + +} +Runner.id = 0; + +class FakeRunner { + constructor(transforms = new Matrix(), id = -1, done = true) { + this.transforms = transforms; + this.id = id; + this.done = done; + } + + clearTransformsFromQueue() {} + +} + +extend([Runner, FakeRunner], { + mergeWith(runner) { + return new FakeRunner(runner.transforms.lmultiply(this.transforms), runner.id); + } + +}); // FakeRunner.emptyRunner = new FakeRunner() + +const lmultiply = (last, curr) => last.lmultiplyO(curr); + +const getRunnerTransform = runner => runner.transforms; + +function mergeTransforms() { + // Find the matrix to apply to the element and apply it + let runners = this._transformationRunners.runners; + let netTransform = runners.map(getRunnerTransform).reduce(lmultiply, new Matrix()); + this.transform(netTransform); + + this._transformationRunners.merge(); + + if (this._transformationRunners.length() === 1) { + this._frameId = null; + } +} + +class RunnerArray { + constructor() { + this.runners = []; + this.ids = []; + } + + add(runner) { + if (this.runners.includes(runner)) return; + let id = runner.id + 1; + this.runners.push(runner); + this.ids.push(id); + return this; + } + + getByID(id) { + return this.runners[this.ids.indexOf(id + 1)]; + } + + remove(id) { + let index = this.ids.indexOf(id + 1); + this.ids.splice(index, 1); + this.runners.splice(index, 1); + return this; + } + + merge() { + let lastRunner = null; + this.runners.forEach((runner, i) => { + const condition = lastRunner && runner.done && lastRunner.done // don't merge runner when persisted on timeline + && (!runner._timeline || !runner._timeline._runnerIds.includes(runner.id)) && (!lastRunner._timeline || !lastRunner._timeline._runnerIds.includes(lastRunner.id)); + + if (condition) { + // the +1 happens in the function + this.remove(runner.id); + this.edit(lastRunner.id, runner.mergeWith(lastRunner)); + } + + lastRunner = runner; + }); + return this; + } + + edit(id, newRunner) { + let index = this.ids.indexOf(id + 1); + this.ids.splice(index, 1, id + 1); + this.runners.splice(index, 1, newRunner); + return this; + } + + length() { + return this.ids.length; + } + + clearBefore(id) { + let deleteCnt = this.ids.indexOf(id + 1) || 1; + this.ids.splice(0, deleteCnt, 0); + this.runners.splice(0, deleteCnt, new FakeRunner()).forEach(r => r.clearTransformsFromQueue()); + return this; + } + +} + +registerMethods({ + Element: { + animate(duration, delay, when) { + var o = Runner.sanitise(duration, delay, when); + var timeline$$1 = this.timeline(); + return new Runner(o.duration).loop(o).element(this).timeline(timeline$$1.play()).schedule(delay, when); + }, + + delay(by, when) { + return this.animate(0, by, when); + }, + + // this function searches for all runners on the element and deletes the ones + // which run before the current one. This is because absolute transformations + // overwfrite anything anyway so there is no need to waste time computing + // other runners + _clearTransformRunnersBefore(currentRunner) { + this._transformationRunners.clearBefore(currentRunner.id); + }, + + _currentTransform(current) { + return this._transformationRunners.runners // we need the equal sign here to make sure, that also transformations + // on the same runner which execute before the current transformation are + // taken into account + .filter(runner => runner.id <= current.id).map(getRunnerTransform).reduce(lmultiply, new Matrix()); + }, + + _addRunner(runner) { + this._transformationRunners.add(runner); // Make sure that the runner merge is executed at the very end of + // all Animator functions. Thats why we use immediate here to execute + // the merge right after all frames are run + + + Animator.cancelImmediate(this._frameId); + this._frameId = Animator.immediate(mergeTransforms.bind(this)); + }, + + _prepareRunner() { + if (this._frameId == null) { + this._transformationRunners = new RunnerArray().add(new FakeRunner(new Matrix(this))); + } + } + + } +}); +extend(Runner, { + attr(a, v) { + return this.styleAttr('attr', a, v); + }, + + // Add animatable styles + css(s, v) { + return this.styleAttr('css', s, v); + }, + + styleAttr(type, name, val) { + // apply attributes individually + if (typeof name === 'object') { + for (var key in name) { + this.styleAttr(type, key, name[key]); + } + + return this; + } + + var morpher = new Morphable(this._stepper).to(val); + this.queue(function () { + morpher = morpher.from(this.element()[type](name)); + }, function (pos) { + this.element()[type](name, morpher.at(pos)); + return morpher.done(); + }); + return this; + }, + + zoom(level, point$$1) { + if (this._tryRetarget('zoom', to, point$$1)) return this; + var morpher = new Morphable(this._stepper).to(new SVGNumber(level)); + this.queue(function () { + morpher = morpher.from(this.element().zoom()); + }, function (pos) { + this.element().zoom(morpher.at(pos), point$$1); + return morpher.done(); + }, function (newLevel, newPoint) { + point$$1 = newPoint; + morpher.to(newLevel); + }); + + this._rememberMorpher('zoom', morpher); + + return this; + }, + + /** + ** absolute transformations + **/ + // + // M v -----|-----(D M v = F v)------|-----> T v + // + // 1. define the final state (T) and decompose it (once) + // t = [tx, ty, the, lam, sy, sx] + // 2. on every frame: pull the current state of all previous transforms + // (M - m can change) + // and then write this as m = [tx0, ty0, the0, lam0, sy0, sx0] + // 3. Find the interpolated matrix F(pos) = m + pos * (t - m) + // - Note F(0) = M + // - Note F(1) = T + // 4. Now you get the delta matrix as a result: D = F * inv(M) + transform(transforms, relative, affine) { + // If we have a declarative function, we should retarget it if possible + relative = transforms.relative || relative; + + if (this._isDeclarative && !relative && this._tryRetarget('transform', transforms)) { + return this; + } // Parse the parameters + + + var isMatrix = Matrix.isMatrixLike(transforms); + affine = transforms.affine != null ? transforms.affine : affine != null ? affine : !isMatrix; // Create a morepher and set its type + + const morpher = new Morphable(this._stepper).type(affine ? TransformBag : Matrix); + let origin; + let element; + let current; + let currentAngle; + let startTransform; + + function setup() { + // make sure element and origin is defined + element = element || this.element(); + origin = origin || getOrigin(transforms, element); + startTransform = new Matrix(relative ? undefined : element); // add the runner to the element so it can merge transformations + + element._addRunner(this); // Deactivate all transforms that have run so far if we are absolute + + + if (!relative) { + element._clearTransformRunnersBefore(this); + } + } + + function run(pos) { + // clear all other transforms before this in case something is saved + // on this runner. We are absolute. We dont need these! + if (!relative) this.clearTransform(); + let { + x: x$$1, + y: y$$1 + } = new Point(origin).transform(element._currentTransform(this)); + let target = new Matrix(_objectSpread({}, transforms, { + origin: [x$$1, y$$1] + })); + let start = this._isDeclarative && current ? current : startTransform; + + if (affine) { + target = target.decompose(x$$1, y$$1); + start = start.decompose(x$$1, y$$1); // Get the current and target angle as it was set + + const rTarget = target.rotate; + const rCurrent = start.rotate; // Figure out the shortest path to rotate directly + + const possibilities = [rTarget - 360, rTarget, rTarget + 360]; + const distances = possibilities.map(a => Math.abs(a - rCurrent)); + const shortest = Math.min(...distances); + const index = distances.indexOf(shortest); + target.rotate = possibilities[index]; + } + + if (relative) { + // we have to be careful here not to overwrite the rotation + // with the rotate method of Matrix + if (!isMatrix) { + target.rotate = transforms.rotate || 0; + } + + if (this._isDeclarative && currentAngle) { + start.rotate = currentAngle; + } + } + + morpher.from(start); + morpher.to(target); + let affineParameters = morpher.at(pos); + currentAngle = affineParameters.rotate; + current = new Matrix(affineParameters); + this.addTransform(current); + + element._addRunner(this); + + return morpher.done(); + } + + function retarget(newTransforms) { + // only get a new origin if it changed since the last call + if ((newTransforms.origin || 'center').toString() !== (transforms.origin || 'center').toString()) { + origin = getOrigin(transforms, element); + } // overwrite the old transformations with the new ones + + + transforms = _objectSpread({}, newTransforms, { + origin + }); + } + + this.queue(setup, run, retarget, true); + this._isDeclarative && this._rememberMorpher('transform', morpher); + return this; + }, + + // Animatable x-axis + x(x$$1, relative) { + return this._queueNumber('x', x$$1); + }, + + // Animatable y-axis + y(y$$1) { + return this._queueNumber('y', y$$1); + }, + + dx(x$$1) { + return this._queueNumberDelta('x', x$$1); + }, + + dy(y$$1) { + return this._queueNumberDelta('y', y$$1); + }, + + _queueNumberDelta(method, to$$1) { + to$$1 = new SVGNumber(to$$1); // Try to change the target if we have this method already registerd + + if (this._tryRetarget(method, to$$1)) return this; // Make a morpher and queue the animation + + var morpher = new Morphable(this._stepper).to(to$$1); + var from$$1 = null; + this.queue(function () { + from$$1 = this.element()[method](); + morpher.from(from$$1); + morpher.to(from$$1 + to$$1); + }, function (pos) { + this.element()[method](morpher.at(pos)); + return morpher.done(); + }, function (newTo) { + morpher.to(from$$1 + new SVGNumber(newTo)); + }); // Register the morpher so that if it is changed again, we can retarget it + + this._rememberMorpher(method, morpher); + + return this; + }, + + _queueObject(method, to$$1) { + // Try to change the target if we have this method already registerd + if (this._tryRetarget(method, to$$1)) return this; // Make a morpher and queue the animation + + var morpher = new Morphable(this._stepper).to(to$$1); + this.queue(function () { + morpher.from(this.element()[method]()); + }, function (pos) { + this.element()[method](morpher.at(pos)); + return morpher.done(); + }); // Register the morpher so that if it is changed again, we can retarget it + + this._rememberMorpher(method, morpher); + + return this; + }, + + _queueNumber(method, value) { + return this._queueObject(method, new SVGNumber(value)); + }, + + // Animatable center x-axis + cx(x$$1) { + return this._queueNumber('cx', x$$1); + }, + + // Animatable center y-axis + cy(y$$1) { + return this._queueNumber('cy', y$$1); + }, + + // Add animatable move + move(x$$1, y$$1) { + return this.x(x$$1).y(y$$1); + }, + + // Add animatable center + center(x$$1, y$$1) { + return this.cx(x$$1).cy(y$$1); + }, + + // Add animatable size + size(width$$1, height$$1) { + // animate bbox based size for all other elements + var box; + + if (!width$$1 || !height$$1) { + box = this._element.bbox(); + } + + if (!width$$1) { + width$$1 = box.width / box.height * height$$1; + } + + if (!height$$1) { + height$$1 = box.height / box.width * width$$1; + } + + return this.width(width$$1).height(height$$1); + }, + + // Add animatable width + width(width$$1) { + return this._queueNumber('width', width$$1); + }, + + // Add animatable height + height(height$$1) { + return this._queueNumber('height', height$$1); + }, + + // Add animatable plot + plot(a, b, c, d) { + // Lines can be plotted with 4 arguments + if (arguments.length === 4) { + return this.plot([a, b, c, d]); + } + + if (this._tryRetarget('plot', a)) return this; + var morpher = new Morphable(this._stepper).type(this._element.MorphArray).to(a); + this.queue(function () { + morpher.from(this._element.array()); + }, function (pos) { + this._element.plot(morpher.at(pos)); + + return morpher.done(); + }); + + this._rememberMorpher('plot', morpher); + + return this; + }, + + // Add leading method + leading(value) { + return this._queueNumber('leading', value); + }, + + // Add animatable viewbox + viewbox(x$$1, y$$1, width$$1, height$$1) { + return this._queueObject('viewbox', new Box(x$$1, y$$1, width$$1, height$$1)); + }, + + update(o) { + if (typeof o !== 'object') { + return this.update({ + offset: arguments[0], + color: arguments[1], + opacity: arguments[2] + }); + } + + if (o.opacity != null) this.attr('stop-opacity', o.opacity); + if (o.color != null) this.attr('stop-color', o.color); + if (o.offset != null) this.attr('offset', o.offset); + return this; + } + +}); +extend(Runner, { + rx, + ry, + from, + to +}); +register(Runner); + +class Svg$1 extends Container { + constructor(node) { + super(nodeOrNew('svg', node), node); + this.namespace(); + } + + isRoot() { + return !this.node.parentNode || !(this.node.parentNode instanceof globals.window.SVGElement) || this.node.parentNode.nodeName === '#document'; + } // Check if this is a root svg + // If not, call docs from this element + + + root() { + if (this.isRoot()) return this; + return super.root(); + } // Add namespaces + + + namespace() { + if (!this.isRoot()) return this.root().namespace(); + return this.attr({ + xmlns: ns, + version: '1.1' + }).attr('xmlns:xlink', xlink, xmlns).attr('xmlns:svgjs', svgjs, xmlns); + } // Creates and returns defs element + + + defs() { + if (!this.isRoot()) return this.root().defs(); + return adopt(this.node.getElementsByTagName('defs')[0]) || this.put(new Defs()); + } // custom parent method + + + parent(type) { + if (this.isRoot()) { + return this.node.parentNode.nodeName === '#document' ? null : adopt(this.node.parentNode); + } + + return super.parent(type); + } + + clear() { + // remove children + while (this.node.hasChildNodes()) { + this.node.removeChild(this.node.lastChild); + } // remove defs reference + + + delete this._defs; + return this; + } + +} +registerMethods({ + Container: { + // Create nested svg document + nested: wrapWithAttrCheck(function () { + return this.put(new Svg$1()); + }) + } +}); +register(Svg$1, 'Svg', true); + +class Symbol extends Container { + // Initialize node + constructor(node) { + super(nodeOrNew('symbol', node), node); + } + +} +registerMethods({ + Container: { + symbol: wrapWithAttrCheck(function () { + return this.put(new Symbol()); + }) + } +}); +register(Symbol); + +function plain(text) { + // clear if build mode is disabled + if (this._build === false) { + this.clear(); + } // create text node + + + this.node.appendChild(globals.document.createTextNode(text)); + return this; +} // Get length of text element + +function length() { + return this.node.getComputedTextLength(); +} + +var textable = ({ + plain: plain, + length: length +}); + +class Text extends Shape { + // Initialize node + constructor(node) { + super(nodeOrNew('text', node), node); + this.dom.leading = new SVGNumber(1.3); // store leading value for rebuilding + + this._rebuild = true; // enable automatic updating of dy values + + this._build = false; // disable build mode for adding multiple lines + // set default font + + this.attr('font-family', attrs['font-family']); + } // Move over x-axis + + + x(x) { + // act as getter + if (x == null) { + return this.attr('x'); + } + + return this.attr('x', x); + } // Move over y-axis + + + y(y) { + var oy = this.attr('y'); + var o = typeof oy === 'number' ? oy - this.bbox().y : 0; // act as getter + + if (y == null) { + return typeof oy === 'number' ? oy - o : oy; + } + + return this.attr('y', typeof y === 'number' ? y + o : y); + } // Move center over x-axis + + + cx(x) { + return x == null ? this.bbox().cx : this.x(x - this.bbox().width / 2); + } // Move center over y-axis + + + cy(y) { + return y == null ? this.bbox().cy : this.y(y - this.bbox().height / 2); + } // Set the text content + + + text(text) { + // act as getter + if (text === undefined) { + var children = this.node.childNodes; + var firstLine = 0; + text = ''; + + for (var i = 0, len = children.length; i < len; ++i) { + // skip textPaths - they are no lines + if (children[i].nodeName === 'textPath') { + if (i === 0) firstLine = 1; + continue; + } // add newline if its not the first child and newLined is set to true + + + if (i !== firstLine && children[i].nodeType !== 3 && adopt(children[i]).dom.newLined === true) { + text += '\n'; + } // add content of this node + + + text += children[i].textContent; + } + + return text; + } // remove existing content + + + this.clear().build(true); + + if (typeof text === 'function') { + // call block + text.call(this, this); + } else { + // store text and make sure text is not blank + text = text.split('\n'); // build new lines + + for (var j = 0, jl = text.length; j < jl; j++) { + this.tspan(text[j]).newLine(); + } + } // disable build mode and rebuild lines + + + return this.build(false).rebuild(); + } // Set / get leading + + + leading(value) { + // act as getter + if (value == null) { + return this.dom.leading; + } // act as setter + + + this.dom.leading = new SVGNumber(value); + return this.rebuild(); + } // Rebuild appearance type + + + rebuild(rebuild) { + // store new rebuild flag if given + if (typeof rebuild === 'boolean') { + this._rebuild = rebuild; + } // define position of all lines + + + if (this._rebuild) { + var self = this; + var blankLineOffset = 0; + var leading = this.dom.leading; + this.each(function () { + var fontSize = globals.window.getComputedStyle(this.node).getPropertyValue('font-size'); + var dy = leading * new SVGNumber(fontSize); + + if (this.dom.newLined) { + this.attr('x', self.attr('x')); + + if (this.text() === '\n') { + blankLineOffset += dy; + } else { + this.attr('dy', dy + blankLineOffset); + blankLineOffset = 0; + } + } + }); + this.fire('rebuild'); + } + + return this; + } // Enable / disable build mode + + + build(build) { + this._build = !!build; + return this; + } // overwrite method from parent to set data properly + + + setData(o) { + this.dom = o; + this.dom.leading = new SVGNumber(o.leading || 1.3); + return this; + } + +} +extend(Text, textable); +registerMethods({ + Container: { + // Create text element + text: wrapWithAttrCheck(function (text) { + return this.put(new Text()).text(text); + }), + // Create plain text element + plain: wrapWithAttrCheck(function (text) { + return this.put(new Text()).plain(text); + }) + } +}); +register(Text); + +class Tspan extends Text { + // Initialize node + constructor(node) { + super(nodeOrNew('tspan', node), node); + } // Set text content + + + text(text) { + if (text == null) return this.node.textContent + (this.dom.newLined ? '\n' : ''); + typeof text === 'function' ? text.call(this, this) : this.plain(text); + return this; + } // Shortcut dx + + + dx(dx) { + return this.attr('dx', dx); + } // Shortcut dy + + + dy(dy) { + return this.attr('dy', dy); + } // Create new line + + + newLine() { + // fetch text parent + var t = this.parent(Text); // mark new line + + this.dom.newLined = true; // apply new position + + return this.dy(t.dom.leading * t.attr('font-size')).attr('x', t.x()); + } + +} +extend(Tspan, textable); +registerMethods({ + Tspan: { + tspan: wrapWithAttrCheck(function (text) { + var tspan = new Tspan(); // clear if build mode is disabled + + if (!this._build) { + this.clear(); + } // add new tspan + + + this.node.appendChild(tspan.node); + return tspan.text(text); + }) + } +}); +register(Tspan); + +class ClipPath extends Container { + constructor(node) { + super(nodeOrNew('clipPath', node), node); + } // Unclip all clipped elements and remove itself + + + remove() { + // unclip all targets + this.targets().forEach(function (el) { + el.unclip(); + }); // remove clipPath from parent + + return super.remove(); + } + + targets() { + return baseFind('svg [clip-path*="' + this.id() + '"]'); + } + +} +registerMethods({ + Container: { + // Create clipping element + clip: wrapWithAttrCheck(function () { + return this.defs().put(new ClipPath()); + }) + }, + Element: { + // Distribute clipPath to svg element + clipWith(element) { + // use given clip or create a new one + let clipper = element instanceof ClipPath ? element : this.parent().clip().add(element); // apply mask + + return this.attr('clip-path', 'url("#' + clipper.id() + '")'); + }, + + // Unclip element + unclip() { + return this.attr('clip-path', null); + }, + + clipper() { + return this.reference('clip-path'); + } + + } +}); +register(ClipPath); + +class G extends Container { + constructor(node) { + super(nodeOrNew('g', node), node); + } + + x(x, box = this.bbox()) { + if (x == null) return box.x; + this.children().dx(x - box.x); + return this; + } + + y(y, box = this.bbox()) { + if (y == null) return box.y; + this.children().dy(y - box.y); + return this; + } + + move(x, y) { + const box = this.bbox(); + return this.x(x, box).y(y, box); + } + + dx(dx) { + return this.children().dx(dx); + } + + dy(dy) { + return this.children().dy(dy); + } + + width(width, box = this.bbox()) { + if (width == null) return box.width; + const scale = width / box.width; + this.each(function () { + const _width = this.width(); + + const _x = this.x(); + + this.width(_width * scale); + this.x((_x - box.x) * scale + box.x); + }); + return this; + } + + height(height, box = this.bbox()) { + if (height == null) return box.height; + const scale = height / box.height; + this.each(function () { + const _height = this.height(); + + const _y = this.y(); + + this.height(_height * scale); + this.y((_y - box.y) * scale + box.y); + }); + return this; + } + + size(width, height) { + const box = this.bbox(); + const p = proportionalSize(this, width, height, box); + return this.width(new SVGNumber(p.width), box).height(new SVGNumber(p.height), box); + } + +} +registerMethods({ + Element: { + // Create a group element + group: wrapWithAttrCheck(function () { + return this.put(new G()); + }) + } +}); +register(G); + +class A extends Container { + constructor(node) { + super(nodeOrNew('a', node), node); + } // Link url + + + to(url) { + return this.attr('href', url, xlink); + } // Link target attribute + + + target(target) { + return this.attr('target', target); + } + +} +registerMethods({ + Container: { + // Create a hyperlink element + link: wrapWithAttrCheck(function (url) { + return this.put(new A()).to(url); + }) + }, + Element: { + // Create a hyperlink element + linkTo: function (url) { + var link = new A(); + + if (typeof url === 'function') { + url.call(link, link); + } else { + link.to(url); + } + + return this.parent().put(link).put(this); + } + } +}); +register(A); + +class Mask extends Container { + // Initialize node + constructor(node) { + super(nodeOrNew('mask', node), node); + } // Unmask all masked elements and remove itself + + + remove() { + // unmask all targets + this.targets().forEach(function (el) { + el.unmask(); + }); // remove mask from parent + + return super.remove(); + } + + targets() { + return baseFind('svg [mask*="' + this.id() + '"]'); + } + +} +registerMethods({ + Container: { + mask: wrapWithAttrCheck(function () { + return this.defs().put(new Mask()); + }) + }, + Element: { + // Distribute mask to svg element + maskWith(element) { + // use given mask or create a new one + var masker = element instanceof Mask ? element : this.parent().mask().add(element); // apply mask + + return this.attr('mask', 'url("#' + masker.id() + '")'); + }, + + // Unmask element + unmask() { + return this.attr('mask', null); + }, + + masker() { + return this.reference('mask'); + } + + } +}); +register(Mask); + +function cssRule(selector, rule) { + if (!selector) return ''; + if (!rule) return selector; + var ret = selector + '{'; + + for (var i in rule) { + ret += unCamelCase(i) + ':' + rule[i] + ';'; + } + + ret += '}'; + return ret; +} + +class Style extends Element { + constructor(node) { + super(nodeOrNew('style', node), node); + } + + addText(w = '') { + this.node.textContent += w; + return this; + } + + font(name, src, params = {}) { + return this.rule('@font-face', _objectSpread({ + fontFamily: name, + src: src + }, params)); + } + + rule(selector, obj) { + return this.addText(cssRule(selector, obj)); + } + +} +registerMethods('Dom', { + style: wrapWithAttrCheck(function (selector, obj) { + return this.put(new Style()).rule(selector, obj); + }), + fontface: wrapWithAttrCheck(function (name, src, params) { + return this.put(new Style()).font(name, src, params); + }) +}); +register(Style); + +class TextPath extends Text { + // Initialize node + constructor(node) { + super(nodeOrNew('textPath', node), node); + } // return the array of the path track element + + + array() { + var track = this.track(); + return track ? track.array() : null; + } // Plot path if any + + + plot(d) { + var track = this.track(); + var pathArray = null; + + if (track) { + pathArray = track.plot(d); + } + + return d == null ? pathArray : this; + } // Get the path element + + + track() { + return this.reference('href'); + } + +} +registerMethods({ + Container: { + textPath: wrapWithAttrCheck(function (text, path) { + return this.defs().path(path).text(text).addTo(this); + }) + }, + Text: { + // Create path for text to run on + path: wrapWithAttrCheck(function (track) { + var path = new TextPath(); // if track is a path, reuse it + + if (!(track instanceof Path)) { + // create path element + track = this.root().defs().path(track); + } // link textPath to path and add content + + + path.attr('href', '#' + track, xlink); // add textPath element as child node and return textPath + + return this.put(path); + }), + + // Get the textPath children + textPath() { + return this.find('textPath')[0]; + } + + }, + Path: { + // creates a textPath from this path + text: wrapWithAttrCheck(function (text) { + if (text instanceof Text) { + var txt = text.text(); + return text.clear().path(this).text(txt); + } + + return this.parent().put(new Text()).path(this).text(text); + }), + + targets() { + return baseFind('svg [href*="' + this.id() + '"]'); + } + + } +}); +TextPath.prototype.MorphArray = PathArray; +register(TextPath); + +class Use extends Shape { + constructor(node) { + super(nodeOrNew('use', node), node); + } // Use element as a reference + + + element(element, file) { + // Set lined element + return this.attr('href', (file || '') + '#' + element, xlink); + } + +} +registerMethods({ + Container: { + // Create a use element + use: wrapWithAttrCheck(function (element, file) { + return this.put(new Use()).element(element, file); + }) + } +}); +register(Use); + +/* Optional Modules */ +const SVG = makeInstance; +extend([Svg$1, Symbol, Image, Pattern, Marker], getMethodsFor('viewbox')); +extend([Line, Polyline, Polygon, Path], getMethodsFor('marker')); +extend(Text, getMethodsFor('Text')); +extend(Path, getMethodsFor('Path')); +extend(Defs, getMethodsFor('Defs')); +extend([Text, Tspan], getMethodsFor('Tspan')); +extend([Rect, Ellipse, Circle, Gradient], getMethodsFor('radius')); +extend(EventTarget, getMethodsFor('EventTarget')); +extend(Dom, getMethodsFor('Dom')); +extend(Element, getMethodsFor('Element')); +extend(Shape, getMethodsFor('Shape')); // extend(Element, getConstructor('Memory')) + +extend(Container, getMethodsFor('Container')); +extend(Runner, getMethodsFor('Runner')); +List.extend(getMethodNames()); +registerMorphableType([SVGNumber, Color, Box, Matrix, SVGArray, PointArray, PathArray]); +makeMorphable(); + +exports.Morphable = Morphable; +exports.registerMorphableType = registerMorphableType; +exports.makeMorphable = makeMorphable; +exports.TransformBag = TransformBag; +exports.ObjectBag = ObjectBag; +exports.NonMorphable = NonMorphable; +exports.defaults = defaults; +exports.utils = utils; +exports.namespaces = namespaces; +exports.regex = regex; +exports.SVG = SVG; +exports.parser = parser; +exports.find = baseFind; +exports.registerWindow = registerWindow; +exports.Animator = Animator; +exports.Controller = Controller; +exports.Ease = Ease; +exports.PID = PID; +exports.Spring = Spring; +exports.easing = easing; +exports.Queue = Queue; +exports.Runner = Runner; +exports.Timeline = Timeline; +exports.Array = SVGArray; +exports.Box = Box; +exports.Color = Color; +exports.EventTarget = EventTarget; +exports.Matrix = Matrix; +exports.Number = SVGNumber; +exports.PathArray = PathArray; +exports.Point = Point; +exports.PointArray = PointArray; +exports.List = List; +exports.Circle = Circle; +exports.ClipPath = ClipPath; +exports.Container = Container; +exports.Defs = Defs; +exports.Dom = Dom; +exports.Element = Element; +exports.Ellipse = Ellipse; +exports.Gradient = Gradient; +exports.G = G; +exports.A = A; +exports.Image = Image; +exports.Line = Line; +exports.Marker = Marker; +exports.Mask = Mask; +exports.Path = Path; +exports.Pattern = Pattern; +exports.Polygon = Polygon; +exports.Polyline = Polyline; +exports.Rect = Rect; +exports.Shape = Shape; +exports.Stop = Stop; +exports.Style = Style; +exports.Svg = Svg$1; +exports.Symbol = Symbol; +exports.Text = Text; +exports.TextPath = TextPath; +exports.Tspan = Tspan; +exports.Use = Use; +exports.on = on; +exports.off = off; +exports.dispatch = dispatch; +exports.root = root; +exports.create = create; +exports.makeInstance = makeInstance; +exports.nodeOrNew = nodeOrNew; +exports.adopt = adopt; +exports.mockAdopt = mockAdopt; +exports.register = register; +exports.getClass = getClass; +exports.eid = eid; +exports.assignNewId = assignNewId; +exports.extend = extend; +exports.wrapWithAttrCheck = wrapWithAttrCheck; +//# sourceMappingURL=svg.node.js.map + + +/***/ }), + +/***/ "./node_modules/bezier-easing/src/index.js": +/*!*************************************************!*\ + !*** ./node_modules/bezier-easing/src/index.js ***! + \*************************************************/ +/*! no static exports found */ +/***/ (function(module, exports) { + +/** + * https://github.com/gre/bezier-easing + * BezierEasing - use bezier curve for transition easing function + * by Gaëtan Renaudeau 2014 - 2015 – MIT License + */ + +// These values are established by empiricism with tests (tradeoff: performance VS precision) +var NEWTON_ITERATIONS = 4; +var NEWTON_MIN_SLOPE = 0.001; +var SUBDIVISION_PRECISION = 0.0000001; +var SUBDIVISION_MAX_ITERATIONS = 10; + +var kSplineTableSize = 11; +var kSampleStepSize = 1.0 / (kSplineTableSize - 1.0); + +var float32ArraySupported = typeof Float32Array === 'function'; + +function A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; } +function B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; } +function C (aA1) { return 3.0 * aA1; } + +// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2. +function calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; } + +// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2. +function getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); } + +function binarySubdivide (aX, aA, aB, mX1, mX2) { + var currentX, currentT, i = 0; + do { + currentT = aA + (aB - aA) / 2.0; + currentX = calcBezier(currentT, mX1, mX2) - aX; + if (currentX > 0.0) { + aB = currentT; + } else { + aA = currentT; + } + } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS); + return currentT; +} + +function newtonRaphsonIterate (aX, aGuessT, mX1, mX2) { + for (var i = 0; i < NEWTON_ITERATIONS; ++i) { + var currentSlope = getSlope(aGuessT, mX1, mX2); + if (currentSlope === 0.0) { + return aGuessT; + } + var currentX = calcBezier(aGuessT, mX1, mX2) - aX; + aGuessT -= currentX / currentSlope; + } + return aGuessT; +} + +function LinearEasing (x) { + return x; +} + +module.exports = function bezier (mX1, mY1, mX2, mY2) { + if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) { + throw new Error('bezier x values must be in [0, 1] range'); + } + + if (mX1 === mY1 && mX2 === mY2) { + return LinearEasing; + } + + // Precompute samples table + var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize); + for (var i = 0; i < kSplineTableSize; ++i) { + sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2); + } + + function getTForX (aX) { + var intervalStart = 0.0; + var currentSample = 1; + var lastSample = kSplineTableSize - 1; + + for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) { + intervalStart += kSampleStepSize; + } + --currentSample; + + // Interpolate to provide an initial guess for t + var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]); + var guessForT = intervalStart + dist * kSampleStepSize; + + var initialSlope = getSlope(guessForT, mX1, mX2); + if (initialSlope >= NEWTON_MIN_SLOPE) { + return newtonRaphsonIterate(aX, guessForT, mX1, mX2); + } else if (initialSlope === 0.0) { + return guessForT; + } else { + return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2); + } + } + + return function BezierEasing (x) { + // Because JavaScript number are imprecise, we should guarantee the extremes are right. + if (x === 0) { + return 0; + } + if (x === 1) { + return 1; + } + return calcBezier(getTForX(x), mY1, mY2); + }; +}; + + +/***/ }), + +/***/ "./node_modules/gl-matrix/lib/gl-matrix.js": +/*!*************************************************!*\ + !*** ./node_modules/gl-matrix/lib/gl-matrix.js ***! + \*************************************************/ +/*! exports provided: glMatrix, mat2, mat2d, mat3, mat4, quat, quat2, vec2, vec3, vec4 */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony import */ var _gl_matrix_common_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./gl-matrix/common.js */ "./node_modules/gl-matrix/lib/gl-matrix/common.js"); +/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "glMatrix", function() { return _gl_matrix_common_js__WEBPACK_IMPORTED_MODULE_0__; }); +/* harmony import */ var _gl_matrix_mat2_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./gl-matrix/mat2.js */ "./node_modules/gl-matrix/lib/gl-matrix/mat2.js"); +/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "mat2", function() { return _gl_matrix_mat2_js__WEBPACK_IMPORTED_MODULE_1__; }); +/* harmony import */ var _gl_matrix_mat2d_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./gl-matrix/mat2d.js */ "./node_modules/gl-matrix/lib/gl-matrix/mat2d.js"); +/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "mat2d", function() { return _gl_matrix_mat2d_js__WEBPACK_IMPORTED_MODULE_2__; }); +/* harmony import */ var _gl_matrix_mat3_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./gl-matrix/mat3.js */ "./node_modules/gl-matrix/lib/gl-matrix/mat3.js"); +/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "mat3", function() { return _gl_matrix_mat3_js__WEBPACK_IMPORTED_MODULE_3__; }); +/* harmony import */ var _gl_matrix_mat4_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./gl-matrix/mat4.js */ "./node_modules/gl-matrix/lib/gl-matrix/mat4.js"); +/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "mat4", function() { return _gl_matrix_mat4_js__WEBPACK_IMPORTED_MODULE_4__; }); +/* harmony import */ var _gl_matrix_quat_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./gl-matrix/quat.js */ "./node_modules/gl-matrix/lib/gl-matrix/quat.js"); +/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "quat", function() { return _gl_matrix_quat_js__WEBPACK_IMPORTED_MODULE_5__; }); +/* harmony import */ var _gl_matrix_quat2_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./gl-matrix/quat2.js */ "./node_modules/gl-matrix/lib/gl-matrix/quat2.js"); +/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "quat2", function() { return _gl_matrix_quat2_js__WEBPACK_IMPORTED_MODULE_6__; }); +/* harmony import */ var _gl_matrix_vec2_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./gl-matrix/vec2.js */ "./node_modules/gl-matrix/lib/gl-matrix/vec2.js"); +/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "vec2", function() { return _gl_matrix_vec2_js__WEBPACK_IMPORTED_MODULE_7__; }); +/* harmony import */ var _gl_matrix_vec3_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./gl-matrix/vec3.js */ "./node_modules/gl-matrix/lib/gl-matrix/vec3.js"); +/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "vec3", function() { return _gl_matrix_vec3_js__WEBPACK_IMPORTED_MODULE_8__; }); +/* harmony import */ var _gl_matrix_vec4_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./gl-matrix/vec4.js */ "./node_modules/gl-matrix/lib/gl-matrix/vec4.js"); +/* harmony reexport (module object) */ __webpack_require__.d(__webpack_exports__, "vec4", function() { return _gl_matrix_vec4_js__WEBPACK_IMPORTED_MODULE_9__; }); + + + + + + + + + + + + + +/***/ }), + +/***/ "./node_modules/gl-matrix/lib/gl-matrix/common.js": +/*!********************************************************!*\ + !*** ./node_modules/gl-matrix/lib/gl-matrix/common.js ***! + \********************************************************/ +/*! exports provided: EPSILON, ARRAY_TYPE, RANDOM, setMatrixArrayType, toRadian, equals */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "EPSILON", function() { return EPSILON; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ARRAY_TYPE", function() { return ARRAY_TYPE; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RANDOM", function() { return RANDOM; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "setMatrixArrayType", function() { return setMatrixArrayType; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "toRadian", function() { return toRadian; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equals", function() { return equals; }); +/** + * Common utilities + * @module glMatrix + */ + +// Configuration Constants +var EPSILON = 0.000001; +var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array; +var RANDOM = Math.random; + +/** + * Sets the type of array used when creating new vectors and matrices + * + * @param {Type} type Array type, such as Float32Array or Array + */ +function setMatrixArrayType(type) { + ARRAY_TYPE = type; +} + +var degree = Math.PI / 180; + +/** + * Convert Degree To Radian + * + * @param {Number} a Angle in Degrees + */ +function toRadian(a) { + return a * degree; +} + +/** + * Tests whether or not the arguments have approximately the same value, within an absolute + * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less + * than or equal to 1.0, and a relative tolerance is used for larger values) + * + * @param {Number} a The first number to test. + * @param {Number} b The second number to test. + * @returns {Boolean} True if the numbers are approximately equal, false otherwise. + */ +function equals(a, b) { + return Math.abs(a - b) <= EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b)); +} + +/***/ }), + +/***/ "./node_modules/gl-matrix/lib/gl-matrix/mat2.js": +/*!******************************************************!*\ + !*** ./node_modules/gl-matrix/lib/gl-matrix/mat2.js ***! + \******************************************************/ +/*! exports provided: create, clone, copy, identity, fromValues, set, transpose, invert, adjoint, determinant, multiply, rotate, scale, fromRotation, fromScaling, str, frob, LDU, add, subtract, exactEquals, equals, multiplyScalar, multiplyScalarAndAdd, mul, sub */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "create", function() { return create; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clone", function() { return clone; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copy", function() { return copy; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "identity", function() { return identity; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromValues", function() { return fromValues; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "set", function() { return set; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transpose", function() { return transpose; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "invert", function() { return invert; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "adjoint", function() { return adjoint; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "determinant", function() { return determinant; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiply", function() { return multiply; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotate", function() { return rotate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scale", function() { return scale; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromRotation", function() { return fromRotation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromScaling", function() { return fromScaling; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "str", function() { return str; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "frob", function() { return frob; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "LDU", function() { return LDU; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "add", function() { return add; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "subtract", function() { return subtract; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "exactEquals", function() { return exactEquals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equals", function() { return equals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiplyScalar", function() { return multiplyScalar; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiplyScalarAndAdd", function() { return multiplyScalarAndAdd; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mul", function() { return mul; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sub", function() { return sub; }); +/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common.js */ "./node_modules/gl-matrix/lib/gl-matrix/common.js"); + + +/** + * 2x2 Matrix + * @module mat2 + */ + +/** + * Creates a new identity mat2 + * + * @returns {mat2} a new 2x2 matrix + */ +function create() { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](4); + if (_common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"] != Float32Array) { + out[1] = 0; + out[2] = 0; + } + out[0] = 1; + out[3] = 1; + return out; +} + +/** + * Creates a new mat2 initialized with values from an existing matrix + * + * @param {mat2} a matrix to clone + * @returns {mat2} a new 2x2 matrix + */ +function clone(a) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](4); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + return out; +} + +/** + * Copy the values from one mat2 to another + * + * @param {mat2} out the receiving matrix + * @param {mat2} a the source matrix + * @returns {mat2} out + */ +function copy(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + return out; +} + +/** + * Set a mat2 to the identity matrix + * + * @param {mat2} out the receiving matrix + * @returns {mat2} out + */ +function identity(out) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 1; + return out; +} + +/** + * Create a new mat2 with the given values + * + * @param {Number} m00 Component in column 0, row 0 position (index 0) + * @param {Number} m01 Component in column 0, row 1 position (index 1) + * @param {Number} m10 Component in column 1, row 0 position (index 2) + * @param {Number} m11 Component in column 1, row 1 position (index 3) + * @returns {mat2} out A new 2x2 matrix + */ +function fromValues(m00, m01, m10, m11) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](4); + out[0] = m00; + out[1] = m01; + out[2] = m10; + out[3] = m11; + return out; +} + +/** + * Set the components of a mat2 to the given values + * + * @param {mat2} out the receiving matrix + * @param {Number} m00 Component in column 0, row 0 position (index 0) + * @param {Number} m01 Component in column 0, row 1 position (index 1) + * @param {Number} m10 Component in column 1, row 0 position (index 2) + * @param {Number} m11 Component in column 1, row 1 position (index 3) + * @returns {mat2} out + */ +function set(out, m00, m01, m10, m11) { + out[0] = m00; + out[1] = m01; + out[2] = m10; + out[3] = m11; + return out; +} + +/** + * Transpose the values of a mat2 + * + * @param {mat2} out the receiving matrix + * @param {mat2} a the source matrix + * @returns {mat2} out + */ +function transpose(out, a) { + // If we are transposing ourselves we can skip a few steps but have to cache + // some values + if (out === a) { + var a1 = a[1]; + out[1] = a[2]; + out[2] = a1; + } else { + out[0] = a[0]; + out[1] = a[2]; + out[2] = a[1]; + out[3] = a[3]; + } + + return out; +} + +/** + * Inverts a mat2 + * + * @param {mat2} out the receiving matrix + * @param {mat2} a the source matrix + * @returns {mat2} out + */ +function invert(out, a) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3]; + + // Calculate the determinant + var det = a0 * a3 - a2 * a1; + + if (!det) { + return null; + } + det = 1.0 / det; + + out[0] = a3 * det; + out[1] = -a1 * det; + out[2] = -a2 * det; + out[3] = a0 * det; + + return out; +} + +/** + * Calculates the adjugate of a mat2 + * + * @param {mat2} out the receiving matrix + * @param {mat2} a the source matrix + * @returns {mat2} out + */ +function adjoint(out, a) { + // Caching this value is nessecary if out == a + var a0 = a[0]; + out[0] = a[3]; + out[1] = -a[1]; + out[2] = -a[2]; + out[3] = a0; + + return out; +} + +/** + * Calculates the determinant of a mat2 + * + * @param {mat2} a the source matrix + * @returns {Number} determinant of a + */ +function determinant(a) { + return a[0] * a[3] - a[2] * a[1]; +} + +/** + * Multiplies two mat2's + * + * @param {mat2} out the receiving matrix + * @param {mat2} a the first operand + * @param {mat2} b the second operand + * @returns {mat2} out + */ +function multiply(out, a, b) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3]; + var b0 = b[0], + b1 = b[1], + b2 = b[2], + b3 = b[3]; + out[0] = a0 * b0 + a2 * b1; + out[1] = a1 * b0 + a3 * b1; + out[2] = a0 * b2 + a2 * b3; + out[3] = a1 * b2 + a3 * b3; + return out; +} + +/** + * Rotates a mat2 by the given angle + * + * @param {mat2} out the receiving matrix + * @param {mat2} a the matrix to rotate + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat2} out + */ +function rotate(out, a, rad) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3]; + var s = Math.sin(rad); + var c = Math.cos(rad); + out[0] = a0 * c + a2 * s; + out[1] = a1 * c + a3 * s; + out[2] = a0 * -s + a2 * c; + out[3] = a1 * -s + a3 * c; + return out; +} + +/** + * Scales the mat2 by the dimensions in the given vec2 + * + * @param {mat2} out the receiving matrix + * @param {mat2} a the matrix to rotate + * @param {vec2} v the vec2 to scale the matrix by + * @returns {mat2} out + **/ +function scale(out, a, v) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3]; + var v0 = v[0], + v1 = v[1]; + out[0] = a0 * v0; + out[1] = a1 * v0; + out[2] = a2 * v1; + out[3] = a3 * v1; + return out; +} + +/** + * Creates a matrix from a given angle + * This is equivalent to (but much faster than): + * + * mat2.identity(dest); + * mat2.rotate(dest, dest, rad); + * + * @param {mat2} out mat2 receiving operation result + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat2} out + */ +function fromRotation(out, rad) { + var s = Math.sin(rad); + var c = Math.cos(rad); + out[0] = c; + out[1] = s; + out[2] = -s; + out[3] = c; + return out; +} + +/** + * Creates a matrix from a vector scaling + * This is equivalent to (but much faster than): + * + * mat2.identity(dest); + * mat2.scale(dest, dest, vec); + * + * @param {mat2} out mat2 receiving operation result + * @param {vec2} v Scaling vector + * @returns {mat2} out + */ +function fromScaling(out, v) { + out[0] = v[0]; + out[1] = 0; + out[2] = 0; + out[3] = v[1]; + return out; +} + +/** + * Returns a string representation of a mat2 + * + * @param {mat2} a matrix to represent as a string + * @returns {String} string representation of the matrix + */ +function str(a) { + return 'mat2(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')'; +} + +/** + * Returns Frobenius norm of a mat2 + * + * @param {mat2} a the matrix to calculate Frobenius norm of + * @returns {Number} Frobenius norm + */ +function frob(a) { + return Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2) + Math.pow(a[2], 2) + Math.pow(a[3], 2)); +} + +/** + * Returns L, D and U matrices (Lower triangular, Diagonal and Upper triangular) by factorizing the input matrix + * @param {mat2} L the lower triangular matrix + * @param {mat2} D the diagonal matrix + * @param {mat2} U the upper triangular matrix + * @param {mat2} a the input matrix to factorize + */ + +function LDU(L, D, U, a) { + L[2] = a[2] / a[0]; + U[0] = a[0]; + U[1] = a[1]; + U[3] = a[3] - L[2] * U[1]; + return [L, D, U]; +} + +/** + * Adds two mat2's + * + * @param {mat2} out the receiving matrix + * @param {mat2} a the first operand + * @param {mat2} b the second operand + * @returns {mat2} out + */ +function add(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + return out; +} + +/** + * Subtracts matrix b from matrix a + * + * @param {mat2} out the receiving matrix + * @param {mat2} a the first operand + * @param {mat2} b the second operand + * @returns {mat2} out + */ +function subtract(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + out[3] = a[3] - b[3]; + return out; +} + +/** + * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===) + * + * @param {mat2} a The first matrix. + * @param {mat2} b The second matrix. + * @returns {Boolean} True if the matrices are equal, false otherwise. + */ +function exactEquals(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3]; +} + +/** + * Returns whether or not the matrices have approximately the same elements in the same position. + * + * @param {mat2} a The first matrix. + * @param {mat2} b The second matrix. + * @returns {Boolean} True if the matrices are equal, false otherwise. + */ +function equals(a, b) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3]; + var b0 = b[0], + b1 = b[1], + b2 = b[2], + b3 = b[3]; + return Math.abs(a0 - b0) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a3), Math.abs(b3)); +} + +/** + * Multiply each element of the matrix by a scalar. + * + * @param {mat2} out the receiving matrix + * @param {mat2} a the matrix to scale + * @param {Number} b amount to scale the matrix's elements by + * @returns {mat2} out + */ +function multiplyScalar(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + return out; +} + +/** + * Adds two mat2's after multiplying each element of the second operand by a scalar value. + * + * @param {mat2} out the receiving vector + * @param {mat2} a the first operand + * @param {mat2} b the second operand + * @param {Number} scale the amount to scale b's elements by before adding + * @returns {mat2} out + */ +function multiplyScalarAndAdd(out, a, b, scale) { + out[0] = a[0] + b[0] * scale; + out[1] = a[1] + b[1] * scale; + out[2] = a[2] + b[2] * scale; + out[3] = a[3] + b[3] * scale; + return out; +} + +/** + * Alias for {@link mat2.multiply} + * @function + */ +var mul = multiply; + +/** + * Alias for {@link mat2.subtract} + * @function + */ +var sub = subtract; + +/***/ }), + +/***/ "./node_modules/gl-matrix/lib/gl-matrix/mat2d.js": +/*!*******************************************************!*\ + !*** ./node_modules/gl-matrix/lib/gl-matrix/mat2d.js ***! + \*******************************************************/ +/*! exports provided: create, clone, copy, identity, fromValues, set, invert, determinant, multiply, rotate, scale, translate, fromRotation, fromScaling, fromTranslation, str, frob, add, subtract, multiplyScalar, multiplyScalarAndAdd, exactEquals, equals, mul, sub */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "create", function() { return create; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clone", function() { return clone; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copy", function() { return copy; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "identity", function() { return identity; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromValues", function() { return fromValues; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "set", function() { return set; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "invert", function() { return invert; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "determinant", function() { return determinant; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiply", function() { return multiply; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotate", function() { return rotate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scale", function() { return scale; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "translate", function() { return translate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromRotation", function() { return fromRotation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromScaling", function() { return fromScaling; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromTranslation", function() { return fromTranslation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "str", function() { return str; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "frob", function() { return frob; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "add", function() { return add; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "subtract", function() { return subtract; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiplyScalar", function() { return multiplyScalar; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiplyScalarAndAdd", function() { return multiplyScalarAndAdd; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "exactEquals", function() { return exactEquals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equals", function() { return equals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mul", function() { return mul; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sub", function() { return sub; }); +/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common.js */ "./node_modules/gl-matrix/lib/gl-matrix/common.js"); + + +/** + * 2x3 Matrix + * @module mat2d + * + * @description + * A mat2d contains six elements defined as: + * 
+ * [a, c, tx,
+ *  b, d, ty]
+ *
+ * This is a short form for the 3x3 matrix: + * 
+ * [a, c, tx,
+ *  b, d, ty,
+ *  0, 0, 1]
+ *
+ * The last row is ignored so the array is shorter and operations are faster. + */ + +/** + * Creates a new identity mat2d + * + * @returns {mat2d} a new 2x3 matrix + */ +function create() { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](6); + if (_common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"] != Float32Array) { + out[1] = 0; + out[2] = 0; + out[4] = 0; + out[5] = 0; + } + out[0] = 1; + out[3] = 1; + return out; +} + +/** + * Creates a new mat2d initialized with values from an existing matrix + * + * @param {mat2d} a matrix to clone + * @returns {mat2d} a new 2x3 matrix + */ +function clone(a) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](6); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + return out; +} + +/** + * Copy the values from one mat2d to another + * + * @param {mat2d} out the receiving matrix + * @param {mat2d} a the source matrix + * @returns {mat2d} out + */ +function copy(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + return out; +} + +/** + * Set a mat2d to the identity matrix + * + * @param {mat2d} out the receiving matrix + * @returns {mat2d} out + */ +function identity(out) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 1; + out[4] = 0; + out[5] = 0; + return out; +} + +/** + * Create a new mat2d with the given values + * + * @param {Number} a Component A (index 0) + * @param {Number} b Component B (index 1) + * @param {Number} c Component C (index 2) + * @param {Number} d Component D (index 3) + * @param {Number} tx Component TX (index 4) + * @param {Number} ty Component TY (index 5) + * @returns {mat2d} A new mat2d + */ +function fromValues(a, b, c, d, tx, ty) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](6); + out[0] = a; + out[1] = b; + out[2] = c; + out[3] = d; + out[4] = tx; + out[5] = ty; + return out; +} + +/** + * Set the components of a mat2d to the given values + * + * @param {mat2d} out the receiving matrix + * @param {Number} a Component A (index 0) + * @param {Number} b Component B (index 1) + * @param {Number} c Component C (index 2) + * @param {Number} d Component D (index 3) + * @param {Number} tx Component TX (index 4) + * @param {Number} ty Component TY (index 5) + * @returns {mat2d} out + */ +function set(out, a, b, c, d, tx, ty) { + out[0] = a; + out[1] = b; + out[2] = c; + out[3] = d; + out[4] = tx; + out[5] = ty; + return out; +} + +/** + * Inverts a mat2d + * + * @param {mat2d} out the receiving matrix + * @param {mat2d} a the source matrix + * @returns {mat2d} out + */ +function invert(out, a) { + var aa = a[0], + ab = a[1], + ac = a[2], + ad = a[3]; + var atx = a[4], + aty = a[5]; + + var det = aa * ad - ab * ac; + if (!det) { + return null; + } + det = 1.0 / det; + + out[0] = ad * det; + out[1] = -ab * det; + out[2] = -ac * det; + out[3] = aa * det; + out[4] = (ac * aty - ad * atx) * det; + out[5] = (ab * atx - aa * aty) * det; + return out; +} + +/** + * Calculates the determinant of a mat2d + * + * @param {mat2d} a the source matrix + * @returns {Number} determinant of a + */ +function determinant(a) { + return a[0] * a[3] - a[1] * a[2]; +} + +/** + * Multiplies two mat2d's + * + * @param {mat2d} out the receiving matrix + * @param {mat2d} a the first operand + * @param {mat2d} b the second operand + * @returns {mat2d} out + */ +function multiply(out, a, b) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3], + a4 = a[4], + a5 = a[5]; + var b0 = b[0], + b1 = b[1], + b2 = b[2], + b3 = b[3], + b4 = b[4], + b5 = b[5]; + out[0] = a0 * b0 + a2 * b1; + out[1] = a1 * b0 + a3 * b1; + out[2] = a0 * b2 + a2 * b3; + out[3] = a1 * b2 + a3 * b3; + out[4] = a0 * b4 + a2 * b5 + a4; + out[5] = a1 * b4 + a3 * b5 + a5; + return out; +} + +/** + * Rotates a mat2d by the given angle + * + * @param {mat2d} out the receiving matrix + * @param {mat2d} a the matrix to rotate + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat2d} out + */ +function rotate(out, a, rad) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3], + a4 = a[4], + a5 = a[5]; + var s = Math.sin(rad); + var c = Math.cos(rad); + out[0] = a0 * c + a2 * s; + out[1] = a1 * c + a3 * s; + out[2] = a0 * -s + a2 * c; + out[3] = a1 * -s + a3 * c; + out[4] = a4; + out[5] = a5; + return out; +} + +/** + * Scales the mat2d by the dimensions in the given vec2 + * + * @param {mat2d} out the receiving matrix + * @param {mat2d} a the matrix to translate + * @param {vec2} v the vec2 to scale the matrix by + * @returns {mat2d} out + **/ +function scale(out, a, v) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3], + a4 = a[4], + a5 = a[5]; + var v0 = v[0], + v1 = v[1]; + out[0] = a0 * v0; + out[1] = a1 * v0; + out[2] = a2 * v1; + out[3] = a3 * v1; + out[4] = a4; + out[5] = a5; + return out; +} + +/** + * Translates the mat2d by the dimensions in the given vec2 + * + * @param {mat2d} out the receiving matrix + * @param {mat2d} a the matrix to translate + * @param {vec2} v the vec2 to translate the matrix by + * @returns {mat2d} out + **/ +function translate(out, a, v) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3], + a4 = a[4], + a5 = a[5]; + var v0 = v[0], + v1 = v[1]; + out[0] = a0; + out[1] = a1; + out[2] = a2; + out[3] = a3; + out[4] = a0 * v0 + a2 * v1 + a4; + out[5] = a1 * v0 + a3 * v1 + a5; + return out; +} + +/** + * Creates a matrix from a given angle + * This is equivalent to (but much faster than): + * + * mat2d.identity(dest); + * mat2d.rotate(dest, dest, rad); + * + * @param {mat2d} out mat2d receiving operation result + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat2d} out + */ +function fromRotation(out, rad) { + var s = Math.sin(rad), + c = Math.cos(rad); + out[0] = c; + out[1] = s; + out[2] = -s; + out[3] = c; + out[4] = 0; + out[5] = 0; + return out; +} + +/** + * Creates a matrix from a vector scaling + * This is equivalent to (but much faster than): + * + * mat2d.identity(dest); + * mat2d.scale(dest, dest, vec); + * + * @param {mat2d} out mat2d receiving operation result + * @param {vec2} v Scaling vector + * @returns {mat2d} out + */ +function fromScaling(out, v) { + out[0] = v[0]; + out[1] = 0; + out[2] = 0; + out[3] = v[1]; + out[4] = 0; + out[5] = 0; + return out; +} + +/** + * Creates a matrix from a vector translation + * This is equivalent to (but much faster than): + * + * mat2d.identity(dest); + * mat2d.translate(dest, dest, vec); + * + * @param {mat2d} out mat2d receiving operation result + * @param {vec2} v Translation vector + * @returns {mat2d} out + */ +function fromTranslation(out, v) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 1; + out[4] = v[0]; + out[5] = v[1]; + return out; +} + +/** + * Returns a string representation of a mat2d + * + * @param {mat2d} a matrix to represent as a string + * @returns {String} string representation of the matrix + */ +function str(a) { + return 'mat2d(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ')'; +} + +/** + * Returns Frobenius norm of a mat2d + * + * @param {mat2d} a the matrix to calculate Frobenius norm of + * @returns {Number} Frobenius norm + */ +function frob(a) { + return Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2) + Math.pow(a[2], 2) + Math.pow(a[3], 2) + Math.pow(a[4], 2) + Math.pow(a[5], 2) + 1); +} + +/** + * Adds two mat2d's + * + * @param {mat2d} out the receiving matrix + * @param {mat2d} a the first operand + * @param {mat2d} b the second operand + * @returns {mat2d} out + */ +function add(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + out[4] = a[4] + b[4]; + out[5] = a[5] + b[5]; + return out; +} + +/** + * Subtracts matrix b from matrix a + * + * @param {mat2d} out the receiving matrix + * @param {mat2d} a the first operand + * @param {mat2d} b the second operand + * @returns {mat2d} out + */ +function subtract(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + out[3] = a[3] - b[3]; + out[4] = a[4] - b[4]; + out[5] = a[5] - b[5]; + return out; +} + +/** + * Multiply each element of the matrix by a scalar. + * + * @param {mat2d} out the receiving matrix + * @param {mat2d} a the matrix to scale + * @param {Number} b amount to scale the matrix's elements by + * @returns {mat2d} out + */ +function multiplyScalar(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + out[4] = a[4] * b; + out[5] = a[5] * b; + return out; +} + +/** + * Adds two mat2d's after multiplying each element of the second operand by a scalar value. + * + * @param {mat2d} out the receiving vector + * @param {mat2d} a the first operand + * @param {mat2d} b the second operand + * @param {Number} scale the amount to scale b's elements by before adding + * @returns {mat2d} out + */ +function multiplyScalarAndAdd(out, a, b, scale) { + out[0] = a[0] + b[0] * scale; + out[1] = a[1] + b[1] * scale; + out[2] = a[2] + b[2] * scale; + out[3] = a[3] + b[3] * scale; + out[4] = a[4] + b[4] * scale; + out[5] = a[5] + b[5] * scale; + return out; +} + +/** + * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===) + * + * @param {mat2d} a The first matrix. + * @param {mat2d} b The second matrix. + * @returns {Boolean} True if the matrices are equal, false otherwise. + */ +function exactEquals(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5]; +} + +/** + * Returns whether or not the matrices have approximately the same elements in the same position. + * + * @param {mat2d} a The first matrix. + * @param {mat2d} b The second matrix. + * @returns {Boolean} True if the matrices are equal, false otherwise. + */ +function equals(a, b) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3], + a4 = a[4], + a5 = a[5]; + var b0 = b[0], + b1 = b[1], + b2 = b[2], + b3 = b[3], + b4 = b[4], + b5 = b[5]; + return Math.abs(a0 - b0) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a5), Math.abs(b5)); +} + +/** + * Alias for {@link mat2d.multiply} + * @function + */ +var mul = multiply; + +/** + * Alias for {@link mat2d.subtract} + * @function + */ +var sub = subtract; + +/***/ }), + +/***/ "./node_modules/gl-matrix/lib/gl-matrix/mat3.js": +/*!******************************************************!*\ + !*** ./node_modules/gl-matrix/lib/gl-matrix/mat3.js ***! + \******************************************************/ +/*! exports provided: create, fromMat4, clone, copy, fromValues, set, identity, transpose, invert, adjoint, determinant, multiply, translate, rotate, scale, fromTranslation, fromRotation, fromScaling, fromMat2d, fromQuat, normalFromMat4, projection, str, frob, add, subtract, multiplyScalar, multiplyScalarAndAdd, exactEquals, equals, mul, sub */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "create", function() { return create; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromMat4", function() { return fromMat4; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clone", function() { return clone; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copy", function() { return copy; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromValues", function() { return fromValues; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "set", function() { return set; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "identity", function() { return identity; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transpose", function() { return transpose; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "invert", function() { return invert; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "adjoint", function() { return adjoint; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "determinant", function() { return determinant; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiply", function() { return multiply; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "translate", function() { return translate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotate", function() { return rotate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scale", function() { return scale; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromTranslation", function() { return fromTranslation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromRotation", function() { return fromRotation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromScaling", function() { return fromScaling; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromMat2d", function() { return fromMat2d; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromQuat", function() { return fromQuat; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "normalFromMat4", function() { return normalFromMat4; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "projection", function() { return projection; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "str", function() { return str; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "frob", function() { return frob; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "add", function() { return add; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "subtract", function() { return subtract; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiplyScalar", function() { return multiplyScalar; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiplyScalarAndAdd", function() { return multiplyScalarAndAdd; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "exactEquals", function() { return exactEquals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equals", function() { return equals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mul", function() { return mul; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sub", function() { return sub; }); +/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common.js */ "./node_modules/gl-matrix/lib/gl-matrix/common.js"); + + +/** + * 3x3 Matrix + * @module mat3 + */ + +/** + * Creates a new identity mat3 + * + * @returns {mat3} a new 3x3 matrix + */ +function create() { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](9); + if (_common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"] != Float32Array) { + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[5] = 0; + out[6] = 0; + out[7] = 0; + } + out[0] = 1; + out[4] = 1; + out[8] = 1; + return out; +} + +/** + * Copies the upper-left 3x3 values into the given mat3. + * + * @param {mat3} out the receiving 3x3 matrix + * @param {mat4} a the source 4x4 matrix + * @returns {mat3} out + */ +function fromMat4(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[4]; + out[4] = a[5]; + out[5] = a[6]; + out[6] = a[8]; + out[7] = a[9]; + out[8] = a[10]; + return out; +} + +/** + * Creates a new mat3 initialized with values from an existing matrix + * + * @param {mat3} a matrix to clone + * @returns {mat3} a new 3x3 matrix + */ +function clone(a) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](9); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + return out; +} + +/** + * Copy the values from one mat3 to another + * + * @param {mat3} out the receiving matrix + * @param {mat3} a the source matrix + * @returns {mat3} out + */ +function copy(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + return out; +} + +/** + * Create a new mat3 with the given values + * + * @param {Number} m00 Component in column 0, row 0 position (index 0) + * @param {Number} m01 Component in column 0, row 1 position (index 1) + * @param {Number} m02 Component in column 0, row 2 position (index 2) + * @param {Number} m10 Component in column 1, row 0 position (index 3) + * @param {Number} m11 Component in column 1, row 1 position (index 4) + * @param {Number} m12 Component in column 1, row 2 position (index 5) + * @param {Number} m20 Component in column 2, row 0 position (index 6) + * @param {Number} m21 Component in column 2, row 1 position (index 7) + * @param {Number} m22 Component in column 2, row 2 position (index 8) + * @returns {mat3} A new mat3 + */ +function fromValues(m00, m01, m02, m10, m11, m12, m20, m21, m22) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](9); + out[0] = m00; + out[1] = m01; + out[2] = m02; + out[3] = m10; + out[4] = m11; + out[5] = m12; + out[6] = m20; + out[7] = m21; + out[8] = m22; + return out; +} + +/** + * Set the components of a mat3 to the given values + * + * @param {mat3} out the receiving matrix + * @param {Number} m00 Component in column 0, row 0 position (index 0) + * @param {Number} m01 Component in column 0, row 1 position (index 1) + * @param {Number} m02 Component in column 0, row 2 position (index 2) + * @param {Number} m10 Component in column 1, row 0 position (index 3) + * @param {Number} m11 Component in column 1, row 1 position (index 4) + * @param {Number} m12 Component in column 1, row 2 position (index 5) + * @param {Number} m20 Component in column 2, row 0 position (index 6) + * @param {Number} m21 Component in column 2, row 1 position (index 7) + * @param {Number} m22 Component in column 2, row 2 position (index 8) + * @returns {mat3} out + */ +function set(out, m00, m01, m02, m10, m11, m12, m20, m21, m22) { + out[0] = m00; + out[1] = m01; + out[2] = m02; + out[3] = m10; + out[4] = m11; + out[5] = m12; + out[6] = m20; + out[7] = m21; + out[8] = m22; + return out; +} + +/** + * Set a mat3 to the identity matrix + * + * @param {mat3} out the receiving matrix + * @returns {mat3} out + */ +function identity(out) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 1; + out[5] = 0; + out[6] = 0; + out[7] = 0; + out[8] = 1; + return out; +} + +/** + * Transpose the values of a mat3 + * + * @param {mat3} out the receiving matrix + * @param {mat3} a the source matrix + * @returns {mat3} out + */ +function transpose(out, a) { + // If we are transposing ourselves we can skip a few steps but have to cache some values + if (out === a) { + var a01 = a[1], + a02 = a[2], + a12 = a[5]; + out[1] = a[3]; + out[2] = a[6]; + out[3] = a01; + out[5] = a[7]; + out[6] = a02; + out[7] = a12; + } else { + out[0] = a[0]; + out[1] = a[3]; + out[2] = a[6]; + out[3] = a[1]; + out[4] = a[4]; + out[5] = a[7]; + out[6] = a[2]; + out[7] = a[5]; + out[8] = a[8]; + } + + return out; +} + +/** + * Inverts a mat3 + * + * @param {mat3} out the receiving matrix + * @param {mat3} a the source matrix + * @returns {mat3} out + */ +function invert(out, a) { + var a00 = a[0], + a01 = a[1], + a02 = a[2]; + var a10 = a[3], + a11 = a[4], + a12 = a[5]; + var a20 = a[6], + a21 = a[7], + a22 = a[8]; + + var b01 = a22 * a11 - a12 * a21; + var b11 = -a22 * a10 + a12 * a20; + var b21 = a21 * a10 - a11 * a20; + + // Calculate the determinant + var det = a00 * b01 + a01 * b11 + a02 * b21; + + if (!det) { + return null; + } + det = 1.0 / det; + + out[0] = b01 * det; + out[1] = (-a22 * a01 + a02 * a21) * det; + out[2] = (a12 * a01 - a02 * a11) * det; + out[3] = b11 * det; + out[4] = (a22 * a00 - a02 * a20) * det; + out[5] = (-a12 * a00 + a02 * a10) * det; + out[6] = b21 * det; + out[7] = (-a21 * a00 + a01 * a20) * det; + out[8] = (a11 * a00 - a01 * a10) * det; + return out; +} + +/** + * Calculates the adjugate of a mat3 + * + * @param {mat3} out the receiving matrix + * @param {mat3} a the source matrix + * @returns {mat3} out + */ +function adjoint(out, a) { + var a00 = a[0], + a01 = a[1], + a02 = a[2]; + var a10 = a[3], + a11 = a[4], + a12 = a[5]; + var a20 = a[6], + a21 = a[7], + a22 = a[8]; + + out[0] = a11 * a22 - a12 * a21; + out[1] = a02 * a21 - a01 * a22; + out[2] = a01 * a12 - a02 * a11; + out[3] = a12 * a20 - a10 * a22; + out[4] = a00 * a22 - a02 * a20; + out[5] = a02 * a10 - a00 * a12; + out[6] = a10 * a21 - a11 * a20; + out[7] = a01 * a20 - a00 * a21; + out[8] = a00 * a11 - a01 * a10; + return out; +} + +/** + * Calculates the determinant of a mat3 + * + * @param {mat3} a the source matrix + * @returns {Number} determinant of a + */ +function determinant(a) { + var a00 = a[0], + a01 = a[1], + a02 = a[2]; + var a10 = a[3], + a11 = a[4], + a12 = a[5]; + var a20 = a[6], + a21 = a[7], + a22 = a[8]; + + return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20); +} + +/** + * Multiplies two mat3's + * + * @param {mat3} out the receiving matrix + * @param {mat3} a the first operand + * @param {mat3} b the second operand + * @returns {mat3} out + */ +function multiply(out, a, b) { + var a00 = a[0], + a01 = a[1], + a02 = a[2]; + var a10 = a[3], + a11 = a[4], + a12 = a[5]; + var a20 = a[6], + a21 = a[7], + a22 = a[8]; + + var b00 = b[0], + b01 = b[1], + b02 = b[2]; + var b10 = b[3], + b11 = b[4], + b12 = b[5]; + var b20 = b[6], + b21 = b[7], + b22 = b[8]; + + out[0] = b00 * a00 + b01 * a10 + b02 * a20; + out[1] = b00 * a01 + b01 * a11 + b02 * a21; + out[2] = b00 * a02 + b01 * a12 + b02 * a22; + + out[3] = b10 * a00 + b11 * a10 + b12 * a20; + out[4] = b10 * a01 + b11 * a11 + b12 * a21; + out[5] = b10 * a02 + b11 * a12 + b12 * a22; + + out[6] = b20 * a00 + b21 * a10 + b22 * a20; + out[7] = b20 * a01 + b21 * a11 + b22 * a21; + out[8] = b20 * a02 + b21 * a12 + b22 * a22; + return out; +} + +/** + * Translate a mat3 by the given vector + * + * @param {mat3} out the receiving matrix + * @param {mat3} a the matrix to translate + * @param {vec2} v vector to translate by + * @returns {mat3} out + */ +function translate(out, a, v) { + var a00 = a[0], + a01 = a[1], + a02 = a[2], + a10 = a[3], + a11 = a[4], + a12 = a[5], + a20 = a[6], + a21 = a[7], + a22 = a[8], + x = v[0], + y = v[1]; + + out[0] = a00; + out[1] = a01; + out[2] = a02; + + out[3] = a10; + out[4] = a11; + out[5] = a12; + + out[6] = x * a00 + y * a10 + a20; + out[7] = x * a01 + y * a11 + a21; + out[8] = x * a02 + y * a12 + a22; + return out; +} + +/** + * Rotates a mat3 by the given angle + * + * @param {mat3} out the receiving matrix + * @param {mat3} a the matrix to rotate + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat3} out + */ +function rotate(out, a, rad) { + var a00 = a[0], + a01 = a[1], + a02 = a[2], + a10 = a[3], + a11 = a[4], + a12 = a[5], + a20 = a[6], + a21 = a[7], + a22 = a[8], + s = Math.sin(rad), + c = Math.cos(rad); + + out[0] = c * a00 + s * a10; + out[1] = c * a01 + s * a11; + out[2] = c * a02 + s * a12; + + out[3] = c * a10 - s * a00; + out[4] = c * a11 - s * a01; + out[5] = c * a12 - s * a02; + + out[6] = a20; + out[7] = a21; + out[8] = a22; + return out; +}; + +/** + * Scales the mat3 by the dimensions in the given vec2 + * + * @param {mat3} out the receiving matrix + * @param {mat3} a the matrix to rotate + * @param {vec2} v the vec2 to scale the matrix by + * @returns {mat3} out + **/ +function scale(out, a, v) { + var x = v[0], + y = v[1]; + + out[0] = x * a[0]; + out[1] = x * a[1]; + out[2] = x * a[2]; + + out[3] = y * a[3]; + out[4] = y * a[4]; + out[5] = y * a[5]; + + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + return out; +} + +/** + * Creates a matrix from a vector translation + * This is equivalent to (but much faster than): + * + * mat3.identity(dest); + * mat3.translate(dest, dest, vec); + * + * @param {mat3} out mat3 receiving operation result + * @param {vec2} v Translation vector + * @returns {mat3} out + */ +function fromTranslation(out, v) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 1; + out[5] = 0; + out[6] = v[0]; + out[7] = v[1]; + out[8] = 1; + return out; +} + +/** + * Creates a matrix from a given angle + * This is equivalent to (but much faster than): + * + * mat3.identity(dest); + * mat3.rotate(dest, dest, rad); + * + * @param {mat3} out mat3 receiving operation result + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat3} out + */ +function fromRotation(out, rad) { + var s = Math.sin(rad), + c = Math.cos(rad); + + out[0] = c; + out[1] = s; + out[2] = 0; + + out[3] = -s; + out[4] = c; + out[5] = 0; + + out[6] = 0; + out[7] = 0; + out[8] = 1; + return out; +} + +/** + * Creates a matrix from a vector scaling + * This is equivalent to (but much faster than): + * + * mat3.identity(dest); + * mat3.scale(dest, dest, vec); + * + * @param {mat3} out mat3 receiving operation result + * @param {vec2} v Scaling vector + * @returns {mat3} out + */ +function fromScaling(out, v) { + out[0] = v[0]; + out[1] = 0; + out[2] = 0; + + out[3] = 0; + out[4] = v[1]; + out[5] = 0; + + out[6] = 0; + out[7] = 0; + out[8] = 1; + return out; +} + +/** + * Copies the values from a mat2d into a mat3 + * + * @param {mat3} out the receiving matrix + * @param {mat2d} a the matrix to copy + * @returns {mat3} out + **/ +function fromMat2d(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = 0; + + out[3] = a[2]; + out[4] = a[3]; + out[5] = 0; + + out[6] = a[4]; + out[7] = a[5]; + out[8] = 1; + return out; +} + +/** +* Calculates a 3x3 matrix from the given quaternion +* +* @param {mat3} out mat3 receiving operation result +* @param {quat} q Quaternion to create matrix from +* +* @returns {mat3} out +*/ +function fromQuat(out, q) { + var x = q[0], + y = q[1], + z = q[2], + w = q[3]; + var x2 = x + x; + var y2 = y + y; + var z2 = z + z; + + var xx = x * x2; + var yx = y * x2; + var yy = y * y2; + var zx = z * x2; + var zy = z * y2; + var zz = z * z2; + var wx = w * x2; + var wy = w * y2; + var wz = w * z2; + + out[0] = 1 - yy - zz; + out[3] = yx - wz; + out[6] = zx + wy; + + out[1] = yx + wz; + out[4] = 1 - xx - zz; + out[7] = zy - wx; + + out[2] = zx - wy; + out[5] = zy + wx; + out[8] = 1 - xx - yy; + + return out; +} + +/** +* Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix +* +* @param {mat3} out mat3 receiving operation result +* @param {mat4} a Mat4 to derive the normal matrix from +* +* @returns {mat3} out +*/ +function normalFromMat4(out, a) { + var a00 = a[0], + a01 = a[1], + a02 = a[2], + a03 = a[3]; + var a10 = a[4], + a11 = a[5], + a12 = a[6], + a13 = a[7]; + var a20 = a[8], + a21 = a[9], + a22 = a[10], + a23 = a[11]; + var a30 = a[12], + a31 = a[13], + a32 = a[14], + a33 = a[15]; + + var b00 = a00 * a11 - a01 * a10; + var b01 = a00 * a12 - a02 * a10; + var b02 = a00 * a13 - a03 * a10; + var b03 = a01 * a12 - a02 * a11; + var b04 = a01 * a13 - a03 * a11; + var b05 = a02 * a13 - a03 * a12; + var b06 = a20 * a31 - a21 * a30; + var b07 = a20 * a32 - a22 * a30; + var b08 = a20 * a33 - a23 * a30; + var b09 = a21 * a32 - a22 * a31; + var b10 = a21 * a33 - a23 * a31; + var b11 = a22 * a33 - a23 * a32; + + // Calculate the determinant + var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + + if (!det) { + return null; + } + det = 1.0 / det; + + out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; + out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det; + out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det; + + out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det; + out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det; + out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det; + + out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det; + out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det; + out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det; + + return out; +} + +/** + * Generates a 2D projection matrix with the given bounds + * + * @param {mat3} out mat3 frustum matrix will be written into + * @param {number} width Width of your gl context + * @param {number} height Height of gl context + * @returns {mat3} out + */ +function projection(out, width, height) { + out[0] = 2 / width; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = -2 / height; + out[5] = 0; + out[6] = -1; + out[7] = 1; + out[8] = 1; + return out; +} + +/** + * Returns a string representation of a mat3 + * + * @param {mat3} a matrix to represent as a string + * @returns {String} string representation of the matrix + */ +function str(a) { + return 'mat3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ', ' + a[6] + ', ' + a[7] + ', ' + a[8] + ')'; +} + +/** + * Returns Frobenius norm of a mat3 + * + * @param {mat3} a the matrix to calculate Frobenius norm of + * @returns {Number} Frobenius norm + */ +function frob(a) { + return Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2) + Math.pow(a[2], 2) + Math.pow(a[3], 2) + Math.pow(a[4], 2) + Math.pow(a[5], 2) + Math.pow(a[6], 2) + Math.pow(a[7], 2) + Math.pow(a[8], 2)); +} + +/** + * Adds two mat3's + * + * @param {mat3} out the receiving matrix + * @param {mat3} a the first operand + * @param {mat3} b the second operand + * @returns {mat3} out + */ +function add(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + out[4] = a[4] + b[4]; + out[5] = a[5] + b[5]; + out[6] = a[6] + b[6]; + out[7] = a[7] + b[7]; + out[8] = a[8] + b[8]; + return out; +} + +/** + * Subtracts matrix b from matrix a + * + * @param {mat3} out the receiving matrix + * @param {mat3} a the first operand + * @param {mat3} b the second operand + * @returns {mat3} out + */ +function subtract(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + out[3] = a[3] - b[3]; + out[4] = a[4] - b[4]; + out[5] = a[5] - b[5]; + out[6] = a[6] - b[6]; + out[7] = a[7] - b[7]; + out[8] = a[8] - b[8]; + return out; +} + +/** + * Multiply each element of the matrix by a scalar. + * + * @param {mat3} out the receiving matrix + * @param {mat3} a the matrix to scale + * @param {Number} b amount to scale the matrix's elements by + * @returns {mat3} out + */ +function multiplyScalar(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + out[4] = a[4] * b; + out[5] = a[5] * b; + out[6] = a[6] * b; + out[7] = a[7] * b; + out[8] = a[8] * b; + return out; +} + +/** + * Adds two mat3's after multiplying each element of the second operand by a scalar value. + * + * @param {mat3} out the receiving vector + * @param {mat3} a the first operand + * @param {mat3} b the second operand + * @param {Number} scale the amount to scale b's elements by before adding + * @returns {mat3} out + */ +function multiplyScalarAndAdd(out, a, b, scale) { + out[0] = a[0] + b[0] * scale; + out[1] = a[1] + b[1] * scale; + out[2] = a[2] + b[2] * scale; + out[3] = a[3] + b[3] * scale; + out[4] = a[4] + b[4] * scale; + out[5] = a[5] + b[5] * scale; + out[6] = a[6] + b[6] * scale; + out[7] = a[7] + b[7] * scale; + out[8] = a[8] + b[8] * scale; + return out; +} + +/** + * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===) + * + * @param {mat3} a The first matrix. + * @param {mat3} b The second matrix. + * @returns {Boolean} True if the matrices are equal, false otherwise. + */ +function exactEquals(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8]; +} + +/** + * Returns whether or not the matrices have approximately the same elements in the same position. + * + * @param {mat3} a The first matrix. + * @param {mat3} b The second matrix. + * @returns {Boolean} True if the matrices are equal, false otherwise. + */ +function equals(a, b) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3], + a4 = a[4], + a5 = a[5], + a6 = a[6], + a7 = a[7], + a8 = a[8]; + var b0 = b[0], + b1 = b[1], + b2 = b[2], + b3 = b[3], + b4 = b[4], + b5 = b[5], + b6 = b[6], + b7 = b[7], + b8 = b[8]; + return Math.abs(a0 - b0) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a8), Math.abs(b8)); +} + +/** + * Alias for {@link mat3.multiply} + * @function + */ +var mul = multiply; + +/** + * Alias for {@link mat3.subtract} + * @function + */ +var sub = subtract; + +/***/ }), + +/***/ "./node_modules/gl-matrix/lib/gl-matrix/mat4.js": +/*!******************************************************!*\ + !*** ./node_modules/gl-matrix/lib/gl-matrix/mat4.js ***! + \******************************************************/ +/*! exports provided: create, clone, copy, fromValues, set, identity, transpose, invert, adjoint, determinant, multiply, translate, scale, rotate, rotateX, rotateY, rotateZ, fromTranslation, fromScaling, fromRotation, fromXRotation, fromYRotation, fromZRotation, fromRotationTranslation, fromQuat2, getTranslation, getScaling, getRotation, fromRotationTranslationScale, fromRotationTranslationScaleOrigin, fromQuat, frustum, perspective, perspectiveFromFieldOfView, ortho, lookAt, targetTo, str, frob, add, subtract, multiplyScalar, multiplyScalarAndAdd, exactEquals, equals, mul, sub */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "create", function() { return create; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clone", function() { return clone; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copy", function() { return copy; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromValues", function() { return fromValues; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "set", function() { return set; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "identity", function() { return identity; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transpose", function() { return transpose; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "invert", function() { return invert; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "adjoint", function() { return adjoint; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "determinant", function() { return determinant; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiply", function() { return multiply; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "translate", function() { return translate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scale", function() { return scale; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotate", function() { return rotate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateX", function() { return rotateX; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateY", function() { return rotateY; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateZ", function() { return rotateZ; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromTranslation", function() { return fromTranslation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromScaling", function() { return fromScaling; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromRotation", function() { return fromRotation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromXRotation", function() { return fromXRotation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromYRotation", function() { return fromYRotation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromZRotation", function() { return fromZRotation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromRotationTranslation", function() { return fromRotationTranslation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromQuat2", function() { return fromQuat2; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getTranslation", function() { return getTranslation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getScaling", function() { return getScaling; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getRotation", function() { return getRotation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromRotationTranslationScale", function() { return fromRotationTranslationScale; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromRotationTranslationScaleOrigin", function() { return fromRotationTranslationScaleOrigin; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromQuat", function() { return fromQuat; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "frustum", function() { return frustum; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "perspective", function() { return perspective; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "perspectiveFromFieldOfView", function() { return perspectiveFromFieldOfView; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ortho", function() { return ortho; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lookAt", function() { return lookAt; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "targetTo", function() { return targetTo; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "str", function() { return str; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "frob", function() { return frob; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "add", function() { return add; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "subtract", function() { return subtract; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiplyScalar", function() { return multiplyScalar; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiplyScalarAndAdd", function() { return multiplyScalarAndAdd; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "exactEquals", function() { return exactEquals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equals", function() { return equals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mul", function() { return mul; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sub", function() { return sub; }); +/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common.js */ "./node_modules/gl-matrix/lib/gl-matrix/common.js"); + + +/** + * 4x4 Matrix
Format: column-major, when typed out it looks like row-major
The matrices are being post multiplied. + * @module mat4 + */ + +/** + * Creates a new identity mat4 + * + * @returns {mat4} a new 4x4 matrix + */ +function create() { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](16); + if (_common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"] != Float32Array) { + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + } + out[0] = 1; + out[5] = 1; + out[10] = 1; + out[15] = 1; + return out; +} + +/** + * Creates a new mat4 initialized with values from an existing matrix + * + * @param {mat4} a matrix to clone + * @returns {mat4} a new 4x4 matrix + */ +function clone(a) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](16); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} + +/** + * Copy the values from one mat4 to another + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the source matrix + * @returns {mat4} out + */ +function copy(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} + +/** + * Create a new mat4 with the given values + * + * @param {Number} m00 Component in column 0, row 0 position (index 0) + * @param {Number} m01 Component in column 0, row 1 position (index 1) + * @param {Number} m02 Component in column 0, row 2 position (index 2) + * @param {Number} m03 Component in column 0, row 3 position (index 3) + * @param {Number} m10 Component in column 1, row 0 position (index 4) + * @param {Number} m11 Component in column 1, row 1 position (index 5) + * @param {Number} m12 Component in column 1, row 2 position (index 6) + * @param {Number} m13 Component in column 1, row 3 position (index 7) + * @param {Number} m20 Component in column 2, row 0 position (index 8) + * @param {Number} m21 Component in column 2, row 1 position (index 9) + * @param {Number} m22 Component in column 2, row 2 position (index 10) + * @param {Number} m23 Component in column 2, row 3 position (index 11) + * @param {Number} m30 Component in column 3, row 0 position (index 12) + * @param {Number} m31 Component in column 3, row 1 position (index 13) + * @param {Number} m32 Component in column 3, row 2 position (index 14) + * @param {Number} m33 Component in column 3, row 3 position (index 15) + * @returns {mat4} A new mat4 + */ +function fromValues(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](16); + out[0] = m00; + out[1] = m01; + out[2] = m02; + out[3] = m03; + out[4] = m10; + out[5] = m11; + out[6] = m12; + out[7] = m13; + out[8] = m20; + out[9] = m21; + out[10] = m22; + out[11] = m23; + out[12] = m30; + out[13] = m31; + out[14] = m32; + out[15] = m33; + return out; +} + +/** + * Set the components of a mat4 to the given values + * + * @param {mat4} out the receiving matrix + * @param {Number} m00 Component in column 0, row 0 position (index 0) + * @param {Number} m01 Component in column 0, row 1 position (index 1) + * @param {Number} m02 Component in column 0, row 2 position (index 2) + * @param {Number} m03 Component in column 0, row 3 position (index 3) + * @param {Number} m10 Component in column 1, row 0 position (index 4) + * @param {Number} m11 Component in column 1, row 1 position (index 5) + * @param {Number} m12 Component in column 1, row 2 position (index 6) + * @param {Number} m13 Component in column 1, row 3 position (index 7) + * @param {Number} m20 Component in column 2, row 0 position (index 8) + * @param {Number} m21 Component in column 2, row 1 position (index 9) + * @param {Number} m22 Component in column 2, row 2 position (index 10) + * @param {Number} m23 Component in column 2, row 3 position (index 11) + * @param {Number} m30 Component in column 3, row 0 position (index 12) + * @param {Number} m31 Component in column 3, row 1 position (index 13) + * @param {Number} m32 Component in column 3, row 2 position (index 14) + * @param {Number} m33 Component in column 3, row 3 position (index 15) + * @returns {mat4} out + */ +function set(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) { + out[0] = m00; + out[1] = m01; + out[2] = m02; + out[3] = m03; + out[4] = m10; + out[5] = m11; + out[6] = m12; + out[7] = m13; + out[8] = m20; + out[9] = m21; + out[10] = m22; + out[11] = m23; + out[12] = m30; + out[13] = m31; + out[14] = m32; + out[15] = m33; + return out; +} + +/** + * Set a mat4 to the identity matrix + * + * @param {mat4} out the receiving matrix + * @returns {mat4} out + */ +function identity(out) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} + +/** + * Transpose the values of a mat4 + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the source matrix + * @returns {mat4} out + */ +function transpose(out, a) { + // If we are transposing ourselves we can skip a few steps but have to cache some values + if (out === a) { + var a01 = a[1], + a02 = a[2], + a03 = a[3]; + var a12 = a[6], + a13 = a[7]; + var a23 = a[11]; + + out[1] = a[4]; + out[2] = a[8]; + out[3] = a[12]; + out[4] = a01; + out[6] = a[9]; + out[7] = a[13]; + out[8] = a02; + out[9] = a12; + out[11] = a[14]; + out[12] = a03; + out[13] = a13; + out[14] = a23; + } else { + out[0] = a[0]; + out[1] = a[4]; + out[2] = a[8]; + out[3] = a[12]; + out[4] = a[1]; + out[5] = a[5]; + out[6] = a[9]; + out[7] = a[13]; + out[8] = a[2]; + out[9] = a[6]; + out[10] = a[10]; + out[11] = a[14]; + out[12] = a[3]; + out[13] = a[7]; + out[14] = a[11]; + out[15] = a[15]; + } + + return out; +} + +/** + * Inverts a mat4 + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the source matrix + * @returns {mat4} out + */ +function invert(out, a) { + var a00 = a[0], + a01 = a[1], + a02 = a[2], + a03 = a[3]; + var a10 = a[4], + a11 = a[5], + a12 = a[6], + a13 = a[7]; + var a20 = a[8], + a21 = a[9], + a22 = a[10], + a23 = a[11]; + var a30 = a[12], + a31 = a[13], + a32 = a[14], + a33 = a[15]; + + var b00 = a00 * a11 - a01 * a10; + var b01 = a00 * a12 - a02 * a10; + var b02 = a00 * a13 - a03 * a10; + var b03 = a01 * a12 - a02 * a11; + var b04 = a01 * a13 - a03 * a11; + var b05 = a02 * a13 - a03 * a12; + var b06 = a20 * a31 - a21 * a30; + var b07 = a20 * a32 - a22 * a30; + var b08 = a20 * a33 - a23 * a30; + var b09 = a21 * a32 - a22 * a31; + var b10 = a21 * a33 - a23 * a31; + var b11 = a22 * a33 - a23 * a32; + + // Calculate the determinant + var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; + + if (!det) { + return null; + } + det = 1.0 / det; + + out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det; + out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det; + out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det; + out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det; + out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det; + out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det; + out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det; + out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det; + out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det; + out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det; + out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det; + out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det; + out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det; + out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det; + out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det; + out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det; + + return out; +} + +/** + * Calculates the adjugate of a mat4 + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the source matrix + * @returns {mat4} out + */ +function adjoint(out, a) { + var a00 = a[0], + a01 = a[1], + a02 = a[2], + a03 = a[3]; + var a10 = a[4], + a11 = a[5], + a12 = a[6], + a13 = a[7]; + var a20 = a[8], + a21 = a[9], + a22 = a[10], + a23 = a[11]; + var a30 = a[12], + a31 = a[13], + a32 = a[14], + a33 = a[15]; + + out[0] = a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22); + out[1] = -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22)); + out[2] = a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12); + out[3] = -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12)); + out[4] = -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22)); + out[5] = a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22); + out[6] = -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12)); + out[7] = a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12); + out[8] = a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21); + out[9] = -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21)); + out[10] = a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11); + out[11] = -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11)); + out[12] = -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21)); + out[13] = a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21); + out[14] = -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11)); + out[15] = a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11); + return out; +} + +/** + * Calculates the determinant of a mat4 + * + * @param {mat4} a the source matrix + * @returns {Number} determinant of a + */ +function determinant(a) { + var a00 = a[0], + a01 = a[1], + a02 = a[2], + a03 = a[3]; + var a10 = a[4], + a11 = a[5], + a12 = a[6], + a13 = a[7]; + var a20 = a[8], + a21 = a[9], + a22 = a[10], + a23 = a[11]; + var a30 = a[12], + a31 = a[13], + a32 = a[14], + a33 = a[15]; + + var b00 = a00 * a11 - a01 * a10; + var b01 = a00 * a12 - a02 * a10; + var b02 = a00 * a13 - a03 * a10; + var b03 = a01 * a12 - a02 * a11; + var b04 = a01 * a13 - a03 * a11; + var b05 = a02 * a13 - a03 * a12; + var b06 = a20 * a31 - a21 * a30; + var b07 = a20 * a32 - a22 * a30; + var b08 = a20 * a33 - a23 * a30; + var b09 = a21 * a32 - a22 * a31; + var b10 = a21 * a33 - a23 * a31; + var b11 = a22 * a33 - a23 * a32; + + // Calculate the determinant + return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06; +} + +/** + * Multiplies two mat4s + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the first operand + * @param {mat4} b the second operand + * @returns {mat4} out + */ +function multiply(out, a, b) { + var a00 = a[0], + a01 = a[1], + a02 = a[2], + a03 = a[3]; + var a10 = a[4], + a11 = a[5], + a12 = a[6], + a13 = a[7]; + var a20 = a[8], + a21 = a[9], + a22 = a[10], + a23 = a[11]; + var a30 = a[12], + a31 = a[13], + a32 = a[14], + a33 = a[15]; + + // Cache only the current line of the second matrix + var b0 = b[0], + b1 = b[1], + b2 = b[2], + b3 = b[3]; + out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + + b0 = b[4];b1 = b[5];b2 = b[6];b3 = b[7]; + out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + + b0 = b[8];b1 = b[9];b2 = b[10];b3 = b[11]; + out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + + b0 = b[12];b1 = b[13];b2 = b[14];b3 = b[15]; + out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30; + out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31; + out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32; + out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33; + return out; +} + +/** + * Translate a mat4 by the given vector + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the matrix to translate + * @param {vec3} v vector to translate by + * @returns {mat4} out + */ +function translate(out, a, v) { + var x = v[0], + y = v[1], + z = v[2]; + var a00 = void 0, + a01 = void 0, + a02 = void 0, + a03 = void 0; + var a10 = void 0, + a11 = void 0, + a12 = void 0, + a13 = void 0; + var a20 = void 0, + a21 = void 0, + a22 = void 0, + a23 = void 0; + + if (a === out) { + out[12] = a[0] * x + a[4] * y + a[8] * z + a[12]; + out[13] = a[1] * x + a[5] * y + a[9] * z + a[13]; + out[14] = a[2] * x + a[6] * y + a[10] * z + a[14]; + out[15] = a[3] * x + a[7] * y + a[11] * z + a[15]; + } else { + a00 = a[0];a01 = a[1];a02 = a[2];a03 = a[3]; + a10 = a[4];a11 = a[5];a12 = a[6];a13 = a[7]; + a20 = a[8];a21 = a[9];a22 = a[10];a23 = a[11]; + + out[0] = a00;out[1] = a01;out[2] = a02;out[3] = a03; + out[4] = a10;out[5] = a11;out[6] = a12;out[7] = a13; + out[8] = a20;out[9] = a21;out[10] = a22;out[11] = a23; + + out[12] = a00 * x + a10 * y + a20 * z + a[12]; + out[13] = a01 * x + a11 * y + a21 * z + a[13]; + out[14] = a02 * x + a12 * y + a22 * z + a[14]; + out[15] = a03 * x + a13 * y + a23 * z + a[15]; + } + + return out; +} + +/** + * Scales the mat4 by the dimensions in the given vec3 not using vectorization + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the matrix to scale + * @param {vec3} v the vec3 to scale the matrix by + * @returns {mat4} out + **/ +function scale(out, a, v) { + var x = v[0], + y = v[1], + z = v[2]; + + out[0] = a[0] * x; + out[1] = a[1] * x; + out[2] = a[2] * x; + out[3] = a[3] * x; + out[4] = a[4] * y; + out[5] = a[5] * y; + out[6] = a[6] * y; + out[7] = a[7] * y; + out[8] = a[8] * z; + out[9] = a[9] * z; + out[10] = a[10] * z; + out[11] = a[11] * z; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + return out; +} + +/** + * Rotates a mat4 by the given angle around the given axis + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the matrix to rotate + * @param {Number} rad the angle to rotate the matrix by + * @param {vec3} axis the axis to rotate around + * @returns {mat4} out + */ +function rotate(out, a, rad, axis) { + var x = axis[0], + y = axis[1], + z = axis[2]; + var len = Math.sqrt(x * x + y * y + z * z); + var s = void 0, + c = void 0, + t = void 0; + var a00 = void 0, + a01 = void 0, + a02 = void 0, + a03 = void 0; + var a10 = void 0, + a11 = void 0, + a12 = void 0, + a13 = void 0; + var a20 = void 0, + a21 = void 0, + a22 = void 0, + a23 = void 0; + var b00 = void 0, + b01 = void 0, + b02 = void 0; + var b10 = void 0, + b11 = void 0, + b12 = void 0; + var b20 = void 0, + b21 = void 0, + b22 = void 0; + + if (len < _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"]) { + return null; + } + + len = 1 / len; + x *= len; + y *= len; + z *= len; + + s = Math.sin(rad); + c = Math.cos(rad); + t = 1 - c; + + a00 = a[0];a01 = a[1];a02 = a[2];a03 = a[3]; + a10 = a[4];a11 = a[5];a12 = a[6];a13 = a[7]; + a20 = a[8];a21 = a[9];a22 = a[10];a23 = a[11]; + + // Construct the elements of the rotation matrix + b00 = x * x * t + c;b01 = y * x * t + z * s;b02 = z * x * t - y * s; + b10 = x * y * t - z * s;b11 = y * y * t + c;b12 = z * y * t + x * s; + b20 = x * z * t + y * s;b21 = y * z * t - x * s;b22 = z * z * t + c; + + // Perform rotation-specific matrix multiplication + out[0] = a00 * b00 + a10 * b01 + a20 * b02; + out[1] = a01 * b00 + a11 * b01 + a21 * b02; + out[2] = a02 * b00 + a12 * b01 + a22 * b02; + out[3] = a03 * b00 + a13 * b01 + a23 * b02; + out[4] = a00 * b10 + a10 * b11 + a20 * b12; + out[5] = a01 * b10 + a11 * b11 + a21 * b12; + out[6] = a02 * b10 + a12 * b11 + a22 * b12; + out[7] = a03 * b10 + a13 * b11 + a23 * b12; + out[8] = a00 * b20 + a10 * b21 + a20 * b22; + out[9] = a01 * b20 + a11 * b21 + a21 * b22; + out[10] = a02 * b20 + a12 * b21 + a22 * b22; + out[11] = a03 * b20 + a13 * b21 + a23 * b22; + + if (a !== out) { + // If the source and destination differ, copy the unchanged last row + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + return out; +} + +/** + * Rotates a matrix by the given angle around the X axis + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the matrix to rotate + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat4} out + */ +function rotateX(out, a, rad) { + var s = Math.sin(rad); + var c = Math.cos(rad); + var a10 = a[4]; + var a11 = a[5]; + var a12 = a[6]; + var a13 = a[7]; + var a20 = a[8]; + var a21 = a[9]; + var a22 = a[10]; + var a23 = a[11]; + + if (a !== out) { + // If the source and destination differ, copy the unchanged rows + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + + // Perform axis-specific matrix multiplication + out[4] = a10 * c + a20 * s; + out[5] = a11 * c + a21 * s; + out[6] = a12 * c + a22 * s; + out[7] = a13 * c + a23 * s; + out[8] = a20 * c - a10 * s; + out[9] = a21 * c - a11 * s; + out[10] = a22 * c - a12 * s; + out[11] = a23 * c - a13 * s; + return out; +} + +/** + * Rotates a matrix by the given angle around the Y axis + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the matrix to rotate + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat4} out + */ +function rotateY(out, a, rad) { + var s = Math.sin(rad); + var c = Math.cos(rad); + var a00 = a[0]; + var a01 = a[1]; + var a02 = a[2]; + var a03 = a[3]; + var a20 = a[8]; + var a21 = a[9]; + var a22 = a[10]; + var a23 = a[11]; + + if (a !== out) { + // If the source and destination differ, copy the unchanged rows + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + + // Perform axis-specific matrix multiplication + out[0] = a00 * c - a20 * s; + out[1] = a01 * c - a21 * s; + out[2] = a02 * c - a22 * s; + out[3] = a03 * c - a23 * s; + out[8] = a00 * s + a20 * c; + out[9] = a01 * s + a21 * c; + out[10] = a02 * s + a22 * c; + out[11] = a03 * s + a23 * c; + return out; +} + +/** + * Rotates a matrix by the given angle around the Z axis + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the matrix to rotate + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat4} out + */ +function rotateZ(out, a, rad) { + var s = Math.sin(rad); + var c = Math.cos(rad); + var a00 = a[0]; + var a01 = a[1]; + var a02 = a[2]; + var a03 = a[3]; + var a10 = a[4]; + var a11 = a[5]; + var a12 = a[6]; + var a13 = a[7]; + + if (a !== out) { + // If the source and destination differ, copy the unchanged last row + out[8] = a[8]; + out[9] = a[9]; + out[10] = a[10]; + out[11] = a[11]; + out[12] = a[12]; + out[13] = a[13]; + out[14] = a[14]; + out[15] = a[15]; + } + + // Perform axis-specific matrix multiplication + out[0] = a00 * c + a10 * s; + out[1] = a01 * c + a11 * s; + out[2] = a02 * c + a12 * s; + out[3] = a03 * c + a13 * s; + out[4] = a10 * c - a00 * s; + out[5] = a11 * c - a01 * s; + out[6] = a12 * c - a02 * s; + out[7] = a13 * c - a03 * s; + return out; +} + +/** + * Creates a matrix from a vector translation + * This is equivalent to (but much faster than): + * + * mat4.identity(dest); + * mat4.translate(dest, dest, vec); + * + * @param {mat4} out mat4 receiving operation result + * @param {vec3} v Translation vector + * @returns {mat4} out + */ +function fromTranslation(out, v) { + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + return out; +} + +/** + * Creates a matrix from a vector scaling + * This is equivalent to (but much faster than): + * + * mat4.identity(dest); + * mat4.scale(dest, dest, vec); + * + * @param {mat4} out mat4 receiving operation result + * @param {vec3} v Scaling vector + * @returns {mat4} out + */ +function fromScaling(out, v) { + out[0] = v[0]; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = v[1]; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = v[2]; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} + +/** + * Creates a matrix from a given angle around a given axis + * This is equivalent to (but much faster than): + * + * mat4.identity(dest); + * mat4.rotate(dest, dest, rad, axis); + * + * @param {mat4} out mat4 receiving operation result + * @param {Number} rad the angle to rotate the matrix by + * @param {vec3} axis the axis to rotate around + * @returns {mat4} out + */ +function fromRotation(out, rad, axis) { + var x = axis[0], + y = axis[1], + z = axis[2]; + var len = Math.sqrt(x * x + y * y + z * z); + var s = void 0, + c = void 0, + t = void 0; + + if (len < _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"]) { + return null; + } + + len = 1 / len; + x *= len; + y *= len; + z *= len; + + s = Math.sin(rad); + c = Math.cos(rad); + t = 1 - c; + + // Perform rotation-specific matrix multiplication + out[0] = x * x * t + c; + out[1] = y * x * t + z * s; + out[2] = z * x * t - y * s; + out[3] = 0; + out[4] = x * y * t - z * s; + out[5] = y * y * t + c; + out[6] = z * y * t + x * s; + out[7] = 0; + out[8] = x * z * t + y * s; + out[9] = y * z * t - x * s; + out[10] = z * z * t + c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} + +/** + * Creates a matrix from the given angle around the X axis + * This is equivalent to (but much faster than): + * + * mat4.identity(dest); + * mat4.rotateX(dest, dest, rad); + * + * @param {mat4} out mat4 receiving operation result + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat4} out + */ +function fromXRotation(out, rad) { + var s = Math.sin(rad); + var c = Math.cos(rad); + + // Perform axis-specific matrix multiplication + out[0] = 1; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = c; + out[6] = s; + out[7] = 0; + out[8] = 0; + out[9] = -s; + out[10] = c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} + +/** + * Creates a matrix from the given angle around the Y axis + * This is equivalent to (but much faster than): + * + * mat4.identity(dest); + * mat4.rotateY(dest, dest, rad); + * + * @param {mat4} out mat4 receiving operation result + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat4} out + */ +function fromYRotation(out, rad) { + var s = Math.sin(rad); + var c = Math.cos(rad); + + // Perform axis-specific matrix multiplication + out[0] = c; + out[1] = 0; + out[2] = -s; + out[3] = 0; + out[4] = 0; + out[5] = 1; + out[6] = 0; + out[7] = 0; + out[8] = s; + out[9] = 0; + out[10] = c; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} + +/** + * Creates a matrix from the given angle around the Z axis + * This is equivalent to (but much faster than): + * + * mat4.identity(dest); + * mat4.rotateZ(dest, dest, rad); + * + * @param {mat4} out mat4 receiving operation result + * @param {Number} rad the angle to rotate the matrix by + * @returns {mat4} out + */ +function fromZRotation(out, rad) { + var s = Math.sin(rad); + var c = Math.cos(rad); + + // Perform axis-specific matrix multiplication + out[0] = c; + out[1] = s; + out[2] = 0; + out[3] = 0; + out[4] = -s; + out[5] = c; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 1; + out[11] = 0; + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + return out; +} + +/** + * Creates a matrix from a quaternion rotation and vector translation + * This is equivalent to (but much faster than): + * + * mat4.identity(dest); + * mat4.translate(dest, vec); + * let quatMat = mat4.create(); + * quat4.toMat4(quat, quatMat); + * mat4.multiply(dest, quatMat); + * + * @param {mat4} out mat4 receiving operation result + * @param {quat4} q Rotation quaternion + * @param {vec3} v Translation vector + * @returns {mat4} out + */ +function fromRotationTranslation(out, q, v) { + // Quaternion math + var x = q[0], + y = q[1], + z = q[2], + w = q[3]; + var x2 = x + x; + var y2 = y + y; + var z2 = z + z; + + var xx = x * x2; + var xy = x * y2; + var xz = x * z2; + var yy = y * y2; + var yz = y * z2; + var zz = z * z2; + var wx = w * x2; + var wy = w * y2; + var wz = w * z2; + + out[0] = 1 - (yy + zz); + out[1] = xy + wz; + out[2] = xz - wy; + out[3] = 0; + out[4] = xy - wz; + out[5] = 1 - (xx + zz); + out[6] = yz + wx; + out[7] = 0; + out[8] = xz + wy; + out[9] = yz - wx; + out[10] = 1 - (xx + yy); + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + + return out; +} + +/** + * Creates a new mat4 from a dual quat. + * + * @param {mat4} out Matrix + * @param {quat2} a Dual Quaternion + * @returns {mat4} mat4 receiving operation result + */ +function fromQuat2(out, a) { + var translation = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](3); + var bx = -a[0], + by = -a[1], + bz = -a[2], + bw = a[3], + ax = a[4], + ay = a[5], + az = a[6], + aw = a[7]; + + var magnitude = bx * bx + by * by + bz * bz + bw * bw; + //Only scale if it makes sense + if (magnitude > 0) { + translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude; + translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude; + translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude; + } else { + translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2; + translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2; + translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2; + } + fromRotationTranslation(out, a, translation); + return out; +} + +/** + * Returns the translation vector component of a transformation + * matrix. If a matrix is built with fromRotationTranslation, + * the returned vector will be the same as the translation vector + * originally supplied. + * @param {vec3} out Vector to receive translation component + * @param {mat4} mat Matrix to be decomposed (input) + * @return {vec3} out + */ +function getTranslation(out, mat) { + out[0] = mat[12]; + out[1] = mat[13]; + out[2] = mat[14]; + + return out; +} + +/** + * Returns the scaling factor component of a transformation + * matrix. If a matrix is built with fromRotationTranslationScale + * with a normalized Quaternion paramter, the returned vector will be + * the same as the scaling vector + * originally supplied. + * @param {vec3} out Vector to receive scaling factor component + * @param {mat4} mat Matrix to be decomposed (input) + * @return {vec3} out + */ +function getScaling(out, mat) { + var m11 = mat[0]; + var m12 = mat[1]; + var m13 = mat[2]; + var m21 = mat[4]; + var m22 = mat[5]; + var m23 = mat[6]; + var m31 = mat[8]; + var m32 = mat[9]; + var m33 = mat[10]; + + out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13); + out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23); + out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33); + + return out; +} + +/** + * Returns a quaternion representing the rotational component + * of a transformation matrix. If a matrix is built with + * fromRotationTranslation, the returned quaternion will be the + * same as the quaternion originally supplied. + * @param {quat} out Quaternion to receive the rotation component + * @param {mat4} mat Matrix to be decomposed (input) + * @return {quat} out + */ +function getRotation(out, mat) { + // Algorithm taken from http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm + var trace = mat[0] + mat[5] + mat[10]; + var S = 0; + + if (trace > 0) { + S = Math.sqrt(trace + 1.0) * 2; + out[3] = 0.25 * S; + out[0] = (mat[6] - mat[9]) / S; + out[1] = (mat[8] - mat[2]) / S; + out[2] = (mat[1] - mat[4]) / S; + } else if (mat[0] > mat[5] && mat[0] > mat[10]) { + S = Math.sqrt(1.0 + mat[0] - mat[5] - mat[10]) * 2; + out[3] = (mat[6] - mat[9]) / S; + out[0] = 0.25 * S; + out[1] = (mat[1] + mat[4]) / S; + out[2] = (mat[8] + mat[2]) / S; + } else if (mat[5] > mat[10]) { + S = Math.sqrt(1.0 + mat[5] - mat[0] - mat[10]) * 2; + out[3] = (mat[8] - mat[2]) / S; + out[0] = (mat[1] + mat[4]) / S; + out[1] = 0.25 * S; + out[2] = (mat[6] + mat[9]) / S; + } else { + S = Math.sqrt(1.0 + mat[10] - mat[0] - mat[5]) * 2; + out[3] = (mat[1] - mat[4]) / S; + out[0] = (mat[8] + mat[2]) / S; + out[1] = (mat[6] + mat[9]) / S; + out[2] = 0.25 * S; + } + + return out; +} + +/** + * Creates a matrix from a quaternion rotation, vector translation and vector scale + * This is equivalent to (but much faster than): + * + * mat4.identity(dest); + * mat4.translate(dest, vec); + * let quatMat = mat4.create(); + * quat4.toMat4(quat, quatMat); + * mat4.multiply(dest, quatMat); + * mat4.scale(dest, scale) + * + * @param {mat4} out mat4 receiving operation result + * @param {quat4} q Rotation quaternion + * @param {vec3} v Translation vector + * @param {vec3} s Scaling vector + * @returns {mat4} out + */ +function fromRotationTranslationScale(out, q, v, s) { + // Quaternion math + var x = q[0], + y = q[1], + z = q[2], + w = q[3]; + var x2 = x + x; + var y2 = y + y; + var z2 = z + z; + + var xx = x * x2; + var xy = x * y2; + var xz = x * z2; + var yy = y * y2; + var yz = y * z2; + var zz = z * z2; + var wx = w * x2; + var wy = w * y2; + var wz = w * z2; + var sx = s[0]; + var sy = s[1]; + var sz = s[2]; + + out[0] = (1 - (yy + zz)) * sx; + out[1] = (xy + wz) * sx; + out[2] = (xz - wy) * sx; + out[3] = 0; + out[4] = (xy - wz) * sy; + out[5] = (1 - (xx + zz)) * sy; + out[6] = (yz + wx) * sy; + out[7] = 0; + out[8] = (xz + wy) * sz; + out[9] = (yz - wx) * sz; + out[10] = (1 - (xx + yy)) * sz; + out[11] = 0; + out[12] = v[0]; + out[13] = v[1]; + out[14] = v[2]; + out[15] = 1; + + return out; +} + +/** + * Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin + * This is equivalent to (but much faster than): + * + * mat4.identity(dest); + * mat4.translate(dest, vec); + * mat4.translate(dest, origin); + * let quatMat = mat4.create(); + * quat4.toMat4(quat, quatMat); + * mat4.multiply(dest, quatMat); + * mat4.scale(dest, scale) + * mat4.translate(dest, negativeOrigin); + * + * @param {mat4} out mat4 receiving operation result + * @param {quat4} q Rotation quaternion + * @param {vec3} v Translation vector + * @param {vec3} s Scaling vector + * @param {vec3} o The origin vector around which to scale and rotate + * @returns {mat4} out + */ +function fromRotationTranslationScaleOrigin(out, q, v, s, o) { + // Quaternion math + var x = q[0], + y = q[1], + z = q[2], + w = q[3]; + var x2 = x + x; + var y2 = y + y; + var z2 = z + z; + + var xx = x * x2; + var xy = x * y2; + var xz = x * z2; + var yy = y * y2; + var yz = y * z2; + var zz = z * z2; + var wx = w * x2; + var wy = w * y2; + var wz = w * z2; + + var sx = s[0]; + var sy = s[1]; + var sz = s[2]; + + var ox = o[0]; + var oy = o[1]; + var oz = o[2]; + + var out0 = (1 - (yy + zz)) * sx; + var out1 = (xy + wz) * sx; + var out2 = (xz - wy) * sx; + var out4 = (xy - wz) * sy; + var out5 = (1 - (xx + zz)) * sy; + var out6 = (yz + wx) * sy; + var out8 = (xz + wy) * sz; + var out9 = (yz - wx) * sz; + var out10 = (1 - (xx + yy)) * sz; + + out[0] = out0; + out[1] = out1; + out[2] = out2; + out[3] = 0; + out[4] = out4; + out[5] = out5; + out[6] = out6; + out[7] = 0; + out[8] = out8; + out[9] = out9; + out[10] = out10; + out[11] = 0; + out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz); + out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz); + out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz); + out[15] = 1; + + return out; +} + +/** + * Calculates a 4x4 matrix from the given quaternion + * + * @param {mat4} out mat4 receiving operation result + * @param {quat} q Quaternion to create matrix from + * + * @returns {mat4} out + */ +function fromQuat(out, q) { + var x = q[0], + y = q[1], + z = q[2], + w = q[3]; + var x2 = x + x; + var y2 = y + y; + var z2 = z + z; + + var xx = x * x2; + var yx = y * x2; + var yy = y * y2; + var zx = z * x2; + var zy = z * y2; + var zz = z * z2; + var wx = w * x2; + var wy = w * y2; + var wz = w * z2; + + out[0] = 1 - yy - zz; + out[1] = yx + wz; + out[2] = zx - wy; + out[3] = 0; + + out[4] = yx - wz; + out[5] = 1 - xx - zz; + out[6] = zy + wx; + out[7] = 0; + + out[8] = zx + wy; + out[9] = zy - wx; + out[10] = 1 - xx - yy; + out[11] = 0; + + out[12] = 0; + out[13] = 0; + out[14] = 0; + out[15] = 1; + + return out; +} + +/** + * Generates a frustum matrix with the given bounds + * + * @param {mat4} out mat4 frustum matrix will be written into + * @param {Number} left Left bound of the frustum + * @param {Number} right Right bound of the frustum + * @param {Number} bottom Bottom bound of the frustum + * @param {Number} top Top bound of the frustum + * @param {Number} near Near bound of the frustum + * @param {Number} far Far bound of the frustum + * @returns {mat4} out + */ +function frustum(out, left, right, bottom, top, near, far) { + var rl = 1 / (right - left); + var tb = 1 / (top - bottom); + var nf = 1 / (near - far); + out[0] = near * 2 * rl; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = near * 2 * tb; + out[6] = 0; + out[7] = 0; + out[8] = (right + left) * rl; + out[9] = (top + bottom) * tb; + out[10] = (far + near) * nf; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[14] = far * near * 2 * nf; + out[15] = 0; + return out; +} + +/** + * Generates a perspective projection matrix with the given bounds. + * Passing null/undefined/no value for far will generate infinite projection matrix. + * + * @param {mat4} out mat4 frustum matrix will be written into + * @param {number} fovy Vertical field of view in radians + * @param {number} aspect Aspect ratio. typically viewport width/height + * @param {number} near Near bound of the frustum + * @param {number} far Far bound of the frustum, can be null or Infinity + * @returns {mat4} out + */ +function perspective(out, fovy, aspect, near, far) { + var f = 1.0 / Math.tan(fovy / 2), + nf = void 0; + out[0] = f / aspect; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = f; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[11] = -1; + out[12] = 0; + out[13] = 0; + out[15] = 0; + if (far != null && far !== Infinity) { + nf = 1 / (near - far); + out[10] = (far + near) * nf; + out[14] = 2 * far * near * nf; + } else { + out[10] = -1; + out[14] = -2 * near; + } + return out; +} + +/** + * Generates a perspective projection matrix with the given field of view. + * This is primarily useful for generating projection matrices to be used + * with the still experiemental WebVR API. + * + * @param {mat4} out mat4 frustum matrix will be written into + * @param {Object} fov Object containing the following values: upDegrees, downDegrees, leftDegrees, rightDegrees + * @param {number} near Near bound of the frustum + * @param {number} far Far bound of the frustum + * @returns {mat4} out + */ +function perspectiveFromFieldOfView(out, fov, near, far) { + var upTan = Math.tan(fov.upDegrees * Math.PI / 180.0); + var downTan = Math.tan(fov.downDegrees * Math.PI / 180.0); + var leftTan = Math.tan(fov.leftDegrees * Math.PI / 180.0); + var rightTan = Math.tan(fov.rightDegrees * Math.PI / 180.0); + var xScale = 2.0 / (leftTan + rightTan); + var yScale = 2.0 / (upTan + downTan); + + out[0] = xScale; + out[1] = 0.0; + out[2] = 0.0; + out[3] = 0.0; + out[4] = 0.0; + out[5] = yScale; + out[6] = 0.0; + out[7] = 0.0; + out[8] = -((leftTan - rightTan) * xScale * 0.5); + out[9] = (upTan - downTan) * yScale * 0.5; + out[10] = far / (near - far); + out[11] = -1.0; + out[12] = 0.0; + out[13] = 0.0; + out[14] = far * near / (near - far); + out[15] = 0.0; + return out; +} + +/** + * Generates a orthogonal projection matrix with the given bounds + * + * @param {mat4} out mat4 frustum matrix will be written into + * @param {number} left Left bound of the frustum + * @param {number} right Right bound of the frustum + * @param {number} bottom Bottom bound of the frustum + * @param {number} top Top bound of the frustum + * @param {number} near Near bound of the frustum + * @param {number} far Far bound of the frustum + * @returns {mat4} out + */ +function ortho(out, left, right, bottom, top, near, far) { + var lr = 1 / (left - right); + var bt = 1 / (bottom - top); + var nf = 1 / (near - far); + out[0] = -2 * lr; + out[1] = 0; + out[2] = 0; + out[3] = 0; + out[4] = 0; + out[5] = -2 * bt; + out[6] = 0; + out[7] = 0; + out[8] = 0; + out[9] = 0; + out[10] = 2 * nf; + out[11] = 0; + out[12] = (left + right) * lr; + out[13] = (top + bottom) * bt; + out[14] = (far + near) * nf; + out[15] = 1; + return out; +} + +/** + * Generates a look-at matrix with the given eye position, focal point, and up axis. + * If you want a matrix that actually makes an object look at another object, you should use targetTo instead. + * + * @param {mat4} out mat4 frustum matrix will be written into + * @param {vec3} eye Position of the viewer + * @param {vec3} center Point the viewer is looking at + * @param {vec3} up vec3 pointing up + * @returns {mat4} out + */ +function lookAt(out, eye, center, up) { + var x0 = void 0, + x1 = void 0, + x2 = void 0, + y0 = void 0, + y1 = void 0, + y2 = void 0, + z0 = void 0, + z1 = void 0, + z2 = void 0, + len = void 0; + var eyex = eye[0]; + var eyey = eye[1]; + var eyez = eye[2]; + var upx = up[0]; + var upy = up[1]; + var upz = up[2]; + var centerx = center[0]; + var centery = center[1]; + var centerz = center[2]; + + if (Math.abs(eyex - centerx) < _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] && Math.abs(eyey - centery) < _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] && Math.abs(eyez - centerz) < _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"]) { + return identity(out); + } + + z0 = eyex - centerx; + z1 = eyey - centery; + z2 = eyez - centerz; + + len = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2); + z0 *= len; + z1 *= len; + z2 *= len; + + x0 = upy * z2 - upz * z1; + x1 = upz * z0 - upx * z2; + x2 = upx * z1 - upy * z0; + len = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2); + if (!len) { + x0 = 0; + x1 = 0; + x2 = 0; + } else { + len = 1 / len; + x0 *= len; + x1 *= len; + x2 *= len; + } + + y0 = z1 * x2 - z2 * x1; + y1 = z2 * x0 - z0 * x2; + y2 = z0 * x1 - z1 * x0; + + len = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2); + if (!len) { + y0 = 0; + y1 = 0; + y2 = 0; + } else { + len = 1 / len; + y0 *= len; + y1 *= len; + y2 *= len; + } + + out[0] = x0; + out[1] = y0; + out[2] = z0; + out[3] = 0; + out[4] = x1; + out[5] = y1; + out[6] = z1; + out[7] = 0; + out[8] = x2; + out[9] = y2; + out[10] = z2; + out[11] = 0; + out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez); + out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez); + out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez); + out[15] = 1; + + return out; +} + +/** + * Generates a matrix that makes something look at something else. + * + * @param {mat4} out mat4 frustum matrix will be written into + * @param {vec3} eye Position of the viewer + * @param {vec3} center Point the viewer is looking at + * @param {vec3} up vec3 pointing up + * @returns {mat4} out + */ +function targetTo(out, eye, target, up) { + var eyex = eye[0], + eyey = eye[1], + eyez = eye[2], + upx = up[0], + upy = up[1], + upz = up[2]; + + var z0 = eyex - target[0], + z1 = eyey - target[1], + z2 = eyez - target[2]; + + var len = z0 * z0 + z1 * z1 + z2 * z2; + if (len > 0) { + len = 1 / Math.sqrt(len); + z0 *= len; + z1 *= len; + z2 *= len; + } + + var x0 = upy * z2 - upz * z1, + x1 = upz * z0 - upx * z2, + x2 = upx * z1 - upy * z0; + + len = x0 * x0 + x1 * x1 + x2 * x2; + if (len > 0) { + len = 1 / Math.sqrt(len); + x0 *= len; + x1 *= len; + x2 *= len; + } + + out[0] = x0; + out[1] = x1; + out[2] = x2; + out[3] = 0; + out[4] = z1 * x2 - z2 * x1; + out[5] = z2 * x0 - z0 * x2; + out[6] = z0 * x1 - z1 * x0; + out[7] = 0; + out[8] = z0; + out[9] = z1; + out[10] = z2; + out[11] = 0; + out[12] = eyex; + out[13] = eyey; + out[14] = eyez; + out[15] = 1; + return out; +}; + +/** + * Returns a string representation of a mat4 + * + * @param {mat4} a matrix to represent as a string + * @returns {String} string representation of the matrix + */ +function str(a) { + return 'mat4(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ', ' + a[6] + ', ' + a[7] + ', ' + a[8] + ', ' + a[9] + ', ' + a[10] + ', ' + a[11] + ', ' + a[12] + ', ' + a[13] + ', ' + a[14] + ', ' + a[15] + ')'; +} + +/** + * Returns Frobenius norm of a mat4 + * + * @param {mat4} a the matrix to calculate Frobenius norm of + * @returns {Number} Frobenius norm + */ +function frob(a) { + return Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2) + Math.pow(a[2], 2) + Math.pow(a[3], 2) + Math.pow(a[4], 2) + Math.pow(a[5], 2) + Math.pow(a[6], 2) + Math.pow(a[7], 2) + Math.pow(a[8], 2) + Math.pow(a[9], 2) + Math.pow(a[10], 2) + Math.pow(a[11], 2) + Math.pow(a[12], 2) + Math.pow(a[13], 2) + Math.pow(a[14], 2) + Math.pow(a[15], 2)); +} + +/** + * Adds two mat4's + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the first operand + * @param {mat4} b the second operand + * @returns {mat4} out + */ +function add(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + out[4] = a[4] + b[4]; + out[5] = a[5] + b[5]; + out[6] = a[6] + b[6]; + out[7] = a[7] + b[7]; + out[8] = a[8] + b[8]; + out[9] = a[9] + b[9]; + out[10] = a[10] + b[10]; + out[11] = a[11] + b[11]; + out[12] = a[12] + b[12]; + out[13] = a[13] + b[13]; + out[14] = a[14] + b[14]; + out[15] = a[15] + b[15]; + return out; +} + +/** + * Subtracts matrix b from matrix a + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the first operand + * @param {mat4} b the second operand + * @returns {mat4} out + */ +function subtract(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + out[3] = a[3] - b[3]; + out[4] = a[4] - b[4]; + out[5] = a[5] - b[5]; + out[6] = a[6] - b[6]; + out[7] = a[7] - b[7]; + out[8] = a[8] - b[8]; + out[9] = a[9] - b[9]; + out[10] = a[10] - b[10]; + out[11] = a[11] - b[11]; + out[12] = a[12] - b[12]; + out[13] = a[13] - b[13]; + out[14] = a[14] - b[14]; + out[15] = a[15] - b[15]; + return out; +} + +/** + * Multiply each element of the matrix by a scalar. + * + * @param {mat4} out the receiving matrix + * @param {mat4} a the matrix to scale + * @param {Number} b amount to scale the matrix's elements by + * @returns {mat4} out + */ +function multiplyScalar(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + out[4] = a[4] * b; + out[5] = a[5] * b; + out[6] = a[6] * b; + out[7] = a[7] * b; + out[8] = a[8] * b; + out[9] = a[9] * b; + out[10] = a[10] * b; + out[11] = a[11] * b; + out[12] = a[12] * b; + out[13] = a[13] * b; + out[14] = a[14] * b; + out[15] = a[15] * b; + return out; +} + +/** + * Adds two mat4's after multiplying each element of the second operand by a scalar value. + * + * @param {mat4} out the receiving vector + * @param {mat4} a the first operand + * @param {mat4} b the second operand + * @param {Number} scale the amount to scale b's elements by before adding + * @returns {mat4} out + */ +function multiplyScalarAndAdd(out, a, b, scale) { + out[0] = a[0] + b[0] * scale; + out[1] = a[1] + b[1] * scale; + out[2] = a[2] + b[2] * scale; + out[3] = a[3] + b[3] * scale; + out[4] = a[4] + b[4] * scale; + out[5] = a[5] + b[5] * scale; + out[6] = a[6] + b[6] * scale; + out[7] = a[7] + b[7] * scale; + out[8] = a[8] + b[8] * scale; + out[9] = a[9] + b[9] * scale; + out[10] = a[10] + b[10] * scale; + out[11] = a[11] + b[11] * scale; + out[12] = a[12] + b[12] * scale; + out[13] = a[13] + b[13] * scale; + out[14] = a[14] + b[14] * scale; + out[15] = a[15] + b[15] * scale; + return out; +} + +/** + * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===) + * + * @param {mat4} a The first matrix. + * @param {mat4} b The second matrix. + * @returns {Boolean} True if the matrices are equal, false otherwise. + */ +function exactEquals(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15]; +} + +/** + * Returns whether or not the matrices have approximately the same elements in the same position. + * + * @param {mat4} a The first matrix. + * @param {mat4} b The second matrix. + * @returns {Boolean} True if the matrices are equal, false otherwise. + */ +function equals(a, b) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3]; + var a4 = a[4], + a5 = a[5], + a6 = a[6], + a7 = a[7]; + var a8 = a[8], + a9 = a[9], + a10 = a[10], + a11 = a[11]; + var a12 = a[12], + a13 = a[13], + a14 = a[14], + a15 = a[15]; + + var b0 = b[0], + b1 = b[1], + b2 = b[2], + b3 = b[3]; + var b4 = b[4], + b5 = b[5], + b6 = b[6], + b7 = b[7]; + var b8 = b[8], + b9 = b[9], + b10 = b[10], + b11 = b[11]; + var b12 = b[12], + b13 = b[13], + b14 = b[14], + b15 = b[15]; + + return Math.abs(a0 - b0) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a15), Math.abs(b15)); +} + +/** + * Alias for {@link mat4.multiply} + * @function + */ +var mul = multiply; + +/** + * Alias for {@link mat4.subtract} + * @function + */ +var sub = subtract; + +/***/ }), + +/***/ "./node_modules/gl-matrix/lib/gl-matrix/quat.js": +/*!******************************************************!*\ + !*** ./node_modules/gl-matrix/lib/gl-matrix/quat.js ***! + \******************************************************/ +/*! exports provided: create, identity, setAxisAngle, getAxisAngle, multiply, rotateX, rotateY, rotateZ, calculateW, slerp, random, invert, conjugate, fromMat3, fromEuler, str, clone, fromValues, copy, set, add, mul, scale, dot, lerp, length, len, squaredLength, sqrLen, normalize, exactEquals, equals, rotationTo, sqlerp, setAxes */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "create", function() { return create; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "identity", function() { return identity; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "setAxisAngle", function() { return setAxisAngle; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getAxisAngle", function() { return getAxisAngle; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiply", function() { return multiply; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateX", function() { return rotateX; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateY", function() { return rotateY; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateZ", function() { return rotateZ; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "calculateW", function() { return calculateW; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "slerp", function() { return slerp; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "random", function() { return random; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "invert", function() { return invert; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conjugate", function() { return conjugate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromMat3", function() { return fromMat3; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromEuler", function() { return fromEuler; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "str", function() { return str; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clone", function() { return clone; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromValues", function() { return fromValues; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copy", function() { return copy; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "set", function() { return set; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "add", function() { return add; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mul", function() { return mul; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scale", function() { return scale; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dot", function() { return dot; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lerp", function() { return lerp; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "length", function() { return length; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "len", function() { return len; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "squaredLength", function() { return squaredLength; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqrLen", function() { return sqrLen; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "normalize", function() { return normalize; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "exactEquals", function() { return exactEquals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equals", function() { return equals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotationTo", function() { return rotationTo; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqlerp", function() { return sqlerp; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "setAxes", function() { return setAxes; }); +/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common.js */ "./node_modules/gl-matrix/lib/gl-matrix/common.js"); +/* harmony import */ var _mat3_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./mat3.js */ "./node_modules/gl-matrix/lib/gl-matrix/mat3.js"); +/* harmony import */ var _vec3_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./vec3.js */ "./node_modules/gl-matrix/lib/gl-matrix/vec3.js"); +/* harmony import */ var _vec4_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./vec4.js */ "./node_modules/gl-matrix/lib/gl-matrix/vec4.js"); + + + + + +/** + * Quaternion + * @module quat + */ + +/** + * Creates a new identity quat + * + * @returns {quat} a new quaternion + */ +function create() { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](4); + if (_common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"] != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + } + out[3] = 1; + return out; +} + +/** + * Set a quat to the identity quaternion + * + * @param {quat} out the receiving quaternion + * @returns {quat} out + */ +function identity(out) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 1; + return out; +} + +/** + * Sets a quat from the given angle and rotation axis, + * then returns it. + * + * @param {quat} out the receiving quaternion + * @param {vec3} axis the axis around which to rotate + * @param {Number} rad the angle in radians + * @returns {quat} out + **/ +function setAxisAngle(out, axis, rad) { + rad = rad * 0.5; + var s = Math.sin(rad); + out[0] = s * axis[0]; + out[1] = s * axis[1]; + out[2] = s * axis[2]; + out[3] = Math.cos(rad); + return out; +} + +/** + * Gets the rotation axis and angle for a given + * quaternion. If a quaternion is created with + * setAxisAngle, this method will return the same + * values as providied in the original parameter list + * OR functionally equivalent values. + * Example: The quaternion formed by axis [0, 0, 1] and + * angle -90 is the same as the quaternion formed by + * [0, 0, 1] and 270. This method favors the latter. + * @param {vec3} out_axis Vector receiving the axis of rotation + * @param {quat} q Quaternion to be decomposed + * @return {Number} Angle, in radians, of the rotation + */ +function getAxisAngle(out_axis, q) { + var rad = Math.acos(q[3]) * 2.0; + var s = Math.sin(rad / 2.0); + if (s > _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"]) { + out_axis[0] = q[0] / s; + out_axis[1] = q[1] / s; + out_axis[2] = q[2] / s; + } else { + // If s is zero, return any axis (no rotation - axis does not matter) + out_axis[0] = 1; + out_axis[1] = 0; + out_axis[2] = 0; + } + return rad; +} + +/** + * Multiplies two quat's + * + * @param {quat} out the receiving quaternion + * @param {quat} a the first operand + * @param {quat} b the second operand + * @returns {quat} out + */ +function multiply(out, a, b) { + var ax = a[0], + ay = a[1], + az = a[2], + aw = a[3]; + var bx = b[0], + by = b[1], + bz = b[2], + bw = b[3]; + + out[0] = ax * bw + aw * bx + ay * bz - az * by; + out[1] = ay * bw + aw * by + az * bx - ax * bz; + out[2] = az * bw + aw * bz + ax * by - ay * bx; + out[3] = aw * bw - ax * bx - ay * by - az * bz; + return out; +} + +/** + * Rotates a quaternion by the given angle about the X axis + * + * @param {quat} out quat receiving operation result + * @param {quat} a quat to rotate + * @param {number} rad angle (in radians) to rotate + * @returns {quat} out + */ +function rotateX(out, a, rad) { + rad *= 0.5; + + var ax = a[0], + ay = a[1], + az = a[2], + aw = a[3]; + var bx = Math.sin(rad), + bw = Math.cos(rad); + + out[0] = ax * bw + aw * bx; + out[1] = ay * bw + az * bx; + out[2] = az * bw - ay * bx; + out[3] = aw * bw - ax * bx; + return out; +} + +/** + * Rotates a quaternion by the given angle about the Y axis + * + * @param {quat} out quat receiving operation result + * @param {quat} a quat to rotate + * @param {number} rad angle (in radians) to rotate + * @returns {quat} out + */ +function rotateY(out, a, rad) { + rad *= 0.5; + + var ax = a[0], + ay = a[1], + az = a[2], + aw = a[3]; + var by = Math.sin(rad), + bw = Math.cos(rad); + + out[0] = ax * bw - az * by; + out[1] = ay * bw + aw * by; + out[2] = az * bw + ax * by; + out[3] = aw * bw - ay * by; + return out; +} + +/** + * Rotates a quaternion by the given angle about the Z axis + * + * @param {quat} out quat receiving operation result + * @param {quat} a quat to rotate + * @param {number} rad angle (in radians) to rotate + * @returns {quat} out + */ +function rotateZ(out, a, rad) { + rad *= 0.5; + + var ax = a[0], + ay = a[1], + az = a[2], + aw = a[3]; + var bz = Math.sin(rad), + bw = Math.cos(rad); + + out[0] = ax * bw + ay * bz; + out[1] = ay * bw - ax * bz; + out[2] = az * bw + aw * bz; + out[3] = aw * bw - az * bz; + return out; +} + +/** + * Calculates the W component of a quat from the X, Y, and Z components. + * Assumes that quaternion is 1 unit in length. + * Any existing W component will be ignored. + * + * @param {quat} out the receiving quaternion + * @param {quat} a quat to calculate W component of + * @returns {quat} out + */ +function calculateW(out, a) { + var x = a[0], + y = a[1], + z = a[2]; + + out[0] = x; + out[1] = y; + out[2] = z; + out[3] = Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z)); + return out; +} + +/** + * Performs a spherical linear interpolation between two quat + * + * @param {quat} out the receiving quaternion + * @param {quat} a the first operand + * @param {quat} b the second operand + * @param {Number} t interpolation amount, in the range [0-1], between the two inputs + * @returns {quat} out + */ +function slerp(out, a, b, t) { + // benchmarks: + // http://jsperf.com/quaternion-slerp-implementations + var ax = a[0], + ay = a[1], + az = a[2], + aw = a[3]; + var bx = b[0], + by = b[1], + bz = b[2], + bw = b[3]; + + var omega = void 0, + cosom = void 0, + sinom = void 0, + scale0 = void 0, + scale1 = void 0; + + // calc cosine + cosom = ax * bx + ay * by + az * bz + aw * bw; + // adjust signs (if necessary) + if (cosom < 0.0) { + cosom = -cosom; + bx = -bx; + by = -by; + bz = -bz; + bw = -bw; + } + // calculate coefficients + if (1.0 - cosom > _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"]) { + // standard case (slerp) + omega = Math.acos(cosom); + sinom = Math.sin(omega); + scale0 = Math.sin((1.0 - t) * omega) / sinom; + scale1 = Math.sin(t * omega) / sinom; + } else { + // "from" and "to" quaternions are very close + // ... so we can do a linear interpolation + scale0 = 1.0 - t; + scale1 = t; + } + // calculate final values + out[0] = scale0 * ax + scale1 * bx; + out[1] = scale0 * ay + scale1 * by; + out[2] = scale0 * az + scale1 * bz; + out[3] = scale0 * aw + scale1 * bw; + + return out; +} + +/** + * Generates a random quaternion + * + * @param {quat} out the receiving quaternion + * @returns {quat} out + */ +function random(out) { + // Implementation of http://planning.cs.uiuc.edu/node198.html + // TODO: Calling random 3 times is probably not the fastest solution + var u1 = _common_js__WEBPACK_IMPORTED_MODULE_0__["RANDOM"](); + var u2 = _common_js__WEBPACK_IMPORTED_MODULE_0__["RANDOM"](); + var u3 = _common_js__WEBPACK_IMPORTED_MODULE_0__["RANDOM"](); + + var sqrt1MinusU1 = Math.sqrt(1 - u1); + var sqrtU1 = Math.sqrt(u1); + + out[0] = sqrt1MinusU1 * Math.sin(2.0 * Math.PI * u2); + out[1] = sqrt1MinusU1 * Math.cos(2.0 * Math.PI * u2); + out[2] = sqrtU1 * Math.sin(2.0 * Math.PI * u3); + out[3] = sqrtU1 * Math.cos(2.0 * Math.PI * u3); + return out; +} + +/** + * Calculates the inverse of a quat + * + * @param {quat} out the receiving quaternion + * @param {quat} a quat to calculate inverse of + * @returns {quat} out + */ +function invert(out, a) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3]; + var dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3; + var invDot = dot ? 1.0 / dot : 0; + + // TODO: Would be faster to return [0,0,0,0] immediately if dot == 0 + + out[0] = -a0 * invDot; + out[1] = -a1 * invDot; + out[2] = -a2 * invDot; + out[3] = a3 * invDot; + return out; +} + +/** + * Calculates the conjugate of a quat + * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result. + * + * @param {quat} out the receiving quaternion + * @param {quat} a quat to calculate conjugate of + * @returns {quat} out + */ +function conjugate(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + out[2] = -a[2]; + out[3] = a[3]; + return out; +} + +/** + * Creates a quaternion from the given 3x3 rotation matrix. + * + * NOTE: The resultant quaternion is not normalized, so you should be sure + * to renormalize the quaternion yourself where necessary. + * + * @param {quat} out the receiving quaternion + * @param {mat3} m rotation matrix + * @returns {quat} out + * @function + */ +function fromMat3(out, m) { + // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes + // article "Quaternion Calculus and Fast Animation". + var fTrace = m[0] + m[4] + m[8]; + var fRoot = void 0; + + if (fTrace > 0.0) { + // |w| > 1/2, may as well choose w > 1/2 + fRoot = Math.sqrt(fTrace + 1.0); // 2w + out[3] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; // 1/(4w) + out[0] = (m[5] - m[7]) * fRoot; + out[1] = (m[6] - m[2]) * fRoot; + out[2] = (m[1] - m[3]) * fRoot; + } else { + // |w| <= 1/2 + var i = 0; + if (m[4] > m[0]) i = 1; + if (m[8] > m[i * 3 + i]) i = 2; + var j = (i + 1) % 3; + var k = (i + 2) % 3; + + fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0); + out[i] = 0.5 * fRoot; + fRoot = 0.5 / fRoot; + out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot; + out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot; + out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot; + } + + return out; +} + +/** + * Creates a quaternion from the given euler angle x, y, z. + * + * @param {quat} out the receiving quaternion + * @param {x} Angle to rotate around X axis in degrees. + * @param {y} Angle to rotate around Y axis in degrees. + * @param {z} Angle to rotate around Z axis in degrees. + * @returns {quat} out + * @function + */ +function fromEuler(out, x, y, z) { + var halfToRad = 0.5 * Math.PI / 180.0; + x *= halfToRad; + y *= halfToRad; + z *= halfToRad; + + var sx = Math.sin(x); + var cx = Math.cos(x); + var sy = Math.sin(y); + var cy = Math.cos(y); + var sz = Math.sin(z); + var cz = Math.cos(z); + + out[0] = sx * cy * cz - cx * sy * sz; + out[1] = cx * sy * cz + sx * cy * sz; + out[2] = cx * cy * sz - sx * sy * cz; + out[3] = cx * cy * cz + sx * sy * sz; + + return out; +} + +/** + * Returns a string representation of a quatenion + * + * @param {quat} a vector to represent as a string + * @returns {String} string representation of the vector + */ +function str(a) { + return 'quat(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')'; +} + +/** + * Creates a new quat initialized with values from an existing quaternion + * + * @param {quat} a quaternion to clone + * @returns {quat} a new quaternion + * @function + */ +var clone = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["clone"]; + +/** + * Creates a new quat initialized with the given values + * + * @param {Number} x X component + * @param {Number} y Y component + * @param {Number} z Z component + * @param {Number} w W component + * @returns {quat} a new quaternion + * @function + */ +var fromValues = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["fromValues"]; + +/** + * Copy the values from one quat to another + * + * @param {quat} out the receiving quaternion + * @param {quat} a the source quaternion + * @returns {quat} out + * @function + */ +var copy = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["copy"]; + +/** + * Set the components of a quat to the given values + * + * @param {quat} out the receiving quaternion + * @param {Number} x X component + * @param {Number} y Y component + * @param {Number} z Z component + * @param {Number} w W component + * @returns {quat} out + * @function + */ +var set = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["set"]; + +/** + * Adds two quat's + * + * @param {quat} out the receiving quaternion + * @param {quat} a the first operand + * @param {quat} b the second operand + * @returns {quat} out + * @function + */ +var add = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["add"]; + +/** + * Alias for {@link quat.multiply} + * @function + */ +var mul = multiply; + +/** + * Scales a quat by a scalar number + * + * @param {quat} out the receiving vector + * @param {quat} a the vector to scale + * @param {Number} b amount to scale the vector by + * @returns {quat} out + * @function + */ +var scale = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["scale"]; + +/** + * Calculates the dot product of two quat's + * + * @param {quat} a the first operand + * @param {quat} b the second operand + * @returns {Number} dot product of a and b + * @function + */ +var dot = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["dot"]; + +/** + * Performs a linear interpolation between two quat's + * + * @param {quat} out the receiving quaternion + * @param {quat} a the first operand + * @param {quat} b the second operand + * @param {Number} t interpolation amount, in the range [0-1], between the two inputs + * @returns {quat} out + * @function + */ +var lerp = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["lerp"]; + +/** + * Calculates the length of a quat + * + * @param {quat} a vector to calculate length of + * @returns {Number} length of a + */ +var length = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["length"]; + +/** + * Alias for {@link quat.length} + * @function + */ +var len = length; + +/** + * Calculates the squared length of a quat + * + * @param {quat} a vector to calculate squared length of + * @returns {Number} squared length of a + * @function + */ +var squaredLength = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["squaredLength"]; + +/** + * Alias for {@link quat.squaredLength} + * @function + */ +var sqrLen = squaredLength; + +/** + * Normalize a quat + * + * @param {quat} out the receiving quaternion + * @param {quat} a quaternion to normalize + * @returns {quat} out + * @function + */ +var normalize = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["normalize"]; + +/** + * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===) + * + * @param {quat} a The first quaternion. + * @param {quat} b The second quaternion. + * @returns {Boolean} True if the vectors are equal, false otherwise. + */ +var exactEquals = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["exactEquals"]; + +/** + * Returns whether or not the quaternions have approximately the same elements in the same position. + * + * @param {quat} a The first vector. + * @param {quat} b The second vector. + * @returns {Boolean} True if the vectors are equal, false otherwise. + */ +var equals = _vec4_js__WEBPACK_IMPORTED_MODULE_3__["equals"]; + +/** + * Sets a quaternion to represent the shortest rotation from one + * vector to another. + * + * Both vectors are assumed to be unit length. + * + * @param {quat} out the receiving quaternion. + * @param {vec3} a the initial vector + * @param {vec3} b the destination vector + * @returns {quat} out + */ +var rotationTo = function () { + var tmpvec3 = _vec3_js__WEBPACK_IMPORTED_MODULE_2__["create"](); + var xUnitVec3 = _vec3_js__WEBPACK_IMPORTED_MODULE_2__["fromValues"](1, 0, 0); + var yUnitVec3 = _vec3_js__WEBPACK_IMPORTED_MODULE_2__["fromValues"](0, 1, 0); + + return function (out, a, b) { + var dot = _vec3_js__WEBPACK_IMPORTED_MODULE_2__["dot"](a, b); + if (dot < -0.999999) { + _vec3_js__WEBPACK_IMPORTED_MODULE_2__["cross"](tmpvec3, xUnitVec3, a); + if (_vec3_js__WEBPACK_IMPORTED_MODULE_2__["len"](tmpvec3) < 0.000001) _vec3_js__WEBPACK_IMPORTED_MODULE_2__["cross"](tmpvec3, yUnitVec3, a); + _vec3_js__WEBPACK_IMPORTED_MODULE_2__["normalize"](tmpvec3, tmpvec3); + setAxisAngle(out, tmpvec3, Math.PI); + return out; + } else if (dot > 0.999999) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 1; + return out; + } else { + _vec3_js__WEBPACK_IMPORTED_MODULE_2__["cross"](tmpvec3, a, b); + out[0] = tmpvec3[0]; + out[1] = tmpvec3[1]; + out[2] = tmpvec3[2]; + out[3] = 1 + dot; + return normalize(out, out); + } + }; +}(); + +/** + * Performs a spherical linear interpolation with two control points + * + * @param {quat} out the receiving quaternion + * @param {quat} a the first operand + * @param {quat} b the second operand + * @param {quat} c the third operand + * @param {quat} d the fourth operand + * @param {Number} t interpolation amount, in the range [0-1], between the two inputs + * @returns {quat} out + */ +var sqlerp = function () { + var temp1 = create(); + var temp2 = create(); + + return function (out, a, b, c, d, t) { + slerp(temp1, a, d, t); + slerp(temp2, b, c, t); + slerp(out, temp1, temp2, 2 * t * (1 - t)); + + return out; + }; +}(); + +/** + * Sets the specified quaternion with values corresponding to the given + * axes. Each axis is a vec3 and is expected to be unit length and + * perpendicular to all other specified axes. + * + * @param {vec3} view the vector representing the viewing direction + * @param {vec3} right the vector representing the local "right" direction + * @param {vec3} up the vector representing the local "up" direction + * @returns {quat} out + */ +var setAxes = function () { + var matr = _mat3_js__WEBPACK_IMPORTED_MODULE_1__["create"](); + + return function (out, view, right, up) { + matr[0] = right[0]; + matr[3] = right[1]; + matr[6] = right[2]; + + matr[1] = up[0]; + matr[4] = up[1]; + matr[7] = up[2]; + + matr[2] = -view[0]; + matr[5] = -view[1]; + matr[8] = -view[2]; + + return normalize(out, fromMat3(out, matr)); + }; +}(); + +/***/ }), + +/***/ "./node_modules/gl-matrix/lib/gl-matrix/quat2.js": +/*!*******************************************************!*\ + !*** ./node_modules/gl-matrix/lib/gl-matrix/quat2.js ***! + \*******************************************************/ +/*! exports provided: create, clone, fromValues, fromRotationTranslationValues, fromRotationTranslation, fromTranslation, fromRotation, fromMat4, copy, identity, set, getReal, getDual, setReal, setDual, getTranslation, translate, rotateX, rotateY, rotateZ, rotateByQuatAppend, rotateByQuatPrepend, rotateAroundAxis, add, multiply, mul, scale, dot, lerp, invert, conjugate, length, len, squaredLength, sqrLen, normalize, str, exactEquals, equals */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "create", function() { return create; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clone", function() { return clone; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromValues", function() { return fromValues; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromRotationTranslationValues", function() { return fromRotationTranslationValues; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromRotationTranslation", function() { return fromRotationTranslation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromTranslation", function() { return fromTranslation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromRotation", function() { return fromRotation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromMat4", function() { return fromMat4; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copy", function() { return copy; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "identity", function() { return identity; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "set", function() { return set; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getReal", function() { return getReal; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getDual", function() { return getDual; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "setReal", function() { return setReal; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "setDual", function() { return setDual; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "getTranslation", function() { return getTranslation; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "translate", function() { return translate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateX", function() { return rotateX; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateY", function() { return rotateY; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateZ", function() { return rotateZ; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateByQuatAppend", function() { return rotateByQuatAppend; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateByQuatPrepend", function() { return rotateByQuatPrepend; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateAroundAxis", function() { return rotateAroundAxis; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "add", function() { return add; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiply", function() { return multiply; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mul", function() { return mul; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scale", function() { return scale; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dot", function() { return dot; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lerp", function() { return lerp; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "invert", function() { return invert; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "conjugate", function() { return conjugate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "length", function() { return length; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "len", function() { return len; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "squaredLength", function() { return squaredLength; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqrLen", function() { return sqrLen; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "normalize", function() { return normalize; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "str", function() { return str; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "exactEquals", function() { return exactEquals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equals", function() { return equals; }); +/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common.js */ "./node_modules/gl-matrix/lib/gl-matrix/common.js"); +/* harmony import */ var _quat_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./quat.js */ "./node_modules/gl-matrix/lib/gl-matrix/quat.js"); +/* harmony import */ var _mat4_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./mat4.js */ "./node_modules/gl-matrix/lib/gl-matrix/mat4.js"); + + + + +/** + * Dual Quaternion
+ * Format: [real, dual]
+ * Quaternion format: XYZW
+ * Make sure to have normalized dual quaternions, otherwise the functions may not work as intended.
+ * @module quat2 + */ + +/** + * Creates a new identity dual quat + * + * @returns {quat2} a new dual quaternion [real -> rotation, dual -> translation] + */ +function create() { + var dq = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](8); + if (_common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"] != Float32Array) { + dq[0] = 0; + dq[1] = 0; + dq[2] = 0; + dq[4] = 0; + dq[5] = 0; + dq[6] = 0; + dq[7] = 0; + } + dq[3] = 1; + return dq; +} + +/** + * Creates a new quat initialized with values from an existing quaternion + * + * @param {quat2} a dual quaternion to clone + * @returns {quat2} new dual quaternion + * @function + */ +function clone(a) { + var dq = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](8); + dq[0] = a[0]; + dq[1] = a[1]; + dq[2] = a[2]; + dq[3] = a[3]; + dq[4] = a[4]; + dq[5] = a[5]; + dq[6] = a[6]; + dq[7] = a[7]; + return dq; +} + +/** + * Creates a new dual quat initialized with the given values + * + * @param {Number} x1 X component + * @param {Number} y1 Y component + * @param {Number} z1 Z component + * @param {Number} w1 W component + * @param {Number} x2 X component + * @param {Number} y2 Y component + * @param {Number} z2 Z component + * @param {Number} w2 W component + * @returns {quat2} new dual quaternion + * @function + */ +function fromValues(x1, y1, z1, w1, x2, y2, z2, w2) { + var dq = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](8); + dq[0] = x1; + dq[1] = y1; + dq[2] = z1; + dq[3] = w1; + dq[4] = x2; + dq[5] = y2; + dq[6] = z2; + dq[7] = w2; + return dq; +} + +/** + * Creates a new dual quat from the given values (quat and translation) + * + * @param {Number} x1 X component + * @param {Number} y1 Y component + * @param {Number} z1 Z component + * @param {Number} w1 W component + * @param {Number} x2 X component (translation) + * @param {Number} y2 Y component (translation) + * @param {Number} z2 Z component (translation) + * @returns {quat2} new dual quaternion + * @function + */ +function fromRotationTranslationValues(x1, y1, z1, w1, x2, y2, z2) { + var dq = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](8); + dq[0] = x1; + dq[1] = y1; + dq[2] = z1; + dq[3] = w1; + var ax = x2 * 0.5, + ay = y2 * 0.5, + az = z2 * 0.5; + dq[4] = ax * w1 + ay * z1 - az * y1; + dq[5] = ay * w1 + az * x1 - ax * z1; + dq[6] = az * w1 + ax * y1 - ay * x1; + dq[7] = -ax * x1 - ay * y1 - az * z1; + return dq; +} + +/** + * Creates a dual quat from a quaternion and a translation + * + * @param {quat2} dual quaternion receiving operation result + * @param {quat} q quaternion + * @param {vec3} t tranlation vector + * @returns {quat2} dual quaternion receiving operation result + * @function + */ +function fromRotationTranslation(out, q, t) { + var ax = t[0] * 0.5, + ay = t[1] * 0.5, + az = t[2] * 0.5, + bx = q[0], + by = q[1], + bz = q[2], + bw = q[3]; + out[0] = bx; + out[1] = by; + out[2] = bz; + out[3] = bw; + out[4] = ax * bw + ay * bz - az * by; + out[5] = ay * bw + az * bx - ax * bz; + out[6] = az * bw + ax * by - ay * bx; + out[7] = -ax * bx - ay * by - az * bz; + return out; +} + +/** + * Creates a dual quat from a translation + * + * @param {quat2} dual quaternion receiving operation result + * @param {vec3} t translation vector + * @returns {quat2} dual quaternion receiving operation result + * @function + */ +function fromTranslation(out, t) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 1; + out[4] = t[0] * 0.5; + out[5] = t[1] * 0.5; + out[6] = t[2] * 0.5; + out[7] = 0; + return out; +} + +/** + * Creates a dual quat from a quaternion + * + * @param {quat2} dual quaternion receiving operation result + * @param {quat} q the quaternion + * @returns {quat2} dual quaternion receiving operation result + * @function + */ +function fromRotation(out, q) { + out[0] = q[0]; + out[1] = q[1]; + out[2] = q[2]; + out[3] = q[3]; + out[4] = 0; + out[5] = 0; + out[6] = 0; + out[7] = 0; + return out; +} + +/** + * Creates a new dual quat from a matrix (4x4) + * + * @param {quat2} out the dual quaternion + * @param {mat4} a the matrix + * @returns {quat2} dual quat receiving operation result + * @function + */ +function fromMat4(out, a) { + //TODO Optimize this + var outer = _quat_js__WEBPACK_IMPORTED_MODULE_1__["create"](); + _mat4_js__WEBPACK_IMPORTED_MODULE_2__["getRotation"](outer, a); + var t = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](3); + _mat4_js__WEBPACK_IMPORTED_MODULE_2__["getTranslation"](t, a); + fromRotationTranslation(out, outer, t); + return out; +} + +/** + * Copy the values from one dual quat to another + * + * @param {quat2} out the receiving dual quaternion + * @param {quat2} a the source dual quaternion + * @returns {quat2} out + * @function + */ +function copy(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + out[4] = a[4]; + out[5] = a[5]; + out[6] = a[6]; + out[7] = a[7]; + return out; +} + +/** + * Set a dual quat to the identity dual quaternion + * + * @param {quat2} out the receiving quaternion + * @returns {quat2} out + */ +function identity(out) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 1; + out[4] = 0; + out[5] = 0; + out[6] = 0; + out[7] = 0; + return out; +} + +/** + * Set the components of a dual quat to the given values + * + * @param {quat2} out the receiving quaternion + * @param {Number} x1 X component + * @param {Number} y1 Y component + * @param {Number} z1 Z component + * @param {Number} w1 W component + * @param {Number} x2 X component + * @param {Number} y2 Y component + * @param {Number} z2 Z component + * @param {Number} w2 W component + * @returns {quat2} out + * @function + */ +function set(out, x1, y1, z1, w1, x2, y2, z2, w2) { + out[0] = x1; + out[1] = y1; + out[2] = z1; + out[3] = w1; + + out[4] = x2; + out[5] = y2; + out[6] = z2; + out[7] = w2; + return out; +} + +/** + * Gets the real part of a dual quat + * @param {quat} out real part + * @param {quat2} a Dual Quaternion + * @return {quat} real part + */ +var getReal = _quat_js__WEBPACK_IMPORTED_MODULE_1__["copy"]; + +/** + * Gets the dual part of a dual quat + * @param {quat} out dual part + * @param {quat2} a Dual Quaternion + * @return {quat} dual part + */ +function getDual(out, a) { + out[0] = a[4]; + out[1] = a[5]; + out[2] = a[6]; + out[3] = a[7]; + return out; +} + +/** + * Set the real component of a dual quat to the given quaternion + * + * @param {quat2} out the receiving quaternion + * @param {quat} q a quaternion representing the real part + * @returns {quat2} out + * @function + */ +var setReal = _quat_js__WEBPACK_IMPORTED_MODULE_1__["copy"]; + +/** + * Set the dual component of a dual quat to the given quaternion + * + * @param {quat2} out the receiving quaternion + * @param {quat} q a quaternion representing the dual part + * @returns {quat2} out + * @function + */ +function setDual(out, q) { + out[4] = q[0]; + out[5] = q[1]; + out[6] = q[2]; + out[7] = q[3]; + return out; +} + +/** + * Gets the translation of a normalized dual quat + * @param {vec3} out translation + * @param {quat2} a Dual Quaternion to be decomposed + * @return {vec3} translation + */ +function getTranslation(out, a) { + var ax = a[4], + ay = a[5], + az = a[6], + aw = a[7], + bx = -a[0], + by = -a[1], + bz = -a[2], + bw = a[3]; + out[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2; + out[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2; + out[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2; + return out; +} + +/** + * Translates a dual quat by the given vector + * + * @param {quat2} out the receiving dual quaternion + * @param {quat2} a the dual quaternion to translate + * @param {vec3} v vector to translate by + * @returns {quat2} out + */ +function translate(out, a, v) { + var ax1 = a[0], + ay1 = a[1], + az1 = a[2], + aw1 = a[3], + bx1 = v[0] * 0.5, + by1 = v[1] * 0.5, + bz1 = v[2] * 0.5, + ax2 = a[4], + ay2 = a[5], + az2 = a[6], + aw2 = a[7]; + out[0] = ax1; + out[1] = ay1; + out[2] = az1; + out[3] = aw1; + out[4] = aw1 * bx1 + ay1 * bz1 - az1 * by1 + ax2; + out[5] = aw1 * by1 + az1 * bx1 - ax1 * bz1 + ay2; + out[6] = aw1 * bz1 + ax1 * by1 - ay1 * bx1 + az2; + out[7] = -ax1 * bx1 - ay1 * by1 - az1 * bz1 + aw2; + return out; +} + +/** + * Rotates a dual quat around the X axis + * + * @param {quat2} out the receiving dual quaternion + * @param {quat2} a the dual quaternion to rotate + * @param {number} rad how far should the rotation be + * @returns {quat2} out + */ +function rotateX(out, a, rad) { + var bx = -a[0], + by = -a[1], + bz = -a[2], + bw = a[3], + ax = a[4], + ay = a[5], + az = a[6], + aw = a[7], + ax1 = ax * bw + aw * bx + ay * bz - az * by, + ay1 = ay * bw + aw * by + az * bx - ax * bz, + az1 = az * bw + aw * bz + ax * by - ay * bx, + aw1 = aw * bw - ax * bx - ay * by - az * bz; + _quat_js__WEBPACK_IMPORTED_MODULE_1__["rotateX"](out, a, rad); + bx = out[0]; + by = out[1]; + bz = out[2]; + bw = out[3]; + out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by; + out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz; + out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx; + out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz; + return out; +} + +/** + * Rotates a dual quat around the Y axis + * + * @param {quat2} out the receiving dual quaternion + * @param {quat2} a the dual quaternion to rotate + * @param {number} rad how far should the rotation be + * @returns {quat2} out + */ +function rotateY(out, a, rad) { + var bx = -a[0], + by = -a[1], + bz = -a[2], + bw = a[3], + ax = a[4], + ay = a[5], + az = a[6], + aw = a[7], + ax1 = ax * bw + aw * bx + ay * bz - az * by, + ay1 = ay * bw + aw * by + az * bx - ax * bz, + az1 = az * bw + aw * bz + ax * by - ay * bx, + aw1 = aw * bw - ax * bx - ay * by - az * bz; + _quat_js__WEBPACK_IMPORTED_MODULE_1__["rotateY"](out, a, rad); + bx = out[0]; + by = out[1]; + bz = out[2]; + bw = out[3]; + out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by; + out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz; + out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx; + out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz; + return out; +} + +/** + * Rotates a dual quat around the Z axis + * + * @param {quat2} out the receiving dual quaternion + * @param {quat2} a the dual quaternion to rotate + * @param {number} rad how far should the rotation be + * @returns {quat2} out + */ +function rotateZ(out, a, rad) { + var bx = -a[0], + by = -a[1], + bz = -a[2], + bw = a[3], + ax = a[4], + ay = a[5], + az = a[6], + aw = a[7], + ax1 = ax * bw + aw * bx + ay * bz - az * by, + ay1 = ay * bw + aw * by + az * bx - ax * bz, + az1 = az * bw + aw * bz + ax * by - ay * bx, + aw1 = aw * bw - ax * bx - ay * by - az * bz; + _quat_js__WEBPACK_IMPORTED_MODULE_1__["rotateZ"](out, a, rad); + bx = out[0]; + by = out[1]; + bz = out[2]; + bw = out[3]; + out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by; + out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz; + out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx; + out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz; + return out; +} + +/** + * Rotates a dual quat by a given quaternion (a * q) + * + * @param {quat2} out the receiving dual quaternion + * @param {quat2} a the dual quaternion to rotate + * @param {quat} q quaternion to rotate by + * @returns {quat2} out + */ +function rotateByQuatAppend(out, a, q) { + var qx = q[0], + qy = q[1], + qz = q[2], + qw = q[3], + ax = a[0], + ay = a[1], + az = a[2], + aw = a[3]; + + out[0] = ax * qw + aw * qx + ay * qz - az * qy; + out[1] = ay * qw + aw * qy + az * qx - ax * qz; + out[2] = az * qw + aw * qz + ax * qy - ay * qx; + out[3] = aw * qw - ax * qx - ay * qy - az * qz; + ax = a[4]; + ay = a[5]; + az = a[6]; + aw = a[7]; + out[4] = ax * qw + aw * qx + ay * qz - az * qy; + out[5] = ay * qw + aw * qy + az * qx - ax * qz; + out[6] = az * qw + aw * qz + ax * qy - ay * qx; + out[7] = aw * qw - ax * qx - ay * qy - az * qz; + return out; +} + +/** + * Rotates a dual quat by a given quaternion (q * a) + * + * @param {quat2} out the receiving dual quaternion + * @param {quat} q quaternion to rotate by + * @param {quat2} a the dual quaternion to rotate + * @returns {quat2} out + */ +function rotateByQuatPrepend(out, q, a) { + var qx = q[0], + qy = q[1], + qz = q[2], + qw = q[3], + bx = a[0], + by = a[1], + bz = a[2], + bw = a[3]; + + out[0] = qx * bw + qw * bx + qy * bz - qz * by; + out[1] = qy * bw + qw * by + qz * bx - qx * bz; + out[2] = qz * bw + qw * bz + qx * by - qy * bx; + out[3] = qw * bw - qx * bx - qy * by - qz * bz; + bx = a[4]; + by = a[5]; + bz = a[6]; + bw = a[7]; + out[4] = qx * bw + qw * bx + qy * bz - qz * by; + out[5] = qy * bw + qw * by + qz * bx - qx * bz; + out[6] = qz * bw + qw * bz + qx * by - qy * bx; + out[7] = qw * bw - qx * bx - qy * by - qz * bz; + return out; +} + +/** + * Rotates a dual quat around a given axis. Does the normalisation automatically + * + * @param {quat2} out the receiving dual quaternion + * @param {quat2} a the dual quaternion to rotate + * @param {vec3} axis the axis to rotate around + * @param {Number} rad how far the rotation should be + * @returns {quat2} out + */ +function rotateAroundAxis(out, a, axis, rad) { + //Special case for rad = 0 + if (Math.abs(rad) < _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"]) { + return copy(out, a); + } + var axisLength = Math.sqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]); + + rad = rad * 0.5; + var s = Math.sin(rad); + var bx = s * axis[0] / axisLength; + var by = s * axis[1] / axisLength; + var bz = s * axis[2] / axisLength; + var bw = Math.cos(rad); + + var ax1 = a[0], + ay1 = a[1], + az1 = a[2], + aw1 = a[3]; + out[0] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by; + out[1] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz; + out[2] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx; + out[3] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz; + + var ax = a[4], + ay = a[5], + az = a[6], + aw = a[7]; + out[4] = ax * bw + aw * bx + ay * bz - az * by; + out[5] = ay * bw + aw * by + az * bx - ax * bz; + out[6] = az * bw + aw * bz + ax * by - ay * bx; + out[7] = aw * bw - ax * bx - ay * by - az * bz; + + return out; +} + +/** + * Adds two dual quat's + * + * @param {quat2} out the receiving dual quaternion + * @param {quat2} a the first operand + * @param {quat2} b the second operand + * @returns {quat2} out + * @function + */ +function add(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + out[4] = a[4] + b[4]; + out[5] = a[5] + b[5]; + out[6] = a[6] + b[6]; + out[7] = a[7] + b[7]; + return out; +} + +/** + * Multiplies two dual quat's + * + * @param {quat2} out the receiving dual quaternion + * @param {quat2} a the first operand + * @param {quat2} b the second operand + * @returns {quat2} out + */ +function multiply(out, a, b) { + var ax0 = a[0], + ay0 = a[1], + az0 = a[2], + aw0 = a[3], + bx1 = b[4], + by1 = b[5], + bz1 = b[6], + bw1 = b[7], + ax1 = a[4], + ay1 = a[5], + az1 = a[6], + aw1 = a[7], + bx0 = b[0], + by0 = b[1], + bz0 = b[2], + bw0 = b[3]; + out[0] = ax0 * bw0 + aw0 * bx0 + ay0 * bz0 - az0 * by0; + out[1] = ay0 * bw0 + aw0 * by0 + az0 * bx0 - ax0 * bz0; + out[2] = az0 * bw0 + aw0 * bz0 + ax0 * by0 - ay0 * bx0; + out[3] = aw0 * bw0 - ax0 * bx0 - ay0 * by0 - az0 * bz0; + out[4] = ax0 * bw1 + aw0 * bx1 + ay0 * bz1 - az0 * by1 + ax1 * bw0 + aw1 * bx0 + ay1 * bz0 - az1 * by0; + out[5] = ay0 * bw1 + aw0 * by1 + az0 * bx1 - ax0 * bz1 + ay1 * bw0 + aw1 * by0 + az1 * bx0 - ax1 * bz0; + out[6] = az0 * bw1 + aw0 * bz1 + ax0 * by1 - ay0 * bx1 + az1 * bw0 + aw1 * bz0 + ax1 * by0 - ay1 * bx0; + out[7] = aw0 * bw1 - ax0 * bx1 - ay0 * by1 - az0 * bz1 + aw1 * bw0 - ax1 * bx0 - ay1 * by0 - az1 * bz0; + return out; +} + +/** + * Alias for {@link quat2.multiply} + * @function + */ +var mul = multiply; + +/** + * Scales a dual quat by a scalar number + * + * @param {quat2} out the receiving dual quat + * @param {quat2} a the dual quat to scale + * @param {Number} b amount to scale the dual quat by + * @returns {quat2} out + * @function + */ +function scale(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + out[4] = a[4] * b; + out[5] = a[5] * b; + out[6] = a[6] * b; + out[7] = a[7] * b; + return out; +} + +/** + * Calculates the dot product of two dual quat's (The dot product of the real parts) + * + * @param {quat2} a the first operand + * @param {quat2} b the second operand + * @returns {Number} dot product of a and b + * @function + */ +var dot = _quat_js__WEBPACK_IMPORTED_MODULE_1__["dot"]; + +/** + * Performs a linear interpolation between two dual quats's + * NOTE: The resulting dual quaternions won't always be normalized (The error is most noticeable when t = 0.5) + * + * @param {quat2} out the receiving dual quat + * @param {quat2} a the first operand + * @param {quat2} b the second operand + * @param {Number} t interpolation amount, in the range [0-1], between the two inputs + * @returns {quat2} out + */ +function lerp(out, a, b, t) { + var mt = 1 - t; + if (dot(a, b) < 0) t = -t; + + out[0] = a[0] * mt + b[0] * t; + out[1] = a[1] * mt + b[1] * t; + out[2] = a[2] * mt + b[2] * t; + out[3] = a[3] * mt + b[3] * t; + out[4] = a[4] * mt + b[4] * t; + out[5] = a[5] * mt + b[5] * t; + out[6] = a[6] * mt + b[6] * t; + out[7] = a[7] * mt + b[7] * t; + + return out; +} + +/** + * Calculates the inverse of a dual quat. If they are normalized, conjugate is cheaper + * + * @param {quat2} out the receiving dual quaternion + * @param {quat2} a dual quat to calculate inverse of + * @returns {quat2} out + */ +function invert(out, a) { + var sqlen = squaredLength(a); + out[0] = -a[0] / sqlen; + out[1] = -a[1] / sqlen; + out[2] = -a[2] / sqlen; + out[3] = a[3] / sqlen; + out[4] = -a[4] / sqlen; + out[5] = -a[5] / sqlen; + out[6] = -a[6] / sqlen; + out[7] = a[7] / sqlen; + return out; +} + +/** + * Calculates the conjugate of a dual quat + * If the dual quaternion is normalized, this function is faster than quat2.inverse and produces the same result. + * + * @param {quat2} out the receiving quaternion + * @param {quat2} a quat to calculate conjugate of + * @returns {quat2} out + */ +function conjugate(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + out[2] = -a[2]; + out[3] = a[3]; + out[4] = -a[4]; + out[5] = -a[5]; + out[6] = -a[6]; + out[7] = a[7]; + return out; +} + +/** + * Calculates the length of a dual quat + * + * @param {quat2} a dual quat to calculate length of + * @returns {Number} length of a + * @function + */ +var length = _quat_js__WEBPACK_IMPORTED_MODULE_1__["length"]; + +/** + * Alias for {@link quat2.length} + * @function + */ +var len = length; + +/** + * Calculates the squared length of a dual quat + * + * @param {quat2} a dual quat to calculate squared length of + * @returns {Number} squared length of a + * @function + */ +var squaredLength = _quat_js__WEBPACK_IMPORTED_MODULE_1__["squaredLength"]; + +/** + * Alias for {@link quat2.squaredLength} + * @function + */ +var sqrLen = squaredLength; + +/** + * Normalize a dual quat + * + * @param {quat2} out the receiving dual quaternion + * @param {quat2} a dual quaternion to normalize + * @returns {quat2} out + * @function + */ +function normalize(out, a) { + var magnitude = squaredLength(a); + if (magnitude > 0) { + magnitude = Math.sqrt(magnitude); + + var a0 = a[0] / magnitude; + var a1 = a[1] / magnitude; + var a2 = a[2] / magnitude; + var a3 = a[3] / magnitude; + + var b0 = a[4]; + var b1 = a[5]; + var b2 = a[6]; + var b3 = a[7]; + + var a_dot_b = a0 * b0 + a1 * b1 + a2 * b2 + a3 * b3; + + out[0] = a0; + out[1] = a1; + out[2] = a2; + out[3] = a3; + + out[4] = (b0 - a0 * a_dot_b) / magnitude; + out[5] = (b1 - a1 * a_dot_b) / magnitude; + out[6] = (b2 - a2 * a_dot_b) / magnitude; + out[7] = (b3 - a3 * a_dot_b) / magnitude; + } + return out; +} + +/** + * Returns a string representation of a dual quatenion + * + * @param {quat2} a dual quaternion to represent as a string + * @returns {String} string representation of the dual quat + */ +function str(a) { + return 'quat2(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ', ' + a[6] + ', ' + a[7] + ')'; +} + +/** + * Returns whether or not the dual quaternions have exactly the same elements in the same position (when compared with ===) + * + * @param {quat2} a the first dual quaternion. + * @param {quat2} b the second dual quaternion. + * @returns {Boolean} true if the dual quaternions are equal, false otherwise. + */ +function exactEquals(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7]; +} + +/** + * Returns whether or not the dual quaternions have approximately the same elements in the same position. + * + * @param {quat2} a the first dual quat. + * @param {quat2} b the second dual quat. + * @returns {Boolean} true if the dual quats are equal, false otherwise. + */ +function equals(a, b) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3], + a4 = a[4], + a5 = a[5], + a6 = a[6], + a7 = a[7]; + var b0 = b[0], + b1 = b[1], + b2 = b[2], + b3 = b[3], + b4 = b[4], + b5 = b[5], + b6 = b[6], + b7 = b[7]; + return Math.abs(a0 - b0) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a7), Math.abs(b7)); +} + +/***/ }), + +/***/ "./node_modules/gl-matrix/lib/gl-matrix/vec2.js": +/*!******************************************************!*\ + !*** ./node_modules/gl-matrix/lib/gl-matrix/vec2.js ***! + \******************************************************/ +/*! exports provided: create, clone, fromValues, copy, set, add, subtract, multiply, divide, ceil, floor, min, max, round, scale, scaleAndAdd, distance, squaredDistance, length, squaredLength, negate, inverse, normalize, dot, cross, lerp, random, transformMat2, transformMat2d, transformMat3, transformMat4, rotate, angle, str, exactEquals, equals, len, sub, mul, div, dist, sqrDist, sqrLen, forEach */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "create", function() { return create; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clone", function() { return clone; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromValues", function() { return fromValues; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copy", function() { return copy; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "set", function() { return set; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "add", function() { return add; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "subtract", function() { return subtract; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiply", function() { return multiply; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "divide", function() { return divide; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ceil", function() { return ceil; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "floor", function() { return floor; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "min", function() { return min; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "max", function() { return max; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "round", function() { return round; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scale", function() { return scale; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scaleAndAdd", function() { return scaleAndAdd; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "distance", function() { return distance; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "squaredDistance", function() { return squaredDistance; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "length", function() { return length; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "squaredLength", function() { return squaredLength; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "negate", function() { return negate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "inverse", function() { return inverse; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "normalize", function() { return normalize; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dot", function() { return dot; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cross", function() { return cross; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lerp", function() { return lerp; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "random", function() { return random; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformMat2", function() { return transformMat2; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformMat2d", function() { return transformMat2d; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformMat3", function() { return transformMat3; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformMat4", function() { return transformMat4; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotate", function() { return rotate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "angle", function() { return angle; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "str", function() { return str; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "exactEquals", function() { return exactEquals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equals", function() { return equals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "len", function() { return len; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sub", function() { return sub; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mul", function() { return mul; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "div", function() { return div; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dist", function() { return dist; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqrDist", function() { return sqrDist; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqrLen", function() { return sqrLen; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "forEach", function() { return forEach; }); +/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common.js */ "./node_modules/gl-matrix/lib/gl-matrix/common.js"); + + +/** + * 2 Dimensional Vector + * @module vec2 + */ + +/** + * Creates a new, empty vec2 + * + * @returns {vec2} a new 2D vector + */ +function create() { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](2); + if (_common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"] != Float32Array) { + out[0] = 0; + out[1] = 0; + } + return out; +} + +/** + * Creates a new vec2 initialized with values from an existing vector + * + * @param {vec2} a vector to clone + * @returns {vec2} a new 2D vector + */ +function clone(a) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](2); + out[0] = a[0]; + out[1] = a[1]; + return out; +} + +/** + * Creates a new vec2 initialized with the given values + * + * @param {Number} x X component + * @param {Number} y Y component + * @returns {vec2} a new 2D vector + */ +function fromValues(x, y) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](2); + out[0] = x; + out[1] = y; + return out; +} + +/** + * Copy the values from one vec2 to another + * + * @param {vec2} out the receiving vector + * @param {vec2} a the source vector + * @returns {vec2} out + */ +function copy(out, a) { + out[0] = a[0]; + out[1] = a[1]; + return out; +} + +/** + * Set the components of a vec2 to the given values + * + * @param {vec2} out the receiving vector + * @param {Number} x X component + * @param {Number} y Y component + * @returns {vec2} out + */ +function set(out, x, y) { + out[0] = x; + out[1] = y; + return out; +} + +/** + * Adds two vec2's + * + * @param {vec2} out the receiving vector + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @returns {vec2} out + */ +function add(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + return out; +} + +/** + * Subtracts vector b from vector a + * + * @param {vec2} out the receiving vector + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @returns {vec2} out + */ +function subtract(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + return out; +} + +/** + * Multiplies two vec2's + * + * @param {vec2} out the receiving vector + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @returns {vec2} out + */ +function multiply(out, a, b) { + out[0] = a[0] * b[0]; + out[1] = a[1] * b[1]; + return out; +} + +/** + * Divides two vec2's + * + * @param {vec2} out the receiving vector + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @returns {vec2} out + */ +function divide(out, a, b) { + out[0] = a[0] / b[0]; + out[1] = a[1] / b[1]; + return out; +} + +/** + * Math.ceil the components of a vec2 + * + * @param {vec2} out the receiving vector + * @param {vec2} a vector to ceil + * @returns {vec2} out + */ +function ceil(out, a) { + out[0] = Math.ceil(a[0]); + out[1] = Math.ceil(a[1]); + return out; +} + +/** + * Math.floor the components of a vec2 + * + * @param {vec2} out the receiving vector + * @param {vec2} a vector to floor + * @returns {vec2} out + */ +function floor(out, a) { + out[0] = Math.floor(a[0]); + out[1] = Math.floor(a[1]); + return out; +} + +/** + * Returns the minimum of two vec2's + * + * @param {vec2} out the receiving vector + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @returns {vec2} out + */ +function min(out, a, b) { + out[0] = Math.min(a[0], b[0]); + out[1] = Math.min(a[1], b[1]); + return out; +} + +/** + * Returns the maximum of two vec2's + * + * @param {vec2} out the receiving vector + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @returns {vec2} out + */ +function max(out, a, b) { + out[0] = Math.max(a[0], b[0]); + out[1] = Math.max(a[1], b[1]); + return out; +} + +/** + * Math.round the components of a vec2 + * + * @param {vec2} out the receiving vector + * @param {vec2} a vector to round + * @returns {vec2} out + */ +function round(out, a) { + out[0] = Math.round(a[0]); + out[1] = Math.round(a[1]); + return out; +} + +/** + * Scales a vec2 by a scalar number + * + * @param {vec2} out the receiving vector + * @param {vec2} a the vector to scale + * @param {Number} b amount to scale the vector by + * @returns {vec2} out + */ +function scale(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + return out; +} + +/** + * Adds two vec2's after scaling the second operand by a scalar value + * + * @param {vec2} out the receiving vector + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @param {Number} scale the amount to scale b by before adding + * @returns {vec2} out + */ +function scaleAndAdd(out, a, b, scale) { + out[0] = a[0] + b[0] * scale; + out[1] = a[1] + b[1] * scale; + return out; +} + +/** + * Calculates the euclidian distance between two vec2's + * + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @returns {Number} distance between a and b + */ +function distance(a, b) { + var x = b[0] - a[0], + y = b[1] - a[1]; + return Math.sqrt(x * x + y * y); +} + +/** + * Calculates the squared euclidian distance between two vec2's + * + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @returns {Number} squared distance between a and b + */ +function squaredDistance(a, b) { + var x = b[0] - a[0], + y = b[1] - a[1]; + return x * x + y * y; +} + +/** + * Calculates the length of a vec2 + * + * @param {vec2} a vector to calculate length of + * @returns {Number} length of a + */ +function length(a) { + var x = a[0], + y = a[1]; + return Math.sqrt(x * x + y * y); +} + +/** + * Calculates the squared length of a vec2 + * + * @param {vec2} a vector to calculate squared length of + * @returns {Number} squared length of a + */ +function squaredLength(a) { + var x = a[0], + y = a[1]; + return x * x + y * y; +} + +/** + * Negates the components of a vec2 + * + * @param {vec2} out the receiving vector + * @param {vec2} a vector to negate + * @returns {vec2} out + */ +function negate(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + return out; +} + +/** + * Returns the inverse of the components of a vec2 + * + * @param {vec2} out the receiving vector + * @param {vec2} a vector to invert + * @returns {vec2} out + */ +function inverse(out, a) { + out[0] = 1.0 / a[0]; + out[1] = 1.0 / a[1]; + return out; +} + +/** + * Normalize a vec2 + * + * @param {vec2} out the receiving vector + * @param {vec2} a vector to normalize + * @returns {vec2} out + */ +function normalize(out, a) { + var x = a[0], + y = a[1]; + var len = x * x + y * y; + if (len > 0) { + //TODO: evaluate use of glm_invsqrt here? + len = 1 / Math.sqrt(len); + out[0] = a[0] * len; + out[1] = a[1] * len; + } + return out; +} + +/** + * Calculates the dot product of two vec2's + * + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @returns {Number} dot product of a and b + */ +function dot(a, b) { + return a[0] * b[0] + a[1] * b[1]; +} + +/** + * Computes the cross product of two vec2's + * Note that the cross product must by definition produce a 3D vector + * + * @param {vec3} out the receiving vector + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @returns {vec3} out + */ +function cross(out, a, b) { + var z = a[0] * b[1] - a[1] * b[0]; + out[0] = out[1] = 0; + out[2] = z; + return out; +} + +/** + * Performs a linear interpolation between two vec2's + * + * @param {vec2} out the receiving vector + * @param {vec2} a the first operand + * @param {vec2} b the second operand + * @param {Number} t interpolation amount, in the range [0-1], between the two inputs + * @returns {vec2} out + */ +function lerp(out, a, b, t) { + var ax = a[0], + ay = a[1]; + out[0] = ax + t * (b[0] - ax); + out[1] = ay + t * (b[1] - ay); + return out; +} + +/** + * Generates a random vector with the given scale + * + * @param {vec2} out the receiving vector + * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned + * @returns {vec2} out + */ +function random(out, scale) { + scale = scale || 1.0; + var r = _common_js__WEBPACK_IMPORTED_MODULE_0__["RANDOM"]() * 2.0 * Math.PI; + out[0] = Math.cos(r) * scale; + out[1] = Math.sin(r) * scale; + return out; +} + +/** + * Transforms the vec2 with a mat2 + * + * @param {vec2} out the receiving vector + * @param {vec2} a the vector to transform + * @param {mat2} m matrix to transform with + * @returns {vec2} out + */ +function transformMat2(out, a, m) { + var x = a[0], + y = a[1]; + out[0] = m[0] * x + m[2] * y; + out[1] = m[1] * x + m[3] * y; + return out; +} + +/** + * Transforms the vec2 with a mat2d + * + * @param {vec2} out the receiving vector + * @param {vec2} a the vector to transform + * @param {mat2d} m matrix to transform with + * @returns {vec2} out + */ +function transformMat2d(out, a, m) { + var x = a[0], + y = a[1]; + out[0] = m[0] * x + m[2] * y + m[4]; + out[1] = m[1] * x + m[3] * y + m[5]; + return out; +} + +/** + * Transforms the vec2 with a mat3 + * 3rd vector component is implicitly '1' + * + * @param {vec2} out the receiving vector + * @param {vec2} a the vector to transform + * @param {mat3} m matrix to transform with + * @returns {vec2} out + */ +function transformMat3(out, a, m) { + var x = a[0], + y = a[1]; + out[0] = m[0] * x + m[3] * y + m[6]; + out[1] = m[1] * x + m[4] * y + m[7]; + return out; +} + +/** + * Transforms the vec2 with a mat4 + * 3rd vector component is implicitly '0' + * 4th vector component is implicitly '1' + * + * @param {vec2} out the receiving vector + * @param {vec2} a the vector to transform + * @param {mat4} m matrix to transform with + * @returns {vec2} out + */ +function transformMat4(out, a, m) { + var x = a[0]; + var y = a[1]; + out[0] = m[0] * x + m[4] * y + m[12]; + out[1] = m[1] * x + m[5] * y + m[13]; + return out; +} + +/** + * Rotate a 2D vector + * @param {vec2} out The receiving vec2 + * @param {vec2} a The vec2 point to rotate + * @param {vec2} b The origin of the rotation + * @param {Number} c The angle of rotation + * @returns {vec2} out + */ +function rotate(out, a, b, c) { + //Translate point to the origin + var p0 = a[0] - b[0], + p1 = a[1] - b[1], + sinC = Math.sin(c), + cosC = Math.cos(c); + + //perform rotation and translate to correct position + out[0] = p0 * cosC - p1 * sinC + b[0]; + out[1] = p0 * sinC + p1 * cosC + b[1]; + + return out; +} + +/** + * Get the angle between two 2D vectors + * @param {vec2} a The first operand + * @param {vec2} b The second operand + * @returns {Number} The angle in radians + */ +function angle(a, b) { + var x1 = a[0], + y1 = a[1], + x2 = b[0], + y2 = b[1]; + + var len1 = x1 * x1 + y1 * y1; + if (len1 > 0) { + //TODO: evaluate use of glm_invsqrt here? + len1 = 1 / Math.sqrt(len1); + } + + var len2 = x2 * x2 + y2 * y2; + if (len2 > 0) { + //TODO: evaluate use of glm_invsqrt here? + len2 = 1 / Math.sqrt(len2); + } + + var cosine = (x1 * x2 + y1 * y2) * len1 * len2; + + if (cosine > 1.0) { + return 0; + } else if (cosine < -1.0) { + return Math.PI; + } else { + return Math.acos(cosine); + } +} + +/** + * Returns a string representation of a vector + * + * @param {vec2} a vector to represent as a string + * @returns {String} string representation of the vector + */ +function str(a) { + return 'vec2(' + a[0] + ', ' + a[1] + ')'; +} + +/** + * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===) + * + * @param {vec2} a The first vector. + * @param {vec2} b The second vector. + * @returns {Boolean} True if the vectors are equal, false otherwise. + */ +function exactEquals(a, b) { + return a[0] === b[0] && a[1] === b[1]; +} + +/** + * Returns whether or not the vectors have approximately the same elements in the same position. + * + * @param {vec2} a The first vector. + * @param {vec2} b The second vector. + * @returns {Boolean} True if the vectors are equal, false otherwise. + */ +function equals(a, b) { + var a0 = a[0], + a1 = a[1]; + var b0 = b[0], + b1 = b[1]; + return Math.abs(a0 - b0) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a1), Math.abs(b1)); +} + +/** + * Alias for {@link vec2.length} + * @function + */ +var len = length; + +/** + * Alias for {@link vec2.subtract} + * @function + */ +var sub = subtract; + +/** + * Alias for {@link vec2.multiply} + * @function + */ +var mul = multiply; + +/** + * Alias for {@link vec2.divide} + * @function + */ +var div = divide; + +/** + * Alias for {@link vec2.distance} + * @function + */ +var dist = distance; + +/** + * Alias for {@link vec2.squaredDistance} + * @function + */ +var sqrDist = squaredDistance; + +/** + * Alias for {@link vec2.squaredLength} + * @function + */ +var sqrLen = squaredLength; + +/** + * Perform some operation over an array of vec2s. + * + * @param {Array} a the array of vectors to iterate over + * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed + * @param {Number} offset Number of elements to skip at the beginning of the array + * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array + * @param {Function} fn Function to call for each vector in the array + * @param {Object} [arg] additional argument to pass to fn + * @returns {Array} a + * @function + */ +var forEach = function () { + var vec = create(); + + return function (a, stride, offset, count, fn, arg) { + var i = void 0, + l = void 0; + if (!stride) { + stride = 2; + } + + if (!offset) { + offset = 0; + } + + if (count) { + l = Math.min(count * stride + offset, a.length); + } else { + l = a.length; + } + + for (i = offset; i < l; i += stride) { + vec[0] = a[i];vec[1] = a[i + 1]; + fn(vec, vec, arg); + a[i] = vec[0];a[i + 1] = vec[1]; + } + + return a; + }; +}(); + +/***/ }), + +/***/ "./node_modules/gl-matrix/lib/gl-matrix/vec3.js": +/*!******************************************************!*\ + !*** ./node_modules/gl-matrix/lib/gl-matrix/vec3.js ***! + \******************************************************/ +/*! exports provided: create, clone, length, fromValues, copy, set, add, subtract, multiply, divide, ceil, floor, min, max, round, scale, scaleAndAdd, distance, squaredDistance, squaredLength, negate, inverse, normalize, dot, cross, lerp, hermite, bezier, random, transformMat4, transformMat3, transformQuat, rotateX, rotateY, rotateZ, angle, str, exactEquals, equals, sub, mul, div, dist, sqrDist, len, sqrLen, forEach */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "create", function() { return create; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clone", function() { return clone; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "length", function() { return length; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromValues", function() { return fromValues; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copy", function() { return copy; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "set", function() { return set; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "add", function() { return add; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "subtract", function() { return subtract; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiply", function() { return multiply; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "divide", function() { return divide; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ceil", function() { return ceil; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "floor", function() { return floor; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "min", function() { return min; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "max", function() { return max; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "round", function() { return round; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scale", function() { return scale; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scaleAndAdd", function() { return scaleAndAdd; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "distance", function() { return distance; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "squaredDistance", function() { return squaredDistance; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "squaredLength", function() { return squaredLength; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "negate", function() { return negate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "inverse", function() { return inverse; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "normalize", function() { return normalize; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dot", function() { return dot; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "cross", function() { return cross; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lerp", function() { return lerp; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "hermite", function() { return hermite; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "bezier", function() { return bezier; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "random", function() { return random; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformMat4", function() { return transformMat4; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformMat3", function() { return transformMat3; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformQuat", function() { return transformQuat; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateX", function() { return rotateX; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateY", function() { return rotateY; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "rotateZ", function() { return rotateZ; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "angle", function() { return angle; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "str", function() { return str; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "exactEquals", function() { return exactEquals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equals", function() { return equals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sub", function() { return sub; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mul", function() { return mul; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "div", function() { return div; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dist", function() { return dist; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqrDist", function() { return sqrDist; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "len", function() { return len; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqrLen", function() { return sqrLen; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "forEach", function() { return forEach; }); +/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common.js */ "./node_modules/gl-matrix/lib/gl-matrix/common.js"); + + +/** + * 3 Dimensional Vector + * @module vec3 + */ + +/** + * Creates a new, empty vec3 + * + * @returns {vec3} a new 3D vector + */ +function create() { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](3); + if (_common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"] != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + } + return out; +} + +/** + * Creates a new vec3 initialized with values from an existing vector + * + * @param {vec3} a vector to clone + * @returns {vec3} a new 3D vector + */ +function clone(a) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](3); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + return out; +} + +/** + * Calculates the length of a vec3 + * + * @param {vec3} a vector to calculate length of + * @returns {Number} length of a + */ +function length(a) { + var x = a[0]; + var y = a[1]; + var z = a[2]; + return Math.sqrt(x * x + y * y + z * z); +} + +/** + * Creates a new vec3 initialized with the given values + * + * @param {Number} x X component + * @param {Number} y Y component + * @param {Number} z Z component + * @returns {vec3} a new 3D vector + */ +function fromValues(x, y, z) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](3); + out[0] = x; + out[1] = y; + out[2] = z; + return out; +} + +/** + * Copy the values from one vec3 to another + * + * @param {vec3} out the receiving vector + * @param {vec3} a the source vector + * @returns {vec3} out + */ +function copy(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + return out; +} + +/** + * Set the components of a vec3 to the given values + * + * @param {vec3} out the receiving vector + * @param {Number} x X component + * @param {Number} y Y component + * @param {Number} z Z component + * @returns {vec3} out + */ +function set(out, x, y, z) { + out[0] = x; + out[1] = y; + out[2] = z; + return out; +} + +/** + * Adds two vec3's + * + * @param {vec3} out the receiving vector + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @returns {vec3} out + */ +function add(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + return out; +} + +/** + * Subtracts vector b from vector a + * + * @param {vec3} out the receiving vector + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @returns {vec3} out + */ +function subtract(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + return out; +} + +/** + * Multiplies two vec3's + * + * @param {vec3} out the receiving vector + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @returns {vec3} out + */ +function multiply(out, a, b) { + out[0] = a[0] * b[0]; + out[1] = a[1] * b[1]; + out[2] = a[2] * b[2]; + return out; +} + +/** + * Divides two vec3's + * + * @param {vec3} out the receiving vector + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @returns {vec3} out + */ +function divide(out, a, b) { + out[0] = a[0] / b[0]; + out[1] = a[1] / b[1]; + out[2] = a[2] / b[2]; + return out; +} + +/** + * Math.ceil the components of a vec3 + * + * @param {vec3} out the receiving vector + * @param {vec3} a vector to ceil + * @returns {vec3} out + */ +function ceil(out, a) { + out[0] = Math.ceil(a[0]); + out[1] = Math.ceil(a[1]); + out[2] = Math.ceil(a[2]); + return out; +} + +/** + * Math.floor the components of a vec3 + * + * @param {vec3} out the receiving vector + * @param {vec3} a vector to floor + * @returns {vec3} out + */ +function floor(out, a) { + out[0] = Math.floor(a[0]); + out[1] = Math.floor(a[1]); + out[2] = Math.floor(a[2]); + return out; +} + +/** + * Returns the minimum of two vec3's + * + * @param {vec3} out the receiving vector + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @returns {vec3} out + */ +function min(out, a, b) { + out[0] = Math.min(a[0], b[0]); + out[1] = Math.min(a[1], b[1]); + out[2] = Math.min(a[2], b[2]); + return out; +} + +/** + * Returns the maximum of two vec3's + * + * @param {vec3} out the receiving vector + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @returns {vec3} out + */ +function max(out, a, b) { + out[0] = Math.max(a[0], b[0]); + out[1] = Math.max(a[1], b[1]); + out[2] = Math.max(a[2], b[2]); + return out; +} + +/** + * Math.round the components of a vec3 + * + * @param {vec3} out the receiving vector + * @param {vec3} a vector to round + * @returns {vec3} out + */ +function round(out, a) { + out[0] = Math.round(a[0]); + out[1] = Math.round(a[1]); + out[2] = Math.round(a[2]); + return out; +} + +/** + * Scales a vec3 by a scalar number + * + * @param {vec3} out the receiving vector + * @param {vec3} a the vector to scale + * @param {Number} b amount to scale the vector by + * @returns {vec3} out + */ +function scale(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + return out; +} + +/** + * Adds two vec3's after scaling the second operand by a scalar value + * + * @param {vec3} out the receiving vector + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @param {Number} scale the amount to scale b by before adding + * @returns {vec3} out + */ +function scaleAndAdd(out, a, b, scale) { + out[0] = a[0] + b[0] * scale; + out[1] = a[1] + b[1] * scale; + out[2] = a[2] + b[2] * scale; + return out; +} + +/** + * Calculates the euclidian distance between two vec3's + * + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @returns {Number} distance between a and b + */ +function distance(a, b) { + var x = b[0] - a[0]; + var y = b[1] - a[1]; + var z = b[2] - a[2]; + return Math.sqrt(x * x + y * y + z * z); +} + +/** + * Calculates the squared euclidian distance between two vec3's + * + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @returns {Number} squared distance between a and b + */ +function squaredDistance(a, b) { + var x = b[0] - a[0]; + var y = b[1] - a[1]; + var z = b[2] - a[2]; + return x * x + y * y + z * z; +} + +/** + * Calculates the squared length of a vec3 + * + * @param {vec3} a vector to calculate squared length of + * @returns {Number} squared length of a + */ +function squaredLength(a) { + var x = a[0]; + var y = a[1]; + var z = a[2]; + return x * x + y * y + z * z; +} + +/** + * Negates the components of a vec3 + * + * @param {vec3} out the receiving vector + * @param {vec3} a vector to negate + * @returns {vec3} out + */ +function negate(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + out[2] = -a[2]; + return out; +} + +/** + * Returns the inverse of the components of a vec3 + * + * @param {vec3} out the receiving vector + * @param {vec3} a vector to invert + * @returns {vec3} out + */ +function inverse(out, a) { + out[0] = 1.0 / a[0]; + out[1] = 1.0 / a[1]; + out[2] = 1.0 / a[2]; + return out; +} + +/** + * Normalize a vec3 + * + * @param {vec3} out the receiving vector + * @param {vec3} a vector to normalize + * @returns {vec3} out + */ +function normalize(out, a) { + var x = a[0]; + var y = a[1]; + var z = a[2]; + var len = x * x + y * y + z * z; + if (len > 0) { + //TODO: evaluate use of glm_invsqrt here? + len = 1 / Math.sqrt(len); + out[0] = a[0] * len; + out[1] = a[1] * len; + out[2] = a[2] * len; + } + return out; +} + +/** + * Calculates the dot product of two vec3's + * + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @returns {Number} dot product of a and b + */ +function dot(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2]; +} + +/** + * Computes the cross product of two vec3's + * + * @param {vec3} out the receiving vector + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @returns {vec3} out + */ +function cross(out, a, b) { + var ax = a[0], + ay = a[1], + az = a[2]; + var bx = b[0], + by = b[1], + bz = b[2]; + + out[0] = ay * bz - az * by; + out[1] = az * bx - ax * bz; + out[2] = ax * by - ay * bx; + return out; +} + +/** + * Performs a linear interpolation between two vec3's + * + * @param {vec3} out the receiving vector + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @param {Number} t interpolation amount, in the range [0-1], between the two inputs + * @returns {vec3} out + */ +function lerp(out, a, b, t) { + var ax = a[0]; + var ay = a[1]; + var az = a[2]; + out[0] = ax + t * (b[0] - ax); + out[1] = ay + t * (b[1] - ay); + out[2] = az + t * (b[2] - az); + return out; +} + +/** + * Performs a hermite interpolation with two control points + * + * @param {vec3} out the receiving vector + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @param {vec3} c the third operand + * @param {vec3} d the fourth operand + * @param {Number} t interpolation amount, in the range [0-1], between the two inputs + * @returns {vec3} out + */ +function hermite(out, a, b, c, d, t) { + var factorTimes2 = t * t; + var factor1 = factorTimes2 * (2 * t - 3) + 1; + var factor2 = factorTimes2 * (t - 2) + t; + var factor3 = factorTimes2 * (t - 1); + var factor4 = factorTimes2 * (3 - 2 * t); + + out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4; + out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4; + out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4; + + return out; +} + +/** + * Performs a bezier interpolation with two control points + * + * @param {vec3} out the receiving vector + * @param {vec3} a the first operand + * @param {vec3} b the second operand + * @param {vec3} c the third operand + * @param {vec3} d the fourth operand + * @param {Number} t interpolation amount, in the range [0-1], between the two inputs + * @returns {vec3} out + */ +function bezier(out, a, b, c, d, t) { + var inverseFactor = 1 - t; + var inverseFactorTimesTwo = inverseFactor * inverseFactor; + var factorTimes2 = t * t; + var factor1 = inverseFactorTimesTwo * inverseFactor; + var factor2 = 3 * t * inverseFactorTimesTwo; + var factor3 = 3 * factorTimes2 * inverseFactor; + var factor4 = factorTimes2 * t; + + out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4; + out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4; + out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4; + + return out; +} + +/** + * Generates a random vector with the given scale + * + * @param {vec3} out the receiving vector + * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned + * @returns {vec3} out + */ +function random(out, scale) { + scale = scale || 1.0; + + var r = _common_js__WEBPACK_IMPORTED_MODULE_0__["RANDOM"]() * 2.0 * Math.PI; + var z = _common_js__WEBPACK_IMPORTED_MODULE_0__["RANDOM"]() * 2.0 - 1.0; + var zScale = Math.sqrt(1.0 - z * z) * scale; + + out[0] = Math.cos(r) * zScale; + out[1] = Math.sin(r) * zScale; + out[2] = z * scale; + return out; +} + +/** + * Transforms the vec3 with a mat4. + * 4th vector component is implicitly '1' + * + * @param {vec3} out the receiving vector + * @param {vec3} a the vector to transform + * @param {mat4} m matrix to transform with + * @returns {vec3} out + */ +function transformMat4(out, a, m) { + var x = a[0], + y = a[1], + z = a[2]; + var w = m[3] * x + m[7] * y + m[11] * z + m[15]; + w = w || 1.0; + out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w; + out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w; + out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w; + return out; +} + +/** + * Transforms the vec3 with a mat3. + * + * @param {vec3} out the receiving vector + * @param {vec3} a the vector to transform + * @param {mat3} m the 3x3 matrix to transform with + * @returns {vec3} out + */ +function transformMat3(out, a, m) { + var x = a[0], + y = a[1], + z = a[2]; + out[0] = x * m[0] + y * m[3] + z * m[6]; + out[1] = x * m[1] + y * m[4] + z * m[7]; + out[2] = x * m[2] + y * m[5] + z * m[8]; + return out; +} + +/** + * Transforms the vec3 with a quat + * Can also be used for dual quaternions. (Multiply it with the real part) + * + * @param {vec3} out the receiving vector + * @param {vec3} a the vector to transform + * @param {quat} q quaternion to transform with + * @returns {vec3} out + */ +function transformQuat(out, a, q) { + // benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed + var qx = q[0], + qy = q[1], + qz = q[2], + qw = q[3]; + var x = a[0], + y = a[1], + z = a[2]; + // var qvec = [qx, qy, qz]; + // var uv = vec3.cross([], qvec, a); + var uvx = qy * z - qz * y, + uvy = qz * x - qx * z, + uvz = qx * y - qy * x; + // var uuv = vec3.cross([], qvec, uv); + var uuvx = qy * uvz - qz * uvy, + uuvy = qz * uvx - qx * uvz, + uuvz = qx * uvy - qy * uvx; + // vec3.scale(uv, uv, 2 * w); + var w2 = qw * 2; + uvx *= w2; + uvy *= w2; + uvz *= w2; + // vec3.scale(uuv, uuv, 2); + uuvx *= 2; + uuvy *= 2; + uuvz *= 2; + // return vec3.add(out, a, vec3.add(out, uv, uuv)); + out[0] = x + uvx + uuvx; + out[1] = y + uvy + uuvy; + out[2] = z + uvz + uuvz; + return out; +} + +/** + * Rotate a 3D vector around the x-axis + * @param {vec3} out The receiving vec3 + * @param {vec3} a The vec3 point to rotate + * @param {vec3} b The origin of the rotation + * @param {Number} c The angle of rotation + * @returns {vec3} out + */ +function rotateX(out, a, b, c) { + var p = [], + r = []; + //Translate point to the origin + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + + //perform rotation + r[0] = p[0]; + r[1] = p[1] * Math.cos(c) - p[2] * Math.sin(c); + r[2] = p[1] * Math.sin(c) + p[2] * Math.cos(c); + + //translate to correct position + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + + return out; +} + +/** + * Rotate a 3D vector around the y-axis + * @param {vec3} out The receiving vec3 + * @param {vec3} a The vec3 point to rotate + * @param {vec3} b The origin of the rotation + * @param {Number} c The angle of rotation + * @returns {vec3} out + */ +function rotateY(out, a, b, c) { + var p = [], + r = []; + //Translate point to the origin + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + + //perform rotation + r[0] = p[2] * Math.sin(c) + p[0] * Math.cos(c); + r[1] = p[1]; + r[2] = p[2] * Math.cos(c) - p[0] * Math.sin(c); + + //translate to correct position + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + + return out; +} + +/** + * Rotate a 3D vector around the z-axis + * @param {vec3} out The receiving vec3 + * @param {vec3} a The vec3 point to rotate + * @param {vec3} b The origin of the rotation + * @param {Number} c The angle of rotation + * @returns {vec3} out + */ +function rotateZ(out, a, b, c) { + var p = [], + r = []; + //Translate point to the origin + p[0] = a[0] - b[0]; + p[1] = a[1] - b[1]; + p[2] = a[2] - b[2]; + + //perform rotation + r[0] = p[0] * Math.cos(c) - p[1] * Math.sin(c); + r[1] = p[0] * Math.sin(c) + p[1] * Math.cos(c); + r[2] = p[2]; + + //translate to correct position + out[0] = r[0] + b[0]; + out[1] = r[1] + b[1]; + out[2] = r[2] + b[2]; + + return out; +} + +/** + * Get the angle between two 3D vectors + * @param {vec3} a The first operand + * @param {vec3} b The second operand + * @returns {Number} The angle in radians + */ +function angle(a, b) { + var tempA = fromValues(a[0], a[1], a[2]); + var tempB = fromValues(b[0], b[1], b[2]); + + normalize(tempA, tempA); + normalize(tempB, tempB); + + var cosine = dot(tempA, tempB); + + if (cosine > 1.0) { + return 0; + } else if (cosine < -1.0) { + return Math.PI; + } else { + return Math.acos(cosine); + } +} + +/** + * Returns a string representation of a vector + * + * @param {vec3} a vector to represent as a string + * @returns {String} string representation of the vector + */ +function str(a) { + return 'vec3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ')'; +} + +/** + * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===) + * + * @param {vec3} a The first vector. + * @param {vec3} b The second vector. + * @returns {Boolean} True if the vectors are equal, false otherwise. + */ +function exactEquals(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2]; +} + +/** + * Returns whether or not the vectors have approximately the same elements in the same position. + * + * @param {vec3} a The first vector. + * @param {vec3} b The second vector. + * @returns {Boolean} True if the vectors are equal, false otherwise. + */ +function equals(a, b) { + var a0 = a[0], + a1 = a[1], + a2 = a[2]; + var b0 = b[0], + b1 = b[1], + b2 = b[2]; + return Math.abs(a0 - b0) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a2), Math.abs(b2)); +} + +/** + * Alias for {@link vec3.subtract} + * @function + */ +var sub = subtract; + +/** + * Alias for {@link vec3.multiply} + * @function + */ +var mul = multiply; + +/** + * Alias for {@link vec3.divide} + * @function + */ +var div = divide; + +/** + * Alias for {@link vec3.distance} + * @function + */ +var dist = distance; + +/** + * Alias for {@link vec3.squaredDistance} + * @function + */ +var sqrDist = squaredDistance; + +/** + * Alias for {@link vec3.length} + * @function + */ +var len = length; + +/** + * Alias for {@link vec3.squaredLength} + * @function + */ +var sqrLen = squaredLength; + +/** + * Perform some operation over an array of vec3s. + * + * @param {Array} a the array of vectors to iterate over + * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed + * @param {Number} offset Number of elements to skip at the beginning of the array + * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array + * @param {Function} fn Function to call for each vector in the array + * @param {Object} [arg] additional argument to pass to fn + * @returns {Array} a + * @function + */ +var forEach = function () { + var vec = create(); + + return function (a, stride, offset, count, fn, arg) { + var i = void 0, + l = void 0; + if (!stride) { + stride = 3; + } + + if (!offset) { + offset = 0; + } + + if (count) { + l = Math.min(count * stride + offset, a.length); + } else { + l = a.length; + } + + for (i = offset; i < l; i += stride) { + vec[0] = a[i];vec[1] = a[i + 1];vec[2] = a[i + 2]; + fn(vec, vec, arg); + a[i] = vec[0];a[i + 1] = vec[1];a[i + 2] = vec[2]; + } + + return a; + }; +}(); + +/***/ }), + +/***/ "./node_modules/gl-matrix/lib/gl-matrix/vec4.js": +/*!******************************************************!*\ + !*** ./node_modules/gl-matrix/lib/gl-matrix/vec4.js ***! + \******************************************************/ +/*! exports provided: create, clone, fromValues, copy, set, add, subtract, multiply, divide, ceil, floor, min, max, round, scale, scaleAndAdd, distance, squaredDistance, length, squaredLength, negate, inverse, normalize, dot, lerp, random, transformMat4, transformQuat, str, exactEquals, equals, sub, mul, div, dist, sqrDist, len, sqrLen, forEach */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "create", function() { return create; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "clone", function() { return clone; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "fromValues", function() { return fromValues; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "copy", function() { return copy; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "set", function() { return set; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "add", function() { return add; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "subtract", function() { return subtract; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "multiply", function() { return multiply; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "divide", function() { return divide; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ceil", function() { return ceil; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "floor", function() { return floor; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "min", function() { return min; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "max", function() { return max; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "round", function() { return round; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scale", function() { return scale; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "scaleAndAdd", function() { return scaleAndAdd; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "distance", function() { return distance; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "squaredDistance", function() { return squaredDistance; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "length", function() { return length; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "squaredLength", function() { return squaredLength; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "negate", function() { return negate; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "inverse", function() { return inverse; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "normalize", function() { return normalize; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dot", function() { return dot; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "lerp", function() { return lerp; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "random", function() { return random; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformMat4", function() { return transformMat4; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "transformQuat", function() { return transformQuat; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "str", function() { return str; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "exactEquals", function() { return exactEquals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "equals", function() { return equals; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sub", function() { return sub; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "mul", function() { return mul; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "div", function() { return div; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "dist", function() { return dist; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqrDist", function() { return sqrDist; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "len", function() { return len; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "sqrLen", function() { return sqrLen; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "forEach", function() { return forEach; }); +/* harmony import */ var _common_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./common.js */ "./node_modules/gl-matrix/lib/gl-matrix/common.js"); + + +/** + * 4 Dimensional Vector + * @module vec4 + */ + +/** + * Creates a new, empty vec4 + * + * @returns {vec4} a new 4D vector + */ +function create() { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](4); + if (_common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"] != Float32Array) { + out[0] = 0; + out[1] = 0; + out[2] = 0; + out[3] = 0; + } + return out; +} + +/** + * Creates a new vec4 initialized with values from an existing vector + * + * @param {vec4} a vector to clone + * @returns {vec4} a new 4D vector + */ +function clone(a) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](4); + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + return out; +} + +/** + * Creates a new vec4 initialized with the given values + * + * @param {Number} x X component + * @param {Number} y Y component + * @param {Number} z Z component + * @param {Number} w W component + * @returns {vec4} a new 4D vector + */ +function fromValues(x, y, z, w) { + var out = new _common_js__WEBPACK_IMPORTED_MODULE_0__["ARRAY_TYPE"](4); + out[0] = x; + out[1] = y; + out[2] = z; + out[3] = w; + return out; +} + +/** + * Copy the values from one vec4 to another + * + * @param {vec4} out the receiving vector + * @param {vec4} a the source vector + * @returns {vec4} out + */ +function copy(out, a) { + out[0] = a[0]; + out[1] = a[1]; + out[2] = a[2]; + out[3] = a[3]; + return out; +} + +/** + * Set the components of a vec4 to the given values + * + * @param {vec4} out the receiving vector + * @param {Number} x X component + * @param {Number} y Y component + * @param {Number} z Z component + * @param {Number} w W component + * @returns {vec4} out + */ +function set(out, x, y, z, w) { + out[0] = x; + out[1] = y; + out[2] = z; + out[3] = w; + return out; +} + +/** + * Adds two vec4's + * + * @param {vec4} out the receiving vector + * @param {vec4} a the first operand + * @param {vec4} b the second operand + * @returns {vec4} out + */ +function add(out, a, b) { + out[0] = a[0] + b[0]; + out[1] = a[1] + b[1]; + out[2] = a[2] + b[2]; + out[3] = a[3] + b[3]; + return out; +} + +/** + * Subtracts vector b from vector a + * + * @param {vec4} out the receiving vector + * @param {vec4} a the first operand + * @param {vec4} b the second operand + * @returns {vec4} out + */ +function subtract(out, a, b) { + out[0] = a[0] - b[0]; + out[1] = a[1] - b[1]; + out[2] = a[2] - b[2]; + out[3] = a[3] - b[3]; + return out; +} + +/** + * Multiplies two vec4's + * + * @param {vec4} out the receiving vector + * @param {vec4} a the first operand + * @param {vec4} b the second operand + * @returns {vec4} out + */ +function multiply(out, a, b) { + out[0] = a[0] * b[0]; + out[1] = a[1] * b[1]; + out[2] = a[2] * b[2]; + out[3] = a[3] * b[3]; + return out; +} + +/** + * Divides two vec4's + * + * @param {vec4} out the receiving vector + * @param {vec4} a the first operand + * @param {vec4} b the second operand + * @returns {vec4} out + */ +function divide(out, a, b) { + out[0] = a[0] / b[0]; + out[1] = a[1] / b[1]; + out[2] = a[2] / b[2]; + out[3] = a[3] / b[3]; + return out; +} + +/** + * Math.ceil the components of a vec4 + * + * @param {vec4} out the receiving vector + * @param {vec4} a vector to ceil + * @returns {vec4} out + */ +function ceil(out, a) { + out[0] = Math.ceil(a[0]); + out[1] = Math.ceil(a[1]); + out[2] = Math.ceil(a[2]); + out[3] = Math.ceil(a[3]); + return out; +} + +/** + * Math.floor the components of a vec4 + * + * @param {vec4} out the receiving vector + * @param {vec4} a vector to floor + * @returns {vec4} out + */ +function floor(out, a) { + out[0] = Math.floor(a[0]); + out[1] = Math.floor(a[1]); + out[2] = Math.floor(a[2]); + out[3] = Math.floor(a[3]); + return out; +} + +/** + * Returns the minimum of two vec4's + * + * @param {vec4} out the receiving vector + * @param {vec4} a the first operand + * @param {vec4} b the second operand + * @returns {vec4} out + */ +function min(out, a, b) { + out[0] = Math.min(a[0], b[0]); + out[1] = Math.min(a[1], b[1]); + out[2] = Math.min(a[2], b[2]); + out[3] = Math.min(a[3], b[3]); + return out; +} + +/** + * Returns the maximum of two vec4's + * + * @param {vec4} out the receiving vector + * @param {vec4} a the first operand + * @param {vec4} b the second operand + * @returns {vec4} out + */ +function max(out, a, b) { + out[0] = Math.max(a[0], b[0]); + out[1] = Math.max(a[1], b[1]); + out[2] = Math.max(a[2], b[2]); + out[3] = Math.max(a[3], b[3]); + return out; +} + +/** + * Math.round the components of a vec4 + * + * @param {vec4} out the receiving vector + * @param {vec4} a vector to round + * @returns {vec4} out + */ +function round(out, a) { + out[0] = Math.round(a[0]); + out[1] = Math.round(a[1]); + out[2] = Math.round(a[2]); + out[3] = Math.round(a[3]); + return out; +} + +/** + * Scales a vec4 by a scalar number + * + * @param {vec4} out the receiving vector + * @param {vec4} a the vector to scale + * @param {Number} b amount to scale the vector by + * @returns {vec4} out + */ +function scale(out, a, b) { + out[0] = a[0] * b; + out[1] = a[1] * b; + out[2] = a[2] * b; + out[3] = a[3] * b; + return out; +} + +/** + * Adds two vec4's after scaling the second operand by a scalar value + * + * @param {vec4} out the receiving vector + * @param {vec4} a the first operand + * @param {vec4} b the second operand + * @param {Number} scale the amount to scale b by before adding + * @returns {vec4} out + */ +function scaleAndAdd(out, a, b, scale) { + out[0] = a[0] + b[0] * scale; + out[1] = a[1] + b[1] * scale; + out[2] = a[2] + b[2] * scale; + out[3] = a[3] + b[3] * scale; + return out; +} + +/** + * Calculates the euclidian distance between two vec4's + * + * @param {vec4} a the first operand + * @param {vec4} b the second operand + * @returns {Number} distance between a and b + */ +function distance(a, b) { + var x = b[0] - a[0]; + var y = b[1] - a[1]; + var z = b[2] - a[2]; + var w = b[3] - a[3]; + return Math.sqrt(x * x + y * y + z * z + w * w); +} + +/** + * Calculates the squared euclidian distance between two vec4's + * + * @param {vec4} a the first operand + * @param {vec4} b the second operand + * @returns {Number} squared distance between a and b + */ +function squaredDistance(a, b) { + var x = b[0] - a[0]; + var y = b[1] - a[1]; + var z = b[2] - a[2]; + var w = b[3] - a[3]; + return x * x + y * y + z * z + w * w; +} + +/** + * Calculates the length of a vec4 + * + * @param {vec4} a vector to calculate length of + * @returns {Number} length of a + */ +function length(a) { + var x = a[0]; + var y = a[1]; + var z = a[2]; + var w = a[3]; + return Math.sqrt(x * x + y * y + z * z + w * w); +} + +/** + * Calculates the squared length of a vec4 + * + * @param {vec4} a vector to calculate squared length of + * @returns {Number} squared length of a + */ +function squaredLength(a) { + var x = a[0]; + var y = a[1]; + var z = a[2]; + var w = a[3]; + return x * x + y * y + z * z + w * w; +} + +/** + * Negates the components of a vec4 + * + * @param {vec4} out the receiving vector + * @param {vec4} a vector to negate + * @returns {vec4} out + */ +function negate(out, a) { + out[0] = -a[0]; + out[1] = -a[1]; + out[2] = -a[2]; + out[3] = -a[3]; + return out; +} + +/** + * Returns the inverse of the components of a vec4 + * + * @param {vec4} out the receiving vector + * @param {vec4} a vector to invert + * @returns {vec4} out + */ +function inverse(out, a) { + out[0] = 1.0 / a[0]; + out[1] = 1.0 / a[1]; + out[2] = 1.0 / a[2]; + out[3] = 1.0 / a[3]; + return out; +} + +/** + * Normalize a vec4 + * + * @param {vec4} out the receiving vector + * @param {vec4} a vector to normalize + * @returns {vec4} out + */ +function normalize(out, a) { + var x = a[0]; + var y = a[1]; + var z = a[2]; + var w = a[3]; + var len = x * x + y * y + z * z + w * w; + if (len > 0) { + len = 1 / Math.sqrt(len); + out[0] = x * len; + out[1] = y * len; + out[2] = z * len; + out[3] = w * len; + } + return out; +} + +/** + * Calculates the dot product of two vec4's + * + * @param {vec4} a the first operand + * @param {vec4} b the second operand + * @returns {Number} dot product of a and b + */ +function dot(a, b) { + return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3]; +} + +/** + * Performs a linear interpolation between two vec4's + * + * @param {vec4} out the receiving vector + * @param {vec4} a the first operand + * @param {vec4} b the second operand + * @param {Number} t interpolation amount, in the range [0-1], between the two inputs + * @returns {vec4} out + */ +function lerp(out, a, b, t) { + var ax = a[0]; + var ay = a[1]; + var az = a[2]; + var aw = a[3]; + out[0] = ax + t * (b[0] - ax); + out[1] = ay + t * (b[1] - ay); + out[2] = az + t * (b[2] - az); + out[3] = aw + t * (b[3] - aw); + return out; +} + +/** + * Generates a random vector with the given scale + * + * @param {vec4} out the receiving vector + * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned + * @returns {vec4} out + */ +function random(out, scale) { + scale = scale || 1.0; + + // Marsaglia, George. Choosing a Point from the Surface of a + // Sphere. Ann. Math. Statist. 43 (1972), no. 2, 645--646. + // http://projecteuclid.org/euclid.aoms/1177692644; + var v1, v2, v3, v4; + var s1, s2; + do { + v1 = _common_js__WEBPACK_IMPORTED_MODULE_0__["RANDOM"]() * 2 - 1; + v2 = _common_js__WEBPACK_IMPORTED_MODULE_0__["RANDOM"]() * 2 - 1; + s1 = v1 * v1 + v2 * v2; + } while (s1 >= 1); + do { + v3 = _common_js__WEBPACK_IMPORTED_MODULE_0__["RANDOM"]() * 2 - 1; + v4 = _common_js__WEBPACK_IMPORTED_MODULE_0__["RANDOM"]() * 2 - 1; + s2 = v3 * v3 + v4 * v4; + } while (s2 >= 1); + + var d = Math.sqrt((1 - s1) / s2); + out[0] = scale * v1; + out[1] = scale * v2; + out[2] = scale * v3 * d; + out[3] = scale * v4 * d; + return out; +} + +/** + * Transforms the vec4 with a mat4. + * + * @param {vec4} out the receiving vector + * @param {vec4} a the vector to transform + * @param {mat4} m matrix to transform with + * @returns {vec4} out + */ +function transformMat4(out, a, m) { + var x = a[0], + y = a[1], + z = a[2], + w = a[3]; + out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w; + out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w; + out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w; + out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w; + return out; +} + +/** + * Transforms the vec4 with a quat + * + * @param {vec4} out the receiving vector + * @param {vec4} a the vector to transform + * @param {quat} q quaternion to transform with + * @returns {vec4} out + */ +function transformQuat(out, a, q) { + var x = a[0], + y = a[1], + z = a[2]; + var qx = q[0], + qy = q[1], + qz = q[2], + qw = q[3]; + + // calculate quat * vec + var ix = qw * x + qy * z - qz * y; + var iy = qw * y + qz * x - qx * z; + var iz = qw * z + qx * y - qy * x; + var iw = -qx * x - qy * y - qz * z; + + // calculate result * inverse quat + out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy; + out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz; + out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx; + out[3] = a[3]; + return out; +} + +/** + * Returns a string representation of a vector + * + * @param {vec4} a vector to represent as a string + * @returns {String} string representation of the vector + */ +function str(a) { + return 'vec4(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')'; +} + +/** + * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===) + * + * @param {vec4} a The first vector. + * @param {vec4} b The second vector. + * @returns {Boolean} True if the vectors are equal, false otherwise. + */ +function exactEquals(a, b) { + return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3]; +} + +/** + * Returns whether or not the vectors have approximately the same elements in the same position. + * + * @param {vec4} a The first vector. + * @param {vec4} b The second vector. + * @returns {Boolean} True if the vectors are equal, false otherwise. + */ +function equals(a, b) { + var a0 = a[0], + a1 = a[1], + a2 = a[2], + a3 = a[3]; + var b0 = b[0], + b1 = b[1], + b2 = b[2], + b3 = b[3]; + return Math.abs(a0 - b0) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= _common_js__WEBPACK_IMPORTED_MODULE_0__["EPSILON"] * Math.max(1.0, Math.abs(a3), Math.abs(b3)); +} + +/** + * Alias for {@link vec4.subtract} + * @function + */ +var sub = subtract; + +/** + * Alias for {@link vec4.multiply} + * @function + */ +var mul = multiply; + +/** + * Alias for {@link vec4.divide} + * @function + */ +var div = divide; + +/** + * Alias for {@link vec4.distance} + * @function + */ +var dist = distance; + +/** + * Alias for {@link vec4.squaredDistance} + * @function + */ +var sqrDist = squaredDistance; + +/** + * Alias for {@link vec4.length} + * @function + */ +var len = length; + +/** + * Alias for {@link vec4.squaredLength} + * @function + */ +var sqrLen = squaredLength; + +/** + * Perform some operation over an array of vec4s. + * + * @param {Array} a the array of vectors to iterate over + * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed + * @param {Number} offset Number of elements to skip at the beginning of the array + * @param {Number} count Number of vec4s to iterate over. If 0 iterates over entire array + * @param {Function} fn Function to call for each vector in the array + * @param {Object} [arg] additional argument to pass to fn + * @returns {Array} a + * @function + */ +var forEach = function () { + var vec = create(); + + return function (a, stride, offset, count, fn, arg) { + var i = void 0, + l = void 0; + if (!stride) { + stride = 4; + } + + if (!offset) { + offset = 0; + } + + if (count) { + l = Math.min(count * stride + offset, a.length); + } else { + l = a.length; + } + + for (i = offset; i < l; i += stride) { + vec[0] = a[i];vec[1] = a[i + 1];vec[2] = a[i + 2];vec[3] = a[i + 3]; + fn(vec, vec, arg); + a[i] = vec[0];a[i + 1] = vec[1];a[i + 2] = vec[2];a[i + 3] = vec[3]; + } + + return a; + }; +}(); + +/***/ }), + +/***/ "./source/Actor.js": +/*!*************************!*\ + !*** ./source/Actor.js ***! + \*************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Actor; }); +/* harmony import */ var _Dispatcher_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Dispatcher.js */ "./source/Dispatcher.js"); + + +class Actor extends _Dispatcher_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + + this._Artboards = []; + this._NestedActorAssets = []; + this._Atlases = []; + } + + getArtboard(name) { + return this._Artboards.find(artboard => artboard._Name === name); + } + + dispose(graphics) { + for (const artboard of this._Artboards) { + artboard.dispose(graphics); + } + } + + initialize(graphics) { + for (let nested of this._NestedActorAssets) { + if (nested.actor) { + nested.actor.initialize(graphics); + } + } + for (const artboard of this._Artboards) { + artboard.initialize(graphics); + } + } + + makeInstance() { + return this._Artboards.length && this._Artboards[0].makeInstance() || null; + } + + get animations() { + return this._Artboards.length && this._Artboards[0]._Animations || null; + } +} + +/***/ }), + +/***/ "./source/ActorArtboard.js": +/*!*********************************!*\ + !*** ./source/ActorArtboard.js ***! + \*********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorArtboard; }); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); +/* harmony import */ var _ActorShape_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ActorShape.js */ "./source/ActorShape.js"); +/* harmony import */ var _ActorImage_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ActorImage.js */ "./source/ActorImage.js"); +/* harmony import */ var _NestedActorNode_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./NestedActorNode.js */ "./source/NestedActorNode.js"); +/* harmony import */ var _AnimationInstance_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./AnimationInstance.js */ "./source/AnimationInstance.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + + + + + +class ActorArtboard { + constructor(actor) { + this._Actor = actor; + this._Components = []; + this._Nodes = []; + this._RootNode = new _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"](); + this._RootNode._Name = "Root"; + this._Components.push(this._RootNode); + this._Drawables = []; + this._Animations = []; + this._IsImageSortDirty = false; + this._Order = null; + this._IsDirty = false; + this._DirtDepth = 0; + + this._Name = "Artboard"; + this._Origin = gl_matrix__WEBPACK_IMPORTED_MODULE_5__["vec2"].create(); + this._Translation = gl_matrix__WEBPACK_IMPORTED_MODULE_5__["vec2"].create(); + this._Color = gl_matrix__WEBPACK_IMPORTED_MODULE_5__["vec4"].create(); + this._ClipsContents = true; + this._Width = 0; + this._Height = 0; + } + + get name() { + return this._Name; + } + + get width() { + return this._Width; + } + + get height() { + return this._Height; + } + + get origin() { + return this._Name; + } + + get translation() { + return this._Translation; + } + + get color() { + return this._Color; + } + + get clipsContents() { + return this._ClipsContents; + } + + get root() { + return this._RootNode; + } + + get actor() { + return this._Actor; + } + + addDependency(a, b) { + // "a" depends on "b" + let dependents = b._Dependents; + if (!dependents) { + dependents = b._Dependents = []; + } + if (dependents.indexOf(a) !== -1) { + return false; + } + dependents.push(a); + return true; + } + + sortDependencies() { + let perm = new Set(); + let temp = new Set(); + + let order = []; + + function visit(n) { + if (perm.has(n)) { + return true; + } + if (temp.has(n)) { + console.warn("Dependency cycle!", n); + return false; + } + + temp.add(n); + + let dependents = n._Dependents; + if (dependents) { + for (let d of dependents) { + if (!visit(d)) { + return false; + } + } + } + perm.add(n); + order.unshift(n); + + return true; + } + + if (!visit(this._RootNode)) { + // We have cyclic dependencies. + return false; + } + + for (let i = 0; i < order.length; i++) { + let component = order[i]; + component._GraphOrder = i; + component._DirtMask = 255; + } + this._Order = order; + this._IsDirty = true; + } + + addDirt(component, value, recurse) { + if ((component._DirtMask & value) === value) { + // Already marked. + return false; + } + + // Make sure dirt is set before calling anything that can set more dirt. + let dirt = component._DirtMask | value; + component._DirtMask = dirt; + + this._IsDirty = true; + + component.onDirty(dirt); + + // If the order of this component is less than the current dirt depth, update the dirt depth + // so that the update loop can break out early and re-run (something up the tree is dirty). + if (component._GraphOrder < this._DirtDepth) { + this._DirtDepth = component._GraphOrder; + } + if (!recurse) { + return true; + } + let dependents = component._Dependents; + if (dependents) { + for (let d of dependents) { + this.addDirt(d, value, recurse); + } + } + + return true; + } + + update() { + if (!this._IsDirty) { + return false; + } + + let order = this._Order; + let end = order.length; + + const maxSteps = 100; + let step = 0; + while (this._IsDirty && step < maxSteps) { + this._IsDirty = false; + // Track dirt depth here so that if something else marks dirty, we restart. + for (let i = 0; i < end; i++) { + let component = order[i]; + this._DirtDepth = i; + let d = component._DirtMask; + if (d === 0) { + continue; + } + component._DirtMask = 0; + component.update(d); + + if (this._DirtDepth < i) { + break; + } + } + step++; + } + + return true; + } + + resolveHierarchy() { + let components = this._Components; + for (let component of components) { + if (component != null) { + component._Actor = this; + component.resolveComponentIndices(components); + if (component.isNode) { + this._Nodes.push(component); + } + switch (component.constructor) { + case _NestedActorNode_js__WEBPACK_IMPORTED_MODULE_3__["default"]: + case _ActorImage_js__WEBPACK_IMPORTED_MODULE_2__["default"]: + this._Drawables.push(component); + break; + } + } + } + + for (let component of components) { + if (component != null) { + component.completeResolve(); + } + } + + this.sortDependencies(); + + this._Drawables.sort(function (a, b) { + return a._DrawOrder - b._DrawOrder; + }); + } + + dispose(graphics) { + let drawables = this._Drawables; + for (let drawable of drawables) { + drawable.dispose(this, graphics); + } + } + + advance(seconds) { + this.update(); + + let components = this._Components; + // Advance last (update graphics buffers and such). + for (let component of components) { + if (component) { + component.advance(seconds); + } + } + + if (this._IsImageSortDirty) { + this._Drawables.sort(function (a, b) { + return a._DrawOrder - b._DrawOrder; + }); + this._IsImageSortDirty = false; + } + } + + draw(graphics) { + let drawables = this._Drawables; + for (let drawable of drawables) { + drawable.draw(graphics); + } + // let nodes = this._Nodes; + // for(let node of nodes) + // { + // if(node._Name === "ctrl_look") + // { + // const ctx = graphics.ctx; + // ctx.save(); + // ctx.beginPath(); + // ctx.arc(node.worldTransform[4], node.worldTransform[5], 20.0, 0, 2*Math.PI); + // ctx.stroke(); + // ctx.restore(); + // } + // } + } + + getNode(name) { + let nodes = this._Nodes; + for (let node of nodes) { + if (node._Name === name) { + return node; + } + } + return null; + } + + get animations() { + return this._Animations; + } + + getAnimation(name) { + let animations = this._Animations; + for (let animation of animations) { + if (animation._Name === name) { + return animation; + } + } + return null; + } + + getAnimationInstance(name) { + let animation = this.getAnimation(name); + if (!animation) { + return null; + } + return new _AnimationInstance_js__WEBPACK_IMPORTED_MODULE_4__["default"](this, animation); + } + + makeInstance() { + const actorInstance = new ActorArtboard(this._Actor); + actorInstance.copy(this); + return actorInstance; + } + + artboardAABB() { + const { _Width: width, _Height: height } = this; + const min_x = -this._Origin[0] * width; + const min_y = -this._Origin[1] * height; + return new Float32Array([min_x, min_y, min_x + width, min_y + height]); + } + + computeAABB() { + let min_x = Number.MAX_VALUE; + let min_y = Number.MAX_VALUE; + let max_x = -Number.MAX_VALUE; + let max_y = -Number.MAX_VALUE; + + for (const drawable of this._Drawables) { + if (drawable.opacity < 0.01) { + continue; + } + const aabb = drawable.computeAABB(); + if (!aabb) { + continue; + } + if (aabb[0] < min_x) { + min_x = aabb[0]; + } + if (aabb[1] < min_y) { + min_y = aabb[1]; + } + if (aabb[2] > max_x) { + max_x = aabb[2]; + } + if (aabb[3] > max_y) { + max_y = aabb[3]; + } + } + + return new Float32Array([min_x, min_y, max_x, max_y]); + } + + copy(artboard) { + this._Name = artboard._Name; + this._Origin = gl_matrix__WEBPACK_IMPORTED_MODULE_5__["vec2"].clone(artboard._Origin); + this._Translation = gl_matrix__WEBPACK_IMPORTED_MODULE_5__["vec2"].clone(artboard._Translation); + this._Color = gl_matrix__WEBPACK_IMPORTED_MODULE_5__["vec4"].clone(artboard._Color); + this._ClipsContents = artboard._ClipContents; + this._Width = artboard._Width; + this._Height = artboard._Height; + + let components = artboard._Components; + this._Animations = artboard._Animations; + this._Components.length = 0; + this._Nodes.length = 0; + this._Drawables.length = 0; + + for (let component of components) { + if (!component) { + this._Components.push(null); + continue; + } + let instanceNode = component.makeInstance(this); + switch (instanceNode.constructor) { + case _ActorShape_js__WEBPACK_IMPORTED_MODULE_1__["default"]: + case _NestedActorNode_js__WEBPACK_IMPORTED_MODULE_3__["default"]: + case _ActorImage_js__WEBPACK_IMPORTED_MODULE_2__["default"]: + this._Drawables.push(instanceNode); + break; + } + if (instanceNode.isNode) { + this._Nodes.push(instanceNode); + } + this._Components.push(instanceNode); + } + this._RootNode = this._Components[0]; + + for (let i = 1; i < this._Components.length; i++) { + let component = this._Components[i]; + if (component == null) { + continue; + } + component.resolveComponentIndices(this._Components); + } + + for (let i = 1; i < this._Components.length; i++) { + let component = this._Components[i]; + if (component == null) { + continue; + } + component.completeResolve(); + } + + this.sortDependencies(); + + this._Drawables.sort(function (a, b) { + return a._DrawOrder - b._DrawOrder; + }); + } + + initialize(graphics) { + let drawables = this._Drawables; + for (let drawable of drawables) { + drawable.initialize(this, graphics); + } + } +} + +/***/ }), + +/***/ "./source/ActorAxisConstraint.js": +/*!***************************************!*\ + !*** ./source/ActorAxisConstraint.js ***! + \***************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorAxisConstraint; }); +/* harmony import */ var _ActorTargetedConstraint_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorTargetedConstraint.js */ "./source/ActorTargetedConstraint.js"); +/* harmony import */ var _TransformSpace_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./TransformSpace.js */ "./source/TransformSpace.js"); + + + +class ActorAxisConstraint extends _ActorTargetedConstraint_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + + this._CopyX = false; + this._CopyY = false; + this._ScaleX = 1; + this._ScaleY = 1; + this._EnableMinX = false; + this._MinX = 0; + this._EnableMaxX = false; + this._MaxX = 0; + this._EnableMinY = false; + this._MinY = 0; + this._EnableMaxY = false; + this._MaxY = 0; + this._Offset = false; + this._SourceSpace = _TransformSpace_js__WEBPACK_IMPORTED_MODULE_1__["default"].World; + this._DestSpace = _TransformSpace_js__WEBPACK_IMPORTED_MODULE_1__["default"].World; + this._MinMaxSpace = _TransformSpace_js__WEBPACK_IMPORTED_MODULE_1__["default"].World; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._CopyX = node._CopyX; + this._CopyY = node._CopyY; + this._ScaleX = node._ScaleX; + this._ScaleY = node._ScaleY; + this._EnableMinX = node._EnableMinX; + this._MinX = node._MinX; + this._EnableMaxX = node._EnableMaxX; + this._MaxX = node._MaxX; + this._EnableMinY = node._EnableMinY; + this._MinY = node._MinY; + this._EnableMaxY = node._EnableMaxY; + this._MaxY = node._MaxY; + this._Offset = node._Offset; + this._SourceSpace = node._SourceSpace; + this._DestSpace = node._DestSpace; + this._MinMaxSpace = node._MinMaxSpace; + } + + onDirty(dirt) { + this.markDirty(); + } +} + +/***/ }), + +/***/ "./source/ActorBone.js": +/*!*****************************!*\ + !*** ./source/ActorBone.js ***! + \*****************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorBone; }); +/* harmony import */ var _ActorBoneBase_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorBoneBase.js */ "./source/ActorBoneBase.js"); + + +class ActorBone extends _ActorBoneBase_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + + this._FirstBone = null; + } + + makeInstance(resetActor) { + const node = new ActorBone(); + node.copy(this, resetActor); + return node; + } + + completeResolve() { + super.completeResolve(); + + let children = this._Children; + for (let child of children) { + if (child instanceof ActorBone) { + this._FirstBone = child; + return; + } + } + } +} + +/***/ }), + +/***/ "./source/ActorBoneBase.js": +/*!*********************************!*\ + !*** ./source/ActorBoneBase.js ***! + \*********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorBoneBase; }); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + +class ActorBoneBase extends _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + + this._Length = 0; + } + + get tipWorldTranslation() { + const transform = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(); + transform[4] = this._Length; + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(transform, this._WorldTransform, transform); + return gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), transform[4], transform[5]); + } + + get length() { + return this._Length; + } + + set length(l) { + if (this._Length === l) { + return; + } + this._Length = l; + this.markTransformDirty(); + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._Length = node._Length; + } + + get firstBone() { + let children = this._Children; + for (let child of children) { + if (child instanceof ActorBoneBase) { + return child; + } + } + + return null; + } +} + +/***/ }), + +/***/ "./source/ActorCollider.js": +/*!*********************************!*\ + !*** ./source/ActorCollider.js ***! + \*********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorCollider; }); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); + + +class ActorCollider extends _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._IsCollisionEnabled = true; + } + + get isCollisionEnabled() { + return this._IsCollisionEnabled; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._IsCollisionEnabled = node._IsCollisionEnabled; + } +} + +/***/ }), + +/***/ "./source/ActorColliderCircle.js": +/*!***************************************!*\ + !*** ./source/ActorColliderCircle.js ***! + \***************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorColliderCircle; }); +/* harmony import */ var _ActorCollider_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorCollider.js */ "./source/ActorCollider.js"); + + +class ActorColliderCircle extends _ActorCollider_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._Radius = 0.0; + } + + get radius() { + return this._Radius; + } + + makeInstance(resetActor) { + let node = new ActorColliderCircle(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._Radius = node._Radius; + } +} + +/***/ }), + +/***/ "./source/ActorColliderLine.js": +/*!*************************************!*\ + !*** ./source/ActorColliderLine.js ***! + \*************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorColliderLine; }); +/* harmony import */ var _ActorCollider_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorCollider.js */ "./source/ActorCollider.js"); + + +class ActorColliderLine extends _ActorCollider_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._Vertices = new Float32Array(); + } + + get vertices() { + return this._Vertices; + } + + makeInstance(resetActor) { + let node = new ActorColliderLine(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._Vertices = node._Vertices; + } +} + +/***/ }), + +/***/ "./source/ActorColliderPolygon.js": +/*!****************************************!*\ + !*** ./source/ActorColliderPolygon.js ***! + \****************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorColliderPolygon; }); +/* harmony import */ var _ActorCollider_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorCollider.js */ "./source/ActorCollider.js"); + + +class ActorColliderPolygon extends _ActorCollider_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._ContourVertices = new Float32Array(); + } + + get contourVertices() { + return this._ContourVertices; + } + + makeInstance(resetActor) { + let node = new ActorColliderPolygon(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._ContourVertices = node._ContourVertices; + } +} + +/***/ }), + +/***/ "./source/ActorColliderRectangle.js": +/*!******************************************!*\ + !*** ./source/ActorColliderRectangle.js ***! + \******************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorColliderRectangle; }); +/* harmony import */ var _ActorCollider_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorCollider.js */ "./source/ActorCollider.js"); + + +class ActorColliderRectangle extends _ActorCollider_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._Width = 0.0; + this._Height = 0.0; + } + + get width() { + return this._Width; + } + + get height() { + return this._Height; + } + + makeInstance(resetActor) { + let node = new ActorColliderRectangle(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._Width = node._Width; + this._Height = node._Height; + } +} + +/***/ }), + +/***/ "./source/ActorColliderTriangle.js": +/*!*****************************************!*\ + !*** ./source/ActorColliderTriangle.js ***! + \*****************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorColliderTriangle; }); +/* harmony import */ var _ActorCollider_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorCollider.js */ "./source/ActorCollider.js"); + + +class ActorColliderTriangle extends _ActorCollider_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._Width = 0.0; + this._Height = 0.0; + } + + get width() { + return this._Width; + } + + get height() { + return this._Height; + } + + makeInstance(resetActor) { + let node = new ActorColliderTriangle(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._Width = node._Width; + this._Height = node._Height; + } +} + +/***/ }), + +/***/ "./source/ActorComponent.js": +/*!**********************************!*\ + !*** ./source/ActorComponent.js ***! + \**********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorComponent; }); +class ActorComponent { + constructor() { + this._Name = "Component"; + this._Parent = null; + this._CustomProperties = []; + this._DirtMask = 0; + this._GraphOrder = -1; + this._Dependents = null; + this._Actor = null; + this._ParentIdx = -1; + } + + get parent() { + return this._Parent; + } + + onDirty(dirt) {} + + initialize(actor, graphics) {} + + update(dirt) {} + + advance(seconds) {} + + resolveComponentIndices(components) { + if (this._ParentIdx !== -1) { + let parent = components[this._ParentIdx]; + this._Parent = parent; + if (this.isNode && parent && parent._Children) { + parent._Children.push(this); + } + if (parent) { + this._Actor.addDependency(this, parent); + } + } + } + + completeResolve() {} + + copy(component, resetActor) { + this._Name = component._Name; + this._ParentIdx = component._ParentIdx; + this._Idx = component._Idx; + this._Actor = resetActor; + } + + getCustomProperty(name) { + let props = this._CustomProperties; + for (let prop of props) { + if (prop._Name === name) { + return prop; + } + } + return null; + } +} + +/***/ }), + +/***/ "./source/ActorConstraint.js": +/*!***********************************!*\ + !*** ./source/ActorConstraint.js ***! + \***********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorConstraint; }); +/* harmony import */ var _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorComponent.js */ "./source/ActorComponent.js"); + + +class ActorConstraint extends _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + + this._IsEnabled = true; + this._Strength = 1.0; + } + + makeInstance(resetActor) { + const node = new ActorConstraint(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._IsEnabled = node._IsEnabled; + this._Strength = node._Strength; + } + + onDirty(dirt) { + this.markDirty(); + } + + markDirty() { + this.parent.markTransformDirty(); + } + + set strength(c) { + if (this._Strength != c) { + this._Strength = c; + this.markDirty(); + } + } + + get isEnabled() { + return this._IsEnabled; + } + + set isEnabled(isIt) { + if (this._IsEnabled === isIt) { + return; + } + + this._IsEnabled = isIt; + this.markDirty(); + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + if (this._Parent) { + // This works because nodes are exported in hierarchy order, so we are assured constraints get added in order as we resolve indices. + this._Parent.addConstraint(this); + } + } +} + +/***/ }), + +/***/ "./source/ActorDistanceConstraint.js": +/*!*******************************************!*\ + !*** ./source/ActorDistanceConstraint.js ***! + \*******************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorDistanceConstraint; }); +/* harmony import */ var _ActorTargetedConstraint_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorTargetedConstraint.js */ "./source/ActorTargetedConstraint.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + +const DistanceMode = { + Closer: 0, + Further: 1, + Exact: 2 +}; + +class ActorDistanceConstraint extends _ActorTargetedConstraint_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + + this._Distance = 100.0; + this._Mode = DistanceMode.Closer; + } + + makeInstance(resetActor) { + let node = new ActorDistanceConstraint(); + node.copy(this, resetActor); + return node; + } + + get distance() { + return this._Distance; + } + + set distance(distance) { + if (this._Distance === distance) { + return; + } + + this._Distance = distance; + this.markDirty(); + } + + get mode() { + return this._Mode; + } + + set mode(mode) { + if (this._Mode === mode) { + return; + } + + this._Mode = mode; + this.markDirty(); + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._Distance = node._Distance; + this._Mode = node._Mode; + } + + constrain(tip) { + let target = this._Target; + if (!target) { + return; + } + + let parent = this._Parent; + + let targetTranslation = target.worldTranslation; + let ourTranslation = parent.worldTranslation; + + let { _Strength: t, _Mode: mode, _Distance: distance } = this; + + let toTarget = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), ourTranslation, targetTranslation); + let currentDistance = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].length(toTarget); + switch (mode) { + case DistanceMode.Closer: + if (currentDistance < distance) { + return; + } + break; + case DistanceMode.Further: + if (currentDistance > distance) { + return; + } + break; + } + if (currentDistance < 0.001) { + return true; + } + + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].scale(toTarget, toTarget, 1.0 / currentDistance); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].scale(toTarget, toTarget, distance); + + let world = parent.worldTransform; + let position = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].lerp(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), ourTranslation, gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].add(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), targetTranslation, toTarget), t); + world[4] = position[0]; + world[5] = position[1]; + } +} + +/***/ }), + +/***/ "./source/ActorEllipse.js": +/*!********************************!*\ + !*** ./source/ActorEllipse.js ***! + \********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorEllipse; }); +/* harmony import */ var _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorProceduralPath.js */ "./source/ActorProceduralPath.js"); + + +class ActorEllipse extends _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + } + + resolveComponentIndices(components) { + _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__["default"].prototype.resolveComponentIndices.call(this, components); + } + + makeInstance(resetActor) { + const node = new ActorEllipse(); + node.copy(this, resetActor); + return node; + } + + getPath() { + const path = new Path2D(); + const radiusX = this._Width / 2; + const radiusY = this._Height / 2; + path.moveTo(radiusX, 0.0); + path.ellipse(0.0, 0.0, radiusX, radiusY, 0.0, 0, Math.PI * 2.0, false); + return path; + } +} + +/***/ }), + +/***/ "./source/ActorEvent.js": +/*!******************************!*\ + !*** ./source/ActorEvent.js ***! + \******************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorEvent; }); +/* harmony import */ var _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorComponent.js */ "./source/ActorComponent.js"); + + +class ActorEvent extends _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + } + + makeInstance(resetActor) { + const node = new ActorEvent(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + } +} + +/***/ }), + +/***/ "./source/ActorIKConstraint.js": +/*!*************************************!*\ + !*** ./source/ActorIKConstraint.js ***! + \*************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorIKConstraint; }); +/* harmony import */ var _ActorTargetedConstraint_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorTargetedConstraint.js */ "./source/ActorTargetedConstraint.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); +/* harmony import */ var _Decompose_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Decompose.js */ "./source/Decompose.js"); + + + + + + +const PI2 = Math.PI * 2; + +class ActorIKConstraint extends _ActorTargetedConstraint_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + + this._InvertDirection = false; + this._InfluencedBones = []; + + this._FKChain = null; + this._BoneData = null; + } + + makeInstance(resetActor) { + let node = new ActorIKConstraint(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._InvertDirection = node._InvertDirection; + this._InfluencedBones = []; + if (node._InfluencedBones) { + for (let i = 0; i < node._InfluencedBones.length; i++) { + const ib = node._InfluencedBones[i]; + if (!ib) { + continue; + } + if (ib.constructor === _ActorNode_js__WEBPACK_IMPORTED_MODULE_2__["default"]) { + this._InfluencedBones.push(ib._Idx); + } else { + this._InfluencedBones.push(ib); + } + } + } + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + + const bones = this._InfluencedBones; + if (!bones || !bones.length) { + return; + } + + for (let j = 0; j < bones.length; j++) { + let componentIndex = bones[j]; + if (componentIndex.constructor !== Number) { + componentIndex = componentIndex._Idx; + } + const bone = components[componentIndex]; + bones[j] = bone; + + // Mark peer constraints, N.B. that we're not adding it to the parent bone + // as we're constraining it anyway. + if (bone !== this.parent) { + bone.addPeerConstraint(this); + } + } + } + + markDirty() { + for (const item of this._FKChain) { + item.bone.markTransformDirty(); + } + } + + completeResolve() { + super.completeResolve(); + + const bones = this._InfluencedBones; + if (!bones || !bones.length) { + return; + } + + // Initialize solver. + const start = bones[0]; + let end = bones[bones.length - 1]; + const chain = this._FKChain = []; + const boneData = this._BoneData = []; + while (end && end !== start._Parent) { + chain.unshift({ bone: end, ikAngle: 0, transformComponents: new Float32Array(6), in: false }); + end = end._Parent; + } + + const allIn = chain.length < 3; + for (let i = 0; i < chain.length; i++) { + let fk = chain[i]; + fk.idx = i; + fk.in = allIn; + } + + for (const bone of bones) { + const fk = chain.find(fk => fk.bone === bone); + if (!fk) { + console.warn("Bone not in chain?", fk, bone); + continue; + } + boneData.push(fk); + } + + if (!allIn) { + for (let i = 0; i < boneData.length - 1; i++) { + const fk = boneData[i]; + fk.in = true; + chain[fk.idx + 1].in = true; + } + } + + // Mark dependencies. + const actor = this._Actor; + for (const bone of bones) { + // Don't mark dependency on parent as ActorComponent already does this. + if (bone === this.parent) { + continue; + } + + actor.addDependency(this, bone); + } + if (this._Target) { + actor.addDependency(this, this._Target); + } + + // N.B. Dependency on target already set in ActorTargetedConstrain. + + // All the first level children of the influenced bones should depend on the final bone. + if (chain.length) { + const tip = chain[chain.length - 1]; + for (const fk of chain) { + if (fk === tip) { + continue; + } + const bone = fk.bone; + const children = bone._Children; + for (const child of children) { + if (!(child instanceof _ActorNode_js__WEBPACK_IMPORTED_MODULE_2__["default"])) { + continue; + } + const item = chain.find(item => item.bone === child); + if (item) { + // we are in the FK chain. + continue; + } + actor.addDependency(child, tip.bone); + } + } + } + } + + constrain(tip) { + const target = this._Target; + if (target) { + const wt = target.worldTransform; + this.solve(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), wt[4], wt[5]), this._Strength); + } + } + + solve1(fk1, worldTargetTranslation) { + const iworld = fk1.parentWorldInverse; + const pA = fk1.bone.worldTranslation; + const pBT = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].copy(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), worldTargetTranslation); + + // To target in worldspace + const toTarget = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pBT, pA); + // Note this is directional, hence not transformMat2d + const toTargetLocal = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), toTarget, iworld); + const r = Math.atan2(toTargetLocal[1], toTargetLocal[0]); + + constrainRotation(fk1, r); + fk1.ikAngle = r; + + return true; + } + + solve2(fk1, fk2, worldTargetTranslation) { + const invertDirection = this._InvertDirection; + const b1 = fk1.bone; + const b2 = fk2.bone; + const chain = this._FKChain; + const firstChild = chain[fk1.idx + 1]; + + const iworld = fk1.parentWorldInverse; + + let pA = b1.worldTranslation; + let pC = firstChild.bone.worldTranslation; + let pB = b2.tipWorldTranslation; + let pBT = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].copy(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), worldTargetTranslation); + + pA = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(pA, pA, iworld); + pC = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(pC, pC, iworld); + pB = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(pB, pB, iworld); + pBT = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(pBT, pBT, iworld); + + // http://mathworld.wolfram.com/LawofCosines.html + const av = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pB, pC); + const a = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].length(av); + + const bv = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pC, pA); + const b = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].length(bv); + + const cv = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pBT, pA); + const c = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].length(cv); + + const A = Math.acos(Math.max(-1, Math.min(1, (-a * a + b * b + c * c) / (2 * b * c)))); + const C = Math.acos(Math.max(-1, Math.min(1, (a * a + b * b - c * c) / (2 * a * b)))); + + let r1, r2; + if (b2.parent != b1) { + const secondChild = chain[fk1.idx + 2]; + + const iworld = secondChild.parentWorldInverse; + + pC = firstChild.bone.worldTranslation; + pB = b2.tipWorldTranslation; + + const av = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pB, pC); + const avLocal = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), av, iworld); + const angleCorrection = -Math.atan2(avLocal[1], avLocal[0]); + + if (invertDirection) { + r1 = Math.atan2(cv[1], cv[0]) - A; + r2 = -C + Math.PI + angleCorrection; + } else { + r1 = A + Math.atan2(cv[1], cv[0]); + r2 = C - Math.PI + angleCorrection; + } + } else if (invertDirection) { + r1 = Math.atan2(cv[1], cv[0]) - A; + r2 = -C + Math.PI; + } else { + r1 = A + Math.atan2(cv[1], cv[0]); + r2 = C - Math.PI; + } + + constrainRotation(fk1, r1); + constrainRotation(firstChild, r2); + if (firstChild !== fk2) { + const bone = fk2.bone; + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(bone.worldTransform, bone.parent.worldTransform, bone.transform); + } + + // Simple storage, need this for interpolation. + fk1.ikAngle = r1; + firstChild.ikAngle = r2; + + return true; + } + + solve(worldTargetTranslation, strength) { + const bones = this._BoneData; + if (!bones.length) { + return; + } + + // Decompose the chain. + const fkChain = this._FKChain; + for (let i = 0; i < fkChain.length; i++) { + const fk = fkChain[i]; + const parentWorld = fk.bone.parent.worldTransform; + const parentWorldInverse = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(), parentWorld); + const local = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(fk.bone.transform, parentWorldInverse, fk.bone.worldTransform); + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_3__["Decompose"])(local, fk.transformComponents); + fk.parentWorldInverse = parentWorldInverse; + } + + if (bones.length === 1) { + this.solve1(bones[0], worldTargetTranslation); + } else if (bones.length == 2) { + this.solve2(bones[0], bones[1], worldTargetTranslation); + } else { + const tip = bones[bones.length - 1]; + for (let i = 0; i < bones.length - 1; i++) { + const fk = bones[i]; + this.solve2(fk, tip, worldTargetTranslation); + for (let j = fk.idx + 1; j < fkChain.length - 1; j++) { + const fk = fkChain[j]; + const parentWorld = fk.bone.parent.worldTransform; + fk.parentWorldInverse = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(), parentWorld); + } + } + } + + // At the end, mix the FK angle with the IK angle by strength + const m = strength; + if (m != 1.0) { + for (const fk of fkChain) { + if (!fk.in) { + const bone = fk.bone; + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(bone.worldTransform, bone.parent.worldTransform, bone.transform); + continue; + } + const fromAngle = fk.transformComponents[4] % PI2; + const toAngle = fk.ikAngle % PI2; + let diff = toAngle - fromAngle; + if (diff > Math.PI) { + diff -= PI2; + } else if (diff < -Math.PI) { + diff += PI2; + } + const angle = fromAngle + diff * m; + constrainRotation(fk, angle); + } + } + } +} + +function constrainRotation(fk, rotation) { + const parentWorld = fk.bone.parent.worldTransform; + + const transform = fk.bone.transform; + const c = fk.transformComponents; + + if (rotation === 0) { + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].identity(transform); + } else { + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].fromRotation(transform, rotation); + } + // Translate + transform[4] = c[0]; + transform[5] = c[1]; + // Scale + const scaleX = c[2]; + const scaleY = c[3]; + transform[0] *= scaleX; + transform[1] *= scaleX; + transform[2] *= scaleY; + transform[3] *= scaleY; + // Skew + const skew = c[5]; + if (skew !== 0) { + transform[2] = transform[0] * skew + transform[2]; + transform[3] = transform[1] * skew + transform[3]; + } + + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(fk.bone.worldTransform, parentWorld, transform); +} + +/***/ }), + +/***/ "./source/ActorIKTarget.js": +/*!*********************************!*\ + !*** ./source/ActorIKTarget.js ***! + \*********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorIKTarget; }); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); +/* harmony import */ var _ActorBone_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ActorBone.js */ "./source/ActorBone.js"); +/* harmony import */ var _ActorIKConstraint_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ActorIKConstraint.js */ "./source/ActorIKConstraint.js"); + + + + +class ActorIKTarget extends _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + + this._Order = 0; + this._Strength = 0; + this._InvertDirection = false; + this._InfluencedBones = null; + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + + const constraint = new _ActorIKConstraint_js__WEBPACK_IMPORTED_MODULE_2__["default"](); + this._Constraint = constraint; + + const bones = this._InfluencedBones; + constraint._Actor = this._Actor; + constraint._TargetIdx = this._Idx; + constraint._ParentIdx = bones ? bones[bones.length - 1] : -1; + constraint._InvertDirection = this._InvertDirection; + constraint._InfluencedBones = bones; + constraint._Strength = this._Strength; + constraint._IsEnabled = true; + constraint.resolveComponentIndices(components); + } + + completeResolve() { + super.completeResolve(); + + this._Constraint.completeResolve(); + } + + get strength() { + if (this._Constraint) { + return this._Constraint.strength; + } + return 0; + } + + set strength(s) { + if (this._Constraint) { + this._Constraint.strength = s; + } + } + + makeInstance(resetActor) { + const node = new ActorIKTarget(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._Order = node._Order; + this._Strength = node._Strength; + this._InvertDirection = node._InvertDirection; + this._InfluencedBones = []; + if (node._InfluencedBones) { + for (let i = 0; i < node._InfluencedBones.length; i++) { + const ib = node._InfluencedBones[i]; + if (!ib) { + continue; + } + if (ib.constructor === _ActorBone_js__WEBPACK_IMPORTED_MODULE_1__["default"]) { + this._InfluencedBones.push(ib._Idx); + } else { + this._InfluencedBones.push(ib); + } + } + } + } +} + +/***/ }), + +/***/ "./source/ActorImage.js": +/*!******************************!*\ + !*** ./source/ActorImage.js ***! + \******************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorImage; }); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + +const White = [1.0, 1.0, 1.0, 1.0]; +class ActorImage extends _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._DrawOrder = 0; + this._BlendMode = ActorImage.BlendModes.Normal; + this._AtlasIndex = -1; + this._NumVertices = 0; + this._HasVertexDeformAnimation = false; + this._AnimationDeformedVertices = null; + this._Vertices = null; + this._Triangles = null; + this._ConnectedBones = null; + this._BoneMatrices = null; + this._IsInstance = false; + this._IsHidden = false; + + this._VertexBuffer = null; + this._IndexBuffer = null; + this._DeformVertexBuffer = null; + + this._SequenceFrames = null; + this._SequenceFrame = 0; + this._SequenceUVs = null; + this._SequenceUVBuffer = null; + } + + get isHidden() { + return this._IsHidden; + } + + set isHidden(hidden) { + this._IsHidden = hidden; + } + + get hasVertexDeformAnimation() { + return this._HasVertexDeformAnimation; + } + + set hasVertexDeformAnimation(value) { + this._HasVertexDeformAnimation = value; + this._AnimationDeformedVertices = new Float32Array(this._NumVertices * 2); + + // Copy the deform verts from the rig verts. + let writeIdx = 0; + let readIdx = 0; + const readStride = this._VertexStride; + for (let i = 0; i < this._NumVertices; i++) { + this._AnimationDeformedVertices[writeIdx++] = this._Vertices[readIdx]; + this._AnimationDeformedVertices[writeIdx++] = this._Vertices[readIdx + 1]; + readIdx += readStride; + } + } + + computeAABB() { + const worldVertices = this.computeWorldVertices(); + const nv = worldVertices.length / 2; + let min_x = Number.MAX_VALUE; + let min_y = Number.MAX_VALUE; + let max_x = -Number.MAX_VALUE; + let max_y = -Number.MAX_VALUE; + + let readIdx = 0; + for (let i = 0; i < nv; i++) { + let x = worldVertices[readIdx++]; + let y = worldVertices[readIdx++]; + if (x < min_x) { + min_x = x; + } + if (y < min_y) { + min_y = y; + } + if (x > max_x) { + max_x = x; + } + if (y > max_y) { + max_y = y; + } + } + + return new Float32Array([min_x, min_y, max_x, max_y]); + } + + computeWorldVertices() { + const vertices = this._HasVertexDeformAnimation ? this._AnimationDeformedVertices : this._Vertices; + + const stride = this._HasVertexDeformAnimation ? 2 : this._VertexStride; + let readIdx = 0; + let writeIdx = 0; + + const world = this._WorldTransform; + + const nv = this._NumVertices; + const deformed = new Float32Array(nv * 2); + + if (this._ConnectedBones) { + let weightIndex = 4; + const weightStride = 12; + const weightVertices = this._Vertices; + + const bones = this._BoneMatrices; + + for (let i = 0; i < nv; i++) { + let x = vertices[readIdx]; + let y = vertices[readIdx + 1]; + + readIdx += stride; + + const px = world[0] * x + world[2] * y + world[4]; + const py = world[1] * x + world[3] * y + world[5]; + + const fm = new Float32Array(6); + for (let wi = 0; wi < 4; wi++) { + const boneIndex = weightVertices[weightIndex + wi]; + const weight = weightVertices[weightIndex + wi + 4]; + + const bb = boneIndex * 6; + + for (let j = 0; j < 6; j++) { + fm[j] += bones[bb + j] * weight; + } + } + + weightIndex += weightStride; + + x = fm[0] * px + fm[2] * py + fm[4]; + y = fm[1] * px + fm[3] * py + fm[5]; + + deformed[writeIdx++] = x; + deformed[writeIdx++] = y; + } + } else { + for (let i = 0; i < nv; i++) { + const x = vertices[readIdx]; + const y = vertices[readIdx + 1]; + + deformed[writeIdx++] = world[0] * x + world[2] * y + world[4]; + deformed[writeIdx++] = world[1] * x + world[3] * y + world[5]; + readIdx += stride; + } + } + + return deformed; + } + + dispose(actor, graphics) { + if (this._IsInstance) { + if (this._DeformVertexBuffer) { + this._DeformVertexBuffer.dispose(); + this._DeformVertexBuffer = null; + } + } else { + if (this._VertexBuffer) { + this._VertexBuffer.dispose(); + this._VertexBuffer = null; + } + if (this._IndexBuffer) { + this._IndexBuffer.dispose(); + this._IndexBuffer = null; + } + if (this._SequenceUVBuffer) { + this._SequenceUVBuffer.dispose(); + this._SequenceUVBuffer = null; + } + } + } + + initialize(actor, graphics) { + if (!this._IsInstance) { + if (this._VertexBuffer) { + this._VertexBuffer.dispose(); + } + if (this._VertexBuffer) { + this._VertexBuffer.dispose(); + } + if (this._SequenceUVBuffer) { + this._SequenceUVBuffer.dispose(); + } + + this._VertexBuffer = graphics.makeVertexBuffer(this._Vertices); + this._IndexBuffer = graphics.makeIndexBuffer(this._Triangles); + + if (this._SequenceUVs) { + this._SequenceUVBuffer = graphics.makeVertexBuffer(this._SequenceUVs); + } + } else if (this._HasVertexDeformAnimation) { + if (this._DeformVertexBuffer) { + this._DeformVertexBuffer.dispose(); + } + this._DeformVertexBuffer = graphics.makeVertexBuffer(this._AnimationDeformedVertices); + } + + if (this._IsInstance && this._ConnectedBones) { + const bt = this._BoneMatrices = new Float32Array((this._ConnectedBones.length + 1) * 6); + + // First bone transform is always identity. + bt[0] = 1; + bt[1] = 0; + bt[2] = 0; + bt[3] = 1; + bt[4] = 0; + bt[5] = 0; + } + // Keep vertices for world calculations. + // delete this._Vertices; + delete this._Triangles; + delete this._SequenceUVs; + this._Texture = actor._Atlases[this._AtlasIndex]; + } + + advance() { + if (this._HasVertexDeformAnimation && this._VerticesDirty) { + this._DeformVertexBuffer.update(this._AnimationDeformedVertices); + this._VerticesDirty = false; + } + + if (this._ConnectedBones) { + const bt = this._BoneMatrices; + let bidx = 6; // Start after first identity. + + const mat = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(); + + for (let i = 0; i < this._ConnectedBones.length; i++) { + const cb = this._ConnectedBones[i]; + if (!cb.node) { + bt[bidx++] = 1; + bt[bidx++] = 0; + bt[bidx++] = 0; + bt[bidx++] = 1; + bt[bidx++] = 0; + bt[bidx++] = 0; + continue; + } + const wt = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(mat, cb.node._WorldTransform, cb.ibind); + + bt[bidx++] = wt[0]; + bt[bidx++] = wt[1]; + bt[bidx++] = wt[2]; + bt[bidx++] = wt[3]; + bt[bidx++] = wt[4]; + bt[bidx++] = wt[5]; + } + } + } + + draw(graphics) { + if (this._RenderCollapsed || this._IsHidden) { + return; + } + + const t = this._WorldTransform; + switch (this._BlendMode) { + case ActorImage.BlendModes.Normal: + graphics.enableBlending(); + break; + case ActorImage.BlendModes.Multiply: + graphics.enableMultiplyBlending(); + break; + case ActorImage.BlendModes.Screen: + graphics.enableScreenBlending(); + break; + case ActorImage.BlendModes.Additive: + graphics.enableAdditiveBlending(); + break; + + } + + const uvBuffer = this._SequenceUVBuffer || null; + let uvOffset; + if (this._SequenceUVBuffer) { + const numFrames = this._SequenceFrames.length; + let frame = this._SequenceFrame % numFrames; + if (uvOffset < 0) { + frame += numFrames; + } + uvOffset = this._SequenceFrames[frame].offset; + } + + graphics.prep(this._Texture, White, this._RenderOpacity, t, this._VertexBuffer, this._ConnectedBones ? this._BoneMatrices : null, this._DeformVertexBuffer, uvBuffer, uvOffset); + graphics.draw(this._IndexBuffer); + } + + resolveComponentIndices(components) { + _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"].prototype.resolveComponentIndices.call(this, components); + + if (this._ConnectedBones) { + for (let j = 0; j < this._ConnectedBones.length; j++) { + const cb = this._ConnectedBones[j]; + cb.node = components[cb.componentIndex]; + if (cb.node) { + cb.node._IsConnectedToImage = true; + } + } + } + } + + makeInstance(resetActor) { + const node = new ActorImage(); + node._IsInstance = true; + ActorImage.prototype.copy.call(node, this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._DrawOrder = node._DrawOrder; + this._BlendMode = node._BlendMode; + this._AtlasIndex = node._AtlasIndex; + this._NumVertices = node._NumVertices; + this._VertexStride = node._VertexStride; + this._HasVertexDeformAnimation = node._HasVertexDeformAnimation; + this._Vertices = node._Vertices; + this._Triangles = node._Triangles; + // N.B. actor.initialize must've been called before instancing. + this._VertexBuffer = node._VertexBuffer; + this._IndexBuffer = node._IndexBuffer; + this._SequenceUVBuffer = node._SequenceUVBuffer; + this._SequenceFrames = node._SequenceFrames; + if (node._HasVertexDeformAnimation) { + const deformedVertexLength = this._NumVertices * 2; + this._AnimationDeformedVertices = new Float32Array(deformedVertexLength); + for (let i = 0; i < deformedVertexLength; i++) { + this._AnimationDeformedVertices[i] = node._AnimationDeformedVertices[i]; + } + } + + if (node._ConnectedBones) { + this._ConnectedBones = []; + for (const cb of node._ConnectedBones) { + // Copy all props except for the actual node reference which will update in our resolve. + this._ConnectedBones.push({ + componentIndex: cb.componentIndex, + bind: cb.bind, + ibind: cb.ibind + }); + } + } + } +} + +ActorImage.BlendModes = { + "Normal": 0, + "Multiply": 1, + "Screen": 2, + "Additive": 3 +}; + +/***/ }), + +/***/ "./source/ActorJellyBone.js": +/*!**********************************!*\ + !*** ./source/ActorJellyBone.js ***! + \**********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorJellyBone; }); +/* harmony import */ var _ActorBoneBase_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorBoneBase.js */ "./source/ActorBoneBase.js"); + + +class ActorJellyBone extends _ActorBoneBase_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + makeInstance(resetActor) { + const node = new ActorJellyBone(); + node.copy(this, resetActor); + return node; + } +} + +/***/ }), + +/***/ "./source/ActorLoader.js": +/*!*******************************!*\ + !*** ./source/ActorLoader.js ***! + \*******************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorLoader; }); +/* harmony import */ var _Animation_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Animation.js */ "./source/Animation.js"); +/* harmony import */ var _Readers_BinaryReader_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./Readers/BinaryReader.js */ "./source/Readers/BinaryReader.js"); +/* harmony import */ var _Readers_JSONReader_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Readers/JSONReader.js */ "./source/Readers/JSONReader.js"); +/* harmony import */ var _Actor_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Actor.js */ "./source/Actor.js"); +/* harmony import */ var _ActorEvent_js__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! ./ActorEvent.js */ "./source/ActorEvent.js"); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_5__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); +/* harmony import */ var _ActorNodeSolo_js__WEBPACK_IMPORTED_MODULE_6__ = __webpack_require__(/*! ./ActorNodeSolo.js */ "./source/ActorNodeSolo.js"); +/* harmony import */ var _ActorBone_js__WEBPACK_IMPORTED_MODULE_7__ = __webpack_require__(/*! ./ActorBone.js */ "./source/ActorBone.js"); +/* harmony import */ var _ActorEllipse_js__WEBPACK_IMPORTED_MODULE_8__ = __webpack_require__(/*! ./ActorEllipse.js */ "./source/ActorEllipse.js"); +/* harmony import */ var _ActorPolygon_js__WEBPACK_IMPORTED_MODULE_9__ = __webpack_require__(/*! ./ActorPolygon.js */ "./source/ActorPolygon.js"); +/* harmony import */ var _ActorRectangle_js__WEBPACK_IMPORTED_MODULE_10__ = __webpack_require__(/*! ./ActorRectangle.js */ "./source/ActorRectangle.js"); +/* harmony import */ var _ActorStar_js__WEBPACK_IMPORTED_MODULE_11__ = __webpack_require__(/*! ./ActorStar.js */ "./source/ActorStar.js"); +/* harmony import */ var _ActorTriangle_js__WEBPACK_IMPORTED_MODULE_12__ = __webpack_require__(/*! ./ActorTriangle.js */ "./source/ActorTriangle.js"); +/* harmony import */ var _ActorJellyBone_js__WEBPACK_IMPORTED_MODULE_13__ = __webpack_require__(/*! ./ActorJellyBone.js */ "./source/ActorJellyBone.js"); +/* harmony import */ var _JellyComponent_js__WEBPACK_IMPORTED_MODULE_14__ = __webpack_require__(/*! ./JellyComponent.js */ "./source/JellyComponent.js"); +/* harmony import */ var _ActorRootBone_js__WEBPACK_IMPORTED_MODULE_15__ = __webpack_require__(/*! ./ActorRootBone.js */ "./source/ActorRootBone.js"); +/* harmony import */ var _ActorImage_js__WEBPACK_IMPORTED_MODULE_16__ = __webpack_require__(/*! ./ActorImage.js */ "./source/ActorImage.js"); +/* harmony import */ var _ActorIKTarget_js__WEBPACK_IMPORTED_MODULE_17__ = __webpack_require__(/*! ./ActorIKTarget.js */ "./source/ActorIKTarget.js"); +/* harmony import */ var _ActorColliderRectangle_js__WEBPACK_IMPORTED_MODULE_18__ = __webpack_require__(/*! ./ActorColliderRectangle.js */ "./source/ActorColliderRectangle.js"); +/* harmony import */ var _ActorColliderTriangle_js__WEBPACK_IMPORTED_MODULE_19__ = __webpack_require__(/*! ./ActorColliderTriangle.js */ "./source/ActorColliderTriangle.js"); +/* harmony import */ var _ActorColliderCircle_js__WEBPACK_IMPORTED_MODULE_20__ = __webpack_require__(/*! ./ActorColliderCircle.js */ "./source/ActorColliderCircle.js"); +/* harmony import */ var _ActorColliderPolygon_js__WEBPACK_IMPORTED_MODULE_21__ = __webpack_require__(/*! ./ActorColliderPolygon.js */ "./source/ActorColliderPolygon.js"); +/* harmony import */ var _ActorColliderLine_js__WEBPACK_IMPORTED_MODULE_22__ = __webpack_require__(/*! ./ActorColliderLine.js */ "./source/ActorColliderLine.js"); +/* harmony import */ var _NestedActorNode_js__WEBPACK_IMPORTED_MODULE_23__ = __webpack_require__(/*! ./NestedActorNode.js */ "./source/NestedActorNode.js"); +/* harmony import */ var _CustomProperty_js__WEBPACK_IMPORTED_MODULE_24__ = __webpack_require__(/*! ./CustomProperty.js */ "./source/CustomProperty.js"); +/* harmony import */ var _AnimatedComponent_js__WEBPACK_IMPORTED_MODULE_25__ = __webpack_require__(/*! ./AnimatedComponent.js */ "./source/AnimatedComponent.js"); +/* harmony import */ var _AnimatedProperty_js__WEBPACK_IMPORTED_MODULE_26__ = __webpack_require__(/*! ./AnimatedProperty.js */ "./source/AnimatedProperty.js"); +/* harmony import */ var _NestedActorAsset_js__WEBPACK_IMPORTED_MODULE_27__ = __webpack_require__(/*! ./NestedActorAsset.js */ "./source/NestedActorAsset.js"); +/* harmony import */ var _ActorIKConstraint_js__WEBPACK_IMPORTED_MODULE_28__ = __webpack_require__(/*! ./ActorIKConstraint.js */ "./source/ActorIKConstraint.js"); +/* harmony import */ var _ActorDistanceConstraint_js__WEBPACK_IMPORTED_MODULE_29__ = __webpack_require__(/*! ./ActorDistanceConstraint.js */ "./source/ActorDistanceConstraint.js"); +/* harmony import */ var _ActorTransformConstraint_js__WEBPACK_IMPORTED_MODULE_30__ = __webpack_require__(/*! ./ActorTransformConstraint.js */ "./source/ActorTransformConstraint.js"); +/* harmony import */ var _ActorTranslationConstraint_js__WEBPACK_IMPORTED_MODULE_31__ = __webpack_require__(/*! ./ActorTranslationConstraint.js */ "./source/ActorTranslationConstraint.js"); +/* harmony import */ var _ActorScaleConstraint_js__WEBPACK_IMPORTED_MODULE_32__ = __webpack_require__(/*! ./ActorScaleConstraint.js */ "./source/ActorScaleConstraint.js"); +/* harmony import */ var _ActorRotationConstraint_js__WEBPACK_IMPORTED_MODULE_33__ = __webpack_require__(/*! ./ActorRotationConstraint.js */ "./source/ActorRotationConstraint.js"); +/* harmony import */ var _ActorShape_js__WEBPACK_IMPORTED_MODULE_34__ = __webpack_require__(/*! ./ActorShape.js */ "./source/ActorShape.js"); +/* harmony import */ var _ActorPath_js__WEBPACK_IMPORTED_MODULE_35__ = __webpack_require__(/*! ./ActorPath.js */ "./source/ActorPath.js"); +/* harmony import */ var _ActorSkin_js__WEBPACK_IMPORTED_MODULE_36__ = __webpack_require__(/*! ./ActorSkin.js */ "./source/ActorSkin.js"); +/* harmony import */ var _ActorArtboard_js__WEBPACK_IMPORTED_MODULE_37__ = __webpack_require__(/*! ./ActorArtboard.js */ "./source/ActorArtboard.js"); +/* harmony import */ var _ColorComponent_js__WEBPACK_IMPORTED_MODULE_38__ = __webpack_require__(/*! ./ColorComponent.js */ "./source/ColorComponent.js"); +/* harmony import */ var _PathPoint_js__WEBPACK_IMPORTED_MODULE_39__ = __webpack_require__(/*! ./PathPoint.js */ "./source/PathPoint.js"); +/* harmony import */ var _KeyFrame_js__WEBPACK_IMPORTED_MODULE_40__ = __webpack_require__(/*! ./KeyFrame.js */ "./source/KeyFrame.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_41__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); +/* harmony import */ var _Interpolation_js__WEBPACK_IMPORTED_MODULE_42__ = __webpack_require__(/*! ./Interpolation.js */ "./source/Interpolation.js"); +/* harmony import */ var _Block_js__WEBPACK_IMPORTED_MODULE_43__ = __webpack_require__(/*! ./Block.js */ "./source/Block.js"); + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + +const _BlockTypes = _Block_js__WEBPACK_IMPORTED_MODULE_43__["default"].Types; +const _AnimatedPropertyTypes = _AnimatedProperty_js__WEBPACK_IMPORTED_MODULE_26__["default"].Types; + +const _Readers = { + "bin": { + stream: _Readers_BinaryReader_js__WEBPACK_IMPORTED_MODULE_1__["default"], + container: Uint8Array, + extension: ".nma" + }, + "json": { + stream: _Readers_JSONReader_js__WEBPACK_IMPORTED_MODULE_2__["default"], + container: Object, + extension: "nmj" + } +}; + +let _ReadAtlasesBlock = null; + +function _ReadNextBlock(reader, error, block) { + if (reader.isEOF()) { + return null; + } + let blockType = 0, + container = 0; + const cType = reader.containerType; // 'bin' || 'json' + const streamReader = _Readers[cType]; + try { + // blockType = reader.readUint8(); + blockType = reader.readBlockType(block); + if (blockType === undefined) { + return null; + } + const length = reader.readUint32Length(); + + container = new streamReader["container"](length); + reader.readRaw(container, length); + } catch (err) { + console.log(err.constructor); + if (error) { + error(err); + } + return null; + } + return { type: blockType, reader: new streamReader.stream(container) }; +} + +function _ReadComponentsBlock(artboard, reader) { + let componentCount = reader.readUint16Length(); + let actorComponents = artboard._Components; + + // Guaranteed from the exporter to be in index order. + let block = null; + while ((block = _ReadNextBlock(reader, function (err) { + artboard.actor.error = err; + }, _Block_js__WEBPACK_IMPORTED_MODULE_43__["default"])) !== null) { + let component = null; + switch (block.type) { + case _BlockTypes.CustomIntProperty: + case _BlockTypes.CustomStringProperty: + case _BlockTypes.CustomFloatProperty: + case _BlockTypes.CustomBooleanProperty: + component = _ReadCustomProperty(block.reader, new _CustomProperty_js__WEBPACK_IMPORTED_MODULE_24__["default"](), block.type); + break; + case _BlockTypes.ColliderRectangle: + component = _ReadRectangleCollider(block.reader, new _ActorColliderRectangle_js__WEBPACK_IMPORTED_MODULE_18__["default"]()); + break; + case _BlockTypes.ColliderTriangle: + component = _ReadTriangleCollider(block.reader, new _ActorColliderTriangle_js__WEBPACK_IMPORTED_MODULE_19__["default"]()); + break; + case _BlockTypes.ColliderCircle: + component = _ReadCircleCollider(block.reader, new _ActorColliderCircle_js__WEBPACK_IMPORTED_MODULE_20__["default"]()); + break; + case _BlockTypes.ColliderPolygon: + component = _ReadPolygonCollider(block.reader, new _ActorColliderPolygon_js__WEBPACK_IMPORTED_MODULE_21__["default"]()); + break; + case _BlockTypes.ColliderLine: + component = _ReadLineCollider(block.reader, new _ActorColliderLine_js__WEBPACK_IMPORTED_MODULE_22__["default"]()); + break; + case _BlockTypes.ActorEvent: + component = _ReadActorEvent(block.reader, new _ActorEvent_js__WEBPACK_IMPORTED_MODULE_4__["default"]()); + break; + case _BlockTypes.ActorNode: + component = _ReadActorNode(block.reader, new _ActorNode_js__WEBPACK_IMPORTED_MODULE_5__["default"]()); + break; + case _BlockTypes.ActorBone: + component = _ReadActorBone(block.reader, new _ActorBone_js__WEBPACK_IMPORTED_MODULE_7__["default"]()); + break; + case _BlockTypes.ActorJellyBone: + component = _ReadActorJellyBone(block.reader, new _ActorJellyBone_js__WEBPACK_IMPORTED_MODULE_13__["default"]()); + break; + case _BlockTypes.JellyComponent: + component = _ReadJellyComponent(block.reader, new _JellyComponent_js__WEBPACK_IMPORTED_MODULE_14__["default"]()); + break; + case _BlockTypes.ActorRootBone: + component = _ReadActorRootBone(block.reader, new _ActorRootBone_js__WEBPACK_IMPORTED_MODULE_15__["default"]()); + break; + case _BlockTypes.ActorImage: + component = _ReadActorImage(block.reader, new _ActorImage_js__WEBPACK_IMPORTED_MODULE_16__["default"]()); + break; + case _BlockTypes.ActorImageSequence: + component = _ReadActorImageSequence(block.reader, new _ActorImage_js__WEBPACK_IMPORTED_MODULE_16__["default"]()); + break; + case _BlockTypes.ActorIKTarget: + component = _ReadActorIKTarget(artboard.actor.dataVersion, block.reader, new _ActorIKTarget_js__WEBPACK_IMPORTED_MODULE_17__["default"]()); + break; + case _BlockTypes.NestedActorNode: + component = _ReadNestedActor(block.reader, new _NestedActorNode_js__WEBPACK_IMPORTED_MODULE_23__["default"](), artboard._NestedActorAssets); + break; + case _BlockTypes.ActorNodeSolo: + component = _ReadActorNodeSolo(block.reader, new _ActorNodeSolo_js__WEBPACK_IMPORTED_MODULE_6__["default"]()); + break; + case _BlockTypes.ActorIKConstraint: + component = _ReadActorIKConstraint(block.reader, new _ActorIKConstraint_js__WEBPACK_IMPORTED_MODULE_28__["default"]()); + break; + case _BlockTypes.ActorDistanceConstraint: + component = _ReadActorDistanceConstraint(block.reader, new _ActorDistanceConstraint_js__WEBPACK_IMPORTED_MODULE_29__["default"]()); + break; + case _BlockTypes.ActorTransformConstraint: + component = _ReadActorTransformConstraint(block.reader, new _ActorTransformConstraint_js__WEBPACK_IMPORTED_MODULE_30__["default"]()); + break; + case _BlockTypes.ActorTranslationConstraint: + component = _ReadAxisConstraint(block.reader, new _ActorTranslationConstraint_js__WEBPACK_IMPORTED_MODULE_31__["default"]()); + break; + case _BlockTypes.ActorScaleConstraint: + component = _ReadAxisConstraint(block.reader, new _ActorScaleConstraint_js__WEBPACK_IMPORTED_MODULE_32__["default"]()); + break; + case _BlockTypes.ActorRotationConstraint: + component = _ReadRotationConstraint(block.reader, new _ActorRotationConstraint_js__WEBPACK_IMPORTED_MODULE_33__["default"]()); + break; + case _BlockTypes.ActorShape: + component = _ReadActorShape(block.reader, new _ActorShape_js__WEBPACK_IMPORTED_MODULE_34__["default"]()); + break; + case _BlockTypes.ActorPath: + component = _ReadActorPath(block.reader, new _ActorPath_js__WEBPACK_IMPORTED_MODULE_35__["default"]()); + break; + case _BlockTypes.ColorFill: + component = _ReadColorFill(block.reader, new _ColorComponent_js__WEBPACK_IMPORTED_MODULE_38__["ColorFill"]()); + break; + case _BlockTypes.ColorStroke: + component = _ReadColorStroke(block.reader, new _ColorComponent_js__WEBPACK_IMPORTED_MODULE_38__["ColorStroke"]()); + break; + case _BlockTypes.GradientFill: + component = _ReadGradientFill(block.reader, new _ColorComponent_js__WEBPACK_IMPORTED_MODULE_38__["GradientFill"]()); + break; + case _BlockTypes.GradientStroke: + component = _ReadGradientStroke(block.reader, new _ColorComponent_js__WEBPACK_IMPORTED_MODULE_38__["GradientStroke"]()); + break; + case _BlockTypes.RadialGradientFill: + component = _ReadRadialGradientFill(block.reader, new _ColorComponent_js__WEBPACK_IMPORTED_MODULE_38__["RadialGradientFill"]()); + break; + case _BlockTypes.RadialGradientStroke: + component = _ReadRadialGradientStroke(block.reader, new _ColorComponent_js__WEBPACK_IMPORTED_MODULE_38__["RadialGradientStroke"]()); + break; + case _BlockTypes.ActorEllipse: + component = _ReadActorEllipse(block.reader, new _ActorEllipse_js__WEBPACK_IMPORTED_MODULE_8__["default"]()); + break; + case _BlockTypes.ActorRectangle: + component = _ReadActorRectangle(block.reader, new _ActorRectangle_js__WEBPACK_IMPORTED_MODULE_10__["default"]()); + break; + case _BlockTypes.ActorTriangle: + component = _ReadActorTriangle(block.reader, new _ActorTriangle_js__WEBPACK_IMPORTED_MODULE_12__["default"]()); + break; + case _BlockTypes.ActorStar: + component = _ReadActorStar(block.reader, new _ActorStar_js__WEBPACK_IMPORTED_MODULE_11__["default"]()); + break; + case _BlockTypes.ActorPolygon: + component = _ReadActorPolygon(block.reader, new _ActorPolygon_js__WEBPACK_IMPORTED_MODULE_9__["default"]()); + break; + case _BlockTypes.ActorSkin: + component = _ReadActorComponent(block.reader, new _ActorSkin_js__WEBPACK_IMPORTED_MODULE_36__["default"]()); + break; + } + if (component) { + component._Idx = actorComponents.length; + } + actorComponents.push(component); + } + artboard.resolveHierarchy(); +} + +function _ReadAnimationBlock(artboard, reader) { + const animation = new _Animation_js__WEBPACK_IMPORTED_MODULE_0__["default"](artboard); + artboard._Animations.push(animation); + + animation._Name = reader.readString("name"); + animation._FPS = reader.readUint8("fps"); + animation._Duration = reader.readFloat32("duration"); + animation._Loop = reader.readBool("isLooping"); + + reader.openArray("keyed"); + // Read the number of keyed nodes. + const numKeyedComponents = reader.readUint16Length(); + if (numKeyedComponents > 0) { + for (let i = 0; i < numKeyedComponents; i++) { + reader.openObject("component"); + const componentIndex = reader.readId("component"); + let component = artboard._Components[componentIndex]; + if (!component) { + // Bad component was loaded, read past the animation data. + // Note this only works after version 12 as we can read by the entire set of properties. + // TODO: test this case with JSON. + const props = reader.readUint16(); + for (let j = 0; j < props; j++) { + let propertyBlock = _ReadNextBlock(reader, function (err) { + artboard.actor.error = err; + }); + } + } else { + const animatedComponent = new _AnimatedComponent_js__WEBPACK_IMPORTED_MODULE_25__["default"](componentIndex); + if (component.constructor === _ActorEvent_js__WEBPACK_IMPORTED_MODULE_4__["default"]) { + // N.B. ActorEvents currently only keyframe their trigger so we cn optimize them into a separate array. + animation._TriggerComponents.push(animatedComponent); + } else { + animation._Components.push(animatedComponent); + } + + const props = reader.readUint16Length(); + for (let j = 0; j < props; j++) { + let propertyBlock = _ReadNextBlock(reader, function (err) { + artboard.actor.error = err; + }, _AnimatedProperty_js__WEBPACK_IMPORTED_MODULE_26__["default"]); + const propertyReader = propertyBlock.reader; + const propertyType = propertyBlock.type; + + let validProperty = false; + switch (propertyType) { + case _AnimatedPropertyTypes.PosX: + case _AnimatedPropertyTypes.PosY: + case _AnimatedPropertyTypes.ScaleX: + case _AnimatedPropertyTypes.ScaleY: + case _AnimatedPropertyTypes.Rotation: + case _AnimatedPropertyTypes.Opacity: + case _AnimatedPropertyTypes.DrawOrder: + case _AnimatedPropertyTypes.Length: + case _AnimatedPropertyTypes.VertexDeform: + case _AnimatedPropertyTypes.ConstraintStrength: + case _AnimatedPropertyTypes.Trigger: + case _AnimatedPropertyTypes.IntProperty: + case _AnimatedPropertyTypes.FloatProperty: + case _AnimatedPropertyTypes.StringProperty: + case _AnimatedPropertyTypes.BooleanProperty: + case _AnimatedPropertyTypes.IsCollisionEnabled: + case _AnimatedPropertyTypes.ActiveChildIndex: + case _AnimatedPropertyTypes.Sequence: + case _AnimatedPropertyTypes.PathVertices: + case _AnimatedPropertyTypes.FillColor: + case _AnimatedPropertyTypes.StrokeColor: + case _AnimatedPropertyTypes.StrokeWidth: + case _AnimatedPropertyTypes.FillGradient: + case _AnimatedPropertyTypes.StrokeGradient: + case _AnimatedPropertyTypes.FillRadial: + case _AnimatedPropertyTypes.StrokeRadial: + case _AnimatedPropertyTypes.StrokeOpacity: + case _AnimatedPropertyTypes.FillOpacity: + case _AnimatedPropertyTypes.ShapeWidth: + case _AnimatedPropertyTypes.ShapeHeight: + case _AnimatedPropertyTypes.CornerRadius: + case _AnimatedPropertyTypes.InnerRadius: + validProperty = true; + break; + default: + break; + } + if (!validProperty) { + continue; + } + const animatedProperty = new _AnimatedProperty_js__WEBPACK_IMPORTED_MODULE_26__["default"](propertyType); + animatedComponent._Properties.push(animatedProperty); + + propertyReader.openArray("frames"); + const keyFrameCount = propertyReader.readUint16Length(); + let lastKeyFrame = null; + for (let k = 0; k < keyFrameCount; k++) { + let keyFrame = new _KeyFrame_js__WEBPACK_IMPORTED_MODULE_40__["KeyFrame"](animatedProperty); + + propertyReader.openObject("frame"); + + keyFrame._Time = propertyReader.readFloat64("time"); + + switch (propertyType) { + case _AnimatedPropertyTypes.IsCollisionEnabled: + case _AnimatedPropertyTypes.BooleanProperty: + case _AnimatedPropertyTypes.StringProperty: + case _AnimatedPropertyTypes.Trigger: + case _AnimatedPropertyTypes.DrawOrder: + case _AnimatedPropertyTypes.ActiveChildIndex: + // These do not interpolate. + keyFrame._Interpolator = _Interpolation_js__WEBPACK_IMPORTED_MODULE_42__["Hold"].instance; + break; + default: + { + const type = propertyReader.readUint8("interpolatorType"); + switch (type) { + case 0: + keyFrame._Interpolator = _Interpolation_js__WEBPACK_IMPORTED_MODULE_42__["Hold"].instance; + break; + case 1: + keyFrame._Interpolator = _Interpolation_js__WEBPACK_IMPORTED_MODULE_42__["Linear"].instance; + break; + case 2: + keyFrame._Interpolator = new _Interpolation_js__WEBPACK_IMPORTED_MODULE_42__["Cubic"](propertyReader.readFloat32("cubicX1"), propertyReader.readFloat32("cubicY1"), propertyReader.readFloat32("cubicX2"), propertyReader.readFloat32("cubicY2")); + break; + } + break; + } + } + if (propertyType === _AnimatedPropertyTypes.PathVertices) { + const path = artboard._Components[animatedComponent._ComponentIndex]; + const pointCount = path._Points.length; + const points = []; + + for (let j = 0; j < pointCount; j++) { + const point = path._Points[j]; + + const pos = propertyReader.readFloat32Array(new Float32Array(2), "translation"); + points.push(pos[0], pos[1]); + + if (point.constructor === _PathPoint_js__WEBPACK_IMPORTED_MODULE_39__["StraightPathPoint"]) { + points.push(propertyReader.readFloat32("radius")); + } else { + let p = propertyReader.readFloat32Array(new Float32Array(2), "inValue"); + points.push(p[0], p[1]); + + p = propertyReader.readFloat32Array(new Float32Array(2), "outValue"); + points.push(p[0], p[1]); + } + } + + keyFrame._Value = new Float32Array(points); + } else if (propertyType === _AnimatedPropertyTypes.FillColor || propertyType === _AnimatedPropertyTypes.StrokeColor) { + keyFrame._Value = propertyReader.readFloat32Array(new Float32Array(4), "value"); + } else if (propertyType === _AnimatedPropertyTypes.FillGradient || propertyType === _AnimatedPropertyTypes.StrokeGradient || propertyType === _AnimatedPropertyTypes.StrokeRadial || propertyType === _AnimatedPropertyTypes.FillRadial) { + const fillLength = propertyReader.readUint16("length"); + keyFrame._Value = propertyReader.readFloat32Array(new Float32Array(fillLength), "value"); + } else if (propertyType === _AnimatedPropertyTypes.Trigger) { + // No value on keyframe. + } else if (propertyType === _AnimatedPropertyTypes.IntProperty) { + keyFrame._Value = propertyReader.readInt32("value"); + } else if (propertyType === _AnimatedPropertyTypes.StringProperty) { + keyFrame._Value = propertyReader.readString("value"); + } else if (propertyType === _AnimatedPropertyTypes.BooleanProperty || propertyType === _AnimatedPropertyTypes.IsCollisionEnabled) { + keyFrame._Value = propertyReader.readBool("value"); + } else if (propertyType === _AnimatedPropertyTypes.DrawOrder) { + propertyReader.openArray("drawOrder"); + const orderedImages = propertyReader.readUint16Length(); + const orderValue = []; + for (let l = 0; l < orderedImages; l++) { + propertyReader.openObject("order"); + const idx = propertyReader.readId("component"); + const order = propertyReader.readUint16("order"); + propertyReader.closeObject(); + orderValue.push({ + componentIdx: idx, + value: order + }); + } + propertyReader.closeArray(); + keyFrame._Value = orderValue; + } else if (propertyType === _AnimatedPropertyTypes.VertexDeform) { + keyFrame._Value = new Float32Array(component._NumVertices * 2); + component.hasVertexDeformAnimation = true; + propertyReader.readFloat32Array(keyFrame._Value, "value"); + } else { + keyFrame._Value = propertyReader.readFloat32("value"); + } + + if (propertyType === _AnimatedPropertyTypes.DrawOrder) { + // Always hold draw order. + keyFrame._Interpolator = _Interpolation_js__WEBPACK_IMPORTED_MODULE_42__["Hold"].instance; + } else if (propertyType === _AnimatedPropertyTypes.VertexDeform) { + keyFrame._Interpolator = _Interpolation_js__WEBPACK_IMPORTED_MODULE_42__["Linear"].instance; + } + + if (lastKeyFrame) { + lastKeyFrame.setNext(keyFrame); + } + animatedProperty._KeyFrames.push(keyFrame); + lastKeyFrame = keyFrame; + propertyReader.closeObject(); + } + if (lastKeyFrame) { + lastKeyFrame.setNext(null); + } + } + } + reader.closeObject(); + } + reader.closeArray(); + + animation._DisplayStart = reader.readFloat32("animationStart"); + animation._DisplayEnd = reader.readFloat32("animationEnd"); + //animation._DisplayStart = 0; + //animation._DisplayEnd = 50/60; + } else { + reader.closeArray(); + } +} + +function _ReadAnimationsBlock(artboard, reader) { + const animationsCount = reader.readUint16Length(); // Keep the reader aligned when using BinaryReader. + let block = null; + // The animations block only contains a list of animations, so we don't need to track how many we've read in. + while ((block = _ReadNextBlock(reader, function (err) { + artboard.actor.error = err; + }, _Block_js__WEBPACK_IMPORTED_MODULE_43__["default"])) !== null) { + switch (block.type) { + case _BlockTypes.Animation: + _ReadAnimationBlock(artboard, block.reader); + break; + } + } +} + +function _ReadNestedActorAssetBlock(actor, reader) { + let asset = new _NestedActorAsset_js__WEBPACK_IMPORTED_MODULE_27__["default"](reader.readString(), reader.readString()); + actor._NestedActorAssets.push(asset); +} + +function _ReadNestedActorAssets(actor, reader) { + let nestedActorCount = reader.readUint16(); + let block = null; + while ((block = _ReadNextBlock(reader, function (err) { + actor.error = err; + })) !== null) { + switch (block.type) { + case _BlockTypes.NestedActorAsset: + _ReadNestedActorAssetBlock(actor, block.reader); + break; + } + } +} + +function _BuildJpegAtlas(atlas, img, imga, callback) { + const canvas = document.createElement("canvas"); + canvas.width = img.width; + canvas.height = img.height; + const ctx = canvas.getContext("2d"); + ctx.drawImage(img, 0, 0, img.width, img.height); + + if (imga) { + const imageDataRGB = ctx.getImageData(0, 0, canvas.width, canvas.height); + const dataRGB = imageDataRGB.data; + const canvasAlpha = document.createElement("canvas"); + + canvasAlpha.width = img.width; + canvasAlpha.height = img.height; + const actx = canvasAlpha.getContext("2d"); + actx.drawImage(imga, 0, 0, imga.width, imga.height); + + const imageDataAlpha = actx.getImageData(0, 0, canvasAlpha.width, canvasAlpha.height); + const dataAlpha = imageDataAlpha.data; + + const pixels = dataAlpha.length / 4; + let widx = 3; + + for (let j = 0; j < pixels; j++) { + dataRGB[widx] = dataAlpha[widx - 1]; + widx += 4; + } + ctx.putImageData(imageDataRGB, 0, 0); + } + + const atlasImage = new Image(); + const enc = canvas.toDataURL(); + atlasImage.src = enc; + atlasImage.onload = function () { + atlas.img = this; + callback(); + }; +} + +function _JpegAtlas(dataRGB, dataAlpha, callback) { + const _This = this; + const img = document.createElement("img"); + let imga; + let c = 0; + let target = 1; + img.onload = function () { + c++; + if (c === target) { + _BuildJpegAtlas(_This, img, imga, callback); + } + }; + + if (dataAlpha) { + imga = document.createElement("img"); + imga.onload = function () { + c++; + if (c == target) { + _BuildJpegAtlas(_This, img, imga, callback); + } + }; + imga.src = URL.createObjectURL(dataAlpha); + } + img.src = URL.createObjectURL(dataRGB); +} + +function _ReadAtlasesBlock14(actor, reader, callback) { + // Read atlases. + const numAtlases = reader.readUint16(); + + let waitCount = 0; + let loadedCount = 0; + function loaded() { + loadedCount++; + if (loadedCount === waitCount) { + callback(); + } + } + + for (let i = 0; i < numAtlases; i++) { + let size = reader.readUint32(); + const atlasDataRGB = new Uint8Array(size); + reader.readRaw(atlasDataRGB, atlasDataRGB.length); + + size = reader.readUint32(); + const atlasDataAlpha = new Uint8Array(size); + reader.readRaw(atlasDataAlpha, atlasDataAlpha.length); + + const rgbSrc = new Blob([atlasDataRGB], { type: "image/jpeg" }); + const alphaSrc = new Blob([atlasDataAlpha], { type: "image/jpeg" }); + + waitCount++; + const atlas = new _JpegAtlas(rgbSrc, alphaSrc, loaded); + + actor._Atlases.push(atlas); //new Blob([atlasDataRGB], {type: "image/jpeg"})); + } + + // Return true if we are waiting for atlases + return waitCount !== loadedCount; +} + +function _ReadAtlasesBlock15(actor, reader, callback) { + // Internal Callback + function loaded() { + loadedCount++; + if (loadedCount === waitCount) { + callback(); + } + } + // ==== + + // Read atlases. + const isOOB = reader.readBool("isOOB"); + reader.openArray("data"); + const numAtlases = reader.readUint16Length(); + + let waitCount = 0; + let loadedCount = 0; + + for (let i = 0; i < numAtlases; i++) { + waitCount++; + let readCallback = function (data) { + if (data.constructor === Blob) { + const atlas = new _JpegAtlas(data, undefined, loaded); + actor._Atlases.push(atlas); + } else if (data.constructor === String) { + const imgElm = document.createElement("img"); + const atlas = {}; + imgElm.onload = function () { + atlas.img = this; + loaded(); + }; + actor._Atlases.push(atlas); + imgElm.src = data; + } + }; + + reader.readImage(isOOB, readCallback); + } + + reader.closeArray(); + + // Return true if we are waiting for atlases + return waitCount !== loadedCount; +} + +function _LoadNestedAssets(loader, actor, callback) { + let loadCount = actor._NestedActorAssets.length; + let nestedLoad = loader.loadNestedActor; + if (loadCount == 0 || !nestedLoad) { + callback(actor); + return; + } + + for (let asset of actor._NestedActorAssets) { + nestedLoad(asset, function (nestedActor) { + asset._Actor = nestedActor; + loadCount--; + if (loadCount <= 0) { + callback(actor); + } + }); + } +} + +function _ReadArtboardsBlock(actor, reader) { + const artboardCount = reader.readUint16Length(); + const actorArtboards = actor._Artboards; + + // Guaranteed from the exporter to be in index order. + let block = null; + while ((block = _ReadNextBlock(reader, function (err) { + actor.error = err; + }, _Block_js__WEBPACK_IMPORTED_MODULE_43__["default"])) !== null) { + switch (block.type) { + case _BlockTypes.ActorArtboard: + { + const artboard = _ReadActorArtboard(block.reader, new _ActorArtboard_js__WEBPACK_IMPORTED_MODULE_37__["default"](actor), block.type); + if (artboard) { + actorArtboards.push(artboard); + } + break; + } + } + } +} + +function _ReadActor(loader, data, callback) { + let reader = new _Readers_BinaryReader_js__WEBPACK_IMPORTED_MODULE_1__["default"](new Uint8Array(data)); + // Check signature + if (reader.readUint8() !== 70 || reader.readUint8() !== 76 || reader.readUint8() !== 65 || reader.readUint8() !== 82 || reader.readUint8() !== 69) { + const dataView = new DataView(data); + const stringData = new TextDecoder("utf-8").decode(dataView); + reader = new _Readers_JSONReader_js__WEBPACK_IMPORTED_MODULE_2__["default"]({ "container": JSON.parse(stringData) }); + } + + const version = reader.readUint32("version"); + const actor = new _Actor_js__WEBPACK_IMPORTED_MODULE_3__["default"](); + actor.dataVersion = version; + let block = null; + let waitForAtlas = false; + while ((block = _ReadNextBlock(reader, function (err) { + actor.error = err; + }, _Block_js__WEBPACK_IMPORTED_MODULE_43__["default"])) !== null) { + switch (block.type) { + case _BlockTypes.Artboards: + _ReadArtboardsBlock(actor, block.reader); + break; + case _BlockTypes.Atlases: + + if (_ReadAtlasesBlock(actor, block.reader, function () { + _LoadNestedAssets(loader, actor, callback); + })) { + waitForAtlas = true; + } + break; + case _BlockTypes.NestedActorAssets: + _ReadNestedActorAssets(actor, block.reader); + break; + } + } + if (!waitForAtlas) { + _LoadNestedAssets(loader, actor, callback); + } +} + +function _ReadActorArtboard(reader, artboard) { + artboard._Name = reader.readString("name"); + reader.readFloat32Array(artboard._Translation, "translation"); + artboard._Width = reader.readFloat32("width"); + artboard._Height = reader.readFloat32("height"); + reader.readFloat32Array(artboard._Origin, "origin"); + artboard._ClipContents = reader.readBool("clipContents"); + reader.readFloat32Array(artboard._Color, "color"); + + let block = null; + while ((block = _ReadNextBlock(reader, function (err) { + artboard.actor.error = err; + }, _Block_js__WEBPACK_IMPORTED_MODULE_43__["default"])) !== null) { + switch (block.type) { + case _BlockTypes.Nodes: + _ReadComponentsBlock(artboard, block.reader); + break; + case _BlockTypes.Animations: + _ReadAnimationsBlock(artboard, block.reader); + break; + } + } + + return artboard; +} + +function _ReadActorComponent(reader, component) { + component._Name = reader.readString("name"); + component._ParentIdx = reader.readId("parent"); + return component; +} + +function _ReadActorPaint(reader, component) { + _ReadActorComponent(reader, component); + component._Opacity = reader.readFloat32("opacity"); + return component; +} + +function _ReadCustomProperty(reader, component, type) { + _ReadActorComponent(reader, component); + + switch (type) { + case _BlockTypes.CustomIntProperty: + component._PropertyType = _CustomProperty_js__WEBPACK_IMPORTED_MODULE_24__["default"].Type.Integer; + component._Value = reader.readInt32("int"); + break; + case _BlockTypes.CustomFloatProperty: + component._PropertyType = _CustomProperty_js__WEBPACK_IMPORTED_MODULE_24__["default"].Type.Float; + component._Value = reader.readFloat32("float"); + break; + case _BlockTypes.CustomStringProperty: + component._PropertyType = _CustomProperty_js__WEBPACK_IMPORTED_MODULE_24__["default"].Type.String; + component._Value = reader.readString("string"); + break; + case _BlockTypes.CustomBooleanProperty: + component._PropertyType = _CustomProperty_js__WEBPACK_IMPORTED_MODULE_24__["default"].Type.Boolean; + component._Value = reader.readBool("bool"); + break; + } + + return component; +} + +function _ReadCollider(reader, component) { + _ReadActorNode(reader, component); + component._IsCollisionEnabled = reader.readBool("isCollisionEnabled"); + return component; +} + +function _ReadRectangleCollider(reader, component) { + _ReadCollider(reader, component); + + component._Width = reader.readFloat32("width"); + component._Height = reader.readFloat32("height"); + + return component; +} + +function _ReadTriangleCollider(reader, component) { + _ReadCollider(reader, component); + + component._Width = reader.readFloat32("width"); + component._Height = reader.readFloat32("height"); + + return component; +} + +function _ReadCircleCollider(reader, component) { + _ReadCollider(reader, component); + + component._Radius = reader.readFloat32("radius"); + + return component; +} + +function _ReadPolygonCollider(reader, component) { + _ReadCollider(reader, component); + + const numVertices = reader.readUint32("cc"); + component._ContourVertices = new Float32Array(numVertices * 2); + reader.readFloat32Array(component._ContourVertices, "countour"); + + return component; +} + +function _ReadLineCollider(reader, component) { + _ReadCollider(reader, component); + + const numVertices = reader.readUint32("lineDataLength"); + component._Vertices = new Float32Array(numVertices * 2); + reader.readFloat32Array(component._Vertices, "lineData"); + + return component; +} + +function _ReadActorEvent(reader, component) { + _ReadActorComponent(reader, component); + return component; +} + +function _ReadActorNode(reader, component) { + _ReadActorComponent(reader, component); + + reader.readFloat32Array(component._Translation, "translation"); + component._Rotation = reader.readFloat32("rotation"); + reader.readFloat32Array(component._Scale, "scale"); + component._Opacity = reader.readFloat32("opacity"); + component._IsCollapsedVisibility = reader.readBool("isCollapsed"); + + reader.openArray("clips"); + const clipCount = reader.readUint8Length(); + if (clipCount) { + component._Clips = []; + for (let i = 0; i < clipCount; i++) { + component._Clips.push(reader.readId("clip")); + } + } + reader.closeArray(); + return component; +} + +function _ReadActorNodeSolo(reader, component) { + _ReadActorNode(reader, component); + component._ActiveChildIndex = reader.readUint32("activeChild"); + return component; +} + +function _ReadActorBone(reader, component) { + _ReadActorNode(reader, component); + component._Length = reader.readFloat32("length"); + return component; +} + +function _ReadActorJellyBone(reader, component) { + _ReadActorComponent(reader, component); + component._Opacity = reader.readFloat32("opacity"); + component._IsCollapsedVisibility = reader.readBool("isCollapsedVisibility"); + + return component; +} + +function _ReadJellyComponent(reader, component) { + _ReadActorComponent(reader, component); + component._EaseIn = reader.readFloat32("easeIn"); + component._EaseOut = reader.readFloat32("easeOut"); + component._ScaleIn = reader.readFloat32("scaleIn"); + component._ScaleOut = reader.readFloat32("scaleOut"); + component._InTargetIdx = reader.readId("inTarget"); + component._OutTargetIdx = reader.readId("outTarget"); + + return component; +} + +function _ReadActorRootBone(reader, component) { + _ReadActorNode(reader, component); + + return component; +} + +function _ReadActorIKTarget(version, reader, component) { + _ReadActorNode(reader, component); + + component._Strength = reader.readFloat32(); + component._InvertDirection = reader.readUint8() === 1; + + let numInfluencedBones = reader.readUint8(); + if (numInfluencedBones > 0) { + component._InfluencedBones = []; + + for (let i = 0; i < numInfluencedBones; i++) { + component._InfluencedBones.push(reader.readUint16()); + } + } + + return component; +} + +function _ReadActorConstraint(reader, component) { + _ReadActorComponent(reader, component); + component._Strength = reader.readFloat32("strength"); + component._IsEnabled = reader.readBool("isEnabled"); +} + +function _ReadActorTargetedConstraint(reader, component) { + _ReadActorConstraint(reader, component); + + component._TargetIdx = reader.readId("target"); +} + +function _ReadActorIKConstraint(reader, component) { + _ReadActorTargetedConstraint(reader, component); + + component._InvertDirection = reader.readBool("isInverted"); + + reader.openArray("bones"); + const numInfluencedBones = reader.readUint8Length(); + if (numInfluencedBones > 0) { + component._InfluencedBones = []; + + for (let i = 0; i < numInfluencedBones; i++) { + component._InfluencedBones.push(reader.readId("")); // No need for a label here, since we're just clearing elements from the array. + } + } + reader.closeArray(); + return component; +} + +function _ReadActorDistanceConstraint(reader, component) { + _ReadActorTargetedConstraint(reader, component); + + component._Distance = reader.readFloat32("distance"); + component._Mode = reader.readUint8("modeId"); + + return component; +} + +function _ReadActorTransformConstraint(reader, component) { + _ReadActorTargetedConstraint(reader, component); + + component._SourceSpace = reader.readUint8("sourceSpaceId"); + component._DestSpace = reader.readUint8("destSpaceId"); + + return component; +} + +function _ReadRotationConstraint(reader, component) { + _ReadActorTargetedConstraint(reader, component); + + if (component._Copy = reader.readBool("copy")) { + component._Scale = reader.readFloat32("scale"); + } + if (component._EnableMin = reader.readBool("enableMin")) { + component._Min = reader.readFloat32("min"); + } + if (component._EnableMax = reader.readBool("enableMax")) { + component._Max = reader.readFloat32("max"); + } + + component._Offset = reader.readBool("offset"); + component._SourceSpace = reader.readUint8("sourceSpaceId"); + component._DestSpace = reader.readUint8("destSpaceId"); + component._MinMaxSpace = reader.readUint8("minMaxSpaceId"); + + return component; +} + +function _ReadAxisConstraint(reader, component) { + _ReadActorTargetedConstraint(reader, component); + // X Axis + if (component._CopyX = reader.readBool("copyX")) { + component._ScaleX = reader.readFloat32("scaleX"); + } + if (component._EnableMinX = reader.readBool("enableMinX")) { + component._MinX = reader.readFloat32("minX"); + } + if (component._EnableMaxX = reader.readBool("enableMaxX")) { + component._MaxX = reader.readFloat32("maxX"); + } + + // Y Axis + if (component._CopyY = reader.readBool("copyY")) { + component._ScaleY = reader.readFloat32("scaleY"); + } + if (component._EnableMinY = reader.readBool("enableMinY")) { + component._MinY = reader.readFloat32("minY"); + } + if (component._EnableMaxY = reader.readBool("enableMaxY")) { + component._MaxY = reader.readFloat32("maxY"); + } + + component._Offset = reader.readBool("offset"); + component._SourceSpace = reader.readUint8("sourceSpaceId"); + component._DestSpace = reader.readUint8("destSpaceId"); + component._MinMaxSpace = reader.readUint8("minMaxSpaceId"); + + return component; +} + +function _ReadActorShape(reader, component) { + _ReadActorNode(reader, component); + component._IsHidden = !reader.readBool("isVisible"); + /*component._BlendMode =*/reader.readUint8("blendMode"); + component._DrawOrder = reader.readUint16("drawOrder"); + + return component; +} + +function _ReadProceduralPath(reader, component) { + _ReadActorNode(reader, component); + component._Width = reader.readFloat32("width"); + component._Height = reader.readFloat32("height"); + return component; +} + +function _ReadActorStar(reader, component) { + _ReadProceduralPath(reader, component); + component._Points = reader.readUint32("points"); + component._InnerRadius = reader.readFloat32("innerRadius"); + + return component; +} + +function _ReadActorRectangle(reader, component) { + _ReadProceduralPath(reader, component); + component._CornerRadius = reader.readFloat32("cornerRadius"); + return component; +} + +function _ReadActorPolygon(reader, component) { + _ReadProceduralPath(reader, component); + component._Sides = reader.readUint32("sides"); + return component; +} + +function _ReadActorTriangle(reader, component) { + _ReadProceduralPath(reader, component); + + return component; +} + +function _ReadActorEllipse(reader, component) { + _ReadProceduralPath(reader, component); + return component; +} + +function _ReadColorFill(reader, component) { + _ReadActorPaint(reader, component); + + reader.readFloat32Array(component._Color, "color"); + component._FillRule = reader.readUint8("fillRule"); + + return component; +} + +function _ReadColorStroke(reader, component) { + _ReadActorPaint(reader, component); + + reader.readFloat32Array(component._Color, "color"); + component._Width = reader.readFloat32("width"); + + return component; +} + +function _ReadGradient(reader, component) { + const numStops = reader.readUint8("numColorStops"); + const stops = new Float32Array(numStops * 5); + reader.readFloat32Array(stops, "colorStops"); + component._ColorStops = stops; + + reader.readFloat32Array(component._Start, "start"); + reader.readFloat32Array(component._End, "end"); + + return component; +} + +function _ReadRadialGradient(reader, component) { + _ReadGradient(reader, component); + component._SecondaryRadiusScale = reader.readFloat32("secondaryRadiusScale"); + + return component; +} + +function _ReadGradientFill(reader, component) { + _ReadActorPaint(reader, component); + + _ReadGradient(reader, component); + component._FillRule = reader.readUint8("fillRule"); + + return component; +} + +function _ReadGradientStroke(reader, component) { + _ReadActorPaint(reader, component); + + _ReadGradient(reader, component); + component._Width = reader.readFloat32("width"); + + return component; +} + +function _ReadRadialGradientFill(reader, component) { + _ReadActorPaint(reader, component); + + _ReadRadialGradient(reader, component); + component._FillRule = reader.readUint8("fillRule"); + + return component; +} + +function _ReadRadialGradientStroke(reader, component) { + _ReadActorPaint(reader, component); + + _ReadRadialGradient(reader, component); + component._Width = reader.readFloat32("width"); + + return component; +} + +function _ReadSkinnable(reader, component) { + _ReadActorNode(reader, component); + + reader.openArray("bones"); + const numConnectedBones = reader.readUint8Length(); + if (numConnectedBones > 0) { + component._ConnectedBones = []; + for (let i = 0; i < numConnectedBones; i++) { + reader.openObject("bone"); + const bind = gl_matrix__WEBPACK_IMPORTED_MODULE_41__["mat2d"].create(); + const componentIndex = reader.readId("component"); + reader.readFloat32Array(bind, "bind"); + reader.closeObject(); + + component._ConnectedBones.push({ + componentIndex: componentIndex, + bind: bind, + ibind: gl_matrix__WEBPACK_IMPORTED_MODULE_41__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_41__["mat2d"].create(), bind) + }); + } + reader.closeArray(); + + // Read the final override parent world. + const overrideWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_41__["mat2d"].create(); + reader.readFloat32Array(overrideWorld, "worldTransform"); + gl_matrix__WEBPACK_IMPORTED_MODULE_41__["mat2d"].copy(component._WorldTransform, overrideWorld); + component._OverrideWorldTransform = true; + } else { + // Close the previously opened JSON Array. + reader.closeArray(); + } +} + +function _ReadActorPath(reader, component) { + _ReadSkinnable(reader, component); + component._IsHidden = !reader.readBool("isVisible"); + component._IsClosed = reader.readBool("isClosed"); + + reader.openArray("points"); + const pointCount = reader.readUint16Length(); + const points = new Array(pointCount); + const isConnectedToBones = component._ConnectedBones && component._ConnectedBones.length > 0; + for (let i = 0; i < pointCount; i++) { + reader.openObject("point"); + const type = reader.readUint8("pointType"); + let point = null; + switch (type) { + case _PathPoint_js__WEBPACK_IMPORTED_MODULE_39__["PointType"].Straight: + { + point = new _PathPoint_js__WEBPACK_IMPORTED_MODULE_39__["StraightPathPoint"](); + reader.readFloat32Array(point._Translation, "translation"); + point._Radius = reader.readFloat32("radius"); + if (isConnectedToBones) { + point._Weights = new Float32Array(8); + } + break; + } + default: + { + point = new _PathPoint_js__WEBPACK_IMPORTED_MODULE_39__["CubicPathPoint"](); + reader.readFloat32Array(point._Translation, "translation"); + reader.readFloat32Array(point._In, "in"); + reader.readFloat32Array(point._Out, "out"); + if (isConnectedToBones) { + point._Weights = new Float32Array(24); + } + break; + } + } + if (point._Weights) { + reader.readFloat32Array(point._Weights, "weights"); + } + reader.closeObject(); + if (!point) { + throw new Error("Invalid point type " + type); + } + point._PointType = type; + points[i] = point; + } + reader.closeArray(); + component._Points = points; + + return component; +} + +function _ReadActorImage(reader, component) { + _ReadActorNode(reader, component); + const isVisible = reader.readBool("isVisible"); + if (isVisible) { + component._BlendMode = reader.readUint8("blendMode"); + component._DrawOrder = reader.readUint16("drawOrder"); + component._AtlasIndex = reader.readUint8("atlas"); + + reader.openArray("bones"); + const numConnectedBones = reader.readUint8Length(); + if (numConnectedBones > 0) { + component._ConnectedBones = []; + for (let i = 0; i < numConnectedBones; i++) { + reader.openObject("bone"); + const bind = gl_matrix__WEBPACK_IMPORTED_MODULE_41__["mat2d"].create(); + const componentIndex = reader.readId("component"); + reader.readFloat32Array(bind, "bind"); + reader.closeObject(); + + component._ConnectedBones.push({ + componentIndex: componentIndex, + bind: bind, + ibind: gl_matrix__WEBPACK_IMPORTED_MODULE_41__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_41__["mat2d"].create(), bind) + }); + } + reader.closeArray(); + + // Read the final override parent world. + const overrideWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_41__["mat2d"].create(); + reader.readFloat32Array(overrideWorld, "worldTransform"); + gl_matrix__WEBPACK_IMPORTED_MODULE_41__["mat2d"].copy(component._WorldTransform, overrideWorld); + component._OverrideWorldTransform = true; + } else { + // Close the previously opened JSON Array. + reader.closeArray(); + } + + const numVertices = reader.readUint32("numVertices"); + const vertexStride = numConnectedBones > 0 ? 12 : 4; + + component._NumVertices = numVertices; + component._VertexStride = vertexStride; + component._Vertices = new Float32Array(numVertices * vertexStride); + reader.readFloat32Array(component._Vertices, "vertices"); + + const numTris = reader.readUint32("numTriangles"); + component._Triangles = new Uint16Array(numTris * 3); + reader.readUint16Array(component._Triangles, "triangles"); + } + + return component; +} + +function _ReadActorImageSequence(reader, component) { + _ReadActorImage(reader, component); + + // See if it was visible to begin with. + if (component._AtlasIndex != -1) { + reader.openArray("frames"); + const frameCount = reader.readUint16Length(); + component._SequenceFrames = []; + const uvs = new Float32Array(component._NumVertices * 2 * frameCount); + const uvStride = component._NumVertices * 2; + component._SequenceUVs = uvs; + const firstFrame = { + atlas: component._AtlasIndex, + offset: 0 + }; + + component._SequenceFrames.push(firstFrame); + + let readIdx = 2; + let writeIdx = 0; + for (let i = 0; i < component._NumVertices; i++) { + uvs[writeIdx++] = component._Vertices[readIdx]; + uvs[writeIdx++] = component._Vertices[readIdx + 1]; + readIdx += component._VertexStride; + } + + let offset = uvStride; + for (let i = 1; i < frameCount; i++) { + reader.openObject("frame"); + let frame = { + atlas: reader.readUint8("atlas"), + offset: offset * 4 + }; + + component._SequenceFrames.push(frame); + reader.readFloat32ArrayOffset(uvs, uvStride, offset, "uv"); + reader.closeObject(); + + offset += uvStride; + } + reader.closeArray(); + } + + return component; +} + +function _ReadNestedActor(reader, component, nestedActorAssets) { + _ReadActorNode(reader, component); + let isVisible = reader.readUint8(); + if (isVisible) { + // Draw order + component._DrawOrder = reader.readUint16(); + let assetIndex = reader.readUint16(); + if (assetIndex < nestedActorAssets.length) { + component._Asset = nestedActorAssets[assetIndex]; + } + } + return component; +} + +class ActorLoader { + load(url, callback) { + let loader = this; + if (url.constructor === String) { + let req = new XMLHttpRequest(); + req.open("GET", url, true); + req.responseType = "blob"; + req.onload = function () { + let fileReader = new FileReader(); + fileReader.onload = function () { + _ReadActor(loader, this.result, callback); + }; + fileReader.readAsArrayBuffer(this.response); + }; + req.send(); + } else { + let fileReader = new FileReader(); + fileReader.onload = function () { + _ReadActor(loader, this.result, callback); + }; + fileReader.readAsArrayBuffer(url); + } + } +} + +/***/ }), + +/***/ "./source/ActorNode.js": +/*!*****************************!*\ + !*** ./source/ActorNode.js ***! + \*****************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorNode; }); +/* harmony import */ var _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorComponent.js */ "./source/ActorComponent.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + +const TransformDirty = 1 << 0; +const WorldTransformDirty = 1 << 1; + +function _UpdateTransform(node) { + let r = node._Rotation; + let t = node._Translation; + + //t[0] += 0.01; + let s = node._Scale; + let transform = node._Transform; + + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].fromRotation(transform, r); + + transform[4] = t[0]; + transform[5] = t[1]; + + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].scale(transform, transform, s); + + return transform; +} + +class ActorNode extends _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._Children = []; + this._Transform = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(); + this._WorldTransform = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(); + this._OverrideWorldTransform = false; + this._Constraints = null; + this._PeerConstraints = null; + + this._Translation = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(); + this._Rotation = 0; + this._Scale = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), 1, 1); + this._Opacity = 1; + this._RenderOpacity = 1; + + this._IsCollapsedVisibility = false; + this._RenderCollapsed = false; + this._Clips = null; + } + + eachChildRecursive(cb) { + const children = this._Children; + for (let child of children) { + if (cb(child) === false) { + continue; + } + + if (child.eachChildRecursive) { + child.eachChildRecursive(cb); + } + } + } + + all(cb) { + if (cb(this) === false) { + return false; + } + const children = this._Children; + for (let child of children) { + if (cb(child) === false) { + continue; + } + + if (child.eachChildRecursive) { + child.eachChildRecursive(cb); + } + } + + return true; + } + + get constraints() { + return this._Constraints; + } + + get allConstraints() { + return new Set((this._Constraints || []).concat(this._PeerConstraints || [])); + } + + addConstraint(constraint) { + let constraints = this._Constraints; + if (!constraints) { + this._Constraints = constraints = []; + } + if (constraints.indexOf(constraint) !== -1) { + return false; + } + + constraints.push(constraint); + + return true; + } + + addPeerConstraint(constraint) { + if (!this._PeerConstraints) { + this._PeerConstraints = []; + } + this._PeerConstraints.push(constraint); + } + + markTransformDirty() { + let actor = this._Actor; + if (!actor) { + // Still loading? + return; + } + if (!actor.addDirt(this, TransformDirty)) { + return; + } + actor.addDirt(this, WorldTransformDirty, true); + } + + updateWorldTransform() { + const parent = this._Parent; + + this._RenderOpacity = this._Opacity; + + if (parent) { + this._RenderCollapsed = this._IsCollapsedVisibility || parent._RenderCollapsed; + this._RenderOpacity *= parent._RenderOpacity; + if (!this._OverrideWorldTransform) { + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(this._WorldTransform, parent._WorldTransform, this._Transform); + } + } else { + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].copy(this._WorldTransform, this._Transform); + } + } + + get isNode() { + return true; + } + + get translation() { + return this._Translation; + } + + set translation(t) { + if (gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].exactEquals(this._Translation, t)) { + return; + } + + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].copy(this._Translation, t); + this.markTransformDirty(); + } + + get scale() { + return this._Scale; + } + + set scale(t) { + if (gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].exactEquals(this._Scale, t)) { + return; + } + + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].copy(this._Scale, t); + this.markTransformDirty(); + } + + get x() { + return this._Translation[0]; + } + + set x(value) { + if (this._Translation[0] != value) { + this._Translation[0] = value; + this.markTransformDirty(); + } + } + + get y() { + return this._Translation[1]; + } + + set y(value) { + if (this._Translation[1] != value) { + this._Translation[1] = value; + this.markTransformDirty(); + } + } + + get scaleX() { + return this._Scale[0]; + } + + set scaleX(value) { + if (this._Scale[0] != value) { + this._Scale[0] = value; + this.markTransformDirty(); + } + } + + get scaleY() { + return this._Scale[1]; + } + + set scaleY(value) { + if (this._Scale[1] != value) { + this._Scale[1] = value; + this.markTransformDirty(); + } + } + + get rotation() { + return this._Rotation; + } + + set rotation(value) { + if (this._Rotation != value) { + this._Rotation = value; + this.markTransformDirty(); + } + } + + get opacity() { + return this._Opacity; + } + + set opacity(value) { + if (this._Opacity != value) { + this._Opacity = value; + this.markTransformDirty(); + } + } + + update(dirt) { + if ((dirt & TransformDirty) === TransformDirty) { + _UpdateTransform(this); + } + if ((dirt & WorldTransformDirty) === WorldTransformDirty) { + this.updateWorldTransform(); + let constraints = this._Constraints; + if (constraints) { + for (let constraint of constraints) { + if (constraint.isEnabled) { + constraint.constrain(this); + } + } + } + } + } + + getWorldTransform() { + if ((this._DirtMask & WorldTransformDirty) !== WorldTransformDirty) { + return this._WorldTransform; + } + + let parent = this.parent; + let chain = [this]; + while (parent) { + chain.unshift(parent); + parent = parent.parent; + } + for (let item of chain) { + if (item instanceof ActorNode) { + if ((this._DirtMask & TransformDirty) !== TransformDirty) { + _UpdateTransform(this); + } + if ((this._DirtMask & WorldTransformDirty) !== WorldTransformDirty) { + item.updateWorldTransform(); + } + } + } + return this._WorldTransform; + } + + get transform() { + return this._Transform; + } + + get worldTransform() { + return this._WorldTransform; + } + + get worldTranslation() { + const transform = this._WorldTransform; + return gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), transform[4], transform[5]); + } + + setCollapsedVisibility(v) { + if (this._IsCollapsedVisibility === v) { + return; + } + + this._IsCollapsedVisibility = v; + this.markTransformDirty(); + } + + makeInstance(resetActor) { + const node = new ActorNode(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].copy(this._Transform, node._Transform); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].copy(this._WorldTransform, node._WorldTransform); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].copy(this._Translation, node._Translation); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].copy(this._Scale, node._Scale); + this._Rotation = node._Rotation; + this._Opacity = node._Opacity; + this._RenderOpacity = node._RenderOpacity; + this._OverrideWorldTransform = node._OverrideWorldTransform; + if (node._Clips) { + this._Clips = []; + for (let clip of node._Clips) { + this._Clips.push(clip._Idx); + } + } else { + this._Clips = null; + } + } + + overrideWorldTransform(transform) { + this._OverrideWorldTransform = transform ? true : false; + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].copy(this._WorldTransform, transform); + this.markTransformDirty(); + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + let clips = this._Clips; + if (!clips) { + return; + } + + for (let i = 0; i < clips.length; i++) { + let idx = clips[i]; + clips[i] = components[idx]; + } + } +} + +/***/ }), + +/***/ "./source/ActorNodeSolo.js": +/*!*********************************!*\ + !*** ./source/ActorNodeSolo.js ***! + \*********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorNodeSolo; }); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); + + +class ActorNodeSolo extends _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._ActiveChildIndex = 0; + } + + setActiveChildIndex(idx) { + this._ActiveChildIndex = Math.min(this._Children.length, Math.max(0, idx)); + + for (let i = 0; i < this._Children.length; ++i) { + const an = this._Children[i]; + const cv = i !== this._ActiveChildIndex - 1; + an.setCollapsedVisibility(cv); + } + } + + set activeChildIndex(index) { + if (index === this._ActiveChildIndex) { + return; + } + this.setActiveChildIndex(index); + } + + get activeChildIndex() { + return this._ActiveChildIndex; + } + + makeInstance(resetActor) { + let node = new ActorNodeSolo(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._ActiveChildIndex = node._ActiveChildIndex; + } + + completeResolve() { + super.completeResolve(); + // Hierarchy is resolved. + this.setActiveChildIndex(this._ActiveChildIndex); + } +} + +/***/ }), + +/***/ "./source/ActorPath.js": +/*!*****************************!*\ + !*** ./source/ActorPath.js ***! + \*****************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorPath; }); +/* harmony import */ var _ActorSkinnableNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorSkinnableNode.js */ "./source/ActorSkinnableNode.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); +/* harmony import */ var _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./PathPoint.js */ "./source/PathPoint.js"); +/* harmony import */ var _PathMatrix_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./PathMatrix.js */ "./source/PathMatrix.js"); + + + + + +const CircleConstant = 0.552284749831; +const InverseCircleConstant = 1.0 - CircleConstant; + +class ActorPath extends _ActorSkinnableNode_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._IsClosed = false; + this._IsHidden = false; + this._Points = []; + this._RenderPath = null; + this._Skin = null; + } + + setSkin(skin) { + this._Skin = skin; + } + + get isHidden() { + return this._IsHidden; + } + + set isHidden(hidden) { + this._IsHidden = hidden; + } + + get isClosed() { + return this._IsClosed; + } + + set isClosed(closed) { + this._IsClosed = closed; + } + + initialize(actor, graphics) {} + + get numPoints() { + return this._Points.length; + } + + getPathOBB() { + let min_x = Number.MAX_VALUE; + let min_y = Number.MAX_VALUE; + let max_x = -Number.MAX_VALUE; + let max_y = -Number.MAX_VALUE; + + const renderPoints = this.makeRenderPoints(); + for (let point of renderPoints) { + let t = point.translation; + + let x = t[0]; + let y = t[1]; + + if (x < min_x) { + min_x = x; + } + if (y < min_y) { + min_y = y; + } + if (x > max_x) { + max_x = x; + } + if (y > max_y) { + max_y = y; + } + + if (point.pointType !== _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["PointType"].Straight) { + let t = point.in; + x = t[0]; + y = t[1]; + if (x < min_x) { + min_x = x; + } + if (y < min_y) { + min_y = y; + } + if (x > max_x) { + max_x = x; + } + if (y > max_y) { + max_y = y; + } + + t = point.out; + x = t[0]; + y = t[1]; + if (x < min_x) { + min_x = x; + } + if (y < min_y) { + min_y = y; + } + if (x > max_x) { + max_x = x; + } + if (y > max_y) { + max_y = y; + } + } + } + + return [min_x, min_y, max_x, max_y]; + } + + getPathAABB() { + let min_x = Number.MAX_VALUE; + let min_y = Number.MAX_VALUE; + let max_x = -Number.MAX_VALUE; + let max_y = -Number.MAX_VALUE; + + const obb = this.getPathOBB(); + + const points = [gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].fromValues(obb[0], obb[1]), gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].fromValues(obb[2], obb[1]), gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].fromValues(obb[2], obb[3]), gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].fromValues(obb[0], obb[3])]; + let { _Transform: transform, isConnectedToBones } = this; + + if (isConnectedToBones) { + // If we're connected to bones, convert the path coordinates into local parent space. + transform = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(), this.parent._WorldTransform); + } + + for (let i = 0; i < points.length; i++) { + const pt = points[i]; + const wp = transform ? gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(pt, pt, transform) : pt; + if (wp[0] < min_x) { + min_x = wp[0]; + } + if (wp[1] < min_y) { + min_y = wp[1]; + } + + if (wp[0] > max_x) { + max_x = wp[0]; + } + if (wp[1] > max_y) { + max_y = wp[1]; + } + } + + return [min_x, min_y, max_x, max_y]; + } + + makeInstance(resetActor) { + const node = new ActorPath(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._IsClosed = node._IsClosed; + this._IsHidden = node._IsHidden; + + const pointCount = node._Points.length; + this._Points = new Array(pointCount); + for (let i = 0; i < pointCount; i++) { + let p = node._Points[i]; + this._Points[i] = p.makeInstance(); + } + } + + get deformedPoints() { + let boneTransforms = null; + if (this._Skin) { + boneTransforms = this._Skin.boneMatrices; + } + const { _Points: points, worldTransform } = this; + if (!boneTransforms) { + return points; + } + + const deformedPoints = []; + for (const point of points) { + deformedPoints.push(point.skin(worldTransform, boneTransforms)); + } + return deformedPoints; + } + + makeRenderPoints() { + let points = this.deformedPoints; + + let renderPoints = []; + + if (points.length) { + let pl = points.length; + const isClosed = this.isClosed; + let previous = isClosed ? points[points.length - 1] : null; + for (let i = 0; i < points.length; i++) { + let point = points[i]; + + switch (point.pointType) { + case _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["PointType"].Straight: + { + const radius = point.radius; + if (radius > 0) { + if (!isClosed && (i === 0 || i === pl - 1)) { + renderPoints.push(point); + previous = point; + } else { + let next = points[(i + 1) % pl]; + previous = previous.pointType === _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["PointType"].Straight ? previous.translation : previous.out; + next = next.pointType === _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["PointType"].Straight ? next.translation : next.in; + + const pos = point.translation; + + const toPrev = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), previous, pos); + const toPrevLength = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].length(toPrev); + toPrev[0] /= toPrevLength; + toPrev[1] /= toPrevLength; + + const toNext = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), next, pos); + const toNextLength = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].length(toNext); + toNext[0] /= toNextLength; + toNext[1] /= toNextLength; + + const renderRadius = Math.min(toPrevLength, Math.min(toNextLength, radius)); + + let translation = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].scaleAndAdd(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pos, toPrev, renderRadius); + const current = { + pointType: _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["PointType"].Disconnected, + translation: translation, + out: gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].scaleAndAdd(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pos, toPrev, InverseCircleConstant * renderRadius), + in: translation + }; + renderPoints.push(current); + + translation = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].scaleAndAdd(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pos, toNext, renderRadius); + + previous = { + pointType: _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["PointType"].Disconnected, + translation: translation, + in: gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].scaleAndAdd(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pos, toNext, InverseCircleConstant * renderRadius), + out: translation + }; + renderPoints.push(previous); + } + } else { + renderPoints.push(point); + previous = point; + } + break; + } + case _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["PointType"].Mirror: + case _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["PointType"].Disconnected: + case _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["PointType"].Asymmetric: + renderPoints.push(point); + previous = point; + break; + } + } + } + return renderPoints; + } + + getPathRenderTransform() { + if (!this.isConnectedToBones) { + return this.worldTransform; + } else { + return undefined; + } + } + + getPathTransform() { + if (!this.isConnectedToBones) { + return Object(_PathMatrix_js__WEBPACK_IMPORTED_MODULE_3__["default"])(this.worldTransform); + } else { + return undefined; + } + } + + invalidatePath() { + this._RenderPath = null; + } + + getPath() { + const renderPath = this._RenderPath; + if (renderPath) { + return renderPath; + } + + const path = new Path2D(); + + const renderPoints = this.makeRenderPoints(); + const isClosed = this.isClosed; + + if (renderPoints.length) { + let firstPoint = renderPoints[0]; + path.moveTo(firstPoint.translation[0], firstPoint.translation[1]); + for (let i = 0, l = isClosed ? renderPoints.length : renderPoints.length - 1, pl = renderPoints.length; i < l; i++) { + let point = renderPoints[i]; + let nextPoint = renderPoints[(i + 1) % pl]; + let cin = nextPoint.pointType === _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["PointType"].Straight ? null : nextPoint.in, + cout = point.pointType === _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["PointType"].Straight ? null : point.out; + if (cin === null && cout === null) { + path.lineTo(nextPoint.translation[0], nextPoint.translation[1]); + } else { + if (cout === null) { + cout = point.translation; + } + if (cin === null) { + cin = nextPoint.translation; + } + path.bezierCurveTo(cout[0], cout[1], cin[0], cin[1], nextPoint.translation[0], nextPoint.translation[1]); + } + } + if (isClosed) { + path.closePath(); + } + } + + this._RenderPath = path; + return path; + } +} + +/***/ }), + +/***/ "./source/ActorPolygon.js": +/*!********************************!*\ + !*** ./source/ActorPolygon.js ***! + \********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorPolygon; }); +/* harmony import */ var _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorProceduralPath.js */ "./source/ActorProceduralPath.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + +class ActorPolygon extends _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + this._Sides = 5; + } + + resolveComponentIndices(components) { + _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__["default"].prototype.resolveComponentIndices.call(this, components); + } + + makeInstance(resetActor) { + const node = new ActorPolygon(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._Sides = node._Sides; + } + + draw(ctx) { + const transform = this._WorldTransform; + ctx.save(); + ctx.transform(transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]); + + const radiusX = this._Width / 2; + const radiusY = this._Height / 2; + const sides = this._Sides; + + ctx.moveTo(0.0, -radiusY); + let angle = -Math.PI / 2.0; + const inc = Math.PI * 2.0 / sides; + for (let i = 0; i < sides; i++) { + ctx.lineTo(Math.cos(angle) * radiusX, Math.sin(angle) * radiusY); + angle += inc; + } + ctx.closePath(); + ctx.restore(); + } + + getPathAABB() { + let min_x = Number.MAX_VALUE; + let min_y = Number.MAX_VALUE; + let max_x = -Number.MAX_VALUE; + let max_y = -Number.MAX_VALUE; + + const transform = this._WorldTransform; + + function addPoint(pt) { + if (transform) { + pt = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pt, transform); + } + if (pt[0] < min_x) { + min_x = pt[0]; + } + if (pt[1] < min_y) { + min_y = pt[1]; + } + if (pt[0] > max_x) { + max_x = pt[0]; + } + if (pt[1] > max_y) { + max_y = pt[1]; + } + } + + const sides = this._Sides; + const radiusX = this.width / 2; + const radiusY = this.height / 2; + let angle = -Math.PI / 2.0; + let inc = Math.PI * 2.0 / sides; + addPoint([0.0, -radiusY]); + for (let i = 0; i < sides; i++) { + addPoint([Math.cos(angle) * radiusX, Math.sin(angle) * radiusY]); + angle += inc; + } + + return [gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].fromValues(min_x, min_y), gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].fromValues(max_x, max_y)]; + } +} + +/***/ }), + +/***/ "./source/ActorProceduralPath.js": +/*!***************************************!*\ + !*** ./source/ActorProceduralPath.js ***! + \***************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorProceduralPath; }); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); +/* harmony import */ var _PathMatrix_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./PathMatrix.js */ "./source/PathMatrix.js"); + + + + +class ActorProceduralPath extends _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + this._Width = 0; + this._Height = 0; + } + + get width() { + return this._Width; + } + + get height() { + return this._Height; + } + + resolveComponentIndices(components) { + _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"].prototype.resolveComponentIndices.call(this, components); + } + + makeInstance(resetActor) { + const node = ActorProceduralPath(); + ActorProceduralPath.prototype.copy.call(node, this, resetActor); + return node; + } + + getPathTransform() { + return Object(_PathMatrix_js__WEBPACK_IMPORTED_MODULE_2__["default"])(this._WorldTransform); + } + + getPathRenderTransform() { + return this.worldTransform; + } + + getPathAABB() { + let min_x = Number.MAX_VALUE; + let min_y = Number.MAX_VALUE; + let max_x = Number.MIN_VALUE; + let max_y = Number.MIN_VALUE; + + const transform = this._Transform; + function addPoint(point) { + if (transform) { + point = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), point, transform); + } + + if (point[0] < min_x) { + min_x = point[0]; + } + if (point[1] < min_y) { + min_y = point[1]; + } + if (point[0] > max_x) { + max_x = point[0]; + } + if (point[1] > max_y) { + max_y = point[1]; + } + } + + const radiusX = this._Width / 2; + const radiusY = this._Height / 2; + addPoint([-radiusX, -radiusY]); + addPoint([radiusX, -radiusY]); + addPoint([-radiusX, radiusY]); + addPoint([radiusX, radiusY]); + + return [min_x, min_y, max_x, max_y]; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._Width = node._Width; + this._Height = node._Height; + } +} + +/***/ }), + +/***/ "./source/ActorRectangle.js": +/*!**********************************!*\ + !*** ./source/ActorRectangle.js ***! + \**********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorRectangle; }); +/* harmony import */ var _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorProceduralPath.js */ "./source/ActorProceduralPath.js"); + + +class ActorRectangle extends _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + this._CornerRadius = 0.0; + } + + resolveComponentIndices(components) { + _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__["default"].prototype.resolveComponentIndices.call(this, components); + } + + makeInstance(resetActor) { + const node = new ActorRectangle(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._CornerRadius = node._CornerRadius; + } + + draw(ctx) { + const transform = this._WorldTransform; + ctx.save(); + ctx.transform(transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]); + + const halfWidth = Math.max(0, this._Width / 2); + const halfHeight = Math.max(0, this._Height / 2); + ctx.moveTo(-halfWidth, -halfHeight); + let r = this._CornerRadius; + if (r > 0) { + this._DrawRoundedRect(ctx, -halfWidth, -halfHeight, this._Width, this._Height, r); + } else { + ctx.rect(-halfWidth, -halfHeight, this._Width, this._Height); + } + ctx.restore(); + } + + _DrawRoundedRect(ctx, x, y, width, height, radius) { + if (width < 2 * radius) radius = width / 2; + if (height < 2 * radius) radius = height / 2; + ctx.beginPath(); + ctx.moveTo(x + radius, y); + ctx.arcTo(x + width, y, x + width, y + height, radius); + ctx.arcTo(x + width, y + height, x, y + height, radius); + ctx.arcTo(x, y + height, x, y, radius); + ctx.arcTo(x, y, x + width, y, radius); + ctx.closePath(); + } + + getPath() { + let { width, height, _CornerRadius: radius } = this; + const halfWidth = width / 2; + const halfHeight = height / 2; + const x = -halfWidth; + const y = -halfHeight; + const path = new Path2D(); + if (radius > 0.0) { + if (width < 2 * radius) radius = width / 2; + if (height < 2 * radius) radius = height / 2; + path.moveTo(x + radius, y); + path.arcTo(x + width, y, x + width, y + height, radius); + path.arcTo(x + width, y + height, x, y + height, radius); + path.arcTo(x, y + height, x, y, radius); + path.arcTo(x, y, x + width, y, radius); + path.closePath(); + } else { + path.rect(-halfWidth, -halfHeight, width, height); + } + return path; + } +} + +/***/ }), + +/***/ "./source/ActorRootBone.js": +/*!*********************************!*\ + !*** ./source/ActorRootBone.js ***! + \*********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorRootBone; }); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); + + +class ActorRootBone extends _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + } + + makeInstance(resetActor) { + const node = new ActorRootBone(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + } +} + +/***/ }), + +/***/ "./source/ActorRotationConstraint.js": +/*!*******************************************!*\ + !*** ./source/ActorRotationConstraint.js ***! + \*******************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorRotationConstraint; }); +/* harmony import */ var _ActorTargetedConstraint_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorTargetedConstraint.js */ "./source/ActorTargetedConstraint.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); +/* harmony import */ var _Decompose_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Decompose.js */ "./source/Decompose.js"); +/* harmony import */ var _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./TransformSpace.js */ "./source/TransformSpace.js"); + + + + + +const PI2 = Math.PI * 2; + +class ActorRotationConstraint extends _ActorTargetedConstraint_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + + this._Copy = false; + this._EnableMin = false; + this._EnableMax = false; + this._Offset = false; + + this._Min = -PI2; + this._Max = PI2; + this._Scale = 1.0; + + this._SourceSpace = _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__["default"].World; + this._DestSpace = _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__["default"].World; + this._MinMaxSpace = _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__["default"].World; + + this._ComponentsA = new Float32Array(6); + this._ComponentsB = new Float32Array(6); + } + + onDirty(dirt) { + this.markDirty(); + } + + makeInstance(resetActor) { + let node = new ActorRotationConstraint(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._Copy = node._Copy; + this._EnableMin = node._EnableMin; + this._EnableMax = node._EnableMax; + this._Offset = node._Offset; + + this._Min = node._Min; + this._Max = node._Max; + this._Scale = node._Scale; + + this._SourceSpace = node._SourceSpace; + this._DestSpace = node._DestSpace; + this._MinMaxSpace = node._MinMaxSpace; + } + + constrain(tip) { + let target = this._Target; + + let parent = this._Parent; + let grandParent = parent._Parent; + + let { _ComponentsA: componentsA, _ComponentsB: componentsB, _Strength: t, _SourceSpace: sourceSpace, _DestSpace: destSpace, _MinMaxSpace: minMaxSpace } = this; + + let transformA = parent.worldTransform; + let transformB = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(); + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Decompose"])(transformA, componentsA); + if (!target) { + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].copy(transformB, transformA); + componentsB[0] = componentsA[0]; + componentsB[1] = componentsA[1]; + componentsB[2] = componentsA[2]; + componentsB[3] = componentsA[3]; + componentsB[4] = componentsA[4]; + componentsB[5] = componentsA[5]; + } else { + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].copy(transformB, target.worldTransform); + if (sourceSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__["default"].Local) { + let sourceGrandParent = target.parent; + if (sourceGrandParent) { + let inverse = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(), sourceGrandParent.worldTransform); + transformB = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(inverse, inverse, transformB); + } + } + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Decompose"])(transformB, componentsB); + + if (!this._Copy) { + componentsB[4] = destSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__["default"].Local ? 0.0 : componentsA[4]; + } else { + componentsB[4] *= this._Scale; + if (this._Offset) { + componentsB[4] += parent._Rotation; + } + } + + if (destSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__["default"].Local) { + // Destination space is in parent transform coordinates. + // Recompose the parent local transform and get it in world, then decompose the world for interpolation. + if (grandParent) { + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Compose"])(transformB, componentsB); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(transformB, grandParent.worldTransform, transformB); + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Decompose"])(transformB, componentsB); + } + } + } + + let clampLocal = minMaxSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__["default"].Local && grandParent ? true : false; + if (clampLocal) { + // Apply min max in local space, so transform to local coordinates first. + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Compose"])(transformB, componentsB); + let inverse = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(), grandParent.worldTransform); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(transformB, inverse, transformB); + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Decompose"])(transformB, componentsB); + } + if (this._EnableMax && componentsB[4] > this._Max) { + componentsB[4] = this._Max; + } + if (this._EnableMin && componentsB[4] < this._Min) { + componentsB[4] = this._Min; + } + if (clampLocal) { + // Transform back to world. + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Compose"])(transformB, componentsB); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(transformB, grandParent.worldTransform, transformB); + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Decompose"])(transformB, componentsB); + } + + let angleA = componentsA[4] % PI2; + let angleB = componentsB[4] % PI2; + let diff = angleB - angleA; + if (diff > Math.PI) { + diff -= PI2; + } else if (diff < -Math.PI) { + diff += PI2; + } + + componentsB[4] = angleA + diff * t; + componentsB[0] = componentsA[0]; + componentsB[1] = componentsA[1]; + componentsB[2] = componentsA[2]; + componentsB[3] = componentsA[3]; + componentsB[5] = componentsA[5]; + + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Compose"])(parent.worldTransform, componentsB); + } +} + +/***/ }), + +/***/ "./source/ActorScaleConstraint.js": +/*!****************************************!*\ + !*** ./source/ActorScaleConstraint.js ***! + \****************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorScaleConstraint; }); +/* harmony import */ var _ActorAxisConstraint_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorAxisConstraint.js */ "./source/ActorAxisConstraint.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); +/* harmony import */ var _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./TransformSpace.js */ "./source/TransformSpace.js"); +/* harmony import */ var _Decompose_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./Decompose.js */ "./source/Decompose.js"); + + + + + +class ActorScaleConstraint extends _ActorAxisConstraint_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + + this._ComponentsA = new Float32Array(6); + this._ComponentsB = new Float32Array(6); + } + + makeInstance(resetActor) { + let node = new ActorScaleConstraint(); + node.copy(this, resetActor); + return node; + } + + constrain(tip) { + let target = this._Target; + + let parent = this._Parent; + let grandParent = parent._Parent; + + let { _ComponentsA: componentsA, _ComponentsB: componentsB, _Strength: t, _SourceSpace: sourceSpace, _DestSpace: destSpace, _MinMaxSpace: minMaxSpace } = this; + + let transformA = parent.worldTransform; + let transformB = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(); + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_3__["Decompose"])(transformA, componentsA); + if (!target) { + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].copy(transformB, transformA); + componentsB[0] = componentsA[0]; + componentsB[1] = componentsA[1]; + componentsB[2] = componentsA[2]; + componentsB[3] = componentsA[3]; + componentsB[4] = componentsA[4]; + componentsB[5] = componentsA[5]; + } else { + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].copy(transformB, target.worldTransform); + if (sourceSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__["default"].Local) { + let sourceGrandParent = target.parent; + if (sourceGrandParent) { + let inverse = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(), sourceGrandParent.worldTransform); + transformB = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(inverse, inverse, transformB); + } + } + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_3__["Decompose"])(transformB, componentsB); + + if (!this._CopyX) { + componentsB[2] = destSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__["default"].Local ? 1.0 : componentsA[2]; + } else { + componentsB[2] *= this._ScaleX; + if (this._Offset) { + componentsB[2] *= parent._Scale[0]; + } + } + + if (!this._CopyY) { + componentsB[3] = destSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__["default"].Local ? 0.0 : componentsA[3]; + } else { + componentsB[3] *= this._ScaleY; + + if (this._Offset) { + componentsB[3] *= parent._Scale[1]; + } + } + + if (destSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__["default"].Local) { + // Destination space is in parent transform coordinates. + // Recompose the parent local transform and get it in world, then decompose the world for interpolation. + if (grandParent) { + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_3__["Compose"])(transformB, componentsB); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(transformB, grandParent.worldTransform, transformB); + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_3__["Decompose"])(transformB, componentsB); + } + } + } + + let clampLocal = minMaxSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__["default"].Local && grandParent ? true : false; + if (clampLocal) { + // Apply min max in local space, so transform to local coordinates first. + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_3__["Compose"])(transformB, componentsB); + let inverse = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(), grandParent.worldTransform); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(transformB, inverse, transformB); + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_3__["Decompose"])(transformB, componentsB); + } + if (this._EnableMaxX && componentsB[2] > this._MaxX) { + componentsB[2] = this._MaxX; + } + if (this._EnableMinX && componentsB[2] < this._MinX) { + componentsB[2] = this._MinX; + } + if (this._EnableMaxY && componentsB[3] > this._MaxY) { + componentsB[3] = this._MaxY; + } + if (this._EnableMinY && componentsB[3] < this._MinY) { + componentsB[3] = this._MinY; + } + if (clampLocal) { + // Transform back to world. + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_3__["Compose"])(transformB, componentsB); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(transformB, grandParent.worldTransform, transformB); + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_3__["Decompose"])(transformB, componentsB); + } + + let ti = 1.0 - t; + + componentsB[4] = componentsA[4]; + componentsB[0] = componentsA[0]; + componentsB[1] = componentsA[1]; + componentsB[2] = componentsA[2] * ti + componentsB[2] * t; + componentsB[3] = componentsA[3] * ti + componentsB[3] * t; + componentsB[5] = componentsA[5]; + + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_3__["Compose"])(parent.worldTransform, componentsB); + } +} + +/***/ }), + +/***/ "./source/ActorShape.js": +/*!******************************!*\ + !*** ./source/ActorShape.js ***! + \******************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorShape; }); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); +/* harmony import */ var _ActorPath_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ActorPath.js */ "./source/ActorPath.js"); +/* harmony import */ var _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ActorProceduralPath.js */ "./source/ActorProceduralPath.js"); +/* harmony import */ var _ColorComponent_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./ColorComponent.js */ "./source/ColorComponent.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_4__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + + + + + +class ActorShape extends _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._DrawOrder = 0; + this._IsHidden = false; + + this._Paths = null; + this._Fills = null; + this._Strokes = null; + } + + get paths() { + return this._Paths; + } + + addFill(fill) { + if (!this._Fills) { + this._Fills = []; + } + this._Fills.push(fill); + } + + addStroke(stroke) { + if (!this._Strokes) { + this._Strokes = []; + } + this._Strokes.push(stroke); + } + + get isHidden() { + return this._IsHidden; + } + + set isHidden(hidden) { + this._IsHidden = hidden; + } + + initialize(actor, graphics) {} + + computeAABB() { + const clips = this.getClips(); + if (clips) { + let aabb = null; + for (const clip of clips) { + clip.all(function (node) { + if (node.constructor === ActorShape) { + let bounds = node.computeAABB(); + if (!aabb) { + aabb = bounds; + } else { + if (bounds[0] < aabb[0]) { + aabb[0] = bounds[0]; + } + if (bounds[1] < aabb[1]) { + aabb[1] = bounds[1]; + } + if (bounds[2] > aabb[2]) { + aabb[2] = bounds[2]; + } + if (bounds[3] > aabb[3]) { + aabb[3] = bounds[3]; + } + } + } + }); + } + return aabb; + } + + let aabb = null; + let maxStroke = 0.0; + if (this._Strokes) { + for (const stroke of this._Strokes) { + if (stroke.width > maxStroke) { + maxStroke = stroke.width; + } + } + } + for (const path of this._Children) { + if (path.constructor !== _ActorPath_js__WEBPACK_IMPORTED_MODULE_1__["default"] && !(path instanceof _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_2__["default"])) { + continue; + } + + if (path.numPoints < 2) { + continue; + } + + // This is the axis aligned bounding box in the space of the parent (this case our shape). + const pathAABB = path.getPathAABB(); + + if (!aabb) { + aabb = pathAABB; + } else { + // Combine. + aabb[0] = Math.min(aabb[0], pathAABB[0]); + aabb[1] = Math.min(aabb[1], pathAABB[1]); + + aabb[2] = Math.max(aabb[2], pathAABB[2]); + aabb[3] = Math.max(aabb[3], pathAABB[3]); + } + } + + const padStroke = maxStroke / 2.0; + aabb[0] -= padStroke; + aabb[1] -= padStroke; + aabb[2] += padStroke; + aabb[3] += padStroke; + + let min_x = Number.MAX_VALUE; + let min_y = Number.MAX_VALUE; + let max_x = -Number.MAX_VALUE; + let max_y = -Number.MAX_VALUE; + + if (!aabb) { + return null; + } + let world = this._WorldTransform; + + const points = [gl_matrix__WEBPACK_IMPORTED_MODULE_4__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_4__["vec2"].create(), aabb[0], aabb[1]), gl_matrix__WEBPACK_IMPORTED_MODULE_4__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_4__["vec2"].create(), aabb[2], aabb[1]), gl_matrix__WEBPACK_IMPORTED_MODULE_4__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_4__["vec2"].create(), aabb[2], aabb[3]), gl_matrix__WEBPACK_IMPORTED_MODULE_4__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_4__["vec2"].create(), aabb[0], aabb[3])]; + for (let i = 0; i < points.length; i++) { + const pt = points[i]; + const wp = gl_matrix__WEBPACK_IMPORTED_MODULE_4__["vec2"].transformMat2d(pt, pt, world); + if (wp[0] < min_x) { + min_x = wp[0]; + } + if (wp[1] < min_y) { + min_y = wp[1]; + } + + if (wp[0] > max_x) { + max_x = wp[0]; + } + if (wp[1] > max_y) { + max_y = wp[1]; + } + } + + return new Float32Array([min_x, min_y, max_x, max_y]); + } + + dispose(actor, graphics) {} + + draw(graphics) { + if (this._RenderCollapsed || this._IsHidden) { + return; + } + + const ctx = graphics.ctx; + ctx.save(); + ctx.globalAlpha = this._RenderOpacity; + this.clip(ctx); + const shapePath = this.getShapePath(); + + const { _Fills: fills, _Strokes: strokes } = this; + + if (fills) { + for (const fill of fills) { + fill.fill(ctx, shapePath); + } + } + if (strokes) { + for (const stroke of strokes) { + if (stroke._Width > 0) { + stroke.stroke(ctx, shapePath); + } + } + } + + // const aabb = this.computeAABB(); + // if(aabb) + // { + // ctx.fillStyle = "rgba(255,0,0,0.25)"; + // ctx.beginPath(); + // ctx.moveTo(aabb[0], aabb[1]); + // ctx.lineTo(aabb[2], aabb[1]); + // ctx.lineTo(aabb[2], aabb[3]); + // ctx.lineTo(aabb[0], aabb[3]); + // ctx.closePath(); + // ctx.fill(); + // } + ctx.restore(); + } + + getShapePath() { + const paths = this._Paths; + const shapePath = new Path2D(); + for (const path of paths) { + if (path.isHidden) { + continue; + } + shapePath.addPath(path.getPath(), path.getPathTransform()); + } + + return shapePath; + } + + getClips() { + // Find clips. + let clipSearch = this; + let clips = null; + while (clipSearch) { + if (clipSearch._Clips) { + clips = clipSearch._Clips; + break; + } + clipSearch = clipSearch.parent; + } + + return clips; + } + + clip(ctx) { + // Find clips. + const clips = this.getClips(); + + if (clips) { + const clipPath = new Path2D(); + for (let clip of clips) { + let shapes = new Set(); + clip.all(function (node) { + if (node.constructor === ActorShape) { + shapes.add(node); + } + }); + for (let shape of shapes) { + const paths = shape.paths; + for (const path of paths) { + clipPath.addPath(path.getPath(), path.getPathTransform()); + } + } + } + ctx.clip(clipPath); + } + } + + completeResolve() { + super.completeResolve(); + this._Paths = this._Children.filter(child => child.constructor === _ActorPath_js__WEBPACK_IMPORTED_MODULE_1__["default"] || child instanceof _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_2__["default"]); + } + + makeInstance(resetActor) { + const node = new ActorShape(); + node._IsInstance = true; + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._DrawOrder = node._DrawOrder; + this._IsHidden = node._IsHidden; + } +} + +/***/ }), + +/***/ "./source/ActorSkin.js": +/*!*****************************!*\ + !*** ./source/ActorSkin.js ***! + \*****************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorSkin; }); +/* harmony import */ var _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorComponent.js */ "./source/ActorComponent.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + +class ActorSkin extends _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._BoneMatrices = null; + } + + get boneMatrices() { + return this._BoneMatrices; + } + + update(dirt) { + const parent = this._Parent; + + if (parent && parent._ConnectedBones) { + const connectedBones = parent._ConnectedBones; + const length = (connectedBones.length + 1) * 6; + let bt = this._BoneMatrices; + if (!bt || bt.length !== length) { + this._BoneMatrices = bt = new Float32Array(length); + // First bone transform is always identity. + bt[0] = 1; + bt[1] = 0; + bt[2] = 0; + bt[3] = 1; + bt[4] = 0; + bt[5] = 0; + } + + let bidx = 6; // Start after first identity. + + const mat = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(); + + for (const cb of connectedBones) { + if (!cb.node) { + bt[bidx++] = 1; + bt[bidx++] = 0; + bt[bidx++] = 0; + bt[bidx++] = 1; + bt[bidx++] = 0; + bt[bidx++] = 0; + continue; + } + + const wt = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(mat, cb.node._WorldTransform, cb.ibind); + + bt[bidx++] = wt[0]; + bt[bidx++] = wt[1]; + bt[bidx++] = wt[2]; + bt[bidx++] = wt[3]; + bt[bidx++] = wt[4]; + bt[bidx++] = wt[5]; + } + } + + parent.invalidatePath(); + } + + makeInstance(resetActor) { + const node = new ActorSkin(); + node.copy(this, resetActor); + return node; + } + + completeResolve() { + super.completeResolve(); + const graph = this._Actor; + let path = this._Parent; + if (path) { + path.setSkin(this); + graph.addDependency(this, path); + const connectedBones = path.connectedBones; + if (connectedBones && connectedBones.length) { + for (const { node } of connectedBones) { + graph.addDependency(this, node); + const constraints = node.allConstraints; + + if (constraints) { + for (const constraint of constraints) { + graph.addDependency(this, constraint); + } + } + } + } + } + } +} + +/***/ }), + +/***/ "./source/ActorSkinnableNode.js": +/*!**************************************!*\ + !*** ./source/ActorSkinnableNode.js ***! + \**************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorSkinnableNode; }); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); + + +class ActorSkinnableNode extends _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._ConnectedBones = null; + } + + get connectedBones() { + return this._ConnectedBones; + } + + get isConnectedToBones() { + return this._ConnectedBones && this._ConnectedBones.length > 0; + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + if (this._ConnectedBones) { + for (let j = 0; j < this._ConnectedBones.length; j++) { + const cb = this._ConnectedBones[j]; + cb.node = components[cb.componentIndex]; + } + } + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + if (node._ConnectedBones) { + this._ConnectedBones = []; + for (const cb of node._ConnectedBones) { + // Copy all props except for the actual node reference which will update in our resolve. + this._ConnectedBones.push({ + componentIndex: cb.componentIndex, + bind: cb.bind, + ibind: cb.ibind + }); + } + } + } +} + +/***/ }), + +/***/ "./source/ActorStar.js": +/*!*****************************!*\ + !*** ./source/ActorStar.js ***! + \*****************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorStar; }); +/* harmony import */ var _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorProceduralPath.js */ "./source/ActorProceduralPath.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + +class ActorStar extends _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + this._Points = 5; + this._InnerRadius = 0.0; + } + + makeInstance(resetActor) { + const node = new ActorStar(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._Points = node._Points; + this._InnerRadius = node._InnerRadius; + } + + getOBB(transform) { + let min_x = Number.MAX_VALUE; + let min_y = Number.MAX_VALUE; + let max_x = -Number.MAX_VALUE; + let max_y = -Number.MAX_VALUE; + + function addPoint(pt) { + if (transform) { + pt = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pt, transform); + } + if (pt[0] < min_x) { + min_x = pt[0]; + } + if (pt[1] < min_y) { + min_y = pt[1]; + } + if (pt[0] > max_x) { + max_x = pt[0]; + } + if (pt[1] > max_y) { + max_y = pt[1]; + } + } + + const radiusX = this.width / 2; + const radiusY = this.height / 2; + + let angle = -Math.PI / 2.0; + + const inc = Math.PI * 2.0 / this.sides; + + const sx = [radiusX, radiusX * this._InnerRadius]; + const sy = [radiusY, radiusY * this._InnerRadius]; + addPoint([0.0, -radiusY]); + for (let i = 0; i < this.sides; i++) { + addPoint([Math.cos(angle) * sx[i % 2], Math.sin(angle) * sy[i % 2]]); + angle += inc; + } + + return [gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].fromValues(min_x, min_y), gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].fromValues(max_x, max_y)]; + } + + getPath() { + //const transform = this._WorldTransform; + const radius = this._InnerRadius; + + const path = new Path2D(); + + //ctx.save(); + //ctx.transform(transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]); + const radiusX = this._Width / 2; + const radiusY = this._Height / 2; + + path.moveTo(0.0, -radiusY); + + const inc = Math.PI * 2.0 / this.sides; + const sx = [radiusX, radiusX * radius]; + const sy = [radiusY, radiusY * radius]; + + let angle = -Math.PI / 2.0; + for (let i = 0; i < this.sides; i++) { + path.lineTo(Math.cos(angle) * sx[i % 2], Math.sin(angle) * sy[i % 2]); + angle += inc; + } + path.closePath(); + //ctx.restore(); + return path; + } + + get sides() { + return this._Points * 2; + } +} + +/***/ }), + +/***/ "./source/ActorTargetedConstraint.js": +/*!*******************************************!*\ + !*** ./source/ActorTargetedConstraint.js ***! + \*******************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorTargetedConstraint; }); +/* harmony import */ var _ActorConstraint_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorConstraint.js */ "./source/ActorConstraint.js"); + + +class ActorTargetedConstraint extends _ActorConstraint_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + + this._TargetIdx = 0; + this._Target = null; + } + + makeInstance(resetActor) { + const node = new ActorTargetedConstraint(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._TargetIdx = node._TargetIdx; + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + + if (this._TargetIdx !== 0) { + const target = components[this._TargetIdx]; + if (target) { + this._Target = target; + // Add dependency on target. + this._Actor.addDependency(this._Parent, target); + } + } + } +} + +/***/ }), + +/***/ "./source/ActorTransformConstraint.js": +/*!********************************************!*\ + !*** ./source/ActorTransformConstraint.js ***! + \********************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorTransformConstraint; }); +/* harmony import */ var _ActorTargetedConstraint_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorTargetedConstraint.js */ "./source/ActorTargetedConstraint.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); +/* harmony import */ var _Decompose_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./Decompose.js */ "./source/Decompose.js"); +/* harmony import */ var _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! ./TransformSpace.js */ "./source/TransformSpace.js"); + + + + + +const PI2 = Math.PI * 2; + +class ActorTransformConstraint extends _ActorTargetedConstraint_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + + this._SourceSpace = _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__["default"].World; + this._DestSpace = _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__["default"].World; + + this._ComponentsA = new Float32Array(6); + this._ComponentsB = new Float32Array(6); + } + + makeInstance(resetActor) { + let node = new ActorTransformConstraint(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._SourceSpace = node._SourceSpace; + this._DestSpace = node._DestSpace; + } + + constrain(tip) { + let target = this._Target; + if (!target) { + return; + } + + let parent = this._Parent; + + let { _ComponentsA: componentsA, _ComponentsB: componentsB, _Strength: t, _SourceSpace: sourceSpace, _DestSpace: destSpace } = this; + + let transformA = parent.worldTransform; + let transformB = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].clone(target.worldTransform); + if (sourceSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__["default"].Local) { + let grandParent = target.parent; + if (grandParent) { + let inverse = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(), grandParent.worldTransform); + transformB = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(inverse, inverse, transformB); + } + } + if (destSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_3__["default"].Local) { + let grandParent = parent.parent; + if (grandParent) { + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(transformB, grandParent.worldTransform, transformB); + } + } + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Decompose"])(transformA, componentsA); + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Decompose"])(transformB, componentsB); + + let angleA = componentsA[4] % PI2; + let angleB = componentsB[4] % PI2; + let diff = angleB - angleA; + if (diff > Math.PI) { + diff -= PI2; + } else if (diff < -Math.PI) { + diff += PI2; + } + + let ti = 1.0 - t; + + componentsB[4] = angleA + diff * t; + componentsB[0] = componentsA[0] * ti + componentsB[0] * t; + componentsB[1] = componentsA[1] * ti + componentsB[1] * t; + componentsB[2] = componentsA[2] * ti + componentsB[2] * t; + componentsB[3] = componentsA[3] * ti + componentsB[3] * t; + componentsB[5] = componentsA[5] * ti + componentsB[5] * t; + + Object(_Decompose_js__WEBPACK_IMPORTED_MODULE_2__["Compose"])(parent.worldTransform, componentsB); + } +} + +/***/ }), + +/***/ "./source/ActorTranslationConstraint.js": +/*!**********************************************!*\ + !*** ./source/ActorTranslationConstraint.js ***! + \**********************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorTranslationConstraint; }); +/* harmony import */ var _ActorAxisConstraint_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorAxisConstraint.js */ "./source/ActorAxisConstraint.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); +/* harmony import */ var _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./TransformSpace.js */ "./source/TransformSpace.js"); + + + + +class ActorTranslationConstraint extends _ActorAxisConstraint_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + } + + makeInstance(resetActor) { + let node = new ActorTranslationConstraint(); + node.copy(this, resetActor); + return node; + } + + constrain(tip) { + let target = this._Target; + + let parent = this._Parent; + let grandParent = parent._Parent; + + let { _Strength: t, _SourceSpace: sourceSpace, _DestSpace: destSpace, _MinMaxSpace: minMaxSpace } = this; + + let transformA = parent.worldTransform; + let translationA = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), transformA[4], transformA[5]); + let translationB = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(); + if (!target) { + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].copy(translationB, translationA); + } else { + let transformB = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].clone(target.worldTransform); + if (sourceSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__["default"].Local) { + let sourceGrandParent = target.parent; + if (sourceGrandParent) { + let inverse = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(), sourceGrandParent.worldTransform); + transformB = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].mul(inverse, inverse, transformB); + } + } + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].set(translationB, transformB[4], transformB[5]); + + if (!this._CopyX) { + translationB[0] = destSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__["default"].Local ? 0.0 : translationA[0]; + } else { + translationB[0] *= this._ScaleX; + if (this._Offset) { + translationB[0] += parent._Translation[0]; + } + } + + if (!this._CopyY) { + translationB[1] = destSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__["default"].Local ? 0.0 : translationA[1]; + } else { + translationB[1] *= this._ScaleY; + + if (this._Offset) { + translationB[1] += parent._Translation[1]; + } + } + + if (destSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__["default"].Local) { + // Destination space is in parent transform coordinates. + if (grandParent) { + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(translationB, translationB, grandParent.worldTransform); + } + } + } + + let clampLocal = minMaxSpace === _TransformSpace_js__WEBPACK_IMPORTED_MODULE_2__["default"].Local && grandParent ? true : false; + if (clampLocal) { + // Apply min max in local space, so transform to local coordinates first. + let temp = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["mat2d"].create(), grandParent.worldTransform); + // Get our target world coordinates in parent local. + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(translationB, translationB, temp); + } + if (this._EnableMaxX && translationB[0] > this._MaxX) { + translationB[0] = this._MaxX; + } + if (this._EnableMinX && translationB[0] < this._MinX) { + translationB[0] = this._MinX; + } + if (this._EnableMaxY && translationB[1] > this._MaxY) { + translationB[1] = this._MaxY; + } + if (this._EnableMinY && translationB[1] < this._MinY) { + translationB[1] = this._MinY; + } + if (clampLocal) { + // Transform back to world. + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(translationB, translationB, grandParent.worldTransform); + } + + let ti = 1.0 - t; + + // Just interpolate world translation + transformA[4] = translationA[0] * ti + translationB[0] * t; + transformA[5] = translationA[1] * ti + translationB[1] * t; + } +} + +/***/ }), + +/***/ "./source/ActorTriangle.js": +/*!*********************************!*\ + !*** ./source/ActorTriangle.js ***! + \*********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return ActorTriangle; }); +/* harmony import */ var _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorProceduralPath.js */ "./source/ActorProceduralPath.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + +class ActorTriangle extends _ActorProceduralPath_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor) { + super(actor); + } + + makeInstance(resetActor) { + const node = new ActorTriangle(); + node.copy(this, resetActor); + return node; + } + + getOBB(transform) { + let min_x = Number.MAX_VALUE; + let min_y = Number.MAX_VALUE; + let max_x = -Number.MAX_VALUE; + let max_y = -Number.MAX_VALUE; + + function addPoint(pt) { + if (transform) { + pt = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(), pt, transform); + } + if (pt[0] < min_x) { + min_x = pt[0]; + } + if (pt[1] < min_y) { + min_y = pt[1]; + } + if (pt[0] > max_x) { + max_x = pt[0]; + } + if (pt[1] > max_y) { + max_y = pt[1]; + } + } + + const radiusX = this.width / 2; + const radiusY = this.height / 2; + addPoint([0.0, -radiusY - 10]); + addPoint([radiusX, radiusY]); + addPoint([-radiusX, radiusY]); + + return [gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].fromValues(min_x, min_y), gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].fromValues(max_x, max_y)]; + } + + draw(ctx) { + const transform = this._WorldTransform; + ctx.save(); + ctx.transform(transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]); + const radiusX = Math.max(0, this._Width / 2); + const radiusY = Math.max(0, this._Height / 2); + + ctx.moveTo(0.0, -radiusY); + ctx.lineTo(radiusX, radiusY); + ctx.lineTo(-radiusX, radiusY); + ctx.closePath(); + ctx.restore(); + } +} + +/***/ }), + +/***/ "./source/AnimatedComponent.js": +/*!*************************************!*\ + !*** ./source/AnimatedComponent.js ***! + \*************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return AnimatedComponent; }); +class AnimatedComponent { + constructor(componentIndex) { + this._ComponentIndex = componentIndex; + this._Properties = []; + } +} + +/***/ }), + +/***/ "./source/AnimatedProperty.js": +/*!************************************!*\ + !*** ./source/AnimatedProperty.js ***! + \************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return AnimatedProperty; }); +function block(id, key) { + return { id, key }; +} + +const Blocks = { + Unknown: block(0, "unknown"), + PosX: block(1, "posX"), + PosY: block(2, "posY"), + ScaleX: block(3, "scaleX"), + ScaleY: block(4, "scaleY"), + Rotation: block(5, "rotation"), + Opacity: block(6, "opacity"), + DrawOrder: block(7, "drawOrder"), + Length: block(8, "length"), + VertexDeform: block(9, "vertices"), + ConstraintStrength: block(10, "strength"), + Trigger: block(11, "trigger"), + IntProperty: block(12, "intValue"), + FloatProperty: block(13, "floatValue"), + StringProperty: block(14, "stringValue"), + BooleanProperty: block(15, "boolValue"), + IsCollisionEnabled: block(16, "isCollisionEnabled"), + Sequence: block(17, "sequence"), + ActiveChildIndex: block(18, "activeChild"), + PathVertices: block(19, "pathVertices"), + FillColor: block(20, "fillColor"), + FillGradient: block(21, "fillGradient"), + FillRadial: block(22, "fillRadial"), + StrokeColor: block(23, "strokeColor"), + StrokeGradient: block(24, "strokeGradient"), + StrokeRadial: block(25, "strokeRadial"), + StrokeWidth: block(26, "strokeWidth"), + StrokeOpacity: block(27, "strokeOpacity"), + FillOpacity: block(28, "fillOpacity"), + ShapeWidth: block(29, "width"), + ShapeHeight: block(30, "height"), + CornerRadius: block(31, "cornerRadius"), + InnerRadius: block(32, "innerRadius") +}; + +const _Types = {}; +const _Map = new Map(); +for (const key in Blocks) { + const value = Blocks[key]; + _Types[key] = value.id; + _Map.set(value.key, value.id); +} + +class AnimatedProperty { + constructor(type) { + this._Type = type; + this._KeyFrames = []; + } + + static get Types() { + return _Types; + } + + static fromString(label) { + return _Map.get(label) || 0; + } +} + +AnimatedProperty.Properties = {}; + +/***/ }), + +/***/ "./source/Animation.js": +/*!*****************************!*\ + !*** ./source/Animation.js ***! + \*****************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Animation; }); +/* harmony import */ var _AnimatedProperty_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./AnimatedProperty.js */ "./source/AnimatedProperty.js"); +/* harmony import */ var _ActorBone_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ActorBone.js */ "./source/ActorBone.js"); +/* harmony import */ var _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./PathPoint.js */ "./source/PathPoint.js"); + + + +const AnimatedPropertyTypes = _AnimatedProperty_js__WEBPACK_IMPORTED_MODULE_0__["default"].Types; + +function keyFrameLocation(seconds, list, start, end) { + let mid; + let element; + while (start <= end) { + mid = start + end >> 1; + element = list[mid]._Time; + if (element < seconds) { + start = mid + 1; + } else if (element > seconds) { + end = mid - 1; + } else { + return mid; + } + } + return start; +} + +class Animation { + constructor(artboard) { + this._Artboard = artboard; + this._Components = []; + this._TriggerComponents = []; + this._DisplayStart = 0; + this._DisplayEnd = 0; + + this._Name = null; + this._FPS = 60; + this._Duration = 0; + this._Loop = false; + } + + get duration() { + return this._Duration; + } + + triggerEvents(artboardComponents, fromTime, toTime, triggered) { + const keyedTriggerComponents = this._TriggerComponents; + for (let i = 0; i < keyedTriggerComponents.length; i++) { + const keyedComponent = keyedTriggerComponents[i]; + const properties = keyedComponent._Properties; + for (let j = 0; j < properties.length; j++) { + const property = properties[j]; + switch (property._Type) { + case AnimatedPropertyTypes.Trigger: + { + const keyFrames = property._KeyFrames; + + const kfl = keyFrames.length; + if (kfl === 0) { + continue; + } + + const idx = keyFrameLocation(toTime, keyFrames, 0, keyFrames.length - 1); + if (idx === 0) { + if (keyFrames.length > 0 && keyFrames[0]._Time === toTime) { + const component = artboardComponents[keyedComponent._ComponentIndex]; + triggered.push({ + name: component._Name, + component: component, + propertyType: property._Type, + keyFrameTime: toTime, + elapsed: 0 + }); + } + } else { + for (let k = idx - 1; k >= 0; k--) { + const frame = keyFrames[k]; + if (frame._Time > fromTime) { + const component = artboardComponents[keyedComponent._ComponentIndex]; + triggered.push({ + name: component._Name, + component: component, + propertyType: property._Type, + keyFrameTime: frame._Time, + elapsed: toTime - frame._Time + }); + } else { + break; + } + } + } + break; + } + default: + break; + } + } + } + } + + apply(time, artboard, mix) { + const components = this._Components; + const imix = 1.0 - mix; + const artboardComponents = artboard._Components; + for (let i = 0; i < components.length; i++) { + const animatedComponent = components[i]; + const component = artboardComponents[animatedComponent._ComponentIndex]; + if (!component) { + continue; + } + + const properties = animatedComponent._Properties; + for (let j = 0; j < properties.length; j++) { + const property = properties[j]; + const keyFrames = property._KeyFrames; + + const kfl = keyFrames.length; + if (kfl === 0) { + continue; + } + + const idx = keyFrameLocation(time, keyFrames, 0, keyFrames.length - 1); + let value = 0.0; + + if (idx === 0) { + value = keyFrames[0]._Value; + } else { + if (idx < keyFrames.length) { + const fromFrame = keyFrames[idx - 1]; + const toFrame = keyFrames[idx]; + if (time == toFrame._Time) { + value = toFrame._Value; + } else { + let mix = (time - fromFrame._Time) / (toFrame._Time - fromFrame._Time); + const interpolator = fromFrame._Interpolator; + + if (interpolator) { + mix = interpolator.getEasedMix(mix); + } + value = fromFrame.interpolate(mix, toFrame); + } + } else { + const kf = keyFrames[idx - 1]; + value = kf._Value; + } + } + + let markDirty = false; + switch (property._Type) { + case AnimatedPropertyTypes.PosX: + if (mix === 1.0) { + component._Translation[0] = value; + } else { + component._Translation[0] = component._Translation[0] * imix + value * mix; + } + + markDirty = true; + break; + case AnimatedPropertyTypes.PosY: + if (mix === 1.0) { + component._Translation[1] = value; + } else { + component._Translation[1] = component._Translation[1] * imix + value * mix; + } + markDirty = true; + break; + case AnimatedPropertyTypes.ScaleX: + if (mix === 1.0) { + component._Scale[0] = value; + } else { + component._Scale[0] = value * imix + value * mix; + } + markDirty = true; + break; + case AnimatedPropertyTypes.ScaleY: + if (mix === 1.0) { + component._Scale[1] = value; + } else { + component._Scale[1] = value * imix + value * mix; + } + markDirty = true; + break; + case AnimatedPropertyTypes.Rotation: + if (mix === 1.0) { + component._Rotation = value; + } else { + component._Rotation = component._Rotation * imix + value * mix; + } + markDirty = true; + break; + case AnimatedPropertyTypes.Opacity: + if (mix === 1.0) { + component._Opacity = value; + } else { + component._Opacity = component._Opacity * imix + value * mix; + } + markDirty = true; + break; + case AnimatedPropertyTypes.ConstraintStrength: + if (mix === 1.0) { + component.strength = value; + } else { + component.strength = component._Strength * imix + value * mix; + } + break; + case AnimatedPropertyTypes.DrawOrder: + if (artboard._LastSetDrawOrder != value) { + artboard._LastSetDrawOrder = value; + for (let i = 0; i < value.length; i++) { + const v = value[i]; + artboardComponents[v.componentIdx]._DrawOrder = v.value; + } + artboard._IsImageSortDirty = true; + } + break; + case AnimatedPropertyTypes.Length: + markDirty = true; + if (mix === 1.0) { + component._Length = value; + } else { + component._Length = component._Length * imix + value * mix; + } + + for (let l = 0; l < component._Children.length; l++) { + const chd = component._Children[l]; + if (chd.constructor === _ActorBone_js__WEBPACK_IMPORTED_MODULE_1__["default"]) { + chd._Translation[0] = component._Length; + chd._IsDirty = true; + } + } + break; + case AnimatedPropertyTypes.VertexDeform: + { + component._VerticesDirty = true; + const nv = component._NumVertices; + const to = component._AnimationDeformedVertices; + let tidx = 0; + let fidx = 0; + if (mix === 1.0) { + for (let l = 0; l < nv; l++) { + to[tidx] = value[fidx++]; + to[tidx + 1] = value[fidx++]; + tidx += 2; + } + } else { + for (let l = 0; l < nv; l++) { + to[tidx] = to[tidx] * imix + value[fidx++] * mix; + to[tidx + 1] = to[tidx + 1] * imix + value[fidx++] * mix; + tidx += 2; + } + } + break; + } + case AnimatedPropertyTypes.StringProperty: + component._Value = value; + break; + case AnimatedPropertyTypes.IntProperty: + if (mix === 1.0) { + component._Value = value; + } else { + component._Value = Math.round(component._Value * imix + value * mix); + } + break; + case AnimatedPropertyTypes.FloatProperty: + if (mix === 1.0) { + component._Value = value; + } else { + component._Value = component._Value * imix + value * mix; + } + break; + case AnimatedPropertyTypes.BooleanProperty: + component._Value = value; + break; + case AnimatedPropertyTypes.IsCollisionEnabled: + component._IsCollisionEnabled = value; + break; + case AnimatedPropertyTypes.Sequence: + if (component._SequenceFrames) { + let frameIndex = Math.floor(value) % component._SequenceFrames.length; + if (frameIndex < 0) { + frameIndex += component._SequenceFrames.length; + } + component._SequenceFrame = frameIndex; + } + break; + + case AnimatedPropertyTypes.ActiveChildIndex: + component.activeChildIndex = value; + markDirty = true; + break; + + case AnimatedPropertyTypes.PathVertices: + { + let readIdx = 0; + if (mix !== 1.0) { + for (const point of component._Points) { + point._Translation[0] = point._Translation[0] * imix + value[readIdx++] * mix; + point._Translation[1] = point._Translation[1] * imix + value[readIdx++] * mix; + if (point.constructor === _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["StraightPathPoint"]) { + point._Radius = point._Radius * imix + value[readIdx++] * mix; + } else { + point._In[0] = point._In[0] * imix + value[readIdx++] * mix; + point._In[1] = point._In[1] * imix + value[readIdx++] * mix; + point._Out[0] = point._Out[0] * imix + value[readIdx++] * mix; + point._Out[1] = point._Out[1] * imix + value[readIdx++] * mix; + } + } + } else { + for (const point of component._Points) { + point._Translation[0] = value[readIdx++]; + point._Translation[1] = value[readIdx++]; + if (point.constructor === _PathPoint_js__WEBPACK_IMPORTED_MODULE_2__["StraightPathPoint"]) { + point._Radius = value[readIdx++]; + } else { + point._In[0] = value[readIdx++]; + point._In[1] = value[readIdx++]; + point._Out[0] = value[readIdx++]; + point._Out[1] = value[readIdx++]; + } + } + } + break; + } + case AnimatedPropertyTypes.ShapeWidth: + case AnimatedPropertyTypes.StrokeWidth: + if (mix === 1.0) { + component._Width = value; + } else { + component._Width = component._Width * imix + value * mix; + } + break; + case AnimatedPropertyTypes.FillOpacity: + case AnimatedPropertyTypes.StrokeOpacity: + if (mix === 1.0) { + component._Opacity = value; + } else { + component._Opacity = component._Opacity * imix + value * mix; + } + break; + case AnimatedPropertyTypes.FillColor: + case AnimatedPropertyTypes.StrokeColor: + { + const color = component._Color; + if (mix === 1.0) { + color[0] = value[0]; + color[1] = value[1]; + color[2] = value[2]; + color[3] = value[3]; + } else { + color[0] = color[0] * imix + value[0] * mix; + color[1] = color[1] * imix + value[1] * mix; + color[2] = color[2] * imix + value[2] * mix; + color[3] = color[3] * imix + value[3] * mix; + } + break; + } + case AnimatedPropertyTypes.FillGradient: + case AnimatedPropertyTypes.StrokeGradient: + { + if (mix === 1.0) { + let ridx = 0; + component._Start[0] = value[ridx++]; + component._Start[1] = value[ridx++]; + component._End[0] = value[ridx++]; + component._End[1] = value[ridx++]; + + const cs = component._ColorStops; + let wi = 0; + while (ridx < value.length && wi < cs.length) { + cs[wi++] = value[ridx++]; + } + } else { + let ridx = 0; + component._Start[0] = component._Start[0] * imix + value[ridx++] * mix; + component._Start[1] = component._Start[1] * imix + value[ridx++] * mix; + component._End[0] = component._End[0] * imix + value[ridx++] * mix; + component._End[1] = component._End[1] * imix + value[ridx++] * mix; + + const cs = component._ColorStops; + let wi = 0; + while (ridx < value.length && wi < cs.length) { + cs[wi] = cs[wi] * imix + value[ridx++]; + wi++; + } + } + break; + } + case AnimatedPropertyTypes.FillRadial: + case AnimatedPropertyTypes.StrokeRadial: + { + if (mix === 1.0) { + let ridx = 0; + component._SecondaryRadiusScale = value[ridx++]; + component._Start[0] = value[ridx++]; + component._Start[1] = value[ridx++]; + component._End[0] = value[ridx++]; + component._End[1] = value[ridx++]; + + const cs = component._ColorStops; + let wi = 0; + while (ridx < value.length && wi < cs.length) { + cs[wi++] = value[ridx++]; + } + } else { + let ridx = 0; + component._SecondaryRadiusScale = component._SecondaryRadiusScale * imix + value[ridx++] * mix; + component._Start[0] = component._Start[0] * imix + value[ridx++] * mix; + component._Start[1] = component._Start[1] * imix + value[ridx++] * mix; + component._End[0] = component._End[0] * imix + value[ridx++] * mix; + component._End[1] = component._End[1] * imix + value[ridx++] * mix; + + const cs = component._ColorStops; + let wi = 0; + while (ridx < value.length && wi < cs.length) { + cs[wi] = cs[wi] * imix + value[ridx++]; + wi++; + } + } + break; + } + case AnimatedPropertyTypes.ShapeHeight: + if (mix === 1.0) { + component._Height = value; + } else { + component._Height = component._Height * imix + value * mix; + } + break; + case AnimatedPropertyTypes.CornerRadius: + if (mix === 1.0) { + component._CornerRadius = value; + } else { + component._CornerRadius = component._CornerRadius * imix + value * mix; + } + break; + case AnimatedPropertyTypes.InnerRadius: + if (mix === 1.0) { + component._InnerRadius = value; + } else { + component._InnerRadius = component._InnerRadius * imix + value * mix; + } + break; + + } + + if (markDirty) { + component.markTransformDirty(); + } + } + } + } +} + +/***/ }), + +/***/ "./source/AnimationInstance.js": +/*!*************************************!*\ + !*** ./source/AnimationInstance.js ***! + \*************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return AnimationInstance; }); +/* harmony import */ var _Dispatcher_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./Dispatcher.js */ "./source/Dispatcher.js"); + + +class AnimationInstance extends _Dispatcher_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(actor, animation) { + super(); + this._Actor = actor; + this._Animation = animation; + this._Time = 0; + + this._Min = animation._DisplayStart || 0; + this._Max = animation._DisplayEnd || animation._Duration; + this._Loop = animation._Loop; + this._Range = this._Max - this._Min; + } + + get loop() { + return this._Loop; + } + + set loop(value) { + this._Loop = value; + } + + get time() { + return this._Time; + } + + get isOver() { + return this._Time >= this._Max; + } + + set time(newTime) { + const delta = newTime - this._Time; + let time = this._Time + delta % this._Range; + + if (time < this._Min) { + if (this._Loop) { + time = this._Max - (this._Min - time); + } else { + time = this._Min; + } + } else if (time > this._Max) { + if (this._Loop) { + time = this._Min + (time - this._Max); + } else { + time = this._Max; + } + } + this._Time = time; + } + + reset() { + this._Time = 0.0; + } + + advance(seconds) { + const triggeredEvents = []; + const actorComponents = this._Actor._Components; + let time = this._Time; + time += seconds % this._Range; + if (time < this._Min) { + if (this._Loop) { + this._Animation.triggerEvents(actorComponents, time, this._Time, triggeredEvents); + time = this._Max - (this._Min - time); + this._Animation.triggerEvents(actorComponents, time, this._Max, triggeredEvents); + } else { + time = this._Min; + if (this._Time != time) { + this._Animation.triggerEvents(actorComponents, this._Min, this._Time, triggeredEvents); + } + } + } else if (time > this._Max) { + if (this._Loop) { + this._Animation.triggerEvents(actorComponents, time, this._Time, triggeredEvents); + time = this._Min + (time - this._Max); + this._Animation.triggerEvents(actorComponents, this._Min - 0.001, time, triggeredEvents); + } else { + time = this._Max; + if (this._Time != time) { + this._Animation.triggerEvents(actorComponents, this._Time, this._Max, triggeredEvents); + } + } + } else if (time > this._Time) { + this._Animation.triggerEvents(actorComponents, this._Time, time, triggeredEvents); + } else { + this._Animation.triggerEvents(actorComponents, time, this._Time, triggeredEvents); + } + + for (let i = 0; i < triggeredEvents.length; i++) { + const event = triggeredEvents[i]; + this.dispatch("animationEvent", event); + this._Actor.dispatch("animationEvent", event); + } + this._Time = time; + + return triggeredEvents; + } + + apply(actor, mix) { + this._Animation.apply(this._Time, actor, mix); + } +} + +/***/ }), + +/***/ "./source/BezierAnimationCurve.js": +/*!****************************************!*\ + !*** ./source/BezierAnimationCurve.js ***! + \****************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return BezierAnimationCurve; }); +function cuberoot(x) { + const y = Math.pow(Math.abs(x), 1 / 3); + return x < 0 ? -y : y; +} + +function yFromT(t, E, F, G, H) { + const y = E * (t * t * t) + F * (t * t) + G * t + H; + return y; +} + +// http://stackoverflow.com/questions/27176423/function-to-solve-cubic-equation-analytically +function solveCubic(a, b, c, d) { + if (Math.abs(a) < Number.EPSILON) { + // Quadratic case, ax^2+bx+c=0 + a = b; + b = c; + c = d; + if (Math.abs(a) < Number.EPSILON) { + // Linear case, ax+b=0 + a = b; + b = c; + if (Math.abs(a) < Number.EPSILON) // Degenerate case + { + return []; + } + return [-b / a]; + } + + const D = b * b - 4 * a * c; + if (Math.abs(D) < Number.EPSILON) return [-b / (2 * a)];else if (D > 0) return [(-b + Math.sqrt(D)) / (2 * a), (-b - Math.sqrt(D)) / (2 * a)]; + return []; + } + + // Convert to depressed cubic t^3+pt+q = 0 (subst x = t - b/3a) + const p = (3 * a * c - b * b) / (3 * a * a); + const q = (2 * b * b * b - 9 * a * b * c + 27 * a * a * d) / (27 * a * a * a); + let roots; + + if (Math.abs(p) < Number.EPSILON) { + // p = 0 -> t^3 = -q -> t = -q^1/3 + roots = [cuberoot(-q)]; + } else if (Math.abs(q) < Number.EPSILON) { + // q = 0 -> t^3 + pt = 0 -> t(t^2+p)=0 + roots = [0].concat(p < 0 ? [Math.sqrt(-p), -Math.sqrt(-p)] : []); + } else { + const D = q * q / 4 + p * p * p / 27; + if (Math.abs(D) < Number.EPSILON) { + // D = 0 -> two roots + roots = [-1.5 * q / p, 3 * q / p]; + } else if (D > 0) { + // Only one real root + const u = cuberoot(-q / 2 - Math.sqrt(D)); + roots = [u - p / (3 * u)]; + } else { + // D < 0, three roots, but needs to use complex numbers/trigonometric solution + const u = 2 * Math.sqrt(-p / 3); + const t = Math.acos(3 * q / p / u) / 3; // D < 0 implies p < 0 and acos argument in [-1..1] + const k = 2 * Math.PI / 3; + roots = [u * Math.cos(t), u * Math.cos(t - k), u * Math.cos(t - 2 * k)]; + } + } + + // Convert back from depressed cubic + for (let i = 0; i < roots.length; i++) { + roots[i] -= b / (3 * a); + } + return roots; +} + +class BezierAnimationCurve { + constructor(pos1, control1, control2, pos2) { + const y0a = pos1[1]; // initial y + const x0a = pos1[0]; // initial x + const y1a = control1[1]; // 1st influence y + const x1a = control1[0]; // 1st influence x + const y2a = control2[1]; // 2nd influence y + const x2a = control2[0]; // 2nd influence x + const y3a = pos2[1]; // final y + const x3a = pos2[0]; // final x + + this._E = y3a - 3 * y2a + 3 * y1a - y0a; + this._F = 3 * y2a - 6 * y1a + 3 * y0a; + this._G = 3 * y1a - 3 * y0a; + this._H = y0a; + + this._Y0a = y0a; + this._X0a = x0a; + this._Y1a = y1a; + this._X1a = x1a; + this._Y2a = y2a; + this._X2a = x2a; + this._Y3a = y3a; + this._X3a = x3a; + } + + get(x) { + const p0 = this._X0a - x; + const p1 = this._X1a - x; + const p2 = this._X2a - x; + const p3 = this._X3a - x; + + const a = p3 - 3 * p2 + 3 * p1 - p0; + const b = 3 * p2 - 6 * p1 + 3 * p0; + const c = 3 * p1 - 3 * p0; + const d = p0; + + const roots = solveCubic(a, b, c, d); + let t = 0; + for (let i = 0; i < roots.length; i++) { + const r = roots[i]; + if (r >= 0.0 && r <= 1.0) { + t = r; + break; + } + } + return yFromT(t, this._E, this._F, this._G, this._H); + } +} + +/***/ }), + +/***/ "./source/Block.js": +/*!*************************!*\ + !*** ./source/Block.js ***! + \*************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Block; }); +function block(id, key) { + return { id, key }; +} + +const Blocks = { + Nodes: block(1, "nodes"), + ActorNode: block(2, "node"), + ActorBone: block(3, "bone"), + ActorRootBone: block(4, "rootBone"), + ActorImage: block(5, "image"), + View: block(6, "view"), + Animation: block(7, "animation"), + Animations: block(8, "animations"), + Atlases: block(9, "atlases"), + Atlas: block(10, "atlas"), + ActorEvent: block(12, "event"), + CustomIntProperty: block(13, "customInt"), + CustomFloatProperty: block(14, "customFloat"), + CustomStringProperty: block(15, "customString"), + CustomBooleanProperty: block(16, "customBool"), + ActorImageSequence: block(22, "imageSequence"), + ActorNodeSolo: block(23, "solo"), + JellyComponent: block(28, "jelly"), + ActorJellyBone: block(29, "jellyBone"), + ActorIKConstraint: block(30, "ikConstraint"), + ActorDistanceConstraint: block(31, "distanceConstraint"), + ActorTranslationConstraint: block(32, "translationConstraint"), + ActorRotationConstraint: block(33, "rotationConstraint"), + ActorScaleConstraint: block(34, "scaleConstraint"), + ActorTransformConstraint: block(35, "transformConstraint"), + + ActorShape: block(100, "shape"), + ActorPath: block(101, "path"), + ColorFill: block(102, "colorFill"), + ColorStroke: block(103, "colorStroke"), + GradientFill: block(104, "gradientFill"), + GradientStroke: block(105, "gradientStroke"), + RadialGradientFill: block(106, "radialGradientFill"), + RadialGradientStroke: block(107, "radialGradientStroke"), + ActorEllipse: block(108, "ellipse"), + ActorRectangle: block(109, "rectangle"), + ActorTriangle: block(110, "triangle"), + ActorStar: block(111, "star"), + ActorPolygon: block(112, "polygon"), + ActorSkin: block(113, "skin"), + ActorArtboard: block(114, "artboard"), + Artboards: block(115, "artboards") +}; + +const _Types = {}; +const _Map = new Map(); +for (const key in Blocks) { + const value = Blocks[key]; + _Types[key] = value.id; + _Map.set(value.key, value.id); +} + +class Block { + static get Types() { + return _Types; + } + + static fromString(label) { + return _Map.get(label) || 0; + } +} + +/***/ }), + +/***/ "./source/ColorComponent.js": +/*!**********************************!*\ + !*** ./source/ColorComponent.js ***! + \**********************************/ +/*! exports provided: FillRule, ActorColor, ColorFill, ColorStroke, GradientColor, GradientFill, GradientStroke, RadialGradientColor, RadialGradientFill, RadialGradientStroke */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "FillRule", function() { return FillRule; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ActorColor", function() { return ActorColor; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ColorFill", function() { return ColorFill; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ColorStroke", function() { return ColorStroke; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GradientColor", function() { return GradientColor; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GradientFill", function() { return GradientFill; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "GradientStroke", function() { return GradientStroke; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RadialGradientColor", function() { return RadialGradientColor; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RadialGradientFill", function() { return RadialGradientFill; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "RadialGradientStroke", function() { return RadialGradientStroke; }); +/* harmony import */ var _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorComponent.js */ "./source/ActorComponent.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + +class FillRule { + static get EvenOdd() { + return 0; + } + + static get NonZero() { + return 1; + } +} + +class ActorPaint extends _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._Opacity = 1.0; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._Opacity = node._Opacity; + } + + get opacity() { + return this._Opacity; + } +} + +class ActorColor extends ActorPaint { + constructor() { + super(); + this._Color = new Float32Array(4); + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec4"].copy(this._Color, node._Color); + } + + get cssColor() { + const c = this._Color; + return "rgba(" + Math.round(c[0] * 255) + ", " + Math.round(c[1] * 255) + ", " + Math.round(c[2] * 255) + ", " + c[3] * this._Opacity + ")"; + } +} + +class ColorFill extends ActorColor { + constructor() { + super(); + this._FillRule = FillRule.EvenOdd; + } + + makeInstance(resetActor) { + const node = new ColorFill(); + ColorFill.prototype.copy.call(node, this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._FillRule = node._FillRule; + } + + fill(ctx, path) { + ctx.fillStyle = this.cssColor; + + switch (this._FillRule) { + case FillRule.EvenOdd: + ctx.fill(path, "evenodd"); + break; + case FillRule.NonZero: + ctx.fill(path, "nonzero"); + break; + } + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + if (this._Parent) { + this._Parent.addFill(this); + } + } +} + +class ColorStroke extends ActorColor { + constructor() { + super(); + this._Width = 0.0; + } + + get width() { + return this._Width; + } + + makeInstance(resetActor) { + const node = new ColorStroke(); + ColorStroke.prototype.copy.call(node, this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._Width = node._Width; + } + + stroke(ctx, path) { + ctx.strokeStyle = this.cssColor; + ctx.lineWidth = this._Width; + ctx.stroke(path); + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + if (this._Parent) { + this._Parent.addStroke(this); + } + } +} + +class GradientColor extends ActorPaint { + constructor() { + super(); + this._ColorStops = new Float32Array(10); + this._Start = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(); + this._End = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(); + this._RenderStart = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(); + this._RenderEnd = gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].create(); + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._ColorStops = new Float32Array(node._ColorStops); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].copy(this._Start, node._Start); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].copy(this._End, node._End); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].copy(this._RenderStart, node._RenderStart); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].copy(this._RenderEnd, node._RenderEnd); + } + + completeResolve() { + super.completeResolve(); + const graph = this._Actor; + const shape = this._Parent; + graph.addDependency(this, shape); + } + + update(dirt) { + const shape = this._Parent; + const world = shape.worldTransform; + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(this._RenderStart, this._Start, world); + gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].transformMat2d(this._RenderEnd, this._End, world); + } +} + +class GradientFill extends GradientColor { + constructor() { + super(); + this._FillRule = FillRule.EvenOdd; + } + + makeInstance(resetActor) { + const node = new GradientFill(); + GradientFill.prototype.copy.call(node, this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._FillRule = node._FillRule; + } + + fill(ctx, path) { + const { _RenderStart: start, _RenderEnd: end, _ColorStops: stops } = this; + const gradient = ctx.createLinearGradient(start[0], start[1], end[0], end[1]); + + const opacity = this._Opacity; + const numStops = stops.length / 5; + let idx = 0; + for (let i = 0; i < numStops; i++) { + const style = "rgba(" + Math.round(stops[idx++] * 255) + ", " + Math.round(stops[idx++] * 255) + ", " + Math.round(stops[idx++] * 255) + ", " + stops[idx++] * opacity + ")"; + const value = stops[idx++]; + gradient.addColorStop(value, style); + } + + ctx.fillStyle = gradient; + switch (this._FillRule) { + case FillRule.EvenOdd: + ctx.fill(path, "evenodd"); + break; + case FillRule.NonZero: + ctx.fill(path, "nonzero"); + break; + } + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + if (this._Parent) { + this._Parent.addFill(this); + } + } +} + +class GradientStroke extends GradientColor { + constructor() { + super(); + this._Width = 0.0; + } + + get width() { + return this._Width; + } + + makeInstance(resetActor) { + const node = new GradientStroke(); + GradientStroke.prototype.copy.call(node, this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._Width = node._Width; + } + + stroke(ctx, path) { + const { _RenderStart: start, _RenderEnd: end, _ColorStops: stops } = this; + const gradient = ctx.createLinearGradient(start[0], start[1], end[0], end[1]); + + const opacity = this._Opacity; + const numStops = stops.length / 5; + let idx = 0; + for (let i = 0; i < numStops; i++) { + const style = "rgba(" + Math.round(stops[idx++] * 255) + ", " + Math.round(stops[idx++] * 255) + ", " + Math.round(stops[idx++] * 255) + ", " + stops[idx++] * opacity + ")"; + const value = stops[idx++]; + gradient.addColorStop(value, style); + } + + ctx.lineWidth = this._Width; + ctx.strokeStyle = gradient; + ctx.stroke(path); + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + if (this._Parent) { + this._Parent.addStroke(this); + } + } +} + +class RadialGradientColor extends GradientColor { + constructor() { + super(); + this._SecondaryRadiusScale = 1.0; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._SecondaryRadiusScale = node._SecondaryRadiusScale; + } +} + +class RadialGradientFill extends RadialGradientColor { + constructor() { + super(); + this._FillRule = FillRule.EvenOdd; + } + + makeInstance(resetActor) { + const node = new RadialGradientFill(); + RadialGradientFill.prototype.copy.call(node, this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._FillRule = node._FillRule; + } + + fill(ctx, path) { + let { _RenderStart: start, _RenderEnd: end, _ColorStops: stops, _SecondaryRadiusScale: secondaryRadiusScale } = this; + const gradient = ctx.createRadialGradient(0.0, 0.0, 0.0, 0.0, 0.0, gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].distance(start, end)); + + const opacity = this._Opacity; + const numStops = stops.length / 5; + let idx = 0; + for (let i = 0; i < numStops; i++) { + const style = "rgba(" + Math.round(stops[idx++] * 255) + ", " + Math.round(stops[idx++] * 255) + ", " + Math.round(stops[idx++] * 255) + ", " + stops[idx++] * opacity + ")"; + const value = stops[idx++]; + gradient.addColorStop(value, style); + } + + ctx.fillStyle = gradient; + + // const squash = Math.max(0.00001, secondaryRadiusScale); + // const diff = vec2.subtract(vec2.create(), end, start); + // const angle = Math.atan2(diff[1], diff[0]); + // ctx.save(); + // ctx.translate(start[0], start[1]); + // ctx.rotate(angle); + // ctx.scale(1.0, squash); + + switch (this._FillRule) { + case FillRule.EvenOdd: + ctx.fill(path, "evenodd"); + break; + case FillRule.NonZero: + ctx.fill(path, "nonzero"); + break; + } + //ctx.restore(); + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + if (this._Parent) { + this._Parent.addFill(this); + } + } +} + +class RadialGradientStroke extends RadialGradientColor { + constructor() { + super(); + this._Width = 0.0; + } + + get width() { + return this._Width; + } + + makeInstance(resetActor) { + const node = new RadialGradientStroke(); + RadialGradientStroke.prototype.copy.call(node, this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + + this._Width = node._Width; + } + + stroke(ctx, path) { + + const { _RenderStart: start, _RenderEnd: end, _ColorStops: stops, _SecondaryRadiusScale: secondaryRadiusScale } = this; + const gradient = ctx.createRadialGradient(0.0, 0.0, 0.0, 0.0, 0.0, gl_matrix__WEBPACK_IMPORTED_MODULE_1__["vec2"].distance(start, end)); + + const opacity = this._Opacity; + const numStops = stops.length / 5; + let idx = 0; + for (let i = 0; i < numStops; i++) { + const style = "rgba(" + Math.round(stops[idx++] * 255) + ", " + Math.round(stops[idx++] * 255) + ", " + Math.round(stops[idx++] * 255) + ", " + stops[idx++] * opacity + ")"; + const value = stops[idx++]; + gradient.addColorStop(value, style); + } + + ctx.lineWidth = this._Width; + ctx.strokeStyle = gradient; + + // const squash = Math.max(0.00001, secondaryRadiusScale); + // const angleVector = vec2.subtract(vec2.create(), end, start); + // const angle = Math.atan2(angleVector[1], angleVector[0]); + + // ctx.save(); + // ctx.translate(start[0], start[1]); + // ctx.rotate(angle); + // ctx.scale(1.0, squash); + ctx.stroke(path); + // ctx.restore(); + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + if (this._Parent) { + this._Parent.addStroke(this); + } + } +} + +/***/ }), + +/***/ "./source/CustomProperty.js": +/*!**********************************!*\ + !*** ./source/CustomProperty.js ***! + \**********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return CustomProperty; }); +/* harmony import */ var _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorComponent.js */ "./source/ActorComponent.js"); + + +class CustomProperty extends _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + this._PropertyType = CustomProperty.Integer; + this._Value = 0; + } + + get propertyType() { + return this._PropertyType; + } + + get value() { + return this._Value; + } + + makeInstance(resetActor) { + const node = new CustomProperty(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._PropertyType = node._PropertyType; + this._Value = node._Value; + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + if (this._ParentIdx !== undefined) { + this._Parent = components[this._ParentIdx]; + if (this._Parent) { + this._Parent._CustomProperties.push(this); + } + } + } +} + +CustomProperty.Type = { + Integer: 0, + Float: 1, + String: 2, + Boolean: 3 +}; + +/***/ }), + +/***/ "./source/Decompose.js": +/*!*****************************!*\ + !*** ./source/Decompose.js ***! + \*****************************/ +/*! exports provided: Decompose, Compose */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Decompose", function() { return Decompose; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Compose", function() { return Compose; }); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + +function Decompose(m, result) { + let m0 = m[0], + m1 = m[1], + m2 = m[2], + m3 = m[3]; + + let rotation = Math.atan2(m1, m0); + let denom = m0 * m0 + m1 * m1; + let scaleX = Math.sqrt(denom); + let scaleY = (m0 * m3 - m2 * m1) / scaleX; + let skewX = Math.atan2(m0 * m2 + m1 * m3, denom); + + result[0] = m[4]; + result[1] = m[5]; + result[2] = scaleX; + result[3] = scaleY; + result[4] = rotation; + result[5] = skewX; +} + +function Compose(m, result) { + let r = result[4]; + + if (r !== 0) { + gl_matrix__WEBPACK_IMPORTED_MODULE_0__["mat2d"].fromRotation(m, r); + } else { + gl_matrix__WEBPACK_IMPORTED_MODULE_0__["mat2d"].identity(m); + } + m[4] = result[0]; + m[5] = result[1]; + gl_matrix__WEBPACK_IMPORTED_MODULE_0__["mat2d"].scale(m, m, [result[2], result[3]]); + + let sk = result[5]; + if (sk !== 0.0) { + m[2] = m[0] * sk + m[2]; + m[3] = m[1] * sk + m[3]; + } +} + +/***/ }), + +/***/ "./source/Dispatcher.js": +/*!******************************!*\ + !*** ./source/Dispatcher.js ***! + \******************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Dispatcher; }); +class Dispatcher { + constructor() { + this.events = {}; + } + + addEventListener(event, callback) { + let evt = this.events[event]; + if (!evt) { + this.events[event] = evt = []; + } + if (evt.indexOf(callback) !== -1) { + return; + } + evt.push(callback); + } + + removeEventListener(event, callback) { + let evt = this.events[event]; + if (!evt) { + return true; + } + for (let i = 0; i < evt.length; i++) { + if (evt[i] === callback) { + evt.splice(i, 1); + return true; + } + } + return false; + } + + dispatch(event, data, extraContext) { + let evt = this.events[event]; + if (evt) { + for (let i = 0; i < evt.length; i++) { + evt[i].call(this, data, extraContext); + } + } + } +} + +/***/ }), + +/***/ "./source/Flare.js": +/*!*************************!*\ + !*** ./source/Flare.js ***! + \*************************/ +/*! no static exports found */ +/***/ (function(module, exports, __webpack_require__) { + +exports.Graphics = __webpack_require__(/*! ./Graphics.js */ "./source/Graphics.js").default; +exports.ActorLoader = __webpack_require__(/*! ./ActorLoader.js */ "./source/ActorLoader.js").default; +exports.AnimationInstance = __webpack_require__(/*! ./AnimationInstance.js */ "./source/AnimationInstance.js").default; +exports.ActorCollider = __webpack_require__(/*! ./ActorCollider.js */ "./source/ActorCollider.js").default; +exports.ActorColliderPolygon = __webpack_require__(/*! ./ActorColliderPolygon.js */ "./source/ActorColliderPolygon.js").default; +exports.ActorColliderLine = __webpack_require__(/*! ./ActorColliderLine.js */ "./source/ActorColliderLine.js").default; +exports.ActorColliderCircle = __webpack_require__(/*! ./ActorColliderCircle.js */ "./source/ActorColliderCircle.js").default; +exports.ActorColliderRectangle = __webpack_require__(/*! ./ActorColliderRectangle.js */ "./source/ActorColliderRectangle.js").default; +exports.ActorColliderTriangle = __webpack_require__(/*! ./ActorColliderTriangle.js */ "./source/ActorColliderTriangle.js").default; + +/***/ }), + +/***/ "./source/Graphics.js": +/*!****************************!*\ + !*** ./source/Graphics.js ***! + \****************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return Graphics; }); +class Graphics { + constructor(canvas) { + if (!canvas) { + canvas = document.createElement("canvas"); + } + this._Canvas = canvas; + this._Context = canvas.getContext("2d"); + } + + get canvas() { + return this._Canvas; + } + + get ctx() { + return this._Context; + } + + dispose() {} + + get width() { + return this._Canvas.width; + } + + get height() { + return this._Canvas.height; + } + + clear(color) { + let ctx = this._Context; + let cvs = this._Canvas; + + ctx.clearRect(0, 0, cvs.width, cvs.height); + ctx.save(); + if (color && color[3]) { + ctx.fillStyle = "rgba(" + Math.round(color[0] * 255) + "," + Math.round(color[1] * 255) + "," + Math.round(color[2] * 255) + "," + color[3] + ")"; + ctx.rect(0, 0, cvs.width, cvs.height); + ctx.fill(); + } + } + + setView(transform) { + this.ctx.setTransform(transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]); + } + + flush() { + let ctx = this._Context; + ctx.restore(); + } + + get viewportWidth() { + return this._Canvas.width; + } + + get viewportHeight() { + return this._Canvas.height; + } + + setSize(width, height) { + if (this.width !== width || this.height !== height) { + this._Canvas.width = width; + this._Canvas.height = height; + return true; + } + return false; + } +} + +/***/ }), + +/***/ "./source/Interpolation.js": +/*!*********************************!*\ + !*** ./source/Interpolation.js ***! + \*********************************/ +/*! exports provided: Hold, Linear, Cubic */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Hold", function() { return Hold; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Linear", function() { return Linear; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "Cubic", function() { return Cubic; }); +/* harmony import */ var bezier_easing__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! bezier-easing */ "./node_modules/bezier-easing/src/index.js"); +/* harmony import */ var bezier_easing__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(bezier_easing__WEBPACK_IMPORTED_MODULE_0__); + + +class Hold { + getEasedMix(mix) { + return 0; + } +} + +Hold.instance = new Hold(); + +class Linear { + getEasedMix(mix) { + return mix; + } +} + +Linear.instance = new Linear(); + +class Cubic { + constructor(x1, y1, x2, y2) { + this._Bezier = bezier_easing__WEBPACK_IMPORTED_MODULE_0___default()(x1, y1, x2, y2); + } + + getEasedMix(mix) { + return this._Bezier(mix); + } +} + +/***/ }), + +/***/ "./source/JellyComponent.js": +/*!**********************************!*\ + !*** ./source/JellyComponent.js ***! + \**********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return JellyComponent; }); +/* harmony import */ var _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorComponent.js */ "./source/ActorComponent.js"); +/* harmony import */ var _ActorJellyBone_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! ./ActorJellyBone.js */ "./source/ActorJellyBone.js"); +/* harmony import */ var _ActorBoneBase_js__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(/*! ./ActorBoneBase.js */ "./source/ActorBoneBase.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + + + +// https://stackoverflow.com/questions/1734745/how-to-create-circle-with-b%C3%A9zier-curves +const JellyMax = 16; +const OptimalDistance = 4 * (Math.sqrt(2) - 1) / 3; +const CurveConstant = OptimalDistance * Math.sqrt(2) * 0.5; + +function ForwardDiffBezier(c0, c1, c2, c3, points, count, offset) { + let f = count; + + const p0 = c0; + + const p1 = 3.0 * (c1 - c0) / f; + + f *= count; + const p2 = 3.0 * (c0 - 2.0 * c1 + c2) / f; + + f *= count; + const p3 = (c3 - c0 + 3.0 * (c1 - c2)) / f; + + c0 = p0; + c1 = p1 + p2 + p3; + c2 = 2 * p2 + 6 * p3; + c3 = 6 * p3; + + for (let a = 0; a <= count; a++) { + points[a][offset] = c0; + c0 += c1; + c1 += c2; + c2 += c3; + } +} + +function NormalizeCurve(curve, numSegments) { + const points = []; + const curvePointCount = curve.length; + const distances = new Float32Array(curvePointCount); + distances[0] = 0; + for (let i = 0; i < curvePointCount - 1; i++) { + const p1 = curve[i]; + const p2 = curve[i + 1]; + distances[i + 1] = distances[i] + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].distance(p1, p2); + } + const totalDistance = distances[curvePointCount - 1]; + + const segmentLength = totalDistance / numSegments; + let pointIndex = 1; + for (let i = 1; i <= numSegments; i++) { + const distance = segmentLength * i; + + while (pointIndex < curvePointCount - 1 && distances[pointIndex] < distance) { + pointIndex++; + } + + const d = distances[pointIndex]; + const lastCurveSegmentLength = d - distances[pointIndex - 1]; + const remainderOfDesired = d - distance; + const ratio = remainderOfDesired / lastCurveSegmentLength; + const iratio = 1.0 - ratio; + + const p1 = curve[pointIndex - 1]; + const p2 = curve[pointIndex]; + points.push([p1[0] * ratio + p2[0] * iratio, p1[1] * ratio + p2[1] * iratio]); + } + + return points; +} + +const EPSILON = 0.001; // Intentionally aggressive. + +function FuzzyEquals(a, b) { + const a0 = a[0], + a1 = a[1]; + const b0 = b[0], + b1 = b[1]; + return Math.abs(a0 - b0) <= EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)); +} + +class JellyComponent extends _ActorComponent_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + + this._EaseIn = 0.0; + this._EaseOut = 0.0; + this._ScaleIn = 0.0; + this._ScaleOut = 0.0; + this._InTargetIdx = 0; + this._OutTargetIdx = 0; + this._InTarget = null; + this._OutTarget = null; + + this._Bones = []; + this._InPoint = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(); + this._InDirection = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(); + this._OutPoint = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(); + this._OutDirection = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(); + } + + makeInstance(resetActor) { + const node = new JellyComponent(); + node.copy(this, resetActor); + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._EaseIn = node._EaseIn; + this._EaseOut = node._EaseOut; + this._ScaleIn = node._ScaleIn; + this._ScaleOut = node._ScaleOut; + this._InTargetIdx = node._InTargetIdx; + this._OutTargetIdx = node._OutTargetIdx; + } + + resolveComponentIndices(components) { + super.resolveComponentIndices(components); + + if (this._InTargetIdx !== 0) { + this._InTarget = components[this._InTargetIdx]; + } + if (this._OutTargetIdx !== 0) { + this._OutTarget = components[this._OutTargetIdx]; + } + + // Add dependencies. + const { _Actor: actor, _Parent: bone } = this; + let dependencyConstraints = []; + if (bone) { + actor.addDependency(this, bone); + dependencyConstraints = dependencyConstraints.concat(Array.from(bone.allConstraints)); + let firstBone = bone.firstBone; + if (firstBone) { + actor.addDependency(this, firstBone); + dependencyConstraints = dependencyConstraints.concat(Array.from(firstBone.allConstraints)); + + // If we don't have an out target and the child jelly does have an in target + // we are dependent on that target's position. + if (!this.outTarget && firstBone.jelly && firstBone.jelly.inTarget) { + actor.addDependency(this, firstBone.jelly.inTarget); + dependencyConstraints = dependencyConstraints.concat(Array.from(firstBone.jelly.inTarget.allConstraints)); + } + } + let parentBone = bone.parent instanceof _ActorBoneBase_js__WEBPACK_IMPORTED_MODULE_2__["default"] && bone.parent; + let parentBoneJelly = parentBone && parentBone.jelly; + if (parentBoneJelly && parentBoneJelly.outTarget) { + actor.addDependency(this, parentBoneJelly.outTarget); + dependencyConstraints = dependencyConstraints.concat(Array.from(parentBoneJelly.outTarget.allConstraints)); + } + } + + if (this._InTarget) { + actor.addDependency(this, this._InTarget); + dependencyConstraints = dependencyConstraints.concat(Array.from(this._InTarget.allConstraints)); + } + if (this._OutTarget) { + actor.addDependency(this, this._OutTarget); + dependencyConstraints = dependencyConstraints.concat(Array.from(this._OutTarget.allConstraints)); + } + + dependencyConstraints = new Set(dependencyConstraints); + + for (const constraint of dependencyConstraints) { + actor.addDependency(this, constraint); + } + } + + completeResolve() { + super.completeResolve(); + + const { _Actor: actor, _Parent: bone } = this; + bone._Jelly = this; + + // Get jellies. + const children = bone._Children; + if (!children) { + return; + } + for (const child of children) { + if (child.constructor === _ActorJellyBone_js__WEBPACK_IMPORTED_MODULE_1__["default"]) { + this._Bones.push(child); + actor.addDependency(child, this); + } + } + } + + updateJellies() { + const bone = this._Parent; + // We are in local bone space. + const tipPosition = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), bone._Length, 0.0); + const jc = this._Cache; + + const jellies = this._Bones; + if (!jellies) { + return; + } + + if (jc && FuzzyEquals(jc.tip, tipPosition) && FuzzyEquals(jc.out, this._OutPoint) && FuzzyEquals(jc.in, this._InPoint) && jc.sin === this._ScaleIn && jc.sout === this._ScaleOut) { + return; + } + + this._Cache = { + tip: tipPosition, + out: gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].clone(this._OutPoint), + in: gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].clone(this._InPoint), + sin: this._ScaleIn, + sout: this._ScaleOut + }; + + const q0 = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(); + const q1 = this._InPoint; + const q2 = this._OutPoint; + const q3 = tipPosition; + + const subdivisions = JellyMax; + const points = []; + for (let i = 0; i <= subdivisions; i++) { + points.push(new Float32Array(2)); + } + + ForwardDiffBezier(q0[0], q1[0], q2[0], q3[0], points, subdivisions, 0); + ForwardDiffBezier(q0[1], q1[1], q2[1], q3[1], points, subdivisions, 1); + + const normalizedPoints = NormalizeCurve(points, jellies.length); + + let lastPoint = points[0]; + + let scale = this._ScaleIn; + const scaleInc = (this._ScaleOut - this._ScaleIn) / (jellies.length - 1); + for (let i = 0; i < normalizedPoints.length; i++) { + const jelly = jellies[i]; + const p = normalizedPoints[i]; + + // We could set these by component and allow the mark to happen only if things have changed + // but it's really likely that we have to mark dirty here, so might as well optimize the general case. + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].copy(jelly._Translation, lastPoint); + jelly._Length = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].distance(p, lastPoint); + jelly._Scale[1] = scale; + scale += scaleInc; + + const diff = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), p, lastPoint); + jelly._Rotation = Math.atan2(diff[1], diff[0]); + jelly.markTransformDirty(); + lastPoint = p; + } + } + + get tipPosition() { + const bone = this._Parent; + return gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), bone._Length, 0.0); + } + + update(dirt) { + const bone = this._Parent; + + const parentBone = bone.parent instanceof _ActorBoneBase_js__WEBPACK_IMPORTED_MODULE_2__["default"] && bone.parent; + const parentBoneJelly = parentBone && parentBone.jelly; + const inverseWorld = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["mat2d"].invert(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["mat2d"].create(), bone.worldTransform); + if (!inverseWorld) { + console.warn("Failed to invert transform space", bone.worldTransform); + return; + } + + if (this._InTarget) { + const translation = this._InTarget.worldTranslation; + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].transformMat2d(this._InPoint, translation, inverseWorld); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].normalize(this._InDirection, this._InPoint); + } else if (parentBone) { + if (parentBone._FirstBone === bone && parentBoneJelly && parentBoneJelly._OutTarget) { + const translation = parentBoneJelly._OutTarget.worldTranslation; + const localParentOut = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].transformMat2d(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), translation, inverseWorld); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].normalize(localParentOut, localParentOut); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].negate(this._InDirection, localParentOut); + } else { + const d1 = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), 1, 0); + const d2 = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), 1, 0); + + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].transformMat2(d1, d1, parentBone.worldTransform); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].transformMat2(d2, d2, bone.worldTransform); + + const sum = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].add(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), d1, d2); + const localIn = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].transformMat2(this._InDirection, sum, inverseWorld); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].normalize(localIn, localIn); + } + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].scale(this._InPoint, this._InDirection, this._EaseIn * bone._Length * CurveConstant); + } else { + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(this._InDirection, 1, 0); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(this._InPoint, this._EaseIn * bone._Length * CurveConstant, 0); + } + + if (this._OutTarget) { + const translation = this._OutTarget.worldTranslation; + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].transformMat2d(this._OutPoint, translation, inverseWorld); + const tip = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), bone._Length, 0.0); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].subtract(this._OutDirection, this._OutPoint, tip); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].normalize(this._OutDirection, this._OutDirection); + } else if (bone._FirstBone) { + const firstBone = bone._FirstBone; + const firstBoneJelly = firstBone.jelly; + if (firstBoneJelly && firstBoneJelly._InTarget) { + const translation = firstBoneJelly._InTarget.worldTranslation; + const worldChildInDir = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].subtract(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), firstBone.worldTranslation, translation); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].transformMat2(this._OutDirection, worldChildInDir, inverseWorld); + } else { + const d1 = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), 1, 0); + const d2 = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), 1, 0); + + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].transformMat2(d1, d1, firstBone.worldTransform); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].transformMat2(d2, d2, bone.worldTransform); + + const sum = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].add(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), d1, d2); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].negate(sum, sum); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].transformMat2(this._OutDirection, sum, inverseWorld); + } + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].normalize(this._OutDirection, this._OutDirection); + const scaledOut = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].scale(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), this._OutDirection, this._EaseOut * bone._Length * CurveConstant); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(this._OutPoint, bone._Length, 0.0); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].add(this._OutPoint, this._OutPoint, scaledOut); + } else { + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(this._OutDirection, -1, 0); + + const scaledOut = gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].scale(gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].create(), this._OutDirection, this._EaseOut * bone._Length * CurveConstant); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].set(this._OutPoint, bone._Length, 0.0); + gl_matrix__WEBPACK_IMPORTED_MODULE_3__["vec2"].add(this._OutPoint, this._OutPoint, scaledOut); + } + + this.updateJellies(); + } +} + +/***/ }), + +/***/ "./source/KeyFrame.js": +/*!****************************!*\ + !*** ./source/KeyFrame.js ***! + \****************************/ +/*! exports provided: KeyFrame */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "KeyFrame", function() { return KeyFrame; }); +/* harmony import */ var _BezierAnimationCurve_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./BezierAnimationCurve.js */ "./source/BezierAnimationCurve.js"); + + +const MAX_FACTOR = 0.99999; +const MIN_FACTOR = 1.0 - MAX_FACTOR; + +let TempBuffer = new Float32Array(32); + +function InterpolateVertexBuffer(buffer, from, to, mix) { + if (buffer.length < to.length) { + buffer = new Float32Array(to.length); + } + + const mixi = 1.0 - mix; + const l = to.length; + + for (let i = 0; i < l; i++) { + buffer[i] = from[i] * mixi + to[i] * mix; + } + + return buffer; +} + +class KeyFrame { + constructor() { + this._Value = 0.0; + this._Time = 0.0; + this._Type = 0; + this._Interpolator = null; + } + + setNext(nxt) { + if (this._Value.constructor === Float32Array) { + this.interpolate = KeyFrame.prototype.interpolateVertexBuffer; + } else { + this.interpolate = KeyFrame.prototype.interpolateFloat; + } + } + + interpolateVertexBuffer(mix, nxt) { + return TempBuffer = InterpolateVertexBuffer(TempBuffer, this._Value, nxt._Value, mix); + } + + interpolateFloat(mix, nxt) { + return this._Value * (1.0 - mix) + nxt._Value * mix; + } +} + +KeyFrame.Type = { + Hold: 0, + Linear: 1, + Mirrored: 2, + Asymmetric: 3, + Disconnected: 4, + Progression: 5 +}; + +/***/ }), + +/***/ "./source/NestedActorAsset.js": +/*!************************************!*\ + !*** ./source/NestedActorAsset.js ***! + \************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return NestedActorAsset; }); +class NestedActorAsset { + constructor(name, id) { + this._Id = id; + this._Name = name; + this._Actor = null; + } + + get id() { + return this._Id; + } + + get name() { + return this._Name; + } + + get actor() { + return this._Actor; + } +} + +/***/ }), + +/***/ "./source/NestedActorNode.js": +/*!***********************************!*\ + !*** ./source/NestedActorNode.js ***! + \***********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return NestedActorNode; }); +/* harmony import */ var _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./ActorNode.js */ "./source/ActorNode.js"); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + + +class NestedActorNode extends _ActorNode_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor() { + super(); + + this._DrawOrder = 0; + this._Asset = null; + this._Instance = null; + this._Actor = null; + } + + makeInstance(resetActor) { + const node = new NestedActorNode(); + node.copy(this, resetActor); + + if (this._Asset.actor) { + node._Actor = this._Asset.actor.makeInstance(); + } + return node; + } + + copy(node, resetActor) { + super.copy(node, resetActor); + this._Asset = node._Asset; + this._DrawOrder = node._DrawOrder; + } + + initialize(actor, graphics) { + if (this._Actor) { + this._Actor.initialize(graphics); + } + } + + updateWorldTransform() { + super.updateWorldTransform(); + if (this._Actor) { + this._Actor.root.overrideWorldTransform(this._WorldTransform); + } + } + + computeAABB() { + if (this._Actor) { + return this._Actor.computeAABB(); + } + return null; + } + + draw(graphics) { + if (this._Actor) { + this._Actor.draw(graphics); + } + } + + advance(seconds) { + super.advance(seconds); + if (this._Actor) { + this._Actor.advance(seconds); + } + } +} + +/***/ }), + +/***/ "./source/PathMatrix.js": +/*!******************************!*\ + !*** ./source/PathMatrix.js ***! + \******************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return make; }); +/* harmony import */ var _svgdotjs_svg_js_dist_svg_node_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! @svgdotjs/svg.js/dist/svg.node.js */ "./node_modules/@svgdotjs/svg.js/dist/svg.node.js"); +/* harmony import */ var _svgdotjs_svg_js_dist_svg_node_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_svgdotjs_svg_js_dist_svg_node_js__WEBPACK_IMPORTED_MODULE_0__); + + +function make(transform) { + const matrix = new _svgdotjs_svg_js_dist_svg_node_js__WEBPACK_IMPORTED_MODULE_0__["Matrix"](); + matrix.a = transform[0]; + matrix.b = transform[1]; + matrix.c = transform[2]; + matrix.d = transform[3]; + matrix.e = transform[4]; + matrix.f = transform[5]; + + return matrix; +} + +/***/ }), + +/***/ "./source/PathPoint.js": +/*!*****************************!*\ + !*** ./source/PathPoint.js ***! + \*****************************/ +/*! exports provided: PointType, PathPoint, StraightPathPoint, CubicPathPoint */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PointType", function() { return PointType; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "PathPoint", function() { return PathPoint; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "StraightPathPoint", function() { return StraightPathPoint; }); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CubicPathPoint", function() { return CubicPathPoint; }); +/* harmony import */ var gl_matrix__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! gl-matrix */ "./node_modules/gl-matrix/lib/gl-matrix.js"); + + +const TempMatrix = new Float32Array(6); + +class PointType { + static get Straight() { + return 0; + } + + static get Mirror() { + return 1; + } + + static get Disconnected() { + return 2; + } + + static get Asymmetric() { + return 3; + } +} + +class PathPoint { + constructor() { + this._PointType = PointType.Straight; + this._Translation = gl_matrix__WEBPACK_IMPORTED_MODULE_0__["vec2"].create(); + this._Weights = null; + } + + get pointType() { + return this._PointType; + } + + get translation() { + return this._Translation; + } + + makeInstance() { + return null; + } + + copy(from) { + this._PointType = from._PointType; + this._Weights = from._Weights; + gl_matrix__WEBPACK_IMPORTED_MODULE_0__["vec2"].copy(this._Translation, from._Translation); + } +} + +class StraightPathPoint extends PathPoint { + constructor() { + super(); + this._Radius = 0; + } + + get radius() { + return this._Radius; + } + + makeInstance() { + const node = new StraightPathPoint(); + StraightPathPoint.prototype.copy.call(node, this); + return node; + } + + copy(from) { + super.copy(from); + this._Radius = from._Radius; + } + + skin(world, bones) { + let { _Weights: weights, translation, pointType, radius } = this; + + let px = world[0] * translation[0] + world[2] * translation[1] + world[4]; + let py = world[1] * translation[0] + world[3] * translation[1] + world[5]; + const point = { pointType, o: this, radius }; + + const fm = TempMatrix; + fm.fill(0); + + for (let i = 0; i < 4; i++) { + const boneIndex = weights[i]; + const weight = weights[i + 4]; + if (weight > 0) { + let bb = boneIndex * 6; + for (let j = 0; j < 6; j++) { + fm[j] += bones[bb + j] * weight; + } + } + } + + point.translation = new Float32Array([fm[0] * px + fm[2] * py + fm[4], fm[1] * px + fm[3] * py + fm[5]]); + + return point; + } +} + +class CubicPathPoint extends PathPoint { + constructor() { + super(); + this._In = gl_matrix__WEBPACK_IMPORTED_MODULE_0__["vec2"].create(); + this._Out = gl_matrix__WEBPACK_IMPORTED_MODULE_0__["vec2"].create(); + } + + get in() { + return this._In; + } + + get out() { + return this._Out; + } + + makeInstance() { + const node = new CubicPathPoint(); + CubicPathPoint.prototype.copy.call(node, this); + return node; + } + + copy(from) { + super.copy(from); + gl_matrix__WEBPACK_IMPORTED_MODULE_0__["vec2"].copy(this._In, from._In); + gl_matrix__WEBPACK_IMPORTED_MODULE_0__["vec2"].copy(this._Out, from._Out); + } + + skin(world, bones) { + let { _Weights: weights, translation, pointType, out: op, in: ip } = this; + + let px = world[0] * translation[0] + world[2] * translation[1] + world[4]; + let py = world[1] * translation[0] + world[3] * translation[1] + world[5]; + const point = { pointType, o: this }; + + const fm = TempMatrix; + fm.fill(0); + + for (let i = 0; i < 4; i++) { + const boneIndex = weights[i]; + const weight = weights[i + 4]; + if (weight > 0) { + let bb = boneIndex * 6; + for (let j = 0; j < 6; j++) { + fm[j] += bones[bb + j] * weight; + } + } + } + + point.translation = new Float32Array([fm[0] * px + fm[2] * py + fm[4], fm[1] * px + fm[3] * py + fm[5]]); + + px = world[0] * ip[0] + world[2] * ip[1] + world[4]; + py = world[1] * ip[0] + world[3] * ip[1] + world[5]; + fm.fill(0); + for (let i = 8; i < 12; i++) { + const boneIndex = weights[i]; + const weight = weights[i + 4]; + if (weight > 0) { + let bb = boneIndex * 6; + for (let j = 0; j < 6; j++) { + fm[j] += bones[bb + j] * weight; + } + } + } + + point.in = new Float32Array([fm[0] * px + fm[2] * py + fm[4], fm[1] * px + fm[3] * py + fm[5]]); + + px = world[0] * op[0] + world[2] * op[1] + world[4]; + py = world[1] * op[0] + world[3] * op[1] + world[5]; + fm.fill(0); + for (let i = 16; i < 20; i++) { + const boneIndex = weights[i]; + const weight = weights[i + 4]; + if (weight > 0) { + let bb = boneIndex * 6; + for (let j = 0; j < 6; j++) { + fm[j] += bones[bb + j] * weight; + } + } + } + + point.out = new Float32Array([fm[0] * px + fm[2] * py + fm[4], fm[1] * px + fm[3] * py + fm[5]]); + + return point; + } +} + +/***/ }), + +/***/ "./source/Readers/BinaryReader.js": +/*!****************************************!*\ + !*** ./source/Readers/BinaryReader.js ***! + \****************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return BinaryReader; }); +/* harmony import */ var _StreamReader_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./StreamReader.js */ "./source/Readers/StreamReader.js"); + + +class BinaryReader extends _StreamReader_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(uint8Array) { + super(); + this.isBigEndian = function () { + const b = new ArrayBuffer(4); + const a = new Uint32Array(b); + const c = new Uint8Array(b); + a[0] = 0xdeadbeef; + return c[0] == 0xde; + }(); + + this.raw = uint8Array; + this.dataView = new DataView(uint8Array.buffer); + this.readIndex = 0; + } + + readFloat32() { + const v = this.dataView.getFloat32(this.readIndex, !this.isBigEndian); + this.readIndex += 4; + return v; + } + + readFloat32ArrayOffset(ar, length, offset) { + if (!offset) { + offset = 0; + } + if (!length) { + length = ar.length; + } + let end = offset + length; + for (let i = offset; i < end; i++) { + ar[i] = this.dataView.getFloat32(this.readIndex, !this.isBigEndian); + this.readIndex += 4; + } + return ar; + } + + readFloat32Array(ar) { + for (let i = 0; i < ar.length; i++) { + ar[i] = this.dataView.getFloat32(this.readIndex, !this.isBigEndian); + this.readIndex += 4; + } + return ar; + } + + readFloat64() { + const v = this.dataView.getFloat64(this.readIndex, !this.isBigEndian); + this.readIndex += 8; + return v; + } + + readUint8() { + return this.raw[this.readIndex++]; + } + + isEOF() { + return this.readIndex >= this.raw.length; + } + + readInt8() { + const v = this.dataView.getInt8(this.readIndex); + this.readIndex += 1; + return v; + } + + readUint16() { + const v = this.dataView.getUint16(this.readIndex, !this.isBigEndian); + this.readIndex += 2; + return v; + } + + readUint16Array(ar, length) { + if (!length) { + length = ar.length; + } + for (let i = 0; i < length; i++) { + ar[i] = this.dataView.getUint16(this.readIndex, !this.isBigEndian); + this.readIndex += 2; + } + return ar; + } + + readInt16() { + const v = this.dataView.getInt16(this.readIndex, !this.isBigEndian); + this.readIndex += 2; + return v; + } + + readUint32() { + const v = this.dataView.getUint32(this.readIndex, !this.isBigEndian); + this.readIndex += 4; + return v; + } + + readInt32() { + const v = this.dataView.getInt32(this.readIndex, !this.isBigEndian); + this.readIndex += 4; + return v; + } + + byteArrayToString(bytes) { + let out = [], + pos = 0, + c = 0; + while (pos < bytes.length) { + let c1 = bytes[pos++]; + if (c1 < 128) { + out[c++] = String.fromCharCode(c1); + } else if (c1 > 191 && c1 < 224) { + let c2 = bytes[pos++]; + out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63); + } else if (c1 > 239 && c1 < 365) { + // Surrogate Pair + let c2 = bytes[pos++]; + let c3 = bytes[pos++]; + let c4 = bytes[pos++]; + let u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 0x10000; + out[c++] = String.fromCharCode(0xD800 + (u >> 10)); + out[c++] = String.fromCharCode(0xDC00 + (u & 1023)); + } else { + let c2 = bytes[pos++]; + let c3 = bytes[pos++]; + out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63); + } + } + return out.join(""); + } + + readString() { + const length = this.readUint32(); + const ua = new Uint8Array(length); + for (let i = 0; i < length; i++) { + ua[i] = this.raw[this.readIndex++]; + } + return this.byteArrayToString(ua); + } + + readRaw(to, length) { + for (let i = 0; i < length; i++) { + to[i] = this.raw[this.readIndex++]; + } + } + + readBool() { + return this.readUint8() === 1; + } + + readBlockType() { + return this.readUint8(); + } + + readImage(isOOB, cb) { + if (isOOB) { + const image = this.readString(); + const req = new XMLHttpRequest(); + req.open("GET", image, true); + req.responseType = "blob"; + + req.onload = function () { + const blob = this.response; + cb(blob); + }; + req.send(); + } else { + const size = this.readUint32(); + const atlasData = new Uint8Array(size); + this.readRaw(atlasData, atlasData.length); + const blob = new Blob([atlasData], { type: "image/png" }); + + cb(blob); + } + } + + readId(label) { + return this.readUint16(); + } + + readUint8Length() { + return this.readUint8(); + } + + readUint16Length() { + return this.readUint16(); + } + + readUint32Length() { + return this.readUint32(); + } + + get containerType() { + return "bin"; + } +} + +BinaryReader.alignment = 1024; + +/***/ }), + +/***/ "./source/Readers/JSONReader.js": +/*!**************************************!*\ + !*** ./source/Readers/JSONReader.js ***! + \**************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return JSONReader; }); +/* harmony import */ var _StreamReader_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./StreamReader.js */ "./source/Readers/StreamReader.js"); + + +class JSONReader extends _StreamReader_js__WEBPACK_IMPORTED_MODULE_0__["default"] { + constructor(object) { + super(); + this._readObject = object["container"]; + this._context = [this._readObject]; + } + + readProp(label) { + const head = this._last; + if (head.constructor === Object) { + const prop = head[label]; + delete head[label]; + return prop; + } else if (head.constructor === Array) { + return head.shift(); + } + } + + readFloat32(label) { + return this.readProp(label); + } + + // Reads the array into ar + readFloat32Array(ar, label) { + return this.readArray(ar, label); + } + + readFloat32ArrayOffset(ar, length, offset, label) { + return this.readFloat32Array(ar, label); + } + + readArray(ar, label) { + const array = this.readProp(label); + if (array) // I think there's a bug here. + { + for (let i = 0; i < ar.length; i++) { + ar[i] = array[i]; + } + } + + return ar; + } + + readFloat64(label) { + return this.readProp(label); + } + + readUint8(label) { + return this.readProp(label); + } + + readUint8Length() { + return this._readLength(); + } + + isEOF() { + return this._context.length <= 1 && Object.keys(this._readObject).length === 0; + } + + readInt8(label) { + return this.readProp(label); + } + + readUint16(label) { + return this.readProp(label); + } + + readUint16Array(ar, label) { + return this.readArray(ar, label); + } + + readInt16(label) { + return this.readProp(label); + } + + readUint16Length() { + return this._readLength(); + } + + readUint32(label) { + return this.readProp(label); + } + + // This implementation doesn't need this, as it would read a wrong value. + // readUint32Length(label) + // { + // return this.readProp(label); + // } + + byteArrayToString(bytes) { + let out = [], + pos = 0, + c = 0; + while (pos < bytes.length) { + let c1 = bytes[pos++]; + if (c1 < 128) { + out[c++] = String.fromCharCode(c1); + } else if (c1 > 191 && c1 < 224) { + let c2 = bytes[pos++]; + out[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63); + } else if (c1 > 239 && c1 < 365) { + // Surrogate Pair + let c2 = bytes[pos++]; + let c3 = bytes[pos++]; + let c4 = bytes[pos++]; + let u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) - 0x10000; + out[c++] = String.fromCharCode(0xD800 + (u >> 10)); + out[c++] = String.fromCharCode(0xDC00 + (u & 1023)); + } else { + let c2 = bytes[pos++]; + let c3 = bytes[pos++]; + out[c++] = String.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63); + } + } + return out.join(""); + } + + readString(label) { + return this.readProp(label); + } + + readBool(label) { + return this.readProp(label); + } + + readRaw(obj, length, label) { + const context = this._last; + const next = this._peekNext(); + obj["container"] = next; + // Remove the block from here. + if (context.constructor === Object) { + delete context[this._nextKey]; + } else if (context.constructor === Array) { + context.shift(); + } + } + + readBlockType(block) { + const next = this._peekNext(); + let bType; + if (next.constructor === Object) { + const last = this._last; + let nType; + if (last.constructor === Object) { + nType = this._nextKey; + } else if (last.constructor === Array) { + // Objects are serialized with "type" property. + nType = next["type"]; + } + bType = block.fromString(nType) || nType; + } else if (next.constructor === Array) { + // Arrays are serialized as "type": [Array]. + const nKey = this._nextKey; + bType = block.fromString(nKey) || nKey; + } + return bType; + } + + readImage(isOOB, cb) { + const image = this.readString(); + if (isOOB) { + const req = new XMLHttpRequest(); + req.open("GET", image, true); + req.responseType = "blob"; + + req.onload = function () { + const blob = this.response; + cb(blob); + }; + req.send(); + } else { + cb(image); + } + } + + readId(label) { + const val = this.readUint16(label); + return val !== undefined ? val + 1 : 0; + } + + openArray(label) { + const array = this.readProp(label); + this._context.unshift(array); + } + + closeArray() { + this._context.shift(); + } + + openObject(label) { + const o = this.readProp(label); + this._context.unshift(o); + } + + closeObject() { + this._context.shift(); + } + + get containerType() { + return "json"; + } + + _peekNext() { + const stream = this._last; + let next; + if (stream.constructor === Object) { + next = stream[this._nextKey]; + } else if (stream.constructor === Array) { + next = stream[0]; + } + return next; + } + + get _nextKey() { + return Object.keys(this._last)[0]; + } + + _readLength() { + const context = this._last; + if (context.constructor === Array) { + return context.length; + } else if (context.constructor === Object) { + return Object.keys(context).length; + } + } + + get _last() { + return this._context[0]; + } +} + +/***/ }), + +/***/ "./source/Readers/StreamReader.js": +/*!****************************************!*\ + !*** ./source/Readers/StreamReader.js ***! + \****************************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "default", function() { return StreamReader; }); +class StreamReader { + constructor() {} + readFloat32() {} + readFloat32Array(ar, length, offset) {} + readFloat32ArrayOffset(ar, length, offset) {} + readFloat64() {} + isEOF() {} + readInt8() {} + readUint8() {} + readUint8Length() {} + readUint16() {} + readUint16Array(ar, length) {} + readUint16Length() {} + readInt16() {} + readUint32() {} + readUint32Length() {} + readInt32() {} + byteArrayToString(bytes) {} + readString() {} + readRaw(to, length) {} + + readBool() {} + readBlockType() {} + readImage(isOOB, cb) {} + + readId(label) {} + + openArray(label) {} + closeArray() {} + openObject(label) {} + closeObject() {} + + get containerType() { + return "stream"; + } +} + +/***/ }), + +/***/ "./source/TransformSpace.js": +/*!**********************************!*\ + !*** ./source/TransformSpace.js ***! + \**********************************/ +/*! exports provided: default */ +/***/ (function(module, __webpack_exports__, __webpack_require__) { + +"use strict"; +__webpack_require__.r(__webpack_exports__); +const TransformSpace = { + Local: 0, + World: 1 +}; + +/* harmony default export */ __webpack_exports__["default"] = (TransformSpace); + +/***/ }) + +/******/ }); +//# sourceMappingURL=example.build.js.map \ No newline at end of file diff --git a/example/example.build.js.map b/example/example.build.js.map new file mode 100644 index 0000000..b8b8f39 --- /dev/null +++ b/example/example.build.js.map @@ -0,0 +1 @@ +{"version":3,"sources":["webpack:///webpack/bootstrap","webpack:///./example/example.js","webpack:///./node_modules/@svgdotjs/svg.js/dist/svg.node.js","webpack:///./node_modules/bezier-easing/src/index.js","webpack:///./node_modules/gl-matrix/lib/gl-matrix.js","webpack:///./node_modules/gl-matrix/lib/gl-matrix/common.js","webpack:///./node_modules/gl-matrix/lib/gl-matrix/mat2.js","webpack:///./node_modules/gl-matrix/lib/gl-matrix/mat2d.js","webpack:///./node_modules/gl-matrix/lib/gl-matrix/mat3.js","webpack:///./node_modules/gl-matrix/lib/gl-matrix/mat4.js","webpack:///./node_modules/gl-matrix/lib/gl-matrix/quat.js","webpack:///./node_modules/gl-matrix/lib/gl-matrix/quat2.js","webpack:///./node_modules/gl-matrix/lib/gl-matrix/vec2.js","webpack:///./node_modules/gl-matrix/lib/gl-matrix/vec3.js","webpack:///./node_modules/gl-matrix/lib/gl-matrix/vec4.js","webpack:///./source/Actor.js","webpack:///./source/ActorArtboard.js","webpack:///./source/ActorAxisConstraint.js","webpack:///./source/ActorBone.js","webpack:///./source/ActorBoneBase.js","webpack:///./source/ActorCollider.js","webpack:///./source/ActorColliderCircle.js","webpack:///./source/ActorColliderLine.js","webpack:///./source/ActorColliderPolygon.js","webpack:///./source/ActorColliderRectangle.js","webpack:///./source/ActorColliderTriangle.js","webpack:///./source/ActorComponent.js","webpack:///./source/ActorConstraint.js","webpack:///./source/ActorDistanceConstraint.js","webpack:///./source/ActorEllipse.js","webpack:///./source/ActorEvent.js","webpack:///./source/ActorIKConstraint.js","webpack:///./source/ActorIKTarget.js","webpack:///./source/ActorImage.js","webpack:///./source/ActorJellyBone.js","webpack:///./source/ActorLoader.js","webpack:///./source/ActorNode.js","webpack:///./source/ActorNodeSolo.js","webpack:///./source/ActorPath.js","webpack:///./source/ActorPolygon.js","webpack:///./source/ActorProceduralPath.js","webpack:///./source/ActorRectangle.js","webpack:///./source/ActorRootBone.js","webpack:///./source/ActorRotationConstraint.js","webpack:///./source/ActorScaleConstraint.js","webpack:///./source/ActorShape.js","webpack:///./source/ActorSkin.js","webpack:///./source/ActorSkinnableNode.js","webpack:///./source/ActorStar.js","webpack:///./source/ActorTargetedConstraint.js","webpack:///./source/ActorTransformConstraint.js","webpack:///./source/ActorTranslationConstraint.js","webpack:///./source/ActorTriangle.js","webpack:///./source/AnimatedComponent.js","webpack:///./source/AnimatedProperty.js","webpack:///./source/Animation.js","webpack:///./source/AnimationInstance.js","webpack:///./source/BezierAnimationCurve.js","webpack:///./source/Block.js","webpack:///./source/ColorComponent.js","webpack:///./source/CustomProperty.js","webpack:///./source/Decompose.js","webpack:///./source/Dispatcher.js","webpack:///./source/Flare.js","webpack:///./source/Graphics.js","webpack:///./source/Interpolation.js","webpack:///./source/JellyComponent.js","webpack:///./source/KeyFrame.js","webpack:///./source/NestedActorAsset.js","webpack:///./source/NestedActorNode.js","webpack:///./source/PathMatrix.js","webpack:///./source/PathPoint.js","webpack:///./source/Readers/BinaryReader.js","webpack:///./source/Readers/JSONReader.js","webpack:///./source/Readers/StreamReader.js","webpack:///./source/TransformSpace.js"],"names":["Actor","Dispatcher","constructor","_Artboards","_NestedActorAssets","_Atlases","getArtboard","name","find","artboard","_Name","dispose","graphics","initialize","nested","actor","makeInstance","length","animations","_Animations","ActorArtboard","_Actor","_Components","_Nodes","_RootNode","ActorNode","push","_Drawables","_IsImageSortDirty","_Order","_IsDirty","_DirtDepth","_Origin","vec2","create","_Translation","_Color","vec4","_ClipsContents","_Width","_Height","width","height","origin","translation","color","clipsContents","root","addDependency","a","b","dependents","_Dependents","indexOf","sortDependencies","perm","Set","temp","order","visit","n","has","console","warn","add","d","unshift","i","component","_GraphOrder","_DirtMask","addDirt","value","recurse","dirt","onDirty","update","end","maxSteps","step","resolveHierarchy","components","resolveComponentIndices","isNode","NestedActorNode","ActorImage","completeResolve","sort","_DrawOrder","drawables","drawable","advance","seconds","draw","getNode","nodes","node","getAnimation","animation","getAnimationInstance","AnimationInstance","actorInstance","copy","artboardAABB","min_x","min_y","Float32Array","computeAABB","Number","MAX_VALUE","max_x","max_y","opacity","aabb","clone","_ClipContents","instanceNode","ActorShape","ActorAxisConstraint","ActorTargetedConstraint","_CopyX","_CopyY","_ScaleX","_ScaleY","_EnableMinX","_MinX","_EnableMaxX","_MaxX","_EnableMinY","_MinY","_EnableMaxY","_MaxY","_Offset","_SourceSpace","TransformSpace","World","_DestSpace","_MinMaxSpace","resetActor","markDirty","ActorBone","ActorBoneBase","_FirstBone","children","_Children","child","_Length","tipWorldTranslation","transform","mat2d","mul","_WorldTransform","set","l","markTransformDirty","firstBone","ActorCollider","_IsCollisionEnabled","isCollisionEnabled","ActorColliderCircle","_Radius","radius","ActorColliderLine","_Vertices","vertices","ActorColliderPolygon","_ContourVertices","contourVertices","ActorColliderRectangle","ActorColliderTriangle","ActorComponent","_Parent","_CustomProperties","_ParentIdx","parent","_Idx","getCustomProperty","props","prop","ActorConstraint","_IsEnabled","_Strength","strength","c","isEnabled","isIt","addConstraint","DistanceMode","Closer","Further","Exact","ActorDistanceConstraint","_Distance","_Mode","distance","mode","constrain","tip","target","_Target","targetTranslation","worldTranslation","ourTranslation","t","toTarget","subtract","currentDistance","scale","world","worldTransform","position","lerp","ActorEllipse","ActorProceduralPath","prototype","call","getPath","path","Path2D","radiusX","radiusY","moveTo","ellipse","Math","PI","ActorEvent","PI2","ActorIKConstraint","_InvertDirection","_InfluencedBones","_FKChain","_BoneData","ib","bones","j","componentIndex","bone","addPeerConstraint","item","start","chain","boneData","ikAngle","transformComponents","in","allIn","fk","idx","wt","solve","solve1","fk1","worldTargetTranslation","iworld","parentWorldInverse","pA","pBT","toTargetLocal","transformMat2","r","atan2","constrainRotation","solve2","fk2","invertDirection","b1","b2","firstChild","pC","pB","transformMat2d","av","bv","cv","A","acos","max","min","C","r1","r2","secondChild","avLocal","angleCorrection","fkChain","parentWorld","invert","local","Decompose","m","fromAngle","toAngle","diff","angle","rotation","identity","fromRotation","scaleX","scaleY","skew","ActorIKTarget","constraint","_Constraint","_TargetIdx","s","White","_BlendMode","BlendModes","Normal","_AtlasIndex","_NumVertices","_HasVertexDeformAnimation","_AnimationDeformedVertices","_Triangles","_ConnectedBones","_BoneMatrices","_IsInstance","_IsHidden","_VertexBuffer","_IndexBuffer","_DeformVertexBuffer","_SequenceFrames","_SequenceFrame","_SequenceUVs","_SequenceUVBuffer","isHidden","hidden","hasVertexDeformAnimation","writeIdx","readIdx","readStride","_VertexStride","worldVertices","computeWorldVertices","nv","x","y","stride","deformed","weightIndex","weightStride","weightVertices","px","py","fm","wi","boneIndex","weight","bb","makeVertexBuffer","makeIndexBuffer","bt","_Texture","_VerticesDirty","bidx","mat","cb","ibind","_RenderCollapsed","enableBlending","Multiply","enableMultiplyBlending","Screen","enableScreenBlending","Additive","enableAdditiveBlending","uvBuffer","uvOffset","numFrames","frame","offset","prep","_RenderOpacity","_IsConnectedToImage","deformedVertexLength","bind","ActorJellyBone","_BlockTypes","Block","Types","_AnimatedPropertyTypes","AnimatedProperty","_Readers","stream","BinaryReader","container","Uint8Array","extension","JSONReader","Object","_ReadAtlasesBlock","_ReadNextBlock","reader","error","block","isEOF","blockType","cType","containerType","streamReader","readBlockType","undefined","readUint32Length","readRaw","err","log","type","_ReadComponentsBlock","componentCount","readUint16Length","actorComponents","CustomIntProperty","CustomStringProperty","CustomFloatProperty","CustomBooleanProperty","_ReadCustomProperty","CustomProperty","ColliderRectangle","_ReadRectangleCollider","ColliderTriangle","_ReadTriangleCollider","ColliderCircle","_ReadCircleCollider","ColliderPolygon","_ReadPolygonCollider","ColliderLine","_ReadLineCollider","_ReadActorEvent","_ReadActorNode","_ReadActorBone","_ReadActorJellyBone","JellyComponent","_ReadJellyComponent","ActorRootBone","_ReadActorRootBone","_ReadActorImage","ActorImageSequence","_ReadActorImageSequence","_ReadActorIKTarget","dataVersion","_ReadNestedActor","ActorNodeSolo","_ReadActorNodeSolo","_ReadActorIKConstraint","_ReadActorDistanceConstraint","ActorTransformConstraint","_ReadActorTransformConstraint","ActorTranslationConstraint","_ReadAxisConstraint","ActorScaleConstraint","ActorRotationConstraint","_ReadRotationConstraint","_ReadActorShape","ActorPath","_ReadActorPath","ColorFill","_ReadColorFill","ColorStroke","_ReadColorStroke","GradientFill","_ReadGradientFill","GradientStroke","_ReadGradientStroke","RadialGradientFill","_ReadRadialGradientFill","RadialGradientStroke","_ReadRadialGradientStroke","_ReadActorEllipse","ActorRectangle","_ReadActorRectangle","ActorTriangle","_ReadActorTriangle","ActorStar","_ReadActorStar","ActorPolygon","_ReadActorPolygon","ActorSkin","_ReadActorComponent","_ReadAnimationBlock","Animation","readString","_FPS","readUint8","_Duration","readFloat32","_Loop","readBool","openArray","numKeyedComponents","openObject","readId","readUint16","propertyBlock","animatedComponent","AnimatedComponent","_TriggerComponents","propertyReader","propertyType","validProperty","PosX","PosY","ScaleX","ScaleY","Rotation","Opacity","DrawOrder","Length","VertexDeform","ConstraintStrength","Trigger","IntProperty","FloatProperty","StringProperty","BooleanProperty","IsCollisionEnabled","ActiveChildIndex","Sequence","PathVertices","FillColor","StrokeColor","StrokeWidth","FillGradient","StrokeGradient","FillRadial","StrokeRadial","StrokeOpacity","FillOpacity","ShapeWidth","ShapeHeight","CornerRadius","InnerRadius","animatedProperty","_Properties","keyFrameCount","lastKeyFrame","k","keyFrame","KeyFrame","_Time","readFloat64","_Interpolator","Hold","instance","Linear","Cubic","_ComponentIndex","pointCount","_Points","points","point","pos","readFloat32Array","StraightPathPoint","p","_Value","fillLength","readInt32","orderedImages","orderValue","closeObject","componentIdx","closeArray","setNext","_KeyFrames","_DisplayStart","_DisplayEnd","_ReadAnimationsBlock","animationsCount","_ReadNestedActorAssetBlock","asset","NestedActorAsset","_ReadNestedActorAssets","nestedActorCount","_BuildJpegAtlas","atlas","img","imga","callback","canvas","document","createElement","ctx","getContext","drawImage","imageDataRGB","getImageData","dataRGB","data","canvasAlpha","actx","imageDataAlpha","dataAlpha","pixels","widx","putImageData","atlasImage","Image","enc","toDataURL","src","onload","_JpegAtlas","_This","URL","createObjectURL","_ReadAtlasesBlock14","numAtlases","waitCount","loadedCount","loaded","size","readUint32","atlasDataRGB","atlasDataAlpha","rgbSrc","Blob","alphaSrc","_ReadAtlasesBlock15","isOOB","readCallback","String","imgElm","readImage","_LoadNestedAssets","loader","loadCount","nestedLoad","loadNestedActor","nestedActor","_ReadArtboardsBlock","artboardCount","actorArtboards","_ReadActorArtboard","_ReadActor","dataView","DataView","stringData","TextDecoder","decode","JSON","parse","version","waitForAtlas","Artboards","Atlases","NestedActorAssets","Nodes","Animations","_ReadActorPaint","_Opacity","_PropertyType","Type","Integer","Float","Boolean","_ReadCollider","numVertices","_Rotation","_Scale","_IsCollapsedVisibility","clipCount","readUint8Length","_Clips","_ActiveChildIndex","_EaseIn","_EaseOut","_ScaleIn","_ScaleOut","_InTargetIdx","_OutTargetIdx","numInfluencedBones","_ReadActorConstraint","_ReadActorTargetedConstraint","_Copy","_EnableMin","_Min","_EnableMax","_Max","_ReadProceduralPath","_InnerRadius","_CornerRadius","_Sides","_FillRule","_ReadGradient","numStops","stops","_ColorStops","_Start","_End","_ReadRadialGradient","_SecondaryRadiusScale","_ReadSkinnable","numConnectedBones","overrideWorld","_OverrideWorldTransform","_IsClosed","Array","isConnectedToBones","PointType","Straight","_Weights","CubicPathPoint","_In","_Out","Error","_PointType","isVisible","vertexStride","numTris","Uint16Array","readUint16Array","frameCount","uvs","uvStride","firstFrame","readFloat32ArrayOffset","nestedActorAssets","assetIndex","_Asset","ActorLoader","load","url","req","XMLHttpRequest","open","responseType","fileReader","FileReader","result","readAsArrayBuffer","response","send","TransformDirty","WorldTransformDirty","_UpdateTransform","_Transform","_Constraints","_PeerConstraints","eachChildRecursive","all","constraints","allConstraints","concat","updateWorldTransform","exactEquals","getWorldTransform","setCollapsedVisibility","v","clip","overrideWorldTransform","clips","setActiveChildIndex","an","activeChildIndex","index","CircleConstant","InverseCircleConstant","ActorSkinnableNode","_RenderPath","_Skin","setSkin","skin","isClosed","closed","numPoints","getPathOBB","renderPoints","makeRenderPoints","pointType","out","getPathAABB","obb","fromValues","pt","wp","deformedPoints","boneTransforms","boneMatrices","pl","previous","next","toPrev","toPrevLength","toNext","toNextLength","renderRadius","scaleAndAdd","current","Disconnected","Mirror","Asymmetric","getPathRenderTransform","getPathTransform","PathMatrix","invalidatePath","renderPath","firstPoint","nextPoint","cin","cout","lineTo","bezierCurveTo","closePath","save","sides","inc","cos","sin","restore","addPoint","MIN_VALUE","halfWidth","halfHeight","_DrawRoundedRect","rect","beginPath","arcTo","_ComponentsA","_ComponentsB","grandParent","componentsA","componentsB","sourceSpace","destSpace","minMaxSpace","transformA","transformB","Local","sourceGrandParent","inverse","Compose","clampLocal","angleA","angleB","ti","_Paths","_Fills","_Strokes","paths","addFill","fill","addStroke","stroke","getClips","bounds","maxStroke","pathAABB","padStroke","globalAlpha","shapePath","getShapePath","fills","strokes","addPath","clipSearch","clipPath","shapes","shape","filter","connectedBones","graph","getOBB","sx","sy","translationA","translationB","id","key","Blocks","Unknown","_Types","_Map","Map","_Type","fromString","label","get","Properties","AnimatedPropertyTypes","keyFrameLocation","list","mid","element","_Artboard","duration","triggerEvents","artboardComponents","fromTime","toTime","triggered","keyedTriggerComponents","keyedComponent","properties","property","keyFrames","kfl","keyFrameTime","elapsed","apply","time","mix","imix","fromFrame","toFrame","interpolator","getEasedMix","interpolate","kf","_LastSetDrawOrder","chd","to","tidx","fidx","round","frameIndex","floor","ridx","cs","_Animation","_Range","loop","isOver","newTime","delta","reset","triggeredEvents","event","dispatch","cuberoot","pow","abs","yFromT","E","F","G","H","solveCubic","EPSILON","D","sqrt","q","roots","u","BezierAnimationCurve","pos1","control1","control2","pos2","y0a","x0a","y1a","x1a","y2a","x2a","y3a","x3a","_E","_F","_G","_H","_Y0a","_X0a","_Y1a","_X1a","_Y2a","_X2a","_Y3a","_X3a","p0","p1","p2","p3","View","Atlas","FillRule","EvenOdd","NonZero","ActorPaint","ActorColor","cssColor","fillStyle","strokeStyle","lineWidth","GradientColor","_RenderStart","_RenderEnd","gradient","createLinearGradient","style","addColorStop","RadialGradientColor","secondaryRadiusScale","createRadialGradient","m0","m1","m2","m3","denom","skewX","sk","events","addEventListener","evt","removeEventListener","splice","extraContext","exports","Graphics","require","default","_Canvas","_Context","clear","cvs","clearRect","setView","setTransform","flush","viewportWidth","viewportHeight","setSize","x1","y1","x2","y2","_Bezier","BezierEasing","JellyMax","OptimalDistance","CurveConstant","ForwardDiffBezier","c0","c1","c2","c3","count","f","NormalizeCurve","curve","numSegments","curvePointCount","distances","totalDistance","segmentLength","pointIndex","lastCurveSegmentLength","remainderOfDesired","ratio","iratio","FuzzyEquals","a0","a1","b0","_InTarget","_OutTarget","_Bones","_InPoint","_InDirection","_OutPoint","_OutDirection","dependencyConstraints","from","outTarget","jelly","inTarget","parentBone","parentBoneJelly","_Jelly","updateJellies","tipPosition","jc","_Cache","jellies","sout","q0","q1","q2","q3","subdivisions","normalizedPoints","lastPoint","scaleInc","inverseWorld","normalize","localParentOut","negate","d1","d2","sum","localIn","firstBoneJelly","worldChildInDir","scaledOut","MAX_FACTOR","MIN_FACTOR","TempBuffer","InterpolateVertexBuffer","buffer","mixi","nxt","interpolateVertexBuffer","interpolateFloat","Mirrored","Progression","_Id","_Instance","make","matrix","SVG","e","TempMatrix","PathPoint","weights","o","op","ip","StreamReader","uint8Array","isBigEndian","ArrayBuffer","Uint32Array","raw","readIndex","getFloat32","ar","getFloat64","readInt8","getInt8","getUint16","readInt16","getInt16","getUint32","getInt32","byteArrayToString","bytes","fromCharCode","c4","join","ua","image","blob","atlasData","alignment","object","_readObject","_context","readProp","head","_last","shift","readArray","array","_readLength","keys","obj","context","_peekNext","_nextKey","bType","last","nType","nKey","val"],"mappings":";AAAA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;;AAGA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,kDAA0C,gCAAgC;AAC1E;AACA;;AAEA;AACA;AACA;AACA,gEAAwD,kBAAkB;AAC1E;AACA,yDAAiD,cAAc;AAC/D;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,iDAAyC,iCAAiC;AAC1E,wHAAgH,mBAAmB,EAAE;AACrI;AACA;;AAEA;AACA;AACA;AACA,mCAA2B,0BAA0B,EAAE;AACvD,yCAAiC,eAAe;AAChD;AACA;AACA;;AAEA;AACA,8DAAsD,+DAA+D;;AAErH;AACA;;;AAGA;AACA;;;;;;;;;;;;;AClFA;AAAA;AAAiC;AACjC,cAAc,mBAAO,CAAC,6CAAoB;;AAE1C;AACA;;AAEA;AACA;AACA;AACA;AACA,uBAAuB,+CAAK;AAC5B;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,IAAI;AACJ;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE;AACF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA,CAAC,E;;;;;;;;;;;ACjLD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,8CAA8C,cAAc;;AAE5D;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,mDAAmD;AACnD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA,aAAa,QAAQ;AACrB;AACA;;AAEA;AACA,CAAC;;AAED;AACA;AACA;AACA;;AAEA,aAAa,QAAQ;AACrB;AACA;AACA;AACA;;AAEA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,GAAG;AACH,CAAC;;AAED;AACA;AACA;AACA,GAAG;AACH,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;;AAExB,aAAa;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK,kBAAkB;;AAEvB;AACA,kGAAkG;;AAElG;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;;;AAGH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,YAAY,yBAAyB,gBAAgB;AACrD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,mCAAmC;;AAEnC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,2BAA2B;AAC3B;;AAEA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,yBAAyB;;AAEzB,0DAA0D;;AAE1D,qDAAqD;;AAErD;AACA,2BAA2B;AAC3B,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED,eAAe;;AAEf;AACA;AACA,CAAC;;AAED;AACA;AACA,wCAAwC,QAAQ;AAChD;AACA;;AAEA;AACA;AACA;;AAEA;AACA,CAAC;;AAED;AACA;AACA;;AAEA,8BAA8B,QAAQ;AACtC;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,CAAC;AACD;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA,wBAAwB;;AAExB,qCAAqC;;AAErC;AACA;AACA;;AAEA;AACA,CAAC;;AAED;AACA;;AAEA;AACA;AACA;;AAEA;AACA,CAAC;;AAED;AACA,wBAAwB;;AAExB,gCAAgC;;AAEhC;AACA;AACA;;AAEA;AACA,CAAC;;AAED;AACA;AACA;AACA;;AAEA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA,yEAAyE;;AAEzE,uBAAuB,EAAE,UAAU,EAAE,UAAU,EAAE,KAAK;;AAEtD,qCAAqC;;AAErC,mCAAmC;;AAEnC,8BAA8B;;AAE9B,uBAAuB;;AAEvB,wBAAwB,IAAI,IAAI;;AAEhC,qBAAqB;;AAErB,sBAAsB,GAAG,GAAG;;AAE5B,yBAAyB;;AAEzB,yDAAyD;;AAEzD,8BAA8B;;AAE9B,sDAAsD;;AAEtD,yBAAyB;AACzB;;AAEA,yBAAyB;;AAEzB,mCAAmC;;AAEnC,mCAAmC;;AAEnC,gFAAgF;;AAEhF;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;;AAEA;AACA;AACA,uCAAuC;AACvC;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;;;AAGL;AACA;AACA,KAAK;;;AAGL;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA,CAAC;;AAED;AACA;AACA;AACA,GAAG;AACH,sCAAsC,QAAQ;AAC9C;AACA;AACA;;AAEA;AACA,CAAC;AACD;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;;AAEA;AACA,oCAAoC;;AAEpC;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,CAAC;;;AAGD;AACA;AACA;AACA;AACA,mCAAmC;;AAEnC,oEAAoE;;AAEpE;AACA;AACA;;AAEA;AACA;AACA,wCAAwC;;AAExC;AACA,oCAAoC;;AAEpC,+CAA+C;;AAE/C;AACA,GAAG;AACH,CAAC;;AAED;AACA;AACA;AACA,mCAAmC;;AAEnC;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;AACA;AACA,+BAA+B;;AAE/B;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,4BAA4B,KAAK;AACjC;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,mBAAmB;;AAEnB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,wCAAwC;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,EAAE;AACT,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT,OAAO;AACP,KAAK;;;AAGL;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,OAAO;;AAEP;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;;AAET;AACA;AACA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA,SAAS;;;AAGT;AACA;AACA,gCAAgC;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;;;AAGP;AACA;AACA,uDAAuD;;AAEvD;AACA;AACA;AACA;AACA,wEAAwE;;AAExE;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,eAAe;;AAEf;AACA;AACA;AACA;AACA,OAAO;;;AAGP;AACA,0BAA0B;;AAE1B;AACA;AACA,gDAAgD;;AAEhD;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO,QAAQ;;AAEf;AACA;AACA,yDAAyD;;AAEzD;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK,cAAc;;AAEnB;AACA;AACA,4BAA4B;;AAE5B;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,2DAA2D;;AAE3D;AACA;AACA,4EAA4E;;AAE5E;AACA;AACA,mEAAmE;;AAEnE;AACA;AACA,0EAA0E;;AAE1E;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK,cAAc;;AAEnB;AACA;;AAEA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,qDAAqD;;AAErD;AACA;AACA,8BAA8B;;AAE9B,+BAA+B;;AAE/B;AACA;AACA,mKAAmK;;AAEnK;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,qDAAqD;;AAErD;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,oCAAoC;;AAEpC;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,KAAK;;AAEL;;AAEA;AACA;;AAEA;AACA;;AAEA,eAAe,EAAE,EAAE,EAAE,EAAE,EAAE;AACzB;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA,wBAAwB,GAAG,GAAG,GAAG,GAAG,GAAG;AACvC;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK,QAAQ;;AAEb;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,8CAA8C;;AAE9C;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;;AAGH;AACA,oDAAoD;;AAEpD,wZAAwZ;;AAExZ;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA;AACA;AACA;AACA,KAAK,4CAA4C;;AAEjD,0MAA0M;;AAE1M;AACA,8DAA8D;;AAE9D;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,+BAA+B;;AAE/B;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB;;AAEnB;AACA,uCAAuC;AACvC;;AAEA;AACA;AACA;AACA;AACA,gCAAgC;AAChC;;AAEA;AACA,8DAA8D;;AAE9D;AACA,oEAAoE;;AAEpE;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,mBAAmB;;AAEnB;AACA,uDAAuD;;AAEvD;AACA;AACA;AACA,qBAAqB;;AAErB;AACA,gCAAgC;;AAEhC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA,mJAAmJ;AACnJ,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wBAAwB;;AAExB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,wCAAwC;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,0HAA0H;AAC1H;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,0CAA0C;;AAE1C;AACA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0DAA0D;;AAE1D;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA,qGAAqG,uCAAuC,+BAA+B,yFAAyF,OAAO,KAAK;AAChR,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA;AACA,OAAO;AACP;AACA,GAAG;;AAEH;AACA;AACA;;AAEA,CAAC;AACD;;AAEA;AACA;AACA;AACA,4CAA4C;;AAE5C,oCAAoC;;AAEpC;AACA;AACA;;AAEA;AACA,GAAG,IAAI;AACP;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH,CAAC;;AAED;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG,KAAK;AACR;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA,kBAAkB;;AAElB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA;AACA;;AAEA,CAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,oDAAoD;;AAEpD;AACA,2BAA2B;;AAE3B;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA,yCAAyC;;AAEzC;AACA;AACA,SAAS;AACT;AACA,SAAS;;;AAGT;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,KAAK,IAAI;AACT,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,KAAK,OAAO;;AAEZ;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;;;AAGL;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;;;AAGL;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,KAAK;AACL,GAAG;;;AAGH;AACA;AACA;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA,0BAA0B;;AAE1B;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA,qCAAqC,QAAQ;AAC7C;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA,sBAAsB;;AAEtB,6CAA6C;;AAE7C;AACA,6BAA6B;;AAE7B;AACA;AACA,8JAA8J;;AAE9J;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,8BAA8B;;AAE9B;AACA;AACA,KAAK;;;AAGL;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;;AAEA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA,uDAAuD;;AAEvD;AACA,yBAAyB;;AAEzB;AACA,sDAAsD;;AAEtD;AACA;AACA,sCAAsC;;AAEtC;AACA,SAAS;;;AAGT;AACA;;AAEA,qCAAqC;;;AAGrC;AACA,0BAA0B;AAC1B,WAAW;AACX;AACA;AACA,SAAS;AACT,OAAO;;;AAGP;AACA,KAAK;AACL;;;AAGA,sDAAsD;;AAEtD;AACA,yDAAyD;;AAEzD,6BAA6B;;AAE7B,oCAAoC,OAAO;AAC3C;AACA;;AAEA,+BAA+B;;AAE/B;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA,uBAAuB;;AAEvB,kBAAkB;;AAElB;;AAEA;AACA;AACA,oEAAoE;AACpE;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA,qEAAqE;AACrE;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA,mCAAmC,QAAQ;AAC3C;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA;AACA;;AAEA,CAAC,EAAE;;AAEH;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;;AAEA;AACA;AACA,CAAC,IAAI;AACL;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;;AAEA;AACA;;AAEA;AACA,iBAAiB,sBAAsB;AACvC;AACA;;AAEA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA,KAAK;AACL;;AAEA;AACA;;AAEA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA,GAAG;AACH;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,wBAAwB;AACxB;AACA,KAAK;AACL,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK,EAAE;;AAEP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,CAAC;AACD;;AAEA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,iBAAiB;;AAEjB;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,iBAAiB;;AAEjB;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA,mCAAmC;;AAEnC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA,iDAAiD,QAAQ;AACzD;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,uCAAuC;;AAEvC,iDAAiD,QAAQ;AACzD;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA,oBAAoB;;AAEpB;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;;;AAGA,4CAA4C;;AAE5C,uCAAuC,SAAS;AAChD;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA,0BAA0B;;AAE1B;AACA,eAAe;;AAEf;AACA,mCAAmC,QAAQ;AAC3C;AACA;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA;AACA,0BAA0B;;AAE1B,6BAA6B,QAAQ;AACrC;AACA;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,CAAC;;AAED,4BAA4B;;AAE5B;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,iBAAiB;;AAEjB;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA,4BAA4B;;AAE5B;AACA,4BAA4B;;AAE5B;AACA;AACA;;AAEA;AACA,CAAC;AACD;;AAEA;AACA,kBAAkB,YAAY,EAAE;AAChC;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,yCAAyC;AACzC,CAAC;;AAED;AACA,6BAA6B;AAC7B,uCAAuC;AACvC,CAAC;;AAED;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA,iCAAiC,QAAQ,mBAAmB,UAAU,EAAE,EAAE;AAC1E,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,wDAAwD,mBAAmB,UAAU,EAAE,EAAE;AACzF,CAAC;;AAED;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG,YAAY;AACf;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,CAAC;AACD;AACA;AACA;;AAEA,uBAAuB;AACvB;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA;AACA;AACA,CAAC;AACD;AACA,CAAC;AACD,CAAC;;AAED;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,qFAAqF,wBAAwB;AAC7G,oEAAoE;AACpE,+DAA+D;AAC/D;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,cAAc;AACd,cAAc;AACd,cAAc;AACd,cAAc;AACd,eAAe;AACf,eAAe;AACf,eAAe;AACf,gBAAgB;AAChB;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,yCAAyC,cAAc;AACvD,GAAG;AACH;;AAEA;AACA;;AAEA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA,OAAO;AACP;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA,OAAO;AACP;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA,KAAK;;;AAGL;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA,uCAAuC;;AAEvC;AACA;AACA;AACA;AACA,mCAAmC;;AAEnC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,eAAe;;AAEf,mCAAmC;;AAEnC;AACA,2EAA2E;;AAE3E,8CAA8C;;AAE9C;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,6BAA6B;;AAE7B;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;;AAEA;AACA,wCAAwC,QAAQ;AAChD;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,uCAAuC,QAAQ;AAC/C;AACA;AACA,uCAAuC,sCAAsC;AAC7E;AACA;AACA,OAAO;AACP,sCAAsC,QAAQ;AAC9C;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,0BAA0B;;AAE1B;AACA;;AAEA;AACA;AACA,sCAAsC,QAAQ;AAC9C;;AAEA;AACA;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,SAAS;AACT;AACA;AACA;AACA;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA,aAAa;;AAEb,6BAA6B,QAAQ;AACrC;;AAEA;AACA;AACA;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA,sDAAsD;;AAEtD;AACA;AACA;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;;AAEA,iCAAiC,yBAAyB;AAC1D;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,qBAAqB;AACrB;;AAEA,wCAAwC,QAAQ;AAChD;;AAEA,6CAA6C,QAAQ;AACrD;AACA,OAAO;AACP;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,iDAAiD;;AAEjD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,wBAAwB;AACxB,KAAK;AACL;AACA;AACA,OAAO;AACP,KAAK;;;AAGL;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,gBAAgB;AAChB,OAAO;AACP;AACA,OAAO;AACP;AACA;;AAEA;AACA,KAAK;;AAEL;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;;AAEA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,OAAO;AACP;AACA;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA,SAAS;AACT;AACA;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA,OAAO;AACP;AACA;AACA;;AAEA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;;AAEL;AACA;;AAEA;AACA;;AAEA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;;AAEA,qCAAqC,SAAS;AAC9C;AACA;;AAEA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA,GAAG;AACH;;AAEA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;;AAEA,CAAC;;AAED,sCAAsC;;AAEtC;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;;;AAGL;AACA;;AAEA;AACA;AACA;AACA,6BAA6B;;AAE7B;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA,sDAAsD;;AAEtD;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK,EAAE;;AAEP;AACA;AACA,KAAK;;;AAGL;AACA,GAAG;;AAEH;AACA,uBAAuB;;AAEvB,8CAA8C;;AAE9C;AACA;AACA;AACA,KAAK,EAAE;;AAEP;AACA;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA,4CAA4C;;AAE5C;AACA;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA,OAAO;;;AAGP;AACA,KAAK;;;AAGL;AACA;;AAEA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,KAAK;;;AAGL;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,kCAAkC;;AAElC;AACA,sBAAsB;;AAEtB,sBAAsB;;AAEtB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,2BAA2B;;AAE3B;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,KAAK;AACL;AACA;;;AAGA;AACA;AACA,uBAAuB;;AAEvB;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,KAAK;;;AAGL;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;;AAEA;;AAEA;AACA,GAAG;;;AAGH;AACA;;AAEA;;AAEA;;AAEA;;AAEA;AACA;AACA,GAAG;;;AAGH;AACA;;AAEA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,gCAAgC;AAChC;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,kCAAkC;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,sCAAsC,KAAK;AAC3C;AACA;AACA,qCAAqC;AACrC;;AAEA,oDAAoD;AACpD;;AAEA;AACA;AACA;AACA,KAAK;;;AAGL;;AAEA,+CAA+C,SAAS;AACxD;AACA;AACA;AACA,sBAAsB;AACtB;;AAEA,oDAAoD;;AAEpD;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;;AAEA,qCAAqC;AACrC;;AAEA;;AAEA;AACA,2BAA2B;AAC3B,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;;;AAGA;AACA;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA,YAAY;;AAEZ,0BAA0B;;AAE1B,4DAA4D;;AAE5D,gFAAgF;;AAEhF;AACA;AACA;AACA,qBAAqB;;AAErB;AACA;AACA,+DAA+D;;AAE/D,uBAAuB;;AAEvB;AACA;AACA,uBAAuB;;AAEvB,yBAAyB;;AAEzB;AACA,yBAAyB;;AAEzB;AACA;AACA;AACA;AACA;AACA;AACA,yBAAyB;;AAEzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA,KAAK;;;AAGL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA,2BAA2B;;AAE3B;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,QAAQ;;;AAGR;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,mCAAmC;;AAEnC;AACA;AACA,mCAAmC;;AAEnC;AACA,kCAAkC;;AAElC;AACA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;;;AAGA;AACA,wEAAwE;;AAExE,0BAA0B;;AAE1B;AACA,gCAAgC;;;AAGhC;;AAEA;;AAEA;AACA,KAAK;AACL;;;AAGA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;AAGA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;;;AAGA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA,OAAO;AACP;;;AAGA;AACA,6DAA6D;;AAE7D,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA,iDAAiD;;AAEjD,6CAA6C,SAAS;AACtD;AACA,mCAAmC;;AAEnC;AACA,kCAAkC;;AAElC;AACA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA,6CAA6C,SAAS;AACtD;AACA,mCAAmC;AACnC;;AAEA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,0BAA0B;;AAE1B;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA,CAAC,EAAE;;AAEH;;AAEA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;AACA,KAAK;;AAEL;AACA,8CAA8C;AAC9C;AACA;;;AAGA;AACA;AACA,KAAK;;AAEL;AACA;AACA;AACA;AACA;;AAEA;AACA,CAAC;AACD;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;;AAEL;;AAEA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,KAAK;;;AAGL;AACA,iGAAiG;;AAEjG;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,kEAAkE;;AAElE,+BAA+B;;;AAG/B;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP,8CAA8C;AAC9C;AACA,OAAO;AACP;;AAEA;AACA;AACA,4CAA4C;;AAE5C;AACA,sCAAsC;;AAEtC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,OAAO;;;AAGP,mCAAmC;AACnC;AACA,OAAO;AACP;;AAEA;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA,iCAAiC;;AAEjC,sDAAsD;;AAEtD;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK;AACL;AACA,KAAK,EAAE;;AAEP;;AAEA;AACA,GAAG;;AAEH;AACA;AACA,sDAAsD;;AAEtD;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,KAAK,EAAE;;AAEP;;AAEA;AACA,GAAG;;AAEH;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA,KAAK;;AAEL;;AAEA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA,OAAO;AACP;;AAEA;AACA;AACA;AACA;AACA;;AAEA,CAAC;AACD;AACA;AACA;AACA;AACA;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,GAAG;AACH;;;AAGA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,CAAC;;AAED;AACA;AACA;;AAEA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA,0CAA0C;;AAE1C,yBAAyB;;AAEzB,wBAAwB;AACxB;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA,4DAA4D;;AAE5D;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;AACA;;AAEA,4CAA4C,SAAS;AACrD;AACA;AACA;AACA;AACA,SAAS;;;AAGT;AACA;AACA,SAAS;;;AAGT;AACA;;AAEA;AACA,KAAK;;;AAGL;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA,8BAA8B;;AAE9B,uCAAuC,QAAQ;AAC/C;AACA;AACA,KAAK;;;AAGL;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA,KAAK;;;AAGL;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,WAAW;AACX;AACA;AACA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA,8BAA8B;;AAE9B,6BAA6B;;AAE7B;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,8BAA8B;;AAE9B;AACA;AACA,OAAO;;;AAGP;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA,KAAK,EAAE;;AAEP;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;AACA,8FAA8F;;AAE9F;AACA,KAAK;;AAEL;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;;AAEA;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,KAAK;AACL;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;;AAEA;AACA;AACA,OAAO;AACP;AACA;;AAEA;AACA;AACA;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;AACA,KAAK,EAAE;;AAEP;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA;AACA,yFAAyF;;AAEzF;AACA,KAAK;;AAEL;AACA;AACA;AACA,KAAK;;AAEL;AACA;AACA;;AAEA;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA,yBAAyB;;AAEzB;AACA,8CAA8C;AAC9C;;AAEA,WAAW;AACX;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA,6BAA6B;AAC7B;AACA;AACA;AACA,KAAK;AACL;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA,GAAG;AACH,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA,GAAG;;;AAGH;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,GAAG;AACH;AACA;AACA;AACA,gCAAgC;;AAEhC;AACA;AACA;AACA,OAAO;;;AAGP,4CAA4C;;AAE5C;AACA,KAAK;;AAEL;AACA;AACA;AACA;;AAEA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,KAAK;;AAEL;AACA;AACA;;AAEA;AACA,CAAC;AACD;AACA;;AAEA;AACA;AACA;AACA,GAAG;;;AAGH;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA,CAAC;AACD;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,sCAAsC;;AAEtC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;AC33NA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;;AAEA,uBAAuB,oCAAoC;AAC3D,uBAAuB,8BAA8B;AACrD,uBAAuB,kBAAkB;;AAEzC;AACA,oCAAoC,8DAA8D;;AAElG;AACA,kCAAkC,sEAAsE;;AAExG;AACA;AACA;AACA;AACA;AACA;AACA;AACA,KAAK;AACL;AACA;AACA,GAAG;AACH;AACA;;AAEA;AACA,gBAAgB,uBAAuB;AACvC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,iBAAiB,sBAAsB;AACvC;AACA;;AAEA;AACA;AACA;AACA;;AAEA,UAAU,mEAAmE;AAC7E;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,KAAK;AACL;AACA,KAAK;AACL;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;;;;;;;;;;;;AC1GA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAkD;AACN;AACE;AACF;AACA;AACA;AACE;AACF;AACA;AACA;;;;;;;;;;;;;;ACT5C;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AACA;AACA;AACA;;AAEA;AACO;AACA;AACA;;AAEP;AACA;AACA;AACA,WAAW,KAAK;AAChB;AACO;AACP;AACA;;AAEA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,QAAQ;AACrB;AACO;AACP;AACA,C;;;;;;;;;;;;ACzCA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwC;;AAExC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC,MAAM,qDAAmB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB;;AAEO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB;AAC7S;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO,mB;;;;;;;;;;;;ACjbP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwC;;AAExC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,MAAM;AACnB;AACO;AACP,gBAAgB,qDAAmB;AACnC,MAAM,qDAAmB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB;AACvd;;AAEA;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO,mB;;;;;;;;;;;;ACneP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwC;;AAExC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC,MAAM,qDAAmB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,MAAM;AACjB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,UAAU,KAAK;AACf,UAAU,KAAK;AACf;AACA,YAAY,KAAK;AACjB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,UAAU,KAAK;AACf,UAAU,KAAK;AACf;AACA,YAAY,KAAK;AACjB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB;AACttB;;AAEA;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO,mB;;;;;;;;;;;;ACzyBP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwC;;AAExC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC,MAAM,qDAAmB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,YAAY,UAAU,UAAU;AAChC;AACA;AACA;AACA;;AAEA,YAAY,UAAU,WAAW;AACjC;AACA;AACA;AACA;;AAEA,aAAa,WAAW,WAAW;AACnC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH,eAAe,WAAW,WAAW;AACrC,eAAe,WAAW,WAAW;AACrC,eAAe,WAAW,YAAY;;AAEtC,iBAAiB,aAAa,aAAa;AAC3C,iBAAiB,aAAa,aAAa;AAC3C,iBAAiB,aAAa,cAAc;;AAE5C;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,YAAY,kDAAgB;AAC5B;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA,aAAa,WAAW,WAAW;AACnC,aAAa,WAAW,WAAW;AACnC,aAAa,WAAW,YAAY;;AAEpC;AACA,sBAAsB,wBAAwB;AAC9C,0BAA0B,oBAAoB;AAC9C,0BAA0B,wBAAwB;;AAElD;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,YAAY,kDAAgB;AAC5B;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,MAAM;AACjB,aAAa,KAAK;AAClB;AACO;AACP,wBAAwB,qDAAmB;AAC3C;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,YAAY,KAAK;AACjB,YAAY,KAAK;AACjB,YAAY,KAAK;AACjB;AACO;AACP;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,KAAK;AACjB,YAAY,KAAK;AACjB,YAAY,KAAK;AACjB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,YAAY,KAAK;AACjB;AACO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB;AACA,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,iCAAiC,kDAAgB,+BAA+B,kDAAgB,+BAA+B,kDAAgB;AAC/I;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA,8BAA8B,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,uEAAuE,kDAAgB,yEAAyE,kDAAgB,yEAAyE,kDAAgB,yEAAyE,kDAAgB,yEAAyE,kDAAgB,yEAAyE,kDAAgB;AAC/zC;;AAEA;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO,mB;;;;;;;;;;;;AChzDP;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwC;AACN;AACA;AACA;;AAElC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC,MAAM,qDAAmB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,YAAY,KAAK;AACjB,YAAY,KAAK;AACjB,YAAY,OAAO;AACnB;AACO;AACP;AACA;AACA,UAAU,kDAAgB;AAC1B;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,oBAAoB,kDAAgB;AACpC;AACA;AACA;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA,WAAW,iDAAe;AAC1B,WAAW,iDAAe;AAC1B,WAAW,iDAAe;;AAE1B;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACA;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA,oCAAoC;AACpC;AACA,wBAAwB;AACxB;AACA;AACA;AACA,GAAG;AACH;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,EAAE;AACb,WAAW,EAAE;AACb,WAAW,EAAE;AACb,aAAa,KAAK;AAClB;AACA;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACA;AACO,YAAY,8CAAU;;AAE7B;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACA;AACO,iBAAiB,mDAAe;;AAEvC;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACA;AACO,WAAW,6CAAS;;AAE3B;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACA;AACO,UAAU,4CAAQ;;AAEzB;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACA;AACO,UAAU,4CAAQ;;AAEzB;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACA;AACO,YAAY,8CAAU;;AAE7B;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACA;AACO,UAAU,4CAAQ;;AAEzB;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACA;AACO,WAAW,6CAAS;;AAE3B;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO,aAAa,+CAAW;;AAE/B;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACA;AACO,oBAAoB,sDAAkB;;AAE7C;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACA;AACO,gBAAgB,kDAAc;;AAErC;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO,kBAAkB,oDAAgB;;AAEzC;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO,aAAa,+CAAW;;AAE/B;AACA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,+CAAW;AAC3B,kBAAkB,mDAAe;AACjC,kBAAkB,mDAAe;;AAEjC;AACA,cAAc,4CAAQ;AACtB;AACA,MAAM,8CAAU;AAChB,UAAU,4CAAQ,sBAAsB,8CAAU;AAClD,MAAM,kDAAc;AACpB;AACA;AACA,KAAK;AACL;AACA;AACA;AACA;AACA;AACA,KAAK;AACL,MAAM,8CAAU;AAChB;AACA;AACA;AACA;AACA;AACA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA,CAAC;;AAED;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP,aAAa,+CAAW;;AAExB;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,CAAC,G;;;;;;;;;;;;ACppBD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwC;AACN;AACA;;AAElC;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,MAAM;AACnB;AACO;AACP,eAAe,qDAAmB;AAClC,MAAM,qDAAmB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACO;AACP,eAAe,qDAAmB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACO;AACP,eAAe,qDAAmB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACO;AACP,eAAe,qDAAmB;AAClC;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACA;AACO;AACP;AACA,cAAc,+CAAW;AACzB,EAAE,oDAAgB;AAClB,cAAc,qDAAmB;AACjC,EAAE,uDAAmB;AACrB;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,YAAY,KAAK;AACjB,YAAY,MAAM;AAClB,YAAY,KAAK;AACjB;AACO,cAAc,6CAAS;;AAE9B;AACA;AACA,YAAY,KAAK;AACjB,YAAY,MAAM;AAClB,YAAY,KAAK;AACjB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACA;AACO,cAAc,6CAAS;;AAE9B;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,YAAY,KAAK;AACjB,YAAY,MAAM;AAClB,YAAY,KAAK;AACjB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,gDAAY;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,gDAAY;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,EAAE,gDAAY;AACd;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACO;AACP;AACA,sBAAsB,kDAAgB;AACtC;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,OAAO;AACpB;AACA;AACO,UAAU,4CAAQ;;AAEzB;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,OAAO;AACpB;AACA;AACO,aAAa,+CAAW;;AAE/B;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,OAAO;AACpB;AACA;AACO,oBAAoB,sDAAkB;;AAE7C;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,MAAM;AACnB;AACA;AACO;AACP;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,MAAM;AACjB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB;AACjoB,C;;;;;;;;;;;;AC30BA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwC;;AAExC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC,MAAM,qDAAmB;AACzB;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA,UAAU,iDAAe;AACzB;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,MAAM;AACjB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;;AAEA;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;AACA;AACA;AACA,8BAA8B,kDAAgB,qEAAqE,kDAAgB;AACnI;;AAEA;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;;AAEA,oBAAoB,OAAO;AAC3B,oBAAoB;AACpB;AACA,oBAAoB;AACpB;;AAEA;AACA;AACA,CAAC,G;;;;;;;;;;;;AChnBD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwC;;AAExC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC,MAAM,qDAAmB;AACzB;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;;AAEA,UAAU,iDAAe;AACzB,UAAU,iDAAe;AACzB;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;;AAEA;AACA;;AAEA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;;AAEA;;AAEA;AACA;AACA,GAAG;AACH;AACA,GAAG;AACH;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB;AACxN;;AAEA;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA;AACA;AACA,WAAW,MAAM;AACjB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,SAAS;AACpB,WAAW,OAAO;AAClB,aAAa,MAAM;AACnB;AACA;AACO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;;AAEA;AACA;AACA,KAAK;AACL;AACA;;AAEA,oBAAoB,OAAO;AAC3B,oBAAoB,kBAAkB;AACtC;AACA,oBAAoB,kBAAkB;AACtC;;AAEA;AACA;AACA,CAAC,G;;;;;;;;;;;;AClxBD;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAwC;;AAExC;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC,MAAM,qDAAmB;AACzB;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP,gBAAgB,qDAAmB;AACnC;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,OAAO;AAClB,aAAa,KAAK;AAClB;AACO;AACP;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA,SAAS,iDAAe;AACxB,SAAS,iDAAe;AACxB;AACA,GAAG;AACH;AACA,SAAS,iDAAe;AACxB,SAAS,iDAAe;AACxB;AACA,GAAG;;AAEH;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,KAAK;AAClB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA;AACA;AACA;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,aAAa,OAAO;AACpB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;;AAEA;AACA;AACA;AACA,WAAW,KAAK;AAChB,WAAW,KAAK;AAChB,aAAa,QAAQ;AACrB;AACO;AACP;AACA;AACA;AACA;AACA;AACA;AACA;AACA;AACA,8BAA8B,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB,qEAAqE,kDAAgB;AAC7S;;AAEA;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;AACd;AACA;AACO;;AAEP;AACA,cAAc;A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","file":"example.build.js","sourcesContent":[" \t// The module cache\n \tvar installedModules = {};\n\n \t// The require function\n \tfunction __webpack_require__(moduleId) {\n\n \t\t// Check if module is in cache\n \t\tif(installedModules[moduleId]) {\n \t\t\treturn installedModules[moduleId].exports;\n \t\t}\n \t\t// Create a new module (and put it into the cache)\n \t\tvar module = installedModules[moduleId] = {\n \t\t\ti: moduleId,\n \t\t\tl: false,\n \t\t\texports: {}\n \t\t};\n\n \t\t// Execute the module function\n \t\tmodules[moduleId].call(module.exports, module, module.exports, __webpack_require__);\n\n \t\t// Flag the module as loaded\n \t\tmodule.l = true;\n\n \t\t// Return the exports of the module\n \t\treturn module.exports;\n \t}\n\n\n \t// expose the modules object (__webpack_modules__)\n \t__webpack_require__.m = modules;\n\n \t// expose the module cache\n \t__webpack_require__.c = installedModules;\n\n \t// define getter function for harmony exports\n \t__webpack_require__.d = function(exports, name, getter) {\n \t\tif(!__webpack_require__.o(exports, name)) {\n \t\t\tObject.defineProperty(exports, name, { enumerable: true, get: getter });\n \t\t}\n \t};\n\n \t// define __esModule on exports\n \t__webpack_require__.r = function(exports) {\n \t\tif(typeof Symbol !== 'undefined' && Symbol.toStringTag) {\n \t\t\tObject.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });\n \t\t}\n \t\tObject.defineProperty(exports, '__esModule', { value: true });\n \t};\n\n \t// create a fake namespace object\n \t// mode & 1: value is a module id, require it\n \t// mode & 2: merge all properties of value into the ns\n \t// mode & 4: return value when already ns object\n \t// mode & 8|1: behave like require\n \t__webpack_require__.t = function(value, mode) {\n \t\tif(mode & 1) value = __webpack_require__(value);\n \t\tif(mode & 8) return value;\n \t\tif((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;\n \t\tvar ns = Object.create(null);\n \t\t__webpack_require__.r(ns);\n \t\tObject.defineProperty(ns, 'default', { enumerable: true, value: value });\n \t\tif(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));\n \t\treturn ns;\n \t};\n\n \t// getDefaultExport function for compatibility with non-harmony modules\n \t__webpack_require__.n = function(module) {\n \t\tvar getter = module && module.__esModule ?\n \t\t\tfunction getDefault() { return module['default']; } :\n \t\t\tfunction getModuleExports() { return module; };\n \t\t__webpack_require__.d(getter, 'a', getter);\n \t\treturn getter;\n \t};\n\n \t// Object.prototype.hasOwnProperty.call\n \t__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };\n\n \t// __webpack_public_path__\n \t__webpack_require__.p = \"\";\n\n\n \t// Load entry module and return exports\n \treturn __webpack_require__(__webpack_require__.s = \"./example/example.js\");\n","import { mat2d } from 'gl-matrix'\nconst Flare = require('../source/Flare.js')\n\nconst _ViewCenter = [500.0, 500.0];\nconst _Scale = 0.5;\n\nfunction FlareExample(canvas)\n{\n\tthis._Graphics = new Flare.Graphics(canvas);\n\tthis._LastAdvanceTime = Date.now();\n\tthis._ViewTransform = mat2d.create();\n\tthis._AnimationInstance = null;\n\tthis._Animation = null;\n\tthis._SoloSkaterAnimation = null;\n\n\tconst _This = this;\n\n\t_ScheduleAdvance(_This);\n\t_Advance(_This);\n}\n\nfunction _Advance(_This)\n{\n\t_ScheduleAdvance(_This);\n\n\t_This.setSize(self.innerWidth, self.innerHeight);\n\n\tconst now = Date.now();\n\tconst elapsed = (now - _This._LastAdvanceTime)/1000.0;\n\t_This._LastAdvanceTime = now;\n\n\tconst actor = _This._ActorInstance;\n\n\tif(_This._AnimationInstance)\n\t{\n\t\tconst ai = _This._AnimationInstance;\n\t\tai.time = ai.time + elapsed;\n\t\tai.apply(_This._ActorInstance, 1.0);\n\t}\n\n\tif(actor)\n\t{\n\t\tconst graphics = _This._Graphics;\n\n\t\tconst w = graphics.viewportWidth;\n\t\tconst h = graphics.viewportHeight;\n\n\t\tconst vt = _This._ViewTransform;\n\t\tvt[0] = _Scale;\n\t\tvt[3] = _Scale;\n\t\tvt[4] = (-_ViewCenter[0] * _Scale + w/2);\n\t\tvt[5] = (-_ViewCenter[1] * _Scale + h/2);\n\n\t\tactor.advance(elapsed);\n\t}\n\n\t_Draw(_This, _This._Graphics);\n}\n\nlet count = 0\n\nsetInterval(() => {\n\tconsole.log(count)\n\n\tcount = 0\n}, 1000)\n\nfunction _Draw(viewer, graphics)\n{\n\tif(!viewer._Actor)\n\t{\n\t\treturn;\n\t}\n\n\tcount++\n\n\tgraphics.clear([0.3628, 0.3628, 0.3628, 1.0]);\n\tgraphics.setView(viewer._ViewTransform);\n\tviewer._ActorInstance.draw(graphics);\n}\n\nfunction _ScheduleAdvance(viewer)\n{\n\t{\n\t\tself.requestAnimationFrame(function()\n\t\t\t{\n\t\t\t\t_Advance(viewer);\n\t\t\t});\n\t}\n}\n\nFlareExample.prototype.load = function(url, callback)\n{\n\tconst loader = new Flare.ActorLoader();\n\tconst _This = this;\n\tloader.load(url, function(actor)\n\t{\n\t\tif(!actor || actor.error)\n\t\t{\n\t\t\tcallback(!actor ? null : actor.error);\n\t\t}\n\t\telse\n\t\t{\n\t\t\t_This.setActor(actor);\n\t\t\tcallback();\n\t\t}\n\t});\n};\n\nFlareExample.prototype.setActor = function(actor)\n{\n\tif(this._Actor)\n\t{\n\t\tthis._Actor.dispose(this._Graphics);\n\t}\n\tif(this._ActorInstance)\n\t{\n\t\tthis._ActorInstance.dispose(this._Graphics);\n\t}\n\tactor.initialize(this._Graphics);\n\n\tconst actorInstance = actor.makeInstance();\n\tactorInstance.initialize(this._Graphics);\n\n\tthis._Actor = actor;\n\tthis._ActorInstance = actorInstance;\n\n\tif(actorInstance)\n\t{\n\t\tactorInstance.initialize(this._Graphics);\n\t\tif(actorInstance._Animations.length)\n\t\t{\n\t\t\tthis._Animation = actorInstance._Animations[0];\n\t\t\tthis._AnimationInstance = new Flare.AnimationInstance(this._Animation._Actor, this._Animation);\n\n\t\t\tif(!this._AnimationInstance)\n\t\t\t{\n\t\t\t\tconsole.log(\"NO ANIMATION IN HERE!?\");\n\t\t\t\treturn;\n\t\t\t}\n\n\t\t}\n\t}\n};\n\nFlareExample.prototype.setSize = function(width, height)\n{\n\tthis._Graphics.setSize(width, height);\n};\n\nlet flareExample;\n\nself.addEventListener(\"message\", (event) => {\n\tswitch (event.data.type)\n\t\t{\n\t\t\tcase \"INIT\":\n\t\t\t\t/*\n\t\t\t\t * Window isn't available in WW so we're getting this info\n\t\t\t\t * passed from the main thread and then mocking it. IRL it\n\t\t\t\t * would make sense for the app to have no refs to window.\n\t\t\t\t */\n\t\t\t\tself.innerWidth = event.data.innerWidth\n\t\t\t\tself.innerHeight = event.data.innerHeight\n\t\t\t\tflareExample = new FlareExample(event.data.canvas);\n\t\t\t\tbreak;\n\n\t\t\tcase \"LOAD\":\n\t\t\t\tflareExample.load(event.data.url, function (error) {\n\t\t\t\t\t\tif (error) {\n\t\t\t\t\t\t\tconsole.log(\"failed to load actor file...\", error);\n\t\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t\tbreak;\n\n\t\t\tcase \"SET_SIZE\":\n\t\t\t\tflareExample.setSize(event.data.width, event.data.height)\n\t\t}\n});","/*!\n* @svgdotjs/svg.js - A lightweight library for manipulating and animating SVG.\n* @version 3.0.5\n* https://svgdotjs.github.io/\n*\n* @copyright Wout Fierens \n* @license MIT\n*\n* BUILT: Wed Dec 12 2018 23:21:54 GMT+0100 (GMT+01:00)\n*/;\n'use strict';\n\nObject.defineProperty(exports, '__esModule', { value: true });\n\nconst methods = {};\nconst names = [];\nfunction registerMethods(name, m) {\n if (Array.isArray(name)) {\n for (let _name of name) {\n registerMethods(_name, m);\n }\n\n return;\n }\n\n if (typeof name === 'object') {\n for (let _name in name) {\n registerMethods(_name, name[_name]);\n }\n\n return;\n }\n\n addMethodNames(Object.getOwnPropertyNames(m));\n methods[name] = Object.assign(methods[name] || {}, m);\n}\nfunction getMethodsFor(name) {\n return methods[name] || {};\n}\nfunction getMethodNames() {\n return [...new Set(names)];\n}\nfunction addMethodNames(_names) {\n names.push(..._names);\n}\n\n// Map function\nfunction map(array, block) {\n var i;\n var il = array.length;\n var result = [];\n\n for (i = 0; i < il; i++) {\n result.push(block(array[i]));\n }\n\n return result;\n} // Filter function\n\nfunction filter(array, block) {\n var i;\n var il = array.length;\n var result = [];\n\n for (i = 0; i < il; i++) {\n if (block(array[i])) {\n result.push(array[i]);\n }\n }\n\n return result;\n} // Degrees to radians\n\nfunction radians(d) {\n return d % 360 * Math.PI / 180;\n} // Radians to degrees\n\nfunction degrees(r) {\n return r * 180 / Math.PI % 360;\n} // Convert dash-separated-string to camelCase\n\nfunction camelCase(s) {\n return s.toLowerCase().replace(/-(.)/g, function (m, g) {\n return g.toUpperCase();\n });\n} // Convert camel cased string to string seperated\n\nfunction unCamelCase(s) {\n return s.replace(/([A-Z])/g, function (m, g) {\n return '-' + g.toLowerCase();\n });\n} // Capitalize first letter of a string\n\nfunction capitalize(s) {\n return s.charAt(0).toUpperCase() + s.slice(1);\n} // Calculate proportional width and height values when necessary\n\nfunction proportionalSize(element, width, height, box) {\n if (width == null || height == null) {\n box = box || element.bbox();\n\n if (width == null) {\n width = box.width / box.height * height;\n } else if (height == null) {\n height = box.height / box.width * width;\n }\n }\n\n return {\n width: width,\n height: height\n };\n}\nfunction getOrigin(o, element) {\n // Allow origin or around as the names\n let origin = o.origin; // o.around == null ? o.origin : o.around\n\n let ox, oy; // Allow the user to pass a string to rotate around a given point\n\n if (typeof origin === 'string' || origin == null) {\n // Get the bounding box of the element with no transformations applied\n const string = (origin || 'center').toLowerCase().trim();\n const {\n height,\n width,\n x,\n y\n } = element.bbox(); // Calculate the transformed x and y coordinates\n\n let bx = string.includes('left') ? x : string.includes('right') ? x + width : x + width / 2;\n let by = string.includes('top') ? y : string.includes('bottom') ? y + height : y + height / 2; // Set the bounds eg : \"bottom-left\", \"Top right\", \"middle\" etc...\n\n ox = o.ox != null ? o.ox : bx;\n oy = o.oy != null ? o.oy : by;\n } else {\n ox = origin[0];\n oy = origin[1];\n } // Return the origin as it is if it wasn't a string\n\n\n return [ox, oy];\n}\n\nvar utils = ({\n map: map,\n filter: filter,\n radians: radians,\n degrees: degrees,\n camelCase: camelCase,\n unCamelCase: unCamelCase,\n capitalize: capitalize,\n proportionalSize: proportionalSize,\n getOrigin: getOrigin\n});\n\n// Default namespaces\nlet ns = 'http://www.w3.org/2000/svg';\nlet xmlns = 'http://www.w3.org/2000/xmlns/';\nlet xlink = 'http://www.w3.org/1999/xlink';\nlet svgjs = 'http://svgjs.com/svgjs';\n\nvar namespaces = ({\n ns: ns,\n xmlns: xmlns,\n xlink: xlink,\n svgjs: svgjs\n});\n\nconst globals = {\n window: typeof window === 'undefined' ? null : window,\n document: typeof document === 'undefined' ? null : document\n};\nfunction registerWindow(win = null, doc = null) {\n globals.window = win;\n globals.document = doc;\n}\n\nclass Base {// constructor (node/*, {extensions = []} */) {\n // // this.tags = []\n // //\n // // for (let extension of extensions) {\n // // extension.setup.call(this, node)\n // // this.tags.push(extension.name)\n // // }\n // }\n}\n\nconst elements = {};\nconst root = '___SYMBOL___ROOT___'; // Method for element creation\n\nfunction create(name) {\n // create element\n return globals.document.createElementNS(ns, name);\n}\nfunction makeInstance(element) {\n if (element instanceof Base) return element;\n\n if (typeof element === 'object') {\n return adopter(element);\n }\n\n if (element == null) {\n return new elements[root]();\n }\n\n if (typeof element === 'string' && element.charAt(0) !== '<') {\n return adopter(globals.document.querySelector(element));\n }\n\n var node = create('svg');\n node.innerHTML = element; // We can use firstChild here because we know,\n // that the first char is < and thus an element\n\n element = adopter(node.firstChild);\n return element;\n}\nfunction nodeOrNew(name, node) {\n return node instanceof globals.window.Node ? node : create(name);\n} // Adopt existing svg elements\n\nfunction adopt(node) {\n // check for presence of node\n if (!node) return null; // make sure a node isn't already adopted\n\n if (node.instance instanceof Base) return node.instance; // initialize variables\n\n var className = capitalize(node.nodeName || 'Dom'); // Make sure that gradients are adopted correctly\n\n if (className === 'LinearGradient' || className === 'RadialGradient') {\n className = 'Gradient'; // Fallback to Dom if element is not known\n } else if (!elements[className]) {\n className = 'Dom';\n }\n\n return new elements[className](node);\n}\nlet adopter = adopt;\nfunction mockAdopt(mock = adopt) {\n adopter = mock;\n}\nfunction register(element, name = element.name, asRoot = false) {\n elements[name] = element;\n if (asRoot) elements[root] = element;\n addMethodNames(Object.getOwnPropertyNames(element.prototype));\n return element;\n}\nfunction getClass(name) {\n return elements[name];\n} // Element id sequence\n\nlet did = 1000; // Get next named element id\n\nfunction eid(name) {\n return 'Svgjs' + capitalize(name) + did++;\n} // Deep new id assignment\n\nfunction assignNewId(node) {\n // do the same for SVG child nodes as well\n for (var i = node.children.length - 1; i >= 0; i--) {\n assignNewId(node.children[i]);\n }\n\n if (node.id) {\n return adopt(node).id(eid(node.nodeName));\n }\n\n return adopt(node);\n} // Method for extending objects\n\nfunction extend(modules, methods, attrCheck) {\n var key, i;\n modules = Array.isArray(modules) ? modules : [modules];\n\n for (i = modules.length - 1; i >= 0; i--) {\n for (key in methods) {\n let method = methods[key];\n\n if (attrCheck) {\n method = wrapWithAttrCheck(methods[key]);\n }\n\n modules[i].prototype[key] = method;\n }\n }\n} // export function extendWithAttrCheck (...args) {\n// extend(...args, true)\n// }\n\nfunction wrapWithAttrCheck(fn) {\n return function (...args) {\n let o = args[args.length - 1];\n\n if (o && o.constructor === Object && !(o instanceof Array)) {\n return fn.apply(this, args.slice(0, -1)).attr(o);\n } else {\n return fn.apply(this, args);\n }\n };\n}\n\nfunction siblings() {\n return this.parent().children();\n} // Get the curent position siblings\n\nfunction position() {\n return this.parent().index(this);\n} // Get the next element (will return null if there is none)\n\nfunction next() {\n return this.siblings()[this.position() + 1];\n} // Get the next element (will return null if there is none)\n\nfunction prev() {\n return this.siblings()[this.position() - 1];\n} // Send given element one step forward\n\nfunction forward() {\n var i = this.position() + 1;\n var p = this.parent(); // move node one step forward\n\n p.removeElement(this).add(this, i); // make sure defs node is always at the top\n\n if (typeof p.isRoot === 'function' && p.isRoot()) {\n p.node.appendChild(p.defs().node);\n }\n\n return this;\n} // Send given element one step backward\n\nfunction backward() {\n var i = this.position();\n\n if (i > 0) {\n this.parent().removeElement(this).add(this, i - 1);\n }\n\n return this;\n} // Send given element all the way to the front\n\nfunction front() {\n var p = this.parent(); // Move node forward\n\n p.node.appendChild(this.node); // Make sure defs node is always at the top\n\n if (typeof p.isRoot === 'function' && p.isRoot()) {\n p.node.appendChild(p.defs().node);\n }\n\n return this;\n} // Send given element all the way to the back\n\nfunction back() {\n if (this.position() > 0) {\n this.parent().removeElement(this).add(this, 0);\n }\n\n return this;\n} // Inserts a given element before the targeted element\n\nfunction before(element) {\n element = makeInstance(element);\n element.remove();\n var i = this.position();\n this.parent().add(element, i);\n return this;\n} // Inserts a given element after the targeted element\n\nfunction after(element) {\n element = makeInstance(element);\n element.remove();\n var i = this.position();\n this.parent().add(element, i + 1);\n return this;\n}\nfunction insertBefore(element) {\n element = makeInstance(element);\n element.before(this);\n return this;\n}\nfunction insertAfter(element) {\n element = makeInstance(element);\n element.after(this);\n return this;\n}\nregisterMethods('Dom', {\n siblings,\n position,\n next,\n prev,\n forward,\n backward,\n front,\n back,\n before,\n after,\n insertBefore,\n insertAfter\n});\n\n// Parse unit value\nlet numberAndUnit = /^([+-]?(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?)([a-z%]*)$/i; // Parse hex value\n\nlet hex = /^#?([a-f\\d]{2})([a-f\\d]{2})([a-f\\d]{2})$/i; // Parse rgb value\n\nlet rgb = /rgb\\((\\d+),(\\d+),(\\d+)\\)/; // Parse reference id\n\nlet reference = /(#[a-z0-9\\-_]+)/i; // splits a transformation chain\n\nlet transforms = /\\)\\s*,?\\s*/; // Whitespace\n\nlet whitespace = /\\s/g; // Test hex value\n\nlet isHex = /^#[a-f0-9]{3,6}$/i; // Test rgb value\n\nlet isRgb = /^rgb\\(/; // Test css declaration\n\nlet isCss = /[^:]+:[^;]+;?/; // Test for blank string\n\nlet isBlank = /^(\\s+)?$/; // Test for numeric string\n\nlet isNumber = /^[+-]?(\\d+(\\.\\d*)?|\\.\\d+)(e[+-]?\\d+)?$/i; // Test for percent value\n\nlet isPercent = /^-?[\\d.]+%$/; // Test for image url\n\nlet isImage = /\\.(jpg|jpeg|png|gif|svg)(\\?[^=]+.*)?/i; // split at whitespace and comma\n\nlet delimiter = /[\\s,]+/; // The following regex are used to parse the d attribute of a path\n// Matches all hyphens which are not after an exponent\n\nlet hyphen = /([^e])-/gi; // Replaces and tests for all path letters\n\nlet pathLetters = /[MLHVCSQTAZ]/gi; // yes we need this one, too\n\nlet isPathLetter = /[MLHVCSQTAZ]/i; // matches 0.154.23.45\n\nlet numbersWithDots = /((\\d?\\.\\d+(?:e[+-]?\\d+)?)((?:\\.\\d+(?:e[+-]?\\d+)?)+))+/gi; // matches .\n\nlet dots = /\\./g;\n\nvar regex = ({\n numberAndUnit: numberAndUnit,\n hex: hex,\n rgb: rgb,\n reference: reference,\n transforms: transforms,\n whitespace: whitespace,\n isHex: isHex,\n isRgb: isRgb,\n isCss: isCss,\n isBlank: isBlank,\n isNumber: isNumber,\n isPercent: isPercent,\n isImage: isImage,\n delimiter: delimiter,\n hyphen: hyphen,\n pathLetters: pathLetters,\n isPathLetter: isPathLetter,\n numbersWithDots: numbersWithDots,\n dots: dots\n});\n\nfunction classes() {\n var attr = this.attr('class');\n return attr == null ? [] : attr.trim().split(delimiter);\n} // Return true if class exists on the node, false otherwise\n\nfunction hasClass(name) {\n return this.classes().indexOf(name) !== -1;\n} // Add class to the node\n\nfunction addClass(name) {\n if (!this.hasClass(name)) {\n var array = this.classes();\n array.push(name);\n this.attr('class', array.join(' '));\n }\n\n return this;\n} // Remove class from the node\n\nfunction removeClass(name) {\n if (this.hasClass(name)) {\n this.attr('class', this.classes().filter(function (c) {\n return c !== name;\n }).join(' '));\n }\n\n return this;\n} // Toggle the presence of a class on the node\n\nfunction toggleClass(name) {\n return this.hasClass(name) ? this.removeClass(name) : this.addClass(name);\n}\nregisterMethods('Dom', {\n classes,\n hasClass,\n addClass,\n removeClass,\n toggleClass\n});\n\nfunction css(style, val) {\n let ret = {};\n\n if (arguments.length === 0) {\n // get full style as object\n this.node.style.cssText.split(/\\s*;\\s*/).filter(function (el) {\n return !!el.length;\n }).forEach(function (el) {\n let t = el.split(/\\s*:\\s*/);\n ret[t[0]] = t[1];\n });\n return ret;\n }\n\n if (arguments.length < 2) {\n // get style properties in the array\n if (Array.isArray(style)) {\n for (let name of style) {\n let cased = camelCase(name);\n ret[cased] = this.node.style[cased];\n }\n\n return ret;\n } // get style for property\n\n\n if (typeof style === 'string') {\n return this.node.style[camelCase(style)];\n } // set styles in object\n\n\n if (typeof style === 'object') {\n for (let name in style) {\n // set empty string if null/undefined/'' was given\n this.node.style[camelCase(name)] = style[name] == null || isBlank.test(style[name]) ? '' : style[name];\n }\n }\n } // set style for property\n\n\n if (arguments.length === 2) {\n this.node.style[camelCase(style)] = val == null || isBlank.test(val) ? '' : val;\n }\n\n return this;\n} // Show element\n\nfunction show() {\n return this.css('display', '');\n} // Hide element\n\nfunction hide() {\n return this.css('display', 'none');\n} // Is element visible?\n\nfunction visible() {\n return this.css('display') !== 'none';\n}\nregisterMethods('Dom', {\n css,\n show,\n hide,\n visible\n});\n\nfunction data(a, v, r) {\n if (typeof a === 'object') {\n for (v in a) {\n this.data(v, a[v]);\n }\n } else if (arguments.length < 2) {\n try {\n return JSON.parse(this.attr('data-' + a));\n } catch (e) {\n return this.attr('data-' + a);\n }\n } else {\n this.attr('data-' + a, v === null ? null : r === true || typeof v === 'string' || typeof v === 'number' ? v : JSON.stringify(v));\n }\n\n return this;\n}\nregisterMethods('Dom', {\n data\n});\n\nfunction remember(k, v) {\n // remember every item in an object individually\n if (typeof arguments[0] === 'object') {\n for (var key in k) {\n this.remember(key, k[key]);\n }\n } else if (arguments.length === 1) {\n // retrieve memory\n return this.memory()[k];\n } else {\n // store memory\n this.memory()[k] = v;\n }\n\n return this;\n} // Erase a given memory\n\nfunction forget() {\n if (arguments.length === 0) {\n this._memory = {};\n } else {\n for (var i = arguments.length - 1; i >= 0; i--) {\n delete this.memory()[arguments[i]];\n }\n }\n\n return this;\n} // This triggers creation of a new hidden class which is not performant\n// However, this function is not rarely used so it will not happen frequently\n// Return local memory object\n\nfunction memory() {\n return this._memory = this._memory || {};\n}\nregisterMethods('Dom', {\n remember,\n forget,\n memory\n});\n\nlet listenerId = 0;\nlet windowEvents = {};\n\nfunction getEvents(instance) {\n let n = instance.getEventHolder(); // We dont want to save events in global space\n\n if (n === globals.window) n = windowEvents;\n if (!n.events) n.events = {};\n return n.events;\n}\n\nfunction getEventTarget(instance) {\n return instance.getEventTarget();\n}\n\nfunction clearEvents(instance) {\n const n = instance.getEventHolder();\n if (n.events) n.events = {};\n} // Add event binder in the SVG namespace\n\n\nfunction on(node, events, listener, binding, options) {\n var l = listener.bind(binding || node);\n var instance = makeInstance(node);\n var bag = getEvents(instance);\n var n = getEventTarget(instance); // events can be an array of events or a string of events\n\n events = Array.isArray(events) ? events : events.split(delimiter); // add id to listener\n\n if (!listener._svgjsListenerId) {\n listener._svgjsListenerId = ++listenerId;\n }\n\n events.forEach(function (event) {\n var ev = event.split('.')[0];\n var ns = event.split('.')[1] || '*'; // ensure valid object\n\n bag[ev] = bag[ev] || {};\n bag[ev][ns] = bag[ev][ns] || {}; // reference listener\n\n bag[ev][ns][listener._svgjsListenerId] = l; // add listener\n\n n.addEventListener(ev, l, options || false);\n });\n} // Add event unbinder in the SVG namespace\n\nfunction off(node, events, listener, options) {\n var instance = makeInstance(node);\n var bag = getEvents(instance);\n var n = getEventTarget(instance); // listener can be a function or a number\n\n if (typeof listener === 'function') {\n listener = listener._svgjsListenerId;\n if (!listener) return;\n } // events can be an array of events or a string or undefined\n\n\n events = Array.isArray(events) ? events : (events || '').split(delimiter);\n events.forEach(function (event) {\n var ev = event && event.split('.')[0];\n var ns = event && event.split('.')[1];\n var namespace, l;\n\n if (listener) {\n // remove listener reference\n if (bag[ev] && bag[ev][ns || '*']) {\n // removeListener\n n.removeEventListener(ev, bag[ev][ns || '*'][listener], options || false);\n delete bag[ev][ns || '*'][listener];\n }\n } else if (ev && ns) {\n // remove all listeners for a namespaced event\n if (bag[ev] && bag[ev][ns]) {\n for (l in bag[ev][ns]) {\n off(n, [ev, ns].join('.'), l);\n }\n\n delete bag[ev][ns];\n }\n } else if (ns) {\n // remove all listeners for a specific namespace\n for (event in bag) {\n for (namespace in bag[event]) {\n if (ns === namespace) {\n off(n, [event, ns].join('.'));\n }\n }\n }\n } else if (ev) {\n // remove all listeners for the event\n if (bag[ev]) {\n for (namespace in bag[ev]) {\n off(n, [ev, namespace].join('.'));\n }\n\n delete bag[ev];\n }\n } else {\n // remove all listeners on a given node\n for (event in bag) {\n off(n, event);\n }\n\n clearEvents(instance);\n }\n });\n}\nfunction dispatch(node, event, data) {\n var n = getEventTarget(node); // Dispatch event\n\n if (event instanceof globals.window.Event) {\n n.dispatchEvent(event);\n } else {\n event = new globals.window.CustomEvent(event, {\n detail: data,\n cancelable: true\n });\n n.dispatchEvent(event);\n }\n\n return event;\n}\n\nfunction sixDigitHex(hex$$1) {\n return hex$$1.length === 4 ? ['#', hex$$1.substring(1, 2), hex$$1.substring(1, 2), hex$$1.substring(2, 3), hex$$1.substring(2, 3), hex$$1.substring(3, 4), hex$$1.substring(3, 4)].join('') : hex$$1;\n}\n\nfunction componentHex(component) {\n const integer = Math.round(component);\n const bounded = Math.max(0, Math.min(255, integer));\n const hex$$1 = bounded.toString(16);\n return hex$$1.length === 1 ? '0' + hex$$1 : hex$$1;\n}\n\nfunction is(object, space) {\n for (let i = space.length; i--;) {\n if (object[space[i]] == null) {\n return false;\n }\n }\n\n return true;\n}\n\nfunction getParameters(a, b) {\n const params = is(a, 'rgb') ? {\n _a: a.r,\n _b: a.g,\n _c: a.b,\n space: 'rgb'\n } : is(a, 'xyz') ? {\n _a: a.x,\n _b: a.y,\n _c: a.z,\n _d: 0,\n space: 'xyz'\n } : is(a, 'hsl') ? {\n _a: a.h,\n _b: a.s,\n _c: a.l,\n _d: 0,\n space: 'hsl'\n } : is(a, 'lab') ? {\n _a: a.l,\n _b: a.a,\n _c: a.b,\n _d: 0,\n space: 'lab'\n } : is(a, 'lch') ? {\n _a: a.l,\n _b: a.c,\n _c: a.h,\n _d: 0,\n space: 'lch'\n } : is(a, 'cmyk') ? {\n _a: a.c,\n _b: a.m,\n _c: a.y,\n _d: a.k,\n space: 'cmyk'\n } : {\n _a: 0,\n _b: 0,\n _c: 0,\n space: 'rgb'\n };\n params.space = b || params.space;\n return params;\n}\n\nfunction cieSpace(space) {\n if (space === 'lab' || space === 'xyz' || space === 'lch') {\n return true;\n } else {\n return false;\n }\n}\n\nfunction hueToRgb(p, q, t) {\n if (t < 0) t += 1;\n if (t > 1) t -= 1;\n if (t < 1 / 6) return p + (q - p) * 6 * t;\n if (t < 1 / 2) return q;\n if (t < 2 / 3) return p + (q - p) * (2 / 3 - t) * 6;\n return p;\n}\n\nclass Color {\n constructor(...inputs) {\n this.init(...inputs);\n }\n\n init(a = 0, b = 0, c = 0, d = 0, space = 'rgb') {\n // This catches the case when a falsy value is passed like ''\n a = !a ? 0 : a; // Reset all values in case the init function is rerun with new color space\n\n if (this.space) {\n for (let component in this.space) {\n delete this[this.space[component]];\n }\n }\n\n if (typeof a === 'number') {\n // Allow for the case that we don't need d...\n space = typeof d === 'string' ? d : space;\n d = typeof d === 'string' ? 0 : d; // Assign the values straight to the color\n\n Object.assign(this, {\n _a: a,\n _b: b,\n _c: c,\n _d: d,\n space\n }); // If the user gave us an array, make the color from it\n } else if (a instanceof Array) {\n this.space = b || (typeof a[3] === 'string' ? a[3] : a[4]) || 'rgb';\n Object.assign(this, {\n _a: a[0],\n _b: a[1],\n _c: a[2],\n _d: a[3] || 0\n });\n } else if (a instanceof Object) {\n // Set the object up and assign its values directly\n const values = getParameters(a, b);\n Object.assign(this, values);\n } else if (typeof a === 'string') {\n if (isRgb.test(a)) {\n const noWhitespace = a.replace(whitespace, '');\n const [_a, _b, _c] = rgb.exec(noWhitespace).slice(1, 4).map(v => parseInt(v));\n Object.assign(this, {\n _a,\n _b,\n _c,\n _d: 0,\n space: 'rgb'\n });\n } else if (isHex.test(a)) {\n const hexParse = v => parseInt(v, 16);\n\n const [, _a, _b, _c] = hex.exec(sixDigitHex(a)).map(hexParse);\n Object.assign(this, {\n _a,\n _b,\n _c,\n _d: 0,\n space: 'rgb'\n });\n } else throw Error(`Unsupported string format, can't construct Color`);\n } // Now add the components as a convenience\n\n\n const {\n _a,\n _b,\n _c,\n _d\n } = this;\n const components = this.space === 'rgb' ? {\n r: _a,\n g: _b,\n b: _c\n } : this.space === 'xyz' ? {\n x: _a,\n y: _b,\n z: _c\n } : this.space === 'hsl' ? {\n h: _a,\n s: _b,\n l: _c\n } : this.space === 'lab' ? {\n l: _a,\n a: _b,\n b: _c\n } : this.space === 'lch' ? {\n l: _a,\n c: _b,\n h: _c\n } : this.space === 'cmyk' ? {\n c: _a,\n m: _b,\n y: _c,\n k: _d\n } : {};\n Object.assign(this, components);\n }\n /*\r\n Conversion Methods\r\n */\n\n\n rgb() {\n if (this.space === 'rgb') {\n return this;\n } else if (cieSpace(this.space)) {\n // Convert to the xyz color space\n let {\n x,\n y,\n z\n } = this;\n\n if (this.space === 'lab' || this.space === 'lch') {\n // Get the values in the lab space\n let {\n l,\n a,\n b\n } = this;\n\n if (this.space === 'lch') {\n let {\n c,\n h\n } = this;\n const dToR = Math.PI / 180;\n a = c * Math.cos(dToR * h);\n b = c * Math.sin(dToR * h);\n } // Undo the nonlinear function\n\n\n const yL = (l + 16) / 116;\n const xL = a / 500 + yL;\n const zL = yL - b / 200; // Get the xyz values\n\n const ct = 16 / 116;\n const mx = 0.008856;\n const nm = 7.787;\n x = 0.95047 * (Math.pow(xL, 3) > mx ? Math.pow(xL, 3) : (xL - ct) / nm);\n y = 1.00000 * (Math.pow(yL, 3) > mx ? Math.pow(yL, 3) : (yL - ct) / nm);\n z = 1.08883 * (Math.pow(zL, 3) > mx ? Math.pow(zL, 3) : (zL - ct) / nm);\n } // Convert xyz to unbounded rgb values\n\n\n const rU = x * 3.2406 + y * -1.5372 + z * -0.4986;\n const gU = x * -0.9689 + y * 1.8758 + z * 0.0415;\n const bU = x * 0.0557 + y * -0.2040 + z * 1.0570; // Convert the values to true rgb values\n\n let pow = Math.pow;\n let bd = 0.0031308;\n const r = rU > bd ? 1.055 * pow(rU, 1 / 2.4) - 0.055 : 12.92 * rU;\n const g = gU > bd ? 1.055 * pow(gU, 1 / 2.4) - 0.055 : 12.92 * gU;\n const b = bU > bd ? 1.055 * pow(bU, 1 / 2.4) - 0.055 : 12.92 * bU; // Make and return the color\n\n const color = new Color(255 * r, 255 * g, 255 * b);\n return color;\n } else if (this.space === 'hsl') {\n // https://bgrins.github.io/TinyColor/docs/tinycolor.html\n // Get the current hsl values\n let {\n h,\n s,\n l\n } = this;\n h /= 360;\n s /= 100;\n l /= 100; // If we are grey, then just make the color directly\n\n if (s === 0) {\n l *= 255;\n let color = new Color(l, l, l);\n return color;\n } // TODO I have no idea what this does :D If you figure it out, tell me!\n\n\n const q = l < 0.5 ? l * (1 + s) : l + s - l * s;\n const p = 2 * l - q; // Get the rgb values\n\n const r = 255 * hueToRgb(p, q, h + 1 / 3);\n const g = 255 * hueToRgb(p, q, h);\n const b = 255 * hueToRgb(p, q, h - 1 / 3); // Make a new color\n\n const color = new Color(r, g, b);\n return color;\n } else if (this.space === 'cmyk') {\n // https://gist.github.com/felipesabino/5066336\n // Get the normalised cmyk values\n const {\n c,\n m,\n y,\n k\n } = this; // Get the rgb values\n\n const r = 255 * (1 - Math.min(1, c * (1 - k) + k));\n const g = 255 * (1 - Math.min(1, m * (1 - k) + k));\n const b = 255 * (1 - Math.min(1, y * (1 - k) + k)); // Form the color and return it\n\n const color = new Color(r, g, b);\n return color;\n } else {\n return this;\n }\n }\n\n lab() {\n // Get the xyz color\n const {\n x,\n y,\n z\n } = this.xyz(); // Get the lab components\n\n const l = 116 * y - 16;\n const a = 500 * (x - y);\n const b = 200 * (y - z); // Construct and return a new color\n\n const color = new Color(l, a, b, 'lab');\n return color;\n }\n\n xyz() {\n // Normalise the red, green and blue values\n const {\n _a: r255,\n _b: g255,\n _c: b255\n } = this.rgb();\n const [r, g, b] = [r255, g255, b255].map(v => v / 255); // Convert to the lab rgb space\n\n const rL = r > 0.04045 ? Math.pow((r + 0.055) / 1.055, 2.4) : r / 12.92;\n const gL = g > 0.04045 ? Math.pow((g + 0.055) / 1.055, 2.4) : g / 12.92;\n const bL = b > 0.04045 ? Math.pow((b + 0.055) / 1.055, 2.4) : b / 12.92; // Convert to the xyz color space without bounding the values\n\n const xU = (rL * 0.4124 + gL * 0.3576 + bL * 0.1805) / 0.95047;\n const yU = (rL * 0.2126 + gL * 0.7152 + bL * 0.0722) / 1.00000;\n const zU = (rL * 0.0193 + gL * 0.1192 + bL * 0.9505) / 1.08883; // Get the proper xyz values by applying the bounding\n\n const x = xU > 0.008856 ? Math.pow(xU, 1 / 3) : 7.787 * xU + 16 / 116;\n const y = yU > 0.008856 ? Math.pow(yU, 1 / 3) : 7.787 * yU + 16 / 116;\n const z = zU > 0.008856 ? Math.pow(zU, 1 / 3) : 7.787 * zU + 16 / 116; // Make and return the color\n\n const color = new Color(x, y, z, 'xyz');\n return color;\n }\n\n lch() {\n // Get the lab color directly\n const {\n l,\n a,\n b\n } = this.lab(); // Get the chromaticity and the hue using polar coordinates\n\n const c = Math.sqrt(Math.pow(a, 2) + Math.pow(b, 2));\n let h = 180 * Math.atan2(b, a) / Math.PI;\n\n if (h < 0) {\n h *= -1;\n h = 360 - h;\n } // Make a new color and return it\n\n\n const color = new Color(l, c, h, 'lch');\n return color;\n }\n\n hsl() {\n // Get the rgb values\n const {\n _a,\n _b,\n _c\n } = this.rgb();\n const [r, g, b] = [_a, _b, _c].map(v => v / 255); // Find the maximum and minimum values to get the lightness\n\n const max = Math.max(r, g, b);\n const min = Math.min(r, g, b);\n const l = (max + min) / 2; // If the r, g, v values are identical then we are grey\n\n const isGrey = max === min; // Calculate the hue and saturation\n\n const delta = max - min;\n const s = isGrey ? 0 : l > 0.5 ? delta / (2 - max - min) : delta / (max + min);\n const h = isGrey ? 0 : max === r ? ((g - b) / delta + (g < b ? 6 : 0)) / 6 : max === g ? ((b - r) / delta + 2) / 6 : max === b ? ((r - g) / delta + 4) / 6 : 0; // Construct and return the new color\n\n const color = new Color(360 * h, 100 * s, 100 * l, 'hsl');\n return color;\n }\n\n cmyk() {\n // Get the rgb values for the current color\n const {\n _a,\n _b,\n _c\n } = this.rgb();\n const [r, g, b] = [_a, _b, _c].map(v => v / 255); // Get the cmyk values in an unbounded format\n\n const k = Math.min(1 - r, 1 - g, 1 - b);\n\n if (k === 1) {\n // Catch the black case\n return new Color(0, 0, 0, 1, 'cmyk');\n }\n\n const c = (1 - r - k) / (1 - k);\n const m = (1 - g - k) / (1 - k);\n const y = (1 - b - k) / (1 - k); // Construct the new color\n\n const color = new Color(c, m, y, k, 'cmyk');\n return color;\n }\n /*\r\n Input and Output methods\r\n */\n\n\n _clamped() {\n let {\n _a,\n _b,\n _c\n } = this.rgb();\n let {\n max,\n min,\n round\n } = Math;\n\n let format = v => max(0, min(round(v), 255));\n\n return [_a, _b, _c].map(format);\n }\n\n toHex() {\n let [r, g, b] = this._clamped().map(componentHex);\n\n return `#${r}${g}${b}`;\n }\n\n toString() {\n return this.toHex();\n }\n\n toRgb() {\n let [rV, gV, bV] = this._clamped();\n\n let string = `rgb(${rV},${gV},${bV})`;\n return string;\n }\n\n toArray() {\n let {\n _a,\n _b,\n _c,\n _d,\n space\n } = this;\n return [_a, _b, _c, _d, space];\n }\n /*\r\n Generating random colors\r\n */\n\n\n static random(mode = 'vibrant', t, u) {\n // Get the math modules\n const {\n random,\n round,\n sin,\n PI: pi\n } = Math; // Run the correct generator\n\n if (mode === 'vibrant') {\n const l = (81 - 57) * random() + 57;\n const c = (83 - 45) * random() + 45;\n const h = 360 * random();\n const color = new Color(l, c, h, 'lch');\n return color;\n } else if (mode === 'sine') {\n t = t == null ? random() : t;\n const r = round(80 * sin(2 * pi * t / 0.5 + 0.01) + 150);\n const g = round(50 * sin(2 * pi * t / 0.5 + 4.6) + 200);\n const b = round(100 * sin(2 * pi * t / 0.5 + 2.3) + 150);\n const color = new Color(r, g, b);\n return color;\n } else if (mode === 'pastel') {\n const l = (94 - 86) * random() + 86;\n const c = (26 - 9) * random() + 9;\n const h = 360 * random();\n const color = new Color(l, c, h, 'lch');\n return color;\n } else if (mode === 'dark') {\n const l = 10 + 10 * random();\n const c = (125 - 75) * random() + 86;\n const h = 360 * random();\n const color = new Color(l, c, h, 'lch');\n return color;\n } else if (mode === 'rgb') {\n const r = 255 * random();\n const g = 255 * random();\n const b = 255 * random();\n const color = new Color(r, g, b);\n return color;\n } else if (mode === 'lab') {\n const l = 100 * random();\n const a = 256 * random() - 128;\n const b = 256 * random() - 128;\n const color = new Color(l, a, b, 'lab');\n return color;\n } else if (mode === 'grey') {\n const grey = 255 * random();\n const color = new Color(grey, grey, grey);\n return color;\n }\n }\n /*\r\n Constructing colors\r\n */\n // Test if given value is a color string\n\n\n static test(color) {\n color += '';\n return isHex.test(color) || isRgb.test(color);\n } // Test if given value is a rgb object\n\n\n static isRgb(color) {\n return color && typeof color.r === 'number' && typeof color.g === 'number' && typeof color.b === 'number';\n } // Test if given value is a color\n\n\n static isColor(color) {\n return this.isRgb(color) || this.test(color);\n }\n\n}\n\nclass Point {\n // Initialize\n constructor(...args) {\n this.init(...args);\n }\n\n init(x, y) {\n let source;\n let base = {\n x: 0,\n y: 0 // ensure source as object\n\n };\n source = Array.isArray(x) ? {\n x: x[0],\n y: x[1]\n } : typeof x === 'object' ? {\n x: x.x,\n y: x.y\n } : {\n x: x,\n y: y // merge source\n\n };\n this.x = source.x == null ? base.x : source.x;\n this.y = source.y == null ? base.y : source.y;\n return this;\n } // Clone point\n\n\n clone() {\n return new Point(this);\n } // transform point with matrix\n\n\n transform(m) {\n // Perform the matrix multiplication\n var x = m.a * this.x + m.c * this.y + m.e;\n var y = m.b * this.x + m.d * this.y + m.f; // Return the required point\n\n return new Point(x, y);\n }\n\n toArray() {\n return [this.x, this.y];\n }\n\n}\nfunction point(x, y) {\n return new Point(x, y).transform(this.screenCTM().inverse());\n}\n\nfunction closeEnough(a, b, threshold) {\n return Math.abs(b - a) < (threshold || 1e-6);\n}\n\nclass Matrix {\n constructor(...args) {\n this.init(...args);\n } // Initialize\n\n\n init(source) {\n var base = Matrix.fromArray([1, 0, 0, 1, 0, 0]); // ensure source as object\n\n source = source instanceof Element ? source.matrixify() : typeof source === 'string' ? Matrix.fromArray(source.split(delimiter).map(parseFloat)) : Array.isArray(source) ? Matrix.fromArray(source) : typeof source === 'object' && Matrix.isMatrixLike(source) ? source : typeof source === 'object' ? new Matrix().transform(source) : arguments.length === 6 ? Matrix.fromArray([].slice.call(arguments)) : base; // Merge the source matrix with the base matrix\n\n this.a = source.a != null ? source.a : base.a;\n this.b = source.b != null ? source.b : base.b;\n this.c = source.c != null ? source.c : base.c;\n this.d = source.d != null ? source.d : base.d;\n this.e = source.e != null ? source.e : base.e;\n this.f = source.f != null ? source.f : base.f;\n return this;\n } // Clones this matrix\n\n\n clone() {\n return new Matrix(this);\n } // Transform a matrix into another matrix by manipulating the space\n\n\n transform(o) {\n // Check if o is a matrix and then left multiply it directly\n if (Matrix.isMatrixLike(o)) {\n var matrix = new Matrix(o);\n return matrix.multiplyO(this);\n } // Get the proposed transformations and the current transformations\n\n\n var t = Matrix.formatTransforms(o);\n var current = this;\n let {\n x: ox,\n y: oy\n } = new Point(t.ox, t.oy).transform(current); // Construct the resulting matrix\n\n var transformer = new Matrix().translateO(t.rx, t.ry).lmultiplyO(current).translateO(-ox, -oy).scaleO(t.scaleX, t.scaleY).skewO(t.skewX, t.skewY).shearO(t.shear).rotateO(t.theta).translateO(ox, oy); // If we want the origin at a particular place, we force it there\n\n if (isFinite(t.px) || isFinite(t.py)) {\n const origin = new Point(ox, oy).transform(transformer); // TODO: Replace t.px with isFinite(t.px)\n\n const dx = t.px ? t.px - origin.x : 0;\n const dy = t.py ? t.py - origin.y : 0;\n transformer.translateO(dx, dy);\n } // Translate now after positioning\n\n\n transformer.translateO(t.tx, t.ty);\n return transformer;\n } // Applies a matrix defined by its affine parameters\n\n\n compose(o) {\n if (o.origin) {\n o.originX = o.origin[0];\n o.originY = o.origin[1];\n } // Get the parameters\n\n\n var ox = o.originX || 0;\n var oy = o.originY || 0;\n var sx = o.scaleX || 1;\n var sy = o.scaleY || 1;\n var lam = o.shear || 0;\n var theta = o.rotate || 0;\n var tx = o.translateX || 0;\n var ty = o.translateY || 0; // Apply the standard matrix\n\n var result = new Matrix().translateO(-ox, -oy).scaleO(sx, sy).shearO(lam).rotateO(theta).translateO(tx, ty).lmultiplyO(this).translateO(ox, oy);\n return result;\n } // Decomposes this matrix into its affine parameters\n\n\n decompose(cx = 0, cy = 0) {\n // Get the parameters from the matrix\n var a = this.a;\n var b = this.b;\n var c = this.c;\n var d = this.d;\n var e = this.e;\n var f = this.f; // Figure out if the winding direction is clockwise or counterclockwise\n\n var determinant = a * d - b * c;\n var ccw = determinant > 0 ? 1 : -1; // Since we only shear in x, we can use the x basis to get the x scale\n // and the rotation of the resulting matrix\n\n var sx = ccw * Math.sqrt(a * a + b * b);\n var thetaRad = Math.atan2(ccw * b, ccw * a);\n var theta = 180 / Math.PI * thetaRad;\n var ct = Math.cos(thetaRad);\n var st = Math.sin(thetaRad); // We can then solve the y basis vector simultaneously to get the other\n // two affine parameters directly from these parameters\n\n var lam = (a * c + b * d) / determinant;\n var sy = c * sx / (lam * a - b) || d * sx / (lam * b + a); // Use the translations\n\n let tx = e - cx + cx * ct * sx + cy * (lam * ct * sx - st * sy);\n let ty = f - cy + cx * st * sx + cy * (lam * st * sx + ct * sy); // Construct the decomposition and return it\n\n return {\n // Return the affine parameters\n scaleX: sx,\n scaleY: sy,\n shear: lam,\n rotate: theta,\n translateX: tx,\n translateY: ty,\n originX: cx,\n originY: cy,\n // Return the matrix parameters\n a: this.a,\n b: this.b,\n c: this.c,\n d: this.d,\n e: this.e,\n f: this.f\n };\n } // Left multiplies by the given matrix\n\n\n multiply(matrix) {\n return this.clone().multiplyO(matrix);\n }\n\n multiplyO(matrix) {\n // Get the matrices\n var l = this;\n var r = matrix instanceof Matrix ? matrix : new Matrix(matrix);\n return Matrix.matrixMultiply(l, r, this);\n }\n\n lmultiply(matrix) {\n return this.clone().lmultiplyO(matrix);\n }\n\n lmultiplyO(matrix) {\n var r = this;\n var l = matrix instanceof Matrix ? matrix : new Matrix(matrix);\n return Matrix.matrixMultiply(l, r, this);\n } // Inverses matrix\n\n\n inverseO() {\n // Get the current parameters out of the matrix\n var a = this.a;\n var b = this.b;\n var c = this.c;\n var d = this.d;\n var e = this.e;\n var f = this.f; // Invert the 2x2 matrix in the top left\n\n var det = a * d - b * c;\n if (!det) throw new Error('Cannot invert ' + this); // Calculate the top 2x2 matrix\n\n var na = d / det;\n var nb = -b / det;\n var nc = -c / det;\n var nd = a / det; // Apply the inverted matrix to the top right\n\n var ne = -(na * e + nc * f);\n var nf = -(nb * e + nd * f); // Construct the inverted matrix\n\n this.a = na;\n this.b = nb;\n this.c = nc;\n this.d = nd;\n this.e = ne;\n this.f = nf;\n return this;\n }\n\n inverse() {\n return this.clone().inverseO();\n } // Translate matrix\n\n\n translate(x, y) {\n return this.clone().translateO(x, y);\n }\n\n translateO(x, y) {\n this.e += x || 0;\n this.f += y || 0;\n return this;\n } // Scale matrix\n\n\n scale(x, y, cx, cy) {\n return this.clone().scaleO(...arguments);\n }\n\n scaleO(x, y = x, cx = 0, cy = 0) {\n // Support uniform scaling\n if (arguments.length === 3) {\n cy = cx;\n cx = y;\n y = x;\n }\n\n let {\n a,\n b,\n c,\n d,\n e,\n f\n } = this;\n this.a = a * x;\n this.b = b * y;\n this.c = c * x;\n this.d = d * y;\n this.e = e * x - cx * x + cx;\n this.f = f * y - cy * y + cy;\n return this;\n } // Rotate matrix\n\n\n rotate(r, cx, cy) {\n return this.clone().rotateO(r, cx, cy);\n }\n\n rotateO(r, cx = 0, cy = 0) {\n // Convert degrees to radians\n r = radians(r);\n let cos = Math.cos(r);\n let sin = Math.sin(r);\n let {\n a,\n b,\n c,\n d,\n e,\n f\n } = this;\n this.a = a * cos - b * sin;\n this.b = b * cos + a * sin;\n this.c = c * cos - d * sin;\n this.d = d * cos + c * sin;\n this.e = e * cos - f * sin + cy * sin - cx * cos + cx;\n this.f = f * cos + e * sin - cx * sin - cy * cos + cy;\n return this;\n } // Flip matrix on x or y, at a given offset\n\n\n flip(axis, around) {\n return this.clone().flipO(axis, around);\n }\n\n flipO(axis, around) {\n return axis === 'x' ? this.scaleO(-1, 1, around, 0) : axis === 'y' ? this.scaleO(1, -1, 0, around) : this.scaleO(-1, -1, axis, around || axis); // Define an x, y flip point\n } // Shear matrix\n\n\n shear(a, cx, cy) {\n return this.clone().shearO(a, cx, cy);\n }\n\n shearO(lx, cx = 0, cy = 0) {\n let {\n a,\n b,\n c,\n d,\n e,\n f\n } = this;\n this.a = a + b * lx;\n this.c = c + d * lx;\n this.e = e + f * lx - cy * lx;\n return this;\n } // Skew Matrix\n\n\n skew(x, y, cx, cy) {\n return this.clone().skewO(...arguments);\n }\n\n skewO(x, y = x, cx = 0, cy = 0) {\n // support uniformal skew\n if (arguments.length === 3) {\n cy = cx;\n cx = y;\n y = x;\n } // Convert degrees to radians\n\n\n x = radians(x);\n y = radians(y);\n let lx = Math.tan(x);\n let ly = Math.tan(y);\n let {\n a,\n b,\n c,\n d,\n e,\n f\n } = this;\n this.a = a + b * lx;\n this.b = b + a * ly;\n this.c = c + d * lx;\n this.d = d + c * ly;\n this.e = e + f * lx - cy * lx;\n this.f = f + e * ly - cx * ly;\n return this;\n } // SkewX\n\n\n skewX(x, cx, cy) {\n return this.skew(x, 0, cx, cy);\n }\n\n skewXO(x, cx, cy) {\n return this.skewO(x, 0, cx, cy);\n } // SkewY\n\n\n skewY(y, cx, cy) {\n return this.skew(0, y, cx, cy);\n }\n\n skewYO(y, cx, cy) {\n return this.skewO(0, y, cx, cy);\n } // Transform around a center point\n\n\n aroundO(cx, cy, matrix) {\n var dx = cx || 0;\n var dy = cy || 0;\n return this.translateO(-dx, -dy).lmultiplyO(matrix).translateO(dx, dy);\n }\n\n around(cx, cy, matrix) {\n return this.clone().aroundO(cx, cy, matrix);\n } // Check if two matrices are equal\n\n\n equals(other) {\n var comp = new Matrix(other);\n return closeEnough(this.a, comp.a) && closeEnough(this.b, comp.b) && closeEnough(this.c, comp.c) && closeEnough(this.d, comp.d) && closeEnough(this.e, comp.e) && closeEnough(this.f, comp.f);\n } // Convert matrix to string\n\n\n toString() {\n return 'matrix(' + this.a + ',' + this.b + ',' + this.c + ',' + this.d + ',' + this.e + ',' + this.f + ')';\n }\n\n toArray() {\n return [this.a, this.b, this.c, this.d, this.e, this.f];\n }\n\n valueOf() {\n return {\n a: this.a,\n b: this.b,\n c: this.c,\n d: this.d,\n e: this.e,\n f: this.f\n };\n }\n\n static fromArray(a) {\n return {\n a: a[0],\n b: a[1],\n c: a[2],\n d: a[3],\n e: a[4],\n f: a[5]\n };\n }\n\n static isMatrixLike(o) {\n return o.a != null || o.b != null || o.c != null || o.d != null || o.e != null || o.f != null;\n }\n\n static formatTransforms(o) {\n // Get all of the parameters required to form the matrix\n var flipBoth = o.flip === 'both' || o.flip === true;\n var flipX = o.flip && (flipBoth || o.flip === 'x') ? -1 : 1;\n var flipY = o.flip && (flipBoth || o.flip === 'y') ? -1 : 1;\n var skewX = o.skew && o.skew.length ? o.skew[0] : isFinite(o.skew) ? o.skew : isFinite(o.skewX) ? o.skewX : 0;\n var skewY = o.skew && o.skew.length ? o.skew[1] : isFinite(o.skew) ? o.skew : isFinite(o.skewY) ? o.skewY : 0;\n var scaleX = o.scale && o.scale.length ? o.scale[0] * flipX : isFinite(o.scale) ? o.scale * flipX : isFinite(o.scaleX) ? o.scaleX * flipX : flipX;\n var scaleY = o.scale && o.scale.length ? o.scale[1] * flipY : isFinite(o.scale) ? o.scale * flipY : isFinite(o.scaleY) ? o.scaleY * flipY : flipY;\n var shear = o.shear || 0;\n var theta = o.rotate || o.theta || 0;\n var origin = new Point(o.origin || o.around || o.ox || o.originX, o.oy || o.originY);\n var ox = origin.x;\n var oy = origin.y;\n var position = new Point(o.position || o.px || o.positionX, o.py || o.positionY);\n var px = position.x;\n var py = position.y;\n var translate = new Point(o.translate || o.tx || o.translateX, o.ty || o.translateY);\n var tx = translate.x;\n var ty = translate.y;\n var relative = new Point(o.relative || o.rx || o.relativeX, o.ry || o.relativeY);\n var rx = relative.x;\n var ry = relative.y; // Populate all of the values\n\n return {\n scaleX,\n scaleY,\n skewX,\n skewY,\n shear,\n theta,\n rx,\n ry,\n tx,\n ty,\n ox,\n oy,\n px,\n py\n };\n } // left matrix, right matrix, target matrix which is overwritten\n\n\n static matrixMultiply(l, r, o) {\n // Work out the product directly\n var a = l.a * r.a + l.c * r.b;\n var b = l.b * r.a + l.d * r.b;\n var c = l.a * r.c + l.c * r.d;\n var d = l.b * r.c + l.d * r.d;\n var e = l.e + l.a * r.e + l.c * r.f;\n var f = l.f + l.b * r.e + l.d * r.f; // make sure to use local variables because l/r and o could be the same\n\n o.a = a;\n o.b = b;\n o.c = c;\n o.d = d;\n o.e = e;\n o.f = f;\n return o;\n }\n\n}\nfunction ctm() {\n return new Matrix(this.node.getCTM());\n}\nfunction screenCTM() {\n /* https://bugzilla.mozilla.org/show_bug.cgi?id=1344537\r\n This is needed because FF does not return the transformation matrix\r\n for the inner coordinate system when getScreenCTM() is called on nested svgs.\r\n However all other Browsers do that */\n if (typeof this.isRoot === 'function' && !this.isRoot()) {\n var rect = this.rect(1, 1);\n var m = rect.node.getScreenCTM();\n rect.remove();\n return new Matrix(m);\n }\n\n return new Matrix(this.node.getScreenCTM());\n}\nregister(Matrix);\n\nfunction parser() {\n // Reuse cached element if possible\n if (!parser.nodes) {\n let svg = makeInstance().size(2, 0);\n svg.node.style.cssText = ['opacity: 0', 'position: absolute', 'left: -100%', 'top: -100%', 'overflow: hidden'].join(';');\n svg.attr('focusable', 'false');\n let path = svg.path().node;\n parser.nodes = {\n svg,\n path\n };\n }\n\n if (!parser.nodes.svg.node.parentNode) {\n let b = globals.document.body || globals.document.documentElement;\n parser.nodes.svg.addTo(b);\n }\n\n return parser.nodes;\n}\n\nfunction isNulledBox(box) {\n return !box.w && !box.h && !box.x && !box.y;\n}\n\nfunction domContains(node) {\n return (globals.document.documentElement.contains || function (node) {\n // This is IE - it does not support contains() for top-level SVGs\n while (node.parentNode) {\n node = node.parentNode;\n }\n\n return node === document;\n }).call(globals.document.documentElement, node);\n}\n\nclass Box {\n constructor(...args) {\n this.init(...args);\n }\n\n init(source) {\n var base = [0, 0, 0, 0];\n source = typeof source === 'string' ? source.split(delimiter).map(parseFloat) : Array.isArray(source) ? source : typeof source === 'object' ? [source.left != null ? source.left : source.x, source.top != null ? source.top : source.y, source.width, source.height] : arguments.length === 4 ? [].slice.call(arguments) : base;\n this.x = source[0] || 0;\n this.y = source[1] || 0;\n this.width = this.w = source[2] || 0;\n this.height = this.h = source[3] || 0; // Add more bounding box properties\n\n this.x2 = this.x + this.w;\n this.y2 = this.y + this.h;\n this.cx = this.x + this.w / 2;\n this.cy = this.y + this.h / 2;\n return this;\n } // Merge rect box with another, return a new instance\n\n\n merge(box) {\n let x = Math.min(this.x, box.x);\n let y = Math.min(this.y, box.y);\n let width = Math.max(this.x + this.width, box.x + box.width) - x;\n let height = Math.max(this.y + this.height, box.y + box.height) - y;\n return new Box(x, y, width, height);\n }\n\n transform(m) {\n let xMin = Infinity;\n let xMax = -Infinity;\n let yMin = Infinity;\n let yMax = -Infinity;\n let pts = [new Point(this.x, this.y), new Point(this.x2, this.y), new Point(this.x, this.y2), new Point(this.x2, this.y2)];\n pts.forEach(function (p) {\n p = p.transform(m);\n xMin = Math.min(xMin, p.x);\n xMax = Math.max(xMax, p.x);\n yMin = Math.min(yMin, p.y);\n yMax = Math.max(yMax, p.y);\n });\n return new Box(xMin, yMin, xMax - xMin, yMax - yMin);\n }\n\n addOffset() {\n // offset by window scroll position, because getBoundingClientRect changes when window is scrolled\n this.x += globals.window.pageXOffset;\n this.y += globals.window.pageYOffset;\n return this;\n }\n\n toString() {\n return this.x + ' ' + this.y + ' ' + this.width + ' ' + this.height;\n }\n\n toArray() {\n return [this.x, this.y, this.width, this.height];\n }\n\n isNulled() {\n return isNulledBox(this);\n }\n\n}\n\nfunction getBox(cb, retry) {\n let box;\n\n try {\n box = cb(this.node);\n\n if (isNulledBox(box) && !domContains(this.node)) {\n throw new Error('Element not in the dom');\n }\n } catch (e) {\n box = retry(this);\n }\n\n return box;\n}\n\nfunction bbox() {\n return new Box(getBox.call(this, node => node.getBBox(), el => {\n try {\n let clone = el.clone().addTo(parser().svg).show();\n let box = clone.node.getBBox();\n clone.remove();\n return box;\n } catch (e) {\n throw new Error('Getting bbox of element \"' + el.node.nodeName + '\" is not possible');\n }\n }));\n}\nfunction rbox(el) {\n let box = new Box(getBox.call(this, node => node.getBoundingClientRect(), el => {\n throw new Error('Getting rbox of element \"' + el.node.nodeName + '\" is not possible');\n }));\n if (el) return box.transform(el.screenCTM().inverse());\n return box.addOffset();\n}\nregisterMethods({\n viewbox: {\n viewbox(x, y, width, height) {\n // act as getter\n if (x == null) return new Box(this.attr('viewBox')); // act as setter\n\n return this.attr('viewBox', new Box(x, y, width, height));\n },\n\n zoom(level, point$$1) {\n var style = window.getComputedStyle(this.node);\n var width = parseFloat(style.getPropertyValue('width'));\n var height = parseFloat(style.getPropertyValue('height'));\n var v = this.viewbox();\n var zoomX = width / v.width;\n var zoomY = height / v.height;\n var zoom = Math.min(zoomX, zoomY);\n\n if (level == null) {\n return zoom;\n }\n\n var zoomAmount = zoom / level;\n if (zoomAmount === Infinity) zoomAmount = Number.MIN_VALUE;\n point$$1 = point$$1 || new Point(width / 2 / zoomX + v.x, height / 2 / zoomY + v.y);\n var box = new Box(v).transform(new Matrix({\n scale: zoomAmount,\n origin: point$$1\n }));\n return this.viewbox(box);\n }\n\n }\n});\nregister(Box);\n\n/* eslint no-new-func: \"off\" */\nconst subClassArray = function () {\n try {\n // try es6 subclassing\n return Function('name', 'baseClass', '_constructor', ['baseClass = baseClass || Array', 'return {', ' [name]: class extends baseClass {', ' constructor (...args) {', ' super(...args)', ' _constructor && _constructor.apply(this, args)', ' }', ' }', '}[name]'].join('\\n'));\n } catch (e) {\n // Use es5 approach\n return (name, baseClass = Array, _constructor) => {\n const Arr = function () {\n baseClass.apply(this, arguments);\n _constructor && _constructor.apply(this, arguments);\n };\n\n Arr.prototype = Object.create(baseClass.prototype);\n Arr.prototype.constructor = Arr;\n\n Arr.prototype.map = function (fn) {\n const arr = new Arr();\n arr.push.apply(arr, Array.prototype.map.call(this, fn));\n return arr;\n };\n\n return Arr;\n };\n }\n}();\n\nconst List = subClassArray('List', Array, function (arr = []) {\n // This catches the case, that native map tries to create an array with new Array(1)\n if (typeof arr === 'number') return this;\n this.length = 0;\n this.push(...arr);\n});\nextend(List, {\n each(fnOrMethodName, ...args) {\n if (typeof fnOrMethodName === 'function') {\n return this.map(el => {\n return fnOrMethodName.call(el, el);\n });\n } else {\n return this.map(el => {\n return el[fnOrMethodName](...args);\n });\n }\n },\n\n toArray() {\n return Array.prototype.concat.apply([], this);\n }\n\n});\nconst reserved = ['toArray', 'constructor', 'each'];\n\nList.extend = function (methods) {\n methods = methods.reduce((obj, name) => {\n // Don't overwrite own methods\n if (reserved.includes(name)) return obj; // Don't add private methods\n\n if (name[0] === '_') return obj; // Relay every call to each()\n\n obj[name] = function (...attrs) {\n return this.each(name, ...attrs);\n };\n\n return obj;\n }, {});\n extend(List, methods);\n};\n\nfunction baseFind(query, parent) {\n return new List(map((parent || globals.document).querySelectorAll(query), function (node) {\n return adopt(node);\n }));\n} // Scoped find method\n\nfunction find(query) {\n return baseFind(query, this.node);\n}\n\nclass EventTarget extends Base {\n constructor({\n events = {}\n } = {}) {\n super();\n this.events = events;\n }\n\n addEventListener() {}\n\n dispatch(event, data) {\n return dispatch(this, event, data);\n }\n\n dispatchEvent(event) {\n const bag = this.getEventHolder().events;\n if (!bag) return true;\n const events = bag[event.type];\n\n for (let i in events) {\n for (let j in events[i]) {\n events[i][j](event);\n }\n }\n\n return !event.defaultPrevented;\n } // Fire given event\n\n\n fire(event, data) {\n this.dispatch(event, data);\n return this;\n }\n\n getEventHolder() {\n return this;\n }\n\n getEventTarget() {\n return this;\n } // Unbind event from listener\n\n\n off(event, listener) {\n off(this, event, listener);\n return this;\n } // Bind given event to listener\n\n\n on(event, listener, binding, options) {\n on(this, event, listener, binding, options);\n return this;\n }\n\n removeEventListener() {}\n\n}\nregister(EventTarget);\n\nfunction noop() {} // Default animation values\n\nlet timeline = {\n duration: 400,\n ease: '>',\n delay: 0 // Default attribute values\n\n};\nlet attrs = {\n // fill and stroke\n 'fill-opacity': 1,\n 'stroke-opacity': 1,\n 'stroke-width': 0,\n 'stroke-linejoin': 'miter',\n 'stroke-linecap': 'butt',\n fill: '#000000',\n stroke: '#000000',\n opacity: 1,\n // position\n x: 0,\n y: 0,\n cx: 0,\n cy: 0,\n // size\n width: 0,\n height: 0,\n // radius\n r: 0,\n rx: 0,\n ry: 0,\n // gradient\n offset: 0,\n 'stop-opacity': 1,\n 'stop-color': '#000000',\n // text\n 'font-size': 16,\n 'font-family': 'Helvetica, Arial, sans-serif',\n 'text-anchor': 'start'\n};\n\nvar defaults = ({\n noop: noop,\n timeline: timeline,\n attrs: attrs\n});\n\nconst SVGArray = subClassArray('SVGArray', Array, function (arr) {\n this.init(arr);\n});\nextend(SVGArray, {\n init(arr) {\n // This catches the case, that native map tries to create an array with new Array(1)\n if (typeof arr === 'number') return this;\n this.length = 0;\n this.push(...this.parse(arr));\n return this;\n },\n\n toArray() {\n return Array.prototype.concat.apply([], this);\n },\n\n toString() {\n return this.join(' ');\n },\n\n // Flattens the array if needed\n valueOf() {\n const ret = [];\n ret.push(...this);\n return ret;\n },\n\n // Parse whitespace separated string\n parse(array = []) {\n // If already is an array, no need to parse it\n if (array instanceof Array) return array;\n return array.trim().split(delimiter).map(parseFloat);\n },\n\n clone() {\n return new this.constructor(this);\n },\n\n toSet() {\n return new Set(this);\n }\n\n});\n\nclass SVGNumber {\n // Initialize\n constructor(...args) {\n this.init(...args);\n }\n\n init(value, unit) {\n unit = Array.isArray(value) ? value[1] : unit;\n value = Array.isArray(value) ? value[0] : value; // initialize defaults\n\n this.value = 0;\n this.unit = unit || ''; // parse value\n\n if (typeof value === 'number') {\n // ensure a valid numeric value\n this.value = isNaN(value) ? 0 : !isFinite(value) ? value < 0 ? -3.4e+38 : +3.4e+38 : value;\n } else if (typeof value === 'string') {\n unit = value.match(numberAndUnit);\n\n if (unit) {\n // make value numeric\n this.value = parseFloat(unit[1]); // normalize\n\n if (unit[5] === '%') {\n this.value /= 100;\n } else if (unit[5] === 's') {\n this.value *= 1000;\n } // store unit\n\n\n this.unit = unit[5];\n }\n } else {\n if (value instanceof SVGNumber) {\n this.value = value.valueOf();\n this.unit = value.unit;\n }\n }\n\n return this;\n }\n\n toString() {\n return (this.unit === '%' ? ~~(this.value * 1e8) / 1e6 : this.unit === 's' ? this.value / 1e3 : this.value) + this.unit;\n }\n\n toJSON() {\n return this.toString();\n }\n\n toArray() {\n return [this.value, this.unit];\n }\n\n valueOf() {\n return this.value;\n } // Add number\n\n\n plus(number) {\n number = new SVGNumber(number);\n return new SVGNumber(this + number, this.unit || number.unit);\n } // Subtract number\n\n\n minus(number) {\n number = new SVGNumber(number);\n return new SVGNumber(this - number, this.unit || number.unit);\n } // Multiply number\n\n\n times(number) {\n number = new SVGNumber(number);\n return new SVGNumber(this * number, this.unit || number.unit);\n } // Divide number\n\n\n divide(number) {\n number = new SVGNumber(number);\n return new SVGNumber(this / number, this.unit || number.unit);\n }\n\n}\n\nconst hooks = [];\nfunction registerAttrHook(fn) {\n hooks.push(fn);\n} // Set svg element attribute\n\nfunction attr(attr, val, ns) {\n // act as full getter\n if (attr == null) {\n // get an object of attributes\n attr = {};\n val = this.node.attributes;\n\n for (let node of val) {\n attr[node.nodeName] = isNumber.test(node.nodeValue) ? parseFloat(node.nodeValue) : node.nodeValue;\n }\n\n return attr;\n } else if (attr instanceof Array) {\n // loop through array and get all values\n return attr.reduce((last, curr) => {\n last[curr] = this.attr(curr);\n return last;\n }, {});\n } else if (typeof attr === 'object' && attr.constructor === Object) {\n // apply every attribute individually if an object is passed\n for (val in attr) this.attr(val, attr[val]);\n } else if (val === null) {\n // remove value\n this.node.removeAttribute(attr);\n } else if (val == null) {\n // act as a getter if the first and only argument is not an object\n val = this.node.getAttribute(attr);\n return val == null ? attrs[attr] : isNumber.test(val) ? parseFloat(val) : val;\n } else {\n // Loop through hooks and execute them to convert value\n val = hooks.reduce((_val, hook) => {\n return hook(attr, _val, this);\n }, val); // ensure correct numeric values (also accepts NaN and Infinity)\n\n if (typeof val === 'number') {\n val = new SVGNumber(val);\n } else if (Color.isColor(val)) {\n // ensure full hex color\n val = new Color(val);\n } else if (val.constructor === Array) {\n // Check for plain arrays and parse array values\n val = new SVGArray(val);\n } // if the passed attribute is leading...\n\n\n if (attr === 'leading') {\n // ... call the leading method instead\n if (this.leading) {\n this.leading(val);\n }\n } else {\n // set given attribute on node\n typeof ns === 'string' ? this.node.setAttributeNS(ns, attr, val.toString()) : this.node.setAttribute(attr, val.toString());\n } // rebuild if required\n\n\n if (this.rebuild && (attr === 'font-size' || attr === 'x')) {\n this.rebuild();\n }\n }\n\n return this;\n}\n\nclass Dom extends EventTarget {\n constructor(node, attrs) {\n super(node);\n this.node = node;\n this.type = node.nodeName;\n\n if (attrs && node !== attrs) {\n this.attr(attrs);\n }\n } // Add given element at a position\n\n\n add(element, i) {\n element = makeInstance(element);\n\n if (i == null) {\n this.node.appendChild(element.node);\n } else if (element.node !== this.node.childNodes[i]) {\n this.node.insertBefore(element.node, this.node.childNodes[i]);\n }\n\n return this;\n } // Add element to given container and return self\n\n\n addTo(parent) {\n return makeInstance(parent).put(this);\n } // Returns all child elements\n\n\n children() {\n return new List(map(this.node.children, function (node) {\n return adopt(node);\n }));\n } // Remove all elements in this container\n\n\n clear() {\n // remove children\n while (this.node.hasChildNodes()) {\n this.node.removeChild(this.node.lastChild);\n }\n\n return this;\n } // Clone element\n\n\n clone() {\n // write dom data to the dom so the clone can pickup the data\n this.writeDataToDom(); // clone element and assign new id\n\n return assignNewId(this.node.cloneNode(true));\n } // Iterates over all children and invokes a given block\n\n\n each(block, deep) {\n var children = this.children();\n var i, il;\n\n for (i = 0, il = children.length; i < il; i++) {\n block.apply(children[i], [i, children]);\n\n if (deep) {\n children[i].each(block, deep);\n }\n }\n\n return this;\n }\n\n element(nodeName) {\n return this.put(new Dom(create(nodeName)));\n } // Get first child\n\n\n first() {\n return adopt(this.node.firstChild);\n } // Get a element at the given index\n\n\n get(i) {\n return adopt(this.node.childNodes[i]);\n }\n\n getEventHolder() {\n return this.node;\n }\n\n getEventTarget() {\n return this.node;\n } // Checks if the given element is a child\n\n\n has(element) {\n return this.index(element) >= 0;\n } // Get / set id\n\n\n id(id) {\n // generate new id if no id set\n if (typeof id === 'undefined' && !this.node.id) {\n this.node.id = eid(this.type);\n } // dont't set directly width this.node.id to make `null` work correctly\n\n\n return this.attr('id', id);\n } // Gets index of given element\n\n\n index(element) {\n return [].slice.call(this.node.childNodes).indexOf(element.node);\n } // Get the last child\n\n\n last() {\n return adopt(this.node.lastChild);\n } // matches the element vs a css selector\n\n\n matches(selector) {\n const el = this.node;\n return (el.matches || el.matchesSelector || el.msMatchesSelector || el.mozMatchesSelector || el.webkitMatchesSelector || el.oMatchesSelector).call(el, selector);\n } // Returns the parent element instance\n\n\n parent(type) {\n var parent = this; // check for parent\n\n if (!parent.node.parentNode) return null; // get parent element\n\n parent = adopt(parent.node.parentNode);\n if (!type) return parent; // loop trough ancestors if type is given\n\n while (parent) {\n if (typeof type === 'string' ? parent.matches(type) : parent instanceof type) return parent;\n if (!parent.node.parentNode || parent.node.parentNode.nodeName === '#document' || parent.node.parentNode.nodeName === '#document-fragment') return null; // #759, #720\n\n parent = adopt(parent.node.parentNode);\n }\n } // Basically does the same as `add()` but returns the added element instead\n\n\n put(element, i) {\n this.add(element, i);\n return element;\n } // Add element to given container and return container\n\n\n putIn(parent) {\n return makeInstance(parent).add(this);\n } // Remove element\n\n\n remove() {\n if (this.parent()) {\n this.parent().removeElement(this);\n }\n\n return this;\n } // Remove a given child\n\n\n removeElement(element) {\n this.node.removeChild(element.node);\n return this;\n } // Replace this with element\n\n\n replace(element) {\n element = makeInstance(element);\n this.node.parentNode.replaceChild(element.node, this.node);\n return element;\n }\n\n round(precision = 2, map$$1) {\n const factor = Math.pow(10, precision);\n const attrs = this.attr(); // If we have no map, build one from attrs\n\n if (!map$$1) {\n map$$1 = Object.keys(attrs);\n } // Holds rounded attributes\n\n\n const newAttrs = {};\n map$$1.forEach(key => {\n newAttrs[key] = Math.round(attrs[key] * factor) / factor;\n });\n this.attr(newAttrs);\n return this;\n } // Return id on string conversion\n\n\n toString() {\n return this.id();\n } // Import raw svg\n\n\n svg(svgOrFn, outerHTML) {\n var well, len, fragment;\n\n if (svgOrFn === false) {\n outerHTML = false;\n svgOrFn = null;\n } // act as getter if no svg string is given\n\n\n if (svgOrFn == null || typeof svgOrFn === 'function') {\n // The default for exports is, that the outerNode is included\n outerHTML = outerHTML == null ? true : outerHTML; // write svgjs data to the dom\n\n this.writeDataToDom();\n let current = this; // An export modifier was passed\n\n if (svgOrFn != null) {\n current = adopt(current.node.cloneNode(true)); // If the user wants outerHTML we need to process this node, too\n\n if (outerHTML) {\n let result = svgOrFn(current);\n current = result || current; // The user does not want this node? Well, then he gets nothing\n\n if (result === false) return '';\n } // Deep loop through all children and apply modifier\n\n\n current.each(function () {\n let result = svgOrFn(this);\n\n let _this = result || this; // If modifier returns false, discard node\n\n\n if (result === false) {\n this.remove(); // If modifier returns new node, use it\n } else if (result && this !== _this) {\n this.replace(_this);\n }\n }, true);\n } // Return outer or inner content\n\n\n return outerHTML ? current.node.outerHTML : current.node.innerHTML;\n } // Act as setter if we got a string\n // The default for import is, that the current node is not replaced\n\n\n outerHTML = outerHTML == null ? false : outerHTML; // Create temporary holder\n\n well = globals.document.createElementNS(ns, 'svg');\n fragment = globals.document.createDocumentFragment(); // Dump raw svg\n\n well.innerHTML = svgOrFn; // Transplant nodes into the fragment\n\n for (len = well.children.length; len--;) {\n fragment.appendChild(well.firstElementChild);\n }\n\n let parent = this.parent(); // Add the whole fragment at once\n\n return outerHTML ? this.replace(fragment) && parent : this.add(fragment);\n }\n\n words(text) {\n // This is faster than removing all children and adding a new one\n this.node.textContent = text;\n return this;\n } // write svgjs data to the dom\n\n\n writeDataToDom() {\n // dump variables recursively\n this.each(function () {\n this.writeDataToDom();\n });\n return this;\n }\n\n}\nextend(Dom, {\n attr,\n find\n});\nregister(Dom);\n\nconst Svg = getClass(root);\nclass Element extends Dom {\n constructor(node, attrs) {\n super(node, attrs); // initialize data object\n\n this.dom = {}; // create circular reference\n\n this.node.instance = this;\n\n if (node.hasAttribute('svgjs:data')) {\n // pull svgjs data from the dom (getAttributeNS doesn't work in html5)\n this.setData(JSON.parse(node.getAttribute('svgjs:data')) || {});\n }\n } // Move element by its center\n\n\n center(x, y) {\n return this.cx(x).cy(y);\n } // Move by center over x-axis\n\n\n cx(x) {\n return x == null ? this.x() + this.width() / 2 : this.x(x - this.width() / 2);\n } // Move by center over y-axis\n\n\n cy(y) {\n return y == null ? this.y() + this.height() / 2 : this.y(y - this.height() / 2);\n } // Get defs\n\n\n defs() {\n return this.root().defs();\n } // Relative move over x axis\n\n\n dx(x) {\n return this.x(new SVGNumber(x).plus(this.x()));\n } // Relative move over y axis\n\n\n dy(y) {\n return this.y(new SVGNumber(y).plus(this.y()));\n } // Get parent document\n\n\n root() {\n let p = this.parent(Svg);\n return p && p.root();\n }\n\n getEventHolder() {\n return this;\n } // Set height of element\n\n\n height(height) {\n return this.attr('height', height);\n } // Checks whether the given point inside the bounding box of the element\n\n\n inside(x, y) {\n let box = this.bbox();\n return x > box.x && y > box.y && x < box.x + box.width && y < box.y + box.height;\n } // Move element to given x and y values\n\n\n move(x, y) {\n return this.x(x).y(y);\n } // return array of all ancestors of given type up to the root svg\n\n\n parents(until = globals.document) {\n until = makeInstance(until);\n let parents = new List();\n let parent = this;\n\n while ((parent = parent.parent()) && parent.node !== until.node && parent.node !== globals.document) {\n parents.push(parent);\n }\n\n return parents;\n } // Get referenced element form attribute value\n\n\n reference(attr) {\n attr = this.attr(attr);\n if (!attr) return null;\n const m = attr.match(reference);\n return m ? makeInstance(m[1]) : null;\n } // set given data to the elements data property\n\n\n setData(o) {\n this.dom = o;\n return this;\n } // Set element size to given width and height\n\n\n size(width, height) {\n let p = proportionalSize(this, width, height);\n return this.width(new SVGNumber(p.width)).height(new SVGNumber(p.height));\n } // Set width of element\n\n\n width(width) {\n return this.attr('width', width);\n } // write svgjs data to the dom\n\n\n writeDataToDom() {\n // remove previously set data\n this.node.removeAttribute('svgjs:data');\n\n if (Object.keys(this.dom).length) {\n this.node.setAttribute('svgjs:data', JSON.stringify(this.dom)); // see #428\n }\n\n return super.writeDataToDom();\n } // Move over x-axis\n\n\n x(x) {\n return this.attr('x', x);\n } // Move over y-axis\n\n\n y(y) {\n return this.attr('y', y);\n }\n\n}\nextend(Element, {\n bbox,\n rbox,\n point,\n ctm,\n screenCTM\n});\nregister(Element);\n\nvar sugar = {\n stroke: ['color', 'width', 'opacity', 'linecap', 'linejoin', 'miterlimit', 'dasharray', 'dashoffset'],\n fill: ['color', 'opacity', 'rule'],\n prefix: function (t, a) {\n return a === 'color' ? t : t + '-' + a;\n } // Add sugar for fill and stroke\n\n};\n['fill', 'stroke'].forEach(function (m) {\n var extension = {};\n var i;\n\n extension[m] = function (o) {\n if (typeof o === 'undefined') {\n return this.attr(m);\n }\n\n if (typeof o === 'string' || o instanceof Color || Color.isRgb(o) || o instanceof Element) {\n this.attr(m, o);\n } else {\n // set all attributes from sugar.fill and sugar.stroke list\n for (i = sugar[m].length - 1; i >= 0; i--) {\n if (o[sugar[m][i]] != null) {\n this.attr(sugar.prefix(m, sugar[m][i]), o[sugar[m][i]]);\n }\n }\n }\n\n return this;\n };\n\n registerMethods(['Element', 'Runner'], extension);\n});\nregisterMethods(['Element', 'Runner'], {\n // Let the user set the matrix directly\n matrix: function (mat, b, c, d, e, f) {\n // Act as a getter\n if (mat == null) {\n return new Matrix(this);\n } // Act as a setter, the user can pass a matrix or a set of numbers\n\n\n return this.attr('transform', new Matrix(mat, b, c, d, e, f));\n },\n // Map rotation to transform\n rotate: function (angle, cx, cy) {\n return this.transform({\n rotate: angle,\n ox: cx,\n oy: cy\n }, true);\n },\n // Map skew to transform\n skew: function (x, y, cx, cy) {\n return arguments.length === 1 || arguments.length === 3 ? this.transform({\n skew: x,\n ox: y,\n oy: cx\n }, true) : this.transform({\n skew: [x, y],\n ox: cx,\n oy: cy\n }, true);\n },\n shear: function (lam, cx, cy) {\n return this.transform({\n shear: lam,\n ox: cx,\n oy: cy\n }, true);\n },\n // Map scale to transform\n scale: function (x, y, cx, cy) {\n return arguments.length === 1 || arguments.length === 3 ? this.transform({\n scale: x,\n ox: y,\n oy: cx\n }, true) : this.transform({\n scale: [x, y],\n ox: cx,\n oy: cy\n }, true);\n },\n // Map translate to transform\n translate: function (x, y) {\n return this.transform({\n translate: [x, y]\n }, true);\n },\n // Map relative translations to transform\n relative: function (x, y) {\n return this.transform({\n relative: [x, y]\n }, true);\n },\n // Map flip to transform\n flip: function (direction, around) {\n var directionString = typeof direction === 'string' ? direction : isFinite(direction) ? 'both' : 'both';\n var origin = direction === 'both' && isFinite(around) ? [around, around] : direction === 'x' ? [around, 0] : direction === 'y' ? [0, around] : isFinite(direction) ? [direction, direction] : [0, 0];\n return this.transform({\n flip: directionString,\n origin: origin\n }, true);\n },\n // Opacity\n opacity: function (value) {\n return this.attr('opacity', value);\n },\n // Relative move over x and y axes\n dmove: function (x, y) {\n return this.dx(x).dy(y);\n }\n});\nregisterMethods('radius', {\n // Add x and y radius\n radius: function (x, y) {\n var type = (this._element || this).type;\n return type === 'radialGradient' || type === 'radialGradient' ? this.attr('r', new SVGNumber(x)) : this.rx(x).ry(y == null ? x : y);\n }\n});\nregisterMethods('Path', {\n // Get path length\n length: function () {\n return this.node.getTotalLength();\n },\n // Get point at length\n pointAt: function (length) {\n return new Point(this.node.getPointAtLength(length));\n }\n});\nregisterMethods(['Element', 'Runner'], {\n // Set font\n font: function (a, v) {\n if (typeof a === 'object') {\n for (v in a) this.font(v, a[v]);\n }\n\n return a === 'leading' ? this.leading(v) : a === 'anchor' ? this.attr('text-anchor', v) : a === 'size' || a === 'family' || a === 'weight' || a === 'stretch' || a === 'variant' || a === 'style' ? this.attr('font-' + a, v) : this.attr(a, v);\n }\n});\nregisterMethods('Text', {\n ax(x) {\n return this.attr('x', x);\n },\n\n ay(y) {\n return this.attr('y', y);\n },\n\n amove(x, y) {\n return this.ax(x).ay(y);\n }\n\n}); // Add events to elements\n\nconst methods$1 = ['click', 'dblclick', 'mousedown', 'mouseup', 'mouseover', 'mouseout', 'mousemove', 'mouseenter', 'mouseleave', 'touchstart', 'touchmove', 'touchleave', 'touchend', 'touchcancel'].reduce(function (last, event) {\n // add event to Element\n const fn = function (f) {\n if (f === null) {\n off(this, event);\n } else {\n on(this, event, f);\n }\n\n return this;\n };\n\n last[event] = fn;\n return last;\n}, {});\nregisterMethods('Element', methods$1);\n\nfunction _defineProperty(obj, key, value) {\n if (key in obj) {\n Object.defineProperty(obj, key, {\n value: value,\n enumerable: true,\n configurable: true,\n writable: true\n });\n } else {\n obj[key] = value;\n }\n\n return obj;\n}\n\nfunction _objectSpread(target) {\n for (var i = 1; i < arguments.length; i++) {\n var source = arguments[i] != null ? arguments[i] : {};\n var ownKeys = Object.keys(source);\n\n if (typeof Object.getOwnPropertySymbols === 'function') {\n ownKeys = ownKeys.concat(Object.getOwnPropertySymbols(source).filter(function (sym) {\n return Object.getOwnPropertyDescriptor(source, sym).enumerable;\n }));\n }\n\n ownKeys.forEach(function (key) {\n _defineProperty(target, key, source[key]);\n });\n }\n\n return target;\n}\n\nfunction untransform() {\n return this.attr('transform', null);\n} // merge the whole transformation chain into one matrix and returns it\n\nfunction matrixify() {\n var matrix = (this.attr('transform') || ''). // split transformations\n split(transforms).slice(0, -1).map(function (str) {\n // generate key => value pairs\n var kv = str.trim().split('(');\n return [kv[0], kv[1].split(delimiter).map(function (str) {\n return parseFloat(str);\n })];\n }).reverse() // merge every transformation into one matrix\n .reduce(function (matrix, transform) {\n if (transform[0] === 'matrix') {\n return matrix.lmultiply(Matrix.fromArray(transform[1]));\n }\n\n return matrix[transform[0]].apply(matrix, transform[1]);\n }, new Matrix());\n return matrix;\n} // add an element to another parent without changing the visual representation on the screen\n\nfunction toParent(parent) {\n if (this === parent) return this;\n var ctm$$1 = this.screenCTM();\n var pCtm = parent.screenCTM().inverse();\n this.addTo(parent).untransform().transform(pCtm.multiply(ctm$$1));\n return this;\n} // same as above with parent equals root-svg\n\nfunction toRoot() {\n return this.toParent(this.root());\n} // Add transformations\n\nfunction transform(o, relative) {\n // Act as a getter if no object was passed\n if (o == null || typeof o === 'string') {\n var decomposed = new Matrix(this).decompose();\n return decomposed[o] || decomposed;\n }\n\n if (!Matrix.isMatrixLike(o)) {\n // Set the origin according to the defined transform\n o = _objectSpread({}, o, {\n origin: getOrigin(o, this)\n });\n } // The user can pass a boolean, an Element or an Matrix or nothing\n\n\n var cleanRelative = relative === true ? this : relative || false;\n var result = new Matrix(cleanRelative).transform(o);\n return this.attr('transform', result);\n}\nregisterMethods('Element', {\n untransform,\n matrixify,\n toParent,\n toRoot,\n transform\n});\n\nfunction rx(rx) {\n return this.attr('rx', rx);\n} // Radius y value\n\nfunction ry(ry) {\n return this.attr('ry', ry);\n} // Move over x-axis\n\nfunction x(x) {\n return x == null ? this.cx() - this.rx() : this.cx(x + this.rx());\n} // Move over y-axis\n\nfunction y(y) {\n return y == null ? this.cy() - this.ry() : this.cy(y + this.ry());\n} // Move by center over x-axis\n\nfunction cx(x) {\n return x == null ? this.attr('cx') : this.attr('cx', x);\n} // Move by center over y-axis\n\nfunction cy(y) {\n return y == null ? this.attr('cy') : this.attr('cy', y);\n} // Set width of element\n\nfunction width(width) {\n return width == null ? this.rx() * 2 : this.rx(new SVGNumber(width).divide(2));\n} // Set height of element\n\nfunction height(height) {\n return height == null ? this.ry() * 2 : this.ry(new SVGNumber(height).divide(2));\n}\n\nvar circled = ({\n rx: rx,\n ry: ry,\n x: x,\n y: y,\n cx: cx,\n cy: cy,\n width: width,\n height: height\n});\n\nclass Shape extends Element {}\nregister(Shape);\n\nclass Circle extends Shape {\n constructor(node) {\n super(nodeOrNew('circle', node), node);\n }\n\n radius(r) {\n return this.attr('r', r);\n } // Radius x value\n\n\n rx(rx$$1) {\n return this.attr('r', rx$$1);\n } // Alias radius x value\n\n\n ry(ry$$1) {\n return this.rx(ry$$1);\n }\n\n size(size) {\n return this.radius(new SVGNumber(size).divide(2));\n }\n\n}\nextend(Circle, {\n x,\n y,\n cx,\n cy,\n width,\n height\n});\nregisterMethods({\n Element: {\n // Create circle element\n circle: wrapWithAttrCheck(function (size) {\n return this.put(new Circle()).size(size).move(0, 0);\n })\n }\n});\nregister(Circle);\n\nclass Container extends Element {\n flatten(parent) {\n this.each(function () {\n if (this instanceof Container) return this.flatten(parent).ungroup(parent);\n return this.toParent(parent);\n }); // we need this so that the root does not get removed\n\n this.node.firstElementChild || this.remove();\n return this;\n }\n\n ungroup(parent) {\n parent = parent || this.parent();\n this.each(function () {\n return this.toParent(parent);\n });\n this.remove();\n return this;\n }\n\n}\nregister(Container);\n\nclass Defs extends Container {\n constructor(node) {\n super(nodeOrNew('defs', node), node);\n }\n\n flatten() {\n return this;\n }\n\n ungroup() {\n return this;\n }\n\n}\nregister(Defs);\n\nclass Ellipse extends Shape {\n constructor(node) {\n super(nodeOrNew('ellipse', node), node);\n }\n\n size(width$$1, height$$1) {\n var p = proportionalSize(this, width$$1, height$$1);\n return this.rx(new SVGNumber(p.width).divide(2)).ry(new SVGNumber(p.height).divide(2));\n }\n\n}\nextend(Ellipse, circled);\nregisterMethods('Container', {\n // Create an ellipse\n ellipse: wrapWithAttrCheck(function (width$$1, height$$1) {\n return this.put(new Ellipse()).size(width$$1, height$$1).move(0, 0);\n })\n});\nregister(Ellipse);\n\nclass Stop extends Element {\n constructor(node) {\n super(nodeOrNew('stop', node), node);\n } // add color stops\n\n\n update(o) {\n if (typeof o === 'number' || o instanceof SVGNumber) {\n o = {\n offset: arguments[0],\n color: arguments[1],\n opacity: arguments[2]\n };\n } // set attributes\n\n\n if (o.opacity != null) this.attr('stop-opacity', o.opacity);\n if (o.color != null) this.attr('stop-color', o.color);\n if (o.offset != null) this.attr('offset', new SVGNumber(o.offset));\n return this;\n }\n\n}\nregister(Stop);\n\nfunction from(x, y) {\n return (this._element || this).type === 'radialGradient' ? this.attr({\n fx: new SVGNumber(x),\n fy: new SVGNumber(y)\n }) : this.attr({\n x1: new SVGNumber(x),\n y1: new SVGNumber(y)\n });\n}\nfunction to(x, y) {\n return (this._element || this).type === 'radialGradient' ? this.attr({\n cx: new SVGNumber(x),\n cy: new SVGNumber(y)\n }) : this.attr({\n x2: new SVGNumber(x),\n y2: new SVGNumber(y)\n });\n}\n\nvar gradiented = ({\n from: from,\n to: to\n});\n\nclass Gradient extends Container {\n constructor(type, attrs) {\n super(nodeOrNew(type + 'Gradient', typeof type === 'string' ? null : type), attrs);\n } // Add a color stop\n\n\n stop(offset, color, opacity) {\n return this.put(new Stop()).update(offset, color, opacity);\n } // Update gradient\n\n\n update(block) {\n // remove all stops\n this.clear(); // invoke passed block\n\n if (typeof block === 'function') {\n block.call(this, this);\n }\n\n return this;\n } // Return the fill id\n\n\n url() {\n return 'url(#' + this.id() + ')';\n } // Alias string convertion to fill\n\n\n toString() {\n return this.url();\n } // custom attr to handle transform\n\n\n attr(a, b, c) {\n if (a === 'transform') a = 'gradientTransform';\n return super.attr(a, b, c);\n }\n\n targets() {\n return baseFind('svg [fill*=\"' + this.id() + '\"]');\n }\n\n bbox() {\n return new Box();\n }\n\n}\nextend(Gradient, gradiented);\nregisterMethods({\n Container: {\n // Create gradient element in defs\n gradient: wrapWithAttrCheck(function (type, block) {\n return this.defs().gradient(type, block);\n })\n },\n // define gradient\n Defs: {\n gradient: wrapWithAttrCheck(function (type, block) {\n return this.put(new Gradient(type)).update(block);\n })\n }\n});\nregister(Gradient);\n\nclass Pattern extends Container {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('pattern', node), node);\n } // Return the fill id\n\n\n url() {\n return 'url(#' + this.id() + ')';\n } // Update pattern by rebuilding\n\n\n update(block) {\n // remove content\n this.clear(); // invoke passed block\n\n if (typeof block === 'function') {\n block.call(this, this);\n }\n\n return this;\n } // Alias string convertion to fill\n\n\n toString() {\n return this.url();\n } // custom attr to handle transform\n\n\n attr(a, b, c) {\n if (a === 'transform') a = 'patternTransform';\n return super.attr(a, b, c);\n }\n\n targets() {\n return baseFind('svg [fill*=\"' + this.id() + '\"]');\n }\n\n bbox() {\n return new Box();\n }\n\n}\nregisterMethods({\n Container: {\n // Create pattern element in defs\n pattern(...args) {\n return this.defs().pattern(...args);\n }\n\n },\n Defs: {\n pattern: wrapWithAttrCheck(function (width, height, block) {\n return this.put(new Pattern()).update(block).attr({\n x: 0,\n y: 0,\n width: width,\n height: height,\n patternUnits: 'userSpaceOnUse'\n });\n })\n }\n});\nregister(Pattern);\n\nclass Image extends Shape {\n constructor(node) {\n super(nodeOrNew('image', node), node);\n } // (re)load image\n\n\n load(url, callback) {\n if (!url) return this;\n var img = new globals.window.Image();\n on(img, 'load', function (e) {\n var p = this.parent(Pattern); // ensure image size\n\n if (this.width() === 0 && this.height() === 0) {\n this.size(img.width, img.height);\n }\n\n if (p instanceof Pattern) {\n // ensure pattern size if not set\n if (p.width() === 0 && p.height() === 0) {\n p.size(this.width(), this.height());\n }\n }\n\n if (typeof callback === 'function') {\n callback.call(this, e);\n }\n }, this);\n on(img, 'load error', function () {\n // dont forget to unbind memory leaking events\n off(img);\n });\n return this.attr('href', img.src = url, xlink);\n }\n\n}\nregisterAttrHook(function (attr$$1, val, _this) {\n // convert image fill and stroke to patterns\n if (attr$$1 === 'fill' || attr$$1 === 'stroke') {\n if (isImage.test(val)) {\n val = _this.root().defs().image(val);\n }\n }\n\n if (val instanceof Image) {\n val = _this.root().defs().pattern(0, 0, pattern => {\n pattern.add(val);\n });\n }\n\n return val;\n});\nregisterMethods({\n Container: {\n // create image element, load image and set its size\n image: wrapWithAttrCheck(function (source, callback) {\n return this.put(new Image()).size(0, 0).load(source, callback);\n })\n }\n});\nregister(Image);\n\nconst PointArray = subClassArray('PointArray', SVGArray);\nextend(PointArray, {\n // Convert array to string\n toString() {\n // convert to a poly point string\n for (var i = 0, il = this.length, array = []; i < il; i++) {\n array.push(this[i].join(','));\n }\n\n return array.join(' ');\n },\n\n // Convert array to line object\n toLine() {\n return {\n x1: this[0][0],\n y1: this[0][1],\n x2: this[1][0],\n y2: this[1][1]\n };\n },\n\n // Get morphed array at given position\n at(pos) {\n // make sure a destination is defined\n if (!this.destination) return this; // generate morphed point string\n\n for (var i = 0, il = this.length, array = []; i < il; i++) {\n array.push([this[i][0] + (this.destination[i][0] - this[i][0]) * pos, this[i][1] + (this.destination[i][1] - this[i][1]) * pos]);\n }\n\n return new PointArray(array);\n },\n\n // Parse point string and flat array\n parse(array = [[0, 0]]) {\n var points = []; // if it is an array\n\n if (array instanceof Array) {\n // and it is not flat, there is no need to parse it\n if (array[0] instanceof Array) {\n return array;\n }\n } else {\n // Else, it is considered as a string\n // parse points\n array = array.trim().split(delimiter).map(parseFloat);\n } // validate points - https://svgwg.org/svg2-draft/shapes.html#DataTypePoints\n // Odd number of coordinates is an error. In such cases, drop the last odd coordinate.\n\n\n if (array.length % 2 !== 0) array.pop(); // wrap points in two-tuples and parse points as floats\n\n for (var i = 0, len = array.length; i < len; i = i + 2) {\n points.push([array[i], array[i + 1]]);\n }\n\n return points;\n },\n\n // Move point string\n move(x, y) {\n var box = this.bbox(); // get relative offset\n\n x -= box.x;\n y -= box.y; // move every point\n\n if (!isNaN(x) && !isNaN(y)) {\n for (var i = this.length - 1; i >= 0; i--) {\n this[i] = [this[i][0] + x, this[i][1] + y];\n }\n }\n\n return this;\n },\n\n // Resize poly string\n size(width, height) {\n var i;\n var box = this.bbox(); // recalculate position of all points according to new size\n\n for (i = this.length - 1; i >= 0; i--) {\n if (box.width) this[i][0] = (this[i][0] - box.x) * width / box.width + box.x;\n if (box.height) this[i][1] = (this[i][1] - box.y) * height / box.height + box.y;\n }\n\n return this;\n },\n\n // Get bounding box of points\n bbox() {\n var maxX = -Infinity;\n var maxY = -Infinity;\n var minX = Infinity;\n var minY = Infinity;\n this.forEach(function (el) {\n maxX = Math.max(el[0], maxX);\n maxY = Math.max(el[1], maxY);\n minX = Math.min(el[0], minX);\n minY = Math.min(el[1], minY);\n });\n return {\n x: minX,\n y: minY,\n width: maxX - minX,\n height: maxY - minY\n };\n }\n\n});\n\nlet MorphArray = PointArray; // Move by left top corner over x-axis\n\nfunction x$1(x) {\n return x == null ? this.bbox().x : this.move(x, this.bbox().y);\n} // Move by left top corner over y-axis\n\nfunction y$1(y) {\n return y == null ? this.bbox().y : this.move(this.bbox().x, y);\n} // Set width of element\n\nfunction width$1(width) {\n let b = this.bbox();\n return width == null ? b.width : this.size(width, b.height);\n} // Set height of element\n\nfunction height$1(height) {\n let b = this.bbox();\n return height == null ? b.height : this.size(b.width, height);\n}\n\nvar pointed = ({\n MorphArray: MorphArray,\n x: x$1,\n y: y$1,\n width: width$1,\n height: height$1\n});\n\nclass Line extends Shape {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('line', node), node);\n } // Get array\n\n\n array() {\n return new PointArray([[this.attr('x1'), this.attr('y1')], [this.attr('x2'), this.attr('y2')]]);\n } // Overwrite native plot() method\n\n\n plot(x1, y1, x2, y2) {\n if (x1 == null) {\n return this.array();\n } else if (typeof y1 !== 'undefined') {\n x1 = {\n x1: x1,\n y1: y1,\n x2: x2,\n y2: y2\n };\n } else {\n x1 = new PointArray(x1).toLine();\n }\n\n return this.attr(x1);\n } // Move by left top corner\n\n\n move(x, y) {\n return this.attr(this.array().move(x, y).toLine());\n } // Set element size to given width and height\n\n\n size(width, height) {\n var p = proportionalSize(this, width, height);\n return this.attr(this.array().size(p.width, p.height).toLine());\n }\n\n}\nextend(Line, pointed);\nregisterMethods({\n Container: {\n // Create a line element\n line: wrapWithAttrCheck(function (...args) {\n // make sure plot is called as a setter\n // x1 is not necessarily a number, it can also be an array, a string and a PointArray\n return Line.prototype.plot.apply(this.put(new Line()), args[0] != null ? args : [0, 0, 0, 0]);\n })\n }\n});\nregister(Line);\n\nclass Marker extends Container {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('marker', node), node);\n } // Set width of element\n\n\n width(width) {\n return this.attr('markerWidth', width);\n } // Set height of element\n\n\n height(height) {\n return this.attr('markerHeight', height);\n } // Set marker refX and refY\n\n\n ref(x, y) {\n return this.attr('refX', x).attr('refY', y);\n } // Update marker\n\n\n update(block) {\n // remove all content\n this.clear(); // invoke passed block\n\n if (typeof block === 'function') {\n block.call(this, this);\n }\n\n return this;\n } // Return the fill id\n\n\n toString() {\n return 'url(#' + this.id() + ')';\n }\n\n}\nregisterMethods({\n Container: {\n marker(...args) {\n // Create marker element in defs\n return this.defs().marker(...args);\n }\n\n },\n Defs: {\n // Create marker\n marker: wrapWithAttrCheck(function (width, height, block) {\n // Set default viewbox to match the width and height, set ref to cx and cy and set orient to auto\n return this.put(new Marker()).size(width, height).ref(width / 2, height / 2).viewbox(0, 0, width, height).attr('orient', 'auto').update(block);\n })\n },\n marker: {\n // Create and attach markers\n marker(marker, width, height, block) {\n var attr = ['marker']; // Build attribute name\n\n if (marker !== 'all') attr.push(marker);\n attr = attr.join('-'); // Set marker attribute\n\n marker = arguments[1] instanceof Marker ? arguments[1] : this.defs().marker(width, height, block);\n return this.attr(attr, marker);\n }\n\n }\n});\nregister(Marker);\n\nfunction createCommonjsModule(fn, module) {\n\treturn module = { exports: {} }, fn(module, module.exports), module.exports;\n}\n\nvar _global = createCommonjsModule(function (module) {\n// https://github.com/zloirock/core-js/issues/86#issuecomment-115759028\nvar global = module.exports = typeof window != 'undefined' && window.Math == Math\n ? window : typeof self != 'undefined' && self.Math == Math ? self\n // eslint-disable-next-line no-new-func\n : Function('return this')();\nif (typeof __g == 'number') __g = global; // eslint-disable-line no-undef\n});\n\nvar _core = createCommonjsModule(function (module) {\nvar core = module.exports = { version: '2.5.7' };\nif (typeof __e == 'number') __e = core; // eslint-disable-line no-undef\n});\n\nvar _isObject = function (it) {\n return typeof it === 'object' ? it !== null : typeof it === 'function';\n};\n\nvar _anObject = function (it) {\n if (!_isObject(it)) throw TypeError(it + ' is not an object!');\n return it;\n};\n\nvar _fails = function (exec) {\n try {\n return !!exec();\n } catch (e) {\n return true;\n }\n};\n\n// Thank's IE8 for his funny defineProperty\nvar _descriptors = !_fails(function () {\n return Object.defineProperty({}, 'a', { get: function () { return 7; } }).a != 7;\n});\n\nvar document$1 = _global.document;\n// typeof document.createElement is 'object' in old IE\nvar is$1 = _isObject(document$1) && _isObject(document$1.createElement);\nvar _domCreate = function (it) {\n return is$1 ? document$1.createElement(it) : {};\n};\n\nvar _ie8DomDefine = !_descriptors && !_fails(function () {\n return Object.defineProperty(_domCreate('div'), 'a', { get: function () { return 7; } }).a != 7;\n});\n\n// 7.1.1 ToPrimitive(input [, PreferredType])\n\n// instead of the ES6 spec version, we didn't implement @@toPrimitive case\n// and the second argument - flag - preferred type is a string\nvar _toPrimitive = function (it, S) {\n if (!_isObject(it)) return it;\n var fn, val;\n if (S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;\n if (typeof (fn = it.valueOf) == 'function' && !_isObject(val = fn.call(it))) return val;\n if (!S && typeof (fn = it.toString) == 'function' && !_isObject(val = fn.call(it))) return val;\n throw TypeError(\"Can't convert object to primitive value\");\n};\n\nvar dP = Object.defineProperty;\n\nvar f = _descriptors ? Object.defineProperty : function defineProperty(O, P, Attributes) {\n _anObject(O);\n P = _toPrimitive(P, true);\n _anObject(Attributes);\n if (_ie8DomDefine) try {\n return dP(O, P, Attributes);\n } catch (e) { /* empty */ }\n if ('get' in Attributes || 'set' in Attributes) throw TypeError('Accessors not supported!');\n if ('value' in Attributes) O[P] = Attributes.value;\n return O;\n};\n\nvar _objectDp = {\n\tf: f\n};\n\nvar _propertyDesc = function (bitmap, value) {\n return {\n enumerable: !(bitmap & 1),\n configurable: !(bitmap & 2),\n writable: !(bitmap & 4),\n value: value\n };\n};\n\nvar _hide = _descriptors ? function (object, key, value) {\n return _objectDp.f(object, key, _propertyDesc(1, value));\n} : function (object, key, value) {\n object[key] = value;\n return object;\n};\n\nvar hasOwnProperty = {}.hasOwnProperty;\nvar _has = function (it, key) {\n return hasOwnProperty.call(it, key);\n};\n\nvar id = 0;\nvar px = Math.random();\nvar _uid = function (key) {\n return 'Symbol('.concat(key === undefined ? '' : key, ')_', (++id + px).toString(36));\n};\n\nvar _redefine = createCommonjsModule(function (module) {\nvar SRC = _uid('src');\nvar TO_STRING = 'toString';\nvar $toString = Function[TO_STRING];\nvar TPL = ('' + $toString).split(TO_STRING);\n\n_core.inspectSource = function (it) {\n return $toString.call(it);\n};\n\n(module.exports = function (O, key, val, safe) {\n var isFunction = typeof val == 'function';\n if (isFunction) _has(val, 'name') || _hide(val, 'name', key);\n if (O[key] === val) return;\n if (isFunction) _has(val, SRC) || _hide(val, SRC, O[key] ? '' + O[key] : TPL.join(String(key)));\n if (O === _global) {\n O[key] = val;\n } else if (!safe) {\n delete O[key];\n _hide(O, key, val);\n } else if (O[key]) {\n O[key] = val;\n } else {\n _hide(O, key, val);\n }\n// add fake Function#toString for correct work wrapped methods / constructors with methods like LoDash isNative\n})(Function.prototype, TO_STRING, function toString() {\n return typeof this == 'function' && this[SRC] || $toString.call(this);\n});\n});\n\nvar _aFunction = function (it) {\n if (typeof it != 'function') throw TypeError(it + ' is not a function!');\n return it;\n};\n\n// optional / simple context binding\n\nvar _ctx = function (fn, that, length) {\n _aFunction(fn);\n if (that === undefined) return fn;\n switch (length) {\n case 1: return function (a) {\n return fn.call(that, a);\n };\n case 2: return function (a, b) {\n return fn.call(that, a, b);\n };\n case 3: return function (a, b, c) {\n return fn.call(that, a, b, c);\n };\n }\n return function (/* ...args */) {\n return fn.apply(that, arguments);\n };\n};\n\nvar PROTOTYPE = 'prototype';\n\nvar $export = function (type, name, source) {\n var IS_FORCED = type & $export.F;\n var IS_GLOBAL = type & $export.G;\n var IS_STATIC = type & $export.S;\n var IS_PROTO = type & $export.P;\n var IS_BIND = type & $export.B;\n var target = IS_GLOBAL ? _global : IS_STATIC ? _global[name] || (_global[name] = {}) : (_global[name] || {})[PROTOTYPE];\n var exports = IS_GLOBAL ? _core : _core[name] || (_core[name] = {});\n var expProto = exports[PROTOTYPE] || (exports[PROTOTYPE] = {});\n var key, own, out, exp;\n if (IS_GLOBAL) source = name;\n for (key in source) {\n // contains in native\n own = !IS_FORCED && target && target[key] !== undefined;\n // export native or passed\n out = (own ? target : source)[key];\n // bind timers to global for call from export context\n exp = IS_BIND && own ? _ctx(out, _global) : IS_PROTO && typeof out == 'function' ? _ctx(Function.call, out) : out;\n // extend global\n if (target) _redefine(target, key, out, type & $export.U);\n // export\n if (exports[key] != out) _hide(exports, key, exp);\n if (IS_PROTO && expProto[key] != out) expProto[key] = out;\n }\n};\n_global.core = _core;\n// type bitmap\n$export.F = 1; // forced\n$export.G = 2; // global\n$export.S = 4; // static\n$export.P = 8; // proto\n$export.B = 16; // bind\n$export.W = 32; // wrap\n$export.U = 64; // safe\n$export.R = 128; // real proto method for `library`\nvar _export = $export;\n\n// 7.2.1 RequireObjectCoercible(argument)\nvar _defined = function (it) {\n if (it == undefined) throw TypeError(\"Can't call method on \" + it);\n return it;\n};\n\n// 7.1.13 ToObject(argument)\n\nvar _toObject = function (it) {\n return Object(_defined(it));\n};\n\nvar _strictMethod = function (method, arg) {\n return !!method && _fails(function () {\n // eslint-disable-next-line no-useless-call\n arg ? method.call(null, function () { /* empty */ }, 1) : method.call(null);\n });\n};\n\nvar $sort = [].sort;\nvar test = [1, 2, 3];\n\n_export(_export.P + _export.F * (_fails(function () {\n // IE8-\n test.sort(undefined);\n}) || !_fails(function () {\n // V8 bug\n test.sort(null);\n // Old WebKit\n}) || !_strictMethod($sort)), 'Array', {\n // 22.1.3.25 Array.prototype.sort(comparefn)\n sort: function sort(comparefn) {\n return comparefn === undefined\n ? $sort.call(_toObject(this))\n : $sort.call(_toObject(this), _aFunction(comparefn));\n }\n});\n\n/***\r\nBase Class\r\n==========\r\nThe base stepper class that will be\r\n***/\n\nfunction makeSetterGetter(k, f) {\n return function (v) {\n if (v == null) return this[v];\n this[k] = v;\n if (f) f.call(this);\n return this;\n };\n}\n\nlet easing = {\n '-': function (pos) {\n return pos;\n },\n '<>': function (pos) {\n return -Math.cos(pos * Math.PI) / 2 + 0.5;\n },\n '>': function (pos) {\n return Math.sin(pos * Math.PI / 2);\n },\n '<': function (pos) {\n return -Math.cos(pos * Math.PI / 2) + 1;\n },\n bezier: function (x1, y1, x2, y2) {\n // see https://www.w3.org/TR/css-easing-1/#cubic-bezier-algo\n return function (t) {\n if (t < 0) {\n if (x1 > 0) {\n return y1 / x1 * t;\n } else if (x2 > 0) {\n return y2 / x2 * t;\n } else {\n return 0;\n }\n } else if (t > 1) {\n if (x2 < 1) {\n return (1 - y2) / (1 - x2) * t + (y2 - x2) / (1 - x2);\n } else if (x1 < 1) {\n return (1 - y1) / (1 - x1) * t + (y1 - x1) / (1 - x1);\n } else {\n return 1;\n }\n } else {\n return 3 * t * Math.pow(1 - t, 2) * y1 + 3 * Math.pow(t, 2) * (1 - t) * y2 + Math.pow(t, 3);\n }\n };\n },\n // see https://www.w3.org/TR/css-easing-1/#step-timing-function-algo\n steps: function (steps, stepPosition = 'end') {\n // deal with \"jump-\" prefix\n stepPosition = stepPosition.split('-').reverse()[0];\n let jumps = steps;\n\n if (stepPosition === 'none') {\n --jumps;\n } else if (stepPosition === 'both') {\n ++jumps;\n } // The beforeFlag is essentially useless\n\n\n return (t, beforeFlag = false) => {\n // Step is called currentStep in referenced url\n let step = Math.floor(t * steps);\n const jumping = t * step % 1 === 0;\n\n if (stepPosition === 'start' || stepPosition === 'both') {\n ++step;\n }\n\n if (beforeFlag && jumping) {\n --step;\n }\n\n if (t >= 0 && step < 0) {\n step = 0;\n }\n\n if (t <= 1 && step > jumps) {\n step = jumps;\n }\n\n return step / jumps;\n };\n }\n};\nclass Stepper {\n done() {\n return false;\n }\n\n}\n/***\r\nEasing Functions\r\n================\r\n***/\n\nclass Ease extends Stepper {\n constructor(fn) {\n super();\n this.ease = easing[fn || timeline.ease] || fn;\n }\n\n step(from, to, pos) {\n if (typeof from !== 'number') {\n return pos < 1 ? from : to;\n }\n\n return from + (to - from) * this.ease(pos);\n }\n\n}\n/***\r\nController Types\r\n================\r\n***/\n\nclass Controller extends Stepper {\n constructor(fn) {\n super();\n this.stepper = fn;\n }\n\n step(current, target, dt, c) {\n return this.stepper(current, target, dt, c);\n }\n\n done(c) {\n return c.done;\n }\n\n}\n\nfunction recalculate() {\n // Apply the default parameters\n var duration = (this._duration || 500) / 1000;\n var overshoot = this._overshoot || 0; // Calculate the PID natural response\n\n var eps = 1e-10;\n var pi = Math.PI;\n var os = Math.log(overshoot / 100 + eps);\n var zeta = -os / Math.sqrt(pi * pi + os * os);\n var wn = 3.9 / (zeta * duration); // Calculate the Spring values\n\n this.d = 2 * zeta * wn;\n this.k = wn * wn;\n}\n\nclass Spring extends Controller {\n constructor(duration, overshoot) {\n super();\n this.duration(duration || 500).overshoot(overshoot || 0);\n }\n\n step(current, target, dt, c) {\n if (typeof current === 'string') return current;\n c.done = dt === Infinity;\n if (dt === Infinity) return target;\n if (dt === 0) return current;\n if (dt > 100) dt = 16;\n dt /= 1000; // Get the previous velocity\n\n var velocity = c.velocity || 0; // Apply the control to get the new position and store it\n\n var acceleration = -this.d * velocity - this.k * (current - target);\n var newPosition = current + velocity * dt + acceleration * dt * dt / 2; // Store the velocity\n\n c.velocity = velocity + acceleration * dt; // Figure out if we have converged, and if so, pass the value\n\n c.done = Math.abs(target - newPosition) + Math.abs(velocity) < 0.002;\n return c.done ? target : newPosition;\n }\n\n}\nextend(Spring, {\n duration: makeSetterGetter('_duration', recalculate),\n overshoot: makeSetterGetter('_overshoot', recalculate)\n});\nclass PID extends Controller {\n constructor(p, i, d, windup) {\n super();\n p = p == null ? 0.1 : p;\n i = i == null ? 0.01 : i;\n d = d == null ? 0 : d;\n windup = windup == null ? 1000 : windup;\n this.p(p).i(i).d(d).windup(windup);\n }\n\n step(current, target, dt, c) {\n if (typeof current === 'string') return current;\n c.done = dt === Infinity;\n if (dt === Infinity) return target;\n if (dt === 0) return current;\n var p = target - current;\n var i = (c.integral || 0) + p * dt;\n var d = (p - (c.error || 0)) / dt;\n var windup = this.windup; // antiwindup\n\n if (windup !== false) {\n i = Math.max(-windup, Math.min(i, windup));\n }\n\n c.error = p;\n c.integral = i;\n c.done = Math.abs(p) < 0.001;\n return c.done ? target : current + (this.P * p + this.I * i + this.D * d);\n }\n\n}\nextend(PID, {\n windup: makeSetterGetter('windup'),\n p: makeSetterGetter('P'),\n i: makeSetterGetter('I'),\n d: makeSetterGetter('D')\n});\n\nconst PathArray = subClassArray('PathArray', SVGArray);\nfunction pathRegReplace(a, b, c, d) {\n return c + d.replace(dots, ' .');\n}\n\nfunction arrayToString(a) {\n for (var i = 0, il = a.length, s = ''; i < il; i++) {\n s += a[i][0];\n\n if (a[i][1] != null) {\n s += a[i][1];\n\n if (a[i][2] != null) {\n s += ' ';\n s += a[i][2];\n\n if (a[i][3] != null) {\n s += ' ';\n s += a[i][3];\n s += ' ';\n s += a[i][4];\n\n if (a[i][5] != null) {\n s += ' ';\n s += a[i][5];\n s += ' ';\n s += a[i][6];\n\n if (a[i][7] != null) {\n s += ' ';\n s += a[i][7];\n }\n }\n }\n }\n }\n }\n\n return s + ' ';\n}\n\nconst pathHandlers = {\n M: function (c, p, p0) {\n p.x = p0.x = c[0];\n p.y = p0.y = c[1];\n return ['M', p.x, p.y];\n },\n L: function (c, p) {\n p.x = c[0];\n p.y = c[1];\n return ['L', c[0], c[1]];\n },\n H: function (c, p) {\n p.x = c[0];\n return ['H', c[0]];\n },\n V: function (c, p) {\n p.y = c[0];\n return ['V', c[0]];\n },\n C: function (c, p) {\n p.x = c[4];\n p.y = c[5];\n return ['C', c[0], c[1], c[2], c[3], c[4], c[5]];\n },\n S: function (c, p) {\n p.x = c[2];\n p.y = c[3];\n return ['S', c[0], c[1], c[2], c[3]];\n },\n Q: function (c, p) {\n p.x = c[2];\n p.y = c[3];\n return ['Q', c[0], c[1], c[2], c[3]];\n },\n T: function (c, p) {\n p.x = c[0];\n p.y = c[1];\n return ['T', c[0], c[1]];\n },\n Z: function (c, p, p0) {\n p.x = p0.x;\n p.y = p0.y;\n return ['Z'];\n },\n A: function (c, p) {\n p.x = c[5];\n p.y = c[6];\n return ['A', c[0], c[1], c[2], c[3], c[4], c[5], c[6]];\n }\n};\nlet mlhvqtcsaz = 'mlhvqtcsaz'.split('');\n\nfor (var i = 0, il = mlhvqtcsaz.length; i < il; ++i) {\n pathHandlers[mlhvqtcsaz[i]] = function (i) {\n return function (c, p, p0) {\n if (i === 'H') c[0] = c[0] + p.x;else if (i === 'V') c[0] = c[0] + p.y;else if (i === 'A') {\n c[5] = c[5] + p.x;\n c[6] = c[6] + p.y;\n } else {\n for (var j = 0, jl = c.length; j < jl; ++j) {\n c[j] = c[j] + (j % 2 ? p.y : p.x);\n }\n }\n return pathHandlers[i](c, p, p0);\n };\n }(mlhvqtcsaz[i].toUpperCase());\n}\n\nextend(PathArray, {\n // Convert array to string\n toString() {\n return arrayToString(this);\n },\n\n // Move path string\n move(x, y) {\n // get bounding box of current situation\n var box = this.bbox(); // get relative offset\n\n x -= box.x;\n y -= box.y;\n\n if (!isNaN(x) && !isNaN(y)) {\n // move every point\n for (var l, i = this.length - 1; i >= 0; i--) {\n l = this[i][0];\n\n if (l === 'M' || l === 'L' || l === 'T') {\n this[i][1] += x;\n this[i][2] += y;\n } else if (l === 'H') {\n this[i][1] += x;\n } else if (l === 'V') {\n this[i][1] += y;\n } else if (l === 'C' || l === 'S' || l === 'Q') {\n this[i][1] += x;\n this[i][2] += y;\n this[i][3] += x;\n this[i][4] += y;\n\n if (l === 'C') {\n this[i][5] += x;\n this[i][6] += y;\n }\n } else if (l === 'A') {\n this[i][6] += x;\n this[i][7] += y;\n }\n }\n }\n\n return this;\n },\n\n // Resize path string\n size(width, height) {\n // get bounding box of current situation\n var box = this.bbox();\n var i, l; // recalculate position of all points according to new size\n\n for (i = this.length - 1; i >= 0; i--) {\n l = this[i][0];\n\n if (l === 'M' || l === 'L' || l === 'T') {\n this[i][1] = (this[i][1] - box.x) * width / box.width + box.x;\n this[i][2] = (this[i][2] - box.y) * height / box.height + box.y;\n } else if (l === 'H') {\n this[i][1] = (this[i][1] - box.x) * width / box.width + box.x;\n } else if (l === 'V') {\n this[i][1] = (this[i][1] - box.y) * height / box.height + box.y;\n } else if (l === 'C' || l === 'S' || l === 'Q') {\n this[i][1] = (this[i][1] - box.x) * width / box.width + box.x;\n this[i][2] = (this[i][2] - box.y) * height / box.height + box.y;\n this[i][3] = (this[i][3] - box.x) * width / box.width + box.x;\n this[i][4] = (this[i][4] - box.y) * height / box.height + box.y;\n\n if (l === 'C') {\n this[i][5] = (this[i][5] - box.x) * width / box.width + box.x;\n this[i][6] = (this[i][6] - box.y) * height / box.height + box.y;\n }\n } else if (l === 'A') {\n // resize radii\n this[i][1] = this[i][1] * width / box.width;\n this[i][2] = this[i][2] * height / box.height; // move position values\n\n this[i][6] = (this[i][6] - box.x) * width / box.width + box.x;\n this[i][7] = (this[i][7] - box.y) * height / box.height + box.y;\n }\n }\n\n return this;\n },\n\n // Test if the passed path array use the same path data commands as this path array\n equalCommands(pathArray) {\n var i, il, equalCommands;\n pathArray = new PathArray(pathArray);\n equalCommands = this.length === pathArray.length;\n\n for (i = 0, il = this.length; equalCommands && i < il; i++) {\n equalCommands = this[i][0] === pathArray[i][0];\n }\n\n return equalCommands;\n },\n\n // Make path array morphable\n morph(pathArray) {\n pathArray = new PathArray(pathArray);\n\n if (this.equalCommands(pathArray)) {\n this.destination = pathArray;\n } else {\n this.destination = null;\n }\n\n return this;\n },\n\n // Get morphed path array at given position\n at(pos) {\n // make sure a destination is defined\n if (!this.destination) return this;\n var sourceArray = this;\n var destinationArray = this.destination.value;\n var array = [];\n var pathArray = new PathArray();\n var i, il, j, jl; // Animate has specified in the SVG spec\n // See: https://www.w3.org/TR/SVG11/paths.html#PathElement\n\n for (i = 0, il = sourceArray.length; i < il; i++) {\n array[i] = [sourceArray[i][0]];\n\n for (j = 1, jl = sourceArray[i].length; j < jl; j++) {\n array[i][j] = sourceArray[i][j] + (destinationArray[i][j] - sourceArray[i][j]) * pos;\n } // For the two flags of the elliptical arc command, the SVG spec say:\n // Flags and booleans are interpolated as fractions between zero and one, with any non-zero value considered to be a value of one/true\n // Elliptical arc command as an array followed by corresponding indexes:\n // ['A', rx, ry, x-axis-rotation, large-arc-flag, sweep-flag, x, y]\n // 0 1 2 3 4 5 6 7\n\n\n if (array[i][0] === 'A') {\n array[i][4] = +(array[i][4] !== 0);\n array[i][5] = +(array[i][5] !== 0);\n }\n } // Directly modify the value of a path array, this is done this way for performance\n\n\n pathArray.value = array;\n return pathArray;\n },\n\n // Absolutize and parse path to array\n parse(array = [['M', 0, 0]]) {\n // if it's already a patharray, no need to parse it\n if (array instanceof PathArray) return array; // prepare for parsing\n\n var s;\n var paramCnt = {\n 'M': 2,\n 'L': 2,\n 'H': 1,\n 'V': 1,\n 'C': 6,\n 'S': 4,\n 'Q': 4,\n 'T': 2,\n 'A': 7,\n 'Z': 0\n };\n\n if (typeof array === 'string') {\n array = array.replace(numbersWithDots, pathRegReplace) // convert 45.123.123 to 45.123 .123\n .replace(pathLetters, ' $& ') // put some room between letters and numbers\n .replace(hyphen, '$1 -') // add space before hyphen\n .trim() // trim\n .split(delimiter); // split into array\n } else {\n array = array.reduce(function (prev, curr) {\n return [].concat.call(prev, curr);\n }, []);\n } // array now is an array containing all parts of a path e.g. ['M', '0', '0', 'L', '30', '30' ...]\n\n\n var result = [];\n var p = new Point();\n var p0 = new Point();\n var index = 0;\n var len = array.length;\n\n do {\n // Test if we have a path letter\n if (isPathLetter.test(array[index])) {\n s = array[index];\n ++index; // If last letter was a move command and we got no new, it defaults to [L]ine\n } else if (s === 'M') {\n s = 'L';\n } else if (s === 'm') {\n s = 'l';\n }\n\n result.push(pathHandlers[s].call(null, array.slice(index, index = index + paramCnt[s.toUpperCase()]).map(parseFloat), p, p0));\n } while (len > index);\n\n return result;\n },\n\n // Get bounding box of path\n bbox() {\n parser().path.setAttribute('d', this.toString());\n return parser.nodes.path.getBBox();\n }\n\n});\n\nclass Morphable {\n constructor(stepper) {\n this._stepper = stepper || new Ease('-');\n this._from = null;\n this._to = null;\n this._type = null;\n this._context = null;\n this._morphObj = null;\n }\n\n from(val) {\n if (val == null) {\n return this._from;\n }\n\n this._from = this._set(val);\n return this;\n }\n\n to(val) {\n if (val == null) {\n return this._to;\n }\n\n this._to = this._set(val);\n return this;\n }\n\n type(type) {\n // getter\n if (type == null) {\n return this._type;\n } // setter\n\n\n this._type = type;\n return this;\n }\n\n _set(value) {\n if (!this._type) {\n var type = typeof value;\n\n if (type === 'number') {\n this.type(SVGNumber);\n } else if (type === 'string') {\n if (Color.isColor(value)) {\n this.type(Color);\n } else if (delimiter.test(value)) {\n this.type(pathLetters.test(value) ? PathArray : SVGArray);\n } else if (numberAndUnit.test(value)) {\n this.type(SVGNumber);\n } else {\n this.type(NonMorphable);\n }\n } else if (morphableTypes.indexOf(value.constructor) > -1) {\n this.type(value.constructor);\n } else if (Array.isArray(value)) {\n this.type(SVGArray);\n } else if (type === 'object') {\n this.type(ObjectBag);\n } else {\n this.type(NonMorphable);\n }\n }\n\n var result = new this._type(value);\n\n if (this._type === Color) {\n result = this._to ? result[this._to[4]]() : this._from ? result[this._from[4]]() : result;\n }\n\n result = result.toArray();\n this._morphObj = this._morphObj || new this._type();\n this._context = this._context || Array.apply(null, Array(result.length)).map(Object).map(function (o) {\n o.done = true;\n return o;\n });\n return result;\n }\n\n stepper(stepper) {\n if (stepper == null) return this._stepper;\n this._stepper = stepper;\n return this;\n }\n\n done() {\n var complete = this._context.map(this._stepper.done).reduce(function (last, curr) {\n return last && curr;\n }, true);\n\n return complete;\n }\n\n at(pos) {\n var _this = this;\n\n return this._morphObj.fromArray(this._from.map(function (i, index) {\n return _this._stepper.step(i, _this._to[index], pos, _this._context[index], _this._context);\n }));\n }\n\n}\nclass NonMorphable {\n constructor(...args) {\n this.init(...args);\n }\n\n init(val) {\n val = Array.isArray(val) ? val[0] : val;\n this.value = val;\n return this;\n }\n\n valueOf() {\n return this.value;\n }\n\n toArray() {\n return [this.value];\n }\n\n}\nclass TransformBag {\n constructor(...args) {\n this.init(...args);\n }\n\n init(obj) {\n if (Array.isArray(obj)) {\n obj = {\n scaleX: obj[0],\n scaleY: obj[1],\n shear: obj[2],\n rotate: obj[3],\n translateX: obj[4],\n translateY: obj[5],\n originX: obj[6],\n originY: obj[7]\n };\n }\n\n Object.assign(this, TransformBag.defaults, obj);\n return this;\n }\n\n toArray() {\n var v = this;\n return [v.scaleX, v.scaleY, v.shear, v.rotate, v.translateX, v.translateY, v.originX, v.originY];\n }\n\n}\nTransformBag.defaults = {\n scaleX: 1,\n scaleY: 1,\n shear: 0,\n rotate: 0,\n translateX: 0,\n translateY: 0,\n originX: 0,\n originY: 0\n};\nclass ObjectBag {\n constructor(...args) {\n this.init(...args);\n }\n\n init(objOrArr) {\n this.values = [];\n\n if (Array.isArray(objOrArr)) {\n this.values = objOrArr;\n return;\n }\n\n objOrArr = objOrArr || {};\n var entries = [];\n\n for (let i in objOrArr) {\n entries.push([i, objOrArr[i]]);\n }\n\n entries.sort((a, b) => {\n return a[0] - b[0];\n });\n this.values = entries.reduce((last, curr) => last.concat(curr), []);\n return this;\n }\n\n valueOf() {\n var obj = {};\n var arr = this.values;\n\n for (var i = 0, len = arr.length; i < len; i += 2) {\n obj[arr[i]] = arr[i + 1];\n }\n\n return obj;\n }\n\n toArray() {\n return this.values;\n }\n\n}\nconst morphableTypes = [NonMorphable, TransformBag, ObjectBag];\nfunction registerMorphableType(type = []) {\n morphableTypes.push(...[].concat(type));\n}\nfunction makeMorphable() {\n extend(morphableTypes, {\n to(val) {\n return new Morphable().type(this.constructor).from(this.valueOf()).to(val);\n },\n\n fromArray(arr) {\n this.init(arr);\n return this;\n }\n\n });\n}\n\nclass Path extends Shape {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('path', node), node);\n } // Get array\n\n\n array() {\n return this._array || (this._array = new PathArray(this.attr('d')));\n } // Plot new path\n\n\n plot(d) {\n return d == null ? this.array() : this.clear().attr('d', typeof d === 'string' ? d : this._array = new PathArray(d));\n } // Clear array cache\n\n\n clear() {\n delete this._array;\n return this;\n } // Move by left top corner\n\n\n move(x, y) {\n return this.attr('d', this.array().move(x, y));\n } // Move by left top corner over x-axis\n\n\n x(x) {\n return x == null ? this.bbox().x : this.move(x, this.bbox().y);\n } // Move by left top corner over y-axis\n\n\n y(y) {\n return y == null ? this.bbox().y : this.move(this.bbox().x, y);\n } // Set element size to given width and height\n\n\n size(width, height) {\n var p = proportionalSize(this, width, height);\n return this.attr('d', this.array().size(p.width, p.height));\n } // Set width of element\n\n\n width(width) {\n return width == null ? this.bbox().width : this.size(width, this.bbox().height);\n } // Set height of element\n\n\n height(height) {\n return height == null ? this.bbox().height : this.size(this.bbox().width, height);\n }\n\n targets() {\n return baseFind('svg textpath [href*=\"' + this.id() + '\"]');\n }\n\n} // Define morphable array\n\nPath.prototype.MorphArray = PathArray; // Add parent method\n\nregisterMethods({\n Container: {\n // Create a wrapped path element\n path: wrapWithAttrCheck(function (d) {\n // make sure plot is called as a setter\n return this.put(new Path()).plot(d || new PathArray());\n })\n }\n});\nregister(Path);\n\nfunction array() {\n return this._array || (this._array = new PointArray(this.attr('points')));\n} // Plot new path\n\nfunction plot(p) {\n return p == null ? this.array() : this.clear().attr('points', typeof p === 'string' ? p : this._array = new PointArray(p));\n} // Clear array cache\n\nfunction clear() {\n delete this._array;\n return this;\n} // Move by left top corner\n\nfunction move(x, y) {\n return this.attr('points', this.array().move(x, y));\n} // Set element size to given width and height\n\nfunction size(width, height) {\n let p = proportionalSize(this, width, height);\n return this.attr('points', this.array().size(p.width, p.height));\n}\n\nvar poly = ({\n array: array,\n plot: plot,\n clear: clear,\n move: move,\n size: size\n});\n\nclass Polygon extends Shape {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('polygon', node), node);\n }\n\n}\nregisterMethods({\n Container: {\n // Create a wrapped polygon element\n polygon: wrapWithAttrCheck(function (p) {\n // make sure plot is called as a setter\n return this.put(new Polygon()).plot(p || new PointArray());\n })\n }\n});\nextend(Polygon, pointed);\nextend(Polygon, poly);\nregister(Polygon);\n\nclass Polyline extends Shape {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('polyline', node), node);\n }\n\n}\nregisterMethods({\n Container: {\n // Create a wrapped polygon element\n polyline: wrapWithAttrCheck(function (p) {\n // make sure plot is called as a setter\n return this.put(new Polyline()).plot(p || new PointArray());\n })\n }\n});\nextend(Polyline, pointed);\nextend(Polyline, poly);\nregister(Polyline);\n\nclass Rect extends Shape {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('rect', node), node);\n }\n\n}\nextend(Rect, {\n rx,\n ry\n});\nregisterMethods({\n Container: {\n // Create a rect element\n rect: wrapWithAttrCheck(function (width$$1, height$$1) {\n return this.put(new Rect()).size(width$$1, height$$1);\n })\n }\n});\nregister(Rect);\n\nclass Queue {\n constructor() {\n this._first = null;\n this._last = null;\n }\n\n push(value) {\n // An item stores an id and the provided value\n var item = value.next ? value : {\n value: value,\n next: null,\n prev: null // Deal with the queue being empty or populated\n\n };\n\n if (this._last) {\n item.prev = this._last;\n this._last.next = item;\n this._last = item;\n } else {\n this._last = item;\n this._first = item;\n } // Return the current item\n\n\n return item;\n }\n\n shift() {\n // Check if we have a value\n var remove = this._first;\n if (!remove) return null; // If we do, remove it and relink things\n\n this._first = remove.next;\n if (this._first) this._first.prev = null;\n this._last = this._first ? this._last : null;\n return remove.value;\n } // Shows us the first item in the list\n\n\n first() {\n return this._first && this._first.value;\n } // Shows us the last item in the list\n\n\n last() {\n return this._last && this._last.value;\n } // Removes the item that was returned from the push\n\n\n remove(item) {\n // Relink the previous item\n if (item.prev) item.prev.next = item.next;\n if (item.next) item.next.prev = item.prev;\n if (item === this._last) this._last = item.prev;\n if (item === this._first) this._first = item.next; // Invalidate item\n\n item.prev = null;\n item.next = null;\n }\n\n}\n\nconst Animator = {\n nextDraw: null,\n frames: new Queue(),\n timeouts: new Queue(),\n immediates: new Queue(),\n timer: () => globals.window.performance || globals.window.Date,\n transforms: [],\n\n frame(fn) {\n // Store the node\n var node = Animator.frames.push({\n run: fn\n }); // Request an animation frame if we don't have one\n\n if (Animator.nextDraw === null) {\n Animator.nextDraw = globals.window.requestAnimationFrame(Animator._draw);\n } // Return the node so we can remove it easily\n\n\n return node;\n },\n\n timeout(fn, delay) {\n delay = delay || 0; // Work out when the event should fire\n\n var time = Animator.timer().now() + delay; // Add the timeout to the end of the queue\n\n var node = Animator.timeouts.push({\n run: fn,\n time: time\n }); // Request another animation frame if we need one\n\n if (Animator.nextDraw === null) {\n Animator.nextDraw = globals.window.requestAnimationFrame(Animator._draw);\n }\n\n return node;\n },\n\n immediate(fn) {\n // Add the immediate fn to the end of the queue\n var node = Animator.immediates.push(fn); // Request another animation frame if we need one\n\n if (Animator.nextDraw === null) {\n Animator.nextDraw = globals.window.requestAnimationFrame(Animator._draw);\n }\n\n return node;\n },\n\n cancelFrame(node) {\n node != null && Animator.frames.remove(node);\n },\n\n clearTimeout(node) {\n node != null && Animator.timeouts.remove(node);\n },\n\n cancelImmediate(node) {\n node != null && Animator.immediates.remove(node);\n },\n\n _draw(now) {\n // Run all the timeouts we can run, if they are not ready yet, add them\n // to the end of the queue immediately! (bad timeouts!!! [sarcasm])\n var nextTimeout = null;\n var lastTimeout = Animator.timeouts.last();\n\n while (nextTimeout = Animator.timeouts.shift()) {\n // Run the timeout if its time, or push it to the end\n if (now >= nextTimeout.time) {\n nextTimeout.run();\n } else {\n Animator.timeouts.push(nextTimeout);\n } // If we hit the last item, we should stop shifting out more items\n\n\n if (nextTimeout === lastTimeout) break;\n } // Run all of the animation frames\n\n\n var nextFrame = null;\n var lastFrame = Animator.frames.last();\n\n while (nextFrame !== lastFrame && (nextFrame = Animator.frames.shift())) {\n nextFrame.run(now);\n }\n\n var nextImmediate = null;\n\n while (nextImmediate = Animator.immediates.shift()) {\n nextImmediate();\n } // If we have remaining timeouts or frames, draw until we don't anymore\n\n\n Animator.nextDraw = Animator.timeouts.first() || Animator.frames.first() ? globals.window.requestAnimationFrame(Animator._draw) : null;\n }\n\n};\n\nvar makeSchedule = function (runnerInfo) {\n var start = runnerInfo.start;\n var duration = runnerInfo.runner.duration();\n var end = start + duration;\n return {\n start: start,\n duration: duration,\n end: end,\n runner: runnerInfo.runner\n };\n};\n\nconst defaultSource = function () {\n let w = globals.window;\n return (w.performance || w.Date).now();\n};\n\nclass Timeline extends EventTarget {\n // Construct a new timeline on the given element\n constructor(timeSource = defaultSource) {\n super();\n this._timeSource = timeSource; // Store the timing variables\n\n this._startTime = 0;\n this._speed = 1.0; // Determines how long a runner is hold in memory. Can be a dt or true/false\n\n this._persist = 0; // Keep track of the running animations and their starting parameters\n\n this._nextFrame = null;\n this._paused = true;\n this._runners = [];\n this._runnerIds = [];\n this._lastRunnerId = -1;\n this._time = 0;\n this._lastSourceTime = 0;\n this._lastStepTime = 0; // Make sure that step is always called in class context\n\n this._step = this._stepFn.bind(this, false);\n this._stepImmediate = this._stepFn.bind(this, true);\n } // schedules a runner on the timeline\n\n\n schedule(runner, delay, when) {\n if (runner == null) {\n return this._runners.map(makeSchedule);\n } // The start time for the next animation can either be given explicitly,\n // derived from the current timeline time or it can be relative to the\n // last start time to chain animations direclty\n\n\n var absoluteStartTime = 0;\n var endTime = this.getEndTime();\n delay = delay || 0; // Work out when to start the animation\n\n if (when == null || when === 'last' || when === 'after') {\n // Take the last time and increment\n absoluteStartTime = endTime;\n } else if (when === 'absolute' || when === 'start') {\n absoluteStartTime = delay;\n delay = 0;\n } else if (when === 'now') {\n absoluteStartTime = this._time;\n } else if (when === 'relative') {\n let runnerInfo = this._runners[runner.id];\n\n if (runnerInfo) {\n absoluteStartTime = runnerInfo.start + delay;\n delay = 0;\n }\n } else {\n throw new Error('Invalid value for the \"when\" parameter');\n } // Manage runner\n\n\n runner.unschedule();\n runner.timeline(this);\n const persist = runner.persist();\n const runnerInfo = {\n persist: persist === null ? this._persist : persist,\n start: absoluteStartTime + delay,\n runner\n };\n this._lastRunnerId = runner.id;\n\n this._runners.push(runnerInfo);\n\n this._runners.sort((a, b) => a.start - b.start);\n\n this._runnerIds = this._runners.map(info => info.runner.id);\n\n this.updateTime()._continue();\n\n return this;\n } // Remove the runner from this timeline\n\n\n unschedule(runner) {\n var index = this._runnerIds.indexOf(runner.id);\n\n if (index < 0) return this;\n\n this._runners.splice(index, 1);\n\n this._runnerIds.splice(index, 1);\n\n runner.timeline(null);\n return this;\n } // Calculates the end of the timeline\n\n\n getEndTime() {\n var lastRunnerInfo = this._runners[this._runnerIds.indexOf(this._lastRunnerId)];\n\n var lastDuration = lastRunnerInfo ? lastRunnerInfo.runner.duration() : 0;\n var lastStartTime = lastRunnerInfo ? lastRunnerInfo.start : 0;\n return lastStartTime + lastDuration;\n } // Makes sure, that after pausing the time doesn't jump\n\n\n updateTime() {\n if (!this.active()) {\n this._lastSourceTime = this._timeSource();\n }\n\n return this;\n }\n\n play() {\n // Now make sure we are not paused and continue the animation\n this._paused = false;\n return this.updateTime()._continue();\n }\n\n pause() {\n this._paused = true;\n return this._continue();\n }\n\n stop() {\n // Go to start and pause\n this.time(0);\n return this.pause();\n }\n\n finish() {\n // Go to end and pause\n this.time(this.getEndTime() + 1);\n return this.pause();\n }\n\n speed(speed) {\n if (speed == null) return this._speed;\n this._speed = speed;\n return this;\n }\n\n reverse(yes) {\n var currentSpeed = this.speed();\n if (yes == null) return this.speed(-currentSpeed);\n var positive = Math.abs(currentSpeed);\n return this.speed(yes ? positive : -positive);\n }\n\n seek(dt) {\n return this.time(this._time + dt);\n }\n\n time(time) {\n if (time == null) return this._time;\n this._time = time;\n return this._continue(true);\n }\n\n persist(dtOrForever) {\n if (dtOrForever == null) return this._persist;\n this._persist = dtOrForever;\n return this;\n }\n\n source(fn) {\n if (fn == null) return this._timeSource;\n this._timeSource = fn;\n return this;\n }\n\n _stepFn(immediateStep = false) {\n // Get the time delta from the last time and update the time\n var time = this._timeSource();\n\n var dtSource = time - this._lastSourceTime;\n if (immediateStep) dtSource = 0;\n var dtTime = this._speed * dtSource + (this._time - this._lastStepTime);\n this._lastSourceTime = time; // Only update the time if we use the timeSource.\n // Otherwise use the current time\n\n if (!immediateStep) {\n // Update the time\n this._time += dtTime;\n this._time = this._time < 0 ? 0 : this._time;\n }\n\n this._lastStepTime = this._time;\n this.fire('time', this._time); // This is for the case that the timeline was seeked so that the time\n // is now before the startTime of the runner. Thats why we need to set\n // the runner to position 0\n // FIXME:\n // However, reseting in insertion order leads to bugs. Considering the case,\n // where 2 runners change the same attriute but in different times,\n // reseting both of them will lead to the case where the later defined\n // runner always wins the reset even if the other runner started earlier\n // and therefore should win the attribute battle\n // this can be solved by reseting them backwards\n\n for (var k = this._runners.length; k--;) {\n // Get and run the current runner and ignore it if its inactive\n let runnerInfo = this._runners[k];\n let runner = runnerInfo.runner; // Make sure that we give the actual difference\n // between runner start time and now\n\n let dtToStart = this._time - runnerInfo.start; // Dont run runner if not started yet\n // and try to reset it\n\n if (dtToStart <= 0) {\n runner.reset();\n }\n } // Run all of the runners directly\n\n\n var runnersLeft = false;\n\n for (var i = 0, len = this._runners.length; i < len; i++) {\n // Get and run the current runner and ignore it if its inactive\n let runnerInfo = this._runners[i];\n let runner = runnerInfo.runner;\n let dt = dtTime; // Make sure that we give the actual difference\n // between runner start time and now\n\n let dtToStart = this._time - runnerInfo.start; // Dont run runner if not started yet\n\n if (dtToStart <= 0) {\n runnersLeft = true;\n continue;\n } else if (dtToStart < dt) {\n // Adjust dt to make sure that animation is on point\n dt = dtToStart;\n }\n\n if (!runner.active()) continue; // If this runner is still going, signal that we need another animation\n // frame, otherwise, remove the completed runner\n\n var finished = runner.step(dt).done;\n\n if (!finished) {\n runnersLeft = true; // continue\n } else if (runnerInfo.persist !== true) {\n // runner is finished. And runner might get removed\n var endTime = runner.duration() - runner.time() + this._time;\n\n if (endTime + runnerInfo.persist < this._time) {\n // Delete runner and correct index\n runner.unschedule();\n --i;\n --len;\n }\n }\n } // Basically: we continue when there are runners right from us in time\n // when -->, and when runners are left from us when <--\n\n\n if (runnersLeft && !(this._speed < 0 && this._time === 0) || this._runnerIds.length && this._speed < 0 && this._time > 0) {\n this._continue();\n } else {\n this.pause();\n this.fire('finished');\n }\n\n return this;\n } // Checks if we are running and continues the animation\n\n\n _continue(immediateStep = false) {\n Animator.cancelFrame(this._nextFrame);\n this._nextFrame = null;\n if (immediateStep) return this._stepImmediate();\n if (this._paused) return this;\n this._nextFrame = Animator.frame(this._step);\n return this;\n }\n\n active() {\n return !!this._nextFrame;\n }\n\n}\nregisterMethods({\n Element: {\n timeline: function (timeline) {\n if (timeline == null) {\n this._timeline = this._timeline || new Timeline();\n return this._timeline;\n } else {\n this._timeline = timeline;\n return this;\n }\n }\n }\n});\n\nclass Runner extends EventTarget {\n constructor(options) {\n super(); // Store a unique id on the runner, so that we can identify it later\n\n this.id = Runner.id++; // Ensure a default value\n\n options = options == null ? timeline.duration : options; // Ensure that we get a controller\n\n options = typeof options === 'function' ? new Controller(options) : options; // Declare all of the variables\n\n this._element = null;\n this._timeline = null;\n this.done = false;\n this._queue = []; // Work out the stepper and the duration\n\n this._duration = typeof options === 'number' && options;\n this._isDeclarative = options instanceof Controller;\n this._stepper = this._isDeclarative ? options : new Ease(); // We copy the current values from the timeline because they can change\n\n this._history = {}; // Store the state of the runner\n\n this.enabled = true;\n this._time = 0;\n this._lastTime = 0; // At creation, the runner is in reseted state\n\n this._reseted = true; // Save transforms applied to this runner\n\n this.transforms = new Matrix();\n this.transformId = 1; // Looping variables\n\n this._haveReversed = false;\n this._reverse = false;\n this._loopsDone = 0;\n this._swing = false;\n this._wait = 0;\n this._times = 1;\n this._frameId = null; // Stores how long a runner is stored after beeing done\n\n this._persist = this._isDeclarative ? true : null;\n }\n /*\r\n Runner Definitions\r\n ==================\r\n These methods help us define the runtime behaviour of the Runner or they\r\n help us make new runners from the current runner\r\n */\n\n\n element(element) {\n if (element == null) return this._element;\n this._element = element;\n\n element._prepareRunner();\n\n return this;\n }\n\n timeline(timeline$$1) {\n // check explicitly for undefined so we can set the timeline to null\n if (typeof timeline$$1 === 'undefined') return this._timeline;\n this._timeline = timeline$$1;\n return this;\n }\n\n animate(duration, delay, when) {\n var o = Runner.sanitise(duration, delay, when);\n var runner = new Runner(o.duration);\n if (this._timeline) runner.timeline(this._timeline);\n if (this._element) runner.element(this._element);\n return runner.loop(o).schedule(delay, when);\n }\n\n schedule(timeline$$1, delay, when) {\n // The user doesn't need to pass a timeline if we already have one\n if (!(timeline$$1 instanceof Timeline)) {\n when = delay;\n delay = timeline$$1;\n timeline$$1 = this.timeline();\n } // If there is no timeline, yell at the user...\n\n\n if (!timeline$$1) {\n throw Error('Runner cannot be scheduled without timeline');\n } // Schedule the runner on the timeline provided\n\n\n timeline$$1.schedule(this, delay, when);\n return this;\n }\n\n unschedule() {\n var timeline$$1 = this.timeline();\n timeline$$1 && timeline$$1.unschedule(this);\n return this;\n }\n\n loop(times, swing, wait) {\n // Deal with the user passing in an object\n if (typeof times === 'object') {\n swing = times.swing;\n wait = times.wait;\n times = times.times;\n } // Sanitise the values and store them\n\n\n this._times = times || Infinity;\n this._swing = swing || false;\n this._wait = wait || 0; // Allow true to be passed\n\n if (this._times === true) {\n this._times = Infinity;\n }\n\n return this;\n }\n\n delay(delay) {\n return this.animate(0, delay);\n }\n /*\r\n Basic Functionality\r\n ===================\r\n These methods allow us to attach basic functions to the runner directly\r\n */\n\n\n queue(initFn, runFn, retargetFn, isTransform) {\n this._queue.push({\n initialiser: initFn || noop,\n runner: runFn || noop,\n retarget: retargetFn,\n isTransform: isTransform,\n initialised: false,\n finished: false\n });\n\n var timeline$$1 = this.timeline();\n timeline$$1 && this.timeline()._continue();\n return this;\n }\n\n during(fn) {\n return this.queue(null, fn);\n }\n\n after(fn) {\n return this.on('finished', fn);\n }\n /*\r\n Runner animation methods\r\n ========================\r\n Control how the animation plays\r\n */\n\n\n time(time) {\n if (time == null) {\n return this._time;\n }\n\n let dt = time - this._time;\n this.step(dt);\n return this;\n }\n\n duration() {\n return this._times * (this._wait + this._duration) - this._wait;\n }\n\n loops(p) {\n var loopDuration = this._duration + this._wait;\n\n if (p == null) {\n var loopsDone = Math.floor(this._time / loopDuration);\n var relativeTime = this._time - loopsDone * loopDuration;\n var position = relativeTime / this._duration;\n return Math.min(loopsDone + position, this._times);\n }\n\n var whole = Math.floor(p);\n var partial = p % 1;\n var time = loopDuration * whole + this._duration * partial;\n return this.time(time);\n }\n\n persist(dtOrForever) {\n if (dtOrForever == null) return this._persist;\n this._persist = dtOrForever;\n return this;\n }\n\n position(p) {\n // Get all of the variables we need\n var x$$1 = this._time;\n var d = this._duration;\n var w = this._wait;\n var t = this._times;\n var s = this._swing;\n var r = this._reverse;\n var position;\n\n if (p == null) {\n /*\r\n This function converts a time to a position in the range [0, 1]\r\n The full explanation can be found in this desmos demonstration\r\n https://www.desmos.com/calculator/u4fbavgche\r\n The logic is slightly simplified here because we can use booleans\r\n */\n // Figure out the value without thinking about the start or end time\n const f = function (x$$1) {\n var swinging = s * Math.floor(x$$1 % (2 * (w + d)) / (w + d));\n var backwards = swinging && !r || !swinging && r;\n var uncliped = Math.pow(-1, backwards) * (x$$1 % (w + d)) / d + backwards;\n var clipped = Math.max(Math.min(uncliped, 1), 0);\n return clipped;\n }; // Figure out the value by incorporating the start time\n\n\n var endTime = t * (w + d) - w;\n position = x$$1 <= 0 ? Math.round(f(1e-5)) : x$$1 < endTime ? f(x$$1) : Math.round(f(endTime - 1e-5));\n return position;\n } // Work out the loops done and add the position to the loops done\n\n\n var loopsDone = Math.floor(this.loops());\n var swingForward = s && loopsDone % 2 === 0;\n var forwards = swingForward && !r || r && swingForward;\n position = loopsDone + (forwards ? p : 1 - p);\n return this.loops(position);\n }\n\n progress(p) {\n if (p == null) {\n return Math.min(1, this._time / this.duration());\n }\n\n return this.time(p * this.duration());\n }\n\n step(dt) {\n // If we are inactive, this stepper just gets skipped\n if (!this.enabled) return this; // Update the time and get the new position\n\n dt = dt == null ? 16 : dt;\n this._time += dt;\n var position = this.position(); // Figure out if we need to run the stepper in this frame\n\n var running = this._lastPosition !== position && this._time >= 0;\n this._lastPosition = position; // Figure out if we just started\n\n var duration = this.duration();\n var justStarted = this._lastTime <= 0 && this._time > 0;\n var justFinished = this._lastTime < duration && this._time >= duration;\n this._lastTime = this._time;\n\n if (justStarted) {\n this.fire('start', this);\n } // Work out if the runner is finished set the done flag here so animations\n // know, that they are running in the last step (this is good for\n // transformations which can be merged)\n\n\n var declarative = this._isDeclarative;\n this.done = !declarative && !justFinished && this._time >= duration; // Runner is running. So its not in reseted state anymore\n\n this._reseted = false; // Call initialise and the run function\n\n if (running || declarative) {\n this._initialise(running); // clear the transforms on this runner so they dont get added again and again\n\n\n this.transforms = new Matrix();\n\n var converged = this._run(declarative ? dt : position);\n\n this.fire('step', this);\n } // correct the done flag here\n // declaritive animations itself know when they converged\n\n\n this.done = this.done || converged && declarative;\n\n if (justFinished) {\n this.fire('finished', this);\n }\n\n return this;\n }\n\n reset() {\n if (this._reseted) return this;\n this.time(0);\n this._reseted = true;\n return this;\n }\n\n finish() {\n return this.step(Infinity);\n }\n\n reverse(reverse) {\n this._reverse = reverse == null ? !this._reverse : reverse;\n return this;\n }\n\n ease(fn) {\n this._stepper = new Ease(fn);\n return this;\n }\n\n active(enabled) {\n if (enabled == null) return this.enabled;\n this.enabled = enabled;\n return this;\n }\n /*\r\n Private Methods\r\n ===============\r\n Methods that shouldn't be used externally\r\n */\n // Save a morpher to the morpher list so that we can retarget it later\n\n\n _rememberMorpher(method, morpher) {\n this._history[method] = {\n morpher: morpher,\n caller: this._queue[this._queue.length - 1] // We have to resume the timeline in case a controller\n // is already done without beeing ever run\n // This can happen when e.g. this is done:\n // anim = el.animate(new SVG.Spring)\n // and later\n // anim.move(...)\n\n };\n\n if (this._isDeclarative) {\n var timeline$$1 = this.timeline();\n timeline$$1 && timeline$$1.play();\n }\n } // Try to set the target for a morpher if the morpher exists, otherwise\n // do nothing and return false\n\n\n _tryRetarget(method, target, extra) {\n if (this._history[method]) {\n // if the last method wasnt even initialised, throw it away\n if (!this._history[method].caller.initialised) {\n let index = this._queue.indexOf(this._history[method].caller);\n\n this._queue.splice(index, 1);\n\n return false;\n } // for the case of transformations, we use the special retarget function\n // which has access to the outer scope\n\n\n if (this._history[method].caller.retarget) {\n this._history[method].caller.retarget(target, extra); // for everything else a simple morpher change is sufficient\n\n } else {\n this._history[method].morpher.to(target);\n }\n\n this._history[method].caller.finished = false;\n var timeline$$1 = this.timeline();\n timeline$$1 && timeline$$1.play();\n return true;\n }\n\n return false;\n } // Run each initialise function in the runner if required\n\n\n _initialise(running) {\n // If we aren't running, we shouldn't initialise when not declarative\n if (!running && !this._isDeclarative) return; // Loop through all of the initialisers\n\n for (var i = 0, len = this._queue.length; i < len; ++i) {\n // Get the current initialiser\n var current = this._queue[i]; // Determine whether we need to initialise\n\n var needsIt = this._isDeclarative || !current.initialised && running;\n running = !current.finished; // Call the initialiser if we need to\n\n if (needsIt && running) {\n current.initialiser.call(this);\n current.initialised = true;\n }\n }\n } // Run each run function for the position or dt given\n\n\n _run(positionOrDt) {\n // Run all of the _queue directly\n var allfinished = true;\n\n for (var i = 0, len = this._queue.length; i < len; ++i) {\n // Get the current function to run\n var current = this._queue[i]; // Run the function if its not finished, we keep track of the finished\n // flag for the sake of declarative _queue\n\n var converged = current.runner.call(this, positionOrDt);\n current.finished = current.finished || converged === true;\n allfinished = allfinished && current.finished;\n } // We report when all of the constructors are finished\n\n\n return allfinished;\n }\n\n addTransform(transform, index) {\n this.transforms.lmultiplyO(transform);\n return this;\n }\n\n clearTransform() {\n this.transforms = new Matrix();\n return this;\n } // TODO: Keep track of all transformations so that deletion is faster\n\n\n clearTransformsFromQueue() {\n if (!this.done || !this._timeline || !this._timeline._runnerIds.includes(this.id)) {\n this._queue = this._queue.filter(item => {\n return !item.isTransform;\n });\n }\n }\n\n static sanitise(duration, delay, when) {\n // Initialise the default parameters\n var times = 1;\n var swing = false;\n var wait = 0;\n duration = duration || timeline.duration;\n delay = delay || timeline.delay;\n when = when || 'last'; // If we have an object, unpack the values\n\n if (typeof duration === 'object' && !(duration instanceof Stepper)) {\n delay = duration.delay || delay;\n when = duration.when || when;\n swing = duration.swing || swing;\n times = duration.times || times;\n wait = duration.wait || wait;\n duration = duration.duration || timeline.duration;\n }\n\n return {\n duration: duration,\n delay: delay,\n swing: swing,\n times: times,\n wait: wait,\n when: when\n };\n }\n\n}\nRunner.id = 0;\n\nclass FakeRunner {\n constructor(transforms = new Matrix(), id = -1, done = true) {\n this.transforms = transforms;\n this.id = id;\n this.done = done;\n }\n\n clearTransformsFromQueue() {}\n\n}\n\nextend([Runner, FakeRunner], {\n mergeWith(runner) {\n return new FakeRunner(runner.transforms.lmultiply(this.transforms), runner.id);\n }\n\n}); // FakeRunner.emptyRunner = new FakeRunner()\n\nconst lmultiply = (last, curr) => last.lmultiplyO(curr);\n\nconst getRunnerTransform = runner => runner.transforms;\n\nfunction mergeTransforms() {\n // Find the matrix to apply to the element and apply it\n let runners = this._transformationRunners.runners;\n let netTransform = runners.map(getRunnerTransform).reduce(lmultiply, new Matrix());\n this.transform(netTransform);\n\n this._transformationRunners.merge();\n\n if (this._transformationRunners.length() === 1) {\n this._frameId = null;\n }\n}\n\nclass RunnerArray {\n constructor() {\n this.runners = [];\n this.ids = [];\n }\n\n add(runner) {\n if (this.runners.includes(runner)) return;\n let id = runner.id + 1;\n this.runners.push(runner);\n this.ids.push(id);\n return this;\n }\n\n getByID(id) {\n return this.runners[this.ids.indexOf(id + 1)];\n }\n\n remove(id) {\n let index = this.ids.indexOf(id + 1);\n this.ids.splice(index, 1);\n this.runners.splice(index, 1);\n return this;\n }\n\n merge() {\n let lastRunner = null;\n this.runners.forEach((runner, i) => {\n const condition = lastRunner && runner.done && lastRunner.done // don't merge runner when persisted on timeline\n && (!runner._timeline || !runner._timeline._runnerIds.includes(runner.id)) && (!lastRunner._timeline || !lastRunner._timeline._runnerIds.includes(lastRunner.id));\n\n if (condition) {\n // the +1 happens in the function\n this.remove(runner.id);\n this.edit(lastRunner.id, runner.mergeWith(lastRunner));\n }\n\n lastRunner = runner;\n });\n return this;\n }\n\n edit(id, newRunner) {\n let index = this.ids.indexOf(id + 1);\n this.ids.splice(index, 1, id + 1);\n this.runners.splice(index, 1, newRunner);\n return this;\n }\n\n length() {\n return this.ids.length;\n }\n\n clearBefore(id) {\n let deleteCnt = this.ids.indexOf(id + 1) || 1;\n this.ids.splice(0, deleteCnt, 0);\n this.runners.splice(0, deleteCnt, new FakeRunner()).forEach(r => r.clearTransformsFromQueue());\n return this;\n }\n\n}\n\nregisterMethods({\n Element: {\n animate(duration, delay, when) {\n var o = Runner.sanitise(duration, delay, when);\n var timeline$$1 = this.timeline();\n return new Runner(o.duration).loop(o).element(this).timeline(timeline$$1.play()).schedule(delay, when);\n },\n\n delay(by, when) {\n return this.animate(0, by, when);\n },\n\n // this function searches for all runners on the element and deletes the ones\n // which run before the current one. This is because absolute transformations\n // overwfrite anything anyway so there is no need to waste time computing\n // other runners\n _clearTransformRunnersBefore(currentRunner) {\n this._transformationRunners.clearBefore(currentRunner.id);\n },\n\n _currentTransform(current) {\n return this._transformationRunners.runners // we need the equal sign here to make sure, that also transformations\n // on the same runner which execute before the current transformation are\n // taken into account\n .filter(runner => runner.id <= current.id).map(getRunnerTransform).reduce(lmultiply, new Matrix());\n },\n\n _addRunner(runner) {\n this._transformationRunners.add(runner); // Make sure that the runner merge is executed at the very end of\n // all Animator functions. Thats why we use immediate here to execute\n // the merge right after all frames are run\n\n\n Animator.cancelImmediate(this._frameId);\n this._frameId = Animator.immediate(mergeTransforms.bind(this));\n },\n\n _prepareRunner() {\n if (this._frameId == null) {\n this._transformationRunners = new RunnerArray().add(new FakeRunner(new Matrix(this)));\n }\n }\n\n }\n});\nextend(Runner, {\n attr(a, v) {\n return this.styleAttr('attr', a, v);\n },\n\n // Add animatable styles\n css(s, v) {\n return this.styleAttr('css', s, v);\n },\n\n styleAttr(type, name, val) {\n // apply attributes individually\n if (typeof name === 'object') {\n for (var key in name) {\n this.styleAttr(type, key, name[key]);\n }\n\n return this;\n }\n\n var morpher = new Morphable(this._stepper).to(val);\n this.queue(function () {\n morpher = morpher.from(this.element()[type](name));\n }, function (pos) {\n this.element()[type](name, morpher.at(pos));\n return morpher.done();\n });\n return this;\n },\n\n zoom(level, point$$1) {\n if (this._tryRetarget('zoom', to, point$$1)) return this;\n var morpher = new Morphable(this._stepper).to(new SVGNumber(level));\n this.queue(function () {\n morpher = morpher.from(this.element().zoom());\n }, function (pos) {\n this.element().zoom(morpher.at(pos), point$$1);\n return morpher.done();\n }, function (newLevel, newPoint) {\n point$$1 = newPoint;\n morpher.to(newLevel);\n });\n\n this._rememberMorpher('zoom', morpher);\n\n return this;\n },\n\n /**\r\n ** absolute transformations\r\n **/\n //\n // M v -----|-----(D M v = F v)------|-----> T v\n //\n // 1. define the final state (T) and decompose it (once)\n // t = [tx, ty, the, lam, sy, sx]\n // 2. on every frame: pull the current state of all previous transforms\n // (M - m can change)\n // and then write this as m = [tx0, ty0, the0, lam0, sy0, sx0]\n // 3. Find the interpolated matrix F(pos) = m + pos * (t - m)\n // - Note F(0) = M\n // - Note F(1) = T\n // 4. Now you get the delta matrix as a result: D = F * inv(M)\n transform(transforms, relative, affine) {\n // If we have a declarative function, we should retarget it if possible\n relative = transforms.relative || relative;\n\n if (this._isDeclarative && !relative && this._tryRetarget('transform', transforms)) {\n return this;\n } // Parse the parameters\n\n\n var isMatrix = Matrix.isMatrixLike(transforms);\n affine = transforms.affine != null ? transforms.affine : affine != null ? affine : !isMatrix; // Create a morepher and set its type\n\n const morpher = new Morphable(this._stepper).type(affine ? TransformBag : Matrix);\n let origin;\n let element;\n let current;\n let currentAngle;\n let startTransform;\n\n function setup() {\n // make sure element and origin is defined\n element = element || this.element();\n origin = origin || getOrigin(transforms, element);\n startTransform = new Matrix(relative ? undefined : element); // add the runner to the element so it can merge transformations\n\n element._addRunner(this); // Deactivate all transforms that have run so far if we are absolute\n\n\n if (!relative) {\n element._clearTransformRunnersBefore(this);\n }\n }\n\n function run(pos) {\n // clear all other transforms before this in case something is saved\n // on this runner. We are absolute. We dont need these!\n if (!relative) this.clearTransform();\n let {\n x: x$$1,\n y: y$$1\n } = new Point(origin).transform(element._currentTransform(this));\n let target = new Matrix(_objectSpread({}, transforms, {\n origin: [x$$1, y$$1]\n }));\n let start = this._isDeclarative && current ? current : startTransform;\n\n if (affine) {\n target = target.decompose(x$$1, y$$1);\n start = start.decompose(x$$1, y$$1); // Get the current and target angle as it was set\n\n const rTarget = target.rotate;\n const rCurrent = start.rotate; // Figure out the shortest path to rotate directly\n\n const possibilities = [rTarget - 360, rTarget, rTarget + 360];\n const distances = possibilities.map(a => Math.abs(a - rCurrent));\n const shortest = Math.min(...distances);\n const index = distances.indexOf(shortest);\n target.rotate = possibilities[index];\n }\n\n if (relative) {\n // we have to be careful here not to overwrite the rotation\n // with the rotate method of Matrix\n if (!isMatrix) {\n target.rotate = transforms.rotate || 0;\n }\n\n if (this._isDeclarative && currentAngle) {\n start.rotate = currentAngle;\n }\n }\n\n morpher.from(start);\n morpher.to(target);\n let affineParameters = morpher.at(pos);\n currentAngle = affineParameters.rotate;\n current = new Matrix(affineParameters);\n this.addTransform(current);\n\n element._addRunner(this);\n\n return morpher.done();\n }\n\n function retarget(newTransforms) {\n // only get a new origin if it changed since the last call\n if ((newTransforms.origin || 'center').toString() !== (transforms.origin || 'center').toString()) {\n origin = getOrigin(transforms, element);\n } // overwrite the old transformations with the new ones\n\n\n transforms = _objectSpread({}, newTransforms, {\n origin\n });\n }\n\n this.queue(setup, run, retarget, true);\n this._isDeclarative && this._rememberMorpher('transform', morpher);\n return this;\n },\n\n // Animatable x-axis\n x(x$$1, relative) {\n return this._queueNumber('x', x$$1);\n },\n\n // Animatable y-axis\n y(y$$1) {\n return this._queueNumber('y', y$$1);\n },\n\n dx(x$$1) {\n return this._queueNumberDelta('x', x$$1);\n },\n\n dy(y$$1) {\n return this._queueNumberDelta('y', y$$1);\n },\n\n _queueNumberDelta(method, to$$1) {\n to$$1 = new SVGNumber(to$$1); // Try to change the target if we have this method already registerd\n\n if (this._tryRetarget(method, to$$1)) return this; // Make a morpher and queue the animation\n\n var morpher = new Morphable(this._stepper).to(to$$1);\n var from$$1 = null;\n this.queue(function () {\n from$$1 = this.element()[method]();\n morpher.from(from$$1);\n morpher.to(from$$1 + to$$1);\n }, function (pos) {\n this.element()[method](morpher.at(pos));\n return morpher.done();\n }, function (newTo) {\n morpher.to(from$$1 + new SVGNumber(newTo));\n }); // Register the morpher so that if it is changed again, we can retarget it\n\n this._rememberMorpher(method, morpher);\n\n return this;\n },\n\n _queueObject(method, to$$1) {\n // Try to change the target if we have this method already registerd\n if (this._tryRetarget(method, to$$1)) return this; // Make a morpher and queue the animation\n\n var morpher = new Morphable(this._stepper).to(to$$1);\n this.queue(function () {\n morpher.from(this.element()[method]());\n }, function (pos) {\n this.element()[method](morpher.at(pos));\n return morpher.done();\n }); // Register the morpher so that if it is changed again, we can retarget it\n\n this._rememberMorpher(method, morpher);\n\n return this;\n },\n\n _queueNumber(method, value) {\n return this._queueObject(method, new SVGNumber(value));\n },\n\n // Animatable center x-axis\n cx(x$$1) {\n return this._queueNumber('cx', x$$1);\n },\n\n // Animatable center y-axis\n cy(y$$1) {\n return this._queueNumber('cy', y$$1);\n },\n\n // Add animatable move\n move(x$$1, y$$1) {\n return this.x(x$$1).y(y$$1);\n },\n\n // Add animatable center\n center(x$$1, y$$1) {\n return this.cx(x$$1).cy(y$$1);\n },\n\n // Add animatable size\n size(width$$1, height$$1) {\n // animate bbox based size for all other elements\n var box;\n\n if (!width$$1 || !height$$1) {\n box = this._element.bbox();\n }\n\n if (!width$$1) {\n width$$1 = box.width / box.height * height$$1;\n }\n\n if (!height$$1) {\n height$$1 = box.height / box.width * width$$1;\n }\n\n return this.width(width$$1).height(height$$1);\n },\n\n // Add animatable width\n width(width$$1) {\n return this._queueNumber('width', width$$1);\n },\n\n // Add animatable height\n height(height$$1) {\n return this._queueNumber('height', height$$1);\n },\n\n // Add animatable plot\n plot(a, b, c, d) {\n // Lines can be plotted with 4 arguments\n if (arguments.length === 4) {\n return this.plot([a, b, c, d]);\n }\n\n if (this._tryRetarget('plot', a)) return this;\n var morpher = new Morphable(this._stepper).type(this._element.MorphArray).to(a);\n this.queue(function () {\n morpher.from(this._element.array());\n }, function (pos) {\n this._element.plot(morpher.at(pos));\n\n return morpher.done();\n });\n\n this._rememberMorpher('plot', morpher);\n\n return this;\n },\n\n // Add leading method\n leading(value) {\n return this._queueNumber('leading', value);\n },\n\n // Add animatable viewbox\n viewbox(x$$1, y$$1, width$$1, height$$1) {\n return this._queueObject('viewbox', new Box(x$$1, y$$1, width$$1, height$$1));\n },\n\n update(o) {\n if (typeof o !== 'object') {\n return this.update({\n offset: arguments[0],\n color: arguments[1],\n opacity: arguments[2]\n });\n }\n\n if (o.opacity != null) this.attr('stop-opacity', o.opacity);\n if (o.color != null) this.attr('stop-color', o.color);\n if (o.offset != null) this.attr('offset', o.offset);\n return this;\n }\n\n});\nextend(Runner, {\n rx,\n ry,\n from,\n to\n});\nregister(Runner);\n\nclass Svg$1 extends Container {\n constructor(node) {\n super(nodeOrNew('svg', node), node);\n this.namespace();\n }\n\n isRoot() {\n return !this.node.parentNode || !(this.node.parentNode instanceof globals.window.SVGElement) || this.node.parentNode.nodeName === '#document';\n } // Check if this is a root svg\n // If not, call docs from this element\n\n\n root() {\n if (this.isRoot()) return this;\n return super.root();\n } // Add namespaces\n\n\n namespace() {\n if (!this.isRoot()) return this.root().namespace();\n return this.attr({\n xmlns: ns,\n version: '1.1'\n }).attr('xmlns:xlink', xlink, xmlns).attr('xmlns:svgjs', svgjs, xmlns);\n } // Creates and returns defs element\n\n\n defs() {\n if (!this.isRoot()) return this.root().defs();\n return adopt(this.node.getElementsByTagName('defs')[0]) || this.put(new Defs());\n } // custom parent method\n\n\n parent(type) {\n if (this.isRoot()) {\n return this.node.parentNode.nodeName === '#document' ? null : adopt(this.node.parentNode);\n }\n\n return super.parent(type);\n }\n\n clear() {\n // remove children\n while (this.node.hasChildNodes()) {\n this.node.removeChild(this.node.lastChild);\n } // remove defs reference\n\n\n delete this._defs;\n return this;\n }\n\n}\nregisterMethods({\n Container: {\n // Create nested svg document\n nested: wrapWithAttrCheck(function () {\n return this.put(new Svg$1());\n })\n }\n});\nregister(Svg$1, 'Svg', true);\n\nclass Symbol extends Container {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('symbol', node), node);\n }\n\n}\nregisterMethods({\n Container: {\n symbol: wrapWithAttrCheck(function () {\n return this.put(new Symbol());\n })\n }\n});\nregister(Symbol);\n\nfunction plain(text) {\n // clear if build mode is disabled\n if (this._build === false) {\n this.clear();\n } // create text node\n\n\n this.node.appendChild(globals.document.createTextNode(text));\n return this;\n} // Get length of text element\n\nfunction length() {\n return this.node.getComputedTextLength();\n}\n\nvar textable = ({\n plain: plain,\n length: length\n});\n\nclass Text extends Shape {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('text', node), node);\n this.dom.leading = new SVGNumber(1.3); // store leading value for rebuilding\n\n this._rebuild = true; // enable automatic updating of dy values\n\n this._build = false; // disable build mode for adding multiple lines\n // set default font\n\n this.attr('font-family', attrs['font-family']);\n } // Move over x-axis\n\n\n x(x) {\n // act as getter\n if (x == null) {\n return this.attr('x');\n }\n\n return this.attr('x', x);\n } // Move over y-axis\n\n\n y(y) {\n var oy = this.attr('y');\n var o = typeof oy === 'number' ? oy - this.bbox().y : 0; // act as getter\n\n if (y == null) {\n return typeof oy === 'number' ? oy - o : oy;\n }\n\n return this.attr('y', typeof y === 'number' ? y + o : y);\n } // Move center over x-axis\n\n\n cx(x) {\n return x == null ? this.bbox().cx : this.x(x - this.bbox().width / 2);\n } // Move center over y-axis\n\n\n cy(y) {\n return y == null ? this.bbox().cy : this.y(y - this.bbox().height / 2);\n } // Set the text content\n\n\n text(text) {\n // act as getter\n if (text === undefined) {\n var children = this.node.childNodes;\n var firstLine = 0;\n text = '';\n\n for (var i = 0, len = children.length; i < len; ++i) {\n // skip textPaths - they are no lines\n if (children[i].nodeName === 'textPath') {\n if (i === 0) firstLine = 1;\n continue;\n } // add newline if its not the first child and newLined is set to true\n\n\n if (i !== firstLine && children[i].nodeType !== 3 && adopt(children[i]).dom.newLined === true) {\n text += '\\n';\n } // add content of this node\n\n\n text += children[i].textContent;\n }\n\n return text;\n } // remove existing content\n\n\n this.clear().build(true);\n\n if (typeof text === 'function') {\n // call block\n text.call(this, this);\n } else {\n // store text and make sure text is not blank\n text = text.split('\\n'); // build new lines\n\n for (var j = 0, jl = text.length; j < jl; j++) {\n this.tspan(text[j]).newLine();\n }\n } // disable build mode and rebuild lines\n\n\n return this.build(false).rebuild();\n } // Set / get leading\n\n\n leading(value) {\n // act as getter\n if (value == null) {\n return this.dom.leading;\n } // act as setter\n\n\n this.dom.leading = new SVGNumber(value);\n return this.rebuild();\n } // Rebuild appearance type\n\n\n rebuild(rebuild) {\n // store new rebuild flag if given\n if (typeof rebuild === 'boolean') {\n this._rebuild = rebuild;\n } // define position of all lines\n\n\n if (this._rebuild) {\n var self = this;\n var blankLineOffset = 0;\n var leading = this.dom.leading;\n this.each(function () {\n var fontSize = globals.window.getComputedStyle(this.node).getPropertyValue('font-size');\n var dy = leading * new SVGNumber(fontSize);\n\n if (this.dom.newLined) {\n this.attr('x', self.attr('x'));\n\n if (this.text() === '\\n') {\n blankLineOffset += dy;\n } else {\n this.attr('dy', dy + blankLineOffset);\n blankLineOffset = 0;\n }\n }\n });\n this.fire('rebuild');\n }\n\n return this;\n } // Enable / disable build mode\n\n\n build(build) {\n this._build = !!build;\n return this;\n } // overwrite method from parent to set data properly\n\n\n setData(o) {\n this.dom = o;\n this.dom.leading = new SVGNumber(o.leading || 1.3);\n return this;\n }\n\n}\nextend(Text, textable);\nregisterMethods({\n Container: {\n // Create text element\n text: wrapWithAttrCheck(function (text) {\n return this.put(new Text()).text(text);\n }),\n // Create plain text element\n plain: wrapWithAttrCheck(function (text) {\n return this.put(new Text()).plain(text);\n })\n }\n});\nregister(Text);\n\nclass Tspan extends Text {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('tspan', node), node);\n } // Set text content\n\n\n text(text) {\n if (text == null) return this.node.textContent + (this.dom.newLined ? '\\n' : '');\n typeof text === 'function' ? text.call(this, this) : this.plain(text);\n return this;\n } // Shortcut dx\n\n\n dx(dx) {\n return this.attr('dx', dx);\n } // Shortcut dy\n\n\n dy(dy) {\n return this.attr('dy', dy);\n } // Create new line\n\n\n newLine() {\n // fetch text parent\n var t = this.parent(Text); // mark new line\n\n this.dom.newLined = true; // apply new position\n\n return this.dy(t.dom.leading * t.attr('font-size')).attr('x', t.x());\n }\n\n}\nextend(Tspan, textable);\nregisterMethods({\n Tspan: {\n tspan: wrapWithAttrCheck(function (text) {\n var tspan = new Tspan(); // clear if build mode is disabled\n\n if (!this._build) {\n this.clear();\n } // add new tspan\n\n\n this.node.appendChild(tspan.node);\n return tspan.text(text);\n })\n }\n});\nregister(Tspan);\n\nclass ClipPath extends Container {\n constructor(node) {\n super(nodeOrNew('clipPath', node), node);\n } // Unclip all clipped elements and remove itself\n\n\n remove() {\n // unclip all targets\n this.targets().forEach(function (el) {\n el.unclip();\n }); // remove clipPath from parent\n\n return super.remove();\n }\n\n targets() {\n return baseFind('svg [clip-path*=\"' + this.id() + '\"]');\n }\n\n}\nregisterMethods({\n Container: {\n // Create clipping element\n clip: wrapWithAttrCheck(function () {\n return this.defs().put(new ClipPath());\n })\n },\n Element: {\n // Distribute clipPath to svg element\n clipWith(element) {\n // use given clip or create a new one\n let clipper = element instanceof ClipPath ? element : this.parent().clip().add(element); // apply mask\n\n return this.attr('clip-path', 'url(\"#' + clipper.id() + '\")');\n },\n\n // Unclip element\n unclip() {\n return this.attr('clip-path', null);\n },\n\n clipper() {\n return this.reference('clip-path');\n }\n\n }\n});\nregister(ClipPath);\n\nclass G extends Container {\n constructor(node) {\n super(nodeOrNew('g', node), node);\n }\n\n x(x, box = this.bbox()) {\n if (x == null) return box.x;\n this.children().dx(x - box.x);\n return this;\n }\n\n y(y, box = this.bbox()) {\n if (y == null) return box.y;\n this.children().dy(y - box.y);\n return this;\n }\n\n move(x, y) {\n const box = this.bbox();\n return this.x(x, box).y(y, box);\n }\n\n dx(dx) {\n return this.children().dx(dx);\n }\n\n dy(dy) {\n return this.children().dy(dy);\n }\n\n width(width, box = this.bbox()) {\n if (width == null) return box.width;\n const scale = width / box.width;\n this.each(function () {\n const _width = this.width();\n\n const _x = this.x();\n\n this.width(_width * scale);\n this.x((_x - box.x) * scale + box.x);\n });\n return this;\n }\n\n height(height, box = this.bbox()) {\n if (height == null) return box.height;\n const scale = height / box.height;\n this.each(function () {\n const _height = this.height();\n\n const _y = this.y();\n\n this.height(_height * scale);\n this.y((_y - box.y) * scale + box.y);\n });\n return this;\n }\n\n size(width, height) {\n const box = this.bbox();\n const p = proportionalSize(this, width, height, box);\n return this.width(new SVGNumber(p.width), box).height(new SVGNumber(p.height), box);\n }\n\n}\nregisterMethods({\n Element: {\n // Create a group element\n group: wrapWithAttrCheck(function () {\n return this.put(new G());\n })\n }\n});\nregister(G);\n\nclass A extends Container {\n constructor(node) {\n super(nodeOrNew('a', node), node);\n } // Link url\n\n\n to(url) {\n return this.attr('href', url, xlink);\n } // Link target attribute\n\n\n target(target) {\n return this.attr('target', target);\n }\n\n}\nregisterMethods({\n Container: {\n // Create a hyperlink element\n link: wrapWithAttrCheck(function (url) {\n return this.put(new A()).to(url);\n })\n },\n Element: {\n // Create a hyperlink element\n linkTo: function (url) {\n var link = new A();\n\n if (typeof url === 'function') {\n url.call(link, link);\n } else {\n link.to(url);\n }\n\n return this.parent().put(link).put(this);\n }\n }\n});\nregister(A);\n\nclass Mask extends Container {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('mask', node), node);\n } // Unmask all masked elements and remove itself\n\n\n remove() {\n // unmask all targets\n this.targets().forEach(function (el) {\n el.unmask();\n }); // remove mask from parent\n\n return super.remove();\n }\n\n targets() {\n return baseFind('svg [mask*=\"' + this.id() + '\"]');\n }\n\n}\nregisterMethods({\n Container: {\n mask: wrapWithAttrCheck(function () {\n return this.defs().put(new Mask());\n })\n },\n Element: {\n // Distribute mask to svg element\n maskWith(element) {\n // use given mask or create a new one\n var masker = element instanceof Mask ? element : this.parent().mask().add(element); // apply mask\n\n return this.attr('mask', 'url(\"#' + masker.id() + '\")');\n },\n\n // Unmask element\n unmask() {\n return this.attr('mask', null);\n },\n\n masker() {\n return this.reference('mask');\n }\n\n }\n});\nregister(Mask);\n\nfunction cssRule(selector, rule) {\n if (!selector) return '';\n if (!rule) return selector;\n var ret = selector + '{';\n\n for (var i in rule) {\n ret += unCamelCase(i) + ':' + rule[i] + ';';\n }\n\n ret += '}';\n return ret;\n}\n\nclass Style extends Element {\n constructor(node) {\n super(nodeOrNew('style', node), node);\n }\n\n addText(w = '') {\n this.node.textContent += w;\n return this;\n }\n\n font(name, src, params = {}) {\n return this.rule('@font-face', _objectSpread({\n fontFamily: name,\n src: src\n }, params));\n }\n\n rule(selector, obj) {\n return this.addText(cssRule(selector, obj));\n }\n\n}\nregisterMethods('Dom', {\n style: wrapWithAttrCheck(function (selector, obj) {\n return this.put(new Style()).rule(selector, obj);\n }),\n fontface: wrapWithAttrCheck(function (name, src, params) {\n return this.put(new Style()).font(name, src, params);\n })\n});\nregister(Style);\n\nclass TextPath extends Text {\n // Initialize node\n constructor(node) {\n super(nodeOrNew('textPath', node), node);\n } // return the array of the path track element\n\n\n array() {\n var track = this.track();\n return track ? track.array() : null;\n } // Plot path if any\n\n\n plot(d) {\n var track = this.track();\n var pathArray = null;\n\n if (track) {\n pathArray = track.plot(d);\n }\n\n return d == null ? pathArray : this;\n } // Get the path element\n\n\n track() {\n return this.reference('href');\n }\n\n}\nregisterMethods({\n Container: {\n textPath: wrapWithAttrCheck(function (text, path) {\n return this.defs().path(path).text(text).addTo(this);\n })\n },\n Text: {\n // Create path for text to run on\n path: wrapWithAttrCheck(function (track) {\n var path = new TextPath(); // if track is a path, reuse it\n\n if (!(track instanceof Path)) {\n // create path element\n track = this.root().defs().path(track);\n } // link textPath to path and add content\n\n\n path.attr('href', '#' + track, xlink); // add textPath element as child node and return textPath\n\n return this.put(path);\n }),\n\n // Get the textPath children\n textPath() {\n return this.find('textPath')[0];\n }\n\n },\n Path: {\n // creates a textPath from this path\n text: wrapWithAttrCheck(function (text) {\n if (text instanceof Text) {\n var txt = text.text();\n return text.clear().path(this).text(txt);\n }\n\n return this.parent().put(new Text()).path(this).text(text);\n }),\n\n targets() {\n return baseFind('svg [href*=\"' + this.id() + '\"]');\n }\n\n }\n});\nTextPath.prototype.MorphArray = PathArray;\nregister(TextPath);\n\nclass Use extends Shape {\n constructor(node) {\n super(nodeOrNew('use', node), node);\n } // Use element as a reference\n\n\n element(element, file) {\n // Set lined element\n return this.attr('href', (file || '') + '#' + element, xlink);\n }\n\n}\nregisterMethods({\n Container: {\n // Create a use element\n use: wrapWithAttrCheck(function (element, file) {\n return this.put(new Use()).element(element, file);\n })\n }\n});\nregister(Use);\n\n/* Optional Modules */\nconst SVG = makeInstance;\nextend([Svg$1, Symbol, Image, Pattern, Marker], getMethodsFor('viewbox'));\nextend([Line, Polyline, Polygon, Path], getMethodsFor('marker'));\nextend(Text, getMethodsFor('Text'));\nextend(Path, getMethodsFor('Path'));\nextend(Defs, getMethodsFor('Defs'));\nextend([Text, Tspan], getMethodsFor('Tspan'));\nextend([Rect, Ellipse, Circle, Gradient], getMethodsFor('radius'));\nextend(EventTarget, getMethodsFor('EventTarget'));\nextend(Dom, getMethodsFor('Dom'));\nextend(Element, getMethodsFor('Element'));\nextend(Shape, getMethodsFor('Shape')); // extend(Element, getConstructor('Memory'))\n\nextend(Container, getMethodsFor('Container'));\nextend(Runner, getMethodsFor('Runner'));\nList.extend(getMethodNames());\nregisterMorphableType([SVGNumber, Color, Box, Matrix, SVGArray, PointArray, PathArray]);\nmakeMorphable();\n\nexports.Morphable = Morphable;\nexports.registerMorphableType = registerMorphableType;\nexports.makeMorphable = makeMorphable;\nexports.TransformBag = TransformBag;\nexports.ObjectBag = ObjectBag;\nexports.NonMorphable = NonMorphable;\nexports.defaults = defaults;\nexports.utils = utils;\nexports.namespaces = namespaces;\nexports.regex = regex;\nexports.SVG = SVG;\nexports.parser = parser;\nexports.find = baseFind;\nexports.registerWindow = registerWindow;\nexports.Animator = Animator;\nexports.Controller = Controller;\nexports.Ease = Ease;\nexports.PID = PID;\nexports.Spring = Spring;\nexports.easing = easing;\nexports.Queue = Queue;\nexports.Runner = Runner;\nexports.Timeline = Timeline;\nexports.Array = SVGArray;\nexports.Box = Box;\nexports.Color = Color;\nexports.EventTarget = EventTarget;\nexports.Matrix = Matrix;\nexports.Number = SVGNumber;\nexports.PathArray = PathArray;\nexports.Point = Point;\nexports.PointArray = PointArray;\nexports.List = List;\nexports.Circle = Circle;\nexports.ClipPath = ClipPath;\nexports.Container = Container;\nexports.Defs = Defs;\nexports.Dom = Dom;\nexports.Element = Element;\nexports.Ellipse = Ellipse;\nexports.Gradient = Gradient;\nexports.G = G;\nexports.A = A;\nexports.Image = Image;\nexports.Line = Line;\nexports.Marker = Marker;\nexports.Mask = Mask;\nexports.Path = Path;\nexports.Pattern = Pattern;\nexports.Polygon = Polygon;\nexports.Polyline = Polyline;\nexports.Rect = Rect;\nexports.Shape = Shape;\nexports.Stop = Stop;\nexports.Style = Style;\nexports.Svg = Svg$1;\nexports.Symbol = Symbol;\nexports.Text = Text;\nexports.TextPath = TextPath;\nexports.Tspan = Tspan;\nexports.Use = Use;\nexports.on = on;\nexports.off = off;\nexports.dispatch = dispatch;\nexports.root = root;\nexports.create = create;\nexports.makeInstance = makeInstance;\nexports.nodeOrNew = nodeOrNew;\nexports.adopt = adopt;\nexports.mockAdopt = mockAdopt;\nexports.register = register;\nexports.getClass = getClass;\nexports.eid = eid;\nexports.assignNewId = assignNewId;\nexports.extend = extend;\nexports.wrapWithAttrCheck = wrapWithAttrCheck;\n//# sourceMappingURL=svg.node.js.map\n","/**\n * https://github.com/gre/bezier-easing\n * BezierEasing - use bezier curve for transition easing function\n * by Gaëtan Renaudeau 2014 - 2015 – MIT License\n */\n\n// These values are established by empiricism with tests (tradeoff: performance VS precision)\nvar NEWTON_ITERATIONS = 4;\nvar NEWTON_MIN_SLOPE = 0.001;\nvar SUBDIVISION_PRECISION = 0.0000001;\nvar SUBDIVISION_MAX_ITERATIONS = 10;\n\nvar kSplineTableSize = 11;\nvar kSampleStepSize = 1.0 / (kSplineTableSize - 1.0);\n\nvar float32ArraySupported = typeof Float32Array === 'function';\n\nfunction A (aA1, aA2) { return 1.0 - 3.0 * aA2 + 3.0 * aA1; }\nfunction B (aA1, aA2) { return 3.0 * aA2 - 6.0 * aA1; }\nfunction C (aA1) { return 3.0 * aA1; }\n\n// Returns x(t) given t, x1, and x2, or y(t) given t, y1, and y2.\nfunction calcBezier (aT, aA1, aA2) { return ((A(aA1, aA2) * aT + B(aA1, aA2)) * aT + C(aA1)) * aT; }\n\n// Returns dx/dt given t, x1, and x2, or dy/dt given t, y1, and y2.\nfunction getSlope (aT, aA1, aA2) { return 3.0 * A(aA1, aA2) * aT * aT + 2.0 * B(aA1, aA2) * aT + C(aA1); }\n\nfunction binarySubdivide (aX, aA, aB, mX1, mX2) {\n var currentX, currentT, i = 0;\n do {\n currentT = aA + (aB - aA) / 2.0;\n currentX = calcBezier(currentT, mX1, mX2) - aX;\n if (currentX > 0.0) {\n aB = currentT;\n } else {\n aA = currentT;\n }\n } while (Math.abs(currentX) > SUBDIVISION_PRECISION && ++i < SUBDIVISION_MAX_ITERATIONS);\n return currentT;\n}\n\nfunction newtonRaphsonIterate (aX, aGuessT, mX1, mX2) {\n for (var i = 0; i < NEWTON_ITERATIONS; ++i) {\n var currentSlope = getSlope(aGuessT, mX1, mX2);\n if (currentSlope === 0.0) {\n return aGuessT;\n }\n var currentX = calcBezier(aGuessT, mX1, mX2) - aX;\n aGuessT -= currentX / currentSlope;\n }\n return aGuessT;\n}\n\nfunction LinearEasing (x) {\n return x;\n}\n\nmodule.exports = function bezier (mX1, mY1, mX2, mY2) {\n if (!(0 <= mX1 && mX1 <= 1 && 0 <= mX2 && mX2 <= 1)) {\n throw new Error('bezier x values must be in [0, 1] range');\n }\n\n if (mX1 === mY1 && mX2 === mY2) {\n return LinearEasing;\n }\n\n // Precompute samples table\n var sampleValues = float32ArraySupported ? new Float32Array(kSplineTableSize) : new Array(kSplineTableSize);\n for (var i = 0; i < kSplineTableSize; ++i) {\n sampleValues[i] = calcBezier(i * kSampleStepSize, mX1, mX2);\n }\n\n function getTForX (aX) {\n var intervalStart = 0.0;\n var currentSample = 1;\n var lastSample = kSplineTableSize - 1;\n\n for (; currentSample !== lastSample && sampleValues[currentSample] <= aX; ++currentSample) {\n intervalStart += kSampleStepSize;\n }\n --currentSample;\n\n // Interpolate to provide an initial guess for t\n var dist = (aX - sampleValues[currentSample]) / (sampleValues[currentSample + 1] - sampleValues[currentSample]);\n var guessForT = intervalStart + dist * kSampleStepSize;\n\n var initialSlope = getSlope(guessForT, mX1, mX2);\n if (initialSlope >= NEWTON_MIN_SLOPE) {\n return newtonRaphsonIterate(aX, guessForT, mX1, mX2);\n } else if (initialSlope === 0.0) {\n return guessForT;\n } else {\n return binarySubdivide(aX, intervalStart, intervalStart + kSampleStepSize, mX1, mX2);\n }\n }\n\n return function BezierEasing (x) {\n // Because JavaScript number are imprecise, we should guarantee the extremes are right.\n if (x === 0) {\n return 0;\n }\n if (x === 1) {\n return 1;\n }\n return calcBezier(getTForX(x), mY1, mY2);\n };\n};\n","import * as glMatrix from \"./gl-matrix/common.js\";\r\nimport * as mat2 from \"./gl-matrix/mat2.js\";\r\nimport * as mat2d from \"./gl-matrix/mat2d.js\";\r\nimport * as mat3 from \"./gl-matrix/mat3.js\";\r\nimport * as mat4 from \"./gl-matrix/mat4.js\";\r\nimport * as quat from \"./gl-matrix/quat.js\";\r\nimport * as quat2 from \"./gl-matrix/quat2.js\";\r\nimport * as vec2 from \"./gl-matrix/vec2.js\";\r\nimport * as vec3 from \"./gl-matrix/vec3.js\";\r\nimport * as vec4 from \"./gl-matrix/vec4.js\";\r\n\r\nexport { glMatrix, mat2, mat2d, mat3, mat4, quat, quat2, vec2, vec3, vec4 };","/**\r\n * Common utilities\r\n * @module glMatrix\r\n */\r\n\r\n// Configuration Constants\r\nexport var EPSILON = 0.000001;\r\nexport var ARRAY_TYPE = typeof Float32Array !== 'undefined' ? Float32Array : Array;\r\nexport var RANDOM = Math.random;\r\n\r\n/**\r\n * Sets the type of array used when creating new vectors and matrices\r\n *\r\n * @param {Type} type Array type, such as Float32Array or Array\r\n */\r\nexport function setMatrixArrayType(type) {\r\n ARRAY_TYPE = type;\r\n}\r\n\r\nvar degree = Math.PI / 180;\r\n\r\n/**\r\n * Convert Degree To Radian\r\n *\r\n * @param {Number} a Angle in Degrees\r\n */\r\nexport function toRadian(a) {\r\n return a * degree;\r\n}\r\n\r\n/**\r\n * Tests whether or not the arguments have approximately the same value, within an absolute\r\n * or relative tolerance of glMatrix.EPSILON (an absolute tolerance is used for values less\r\n * than or equal to 1.0, and a relative tolerance is used for larger values)\r\n *\r\n * @param {Number} a The first number to test.\r\n * @param {Number} b The second number to test.\r\n * @returns {Boolean} True if the numbers are approximately equal, false otherwise.\r\n */\r\nexport function equals(a, b) {\r\n return Math.abs(a - b) <= EPSILON * Math.max(1.0, Math.abs(a), Math.abs(b));\r\n}","import * as glMatrix from \"./common.js\";\r\n\r\n/**\r\n * 2x2 Matrix\r\n * @module mat2\r\n */\r\n\r\n/**\r\n * Creates a new identity mat2\r\n *\r\n * @returns {mat2} a new 2x2 matrix\r\n */\r\nexport function create() {\r\n var out = new glMatrix.ARRAY_TYPE(4);\r\n if (glMatrix.ARRAY_TYPE != Float32Array) {\r\n out[1] = 0;\r\n out[2] = 0;\r\n }\r\n out[0] = 1;\r\n out[3] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a new mat2 initialized with values from an existing matrix\r\n *\r\n * @param {mat2} a matrix to clone\r\n * @returns {mat2} a new 2x2 matrix\r\n */\r\nexport function clone(a) {\r\n var out = new glMatrix.ARRAY_TYPE(4);\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Copy the values from one mat2 to another\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @param {mat2} a the source matrix\r\n * @returns {mat2} out\r\n */\r\nexport function copy(out, a) {\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Set a mat2 to the identity matrix\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @returns {mat2} out\r\n */\r\nexport function identity(out) {\r\n out[0] = 1;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Create a new mat2 with the given values\r\n *\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 2)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 3)\r\n * @returns {mat2} out A new 2x2 matrix\r\n */\r\nexport function fromValues(m00, m01, m10, m11) {\r\n var out = new glMatrix.ARRAY_TYPE(4);\r\n out[0] = m00;\r\n out[1] = m01;\r\n out[2] = m10;\r\n out[3] = m11;\r\n return out;\r\n}\r\n\r\n/**\r\n * Set the components of a mat2 to the given values\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 2)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 3)\r\n * @returns {mat2} out\r\n */\r\nexport function set(out, m00, m01, m10, m11) {\r\n out[0] = m00;\r\n out[1] = m01;\r\n out[2] = m10;\r\n out[3] = m11;\r\n return out;\r\n}\r\n\r\n/**\r\n * Transpose the values of a mat2\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @param {mat2} a the source matrix\r\n * @returns {mat2} out\r\n */\r\nexport function transpose(out, a) {\r\n // If we are transposing ourselves we can skip a few steps but have to cache\r\n // some values\r\n if (out === a) {\r\n var a1 = a[1];\r\n out[1] = a[2];\r\n out[2] = a1;\r\n } else {\r\n out[0] = a[0];\r\n out[1] = a[2];\r\n out[2] = a[1];\r\n out[3] = a[3];\r\n }\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Inverts a mat2\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @param {mat2} a the source matrix\r\n * @returns {mat2} out\r\n */\r\nexport function invert(out, a) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3];\r\n\r\n // Calculate the determinant\r\n var det = a0 * a3 - a2 * a1;\r\n\r\n if (!det) {\r\n return null;\r\n }\r\n det = 1.0 / det;\r\n\r\n out[0] = a3 * det;\r\n out[1] = -a1 * det;\r\n out[2] = -a2 * det;\r\n out[3] = a0 * det;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the adjugate of a mat2\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @param {mat2} a the source matrix\r\n * @returns {mat2} out\r\n */\r\nexport function adjoint(out, a) {\r\n // Caching this value is nessecary if out == a\r\n var a0 = a[0];\r\n out[0] = a[3];\r\n out[1] = -a[1];\r\n out[2] = -a[2];\r\n out[3] = a0;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the determinant of a mat2\r\n *\r\n * @param {mat2} a the source matrix\r\n * @returns {Number} determinant of a\r\n */\r\nexport function determinant(a) {\r\n return a[0] * a[3] - a[2] * a[1];\r\n}\r\n\r\n/**\r\n * Multiplies two mat2's\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @param {mat2} a the first operand\r\n * @param {mat2} b the second operand\r\n * @returns {mat2} out\r\n */\r\nexport function multiply(out, a, b) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3];\r\n var b0 = b[0],\r\n b1 = b[1],\r\n b2 = b[2],\r\n b3 = b[3];\r\n out[0] = a0 * b0 + a2 * b1;\r\n out[1] = a1 * b0 + a3 * b1;\r\n out[2] = a0 * b2 + a2 * b3;\r\n out[3] = a1 * b2 + a3 * b3;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a mat2 by the given angle\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @param {mat2} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat2} out\r\n */\r\nexport function rotate(out, a, rad) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3];\r\n var s = Math.sin(rad);\r\n var c = Math.cos(rad);\r\n out[0] = a0 * c + a2 * s;\r\n out[1] = a1 * c + a3 * s;\r\n out[2] = a0 * -s + a2 * c;\r\n out[3] = a1 * -s + a3 * c;\r\n return out;\r\n}\r\n\r\n/**\r\n * Scales the mat2 by the dimensions in the given vec2\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @param {mat2} a the matrix to rotate\r\n * @param {vec2} v the vec2 to scale the matrix by\r\n * @returns {mat2} out\r\n **/\r\nexport function scale(out, a, v) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3];\r\n var v0 = v[0],\r\n v1 = v[1];\r\n out[0] = a0 * v0;\r\n out[1] = a1 * v0;\r\n out[2] = a2 * v1;\r\n out[3] = a3 * v1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a given angle\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat2.identity(dest);\r\n * mat2.rotate(dest, dest, rad);\r\n *\r\n * @param {mat2} out mat2 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat2} out\r\n */\r\nexport function fromRotation(out, rad) {\r\n var s = Math.sin(rad);\r\n var c = Math.cos(rad);\r\n out[0] = c;\r\n out[1] = s;\r\n out[2] = -s;\r\n out[3] = c;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a vector scaling\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat2.identity(dest);\r\n * mat2.scale(dest, dest, vec);\r\n *\r\n * @param {mat2} out mat2 receiving operation result\r\n * @param {vec2} v Scaling vector\r\n * @returns {mat2} out\r\n */\r\nexport function fromScaling(out, v) {\r\n out[0] = v[0];\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = v[1];\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns a string representation of a mat2\r\n *\r\n * @param {mat2} a matrix to represent as a string\r\n * @returns {String} string representation of the matrix\r\n */\r\nexport function str(a) {\r\n return 'mat2(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')';\r\n}\r\n\r\n/**\r\n * Returns Frobenius norm of a mat2\r\n *\r\n * @param {mat2} a the matrix to calculate Frobenius norm of\r\n * @returns {Number} Frobenius norm\r\n */\r\nexport function frob(a) {\r\n return Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2) + Math.pow(a[2], 2) + Math.pow(a[3], 2));\r\n}\r\n\r\n/**\r\n * Returns L, D and U matrices (Lower triangular, Diagonal and Upper triangular) by factorizing the input matrix\r\n * @param {mat2} L the lower triangular matrix\r\n * @param {mat2} D the diagonal matrix\r\n * @param {mat2} U the upper triangular matrix\r\n * @param {mat2} a the input matrix to factorize\r\n */\r\n\r\nexport function LDU(L, D, U, a) {\r\n L[2] = a[2] / a[0];\r\n U[0] = a[0];\r\n U[1] = a[1];\r\n U[3] = a[3] - L[2] * U[1];\r\n return [L, D, U];\r\n}\r\n\r\n/**\r\n * Adds two mat2's\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @param {mat2} a the first operand\r\n * @param {mat2} b the second operand\r\n * @returns {mat2} out\r\n */\r\nexport function add(out, a, b) {\r\n out[0] = a[0] + b[0];\r\n out[1] = a[1] + b[1];\r\n out[2] = a[2] + b[2];\r\n out[3] = a[3] + b[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Subtracts matrix b from matrix a\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @param {mat2} a the first operand\r\n * @param {mat2} b the second operand\r\n * @returns {mat2} out\r\n */\r\nexport function subtract(out, a, b) {\r\n out[0] = a[0] - b[0];\r\n out[1] = a[1] - b[1];\r\n out[2] = a[2] - b[2];\r\n out[3] = a[3] - b[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {mat2} a The first matrix.\r\n * @param {mat2} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\r\nexport function exactEquals(a, b) {\r\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];\r\n}\r\n\r\n/**\r\n * Returns whether or not the matrices have approximately the same elements in the same position.\r\n *\r\n * @param {mat2} a The first matrix.\r\n * @param {mat2} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\r\nexport function equals(a, b) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3];\r\n var b0 = b[0],\r\n b1 = b[1],\r\n b2 = b[2],\r\n b3 = b[3];\r\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3));\r\n}\r\n\r\n/**\r\n * Multiply each element of the matrix by a scalar.\r\n *\r\n * @param {mat2} out the receiving matrix\r\n * @param {mat2} a the matrix to scale\r\n * @param {Number} b amount to scale the matrix's elements by\r\n * @returns {mat2} out\r\n */\r\nexport function multiplyScalar(out, a, b) {\r\n out[0] = a[0] * b;\r\n out[1] = a[1] * b;\r\n out[2] = a[2] * b;\r\n out[3] = a[3] * b;\r\n return out;\r\n}\r\n\r\n/**\r\n * Adds two mat2's after multiplying each element of the second operand by a scalar value.\r\n *\r\n * @param {mat2} out the receiving vector\r\n * @param {mat2} a the first operand\r\n * @param {mat2} b the second operand\r\n * @param {Number} scale the amount to scale b's elements by before adding\r\n * @returns {mat2} out\r\n */\r\nexport function multiplyScalarAndAdd(out, a, b, scale) {\r\n out[0] = a[0] + b[0] * scale;\r\n out[1] = a[1] + b[1] * scale;\r\n out[2] = a[2] + b[2] * scale;\r\n out[3] = a[3] + b[3] * scale;\r\n return out;\r\n}\r\n\r\n/**\r\n * Alias for {@link mat2.multiply}\r\n * @function\r\n */\r\nexport var mul = multiply;\r\n\r\n/**\r\n * Alias for {@link mat2.subtract}\r\n * @function\r\n */\r\nexport var sub = subtract;","import * as glMatrix from \"./common.js\";\r\n\r\n/**\r\n * 2x3 Matrix\r\n * @module mat2d\r\n *\r\n * @description\r\n * A mat2d contains six elements defined as:\r\n * 
\r\n * [a, c, tx,\r\n *  b, d, ty]\r\n *
\r\n * This is a short form for the 3x3 matrix:\r\n * 
\r\n * [a, c, tx,\r\n *  b, d, ty,\r\n *  0, 0, 1]\r\n *
\r\n * The last row is ignored so the array is shorter and operations are faster.\r\n */\r\n\r\n/**\r\n * Creates a new identity mat2d\r\n *\r\n * @returns {mat2d} a new 2x3 matrix\r\n */\r\nexport function create() {\r\n var out = new glMatrix.ARRAY_TYPE(6);\r\n if (glMatrix.ARRAY_TYPE != Float32Array) {\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[4] = 0;\r\n out[5] = 0;\r\n }\r\n out[0] = 1;\r\n out[3] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a new mat2d initialized with values from an existing matrix\r\n *\r\n * @param {mat2d} a matrix to clone\r\n * @returns {mat2d} a new 2x3 matrix\r\n */\r\nexport function clone(a) {\r\n var out = new glMatrix.ARRAY_TYPE(6);\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n out[4] = a[4];\r\n out[5] = a[5];\r\n return out;\r\n}\r\n\r\n/**\r\n * Copy the values from one mat2d to another\r\n *\r\n * @param {mat2d} out the receiving matrix\r\n * @param {mat2d} a the source matrix\r\n * @returns {mat2d} out\r\n */\r\nexport function copy(out, a) {\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n out[4] = a[4];\r\n out[5] = a[5];\r\n return out;\r\n}\r\n\r\n/**\r\n * Set a mat2d to the identity matrix\r\n *\r\n * @param {mat2d} out the receiving matrix\r\n * @returns {mat2d} out\r\n */\r\nexport function identity(out) {\r\n out[0] = 1;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 1;\r\n out[4] = 0;\r\n out[5] = 0;\r\n return out;\r\n}\r\n\r\n/**\r\n * Create a new mat2d with the given values\r\n *\r\n * @param {Number} a Component A (index 0)\r\n * @param {Number} b Component B (index 1)\r\n * @param {Number} c Component C (index 2)\r\n * @param {Number} d Component D (index 3)\r\n * @param {Number} tx Component TX (index 4)\r\n * @param {Number} ty Component TY (index 5)\r\n * @returns {mat2d} A new mat2d\r\n */\r\nexport function fromValues(a, b, c, d, tx, ty) {\r\n var out = new glMatrix.ARRAY_TYPE(6);\r\n out[0] = a;\r\n out[1] = b;\r\n out[2] = c;\r\n out[3] = d;\r\n out[4] = tx;\r\n out[5] = ty;\r\n return out;\r\n}\r\n\r\n/**\r\n * Set the components of a mat2d to the given values\r\n *\r\n * @param {mat2d} out the receiving matrix\r\n * @param {Number} a Component A (index 0)\r\n * @param {Number} b Component B (index 1)\r\n * @param {Number} c Component C (index 2)\r\n * @param {Number} d Component D (index 3)\r\n * @param {Number} tx Component TX (index 4)\r\n * @param {Number} ty Component TY (index 5)\r\n * @returns {mat2d} out\r\n */\r\nexport function set(out, a, b, c, d, tx, ty) {\r\n out[0] = a;\r\n out[1] = b;\r\n out[2] = c;\r\n out[3] = d;\r\n out[4] = tx;\r\n out[5] = ty;\r\n return out;\r\n}\r\n\r\n/**\r\n * Inverts a mat2d\r\n *\r\n * @param {mat2d} out the receiving matrix\r\n * @param {mat2d} a the source matrix\r\n * @returns {mat2d} out\r\n */\r\nexport function invert(out, a) {\r\n var aa = a[0],\r\n ab = a[1],\r\n ac = a[2],\r\n ad = a[3];\r\n var atx = a[4],\r\n aty = a[5];\r\n\r\n var det = aa * ad - ab * ac;\r\n if (!det) {\r\n return null;\r\n }\r\n det = 1.0 / det;\r\n\r\n out[0] = ad * det;\r\n out[1] = -ab * det;\r\n out[2] = -ac * det;\r\n out[3] = aa * det;\r\n out[4] = (ac * aty - ad * atx) * det;\r\n out[5] = (ab * atx - aa * aty) * det;\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the determinant of a mat2d\r\n *\r\n * @param {mat2d} a the source matrix\r\n * @returns {Number} determinant of a\r\n */\r\nexport function determinant(a) {\r\n return a[0] * a[3] - a[1] * a[2];\r\n}\r\n\r\n/**\r\n * Multiplies two mat2d's\r\n *\r\n * @param {mat2d} out the receiving matrix\r\n * @param {mat2d} a the first operand\r\n * @param {mat2d} b the second operand\r\n * @returns {mat2d} out\r\n */\r\nexport function multiply(out, a, b) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3],\r\n a4 = a[4],\r\n a5 = a[5];\r\n var b0 = b[0],\r\n b1 = b[1],\r\n b2 = b[2],\r\n b3 = b[3],\r\n b4 = b[4],\r\n b5 = b[5];\r\n out[0] = a0 * b0 + a2 * b1;\r\n out[1] = a1 * b0 + a3 * b1;\r\n out[2] = a0 * b2 + a2 * b3;\r\n out[3] = a1 * b2 + a3 * b3;\r\n out[4] = a0 * b4 + a2 * b5 + a4;\r\n out[5] = a1 * b4 + a3 * b5 + a5;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a mat2d by the given angle\r\n *\r\n * @param {mat2d} out the receiving matrix\r\n * @param {mat2d} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat2d} out\r\n */\r\nexport function rotate(out, a, rad) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3],\r\n a4 = a[4],\r\n a5 = a[5];\r\n var s = Math.sin(rad);\r\n var c = Math.cos(rad);\r\n out[0] = a0 * c + a2 * s;\r\n out[1] = a1 * c + a3 * s;\r\n out[2] = a0 * -s + a2 * c;\r\n out[3] = a1 * -s + a3 * c;\r\n out[4] = a4;\r\n out[5] = a5;\r\n return out;\r\n}\r\n\r\n/**\r\n * Scales the mat2d by the dimensions in the given vec2\r\n *\r\n * @param {mat2d} out the receiving matrix\r\n * @param {mat2d} a the matrix to translate\r\n * @param {vec2} v the vec2 to scale the matrix by\r\n * @returns {mat2d} out\r\n **/\r\nexport function scale(out, a, v) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3],\r\n a4 = a[4],\r\n a5 = a[5];\r\n var v0 = v[0],\r\n v1 = v[1];\r\n out[0] = a0 * v0;\r\n out[1] = a1 * v0;\r\n out[2] = a2 * v1;\r\n out[3] = a3 * v1;\r\n out[4] = a4;\r\n out[5] = a5;\r\n return out;\r\n}\r\n\r\n/**\r\n * Translates the mat2d by the dimensions in the given vec2\r\n *\r\n * @param {mat2d} out the receiving matrix\r\n * @param {mat2d} a the matrix to translate\r\n * @param {vec2} v the vec2 to translate the matrix by\r\n * @returns {mat2d} out\r\n **/\r\nexport function translate(out, a, v) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3],\r\n a4 = a[4],\r\n a5 = a[5];\r\n var v0 = v[0],\r\n v1 = v[1];\r\n out[0] = a0;\r\n out[1] = a1;\r\n out[2] = a2;\r\n out[3] = a3;\r\n out[4] = a0 * v0 + a2 * v1 + a4;\r\n out[5] = a1 * v0 + a3 * v1 + a5;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a given angle\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat2d.identity(dest);\r\n * mat2d.rotate(dest, dest, rad);\r\n *\r\n * @param {mat2d} out mat2d receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat2d} out\r\n */\r\nexport function fromRotation(out, rad) {\r\n var s = Math.sin(rad),\r\n c = Math.cos(rad);\r\n out[0] = c;\r\n out[1] = s;\r\n out[2] = -s;\r\n out[3] = c;\r\n out[4] = 0;\r\n out[5] = 0;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a vector scaling\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat2d.identity(dest);\r\n * mat2d.scale(dest, dest, vec);\r\n *\r\n * @param {mat2d} out mat2d receiving operation result\r\n * @param {vec2} v Scaling vector\r\n * @returns {mat2d} out\r\n */\r\nexport function fromScaling(out, v) {\r\n out[0] = v[0];\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = v[1];\r\n out[4] = 0;\r\n out[5] = 0;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a vector translation\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat2d.identity(dest);\r\n * mat2d.translate(dest, dest, vec);\r\n *\r\n * @param {mat2d} out mat2d receiving operation result\r\n * @param {vec2} v Translation vector\r\n * @returns {mat2d} out\r\n */\r\nexport function fromTranslation(out, v) {\r\n out[0] = 1;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 1;\r\n out[4] = v[0];\r\n out[5] = v[1];\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns a string representation of a mat2d\r\n *\r\n * @param {mat2d} a matrix to represent as a string\r\n * @returns {String} string representation of the matrix\r\n */\r\nexport function str(a) {\r\n return 'mat2d(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ')';\r\n}\r\n\r\n/**\r\n * Returns Frobenius norm of a mat2d\r\n *\r\n * @param {mat2d} a the matrix to calculate Frobenius norm of\r\n * @returns {Number} Frobenius norm\r\n */\r\nexport function frob(a) {\r\n return Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2) + Math.pow(a[2], 2) + Math.pow(a[3], 2) + Math.pow(a[4], 2) + Math.pow(a[5], 2) + 1);\r\n}\r\n\r\n/**\r\n * Adds two mat2d's\r\n *\r\n * @param {mat2d} out the receiving matrix\r\n * @param {mat2d} a the first operand\r\n * @param {mat2d} b the second operand\r\n * @returns {mat2d} out\r\n */\r\nexport function add(out, a, b) {\r\n out[0] = a[0] + b[0];\r\n out[1] = a[1] + b[1];\r\n out[2] = a[2] + b[2];\r\n out[3] = a[3] + b[3];\r\n out[4] = a[4] + b[4];\r\n out[5] = a[5] + b[5];\r\n return out;\r\n}\r\n\r\n/**\r\n * Subtracts matrix b from matrix a\r\n *\r\n * @param {mat2d} out the receiving matrix\r\n * @param {mat2d} a the first operand\r\n * @param {mat2d} b the second operand\r\n * @returns {mat2d} out\r\n */\r\nexport function subtract(out, a, b) {\r\n out[0] = a[0] - b[0];\r\n out[1] = a[1] - b[1];\r\n out[2] = a[2] - b[2];\r\n out[3] = a[3] - b[3];\r\n out[4] = a[4] - b[4];\r\n out[5] = a[5] - b[5];\r\n return out;\r\n}\r\n\r\n/**\r\n * Multiply each element of the matrix by a scalar.\r\n *\r\n * @param {mat2d} out the receiving matrix\r\n * @param {mat2d} a the matrix to scale\r\n * @param {Number} b amount to scale the matrix's elements by\r\n * @returns {mat2d} out\r\n */\r\nexport function multiplyScalar(out, a, b) {\r\n out[0] = a[0] * b;\r\n out[1] = a[1] * b;\r\n out[2] = a[2] * b;\r\n out[3] = a[3] * b;\r\n out[4] = a[4] * b;\r\n out[5] = a[5] * b;\r\n return out;\r\n}\r\n\r\n/**\r\n * Adds two mat2d's after multiplying each element of the second operand by a scalar value.\r\n *\r\n * @param {mat2d} out the receiving vector\r\n * @param {mat2d} a the first operand\r\n * @param {mat2d} b the second operand\r\n * @param {Number} scale the amount to scale b's elements by before adding\r\n * @returns {mat2d} out\r\n */\r\nexport function multiplyScalarAndAdd(out, a, b, scale) {\r\n out[0] = a[0] + b[0] * scale;\r\n out[1] = a[1] + b[1] * scale;\r\n out[2] = a[2] + b[2] * scale;\r\n out[3] = a[3] + b[3] * scale;\r\n out[4] = a[4] + b[4] * scale;\r\n out[5] = a[5] + b[5] * scale;\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {mat2d} a The first matrix.\r\n * @param {mat2d} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\r\nexport function exactEquals(a, b) {\r\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5];\r\n}\r\n\r\n/**\r\n * Returns whether or not the matrices have approximately the same elements in the same position.\r\n *\r\n * @param {mat2d} a The first matrix.\r\n * @param {mat2d} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\r\nexport function equals(a, b) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3],\r\n a4 = a[4],\r\n a5 = a[5];\r\n var b0 = b[0],\r\n b1 = b[1],\r\n b2 = b[2],\r\n b3 = b[3],\r\n b4 = b[4],\r\n b5 = b[5];\r\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5));\r\n}\r\n\r\n/**\r\n * Alias for {@link mat2d.multiply}\r\n * @function\r\n */\r\nexport var mul = multiply;\r\n\r\n/**\r\n * Alias for {@link mat2d.subtract}\r\n * @function\r\n */\r\nexport var sub = subtract;","import * as glMatrix from \"./common.js\";\r\n\r\n/**\r\n * 3x3 Matrix\r\n * @module mat3\r\n */\r\n\r\n/**\r\n * Creates a new identity mat3\r\n *\r\n * @returns {mat3} a new 3x3 matrix\r\n */\r\nexport function create() {\r\n var out = new glMatrix.ARRAY_TYPE(9);\r\n if (glMatrix.ARRAY_TYPE != Float32Array) {\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[5] = 0;\r\n out[6] = 0;\r\n out[7] = 0;\r\n }\r\n out[0] = 1;\r\n out[4] = 1;\r\n out[8] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Copies the upper-left 3x3 values into the given mat3.\r\n *\r\n * @param {mat3} out the receiving 3x3 matrix\r\n * @param {mat4} a the source 4x4 matrix\r\n * @returns {mat3} out\r\n */\r\nexport function fromMat4(out, a) {\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[4];\r\n out[4] = a[5];\r\n out[5] = a[6];\r\n out[6] = a[8];\r\n out[7] = a[9];\r\n out[8] = a[10];\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a new mat3 initialized with values from an existing matrix\r\n *\r\n * @param {mat3} a matrix to clone\r\n * @returns {mat3} a new 3x3 matrix\r\n */\r\nexport function clone(a) {\r\n var out = new glMatrix.ARRAY_TYPE(9);\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n out[4] = a[4];\r\n out[5] = a[5];\r\n out[6] = a[6];\r\n out[7] = a[7];\r\n out[8] = a[8];\r\n return out;\r\n}\r\n\r\n/**\r\n * Copy the values from one mat3 to another\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat3} a the source matrix\r\n * @returns {mat3} out\r\n */\r\nexport function copy(out, a) {\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n out[4] = a[4];\r\n out[5] = a[5];\r\n out[6] = a[6];\r\n out[7] = a[7];\r\n out[8] = a[8];\r\n return out;\r\n}\r\n\r\n/**\r\n * Create a new mat3 with the given values\r\n *\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 3)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 4)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 5)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 6)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 7)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 8)\r\n * @returns {mat3} A new mat3\r\n */\r\nexport function fromValues(m00, m01, m02, m10, m11, m12, m20, m21, m22) {\r\n var out = new glMatrix.ARRAY_TYPE(9);\r\n out[0] = m00;\r\n out[1] = m01;\r\n out[2] = m02;\r\n out[3] = m10;\r\n out[4] = m11;\r\n out[5] = m12;\r\n out[6] = m20;\r\n out[7] = m21;\r\n out[8] = m22;\r\n return out;\r\n}\r\n\r\n/**\r\n * Set the components of a mat3 to the given values\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 3)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 4)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 5)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 6)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 7)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 8)\r\n * @returns {mat3} out\r\n */\r\nexport function set(out, m00, m01, m02, m10, m11, m12, m20, m21, m22) {\r\n out[0] = m00;\r\n out[1] = m01;\r\n out[2] = m02;\r\n out[3] = m10;\r\n out[4] = m11;\r\n out[5] = m12;\r\n out[6] = m20;\r\n out[7] = m21;\r\n out[8] = m22;\r\n return out;\r\n}\r\n\r\n/**\r\n * Set a mat3 to the identity matrix\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @returns {mat3} out\r\n */\r\nexport function identity(out) {\r\n out[0] = 1;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = 1;\r\n out[5] = 0;\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Transpose the values of a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat3} a the source matrix\r\n * @returns {mat3} out\r\n */\r\nexport function transpose(out, a) {\r\n // If we are transposing ourselves we can skip a few steps but have to cache some values\r\n if (out === a) {\r\n var a01 = a[1],\r\n a02 = a[2],\r\n a12 = a[5];\r\n out[1] = a[3];\r\n out[2] = a[6];\r\n out[3] = a01;\r\n out[5] = a[7];\r\n out[6] = a02;\r\n out[7] = a12;\r\n } else {\r\n out[0] = a[0];\r\n out[1] = a[3];\r\n out[2] = a[6];\r\n out[3] = a[1];\r\n out[4] = a[4];\r\n out[5] = a[7];\r\n out[6] = a[2];\r\n out[7] = a[5];\r\n out[8] = a[8];\r\n }\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Inverts a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat3} a the source matrix\r\n * @returns {mat3} out\r\n */\r\nexport function invert(out, a) {\r\n var a00 = a[0],\r\n a01 = a[1],\r\n a02 = a[2];\r\n var a10 = a[3],\r\n a11 = a[4],\r\n a12 = a[5];\r\n var a20 = a[6],\r\n a21 = a[7],\r\n a22 = a[8];\r\n\r\n var b01 = a22 * a11 - a12 * a21;\r\n var b11 = -a22 * a10 + a12 * a20;\r\n var b21 = a21 * a10 - a11 * a20;\r\n\r\n // Calculate the determinant\r\n var det = a00 * b01 + a01 * b11 + a02 * b21;\r\n\r\n if (!det) {\r\n return null;\r\n }\r\n det = 1.0 / det;\r\n\r\n out[0] = b01 * det;\r\n out[1] = (-a22 * a01 + a02 * a21) * det;\r\n out[2] = (a12 * a01 - a02 * a11) * det;\r\n out[3] = b11 * det;\r\n out[4] = (a22 * a00 - a02 * a20) * det;\r\n out[5] = (-a12 * a00 + a02 * a10) * det;\r\n out[6] = b21 * det;\r\n out[7] = (-a21 * a00 + a01 * a20) * det;\r\n out[8] = (a11 * a00 - a01 * a10) * det;\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the adjugate of a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat3} a the source matrix\r\n * @returns {mat3} out\r\n */\r\nexport function adjoint(out, a) {\r\n var a00 = a[0],\r\n a01 = a[1],\r\n a02 = a[2];\r\n var a10 = a[3],\r\n a11 = a[4],\r\n a12 = a[5];\r\n var a20 = a[6],\r\n a21 = a[7],\r\n a22 = a[8];\r\n\r\n out[0] = a11 * a22 - a12 * a21;\r\n out[1] = a02 * a21 - a01 * a22;\r\n out[2] = a01 * a12 - a02 * a11;\r\n out[3] = a12 * a20 - a10 * a22;\r\n out[4] = a00 * a22 - a02 * a20;\r\n out[5] = a02 * a10 - a00 * a12;\r\n out[6] = a10 * a21 - a11 * a20;\r\n out[7] = a01 * a20 - a00 * a21;\r\n out[8] = a00 * a11 - a01 * a10;\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the determinant of a mat3\r\n *\r\n * @param {mat3} a the source matrix\r\n * @returns {Number} determinant of a\r\n */\r\nexport function determinant(a) {\r\n var a00 = a[0],\r\n a01 = a[1],\r\n a02 = a[2];\r\n var a10 = a[3],\r\n a11 = a[4],\r\n a12 = a[5];\r\n var a20 = a[6],\r\n a21 = a[7],\r\n a22 = a[8];\r\n\r\n return a00 * (a22 * a11 - a12 * a21) + a01 * (-a22 * a10 + a12 * a20) + a02 * (a21 * a10 - a11 * a20);\r\n}\r\n\r\n/**\r\n * Multiplies two mat3's\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat3} a the first operand\r\n * @param {mat3} b the second operand\r\n * @returns {mat3} out\r\n */\r\nexport function multiply(out, a, b) {\r\n var a00 = a[0],\r\n a01 = a[1],\r\n a02 = a[2];\r\n var a10 = a[3],\r\n a11 = a[4],\r\n a12 = a[5];\r\n var a20 = a[6],\r\n a21 = a[7],\r\n a22 = a[8];\r\n\r\n var b00 = b[0],\r\n b01 = b[1],\r\n b02 = b[2];\r\n var b10 = b[3],\r\n b11 = b[4],\r\n b12 = b[5];\r\n var b20 = b[6],\r\n b21 = b[7],\r\n b22 = b[8];\r\n\r\n out[0] = b00 * a00 + b01 * a10 + b02 * a20;\r\n out[1] = b00 * a01 + b01 * a11 + b02 * a21;\r\n out[2] = b00 * a02 + b01 * a12 + b02 * a22;\r\n\r\n out[3] = b10 * a00 + b11 * a10 + b12 * a20;\r\n out[4] = b10 * a01 + b11 * a11 + b12 * a21;\r\n out[5] = b10 * a02 + b11 * a12 + b12 * a22;\r\n\r\n out[6] = b20 * a00 + b21 * a10 + b22 * a20;\r\n out[7] = b20 * a01 + b21 * a11 + b22 * a21;\r\n out[8] = b20 * a02 + b21 * a12 + b22 * a22;\r\n return out;\r\n}\r\n\r\n/**\r\n * Translate a mat3 by the given vector\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat3} a the matrix to translate\r\n * @param {vec2} v vector to translate by\r\n * @returns {mat3} out\r\n */\r\nexport function translate(out, a, v) {\r\n var a00 = a[0],\r\n a01 = a[1],\r\n a02 = a[2],\r\n a10 = a[3],\r\n a11 = a[4],\r\n a12 = a[5],\r\n a20 = a[6],\r\n a21 = a[7],\r\n a22 = a[8],\r\n x = v[0],\r\n y = v[1];\r\n\r\n out[0] = a00;\r\n out[1] = a01;\r\n out[2] = a02;\r\n\r\n out[3] = a10;\r\n out[4] = a11;\r\n out[5] = a12;\r\n\r\n out[6] = x * a00 + y * a10 + a20;\r\n out[7] = x * a01 + y * a11 + a21;\r\n out[8] = x * a02 + y * a12 + a22;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a mat3 by the given angle\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat3} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat3} out\r\n */\r\nexport function rotate(out, a, rad) {\r\n var a00 = a[0],\r\n a01 = a[1],\r\n a02 = a[2],\r\n a10 = a[3],\r\n a11 = a[4],\r\n a12 = a[5],\r\n a20 = a[6],\r\n a21 = a[7],\r\n a22 = a[8],\r\n s = Math.sin(rad),\r\n c = Math.cos(rad);\r\n\r\n out[0] = c * a00 + s * a10;\r\n out[1] = c * a01 + s * a11;\r\n out[2] = c * a02 + s * a12;\r\n\r\n out[3] = c * a10 - s * a00;\r\n out[4] = c * a11 - s * a01;\r\n out[5] = c * a12 - s * a02;\r\n\r\n out[6] = a20;\r\n out[7] = a21;\r\n out[8] = a22;\r\n return out;\r\n};\r\n\r\n/**\r\n * Scales the mat3 by the dimensions in the given vec2\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat3} a the matrix to rotate\r\n * @param {vec2} v the vec2 to scale the matrix by\r\n * @returns {mat3} out\r\n **/\r\nexport function scale(out, a, v) {\r\n var x = v[0],\r\n y = v[1];\r\n\r\n out[0] = x * a[0];\r\n out[1] = x * a[1];\r\n out[2] = x * a[2];\r\n\r\n out[3] = y * a[3];\r\n out[4] = y * a[4];\r\n out[5] = y * a[5];\r\n\r\n out[6] = a[6];\r\n out[7] = a[7];\r\n out[8] = a[8];\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a vector translation\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat3.identity(dest);\r\n * mat3.translate(dest, dest, vec);\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {vec2} v Translation vector\r\n * @returns {mat3} out\r\n */\r\nexport function fromTranslation(out, v) {\r\n out[0] = 1;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = 1;\r\n out[5] = 0;\r\n out[6] = v[0];\r\n out[7] = v[1];\r\n out[8] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a given angle\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat3.identity(dest);\r\n * mat3.rotate(dest, dest, rad);\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat3} out\r\n */\r\nexport function fromRotation(out, rad) {\r\n var s = Math.sin(rad),\r\n c = Math.cos(rad);\r\n\r\n out[0] = c;\r\n out[1] = s;\r\n out[2] = 0;\r\n\r\n out[3] = -s;\r\n out[4] = c;\r\n out[5] = 0;\r\n\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a vector scaling\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat3.identity(dest);\r\n * mat3.scale(dest, dest, vec);\r\n *\r\n * @param {mat3} out mat3 receiving operation result\r\n * @param {vec2} v Scaling vector\r\n * @returns {mat3} out\r\n */\r\nexport function fromScaling(out, v) {\r\n out[0] = v[0];\r\n out[1] = 0;\r\n out[2] = 0;\r\n\r\n out[3] = 0;\r\n out[4] = v[1];\r\n out[5] = 0;\r\n\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Copies the values from a mat2d into a mat3\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat2d} a the matrix to copy\r\n * @returns {mat3} out\r\n **/\r\nexport function fromMat2d(out, a) {\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = 0;\r\n\r\n out[3] = a[2];\r\n out[4] = a[3];\r\n out[5] = 0;\r\n\r\n out[6] = a[4];\r\n out[7] = a[5];\r\n out[8] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n* Calculates a 3x3 matrix from the given quaternion\r\n*\r\n* @param {mat3} out mat3 receiving operation result\r\n* @param {quat} q Quaternion to create matrix from\r\n*\r\n* @returns {mat3} out\r\n*/\r\nexport function fromQuat(out, q) {\r\n var x = q[0],\r\n y = q[1],\r\n z = q[2],\r\n w = q[3];\r\n var x2 = x + x;\r\n var y2 = y + y;\r\n var z2 = z + z;\r\n\r\n var xx = x * x2;\r\n var yx = y * x2;\r\n var yy = y * y2;\r\n var zx = z * x2;\r\n var zy = z * y2;\r\n var zz = z * z2;\r\n var wx = w * x2;\r\n var wy = w * y2;\r\n var wz = w * z2;\r\n\r\n out[0] = 1 - yy - zz;\r\n out[3] = yx - wz;\r\n out[6] = zx + wy;\r\n\r\n out[1] = yx + wz;\r\n out[4] = 1 - xx - zz;\r\n out[7] = zy - wx;\r\n\r\n out[2] = zx - wy;\r\n out[5] = zy + wx;\r\n out[8] = 1 - xx - yy;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n* Calculates a 3x3 normal matrix (transpose inverse) from the 4x4 matrix\r\n*\r\n* @param {mat3} out mat3 receiving operation result\r\n* @param {mat4} a Mat4 to derive the normal matrix from\r\n*\r\n* @returns {mat3} out\r\n*/\r\nexport function normalFromMat4(out, a) {\r\n var a00 = a[0],\r\n a01 = a[1],\r\n a02 = a[2],\r\n a03 = a[3];\r\n var a10 = a[4],\r\n a11 = a[5],\r\n a12 = a[6],\r\n a13 = a[7];\r\n var a20 = a[8],\r\n a21 = a[9],\r\n a22 = a[10],\r\n a23 = a[11];\r\n var a30 = a[12],\r\n a31 = a[13],\r\n a32 = a[14],\r\n a33 = a[15];\r\n\r\n var b00 = a00 * a11 - a01 * a10;\r\n var b01 = a00 * a12 - a02 * a10;\r\n var b02 = a00 * a13 - a03 * a10;\r\n var b03 = a01 * a12 - a02 * a11;\r\n var b04 = a01 * a13 - a03 * a11;\r\n var b05 = a02 * a13 - a03 * a12;\r\n var b06 = a20 * a31 - a21 * a30;\r\n var b07 = a20 * a32 - a22 * a30;\r\n var b08 = a20 * a33 - a23 * a30;\r\n var b09 = a21 * a32 - a22 * a31;\r\n var b10 = a21 * a33 - a23 * a31;\r\n var b11 = a22 * a33 - a23 * a32;\r\n\r\n // Calculate the determinant\r\n var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\r\n\r\n if (!det) {\r\n return null;\r\n }\r\n det = 1.0 / det;\r\n\r\n out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;\r\n out[1] = (a12 * b08 - a10 * b11 - a13 * b07) * det;\r\n out[2] = (a10 * b10 - a11 * b08 + a13 * b06) * det;\r\n\r\n out[3] = (a02 * b10 - a01 * b11 - a03 * b09) * det;\r\n out[4] = (a00 * b11 - a02 * b08 + a03 * b07) * det;\r\n out[5] = (a01 * b08 - a00 * b10 - a03 * b06) * det;\r\n\r\n out[6] = (a31 * b05 - a32 * b04 + a33 * b03) * det;\r\n out[7] = (a32 * b02 - a30 * b05 - a33 * b01) * det;\r\n out[8] = (a30 * b04 - a31 * b02 + a33 * b00) * det;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Generates a 2D projection matrix with the given bounds\r\n *\r\n * @param {mat3} out mat3 frustum matrix will be written into\r\n * @param {number} width Width of your gl context\r\n * @param {number} height Height of gl context\r\n * @returns {mat3} out\r\n */\r\nexport function projection(out, width, height) {\r\n out[0] = 2 / width;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = -2 / height;\r\n out[5] = 0;\r\n out[6] = -1;\r\n out[7] = 1;\r\n out[8] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns a string representation of a mat3\r\n *\r\n * @param {mat3} a matrix to represent as a string\r\n * @returns {String} string representation of the matrix\r\n */\r\nexport function str(a) {\r\n return 'mat3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ', ' + a[6] + ', ' + a[7] + ', ' + a[8] + ')';\r\n}\r\n\r\n/**\r\n * Returns Frobenius norm of a mat3\r\n *\r\n * @param {mat3} a the matrix to calculate Frobenius norm of\r\n * @returns {Number} Frobenius norm\r\n */\r\nexport function frob(a) {\r\n return Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2) + Math.pow(a[2], 2) + Math.pow(a[3], 2) + Math.pow(a[4], 2) + Math.pow(a[5], 2) + Math.pow(a[6], 2) + Math.pow(a[7], 2) + Math.pow(a[8], 2));\r\n}\r\n\r\n/**\r\n * Adds two mat3's\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat3} a the first operand\r\n * @param {mat3} b the second operand\r\n * @returns {mat3} out\r\n */\r\nexport function add(out, a, b) {\r\n out[0] = a[0] + b[0];\r\n out[1] = a[1] + b[1];\r\n out[2] = a[2] + b[2];\r\n out[3] = a[3] + b[3];\r\n out[4] = a[4] + b[4];\r\n out[5] = a[5] + b[5];\r\n out[6] = a[6] + b[6];\r\n out[7] = a[7] + b[7];\r\n out[8] = a[8] + b[8];\r\n return out;\r\n}\r\n\r\n/**\r\n * Subtracts matrix b from matrix a\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat3} a the first operand\r\n * @param {mat3} b the second operand\r\n * @returns {mat3} out\r\n */\r\nexport function subtract(out, a, b) {\r\n out[0] = a[0] - b[0];\r\n out[1] = a[1] - b[1];\r\n out[2] = a[2] - b[2];\r\n out[3] = a[3] - b[3];\r\n out[4] = a[4] - b[4];\r\n out[5] = a[5] - b[5];\r\n out[6] = a[6] - b[6];\r\n out[7] = a[7] - b[7];\r\n out[8] = a[8] - b[8];\r\n return out;\r\n}\r\n\r\n/**\r\n * Multiply each element of the matrix by a scalar.\r\n *\r\n * @param {mat3} out the receiving matrix\r\n * @param {mat3} a the matrix to scale\r\n * @param {Number} b amount to scale the matrix's elements by\r\n * @returns {mat3} out\r\n */\r\nexport function multiplyScalar(out, a, b) {\r\n out[0] = a[0] * b;\r\n out[1] = a[1] * b;\r\n out[2] = a[2] * b;\r\n out[3] = a[3] * b;\r\n out[4] = a[4] * b;\r\n out[5] = a[5] * b;\r\n out[6] = a[6] * b;\r\n out[7] = a[7] * b;\r\n out[8] = a[8] * b;\r\n return out;\r\n}\r\n\r\n/**\r\n * Adds two mat3's after multiplying each element of the second operand by a scalar value.\r\n *\r\n * @param {mat3} out the receiving vector\r\n * @param {mat3} a the first operand\r\n * @param {mat3} b the second operand\r\n * @param {Number} scale the amount to scale b's elements by before adding\r\n * @returns {mat3} out\r\n */\r\nexport function multiplyScalarAndAdd(out, a, b, scale) {\r\n out[0] = a[0] + b[0] * scale;\r\n out[1] = a[1] + b[1] * scale;\r\n out[2] = a[2] + b[2] * scale;\r\n out[3] = a[3] + b[3] * scale;\r\n out[4] = a[4] + b[4] * scale;\r\n out[5] = a[5] + b[5] * scale;\r\n out[6] = a[6] + b[6] * scale;\r\n out[7] = a[7] + b[7] * scale;\r\n out[8] = a[8] + b[8] * scale;\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {mat3} a The first matrix.\r\n * @param {mat3} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\r\nexport function exactEquals(a, b) {\r\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8];\r\n}\r\n\r\n/**\r\n * Returns whether or not the matrices have approximately the same elements in the same position.\r\n *\r\n * @param {mat3} a The first matrix.\r\n * @param {mat3} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\r\nexport function equals(a, b) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3],\r\n a4 = a[4],\r\n a5 = a[5],\r\n a6 = a[6],\r\n a7 = a[7],\r\n a8 = a[8];\r\n var b0 = b[0],\r\n b1 = b[1],\r\n b2 = b[2],\r\n b3 = b[3],\r\n b4 = b[4],\r\n b5 = b[5],\r\n b6 = b[6],\r\n b7 = b[7],\r\n b8 = b[8];\r\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8));\r\n}\r\n\r\n/**\r\n * Alias for {@link mat3.multiply}\r\n * @function\r\n */\r\nexport var mul = multiply;\r\n\r\n/**\r\n * Alias for {@link mat3.subtract}\r\n * @function\r\n */\r\nexport var sub = subtract;","import * as glMatrix from \"./common.js\";\r\n\r\n/**\r\n * 4x4 Matrix
Format: column-major, when typed out it looks like row-major
The matrices are being post multiplied.\r\n * @module mat4\r\n */\r\n\r\n/**\r\n * Creates a new identity mat4\r\n *\r\n * @returns {mat4} a new 4x4 matrix\r\n */\r\nexport function create() {\r\n var out = new glMatrix.ARRAY_TYPE(16);\r\n if (glMatrix.ARRAY_TYPE != Float32Array) {\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = 0;\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = 0;\r\n out[9] = 0;\r\n out[11] = 0;\r\n out[12] = 0;\r\n out[13] = 0;\r\n out[14] = 0;\r\n }\r\n out[0] = 1;\r\n out[5] = 1;\r\n out[10] = 1;\r\n out[15] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a new mat4 initialized with values from an existing matrix\r\n *\r\n * @param {mat4} a matrix to clone\r\n * @returns {mat4} a new 4x4 matrix\r\n */\r\nexport function clone(a) {\r\n var out = new glMatrix.ARRAY_TYPE(16);\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n out[4] = a[4];\r\n out[5] = a[5];\r\n out[6] = a[6];\r\n out[7] = a[7];\r\n out[8] = a[8];\r\n out[9] = a[9];\r\n out[10] = a[10];\r\n out[11] = a[11];\r\n out[12] = a[12];\r\n out[13] = a[13];\r\n out[14] = a[14];\r\n out[15] = a[15];\r\n return out;\r\n}\r\n\r\n/**\r\n * Copy the values from one mat4 to another\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the source matrix\r\n * @returns {mat4} out\r\n */\r\nexport function copy(out, a) {\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n out[4] = a[4];\r\n out[5] = a[5];\r\n out[6] = a[6];\r\n out[7] = a[7];\r\n out[8] = a[8];\r\n out[9] = a[9];\r\n out[10] = a[10];\r\n out[11] = a[11];\r\n out[12] = a[12];\r\n out[13] = a[13];\r\n out[14] = a[14];\r\n out[15] = a[15];\r\n return out;\r\n}\r\n\r\n/**\r\n * Create a new mat4 with the given values\r\n *\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m03 Component in column 0, row 3 position (index 3)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 4)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 5)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 6)\r\n * @param {Number} m13 Component in column 1, row 3 position (index 7)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 8)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 9)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 10)\r\n * @param {Number} m23 Component in column 2, row 3 position (index 11)\r\n * @param {Number} m30 Component in column 3, row 0 position (index 12)\r\n * @param {Number} m31 Component in column 3, row 1 position (index 13)\r\n * @param {Number} m32 Component in column 3, row 2 position (index 14)\r\n * @param {Number} m33 Component in column 3, row 3 position (index 15)\r\n * @returns {mat4} A new mat4\r\n */\r\nexport function fromValues(m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {\r\n var out = new glMatrix.ARRAY_TYPE(16);\r\n out[0] = m00;\r\n out[1] = m01;\r\n out[2] = m02;\r\n out[3] = m03;\r\n out[4] = m10;\r\n out[5] = m11;\r\n out[6] = m12;\r\n out[7] = m13;\r\n out[8] = m20;\r\n out[9] = m21;\r\n out[10] = m22;\r\n out[11] = m23;\r\n out[12] = m30;\r\n out[13] = m31;\r\n out[14] = m32;\r\n out[15] = m33;\r\n return out;\r\n}\r\n\r\n/**\r\n * Set the components of a mat4 to the given values\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {Number} m00 Component in column 0, row 0 position (index 0)\r\n * @param {Number} m01 Component in column 0, row 1 position (index 1)\r\n * @param {Number} m02 Component in column 0, row 2 position (index 2)\r\n * @param {Number} m03 Component in column 0, row 3 position (index 3)\r\n * @param {Number} m10 Component in column 1, row 0 position (index 4)\r\n * @param {Number} m11 Component in column 1, row 1 position (index 5)\r\n * @param {Number} m12 Component in column 1, row 2 position (index 6)\r\n * @param {Number} m13 Component in column 1, row 3 position (index 7)\r\n * @param {Number} m20 Component in column 2, row 0 position (index 8)\r\n * @param {Number} m21 Component in column 2, row 1 position (index 9)\r\n * @param {Number} m22 Component in column 2, row 2 position (index 10)\r\n * @param {Number} m23 Component in column 2, row 3 position (index 11)\r\n * @param {Number} m30 Component in column 3, row 0 position (index 12)\r\n * @param {Number} m31 Component in column 3, row 1 position (index 13)\r\n * @param {Number} m32 Component in column 3, row 2 position (index 14)\r\n * @param {Number} m33 Component in column 3, row 3 position (index 15)\r\n * @returns {mat4} out\r\n */\r\nexport function set(out, m00, m01, m02, m03, m10, m11, m12, m13, m20, m21, m22, m23, m30, m31, m32, m33) {\r\n out[0] = m00;\r\n out[1] = m01;\r\n out[2] = m02;\r\n out[3] = m03;\r\n out[4] = m10;\r\n out[5] = m11;\r\n out[6] = m12;\r\n out[7] = m13;\r\n out[8] = m20;\r\n out[9] = m21;\r\n out[10] = m22;\r\n out[11] = m23;\r\n out[12] = m30;\r\n out[13] = m31;\r\n out[14] = m32;\r\n out[15] = m33;\r\n return out;\r\n}\r\n\r\n/**\r\n * Set a mat4 to the identity matrix\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @returns {mat4} out\r\n */\r\nexport function identity(out) {\r\n out[0] = 1;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = 0;\r\n out[5] = 1;\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = 0;\r\n out[9] = 0;\r\n out[10] = 1;\r\n out[11] = 0;\r\n out[12] = 0;\r\n out[13] = 0;\r\n out[14] = 0;\r\n out[15] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Transpose the values of a mat4\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the source matrix\r\n * @returns {mat4} out\r\n */\r\nexport function transpose(out, a) {\r\n // If we are transposing ourselves we can skip a few steps but have to cache some values\r\n if (out === a) {\r\n var a01 = a[1],\r\n a02 = a[2],\r\n a03 = a[3];\r\n var a12 = a[6],\r\n a13 = a[7];\r\n var a23 = a[11];\r\n\r\n out[1] = a[4];\r\n out[2] = a[8];\r\n out[3] = a[12];\r\n out[4] = a01;\r\n out[6] = a[9];\r\n out[7] = a[13];\r\n out[8] = a02;\r\n out[9] = a12;\r\n out[11] = a[14];\r\n out[12] = a03;\r\n out[13] = a13;\r\n out[14] = a23;\r\n } else {\r\n out[0] = a[0];\r\n out[1] = a[4];\r\n out[2] = a[8];\r\n out[3] = a[12];\r\n out[4] = a[1];\r\n out[5] = a[5];\r\n out[6] = a[9];\r\n out[7] = a[13];\r\n out[8] = a[2];\r\n out[9] = a[6];\r\n out[10] = a[10];\r\n out[11] = a[14];\r\n out[12] = a[3];\r\n out[13] = a[7];\r\n out[14] = a[11];\r\n out[15] = a[15];\r\n }\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Inverts a mat4\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the source matrix\r\n * @returns {mat4} out\r\n */\r\nexport function invert(out, a) {\r\n var a00 = a[0],\r\n a01 = a[1],\r\n a02 = a[2],\r\n a03 = a[3];\r\n var a10 = a[4],\r\n a11 = a[5],\r\n a12 = a[6],\r\n a13 = a[7];\r\n var a20 = a[8],\r\n a21 = a[9],\r\n a22 = a[10],\r\n a23 = a[11];\r\n var a30 = a[12],\r\n a31 = a[13],\r\n a32 = a[14],\r\n a33 = a[15];\r\n\r\n var b00 = a00 * a11 - a01 * a10;\r\n var b01 = a00 * a12 - a02 * a10;\r\n var b02 = a00 * a13 - a03 * a10;\r\n var b03 = a01 * a12 - a02 * a11;\r\n var b04 = a01 * a13 - a03 * a11;\r\n var b05 = a02 * a13 - a03 * a12;\r\n var b06 = a20 * a31 - a21 * a30;\r\n var b07 = a20 * a32 - a22 * a30;\r\n var b08 = a20 * a33 - a23 * a30;\r\n var b09 = a21 * a32 - a22 * a31;\r\n var b10 = a21 * a33 - a23 * a31;\r\n var b11 = a22 * a33 - a23 * a32;\r\n\r\n // Calculate the determinant\r\n var det = b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\r\n\r\n if (!det) {\r\n return null;\r\n }\r\n det = 1.0 / det;\r\n\r\n out[0] = (a11 * b11 - a12 * b10 + a13 * b09) * det;\r\n out[1] = (a02 * b10 - a01 * b11 - a03 * b09) * det;\r\n out[2] = (a31 * b05 - a32 * b04 + a33 * b03) * det;\r\n out[3] = (a22 * b04 - a21 * b05 - a23 * b03) * det;\r\n out[4] = (a12 * b08 - a10 * b11 - a13 * b07) * det;\r\n out[5] = (a00 * b11 - a02 * b08 + a03 * b07) * det;\r\n out[6] = (a32 * b02 - a30 * b05 - a33 * b01) * det;\r\n out[7] = (a20 * b05 - a22 * b02 + a23 * b01) * det;\r\n out[8] = (a10 * b10 - a11 * b08 + a13 * b06) * det;\r\n out[9] = (a01 * b08 - a00 * b10 - a03 * b06) * det;\r\n out[10] = (a30 * b04 - a31 * b02 + a33 * b00) * det;\r\n out[11] = (a21 * b02 - a20 * b04 - a23 * b00) * det;\r\n out[12] = (a11 * b07 - a10 * b09 - a12 * b06) * det;\r\n out[13] = (a00 * b09 - a01 * b07 + a02 * b06) * det;\r\n out[14] = (a31 * b01 - a30 * b03 - a32 * b00) * det;\r\n out[15] = (a20 * b03 - a21 * b01 + a22 * b00) * det;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the adjugate of a mat4\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the source matrix\r\n * @returns {mat4} out\r\n */\r\nexport function adjoint(out, a) {\r\n var a00 = a[0],\r\n a01 = a[1],\r\n a02 = a[2],\r\n a03 = a[3];\r\n var a10 = a[4],\r\n a11 = a[5],\r\n a12 = a[6],\r\n a13 = a[7];\r\n var a20 = a[8],\r\n a21 = a[9],\r\n a22 = a[10],\r\n a23 = a[11];\r\n var a30 = a[12],\r\n a31 = a[13],\r\n a32 = a[14],\r\n a33 = a[15];\r\n\r\n out[0] = a11 * (a22 * a33 - a23 * a32) - a21 * (a12 * a33 - a13 * a32) + a31 * (a12 * a23 - a13 * a22);\r\n out[1] = -(a01 * (a22 * a33 - a23 * a32) - a21 * (a02 * a33 - a03 * a32) + a31 * (a02 * a23 - a03 * a22));\r\n out[2] = a01 * (a12 * a33 - a13 * a32) - a11 * (a02 * a33 - a03 * a32) + a31 * (a02 * a13 - a03 * a12);\r\n out[3] = -(a01 * (a12 * a23 - a13 * a22) - a11 * (a02 * a23 - a03 * a22) + a21 * (a02 * a13 - a03 * a12));\r\n out[4] = -(a10 * (a22 * a33 - a23 * a32) - a20 * (a12 * a33 - a13 * a32) + a30 * (a12 * a23 - a13 * a22));\r\n out[5] = a00 * (a22 * a33 - a23 * a32) - a20 * (a02 * a33 - a03 * a32) + a30 * (a02 * a23 - a03 * a22);\r\n out[6] = -(a00 * (a12 * a33 - a13 * a32) - a10 * (a02 * a33 - a03 * a32) + a30 * (a02 * a13 - a03 * a12));\r\n out[7] = a00 * (a12 * a23 - a13 * a22) - a10 * (a02 * a23 - a03 * a22) + a20 * (a02 * a13 - a03 * a12);\r\n out[8] = a10 * (a21 * a33 - a23 * a31) - a20 * (a11 * a33 - a13 * a31) + a30 * (a11 * a23 - a13 * a21);\r\n out[9] = -(a00 * (a21 * a33 - a23 * a31) - a20 * (a01 * a33 - a03 * a31) + a30 * (a01 * a23 - a03 * a21));\r\n out[10] = a00 * (a11 * a33 - a13 * a31) - a10 * (a01 * a33 - a03 * a31) + a30 * (a01 * a13 - a03 * a11);\r\n out[11] = -(a00 * (a11 * a23 - a13 * a21) - a10 * (a01 * a23 - a03 * a21) + a20 * (a01 * a13 - a03 * a11));\r\n out[12] = -(a10 * (a21 * a32 - a22 * a31) - a20 * (a11 * a32 - a12 * a31) + a30 * (a11 * a22 - a12 * a21));\r\n out[13] = a00 * (a21 * a32 - a22 * a31) - a20 * (a01 * a32 - a02 * a31) + a30 * (a01 * a22 - a02 * a21);\r\n out[14] = -(a00 * (a11 * a32 - a12 * a31) - a10 * (a01 * a32 - a02 * a31) + a30 * (a01 * a12 - a02 * a11));\r\n out[15] = a00 * (a11 * a22 - a12 * a21) - a10 * (a01 * a22 - a02 * a21) + a20 * (a01 * a12 - a02 * a11);\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the determinant of a mat4\r\n *\r\n * @param {mat4} a the source matrix\r\n * @returns {Number} determinant of a\r\n */\r\nexport function determinant(a) {\r\n var a00 = a[0],\r\n a01 = a[1],\r\n a02 = a[2],\r\n a03 = a[3];\r\n var a10 = a[4],\r\n a11 = a[5],\r\n a12 = a[6],\r\n a13 = a[7];\r\n var a20 = a[8],\r\n a21 = a[9],\r\n a22 = a[10],\r\n a23 = a[11];\r\n var a30 = a[12],\r\n a31 = a[13],\r\n a32 = a[14],\r\n a33 = a[15];\r\n\r\n var b00 = a00 * a11 - a01 * a10;\r\n var b01 = a00 * a12 - a02 * a10;\r\n var b02 = a00 * a13 - a03 * a10;\r\n var b03 = a01 * a12 - a02 * a11;\r\n var b04 = a01 * a13 - a03 * a11;\r\n var b05 = a02 * a13 - a03 * a12;\r\n var b06 = a20 * a31 - a21 * a30;\r\n var b07 = a20 * a32 - a22 * a30;\r\n var b08 = a20 * a33 - a23 * a30;\r\n var b09 = a21 * a32 - a22 * a31;\r\n var b10 = a21 * a33 - a23 * a31;\r\n var b11 = a22 * a33 - a23 * a32;\r\n\r\n // Calculate the determinant\r\n return b00 * b11 - b01 * b10 + b02 * b09 + b03 * b08 - b04 * b07 + b05 * b06;\r\n}\r\n\r\n/**\r\n * Multiplies two mat4s\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the first operand\r\n * @param {mat4} b the second operand\r\n * @returns {mat4} out\r\n */\r\nexport function multiply(out, a, b) {\r\n var a00 = a[0],\r\n a01 = a[1],\r\n a02 = a[2],\r\n a03 = a[3];\r\n var a10 = a[4],\r\n a11 = a[5],\r\n a12 = a[6],\r\n a13 = a[7];\r\n var a20 = a[8],\r\n a21 = a[9],\r\n a22 = a[10],\r\n a23 = a[11];\r\n var a30 = a[12],\r\n a31 = a[13],\r\n a32 = a[14],\r\n a33 = a[15];\r\n\r\n // Cache only the current line of the second matrix\r\n var b0 = b[0],\r\n b1 = b[1],\r\n b2 = b[2],\r\n b3 = b[3];\r\n out[0] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\r\n out[1] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\r\n out[2] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\r\n out[3] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\r\n\r\n b0 = b[4];b1 = b[5];b2 = b[6];b3 = b[7];\r\n out[4] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\r\n out[5] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\r\n out[6] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\r\n out[7] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\r\n\r\n b0 = b[8];b1 = b[9];b2 = b[10];b3 = b[11];\r\n out[8] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\r\n out[9] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\r\n out[10] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\r\n out[11] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\r\n\r\n b0 = b[12];b1 = b[13];b2 = b[14];b3 = b[15];\r\n out[12] = b0 * a00 + b1 * a10 + b2 * a20 + b3 * a30;\r\n out[13] = b0 * a01 + b1 * a11 + b2 * a21 + b3 * a31;\r\n out[14] = b0 * a02 + b1 * a12 + b2 * a22 + b3 * a32;\r\n out[15] = b0 * a03 + b1 * a13 + b2 * a23 + b3 * a33;\r\n return out;\r\n}\r\n\r\n/**\r\n * Translate a mat4 by the given vector\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the matrix to translate\r\n * @param {vec3} v vector to translate by\r\n * @returns {mat4} out\r\n */\r\nexport function translate(out, a, v) {\r\n var x = v[0],\r\n y = v[1],\r\n z = v[2];\r\n var a00 = void 0,\r\n a01 = void 0,\r\n a02 = void 0,\r\n a03 = void 0;\r\n var a10 = void 0,\r\n a11 = void 0,\r\n a12 = void 0,\r\n a13 = void 0;\r\n var a20 = void 0,\r\n a21 = void 0,\r\n a22 = void 0,\r\n a23 = void 0;\r\n\r\n if (a === out) {\r\n out[12] = a[0] * x + a[4] * y + a[8] * z + a[12];\r\n out[13] = a[1] * x + a[5] * y + a[9] * z + a[13];\r\n out[14] = a[2] * x + a[6] * y + a[10] * z + a[14];\r\n out[15] = a[3] * x + a[7] * y + a[11] * z + a[15];\r\n } else {\r\n a00 = a[0];a01 = a[1];a02 = a[2];a03 = a[3];\r\n a10 = a[4];a11 = a[5];a12 = a[6];a13 = a[7];\r\n a20 = a[8];a21 = a[9];a22 = a[10];a23 = a[11];\r\n\r\n out[0] = a00;out[1] = a01;out[2] = a02;out[3] = a03;\r\n out[4] = a10;out[5] = a11;out[6] = a12;out[7] = a13;\r\n out[8] = a20;out[9] = a21;out[10] = a22;out[11] = a23;\r\n\r\n out[12] = a00 * x + a10 * y + a20 * z + a[12];\r\n out[13] = a01 * x + a11 * y + a21 * z + a[13];\r\n out[14] = a02 * x + a12 * y + a22 * z + a[14];\r\n out[15] = a03 * x + a13 * y + a23 * z + a[15];\r\n }\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Scales the mat4 by the dimensions in the given vec3 not using vectorization\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the matrix to scale\r\n * @param {vec3} v the vec3 to scale the matrix by\r\n * @returns {mat4} out\r\n **/\r\nexport function scale(out, a, v) {\r\n var x = v[0],\r\n y = v[1],\r\n z = v[2];\r\n\r\n out[0] = a[0] * x;\r\n out[1] = a[1] * x;\r\n out[2] = a[2] * x;\r\n out[3] = a[3] * x;\r\n out[4] = a[4] * y;\r\n out[5] = a[5] * y;\r\n out[6] = a[6] * y;\r\n out[7] = a[7] * y;\r\n out[8] = a[8] * z;\r\n out[9] = a[9] * z;\r\n out[10] = a[10] * z;\r\n out[11] = a[11] * z;\r\n out[12] = a[12];\r\n out[13] = a[13];\r\n out[14] = a[14];\r\n out[15] = a[15];\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a mat4 by the given angle around the given axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @param {vec3} axis the axis to rotate around\r\n * @returns {mat4} out\r\n */\r\nexport function rotate(out, a, rad, axis) {\r\n var x = axis[0],\r\n y = axis[1],\r\n z = axis[2];\r\n var len = Math.sqrt(x * x + y * y + z * z);\r\n var s = void 0,\r\n c = void 0,\r\n t = void 0;\r\n var a00 = void 0,\r\n a01 = void 0,\r\n a02 = void 0,\r\n a03 = void 0;\r\n var a10 = void 0,\r\n a11 = void 0,\r\n a12 = void 0,\r\n a13 = void 0;\r\n var a20 = void 0,\r\n a21 = void 0,\r\n a22 = void 0,\r\n a23 = void 0;\r\n var b00 = void 0,\r\n b01 = void 0,\r\n b02 = void 0;\r\n var b10 = void 0,\r\n b11 = void 0,\r\n b12 = void 0;\r\n var b20 = void 0,\r\n b21 = void 0,\r\n b22 = void 0;\r\n\r\n if (len < glMatrix.EPSILON) {\r\n return null;\r\n }\r\n\r\n len = 1 / len;\r\n x *= len;\r\n y *= len;\r\n z *= len;\r\n\r\n s = Math.sin(rad);\r\n c = Math.cos(rad);\r\n t = 1 - c;\r\n\r\n a00 = a[0];a01 = a[1];a02 = a[2];a03 = a[3];\r\n a10 = a[4];a11 = a[5];a12 = a[6];a13 = a[7];\r\n a20 = a[8];a21 = a[9];a22 = a[10];a23 = a[11];\r\n\r\n // Construct the elements of the rotation matrix\r\n b00 = x * x * t + c;b01 = y * x * t + z * s;b02 = z * x * t - y * s;\r\n b10 = x * y * t - z * s;b11 = y * y * t + c;b12 = z * y * t + x * s;\r\n b20 = x * z * t + y * s;b21 = y * z * t - x * s;b22 = z * z * t + c;\r\n\r\n // Perform rotation-specific matrix multiplication\r\n out[0] = a00 * b00 + a10 * b01 + a20 * b02;\r\n out[1] = a01 * b00 + a11 * b01 + a21 * b02;\r\n out[2] = a02 * b00 + a12 * b01 + a22 * b02;\r\n out[3] = a03 * b00 + a13 * b01 + a23 * b02;\r\n out[4] = a00 * b10 + a10 * b11 + a20 * b12;\r\n out[5] = a01 * b10 + a11 * b11 + a21 * b12;\r\n out[6] = a02 * b10 + a12 * b11 + a22 * b12;\r\n out[7] = a03 * b10 + a13 * b11 + a23 * b12;\r\n out[8] = a00 * b20 + a10 * b21 + a20 * b22;\r\n out[9] = a01 * b20 + a11 * b21 + a21 * b22;\r\n out[10] = a02 * b20 + a12 * b21 + a22 * b22;\r\n out[11] = a03 * b20 + a13 * b21 + a23 * b22;\r\n\r\n if (a !== out) {\r\n // If the source and destination differ, copy the unchanged last row\r\n out[12] = a[12];\r\n out[13] = a[13];\r\n out[14] = a[14];\r\n out[15] = a[15];\r\n }\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a matrix by the given angle around the X axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\r\nexport function rotateX(out, a, rad) {\r\n var s = Math.sin(rad);\r\n var c = Math.cos(rad);\r\n var a10 = a[4];\r\n var a11 = a[5];\r\n var a12 = a[6];\r\n var a13 = a[7];\r\n var a20 = a[8];\r\n var a21 = a[9];\r\n var a22 = a[10];\r\n var a23 = a[11];\r\n\r\n if (a !== out) {\r\n // If the source and destination differ, copy the unchanged rows\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n out[12] = a[12];\r\n out[13] = a[13];\r\n out[14] = a[14];\r\n out[15] = a[15];\r\n }\r\n\r\n // Perform axis-specific matrix multiplication\r\n out[4] = a10 * c + a20 * s;\r\n out[5] = a11 * c + a21 * s;\r\n out[6] = a12 * c + a22 * s;\r\n out[7] = a13 * c + a23 * s;\r\n out[8] = a20 * c - a10 * s;\r\n out[9] = a21 * c - a11 * s;\r\n out[10] = a22 * c - a12 * s;\r\n out[11] = a23 * c - a13 * s;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a matrix by the given angle around the Y axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\r\nexport function rotateY(out, a, rad) {\r\n var s = Math.sin(rad);\r\n var c = Math.cos(rad);\r\n var a00 = a[0];\r\n var a01 = a[1];\r\n var a02 = a[2];\r\n var a03 = a[3];\r\n var a20 = a[8];\r\n var a21 = a[9];\r\n var a22 = a[10];\r\n var a23 = a[11];\r\n\r\n if (a !== out) {\r\n // If the source and destination differ, copy the unchanged rows\r\n out[4] = a[4];\r\n out[5] = a[5];\r\n out[6] = a[6];\r\n out[7] = a[7];\r\n out[12] = a[12];\r\n out[13] = a[13];\r\n out[14] = a[14];\r\n out[15] = a[15];\r\n }\r\n\r\n // Perform axis-specific matrix multiplication\r\n out[0] = a00 * c - a20 * s;\r\n out[1] = a01 * c - a21 * s;\r\n out[2] = a02 * c - a22 * s;\r\n out[3] = a03 * c - a23 * s;\r\n out[8] = a00 * s + a20 * c;\r\n out[9] = a01 * s + a21 * c;\r\n out[10] = a02 * s + a22 * c;\r\n out[11] = a03 * s + a23 * c;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a matrix by the given angle around the Z axis\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the matrix to rotate\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\r\nexport function rotateZ(out, a, rad) {\r\n var s = Math.sin(rad);\r\n var c = Math.cos(rad);\r\n var a00 = a[0];\r\n var a01 = a[1];\r\n var a02 = a[2];\r\n var a03 = a[3];\r\n var a10 = a[4];\r\n var a11 = a[5];\r\n var a12 = a[6];\r\n var a13 = a[7];\r\n\r\n if (a !== out) {\r\n // If the source and destination differ, copy the unchanged last row\r\n out[8] = a[8];\r\n out[9] = a[9];\r\n out[10] = a[10];\r\n out[11] = a[11];\r\n out[12] = a[12];\r\n out[13] = a[13];\r\n out[14] = a[14];\r\n out[15] = a[15];\r\n }\r\n\r\n // Perform axis-specific matrix multiplication\r\n out[0] = a00 * c + a10 * s;\r\n out[1] = a01 * c + a11 * s;\r\n out[2] = a02 * c + a12 * s;\r\n out[3] = a03 * c + a13 * s;\r\n out[4] = a10 * c - a00 * s;\r\n out[5] = a11 * c - a01 * s;\r\n out[6] = a12 * c - a02 * s;\r\n out[7] = a13 * c - a03 * s;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a vector translation\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, dest, vec);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {vec3} v Translation vector\r\n * @returns {mat4} out\r\n */\r\nexport function fromTranslation(out, v) {\r\n out[0] = 1;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = 0;\r\n out[5] = 1;\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = 0;\r\n out[9] = 0;\r\n out[10] = 1;\r\n out[11] = 0;\r\n out[12] = v[0];\r\n out[13] = v[1];\r\n out[14] = v[2];\r\n out[15] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a vector scaling\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.scale(dest, dest, vec);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {vec3} v Scaling vector\r\n * @returns {mat4} out\r\n */\r\nexport function fromScaling(out, v) {\r\n out[0] = v[0];\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = 0;\r\n out[5] = v[1];\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = 0;\r\n out[9] = 0;\r\n out[10] = v[2];\r\n out[11] = 0;\r\n out[12] = 0;\r\n out[13] = 0;\r\n out[14] = 0;\r\n out[15] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a given angle around a given axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotate(dest, dest, rad, axis);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @param {vec3} axis the axis to rotate around\r\n * @returns {mat4} out\r\n */\r\nexport function fromRotation(out, rad, axis) {\r\n var x = axis[0],\r\n y = axis[1],\r\n z = axis[2];\r\n var len = Math.sqrt(x * x + y * y + z * z);\r\n var s = void 0,\r\n c = void 0,\r\n t = void 0;\r\n\r\n if (len < glMatrix.EPSILON) {\r\n return null;\r\n }\r\n\r\n len = 1 / len;\r\n x *= len;\r\n y *= len;\r\n z *= len;\r\n\r\n s = Math.sin(rad);\r\n c = Math.cos(rad);\r\n t = 1 - c;\r\n\r\n // Perform rotation-specific matrix multiplication\r\n out[0] = x * x * t + c;\r\n out[1] = y * x * t + z * s;\r\n out[2] = z * x * t - y * s;\r\n out[3] = 0;\r\n out[4] = x * y * t - z * s;\r\n out[5] = y * y * t + c;\r\n out[6] = z * y * t + x * s;\r\n out[7] = 0;\r\n out[8] = x * z * t + y * s;\r\n out[9] = y * z * t - x * s;\r\n out[10] = z * z * t + c;\r\n out[11] = 0;\r\n out[12] = 0;\r\n out[13] = 0;\r\n out[14] = 0;\r\n out[15] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from the given angle around the X axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotateX(dest, dest, rad);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\r\nexport function fromXRotation(out, rad) {\r\n var s = Math.sin(rad);\r\n var c = Math.cos(rad);\r\n\r\n // Perform axis-specific matrix multiplication\r\n out[0] = 1;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = 0;\r\n out[5] = c;\r\n out[6] = s;\r\n out[7] = 0;\r\n out[8] = 0;\r\n out[9] = -s;\r\n out[10] = c;\r\n out[11] = 0;\r\n out[12] = 0;\r\n out[13] = 0;\r\n out[14] = 0;\r\n out[15] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from the given angle around the Y axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotateY(dest, dest, rad);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\r\nexport function fromYRotation(out, rad) {\r\n var s = Math.sin(rad);\r\n var c = Math.cos(rad);\r\n\r\n // Perform axis-specific matrix multiplication\r\n out[0] = c;\r\n out[1] = 0;\r\n out[2] = -s;\r\n out[3] = 0;\r\n out[4] = 0;\r\n out[5] = 1;\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = s;\r\n out[9] = 0;\r\n out[10] = c;\r\n out[11] = 0;\r\n out[12] = 0;\r\n out[13] = 0;\r\n out[14] = 0;\r\n out[15] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from the given angle around the Z axis\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.rotateZ(dest, dest, rad);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {Number} rad the angle to rotate the matrix by\r\n * @returns {mat4} out\r\n */\r\nexport function fromZRotation(out, rad) {\r\n var s = Math.sin(rad);\r\n var c = Math.cos(rad);\r\n\r\n // Perform axis-specific matrix multiplication\r\n out[0] = c;\r\n out[1] = s;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = -s;\r\n out[5] = c;\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = 0;\r\n out[9] = 0;\r\n out[10] = 1;\r\n out[11] = 0;\r\n out[12] = 0;\r\n out[13] = 0;\r\n out[14] = 0;\r\n out[15] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a quaternion rotation and vector translation\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, vec);\r\n * let quatMat = mat4.create();\r\n * quat4.toMat4(quat, quatMat);\r\n * mat4.multiply(dest, quatMat);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {quat4} q Rotation quaternion\r\n * @param {vec3} v Translation vector\r\n * @returns {mat4} out\r\n */\r\nexport function fromRotationTranslation(out, q, v) {\r\n // Quaternion math\r\n var x = q[0],\r\n y = q[1],\r\n z = q[2],\r\n w = q[3];\r\n var x2 = x + x;\r\n var y2 = y + y;\r\n var z2 = z + z;\r\n\r\n var xx = x * x2;\r\n var xy = x * y2;\r\n var xz = x * z2;\r\n var yy = y * y2;\r\n var yz = y * z2;\r\n var zz = z * z2;\r\n var wx = w * x2;\r\n var wy = w * y2;\r\n var wz = w * z2;\r\n\r\n out[0] = 1 - (yy + zz);\r\n out[1] = xy + wz;\r\n out[2] = xz - wy;\r\n out[3] = 0;\r\n out[4] = xy - wz;\r\n out[5] = 1 - (xx + zz);\r\n out[6] = yz + wx;\r\n out[7] = 0;\r\n out[8] = xz + wy;\r\n out[9] = yz - wx;\r\n out[10] = 1 - (xx + yy);\r\n out[11] = 0;\r\n out[12] = v[0];\r\n out[13] = v[1];\r\n out[14] = v[2];\r\n out[15] = 1;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a new mat4 from a dual quat.\r\n *\r\n * @param {mat4} out Matrix\r\n * @param {quat2} a Dual Quaternion\r\n * @returns {mat4} mat4 receiving operation result\r\n */\r\nexport function fromQuat2(out, a) {\r\n var translation = new glMatrix.ARRAY_TYPE(3);\r\n var bx = -a[0],\r\n by = -a[1],\r\n bz = -a[2],\r\n bw = a[3],\r\n ax = a[4],\r\n ay = a[5],\r\n az = a[6],\r\n aw = a[7];\r\n\r\n var magnitude = bx * bx + by * by + bz * bz + bw * bw;\r\n //Only scale if it makes sense\r\n if (magnitude > 0) {\r\n translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2 / magnitude;\r\n translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2 / magnitude;\r\n translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2 / magnitude;\r\n } else {\r\n translation[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;\r\n translation[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;\r\n translation[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;\r\n }\r\n fromRotationTranslation(out, a, translation);\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns the translation vector component of a transformation\r\n * matrix. If a matrix is built with fromRotationTranslation,\r\n * the returned vector will be the same as the translation vector\r\n * originally supplied.\r\n * @param {vec3} out Vector to receive translation component\r\n * @param {mat4} mat Matrix to be decomposed (input)\r\n * @return {vec3} out\r\n */\r\nexport function getTranslation(out, mat) {\r\n out[0] = mat[12];\r\n out[1] = mat[13];\r\n out[2] = mat[14];\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns the scaling factor component of a transformation\r\n * matrix. If a matrix is built with fromRotationTranslationScale\r\n * with a normalized Quaternion paramter, the returned vector will be\r\n * the same as the scaling vector\r\n * originally supplied.\r\n * @param {vec3} out Vector to receive scaling factor component\r\n * @param {mat4} mat Matrix to be decomposed (input)\r\n * @return {vec3} out\r\n */\r\nexport function getScaling(out, mat) {\r\n var m11 = mat[0];\r\n var m12 = mat[1];\r\n var m13 = mat[2];\r\n var m21 = mat[4];\r\n var m22 = mat[5];\r\n var m23 = mat[6];\r\n var m31 = mat[8];\r\n var m32 = mat[9];\r\n var m33 = mat[10];\r\n\r\n out[0] = Math.sqrt(m11 * m11 + m12 * m12 + m13 * m13);\r\n out[1] = Math.sqrt(m21 * m21 + m22 * m22 + m23 * m23);\r\n out[2] = Math.sqrt(m31 * m31 + m32 * m32 + m33 * m33);\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns a quaternion representing the rotational component\r\n * of a transformation matrix. If a matrix is built with\r\n * fromRotationTranslation, the returned quaternion will be the\r\n * same as the quaternion originally supplied.\r\n * @param {quat} out Quaternion to receive the rotation component\r\n * @param {mat4} mat Matrix to be decomposed (input)\r\n * @return {quat} out\r\n */\r\nexport function getRotation(out, mat) {\r\n // Algorithm taken from http://www.euclideanspace.com/maths/geometry/rotations/conversions/matrixToQuaternion/index.htm\r\n var trace = mat[0] + mat[5] + mat[10];\r\n var S = 0;\r\n\r\n if (trace > 0) {\r\n S = Math.sqrt(trace + 1.0) * 2;\r\n out[3] = 0.25 * S;\r\n out[0] = (mat[6] - mat[9]) / S;\r\n out[1] = (mat[8] - mat[2]) / S;\r\n out[2] = (mat[1] - mat[4]) / S;\r\n } else if (mat[0] > mat[5] && mat[0] > mat[10]) {\r\n S = Math.sqrt(1.0 + mat[0] - mat[5] - mat[10]) * 2;\r\n out[3] = (mat[6] - mat[9]) / S;\r\n out[0] = 0.25 * S;\r\n out[1] = (mat[1] + mat[4]) / S;\r\n out[2] = (mat[8] + mat[2]) / S;\r\n } else if (mat[5] > mat[10]) {\r\n S = Math.sqrt(1.0 + mat[5] - mat[0] - mat[10]) * 2;\r\n out[3] = (mat[8] - mat[2]) / S;\r\n out[0] = (mat[1] + mat[4]) / S;\r\n out[1] = 0.25 * S;\r\n out[2] = (mat[6] + mat[9]) / S;\r\n } else {\r\n S = Math.sqrt(1.0 + mat[10] - mat[0] - mat[5]) * 2;\r\n out[3] = (mat[1] - mat[4]) / S;\r\n out[0] = (mat[8] + mat[2]) / S;\r\n out[1] = (mat[6] + mat[9]) / S;\r\n out[2] = 0.25 * S;\r\n }\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a quaternion rotation, vector translation and vector scale\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, vec);\r\n * let quatMat = mat4.create();\r\n * quat4.toMat4(quat, quatMat);\r\n * mat4.multiply(dest, quatMat);\r\n * mat4.scale(dest, scale)\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {quat4} q Rotation quaternion\r\n * @param {vec3} v Translation vector\r\n * @param {vec3} s Scaling vector\r\n * @returns {mat4} out\r\n */\r\nexport function fromRotationTranslationScale(out, q, v, s) {\r\n // Quaternion math\r\n var x = q[0],\r\n y = q[1],\r\n z = q[2],\r\n w = q[3];\r\n var x2 = x + x;\r\n var y2 = y + y;\r\n var z2 = z + z;\r\n\r\n var xx = x * x2;\r\n var xy = x * y2;\r\n var xz = x * z2;\r\n var yy = y * y2;\r\n var yz = y * z2;\r\n var zz = z * z2;\r\n var wx = w * x2;\r\n var wy = w * y2;\r\n var wz = w * z2;\r\n var sx = s[0];\r\n var sy = s[1];\r\n var sz = s[2];\r\n\r\n out[0] = (1 - (yy + zz)) * sx;\r\n out[1] = (xy + wz) * sx;\r\n out[2] = (xz - wy) * sx;\r\n out[3] = 0;\r\n out[4] = (xy - wz) * sy;\r\n out[5] = (1 - (xx + zz)) * sy;\r\n out[6] = (yz + wx) * sy;\r\n out[7] = 0;\r\n out[8] = (xz + wy) * sz;\r\n out[9] = (yz - wx) * sz;\r\n out[10] = (1 - (xx + yy)) * sz;\r\n out[11] = 0;\r\n out[12] = v[0];\r\n out[13] = v[1];\r\n out[14] = v[2];\r\n out[15] = 1;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a matrix from a quaternion rotation, vector translation and vector scale, rotating and scaling around the given origin\r\n * This is equivalent to (but much faster than):\r\n *\r\n * mat4.identity(dest);\r\n * mat4.translate(dest, vec);\r\n * mat4.translate(dest, origin);\r\n * let quatMat = mat4.create();\r\n * quat4.toMat4(quat, quatMat);\r\n * mat4.multiply(dest, quatMat);\r\n * mat4.scale(dest, scale)\r\n * mat4.translate(dest, negativeOrigin);\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {quat4} q Rotation quaternion\r\n * @param {vec3} v Translation vector\r\n * @param {vec3} s Scaling vector\r\n * @param {vec3} o The origin vector around which to scale and rotate\r\n * @returns {mat4} out\r\n */\r\nexport function fromRotationTranslationScaleOrigin(out, q, v, s, o) {\r\n // Quaternion math\r\n var x = q[0],\r\n y = q[1],\r\n z = q[2],\r\n w = q[3];\r\n var x2 = x + x;\r\n var y2 = y + y;\r\n var z2 = z + z;\r\n\r\n var xx = x * x2;\r\n var xy = x * y2;\r\n var xz = x * z2;\r\n var yy = y * y2;\r\n var yz = y * z2;\r\n var zz = z * z2;\r\n var wx = w * x2;\r\n var wy = w * y2;\r\n var wz = w * z2;\r\n\r\n var sx = s[0];\r\n var sy = s[1];\r\n var sz = s[2];\r\n\r\n var ox = o[0];\r\n var oy = o[1];\r\n var oz = o[2];\r\n\r\n var out0 = (1 - (yy + zz)) * sx;\r\n var out1 = (xy + wz) * sx;\r\n var out2 = (xz - wy) * sx;\r\n var out4 = (xy - wz) * sy;\r\n var out5 = (1 - (xx + zz)) * sy;\r\n var out6 = (yz + wx) * sy;\r\n var out8 = (xz + wy) * sz;\r\n var out9 = (yz - wx) * sz;\r\n var out10 = (1 - (xx + yy)) * sz;\r\n\r\n out[0] = out0;\r\n out[1] = out1;\r\n out[2] = out2;\r\n out[3] = 0;\r\n out[4] = out4;\r\n out[5] = out5;\r\n out[6] = out6;\r\n out[7] = 0;\r\n out[8] = out8;\r\n out[9] = out9;\r\n out[10] = out10;\r\n out[11] = 0;\r\n out[12] = v[0] + ox - (out0 * ox + out4 * oy + out8 * oz);\r\n out[13] = v[1] + oy - (out1 * ox + out5 * oy + out9 * oz);\r\n out[14] = v[2] + oz - (out2 * ox + out6 * oy + out10 * oz);\r\n out[15] = 1;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates a 4x4 matrix from the given quaternion\r\n *\r\n * @param {mat4} out mat4 receiving operation result\r\n * @param {quat} q Quaternion to create matrix from\r\n *\r\n * @returns {mat4} out\r\n */\r\nexport function fromQuat(out, q) {\r\n var x = q[0],\r\n y = q[1],\r\n z = q[2],\r\n w = q[3];\r\n var x2 = x + x;\r\n var y2 = y + y;\r\n var z2 = z + z;\r\n\r\n var xx = x * x2;\r\n var yx = y * x2;\r\n var yy = y * y2;\r\n var zx = z * x2;\r\n var zy = z * y2;\r\n var zz = z * z2;\r\n var wx = w * x2;\r\n var wy = w * y2;\r\n var wz = w * z2;\r\n\r\n out[0] = 1 - yy - zz;\r\n out[1] = yx + wz;\r\n out[2] = zx - wy;\r\n out[3] = 0;\r\n\r\n out[4] = yx - wz;\r\n out[5] = 1 - xx - zz;\r\n out[6] = zy + wx;\r\n out[7] = 0;\r\n\r\n out[8] = zx + wy;\r\n out[9] = zy - wx;\r\n out[10] = 1 - xx - yy;\r\n out[11] = 0;\r\n\r\n out[12] = 0;\r\n out[13] = 0;\r\n out[14] = 0;\r\n out[15] = 1;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Generates a frustum matrix with the given bounds\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {Number} left Left bound of the frustum\r\n * @param {Number} right Right bound of the frustum\r\n * @param {Number} bottom Bottom bound of the frustum\r\n * @param {Number} top Top bound of the frustum\r\n * @param {Number} near Near bound of the frustum\r\n * @param {Number} far Far bound of the frustum\r\n * @returns {mat4} out\r\n */\r\nexport function frustum(out, left, right, bottom, top, near, far) {\r\n var rl = 1 / (right - left);\r\n var tb = 1 / (top - bottom);\r\n var nf = 1 / (near - far);\r\n out[0] = near * 2 * rl;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = 0;\r\n out[5] = near * 2 * tb;\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = (right + left) * rl;\r\n out[9] = (top + bottom) * tb;\r\n out[10] = (far + near) * nf;\r\n out[11] = -1;\r\n out[12] = 0;\r\n out[13] = 0;\r\n out[14] = far * near * 2 * nf;\r\n out[15] = 0;\r\n return out;\r\n}\r\n\r\n/**\r\n * Generates a perspective projection matrix with the given bounds.\r\n * Passing null/undefined/no value for far will generate infinite projection matrix.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {number} fovy Vertical field of view in radians\r\n * @param {number} aspect Aspect ratio. typically viewport width/height\r\n * @param {number} near Near bound of the frustum\r\n * @param {number} far Far bound of the frustum, can be null or Infinity\r\n * @returns {mat4} out\r\n */\r\nexport function perspective(out, fovy, aspect, near, far) {\r\n var f = 1.0 / Math.tan(fovy / 2),\r\n nf = void 0;\r\n out[0] = f / aspect;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = 0;\r\n out[5] = f;\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = 0;\r\n out[9] = 0;\r\n out[11] = -1;\r\n out[12] = 0;\r\n out[13] = 0;\r\n out[15] = 0;\r\n if (far != null && far !== Infinity) {\r\n nf = 1 / (near - far);\r\n out[10] = (far + near) * nf;\r\n out[14] = 2 * far * near * nf;\r\n } else {\r\n out[10] = -1;\r\n out[14] = -2 * near;\r\n }\r\n return out;\r\n}\r\n\r\n/**\r\n * Generates a perspective projection matrix with the given field of view.\r\n * This is primarily useful for generating projection matrices to be used\r\n * with the still experiemental WebVR API.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {Object} fov Object containing the following values: upDegrees, downDegrees, leftDegrees, rightDegrees\r\n * @param {number} near Near bound of the frustum\r\n * @param {number} far Far bound of the frustum\r\n * @returns {mat4} out\r\n */\r\nexport function perspectiveFromFieldOfView(out, fov, near, far) {\r\n var upTan = Math.tan(fov.upDegrees * Math.PI / 180.0);\r\n var downTan = Math.tan(fov.downDegrees * Math.PI / 180.0);\r\n var leftTan = Math.tan(fov.leftDegrees * Math.PI / 180.0);\r\n var rightTan = Math.tan(fov.rightDegrees * Math.PI / 180.0);\r\n var xScale = 2.0 / (leftTan + rightTan);\r\n var yScale = 2.0 / (upTan + downTan);\r\n\r\n out[0] = xScale;\r\n out[1] = 0.0;\r\n out[2] = 0.0;\r\n out[3] = 0.0;\r\n out[4] = 0.0;\r\n out[5] = yScale;\r\n out[6] = 0.0;\r\n out[7] = 0.0;\r\n out[8] = -((leftTan - rightTan) * xScale * 0.5);\r\n out[9] = (upTan - downTan) * yScale * 0.5;\r\n out[10] = far / (near - far);\r\n out[11] = -1.0;\r\n out[12] = 0.0;\r\n out[13] = 0.0;\r\n out[14] = far * near / (near - far);\r\n out[15] = 0.0;\r\n return out;\r\n}\r\n\r\n/**\r\n * Generates a orthogonal projection matrix with the given bounds\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {number} left Left bound of the frustum\r\n * @param {number} right Right bound of the frustum\r\n * @param {number} bottom Bottom bound of the frustum\r\n * @param {number} top Top bound of the frustum\r\n * @param {number} near Near bound of the frustum\r\n * @param {number} far Far bound of the frustum\r\n * @returns {mat4} out\r\n */\r\nexport function ortho(out, left, right, bottom, top, near, far) {\r\n var lr = 1 / (left - right);\r\n var bt = 1 / (bottom - top);\r\n var nf = 1 / (near - far);\r\n out[0] = -2 * lr;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n out[4] = 0;\r\n out[5] = -2 * bt;\r\n out[6] = 0;\r\n out[7] = 0;\r\n out[8] = 0;\r\n out[9] = 0;\r\n out[10] = 2 * nf;\r\n out[11] = 0;\r\n out[12] = (left + right) * lr;\r\n out[13] = (top + bottom) * bt;\r\n out[14] = (far + near) * nf;\r\n out[15] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Generates a look-at matrix with the given eye position, focal point, and up axis.\r\n * If you want a matrix that actually makes an object look at another object, you should use targetTo instead.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {vec3} eye Position of the viewer\r\n * @param {vec3} center Point the viewer is looking at\r\n * @param {vec3} up vec3 pointing up\r\n * @returns {mat4} out\r\n */\r\nexport function lookAt(out, eye, center, up) {\r\n var x0 = void 0,\r\n x1 = void 0,\r\n x2 = void 0,\r\n y0 = void 0,\r\n y1 = void 0,\r\n y2 = void 0,\r\n z0 = void 0,\r\n z1 = void 0,\r\n z2 = void 0,\r\n len = void 0;\r\n var eyex = eye[0];\r\n var eyey = eye[1];\r\n var eyez = eye[2];\r\n var upx = up[0];\r\n var upy = up[1];\r\n var upz = up[2];\r\n var centerx = center[0];\r\n var centery = center[1];\r\n var centerz = center[2];\r\n\r\n if (Math.abs(eyex - centerx) < glMatrix.EPSILON && Math.abs(eyey - centery) < glMatrix.EPSILON && Math.abs(eyez - centerz) < glMatrix.EPSILON) {\r\n return identity(out);\r\n }\r\n\r\n z0 = eyex - centerx;\r\n z1 = eyey - centery;\r\n z2 = eyez - centerz;\r\n\r\n len = 1 / Math.sqrt(z0 * z0 + z1 * z1 + z2 * z2);\r\n z0 *= len;\r\n z1 *= len;\r\n z2 *= len;\r\n\r\n x0 = upy * z2 - upz * z1;\r\n x1 = upz * z0 - upx * z2;\r\n x2 = upx * z1 - upy * z0;\r\n len = Math.sqrt(x0 * x0 + x1 * x1 + x2 * x2);\r\n if (!len) {\r\n x0 = 0;\r\n x1 = 0;\r\n x2 = 0;\r\n } else {\r\n len = 1 / len;\r\n x0 *= len;\r\n x1 *= len;\r\n x2 *= len;\r\n }\r\n\r\n y0 = z1 * x2 - z2 * x1;\r\n y1 = z2 * x0 - z0 * x2;\r\n y2 = z0 * x1 - z1 * x0;\r\n\r\n len = Math.sqrt(y0 * y0 + y1 * y1 + y2 * y2);\r\n if (!len) {\r\n y0 = 0;\r\n y1 = 0;\r\n y2 = 0;\r\n } else {\r\n len = 1 / len;\r\n y0 *= len;\r\n y1 *= len;\r\n y2 *= len;\r\n }\r\n\r\n out[0] = x0;\r\n out[1] = y0;\r\n out[2] = z0;\r\n out[3] = 0;\r\n out[4] = x1;\r\n out[5] = y1;\r\n out[6] = z1;\r\n out[7] = 0;\r\n out[8] = x2;\r\n out[9] = y2;\r\n out[10] = z2;\r\n out[11] = 0;\r\n out[12] = -(x0 * eyex + x1 * eyey + x2 * eyez);\r\n out[13] = -(y0 * eyex + y1 * eyey + y2 * eyez);\r\n out[14] = -(z0 * eyex + z1 * eyey + z2 * eyez);\r\n out[15] = 1;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Generates a matrix that makes something look at something else.\r\n *\r\n * @param {mat4} out mat4 frustum matrix will be written into\r\n * @param {vec3} eye Position of the viewer\r\n * @param {vec3} center Point the viewer is looking at\r\n * @param {vec3} up vec3 pointing up\r\n * @returns {mat4} out\r\n */\r\nexport function targetTo(out, eye, target, up) {\r\n var eyex = eye[0],\r\n eyey = eye[1],\r\n eyez = eye[2],\r\n upx = up[0],\r\n upy = up[1],\r\n upz = up[2];\r\n\r\n var z0 = eyex - target[0],\r\n z1 = eyey - target[1],\r\n z2 = eyez - target[2];\r\n\r\n var len = z0 * z0 + z1 * z1 + z2 * z2;\r\n if (len > 0) {\r\n len = 1 / Math.sqrt(len);\r\n z0 *= len;\r\n z1 *= len;\r\n z2 *= len;\r\n }\r\n\r\n var x0 = upy * z2 - upz * z1,\r\n x1 = upz * z0 - upx * z2,\r\n x2 = upx * z1 - upy * z0;\r\n\r\n len = x0 * x0 + x1 * x1 + x2 * x2;\r\n if (len > 0) {\r\n len = 1 / Math.sqrt(len);\r\n x0 *= len;\r\n x1 *= len;\r\n x2 *= len;\r\n }\r\n\r\n out[0] = x0;\r\n out[1] = x1;\r\n out[2] = x2;\r\n out[3] = 0;\r\n out[4] = z1 * x2 - z2 * x1;\r\n out[5] = z2 * x0 - z0 * x2;\r\n out[6] = z0 * x1 - z1 * x0;\r\n out[7] = 0;\r\n out[8] = z0;\r\n out[9] = z1;\r\n out[10] = z2;\r\n out[11] = 0;\r\n out[12] = eyex;\r\n out[13] = eyey;\r\n out[14] = eyez;\r\n out[15] = 1;\r\n return out;\r\n};\r\n\r\n/**\r\n * Returns a string representation of a mat4\r\n *\r\n * @param {mat4} a matrix to represent as a string\r\n * @returns {String} string representation of the matrix\r\n */\r\nexport function str(a) {\r\n return 'mat4(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ', ' + a[6] + ', ' + a[7] + ', ' + a[8] + ', ' + a[9] + ', ' + a[10] + ', ' + a[11] + ', ' + a[12] + ', ' + a[13] + ', ' + a[14] + ', ' + a[15] + ')';\r\n}\r\n\r\n/**\r\n * Returns Frobenius norm of a mat4\r\n *\r\n * @param {mat4} a the matrix to calculate Frobenius norm of\r\n * @returns {Number} Frobenius norm\r\n */\r\nexport function frob(a) {\r\n return Math.sqrt(Math.pow(a[0], 2) + Math.pow(a[1], 2) + Math.pow(a[2], 2) + Math.pow(a[3], 2) + Math.pow(a[4], 2) + Math.pow(a[5], 2) + Math.pow(a[6], 2) + Math.pow(a[7], 2) + Math.pow(a[8], 2) + Math.pow(a[9], 2) + Math.pow(a[10], 2) + Math.pow(a[11], 2) + Math.pow(a[12], 2) + Math.pow(a[13], 2) + Math.pow(a[14], 2) + Math.pow(a[15], 2));\r\n}\r\n\r\n/**\r\n * Adds two mat4's\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the first operand\r\n * @param {mat4} b the second operand\r\n * @returns {mat4} out\r\n */\r\nexport function add(out, a, b) {\r\n out[0] = a[0] + b[0];\r\n out[1] = a[1] + b[1];\r\n out[2] = a[2] + b[2];\r\n out[3] = a[3] + b[3];\r\n out[4] = a[4] + b[4];\r\n out[5] = a[5] + b[5];\r\n out[6] = a[6] + b[6];\r\n out[7] = a[7] + b[7];\r\n out[8] = a[8] + b[8];\r\n out[9] = a[9] + b[9];\r\n out[10] = a[10] + b[10];\r\n out[11] = a[11] + b[11];\r\n out[12] = a[12] + b[12];\r\n out[13] = a[13] + b[13];\r\n out[14] = a[14] + b[14];\r\n out[15] = a[15] + b[15];\r\n return out;\r\n}\r\n\r\n/**\r\n * Subtracts matrix b from matrix a\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the first operand\r\n * @param {mat4} b the second operand\r\n * @returns {mat4} out\r\n */\r\nexport function subtract(out, a, b) {\r\n out[0] = a[0] - b[0];\r\n out[1] = a[1] - b[1];\r\n out[2] = a[2] - b[2];\r\n out[3] = a[3] - b[3];\r\n out[4] = a[4] - b[4];\r\n out[5] = a[5] - b[5];\r\n out[6] = a[6] - b[6];\r\n out[7] = a[7] - b[7];\r\n out[8] = a[8] - b[8];\r\n out[9] = a[9] - b[9];\r\n out[10] = a[10] - b[10];\r\n out[11] = a[11] - b[11];\r\n out[12] = a[12] - b[12];\r\n out[13] = a[13] - b[13];\r\n out[14] = a[14] - b[14];\r\n out[15] = a[15] - b[15];\r\n return out;\r\n}\r\n\r\n/**\r\n * Multiply each element of the matrix by a scalar.\r\n *\r\n * @param {mat4} out the receiving matrix\r\n * @param {mat4} a the matrix to scale\r\n * @param {Number} b amount to scale the matrix's elements by\r\n * @returns {mat4} out\r\n */\r\nexport function multiplyScalar(out, a, b) {\r\n out[0] = a[0] * b;\r\n out[1] = a[1] * b;\r\n out[2] = a[2] * b;\r\n out[3] = a[3] * b;\r\n out[4] = a[4] * b;\r\n out[5] = a[5] * b;\r\n out[6] = a[6] * b;\r\n out[7] = a[7] * b;\r\n out[8] = a[8] * b;\r\n out[9] = a[9] * b;\r\n out[10] = a[10] * b;\r\n out[11] = a[11] * b;\r\n out[12] = a[12] * b;\r\n out[13] = a[13] * b;\r\n out[14] = a[14] * b;\r\n out[15] = a[15] * b;\r\n return out;\r\n}\r\n\r\n/**\r\n * Adds two mat4's after multiplying each element of the second operand by a scalar value.\r\n *\r\n * @param {mat4} out the receiving vector\r\n * @param {mat4} a the first operand\r\n * @param {mat4} b the second operand\r\n * @param {Number} scale the amount to scale b's elements by before adding\r\n * @returns {mat4} out\r\n */\r\nexport function multiplyScalarAndAdd(out, a, b, scale) {\r\n out[0] = a[0] + b[0] * scale;\r\n out[1] = a[1] + b[1] * scale;\r\n out[2] = a[2] + b[2] * scale;\r\n out[3] = a[3] + b[3] * scale;\r\n out[4] = a[4] + b[4] * scale;\r\n out[5] = a[5] + b[5] * scale;\r\n out[6] = a[6] + b[6] * scale;\r\n out[7] = a[7] + b[7] * scale;\r\n out[8] = a[8] + b[8] * scale;\r\n out[9] = a[9] + b[9] * scale;\r\n out[10] = a[10] + b[10] * scale;\r\n out[11] = a[11] + b[11] * scale;\r\n out[12] = a[12] + b[12] * scale;\r\n out[13] = a[13] + b[13] * scale;\r\n out[14] = a[14] + b[14] * scale;\r\n out[15] = a[15] + b[15] * scale;\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns whether or not the matrices have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {mat4} a The first matrix.\r\n * @param {mat4} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\r\nexport function exactEquals(a, b) {\r\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7] && a[8] === b[8] && a[9] === b[9] && a[10] === b[10] && a[11] === b[11] && a[12] === b[12] && a[13] === b[13] && a[14] === b[14] && a[15] === b[15];\r\n}\r\n\r\n/**\r\n * Returns whether or not the matrices have approximately the same elements in the same position.\r\n *\r\n * @param {mat4} a The first matrix.\r\n * @param {mat4} b The second matrix.\r\n * @returns {Boolean} True if the matrices are equal, false otherwise.\r\n */\r\nexport function equals(a, b) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3];\r\n var a4 = a[4],\r\n a5 = a[5],\r\n a6 = a[6],\r\n a7 = a[7];\r\n var a8 = a[8],\r\n a9 = a[9],\r\n a10 = a[10],\r\n a11 = a[11];\r\n var a12 = a[12],\r\n a13 = a[13],\r\n a14 = a[14],\r\n a15 = a[15];\r\n\r\n var b0 = b[0],\r\n b1 = b[1],\r\n b2 = b[2],\r\n b3 = b[3];\r\n var b4 = b[4],\r\n b5 = b[5],\r\n b6 = b[6],\r\n b7 = b[7];\r\n var b8 = b[8],\r\n b9 = b[9],\r\n b10 = b[10],\r\n b11 = b[11];\r\n var b12 = b[12],\r\n b13 = b[13],\r\n b14 = b[14],\r\n b15 = b[15];\r\n\r\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7)) && Math.abs(a8 - b8) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a8), Math.abs(b8)) && Math.abs(a9 - b9) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a9), Math.abs(b9)) && Math.abs(a10 - b10) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a10), Math.abs(b10)) && Math.abs(a11 - b11) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a11), Math.abs(b11)) && Math.abs(a12 - b12) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a12), Math.abs(b12)) && Math.abs(a13 - b13) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a13), Math.abs(b13)) && Math.abs(a14 - b14) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a14), Math.abs(b14)) && Math.abs(a15 - b15) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a15), Math.abs(b15));\r\n}\r\n\r\n/**\r\n * Alias for {@link mat4.multiply}\r\n * @function\r\n */\r\nexport var mul = multiply;\r\n\r\n/**\r\n * Alias for {@link mat4.subtract}\r\n * @function\r\n */\r\nexport var sub = subtract;","import * as glMatrix from \"./common.js\";\r\nimport * as mat3 from \"./mat3.js\";\r\nimport * as vec3 from \"./vec3.js\";\r\nimport * as vec4 from \"./vec4.js\";\r\n\r\n/**\r\n * Quaternion\r\n * @module quat\r\n */\r\n\r\n/**\r\n * Creates a new identity quat\r\n *\r\n * @returns {quat} a new quaternion\r\n */\r\nexport function create() {\r\n var out = new glMatrix.ARRAY_TYPE(4);\r\n if (glMatrix.ARRAY_TYPE != Float32Array) {\r\n out[0] = 0;\r\n out[1] = 0;\r\n out[2] = 0;\r\n }\r\n out[3] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Set a quat to the identity quaternion\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @returns {quat} out\r\n */\r\nexport function identity(out) {\r\n out[0] = 0;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 1;\r\n return out;\r\n}\r\n\r\n/**\r\n * Sets a quat from the given angle and rotation axis,\r\n * then returns it.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {vec3} axis the axis around which to rotate\r\n * @param {Number} rad the angle in radians\r\n * @returns {quat} out\r\n **/\r\nexport function setAxisAngle(out, axis, rad) {\r\n rad = rad * 0.5;\r\n var s = Math.sin(rad);\r\n out[0] = s * axis[0];\r\n out[1] = s * axis[1];\r\n out[2] = s * axis[2];\r\n out[3] = Math.cos(rad);\r\n return out;\r\n}\r\n\r\n/**\r\n * Gets the rotation axis and angle for a given\r\n * quaternion. If a quaternion is created with\r\n * setAxisAngle, this method will return the same\r\n * values as providied in the original parameter list\r\n * OR functionally equivalent values.\r\n * Example: The quaternion formed by axis [0, 0, 1] and\r\n * angle -90 is the same as the quaternion formed by\r\n * [0, 0, 1] and 270. This method favors the latter.\r\n * @param {vec3} out_axis Vector receiving the axis of rotation\r\n * @param {quat} q Quaternion to be decomposed\r\n * @return {Number} Angle, in radians, of the rotation\r\n */\r\nexport function getAxisAngle(out_axis, q) {\r\n var rad = Math.acos(q[3]) * 2.0;\r\n var s = Math.sin(rad / 2.0);\r\n if (s > glMatrix.EPSILON) {\r\n out_axis[0] = q[0] / s;\r\n out_axis[1] = q[1] / s;\r\n out_axis[2] = q[2] / s;\r\n } else {\r\n // If s is zero, return any axis (no rotation - axis does not matter)\r\n out_axis[0] = 1;\r\n out_axis[1] = 0;\r\n out_axis[2] = 0;\r\n }\r\n return rad;\r\n}\r\n\r\n/**\r\n * Multiplies two quat's\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {quat} a the first operand\r\n * @param {quat} b the second operand\r\n * @returns {quat} out\r\n */\r\nexport function multiply(out, a, b) {\r\n var ax = a[0],\r\n ay = a[1],\r\n az = a[2],\r\n aw = a[3];\r\n var bx = b[0],\r\n by = b[1],\r\n bz = b[2],\r\n bw = b[3];\r\n\r\n out[0] = ax * bw + aw * bx + ay * bz - az * by;\r\n out[1] = ay * bw + aw * by + az * bx - ax * bz;\r\n out[2] = az * bw + aw * bz + ax * by - ay * bx;\r\n out[3] = aw * bw - ax * bx - ay * by - az * bz;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a quaternion by the given angle about the X axis\r\n *\r\n * @param {quat} out quat receiving operation result\r\n * @param {quat} a quat to rotate\r\n * @param {number} rad angle (in radians) to rotate\r\n * @returns {quat} out\r\n */\r\nexport function rotateX(out, a, rad) {\r\n rad *= 0.5;\r\n\r\n var ax = a[0],\r\n ay = a[1],\r\n az = a[2],\r\n aw = a[3];\r\n var bx = Math.sin(rad),\r\n bw = Math.cos(rad);\r\n\r\n out[0] = ax * bw + aw * bx;\r\n out[1] = ay * bw + az * bx;\r\n out[2] = az * bw - ay * bx;\r\n out[3] = aw * bw - ax * bx;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a quaternion by the given angle about the Y axis\r\n *\r\n * @param {quat} out quat receiving operation result\r\n * @param {quat} a quat to rotate\r\n * @param {number} rad angle (in radians) to rotate\r\n * @returns {quat} out\r\n */\r\nexport function rotateY(out, a, rad) {\r\n rad *= 0.5;\r\n\r\n var ax = a[0],\r\n ay = a[1],\r\n az = a[2],\r\n aw = a[3];\r\n var by = Math.sin(rad),\r\n bw = Math.cos(rad);\r\n\r\n out[0] = ax * bw - az * by;\r\n out[1] = ay * bw + aw * by;\r\n out[2] = az * bw + ax * by;\r\n out[3] = aw * bw - ay * by;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a quaternion by the given angle about the Z axis\r\n *\r\n * @param {quat} out quat receiving operation result\r\n * @param {quat} a quat to rotate\r\n * @param {number} rad angle (in radians) to rotate\r\n * @returns {quat} out\r\n */\r\nexport function rotateZ(out, a, rad) {\r\n rad *= 0.5;\r\n\r\n var ax = a[0],\r\n ay = a[1],\r\n az = a[2],\r\n aw = a[3];\r\n var bz = Math.sin(rad),\r\n bw = Math.cos(rad);\r\n\r\n out[0] = ax * bw + ay * bz;\r\n out[1] = ay * bw - ax * bz;\r\n out[2] = az * bw + aw * bz;\r\n out[3] = aw * bw - az * bz;\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the W component of a quat from the X, Y, and Z components.\r\n * Assumes that quaternion is 1 unit in length.\r\n * Any existing W component will be ignored.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {quat} a quat to calculate W component of\r\n * @returns {quat} out\r\n */\r\nexport function calculateW(out, a) {\r\n var x = a[0],\r\n y = a[1],\r\n z = a[2];\r\n\r\n out[0] = x;\r\n out[1] = y;\r\n out[2] = z;\r\n out[3] = Math.sqrt(Math.abs(1.0 - x * x - y * y - z * z));\r\n return out;\r\n}\r\n\r\n/**\r\n * Performs a spherical linear interpolation between two quat\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {quat} a the first operand\r\n * @param {quat} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {quat} out\r\n */\r\nexport function slerp(out, a, b, t) {\r\n // benchmarks:\r\n // http://jsperf.com/quaternion-slerp-implementations\r\n var ax = a[0],\r\n ay = a[1],\r\n az = a[2],\r\n aw = a[3];\r\n var bx = b[0],\r\n by = b[1],\r\n bz = b[2],\r\n bw = b[3];\r\n\r\n var omega = void 0,\r\n cosom = void 0,\r\n sinom = void 0,\r\n scale0 = void 0,\r\n scale1 = void 0;\r\n\r\n // calc cosine\r\n cosom = ax * bx + ay * by + az * bz + aw * bw;\r\n // adjust signs (if necessary)\r\n if (cosom < 0.0) {\r\n cosom = -cosom;\r\n bx = -bx;\r\n by = -by;\r\n bz = -bz;\r\n bw = -bw;\r\n }\r\n // calculate coefficients\r\n if (1.0 - cosom > glMatrix.EPSILON) {\r\n // standard case (slerp)\r\n omega = Math.acos(cosom);\r\n sinom = Math.sin(omega);\r\n scale0 = Math.sin((1.0 - t) * omega) / sinom;\r\n scale1 = Math.sin(t * omega) / sinom;\r\n } else {\r\n // \"from\" and \"to\" quaternions are very close\r\n // ... so we can do a linear interpolation\r\n scale0 = 1.0 - t;\r\n scale1 = t;\r\n }\r\n // calculate final values\r\n out[0] = scale0 * ax + scale1 * bx;\r\n out[1] = scale0 * ay + scale1 * by;\r\n out[2] = scale0 * az + scale1 * bz;\r\n out[3] = scale0 * aw + scale1 * bw;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Generates a random quaternion\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @returns {quat} out\r\n */\r\nexport function random(out) {\r\n // Implementation of http://planning.cs.uiuc.edu/node198.html\r\n // TODO: Calling random 3 times is probably not the fastest solution\r\n var u1 = glMatrix.RANDOM();\r\n var u2 = glMatrix.RANDOM();\r\n var u3 = glMatrix.RANDOM();\r\n\r\n var sqrt1MinusU1 = Math.sqrt(1 - u1);\r\n var sqrtU1 = Math.sqrt(u1);\r\n\r\n out[0] = sqrt1MinusU1 * Math.sin(2.0 * Math.PI * u2);\r\n out[1] = sqrt1MinusU1 * Math.cos(2.0 * Math.PI * u2);\r\n out[2] = sqrtU1 * Math.sin(2.0 * Math.PI * u3);\r\n out[3] = sqrtU1 * Math.cos(2.0 * Math.PI * u3);\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the inverse of a quat\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {quat} a quat to calculate inverse of\r\n * @returns {quat} out\r\n */\r\nexport function invert(out, a) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3];\r\n var dot = a0 * a0 + a1 * a1 + a2 * a2 + a3 * a3;\r\n var invDot = dot ? 1.0 / dot : 0;\r\n\r\n // TODO: Would be faster to return [0,0,0,0] immediately if dot == 0\r\n\r\n out[0] = -a0 * invDot;\r\n out[1] = -a1 * invDot;\r\n out[2] = -a2 * invDot;\r\n out[3] = a3 * invDot;\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the conjugate of a quat\r\n * If the quaternion is normalized, this function is faster than quat.inverse and produces the same result.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {quat} a quat to calculate conjugate of\r\n * @returns {quat} out\r\n */\r\nexport function conjugate(out, a) {\r\n out[0] = -a[0];\r\n out[1] = -a[1];\r\n out[2] = -a[2];\r\n out[3] = a[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a quaternion from the given 3x3 rotation matrix.\r\n *\r\n * NOTE: The resultant quaternion is not normalized, so you should be sure\r\n * to renormalize the quaternion yourself where necessary.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {mat3} m rotation matrix\r\n * @returns {quat} out\r\n * @function\r\n */\r\nexport function fromMat3(out, m) {\r\n // Algorithm in Ken Shoemake's article in 1987 SIGGRAPH course notes\r\n // article \"Quaternion Calculus and Fast Animation\".\r\n var fTrace = m[0] + m[4] + m[8];\r\n var fRoot = void 0;\r\n\r\n if (fTrace > 0.0) {\r\n // |w| > 1/2, may as well choose w > 1/2\r\n fRoot = Math.sqrt(fTrace + 1.0); // 2w\r\n out[3] = 0.5 * fRoot;\r\n fRoot = 0.5 / fRoot; // 1/(4w)\r\n out[0] = (m[5] - m[7]) * fRoot;\r\n out[1] = (m[6] - m[2]) * fRoot;\r\n out[2] = (m[1] - m[3]) * fRoot;\r\n } else {\r\n // |w| <= 1/2\r\n var i = 0;\r\n if (m[4] > m[0]) i = 1;\r\n if (m[8] > m[i * 3 + i]) i = 2;\r\n var j = (i + 1) % 3;\r\n var k = (i + 2) % 3;\r\n\r\n fRoot = Math.sqrt(m[i * 3 + i] - m[j * 3 + j] - m[k * 3 + k] + 1.0);\r\n out[i] = 0.5 * fRoot;\r\n fRoot = 0.5 / fRoot;\r\n out[3] = (m[j * 3 + k] - m[k * 3 + j]) * fRoot;\r\n out[j] = (m[j * 3 + i] + m[i * 3 + j]) * fRoot;\r\n out[k] = (m[k * 3 + i] + m[i * 3 + k]) * fRoot;\r\n }\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a quaternion from the given euler angle x, y, z.\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {x} Angle to rotate around X axis in degrees.\r\n * @param {y} Angle to rotate around Y axis in degrees.\r\n * @param {z} Angle to rotate around Z axis in degrees.\r\n * @returns {quat} out\r\n * @function\r\n */\r\nexport function fromEuler(out, x, y, z) {\r\n var halfToRad = 0.5 * Math.PI / 180.0;\r\n x *= halfToRad;\r\n y *= halfToRad;\r\n z *= halfToRad;\r\n\r\n var sx = Math.sin(x);\r\n var cx = Math.cos(x);\r\n var sy = Math.sin(y);\r\n var cy = Math.cos(y);\r\n var sz = Math.sin(z);\r\n var cz = Math.cos(z);\r\n\r\n out[0] = sx * cy * cz - cx * sy * sz;\r\n out[1] = cx * sy * cz + sx * cy * sz;\r\n out[2] = cx * cy * sz - sx * sy * cz;\r\n out[3] = cx * cy * cz + sx * sy * sz;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns a string representation of a quatenion\r\n *\r\n * @param {quat} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\r\nexport function str(a) {\r\n return 'quat(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')';\r\n}\r\n\r\n/**\r\n * Creates a new quat initialized with values from an existing quaternion\r\n *\r\n * @param {quat} a quaternion to clone\r\n * @returns {quat} a new quaternion\r\n * @function\r\n */\r\nexport var clone = vec4.clone;\r\n\r\n/**\r\n * Creates a new quat initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {quat} a new quaternion\r\n * @function\r\n */\r\nexport var fromValues = vec4.fromValues;\r\n\r\n/**\r\n * Copy the values from one quat to another\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {quat} a the source quaternion\r\n * @returns {quat} out\r\n * @function\r\n */\r\nexport var copy = vec4.copy;\r\n\r\n/**\r\n * Set the components of a quat to the given values\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {quat} out\r\n * @function\r\n */\r\nexport var set = vec4.set;\r\n\r\n/**\r\n * Adds two quat's\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {quat} a the first operand\r\n * @param {quat} b the second operand\r\n * @returns {quat} out\r\n * @function\r\n */\r\nexport var add = vec4.add;\r\n\r\n/**\r\n * Alias for {@link quat.multiply}\r\n * @function\r\n */\r\nexport var mul = multiply;\r\n\r\n/**\r\n * Scales a quat by a scalar number\r\n *\r\n * @param {quat} out the receiving vector\r\n * @param {quat} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {quat} out\r\n * @function\r\n */\r\nexport var scale = vec4.scale;\r\n\r\n/**\r\n * Calculates the dot product of two quat's\r\n *\r\n * @param {quat} a the first operand\r\n * @param {quat} b the second operand\r\n * @returns {Number} dot product of a and b\r\n * @function\r\n */\r\nexport var dot = vec4.dot;\r\n\r\n/**\r\n * Performs a linear interpolation between two quat's\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {quat} a the first operand\r\n * @param {quat} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {quat} out\r\n * @function\r\n */\r\nexport var lerp = vec4.lerp;\r\n\r\n/**\r\n * Calculates the length of a quat\r\n *\r\n * @param {quat} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\r\nexport var length = vec4.length;\r\n\r\n/**\r\n * Alias for {@link quat.length}\r\n * @function\r\n */\r\nexport var len = length;\r\n\r\n/**\r\n * Calculates the squared length of a quat\r\n *\r\n * @param {quat} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n * @function\r\n */\r\nexport var squaredLength = vec4.squaredLength;\r\n\r\n/**\r\n * Alias for {@link quat.squaredLength}\r\n * @function\r\n */\r\nexport var sqrLen = squaredLength;\r\n\r\n/**\r\n * Normalize a quat\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {quat} a quaternion to normalize\r\n * @returns {quat} out\r\n * @function\r\n */\r\nexport var normalize = vec4.normalize;\r\n\r\n/**\r\n * Returns whether or not the quaternions have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {quat} a The first quaternion.\r\n * @param {quat} b The second quaternion.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\r\nexport var exactEquals = vec4.exactEquals;\r\n\r\n/**\r\n * Returns whether or not the quaternions have approximately the same elements in the same position.\r\n *\r\n * @param {quat} a The first vector.\r\n * @param {quat} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\r\nexport var equals = vec4.equals;\r\n\r\n/**\r\n * Sets a quaternion to represent the shortest rotation from one\r\n * vector to another.\r\n *\r\n * Both vectors are assumed to be unit length.\r\n *\r\n * @param {quat} out the receiving quaternion.\r\n * @param {vec3} a the initial vector\r\n * @param {vec3} b the destination vector\r\n * @returns {quat} out\r\n */\r\nexport var rotationTo = function () {\r\n var tmpvec3 = vec3.create();\r\n var xUnitVec3 = vec3.fromValues(1, 0, 0);\r\n var yUnitVec3 = vec3.fromValues(0, 1, 0);\r\n\r\n return function (out, a, b) {\r\n var dot = vec3.dot(a, b);\r\n if (dot < -0.999999) {\r\n vec3.cross(tmpvec3, xUnitVec3, a);\r\n if (vec3.len(tmpvec3) < 0.000001) vec3.cross(tmpvec3, yUnitVec3, a);\r\n vec3.normalize(tmpvec3, tmpvec3);\r\n setAxisAngle(out, tmpvec3, Math.PI);\r\n return out;\r\n } else if (dot > 0.999999) {\r\n out[0] = 0;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 1;\r\n return out;\r\n } else {\r\n vec3.cross(tmpvec3, a, b);\r\n out[0] = tmpvec3[0];\r\n out[1] = tmpvec3[1];\r\n out[2] = tmpvec3[2];\r\n out[3] = 1 + dot;\r\n return normalize(out, out);\r\n }\r\n };\r\n}();\r\n\r\n/**\r\n * Performs a spherical linear interpolation with two control points\r\n *\r\n * @param {quat} out the receiving quaternion\r\n * @param {quat} a the first operand\r\n * @param {quat} b the second operand\r\n * @param {quat} c the third operand\r\n * @param {quat} d the fourth operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {quat} out\r\n */\r\nexport var sqlerp = function () {\r\n var temp1 = create();\r\n var temp2 = create();\r\n\r\n return function (out, a, b, c, d, t) {\r\n slerp(temp1, a, d, t);\r\n slerp(temp2, b, c, t);\r\n slerp(out, temp1, temp2, 2 * t * (1 - t));\r\n\r\n return out;\r\n };\r\n}();\r\n\r\n/**\r\n * Sets the specified quaternion with values corresponding to the given\r\n * axes. Each axis is a vec3 and is expected to be unit length and\r\n * perpendicular to all other specified axes.\r\n *\r\n * @param {vec3} view the vector representing the viewing direction\r\n * @param {vec3} right the vector representing the local \"right\" direction\r\n * @param {vec3} up the vector representing the local \"up\" direction\r\n * @returns {quat} out\r\n */\r\nexport var setAxes = function () {\r\n var matr = mat3.create();\r\n\r\n return function (out, view, right, up) {\r\n matr[0] = right[0];\r\n matr[3] = right[1];\r\n matr[6] = right[2];\r\n\r\n matr[1] = up[0];\r\n matr[4] = up[1];\r\n matr[7] = up[2];\r\n\r\n matr[2] = -view[0];\r\n matr[5] = -view[1];\r\n matr[8] = -view[2];\r\n\r\n return normalize(out, fromMat3(out, matr));\r\n };\r\n}();","import * as glMatrix from \"./common.js\";\r\nimport * as quat from \"./quat.js\";\r\nimport * as mat4 from \"./mat4.js\";\r\n\r\n/**\r\n * Dual Quaternion
\r\n * Format: [real, dual]
\r\n * Quaternion format: XYZW
\r\n * Make sure to have normalized dual quaternions, otherwise the functions may not work as intended.
\r\n * @module quat2\r\n */\r\n\r\n/**\r\n * Creates a new identity dual quat\r\n *\r\n * @returns {quat2} a new dual quaternion [real -> rotation, dual -> translation]\r\n */\r\nexport function create() {\r\n var dq = new glMatrix.ARRAY_TYPE(8);\r\n if (glMatrix.ARRAY_TYPE != Float32Array) {\r\n dq[0] = 0;\r\n dq[1] = 0;\r\n dq[2] = 0;\r\n dq[4] = 0;\r\n dq[5] = 0;\r\n dq[6] = 0;\r\n dq[7] = 0;\r\n }\r\n dq[3] = 1;\r\n return dq;\r\n}\r\n\r\n/**\r\n * Creates a new quat initialized with values from an existing quaternion\r\n *\r\n * @param {quat2} a dual quaternion to clone\r\n * @returns {quat2} new dual quaternion\r\n * @function\r\n */\r\nexport function clone(a) {\r\n var dq = new glMatrix.ARRAY_TYPE(8);\r\n dq[0] = a[0];\r\n dq[1] = a[1];\r\n dq[2] = a[2];\r\n dq[3] = a[3];\r\n dq[4] = a[4];\r\n dq[5] = a[5];\r\n dq[6] = a[6];\r\n dq[7] = a[7];\r\n return dq;\r\n}\r\n\r\n/**\r\n * Creates a new dual quat initialized with the given values\r\n *\r\n * @param {Number} x1 X component\r\n * @param {Number} y1 Y component\r\n * @param {Number} z1 Z component\r\n * @param {Number} w1 W component\r\n * @param {Number} x2 X component\r\n * @param {Number} y2 Y component\r\n * @param {Number} z2 Z component\r\n * @param {Number} w2 W component\r\n * @returns {quat2} new dual quaternion\r\n * @function\r\n */\r\nexport function fromValues(x1, y1, z1, w1, x2, y2, z2, w2) {\r\n var dq = new glMatrix.ARRAY_TYPE(8);\r\n dq[0] = x1;\r\n dq[1] = y1;\r\n dq[2] = z1;\r\n dq[3] = w1;\r\n dq[4] = x2;\r\n dq[5] = y2;\r\n dq[6] = z2;\r\n dq[7] = w2;\r\n return dq;\r\n}\r\n\r\n/**\r\n * Creates a new dual quat from the given values (quat and translation)\r\n *\r\n * @param {Number} x1 X component\r\n * @param {Number} y1 Y component\r\n * @param {Number} z1 Z component\r\n * @param {Number} w1 W component\r\n * @param {Number} x2 X component (translation)\r\n * @param {Number} y2 Y component (translation)\r\n * @param {Number} z2 Z component (translation)\r\n * @returns {quat2} new dual quaternion\r\n * @function\r\n */\r\nexport function fromRotationTranslationValues(x1, y1, z1, w1, x2, y2, z2) {\r\n var dq = new glMatrix.ARRAY_TYPE(8);\r\n dq[0] = x1;\r\n dq[1] = y1;\r\n dq[2] = z1;\r\n dq[3] = w1;\r\n var ax = x2 * 0.5,\r\n ay = y2 * 0.5,\r\n az = z2 * 0.5;\r\n dq[4] = ax * w1 + ay * z1 - az * y1;\r\n dq[5] = ay * w1 + az * x1 - ax * z1;\r\n dq[6] = az * w1 + ax * y1 - ay * x1;\r\n dq[7] = -ax * x1 - ay * y1 - az * z1;\r\n return dq;\r\n}\r\n\r\n/**\r\n * Creates a dual quat from a quaternion and a translation\r\n *\r\n * @param {quat2} dual quaternion receiving operation result\r\n * @param {quat} q quaternion\r\n * @param {vec3} t tranlation vector\r\n * @returns {quat2} dual quaternion receiving operation result\r\n * @function\r\n */\r\nexport function fromRotationTranslation(out, q, t) {\r\n var ax = t[0] * 0.5,\r\n ay = t[1] * 0.5,\r\n az = t[2] * 0.5,\r\n bx = q[0],\r\n by = q[1],\r\n bz = q[2],\r\n bw = q[3];\r\n out[0] = bx;\r\n out[1] = by;\r\n out[2] = bz;\r\n out[3] = bw;\r\n out[4] = ax * bw + ay * bz - az * by;\r\n out[5] = ay * bw + az * bx - ax * bz;\r\n out[6] = az * bw + ax * by - ay * bx;\r\n out[7] = -ax * bx - ay * by - az * bz;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a dual quat from a translation\r\n *\r\n * @param {quat2} dual quaternion receiving operation result\r\n * @param {vec3} t translation vector\r\n * @returns {quat2} dual quaternion receiving operation result\r\n * @function\r\n */\r\nexport function fromTranslation(out, t) {\r\n out[0] = 0;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 1;\r\n out[4] = t[0] * 0.5;\r\n out[5] = t[1] * 0.5;\r\n out[6] = t[2] * 0.5;\r\n out[7] = 0;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a dual quat from a quaternion\r\n *\r\n * @param {quat2} dual quaternion receiving operation result\r\n * @param {quat} q the quaternion\r\n * @returns {quat2} dual quaternion receiving operation result\r\n * @function\r\n */\r\nexport function fromRotation(out, q) {\r\n out[0] = q[0];\r\n out[1] = q[1];\r\n out[2] = q[2];\r\n out[3] = q[3];\r\n out[4] = 0;\r\n out[5] = 0;\r\n out[6] = 0;\r\n out[7] = 0;\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a new dual quat from a matrix (4x4)\r\n *\r\n * @param {quat2} out the dual quaternion\r\n * @param {mat4} a the matrix\r\n * @returns {quat2} dual quat receiving operation result\r\n * @function\r\n */\r\nexport function fromMat4(out, a) {\r\n //TODO Optimize this\r\n var outer = quat.create();\r\n mat4.getRotation(outer, a);\r\n var t = new glMatrix.ARRAY_TYPE(3);\r\n mat4.getTranslation(t, a);\r\n fromRotationTranslation(out, outer, t);\r\n return out;\r\n}\r\n\r\n/**\r\n * Copy the values from one dual quat to another\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat2} a the source dual quaternion\r\n * @returns {quat2} out\r\n * @function\r\n */\r\nexport function copy(out, a) {\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n out[4] = a[4];\r\n out[5] = a[5];\r\n out[6] = a[6];\r\n out[7] = a[7];\r\n return out;\r\n}\r\n\r\n/**\r\n * Set a dual quat to the identity dual quaternion\r\n *\r\n * @param {quat2} out the receiving quaternion\r\n * @returns {quat2} out\r\n */\r\nexport function identity(out) {\r\n out[0] = 0;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 1;\r\n out[4] = 0;\r\n out[5] = 0;\r\n out[6] = 0;\r\n out[7] = 0;\r\n return out;\r\n}\r\n\r\n/**\r\n * Set the components of a dual quat to the given values\r\n *\r\n * @param {quat2} out the receiving quaternion\r\n * @param {Number} x1 X component\r\n * @param {Number} y1 Y component\r\n * @param {Number} z1 Z component\r\n * @param {Number} w1 W component\r\n * @param {Number} x2 X component\r\n * @param {Number} y2 Y component\r\n * @param {Number} z2 Z component\r\n * @param {Number} w2 W component\r\n * @returns {quat2} out\r\n * @function\r\n */\r\nexport function set(out, x1, y1, z1, w1, x2, y2, z2, w2) {\r\n out[0] = x1;\r\n out[1] = y1;\r\n out[2] = z1;\r\n out[3] = w1;\r\n\r\n out[4] = x2;\r\n out[5] = y2;\r\n out[6] = z2;\r\n out[7] = w2;\r\n return out;\r\n}\r\n\r\n/**\r\n * Gets the real part of a dual quat\r\n * @param {quat} out real part\r\n * @param {quat2} a Dual Quaternion\r\n * @return {quat} real part\r\n */\r\nexport var getReal = quat.copy;\r\n\r\n/**\r\n * Gets the dual part of a dual quat\r\n * @param {quat} out dual part\r\n * @param {quat2} a Dual Quaternion\r\n * @return {quat} dual part\r\n */\r\nexport function getDual(out, a) {\r\n out[0] = a[4];\r\n out[1] = a[5];\r\n out[2] = a[6];\r\n out[3] = a[7];\r\n return out;\r\n}\r\n\r\n/**\r\n * Set the real component of a dual quat to the given quaternion\r\n *\r\n * @param {quat2} out the receiving quaternion\r\n * @param {quat} q a quaternion representing the real part\r\n * @returns {quat2} out\r\n * @function\r\n */\r\nexport var setReal = quat.copy;\r\n\r\n/**\r\n * Set the dual component of a dual quat to the given quaternion\r\n *\r\n * @param {quat2} out the receiving quaternion\r\n * @param {quat} q a quaternion representing the dual part\r\n * @returns {quat2} out\r\n * @function\r\n */\r\nexport function setDual(out, q) {\r\n out[4] = q[0];\r\n out[5] = q[1];\r\n out[6] = q[2];\r\n out[7] = q[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Gets the translation of a normalized dual quat\r\n * @param {vec3} out translation\r\n * @param {quat2} a Dual Quaternion to be decomposed\r\n * @return {vec3} translation\r\n */\r\nexport function getTranslation(out, a) {\r\n var ax = a[4],\r\n ay = a[5],\r\n az = a[6],\r\n aw = a[7],\r\n bx = -a[0],\r\n by = -a[1],\r\n bz = -a[2],\r\n bw = a[3];\r\n out[0] = (ax * bw + aw * bx + ay * bz - az * by) * 2;\r\n out[1] = (ay * bw + aw * by + az * bx - ax * bz) * 2;\r\n out[2] = (az * bw + aw * bz + ax * by - ay * bx) * 2;\r\n return out;\r\n}\r\n\r\n/**\r\n * Translates a dual quat by the given vector\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat2} a the dual quaternion to translate\r\n * @param {vec3} v vector to translate by\r\n * @returns {quat2} out\r\n */\r\nexport function translate(out, a, v) {\r\n var ax1 = a[0],\r\n ay1 = a[1],\r\n az1 = a[2],\r\n aw1 = a[3],\r\n bx1 = v[0] * 0.5,\r\n by1 = v[1] * 0.5,\r\n bz1 = v[2] * 0.5,\r\n ax2 = a[4],\r\n ay2 = a[5],\r\n az2 = a[6],\r\n aw2 = a[7];\r\n out[0] = ax1;\r\n out[1] = ay1;\r\n out[2] = az1;\r\n out[3] = aw1;\r\n out[4] = aw1 * bx1 + ay1 * bz1 - az1 * by1 + ax2;\r\n out[5] = aw1 * by1 + az1 * bx1 - ax1 * bz1 + ay2;\r\n out[6] = aw1 * bz1 + ax1 * by1 - ay1 * bx1 + az2;\r\n out[7] = -ax1 * bx1 - ay1 * by1 - az1 * bz1 + aw2;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a dual quat around the X axis\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat2} a the dual quaternion to rotate\r\n * @param {number} rad how far should the rotation be\r\n * @returns {quat2} out\r\n */\r\nexport function rotateX(out, a, rad) {\r\n var bx = -a[0],\r\n by = -a[1],\r\n bz = -a[2],\r\n bw = a[3],\r\n ax = a[4],\r\n ay = a[5],\r\n az = a[6],\r\n aw = a[7],\r\n ax1 = ax * bw + aw * bx + ay * bz - az * by,\r\n ay1 = ay * bw + aw * by + az * bx - ax * bz,\r\n az1 = az * bw + aw * bz + ax * by - ay * bx,\r\n aw1 = aw * bw - ax * bx - ay * by - az * bz;\r\n quat.rotateX(out, a, rad);\r\n bx = out[0];\r\n by = out[1];\r\n bz = out[2];\r\n bw = out[3];\r\n out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;\r\n out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;\r\n out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;\r\n out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a dual quat around the Y axis\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat2} a the dual quaternion to rotate\r\n * @param {number} rad how far should the rotation be\r\n * @returns {quat2} out\r\n */\r\nexport function rotateY(out, a, rad) {\r\n var bx = -a[0],\r\n by = -a[1],\r\n bz = -a[2],\r\n bw = a[3],\r\n ax = a[4],\r\n ay = a[5],\r\n az = a[6],\r\n aw = a[7],\r\n ax1 = ax * bw + aw * bx + ay * bz - az * by,\r\n ay1 = ay * bw + aw * by + az * bx - ax * bz,\r\n az1 = az * bw + aw * bz + ax * by - ay * bx,\r\n aw1 = aw * bw - ax * bx - ay * by - az * bz;\r\n quat.rotateY(out, a, rad);\r\n bx = out[0];\r\n by = out[1];\r\n bz = out[2];\r\n bw = out[3];\r\n out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;\r\n out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;\r\n out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;\r\n out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a dual quat around the Z axis\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat2} a the dual quaternion to rotate\r\n * @param {number} rad how far should the rotation be\r\n * @returns {quat2} out\r\n */\r\nexport function rotateZ(out, a, rad) {\r\n var bx = -a[0],\r\n by = -a[1],\r\n bz = -a[2],\r\n bw = a[3],\r\n ax = a[4],\r\n ay = a[5],\r\n az = a[6],\r\n aw = a[7],\r\n ax1 = ax * bw + aw * bx + ay * bz - az * by,\r\n ay1 = ay * bw + aw * by + az * bx - ax * bz,\r\n az1 = az * bw + aw * bz + ax * by - ay * bx,\r\n aw1 = aw * bw - ax * bx - ay * by - az * bz;\r\n quat.rotateZ(out, a, rad);\r\n bx = out[0];\r\n by = out[1];\r\n bz = out[2];\r\n bw = out[3];\r\n out[4] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;\r\n out[5] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;\r\n out[6] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;\r\n out[7] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a dual quat by a given quaternion (a * q)\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat2} a the dual quaternion to rotate\r\n * @param {quat} q quaternion to rotate by\r\n * @returns {quat2} out\r\n */\r\nexport function rotateByQuatAppend(out, a, q) {\r\n var qx = q[0],\r\n qy = q[1],\r\n qz = q[2],\r\n qw = q[3],\r\n ax = a[0],\r\n ay = a[1],\r\n az = a[2],\r\n aw = a[3];\r\n\r\n out[0] = ax * qw + aw * qx + ay * qz - az * qy;\r\n out[1] = ay * qw + aw * qy + az * qx - ax * qz;\r\n out[2] = az * qw + aw * qz + ax * qy - ay * qx;\r\n out[3] = aw * qw - ax * qx - ay * qy - az * qz;\r\n ax = a[4];\r\n ay = a[5];\r\n az = a[6];\r\n aw = a[7];\r\n out[4] = ax * qw + aw * qx + ay * qz - az * qy;\r\n out[5] = ay * qw + aw * qy + az * qx - ax * qz;\r\n out[6] = az * qw + aw * qz + ax * qy - ay * qx;\r\n out[7] = aw * qw - ax * qx - ay * qy - az * qz;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a dual quat by a given quaternion (q * a)\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat} q quaternion to rotate by\r\n * @param {quat2} a the dual quaternion to rotate\r\n * @returns {quat2} out\r\n */\r\nexport function rotateByQuatPrepend(out, q, a) {\r\n var qx = q[0],\r\n qy = q[1],\r\n qz = q[2],\r\n qw = q[3],\r\n bx = a[0],\r\n by = a[1],\r\n bz = a[2],\r\n bw = a[3];\r\n\r\n out[0] = qx * bw + qw * bx + qy * bz - qz * by;\r\n out[1] = qy * bw + qw * by + qz * bx - qx * bz;\r\n out[2] = qz * bw + qw * bz + qx * by - qy * bx;\r\n out[3] = qw * bw - qx * bx - qy * by - qz * bz;\r\n bx = a[4];\r\n by = a[5];\r\n bz = a[6];\r\n bw = a[7];\r\n out[4] = qx * bw + qw * bx + qy * bz - qz * by;\r\n out[5] = qy * bw + qw * by + qz * bx - qx * bz;\r\n out[6] = qz * bw + qw * bz + qx * by - qy * bx;\r\n out[7] = qw * bw - qx * bx - qy * by - qz * bz;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotates a dual quat around a given axis. Does the normalisation automatically\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat2} a the dual quaternion to rotate\r\n * @param {vec3} axis the axis to rotate around\r\n * @param {Number} rad how far the rotation should be\r\n * @returns {quat2} out\r\n */\r\nexport function rotateAroundAxis(out, a, axis, rad) {\r\n //Special case for rad = 0\r\n if (Math.abs(rad) < glMatrix.EPSILON) {\r\n return copy(out, a);\r\n }\r\n var axisLength = Math.sqrt(axis[0] * axis[0] + axis[1] * axis[1] + axis[2] * axis[2]);\r\n\r\n rad = rad * 0.5;\r\n var s = Math.sin(rad);\r\n var bx = s * axis[0] / axisLength;\r\n var by = s * axis[1] / axisLength;\r\n var bz = s * axis[2] / axisLength;\r\n var bw = Math.cos(rad);\r\n\r\n var ax1 = a[0],\r\n ay1 = a[1],\r\n az1 = a[2],\r\n aw1 = a[3];\r\n out[0] = ax1 * bw + aw1 * bx + ay1 * bz - az1 * by;\r\n out[1] = ay1 * bw + aw1 * by + az1 * bx - ax1 * bz;\r\n out[2] = az1 * bw + aw1 * bz + ax1 * by - ay1 * bx;\r\n out[3] = aw1 * bw - ax1 * bx - ay1 * by - az1 * bz;\r\n\r\n var ax = a[4],\r\n ay = a[5],\r\n az = a[6],\r\n aw = a[7];\r\n out[4] = ax * bw + aw * bx + ay * bz - az * by;\r\n out[5] = ay * bw + aw * by + az * bx - ax * bz;\r\n out[6] = az * bw + aw * bz + ax * by - ay * bx;\r\n out[7] = aw * bw - ax * bx - ay * by - az * bz;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Adds two dual quat's\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat2} a the first operand\r\n * @param {quat2} b the second operand\r\n * @returns {quat2} out\r\n * @function\r\n */\r\nexport function add(out, a, b) {\r\n out[0] = a[0] + b[0];\r\n out[1] = a[1] + b[1];\r\n out[2] = a[2] + b[2];\r\n out[3] = a[3] + b[3];\r\n out[4] = a[4] + b[4];\r\n out[5] = a[5] + b[5];\r\n out[6] = a[6] + b[6];\r\n out[7] = a[7] + b[7];\r\n return out;\r\n}\r\n\r\n/**\r\n * Multiplies two dual quat's\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat2} a the first operand\r\n * @param {quat2} b the second operand\r\n * @returns {quat2} out\r\n */\r\nexport function multiply(out, a, b) {\r\n var ax0 = a[0],\r\n ay0 = a[1],\r\n az0 = a[2],\r\n aw0 = a[3],\r\n bx1 = b[4],\r\n by1 = b[5],\r\n bz1 = b[6],\r\n bw1 = b[7],\r\n ax1 = a[4],\r\n ay1 = a[5],\r\n az1 = a[6],\r\n aw1 = a[7],\r\n bx0 = b[0],\r\n by0 = b[1],\r\n bz0 = b[2],\r\n bw0 = b[3];\r\n out[0] = ax0 * bw0 + aw0 * bx0 + ay0 * bz0 - az0 * by0;\r\n out[1] = ay0 * bw0 + aw0 * by0 + az0 * bx0 - ax0 * bz0;\r\n out[2] = az0 * bw0 + aw0 * bz0 + ax0 * by0 - ay0 * bx0;\r\n out[3] = aw0 * bw0 - ax0 * bx0 - ay0 * by0 - az0 * bz0;\r\n out[4] = ax0 * bw1 + aw0 * bx1 + ay0 * bz1 - az0 * by1 + ax1 * bw0 + aw1 * bx0 + ay1 * bz0 - az1 * by0;\r\n out[5] = ay0 * bw1 + aw0 * by1 + az0 * bx1 - ax0 * bz1 + ay1 * bw0 + aw1 * by0 + az1 * bx0 - ax1 * bz0;\r\n out[6] = az0 * bw1 + aw0 * bz1 + ax0 * by1 - ay0 * bx1 + az1 * bw0 + aw1 * bz0 + ax1 * by0 - ay1 * bx0;\r\n out[7] = aw0 * bw1 - ax0 * bx1 - ay0 * by1 - az0 * bz1 + aw1 * bw0 - ax1 * bx0 - ay1 * by0 - az1 * bz0;\r\n return out;\r\n}\r\n\r\n/**\r\n * Alias for {@link quat2.multiply}\r\n * @function\r\n */\r\nexport var mul = multiply;\r\n\r\n/**\r\n * Scales a dual quat by a scalar number\r\n *\r\n * @param {quat2} out the receiving dual quat\r\n * @param {quat2} a the dual quat to scale\r\n * @param {Number} b amount to scale the dual quat by\r\n * @returns {quat2} out\r\n * @function\r\n */\r\nexport function scale(out, a, b) {\r\n out[0] = a[0] * b;\r\n out[1] = a[1] * b;\r\n out[2] = a[2] * b;\r\n out[3] = a[3] * b;\r\n out[4] = a[4] * b;\r\n out[5] = a[5] * b;\r\n out[6] = a[6] * b;\r\n out[7] = a[7] * b;\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the dot product of two dual quat's (The dot product of the real parts)\r\n *\r\n * @param {quat2} a the first operand\r\n * @param {quat2} b the second operand\r\n * @returns {Number} dot product of a and b\r\n * @function\r\n */\r\nexport var dot = quat.dot;\r\n\r\n/**\r\n * Performs a linear interpolation between two dual quats's\r\n * NOTE: The resulting dual quaternions won't always be normalized (The error is most noticeable when t = 0.5)\r\n *\r\n * @param {quat2} out the receiving dual quat\r\n * @param {quat2} a the first operand\r\n * @param {quat2} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {quat2} out\r\n */\r\nexport function lerp(out, a, b, t) {\r\n var mt = 1 - t;\r\n if (dot(a, b) < 0) t = -t;\r\n\r\n out[0] = a[0] * mt + b[0] * t;\r\n out[1] = a[1] * mt + b[1] * t;\r\n out[2] = a[2] * mt + b[2] * t;\r\n out[3] = a[3] * mt + b[3] * t;\r\n out[4] = a[4] * mt + b[4] * t;\r\n out[5] = a[5] * mt + b[5] * t;\r\n out[6] = a[6] * mt + b[6] * t;\r\n out[7] = a[7] * mt + b[7] * t;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the inverse of a dual quat. If they are normalized, conjugate is cheaper\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat2} a dual quat to calculate inverse of\r\n * @returns {quat2} out\r\n */\r\nexport function invert(out, a) {\r\n var sqlen = squaredLength(a);\r\n out[0] = -a[0] / sqlen;\r\n out[1] = -a[1] / sqlen;\r\n out[2] = -a[2] / sqlen;\r\n out[3] = a[3] / sqlen;\r\n out[4] = -a[4] / sqlen;\r\n out[5] = -a[5] / sqlen;\r\n out[6] = -a[6] / sqlen;\r\n out[7] = a[7] / sqlen;\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the conjugate of a dual quat\r\n * If the dual quaternion is normalized, this function is faster than quat2.inverse and produces the same result.\r\n *\r\n * @param {quat2} out the receiving quaternion\r\n * @param {quat2} a quat to calculate conjugate of\r\n * @returns {quat2} out\r\n */\r\nexport function conjugate(out, a) {\r\n out[0] = -a[0];\r\n out[1] = -a[1];\r\n out[2] = -a[2];\r\n out[3] = a[3];\r\n out[4] = -a[4];\r\n out[5] = -a[5];\r\n out[6] = -a[6];\r\n out[7] = a[7];\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the length of a dual quat\r\n *\r\n * @param {quat2} a dual quat to calculate length of\r\n * @returns {Number} length of a\r\n * @function\r\n */\r\nexport var length = quat.length;\r\n\r\n/**\r\n * Alias for {@link quat2.length}\r\n * @function\r\n */\r\nexport var len = length;\r\n\r\n/**\r\n * Calculates the squared length of a dual quat\r\n *\r\n * @param {quat2} a dual quat to calculate squared length of\r\n * @returns {Number} squared length of a\r\n * @function\r\n */\r\nexport var squaredLength = quat.squaredLength;\r\n\r\n/**\r\n * Alias for {@link quat2.squaredLength}\r\n * @function\r\n */\r\nexport var sqrLen = squaredLength;\r\n\r\n/**\r\n * Normalize a dual quat\r\n *\r\n * @param {quat2} out the receiving dual quaternion\r\n * @param {quat2} a dual quaternion to normalize\r\n * @returns {quat2} out\r\n * @function\r\n */\r\nexport function normalize(out, a) {\r\n var magnitude = squaredLength(a);\r\n if (magnitude > 0) {\r\n magnitude = Math.sqrt(magnitude);\r\n\r\n var a0 = a[0] / magnitude;\r\n var a1 = a[1] / magnitude;\r\n var a2 = a[2] / magnitude;\r\n var a3 = a[3] / magnitude;\r\n\r\n var b0 = a[4];\r\n var b1 = a[5];\r\n var b2 = a[6];\r\n var b3 = a[7];\r\n\r\n var a_dot_b = a0 * b0 + a1 * b1 + a2 * b2 + a3 * b3;\r\n\r\n out[0] = a0;\r\n out[1] = a1;\r\n out[2] = a2;\r\n out[3] = a3;\r\n\r\n out[4] = (b0 - a0 * a_dot_b) / magnitude;\r\n out[5] = (b1 - a1 * a_dot_b) / magnitude;\r\n out[6] = (b2 - a2 * a_dot_b) / magnitude;\r\n out[7] = (b3 - a3 * a_dot_b) / magnitude;\r\n }\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns a string representation of a dual quatenion\r\n *\r\n * @param {quat2} a dual quaternion to represent as a string\r\n * @returns {String} string representation of the dual quat\r\n */\r\nexport function str(a) {\r\n return 'quat2(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ', ' + a[4] + ', ' + a[5] + ', ' + a[6] + ', ' + a[7] + ')';\r\n}\r\n\r\n/**\r\n * Returns whether or not the dual quaternions have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {quat2} a the first dual quaternion.\r\n * @param {quat2} b the second dual quaternion.\r\n * @returns {Boolean} true if the dual quaternions are equal, false otherwise.\r\n */\r\nexport function exactEquals(a, b) {\r\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3] && a[4] === b[4] && a[5] === b[5] && a[6] === b[6] && a[7] === b[7];\r\n}\r\n\r\n/**\r\n * Returns whether or not the dual quaternions have approximately the same elements in the same position.\r\n *\r\n * @param {quat2} a the first dual quat.\r\n * @param {quat2} b the second dual quat.\r\n * @returns {Boolean} true if the dual quats are equal, false otherwise.\r\n */\r\nexport function equals(a, b) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3],\r\n a4 = a[4],\r\n a5 = a[5],\r\n a6 = a[6],\r\n a7 = a[7];\r\n var b0 = b[0],\r\n b1 = b[1],\r\n b2 = b[2],\r\n b3 = b[3],\r\n b4 = b[4],\r\n b5 = b[5],\r\n b6 = b[6],\r\n b7 = b[7];\r\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3)) && Math.abs(a4 - b4) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a4), Math.abs(b4)) && Math.abs(a5 - b5) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a5), Math.abs(b5)) && Math.abs(a6 - b6) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a6), Math.abs(b6)) && Math.abs(a7 - b7) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a7), Math.abs(b7));\r\n}","import * as glMatrix from \"./common.js\";\r\n\r\n/**\r\n * 2 Dimensional Vector\r\n * @module vec2\r\n */\r\n\r\n/**\r\n * Creates a new, empty vec2\r\n *\r\n * @returns {vec2} a new 2D vector\r\n */\r\nexport function create() {\r\n var out = new glMatrix.ARRAY_TYPE(2);\r\n if (glMatrix.ARRAY_TYPE != Float32Array) {\r\n out[0] = 0;\r\n out[1] = 0;\r\n }\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a new vec2 initialized with values from an existing vector\r\n *\r\n * @param {vec2} a vector to clone\r\n * @returns {vec2} a new 2D vector\r\n */\r\nexport function clone(a) {\r\n var out = new glMatrix.ARRAY_TYPE(2);\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a new vec2 initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @returns {vec2} a new 2D vector\r\n */\r\nexport function fromValues(x, y) {\r\n var out = new glMatrix.ARRAY_TYPE(2);\r\n out[0] = x;\r\n out[1] = y;\r\n return out;\r\n}\r\n\r\n/**\r\n * Copy the values from one vec2 to another\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the source vector\r\n * @returns {vec2} out\r\n */\r\nexport function copy(out, a) {\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n return out;\r\n}\r\n\r\n/**\r\n * Set the components of a vec2 to the given values\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @returns {vec2} out\r\n */\r\nexport function set(out, x, y) {\r\n out[0] = x;\r\n out[1] = y;\r\n return out;\r\n}\r\n\r\n/**\r\n * Adds two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @returns {vec2} out\r\n */\r\nexport function add(out, a, b) {\r\n out[0] = a[0] + b[0];\r\n out[1] = a[1] + b[1];\r\n return out;\r\n}\r\n\r\n/**\r\n * Subtracts vector b from vector a\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @returns {vec2} out\r\n */\r\nexport function subtract(out, a, b) {\r\n out[0] = a[0] - b[0];\r\n out[1] = a[1] - b[1];\r\n return out;\r\n}\r\n\r\n/**\r\n * Multiplies two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @returns {vec2} out\r\n */\r\nexport function multiply(out, a, b) {\r\n out[0] = a[0] * b[0];\r\n out[1] = a[1] * b[1];\r\n return out;\r\n}\r\n\r\n/**\r\n * Divides two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @returns {vec2} out\r\n */\r\nexport function divide(out, a, b) {\r\n out[0] = a[0] / b[0];\r\n out[1] = a[1] / b[1];\r\n return out;\r\n}\r\n\r\n/**\r\n * Math.ceil the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a vector to ceil\r\n * @returns {vec2} out\r\n */\r\nexport function ceil(out, a) {\r\n out[0] = Math.ceil(a[0]);\r\n out[1] = Math.ceil(a[1]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Math.floor the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a vector to floor\r\n * @returns {vec2} out\r\n */\r\nexport function floor(out, a) {\r\n out[0] = Math.floor(a[0]);\r\n out[1] = Math.floor(a[1]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns the minimum of two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @returns {vec2} out\r\n */\r\nexport function min(out, a, b) {\r\n out[0] = Math.min(a[0], b[0]);\r\n out[1] = Math.min(a[1], b[1]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns the maximum of two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @returns {vec2} out\r\n */\r\nexport function max(out, a, b) {\r\n out[0] = Math.max(a[0], b[0]);\r\n out[1] = Math.max(a[1], b[1]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Math.round the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a vector to round\r\n * @returns {vec2} out\r\n */\r\nexport function round(out, a) {\r\n out[0] = Math.round(a[0]);\r\n out[1] = Math.round(a[1]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Scales a vec2 by a scalar number\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {vec2} out\r\n */\r\nexport function scale(out, a, b) {\r\n out[0] = a[0] * b;\r\n out[1] = a[1] * b;\r\n return out;\r\n}\r\n\r\n/**\r\n * Adds two vec2's after scaling the second operand by a scalar value\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @param {Number} scale the amount to scale b by before adding\r\n * @returns {vec2} out\r\n */\r\nexport function scaleAndAdd(out, a, b, scale) {\r\n out[0] = a[0] + b[0] * scale;\r\n out[1] = a[1] + b[1] * scale;\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the euclidian distance between two vec2's\r\n *\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @returns {Number} distance between a and b\r\n */\r\nexport function distance(a, b) {\r\n var x = b[0] - a[0],\r\n y = b[1] - a[1];\r\n return Math.sqrt(x * x + y * y);\r\n}\r\n\r\n/**\r\n * Calculates the squared euclidian distance between two vec2's\r\n *\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @returns {Number} squared distance between a and b\r\n */\r\nexport function squaredDistance(a, b) {\r\n var x = b[0] - a[0],\r\n y = b[1] - a[1];\r\n return x * x + y * y;\r\n}\r\n\r\n/**\r\n * Calculates the length of a vec2\r\n *\r\n * @param {vec2} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\r\nexport function length(a) {\r\n var x = a[0],\r\n y = a[1];\r\n return Math.sqrt(x * x + y * y);\r\n}\r\n\r\n/**\r\n * Calculates the squared length of a vec2\r\n *\r\n * @param {vec2} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n */\r\nexport function squaredLength(a) {\r\n var x = a[0],\r\n y = a[1];\r\n return x * x + y * y;\r\n}\r\n\r\n/**\r\n * Negates the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a vector to negate\r\n * @returns {vec2} out\r\n */\r\nexport function negate(out, a) {\r\n out[0] = -a[0];\r\n out[1] = -a[1];\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns the inverse of the components of a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a vector to invert\r\n * @returns {vec2} out\r\n */\r\nexport function inverse(out, a) {\r\n out[0] = 1.0 / a[0];\r\n out[1] = 1.0 / a[1];\r\n return out;\r\n}\r\n\r\n/**\r\n * Normalize a vec2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a vector to normalize\r\n * @returns {vec2} out\r\n */\r\nexport function normalize(out, a) {\r\n var x = a[0],\r\n y = a[1];\r\n var len = x * x + y * y;\r\n if (len > 0) {\r\n //TODO: evaluate use of glm_invsqrt here?\r\n len = 1 / Math.sqrt(len);\r\n out[0] = a[0] * len;\r\n out[1] = a[1] * len;\r\n }\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the dot product of two vec2's\r\n *\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @returns {Number} dot product of a and b\r\n */\r\nexport function dot(a, b) {\r\n return a[0] * b[0] + a[1] * b[1];\r\n}\r\n\r\n/**\r\n * Computes the cross product of two vec2's\r\n * Note that the cross product must by definition produce a 3D vector\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @returns {vec3} out\r\n */\r\nexport function cross(out, a, b) {\r\n var z = a[0] * b[1] - a[1] * b[0];\r\n out[0] = out[1] = 0;\r\n out[2] = z;\r\n return out;\r\n}\r\n\r\n/**\r\n * Performs a linear interpolation between two vec2's\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the first operand\r\n * @param {vec2} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec2} out\r\n */\r\nexport function lerp(out, a, b, t) {\r\n var ax = a[0],\r\n ay = a[1];\r\n out[0] = ax + t * (b[0] - ax);\r\n out[1] = ay + t * (b[1] - ay);\r\n return out;\r\n}\r\n\r\n/**\r\n * Generates a random vector with the given scale\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned\r\n * @returns {vec2} out\r\n */\r\nexport function random(out, scale) {\r\n scale = scale || 1.0;\r\n var r = glMatrix.RANDOM() * 2.0 * Math.PI;\r\n out[0] = Math.cos(r) * scale;\r\n out[1] = Math.sin(r) * scale;\r\n return out;\r\n}\r\n\r\n/**\r\n * Transforms the vec2 with a mat2\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the vector to transform\r\n * @param {mat2} m matrix to transform with\r\n * @returns {vec2} out\r\n */\r\nexport function transformMat2(out, a, m) {\r\n var x = a[0],\r\n y = a[1];\r\n out[0] = m[0] * x + m[2] * y;\r\n out[1] = m[1] * x + m[3] * y;\r\n return out;\r\n}\r\n\r\n/**\r\n * Transforms the vec2 with a mat2d\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the vector to transform\r\n * @param {mat2d} m matrix to transform with\r\n * @returns {vec2} out\r\n */\r\nexport function transformMat2d(out, a, m) {\r\n var x = a[0],\r\n y = a[1];\r\n out[0] = m[0] * x + m[2] * y + m[4];\r\n out[1] = m[1] * x + m[3] * y + m[5];\r\n return out;\r\n}\r\n\r\n/**\r\n * Transforms the vec2 with a mat3\r\n * 3rd vector component is implicitly '1'\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the vector to transform\r\n * @param {mat3} m matrix to transform with\r\n * @returns {vec2} out\r\n */\r\nexport function transformMat3(out, a, m) {\r\n var x = a[0],\r\n y = a[1];\r\n out[0] = m[0] * x + m[3] * y + m[6];\r\n out[1] = m[1] * x + m[4] * y + m[7];\r\n return out;\r\n}\r\n\r\n/**\r\n * Transforms the vec2 with a mat4\r\n * 3rd vector component is implicitly '0'\r\n * 4th vector component is implicitly '1'\r\n *\r\n * @param {vec2} out the receiving vector\r\n * @param {vec2} a the vector to transform\r\n * @param {mat4} m matrix to transform with\r\n * @returns {vec2} out\r\n */\r\nexport function transformMat4(out, a, m) {\r\n var x = a[0];\r\n var y = a[1];\r\n out[0] = m[0] * x + m[4] * y + m[12];\r\n out[1] = m[1] * x + m[5] * y + m[13];\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotate a 2D vector\r\n * @param {vec2} out The receiving vec2\r\n * @param {vec2} a The vec2 point to rotate\r\n * @param {vec2} b The origin of the rotation\r\n * @param {Number} c The angle of rotation\r\n * @returns {vec2} out\r\n */\r\nexport function rotate(out, a, b, c) {\r\n //Translate point to the origin\r\n var p0 = a[0] - b[0],\r\n p1 = a[1] - b[1],\r\n sinC = Math.sin(c),\r\n cosC = Math.cos(c);\r\n\r\n //perform rotation and translate to correct position\r\n out[0] = p0 * cosC - p1 * sinC + b[0];\r\n out[1] = p0 * sinC + p1 * cosC + b[1];\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Get the angle between two 2D vectors\r\n * @param {vec2} a The first operand\r\n * @param {vec2} b The second operand\r\n * @returns {Number} The angle in radians\r\n */\r\nexport function angle(a, b) {\r\n var x1 = a[0],\r\n y1 = a[1],\r\n x2 = b[0],\r\n y2 = b[1];\r\n\r\n var len1 = x1 * x1 + y1 * y1;\r\n if (len1 > 0) {\r\n //TODO: evaluate use of glm_invsqrt here?\r\n len1 = 1 / Math.sqrt(len1);\r\n }\r\n\r\n var len2 = x2 * x2 + y2 * y2;\r\n if (len2 > 0) {\r\n //TODO: evaluate use of glm_invsqrt here?\r\n len2 = 1 / Math.sqrt(len2);\r\n }\r\n\r\n var cosine = (x1 * x2 + y1 * y2) * len1 * len2;\r\n\r\n if (cosine > 1.0) {\r\n return 0;\r\n } else if (cosine < -1.0) {\r\n return Math.PI;\r\n } else {\r\n return Math.acos(cosine);\r\n }\r\n}\r\n\r\n/**\r\n * Returns a string representation of a vector\r\n *\r\n * @param {vec2} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\r\nexport function str(a) {\r\n return 'vec2(' + a[0] + ', ' + a[1] + ')';\r\n}\r\n\r\n/**\r\n * Returns whether or not the vectors exactly have the same elements in the same position (when compared with ===)\r\n *\r\n * @param {vec2} a The first vector.\r\n * @param {vec2} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\r\nexport function exactEquals(a, b) {\r\n return a[0] === b[0] && a[1] === b[1];\r\n}\r\n\r\n/**\r\n * Returns whether or not the vectors have approximately the same elements in the same position.\r\n *\r\n * @param {vec2} a The first vector.\r\n * @param {vec2} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\r\nexport function equals(a, b) {\r\n var a0 = a[0],\r\n a1 = a[1];\r\n var b0 = b[0],\r\n b1 = b[1];\r\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1));\r\n}\r\n\r\n/**\r\n * Alias for {@link vec2.length}\r\n * @function\r\n */\r\nexport var len = length;\r\n\r\n/**\r\n * Alias for {@link vec2.subtract}\r\n * @function\r\n */\r\nexport var sub = subtract;\r\n\r\n/**\r\n * Alias for {@link vec2.multiply}\r\n * @function\r\n */\r\nexport var mul = multiply;\r\n\r\n/**\r\n * Alias for {@link vec2.divide}\r\n * @function\r\n */\r\nexport var div = divide;\r\n\r\n/**\r\n * Alias for {@link vec2.distance}\r\n * @function\r\n */\r\nexport var dist = distance;\r\n\r\n/**\r\n * Alias for {@link vec2.squaredDistance}\r\n * @function\r\n */\r\nexport var sqrDist = squaredDistance;\r\n\r\n/**\r\n * Alias for {@link vec2.squaredLength}\r\n * @function\r\n */\r\nexport var sqrLen = squaredLength;\r\n\r\n/**\r\n * Perform some operation over an array of vec2s.\r\n *\r\n * @param {Array} a the array of vectors to iterate over\r\n * @param {Number} stride Number of elements between the start of each vec2. If 0 assumes tightly packed\r\n * @param {Number} offset Number of elements to skip at the beginning of the array\r\n * @param {Number} count Number of vec2s to iterate over. If 0 iterates over entire array\r\n * @param {Function} fn Function to call for each vector in the array\r\n * @param {Object} [arg] additional argument to pass to fn\r\n * @returns {Array} a\r\n * @function\r\n */\r\nexport var forEach = function () {\r\n var vec = create();\r\n\r\n return function (a, stride, offset, count, fn, arg) {\r\n var i = void 0,\r\n l = void 0;\r\n if (!stride) {\r\n stride = 2;\r\n }\r\n\r\n if (!offset) {\r\n offset = 0;\r\n }\r\n\r\n if (count) {\r\n l = Math.min(count * stride + offset, a.length);\r\n } else {\r\n l = a.length;\r\n }\r\n\r\n for (i = offset; i < l; i += stride) {\r\n vec[0] = a[i];vec[1] = a[i + 1];\r\n fn(vec, vec, arg);\r\n a[i] = vec[0];a[i + 1] = vec[1];\r\n }\r\n\r\n return a;\r\n };\r\n}();","import * as glMatrix from \"./common.js\";\r\n\r\n/**\r\n * 3 Dimensional Vector\r\n * @module vec3\r\n */\r\n\r\n/**\r\n * Creates a new, empty vec3\r\n *\r\n * @returns {vec3} a new 3D vector\r\n */\r\nexport function create() {\r\n var out = new glMatrix.ARRAY_TYPE(3);\r\n if (glMatrix.ARRAY_TYPE != Float32Array) {\r\n out[0] = 0;\r\n out[1] = 0;\r\n out[2] = 0;\r\n }\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a new vec3 initialized with values from an existing vector\r\n *\r\n * @param {vec3} a vector to clone\r\n * @returns {vec3} a new 3D vector\r\n */\r\nexport function clone(a) {\r\n var out = new glMatrix.ARRAY_TYPE(3);\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the length of a vec3\r\n *\r\n * @param {vec3} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\r\nexport function length(a) {\r\n var x = a[0];\r\n var y = a[1];\r\n var z = a[2];\r\n return Math.sqrt(x * x + y * y + z * z);\r\n}\r\n\r\n/**\r\n * Creates a new vec3 initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @returns {vec3} a new 3D vector\r\n */\r\nexport function fromValues(x, y, z) {\r\n var out = new glMatrix.ARRAY_TYPE(3);\r\n out[0] = x;\r\n out[1] = y;\r\n out[2] = z;\r\n return out;\r\n}\r\n\r\n/**\r\n * Copy the values from one vec3 to another\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the source vector\r\n * @returns {vec3} out\r\n */\r\nexport function copy(out, a) {\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n return out;\r\n}\r\n\r\n/**\r\n * Set the components of a vec3 to the given values\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @returns {vec3} out\r\n */\r\nexport function set(out, x, y, z) {\r\n out[0] = x;\r\n out[1] = y;\r\n out[2] = z;\r\n return out;\r\n}\r\n\r\n/**\r\n * Adds two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @returns {vec3} out\r\n */\r\nexport function add(out, a, b) {\r\n out[0] = a[0] + b[0];\r\n out[1] = a[1] + b[1];\r\n out[2] = a[2] + b[2];\r\n return out;\r\n}\r\n\r\n/**\r\n * Subtracts vector b from vector a\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @returns {vec3} out\r\n */\r\nexport function subtract(out, a, b) {\r\n out[0] = a[0] - b[0];\r\n out[1] = a[1] - b[1];\r\n out[2] = a[2] - b[2];\r\n return out;\r\n}\r\n\r\n/**\r\n * Multiplies two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @returns {vec3} out\r\n */\r\nexport function multiply(out, a, b) {\r\n out[0] = a[0] * b[0];\r\n out[1] = a[1] * b[1];\r\n out[2] = a[2] * b[2];\r\n return out;\r\n}\r\n\r\n/**\r\n * Divides two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @returns {vec3} out\r\n */\r\nexport function divide(out, a, b) {\r\n out[0] = a[0] / b[0];\r\n out[1] = a[1] / b[1];\r\n out[2] = a[2] / b[2];\r\n return out;\r\n}\r\n\r\n/**\r\n * Math.ceil the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a vector to ceil\r\n * @returns {vec3} out\r\n */\r\nexport function ceil(out, a) {\r\n out[0] = Math.ceil(a[0]);\r\n out[1] = Math.ceil(a[1]);\r\n out[2] = Math.ceil(a[2]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Math.floor the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a vector to floor\r\n * @returns {vec3} out\r\n */\r\nexport function floor(out, a) {\r\n out[0] = Math.floor(a[0]);\r\n out[1] = Math.floor(a[1]);\r\n out[2] = Math.floor(a[2]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns the minimum of two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @returns {vec3} out\r\n */\r\nexport function min(out, a, b) {\r\n out[0] = Math.min(a[0], b[0]);\r\n out[1] = Math.min(a[1], b[1]);\r\n out[2] = Math.min(a[2], b[2]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns the maximum of two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @returns {vec3} out\r\n */\r\nexport function max(out, a, b) {\r\n out[0] = Math.max(a[0], b[0]);\r\n out[1] = Math.max(a[1], b[1]);\r\n out[2] = Math.max(a[2], b[2]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Math.round the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a vector to round\r\n * @returns {vec3} out\r\n */\r\nexport function round(out, a) {\r\n out[0] = Math.round(a[0]);\r\n out[1] = Math.round(a[1]);\r\n out[2] = Math.round(a[2]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Scales a vec3 by a scalar number\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {vec3} out\r\n */\r\nexport function scale(out, a, b) {\r\n out[0] = a[0] * b;\r\n out[1] = a[1] * b;\r\n out[2] = a[2] * b;\r\n return out;\r\n}\r\n\r\n/**\r\n * Adds two vec3's after scaling the second operand by a scalar value\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @param {Number} scale the amount to scale b by before adding\r\n * @returns {vec3} out\r\n */\r\nexport function scaleAndAdd(out, a, b, scale) {\r\n out[0] = a[0] + b[0] * scale;\r\n out[1] = a[1] + b[1] * scale;\r\n out[2] = a[2] + b[2] * scale;\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the euclidian distance between two vec3's\r\n *\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @returns {Number} distance between a and b\r\n */\r\nexport function distance(a, b) {\r\n var x = b[0] - a[0];\r\n var y = b[1] - a[1];\r\n var z = b[2] - a[2];\r\n return Math.sqrt(x * x + y * y + z * z);\r\n}\r\n\r\n/**\r\n * Calculates the squared euclidian distance between two vec3's\r\n *\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @returns {Number} squared distance between a and b\r\n */\r\nexport function squaredDistance(a, b) {\r\n var x = b[0] - a[0];\r\n var y = b[1] - a[1];\r\n var z = b[2] - a[2];\r\n return x * x + y * y + z * z;\r\n}\r\n\r\n/**\r\n * Calculates the squared length of a vec3\r\n *\r\n * @param {vec3} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n */\r\nexport function squaredLength(a) {\r\n var x = a[0];\r\n var y = a[1];\r\n var z = a[2];\r\n return x * x + y * y + z * z;\r\n}\r\n\r\n/**\r\n * Negates the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a vector to negate\r\n * @returns {vec3} out\r\n */\r\nexport function negate(out, a) {\r\n out[0] = -a[0];\r\n out[1] = -a[1];\r\n out[2] = -a[2];\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns the inverse of the components of a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a vector to invert\r\n * @returns {vec3} out\r\n */\r\nexport function inverse(out, a) {\r\n out[0] = 1.0 / a[0];\r\n out[1] = 1.0 / a[1];\r\n out[2] = 1.0 / a[2];\r\n return out;\r\n}\r\n\r\n/**\r\n * Normalize a vec3\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a vector to normalize\r\n * @returns {vec3} out\r\n */\r\nexport function normalize(out, a) {\r\n var x = a[0];\r\n var y = a[1];\r\n var z = a[2];\r\n var len = x * x + y * y + z * z;\r\n if (len > 0) {\r\n //TODO: evaluate use of glm_invsqrt here?\r\n len = 1 / Math.sqrt(len);\r\n out[0] = a[0] * len;\r\n out[1] = a[1] * len;\r\n out[2] = a[2] * len;\r\n }\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the dot product of two vec3's\r\n *\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @returns {Number} dot product of a and b\r\n */\r\nexport function dot(a, b) {\r\n return a[0] * b[0] + a[1] * b[1] + a[2] * b[2];\r\n}\r\n\r\n/**\r\n * Computes the cross product of two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @returns {vec3} out\r\n */\r\nexport function cross(out, a, b) {\r\n var ax = a[0],\r\n ay = a[1],\r\n az = a[2];\r\n var bx = b[0],\r\n by = b[1],\r\n bz = b[2];\r\n\r\n out[0] = ay * bz - az * by;\r\n out[1] = az * bx - ax * bz;\r\n out[2] = ax * by - ay * bx;\r\n return out;\r\n}\r\n\r\n/**\r\n * Performs a linear interpolation between two vec3's\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec3} out\r\n */\r\nexport function lerp(out, a, b, t) {\r\n var ax = a[0];\r\n var ay = a[1];\r\n var az = a[2];\r\n out[0] = ax + t * (b[0] - ax);\r\n out[1] = ay + t * (b[1] - ay);\r\n out[2] = az + t * (b[2] - az);\r\n return out;\r\n}\r\n\r\n/**\r\n * Performs a hermite interpolation with two control points\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @param {vec3} c the third operand\r\n * @param {vec3} d the fourth operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec3} out\r\n */\r\nexport function hermite(out, a, b, c, d, t) {\r\n var factorTimes2 = t * t;\r\n var factor1 = factorTimes2 * (2 * t - 3) + 1;\r\n var factor2 = factorTimes2 * (t - 2) + t;\r\n var factor3 = factorTimes2 * (t - 1);\r\n var factor4 = factorTimes2 * (3 - 2 * t);\r\n\r\n out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;\r\n out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;\r\n out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Performs a bezier interpolation with two control points\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the first operand\r\n * @param {vec3} b the second operand\r\n * @param {vec3} c the third operand\r\n * @param {vec3} d the fourth operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec3} out\r\n */\r\nexport function bezier(out, a, b, c, d, t) {\r\n var inverseFactor = 1 - t;\r\n var inverseFactorTimesTwo = inverseFactor * inverseFactor;\r\n var factorTimes2 = t * t;\r\n var factor1 = inverseFactorTimesTwo * inverseFactor;\r\n var factor2 = 3 * t * inverseFactorTimesTwo;\r\n var factor3 = 3 * factorTimes2 * inverseFactor;\r\n var factor4 = factorTimes2 * t;\r\n\r\n out[0] = a[0] * factor1 + b[0] * factor2 + c[0] * factor3 + d[0] * factor4;\r\n out[1] = a[1] * factor1 + b[1] * factor2 + c[1] * factor3 + d[1] * factor4;\r\n out[2] = a[2] * factor1 + b[2] * factor2 + c[2] * factor3 + d[2] * factor4;\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Generates a random vector with the given scale\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned\r\n * @returns {vec3} out\r\n */\r\nexport function random(out, scale) {\r\n scale = scale || 1.0;\r\n\r\n var r = glMatrix.RANDOM() * 2.0 * Math.PI;\r\n var z = glMatrix.RANDOM() * 2.0 - 1.0;\r\n var zScale = Math.sqrt(1.0 - z * z) * scale;\r\n\r\n out[0] = Math.cos(r) * zScale;\r\n out[1] = Math.sin(r) * zScale;\r\n out[2] = z * scale;\r\n return out;\r\n}\r\n\r\n/**\r\n * Transforms the vec3 with a mat4.\r\n * 4th vector component is implicitly '1'\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the vector to transform\r\n * @param {mat4} m matrix to transform with\r\n * @returns {vec3} out\r\n */\r\nexport function transformMat4(out, a, m) {\r\n var x = a[0],\r\n y = a[1],\r\n z = a[2];\r\n var w = m[3] * x + m[7] * y + m[11] * z + m[15];\r\n w = w || 1.0;\r\n out[0] = (m[0] * x + m[4] * y + m[8] * z + m[12]) / w;\r\n out[1] = (m[1] * x + m[5] * y + m[9] * z + m[13]) / w;\r\n out[2] = (m[2] * x + m[6] * y + m[10] * z + m[14]) / w;\r\n return out;\r\n}\r\n\r\n/**\r\n * Transforms the vec3 with a mat3.\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the vector to transform\r\n * @param {mat3} m the 3x3 matrix to transform with\r\n * @returns {vec3} out\r\n */\r\nexport function transformMat3(out, a, m) {\r\n var x = a[0],\r\n y = a[1],\r\n z = a[2];\r\n out[0] = x * m[0] + y * m[3] + z * m[6];\r\n out[1] = x * m[1] + y * m[4] + z * m[7];\r\n out[2] = x * m[2] + y * m[5] + z * m[8];\r\n return out;\r\n}\r\n\r\n/**\r\n * Transforms the vec3 with a quat\r\n * Can also be used for dual quaternions. (Multiply it with the real part)\r\n *\r\n * @param {vec3} out the receiving vector\r\n * @param {vec3} a the vector to transform\r\n * @param {quat} q quaternion to transform with\r\n * @returns {vec3} out\r\n */\r\nexport function transformQuat(out, a, q) {\r\n // benchmarks: https://jsperf.com/quaternion-transform-vec3-implementations-fixed\r\n var qx = q[0],\r\n qy = q[1],\r\n qz = q[2],\r\n qw = q[3];\r\n var x = a[0],\r\n y = a[1],\r\n z = a[2];\r\n // var qvec = [qx, qy, qz];\r\n // var uv = vec3.cross([], qvec, a);\r\n var uvx = qy * z - qz * y,\r\n uvy = qz * x - qx * z,\r\n uvz = qx * y - qy * x;\r\n // var uuv = vec3.cross([], qvec, uv);\r\n var uuvx = qy * uvz - qz * uvy,\r\n uuvy = qz * uvx - qx * uvz,\r\n uuvz = qx * uvy - qy * uvx;\r\n // vec3.scale(uv, uv, 2 * w);\r\n var w2 = qw * 2;\r\n uvx *= w2;\r\n uvy *= w2;\r\n uvz *= w2;\r\n // vec3.scale(uuv, uuv, 2);\r\n uuvx *= 2;\r\n uuvy *= 2;\r\n uuvz *= 2;\r\n // return vec3.add(out, a, vec3.add(out, uv, uuv));\r\n out[0] = x + uvx + uuvx;\r\n out[1] = y + uvy + uuvy;\r\n out[2] = z + uvz + uuvz;\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotate a 3D vector around the x-axis\r\n * @param {vec3} out The receiving vec3\r\n * @param {vec3} a The vec3 point to rotate\r\n * @param {vec3} b The origin of the rotation\r\n * @param {Number} c The angle of rotation\r\n * @returns {vec3} out\r\n */\r\nexport function rotateX(out, a, b, c) {\r\n var p = [],\r\n r = [];\r\n //Translate point to the origin\r\n p[0] = a[0] - b[0];\r\n p[1] = a[1] - b[1];\r\n p[2] = a[2] - b[2];\r\n\r\n //perform rotation\r\n r[0] = p[0];\r\n r[1] = p[1] * Math.cos(c) - p[2] * Math.sin(c);\r\n r[2] = p[1] * Math.sin(c) + p[2] * Math.cos(c);\r\n\r\n //translate to correct position\r\n out[0] = r[0] + b[0];\r\n out[1] = r[1] + b[1];\r\n out[2] = r[2] + b[2];\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotate a 3D vector around the y-axis\r\n * @param {vec3} out The receiving vec3\r\n * @param {vec3} a The vec3 point to rotate\r\n * @param {vec3} b The origin of the rotation\r\n * @param {Number} c The angle of rotation\r\n * @returns {vec3} out\r\n */\r\nexport function rotateY(out, a, b, c) {\r\n var p = [],\r\n r = [];\r\n //Translate point to the origin\r\n p[0] = a[0] - b[0];\r\n p[1] = a[1] - b[1];\r\n p[2] = a[2] - b[2];\r\n\r\n //perform rotation\r\n r[0] = p[2] * Math.sin(c) + p[0] * Math.cos(c);\r\n r[1] = p[1];\r\n r[2] = p[2] * Math.cos(c) - p[0] * Math.sin(c);\r\n\r\n //translate to correct position\r\n out[0] = r[0] + b[0];\r\n out[1] = r[1] + b[1];\r\n out[2] = r[2] + b[2];\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Rotate a 3D vector around the z-axis\r\n * @param {vec3} out The receiving vec3\r\n * @param {vec3} a The vec3 point to rotate\r\n * @param {vec3} b The origin of the rotation\r\n * @param {Number} c The angle of rotation\r\n * @returns {vec3} out\r\n */\r\nexport function rotateZ(out, a, b, c) {\r\n var p = [],\r\n r = [];\r\n //Translate point to the origin\r\n p[0] = a[0] - b[0];\r\n p[1] = a[1] - b[1];\r\n p[2] = a[2] - b[2];\r\n\r\n //perform rotation\r\n r[0] = p[0] * Math.cos(c) - p[1] * Math.sin(c);\r\n r[1] = p[0] * Math.sin(c) + p[1] * Math.cos(c);\r\n r[2] = p[2];\r\n\r\n //translate to correct position\r\n out[0] = r[0] + b[0];\r\n out[1] = r[1] + b[1];\r\n out[2] = r[2] + b[2];\r\n\r\n return out;\r\n}\r\n\r\n/**\r\n * Get the angle between two 3D vectors\r\n * @param {vec3} a The first operand\r\n * @param {vec3} b The second operand\r\n * @returns {Number} The angle in radians\r\n */\r\nexport function angle(a, b) {\r\n var tempA = fromValues(a[0], a[1], a[2]);\r\n var tempB = fromValues(b[0], b[1], b[2]);\r\n\r\n normalize(tempA, tempA);\r\n normalize(tempB, tempB);\r\n\r\n var cosine = dot(tempA, tempB);\r\n\r\n if (cosine > 1.0) {\r\n return 0;\r\n } else if (cosine < -1.0) {\r\n return Math.PI;\r\n } else {\r\n return Math.acos(cosine);\r\n }\r\n}\r\n\r\n/**\r\n * Returns a string representation of a vector\r\n *\r\n * @param {vec3} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\r\nexport function str(a) {\r\n return 'vec3(' + a[0] + ', ' + a[1] + ', ' + a[2] + ')';\r\n}\r\n\r\n/**\r\n * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {vec3} a The first vector.\r\n * @param {vec3} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\r\nexport function exactEquals(a, b) {\r\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2];\r\n}\r\n\r\n/**\r\n * Returns whether or not the vectors have approximately the same elements in the same position.\r\n *\r\n * @param {vec3} a The first vector.\r\n * @param {vec3} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\r\nexport function equals(a, b) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2];\r\n var b0 = b[0],\r\n b1 = b[1],\r\n b2 = b[2];\r\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2));\r\n}\r\n\r\n/**\r\n * Alias for {@link vec3.subtract}\r\n * @function\r\n */\r\nexport var sub = subtract;\r\n\r\n/**\r\n * Alias for {@link vec3.multiply}\r\n * @function\r\n */\r\nexport var mul = multiply;\r\n\r\n/**\r\n * Alias for {@link vec3.divide}\r\n * @function\r\n */\r\nexport var div = divide;\r\n\r\n/**\r\n * Alias for {@link vec3.distance}\r\n * @function\r\n */\r\nexport var dist = distance;\r\n\r\n/**\r\n * Alias for {@link vec3.squaredDistance}\r\n * @function\r\n */\r\nexport var sqrDist = squaredDistance;\r\n\r\n/**\r\n * Alias for {@link vec3.length}\r\n * @function\r\n */\r\nexport var len = length;\r\n\r\n/**\r\n * Alias for {@link vec3.squaredLength}\r\n * @function\r\n */\r\nexport var sqrLen = squaredLength;\r\n\r\n/**\r\n * Perform some operation over an array of vec3s.\r\n *\r\n * @param {Array} a the array of vectors to iterate over\r\n * @param {Number} stride Number of elements between the start of each vec3. If 0 assumes tightly packed\r\n * @param {Number} offset Number of elements to skip at the beginning of the array\r\n * @param {Number} count Number of vec3s to iterate over. If 0 iterates over entire array\r\n * @param {Function} fn Function to call for each vector in the array\r\n * @param {Object} [arg] additional argument to pass to fn\r\n * @returns {Array} a\r\n * @function\r\n */\r\nexport var forEach = function () {\r\n var vec = create();\r\n\r\n return function (a, stride, offset, count, fn, arg) {\r\n var i = void 0,\r\n l = void 0;\r\n if (!stride) {\r\n stride = 3;\r\n }\r\n\r\n if (!offset) {\r\n offset = 0;\r\n }\r\n\r\n if (count) {\r\n l = Math.min(count * stride + offset, a.length);\r\n } else {\r\n l = a.length;\r\n }\r\n\r\n for (i = offset; i < l; i += stride) {\r\n vec[0] = a[i];vec[1] = a[i + 1];vec[2] = a[i + 2];\r\n fn(vec, vec, arg);\r\n a[i] = vec[0];a[i + 1] = vec[1];a[i + 2] = vec[2];\r\n }\r\n\r\n return a;\r\n };\r\n}();","import * as glMatrix from \"./common.js\";\r\n\r\n/**\r\n * 4 Dimensional Vector\r\n * @module vec4\r\n */\r\n\r\n/**\r\n * Creates a new, empty vec4\r\n *\r\n * @returns {vec4} a new 4D vector\r\n */\r\nexport function create() {\r\n var out = new glMatrix.ARRAY_TYPE(4);\r\n if (glMatrix.ARRAY_TYPE != Float32Array) {\r\n out[0] = 0;\r\n out[1] = 0;\r\n out[2] = 0;\r\n out[3] = 0;\r\n }\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a new vec4 initialized with values from an existing vector\r\n *\r\n * @param {vec4} a vector to clone\r\n * @returns {vec4} a new 4D vector\r\n */\r\nexport function clone(a) {\r\n var out = new glMatrix.ARRAY_TYPE(4);\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Creates a new vec4 initialized with the given values\r\n *\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {vec4} a new 4D vector\r\n */\r\nexport function fromValues(x, y, z, w) {\r\n var out = new glMatrix.ARRAY_TYPE(4);\r\n out[0] = x;\r\n out[1] = y;\r\n out[2] = z;\r\n out[3] = w;\r\n return out;\r\n}\r\n\r\n/**\r\n * Copy the values from one vec4 to another\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the source vector\r\n * @returns {vec4} out\r\n */\r\nexport function copy(out, a) {\r\n out[0] = a[0];\r\n out[1] = a[1];\r\n out[2] = a[2];\r\n out[3] = a[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Set the components of a vec4 to the given values\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {Number} x X component\r\n * @param {Number} y Y component\r\n * @param {Number} z Z component\r\n * @param {Number} w W component\r\n * @returns {vec4} out\r\n */\r\nexport function set(out, x, y, z, w) {\r\n out[0] = x;\r\n out[1] = y;\r\n out[2] = z;\r\n out[3] = w;\r\n return out;\r\n}\r\n\r\n/**\r\n * Adds two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the first operand\r\n * @param {vec4} b the second operand\r\n * @returns {vec4} out\r\n */\r\nexport function add(out, a, b) {\r\n out[0] = a[0] + b[0];\r\n out[1] = a[1] + b[1];\r\n out[2] = a[2] + b[2];\r\n out[3] = a[3] + b[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Subtracts vector b from vector a\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the first operand\r\n * @param {vec4} b the second operand\r\n * @returns {vec4} out\r\n */\r\nexport function subtract(out, a, b) {\r\n out[0] = a[0] - b[0];\r\n out[1] = a[1] - b[1];\r\n out[2] = a[2] - b[2];\r\n out[3] = a[3] - b[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Multiplies two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the first operand\r\n * @param {vec4} b the second operand\r\n * @returns {vec4} out\r\n */\r\nexport function multiply(out, a, b) {\r\n out[0] = a[0] * b[0];\r\n out[1] = a[1] * b[1];\r\n out[2] = a[2] * b[2];\r\n out[3] = a[3] * b[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Divides two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the first operand\r\n * @param {vec4} b the second operand\r\n * @returns {vec4} out\r\n */\r\nexport function divide(out, a, b) {\r\n out[0] = a[0] / b[0];\r\n out[1] = a[1] / b[1];\r\n out[2] = a[2] / b[2];\r\n out[3] = a[3] / b[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Math.ceil the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a vector to ceil\r\n * @returns {vec4} out\r\n */\r\nexport function ceil(out, a) {\r\n out[0] = Math.ceil(a[0]);\r\n out[1] = Math.ceil(a[1]);\r\n out[2] = Math.ceil(a[2]);\r\n out[3] = Math.ceil(a[3]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Math.floor the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a vector to floor\r\n * @returns {vec4} out\r\n */\r\nexport function floor(out, a) {\r\n out[0] = Math.floor(a[0]);\r\n out[1] = Math.floor(a[1]);\r\n out[2] = Math.floor(a[2]);\r\n out[3] = Math.floor(a[3]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns the minimum of two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the first operand\r\n * @param {vec4} b the second operand\r\n * @returns {vec4} out\r\n */\r\nexport function min(out, a, b) {\r\n out[0] = Math.min(a[0], b[0]);\r\n out[1] = Math.min(a[1], b[1]);\r\n out[2] = Math.min(a[2], b[2]);\r\n out[3] = Math.min(a[3], b[3]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns the maximum of two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the first operand\r\n * @param {vec4} b the second operand\r\n * @returns {vec4} out\r\n */\r\nexport function max(out, a, b) {\r\n out[0] = Math.max(a[0], b[0]);\r\n out[1] = Math.max(a[1], b[1]);\r\n out[2] = Math.max(a[2], b[2]);\r\n out[3] = Math.max(a[3], b[3]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Math.round the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a vector to round\r\n * @returns {vec4} out\r\n */\r\nexport function round(out, a) {\r\n out[0] = Math.round(a[0]);\r\n out[1] = Math.round(a[1]);\r\n out[2] = Math.round(a[2]);\r\n out[3] = Math.round(a[3]);\r\n return out;\r\n}\r\n\r\n/**\r\n * Scales a vec4 by a scalar number\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the vector to scale\r\n * @param {Number} b amount to scale the vector by\r\n * @returns {vec4} out\r\n */\r\nexport function scale(out, a, b) {\r\n out[0] = a[0] * b;\r\n out[1] = a[1] * b;\r\n out[2] = a[2] * b;\r\n out[3] = a[3] * b;\r\n return out;\r\n}\r\n\r\n/**\r\n * Adds two vec4's after scaling the second operand by a scalar value\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the first operand\r\n * @param {vec4} b the second operand\r\n * @param {Number} scale the amount to scale b by before adding\r\n * @returns {vec4} out\r\n */\r\nexport function scaleAndAdd(out, a, b, scale) {\r\n out[0] = a[0] + b[0] * scale;\r\n out[1] = a[1] + b[1] * scale;\r\n out[2] = a[2] + b[2] * scale;\r\n out[3] = a[3] + b[3] * scale;\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the euclidian distance between two vec4's\r\n *\r\n * @param {vec4} a the first operand\r\n * @param {vec4} b the second operand\r\n * @returns {Number} distance between a and b\r\n */\r\nexport function distance(a, b) {\r\n var x = b[0] - a[0];\r\n var y = b[1] - a[1];\r\n var z = b[2] - a[2];\r\n var w = b[3] - a[3];\r\n return Math.sqrt(x * x + y * y + z * z + w * w);\r\n}\r\n\r\n/**\r\n * Calculates the squared euclidian distance between two vec4's\r\n *\r\n * @param {vec4} a the first operand\r\n * @param {vec4} b the second operand\r\n * @returns {Number} squared distance between a and b\r\n */\r\nexport function squaredDistance(a, b) {\r\n var x = b[0] - a[0];\r\n var y = b[1] - a[1];\r\n var z = b[2] - a[2];\r\n var w = b[3] - a[3];\r\n return x * x + y * y + z * z + w * w;\r\n}\r\n\r\n/**\r\n * Calculates the length of a vec4\r\n *\r\n * @param {vec4} a vector to calculate length of\r\n * @returns {Number} length of a\r\n */\r\nexport function length(a) {\r\n var x = a[0];\r\n var y = a[1];\r\n var z = a[2];\r\n var w = a[3];\r\n return Math.sqrt(x * x + y * y + z * z + w * w);\r\n}\r\n\r\n/**\r\n * Calculates the squared length of a vec4\r\n *\r\n * @param {vec4} a vector to calculate squared length of\r\n * @returns {Number} squared length of a\r\n */\r\nexport function squaredLength(a) {\r\n var x = a[0];\r\n var y = a[1];\r\n var z = a[2];\r\n var w = a[3];\r\n return x * x + y * y + z * z + w * w;\r\n}\r\n\r\n/**\r\n * Negates the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a vector to negate\r\n * @returns {vec4} out\r\n */\r\nexport function negate(out, a) {\r\n out[0] = -a[0];\r\n out[1] = -a[1];\r\n out[2] = -a[2];\r\n out[3] = -a[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns the inverse of the components of a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a vector to invert\r\n * @returns {vec4} out\r\n */\r\nexport function inverse(out, a) {\r\n out[0] = 1.0 / a[0];\r\n out[1] = 1.0 / a[1];\r\n out[2] = 1.0 / a[2];\r\n out[3] = 1.0 / a[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Normalize a vec4\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a vector to normalize\r\n * @returns {vec4} out\r\n */\r\nexport function normalize(out, a) {\r\n var x = a[0];\r\n var y = a[1];\r\n var z = a[2];\r\n var w = a[3];\r\n var len = x * x + y * y + z * z + w * w;\r\n if (len > 0) {\r\n len = 1 / Math.sqrt(len);\r\n out[0] = x * len;\r\n out[1] = y * len;\r\n out[2] = z * len;\r\n out[3] = w * len;\r\n }\r\n return out;\r\n}\r\n\r\n/**\r\n * Calculates the dot product of two vec4's\r\n *\r\n * @param {vec4} a the first operand\r\n * @param {vec4} b the second operand\r\n * @returns {Number} dot product of a and b\r\n */\r\nexport function dot(a, b) {\r\n return a[0] * b[0] + a[1] * b[1] + a[2] * b[2] + a[3] * b[3];\r\n}\r\n\r\n/**\r\n * Performs a linear interpolation between two vec4's\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the first operand\r\n * @param {vec4} b the second operand\r\n * @param {Number} t interpolation amount, in the range [0-1], between the two inputs\r\n * @returns {vec4} out\r\n */\r\nexport function lerp(out, a, b, t) {\r\n var ax = a[0];\r\n var ay = a[1];\r\n var az = a[2];\r\n var aw = a[3];\r\n out[0] = ax + t * (b[0] - ax);\r\n out[1] = ay + t * (b[1] - ay);\r\n out[2] = az + t * (b[2] - az);\r\n out[3] = aw + t * (b[3] - aw);\r\n return out;\r\n}\r\n\r\n/**\r\n * Generates a random vector with the given scale\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {Number} [scale] Length of the resulting vector. If ommitted, a unit vector will be returned\r\n * @returns {vec4} out\r\n */\r\nexport function random(out, scale) {\r\n scale = scale || 1.0;\r\n\r\n // Marsaglia, George. Choosing a Point from the Surface of a\r\n // Sphere. Ann. Math. Statist. 43 (1972), no. 2, 645--646.\r\n // http://projecteuclid.org/euclid.aoms/1177692644;\r\n var v1, v2, v3, v4;\r\n var s1, s2;\r\n do {\r\n v1 = glMatrix.RANDOM() * 2 - 1;\r\n v2 = glMatrix.RANDOM() * 2 - 1;\r\n s1 = v1 * v1 + v2 * v2;\r\n } while (s1 >= 1);\r\n do {\r\n v3 = glMatrix.RANDOM() * 2 - 1;\r\n v4 = glMatrix.RANDOM() * 2 - 1;\r\n s2 = v3 * v3 + v4 * v4;\r\n } while (s2 >= 1);\r\n\r\n var d = Math.sqrt((1 - s1) / s2);\r\n out[0] = scale * v1;\r\n out[1] = scale * v2;\r\n out[2] = scale * v3 * d;\r\n out[3] = scale * v4 * d;\r\n return out;\r\n}\r\n\r\n/**\r\n * Transforms the vec4 with a mat4.\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the vector to transform\r\n * @param {mat4} m matrix to transform with\r\n * @returns {vec4} out\r\n */\r\nexport function transformMat4(out, a, m) {\r\n var x = a[0],\r\n y = a[1],\r\n z = a[2],\r\n w = a[3];\r\n out[0] = m[0] * x + m[4] * y + m[8] * z + m[12] * w;\r\n out[1] = m[1] * x + m[5] * y + m[9] * z + m[13] * w;\r\n out[2] = m[2] * x + m[6] * y + m[10] * z + m[14] * w;\r\n out[3] = m[3] * x + m[7] * y + m[11] * z + m[15] * w;\r\n return out;\r\n}\r\n\r\n/**\r\n * Transforms the vec4 with a quat\r\n *\r\n * @param {vec4} out the receiving vector\r\n * @param {vec4} a the vector to transform\r\n * @param {quat} q quaternion to transform with\r\n * @returns {vec4} out\r\n */\r\nexport function transformQuat(out, a, q) {\r\n var x = a[0],\r\n y = a[1],\r\n z = a[2];\r\n var qx = q[0],\r\n qy = q[1],\r\n qz = q[2],\r\n qw = q[3];\r\n\r\n // calculate quat * vec\r\n var ix = qw * x + qy * z - qz * y;\r\n var iy = qw * y + qz * x - qx * z;\r\n var iz = qw * z + qx * y - qy * x;\r\n var iw = -qx * x - qy * y - qz * z;\r\n\r\n // calculate result * inverse quat\r\n out[0] = ix * qw + iw * -qx + iy * -qz - iz * -qy;\r\n out[1] = iy * qw + iw * -qy + iz * -qx - ix * -qz;\r\n out[2] = iz * qw + iw * -qz + ix * -qy - iy * -qx;\r\n out[3] = a[3];\r\n return out;\r\n}\r\n\r\n/**\r\n * Returns a string representation of a vector\r\n *\r\n * @param {vec4} a vector to represent as a string\r\n * @returns {String} string representation of the vector\r\n */\r\nexport function str(a) {\r\n return 'vec4(' + a[0] + ', ' + a[1] + ', ' + a[2] + ', ' + a[3] + ')';\r\n}\r\n\r\n/**\r\n * Returns whether or not the vectors have exactly the same elements in the same position (when compared with ===)\r\n *\r\n * @param {vec4} a The first vector.\r\n * @param {vec4} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\r\nexport function exactEquals(a, b) {\r\n return a[0] === b[0] && a[1] === b[1] && a[2] === b[2] && a[3] === b[3];\r\n}\r\n\r\n/**\r\n * Returns whether or not the vectors have approximately the same elements in the same position.\r\n *\r\n * @param {vec4} a The first vector.\r\n * @param {vec4} b The second vector.\r\n * @returns {Boolean} True if the vectors are equal, false otherwise.\r\n */\r\nexport function equals(a, b) {\r\n var a0 = a[0],\r\n a1 = a[1],\r\n a2 = a[2],\r\n a3 = a[3];\r\n var b0 = b[0],\r\n b1 = b[1],\r\n b2 = b[2],\r\n b3 = b[3];\r\n return Math.abs(a0 - b0) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a0), Math.abs(b0)) && Math.abs(a1 - b1) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a1), Math.abs(b1)) && Math.abs(a2 - b2) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a2), Math.abs(b2)) && Math.abs(a3 - b3) <= glMatrix.EPSILON * Math.max(1.0, Math.abs(a3), Math.abs(b3));\r\n}\r\n\r\n/**\r\n * Alias for {@link vec4.subtract}\r\n * @function\r\n */\r\nexport var sub = subtract;\r\n\r\n/**\r\n * Alias for {@link vec4.multiply}\r\n * @function\r\n */\r\nexport var mul = multiply;\r\n\r\n/**\r\n * Alias for {@link vec4.divide}\r\n * @function\r\n */\r\nexport var div = divide;\r\n\r\n/**\r\n * Alias for {@link vec4.distance}\r\n * @function\r\n */\r\nexport var dist = distance;\r\n\r\n/**\r\n * Alias for {@link vec4.squaredDistance}\r\n * @function\r\n */\r\nexport var sqrDist = squaredDistance;\r\n\r\n/**\r\n * Alias for {@link vec4.length}\r\n * @function\r\n */\r\nexport var len = length;\r\n\r\n/**\r\n * Alias for {@link vec4.squaredLength}\r\n * @function\r\n */\r\nexport var sqrLen = squaredLength;\r\n\r\n/**\r\n * Perform some operation over an array of vec4s.\r\n *\r\n * @param {Array} a the array of vectors to iterate over\r\n * @param {Number} stride Number of elements between the start of each vec4. If 0 assumes tightly packed\r\n * @param {Number} offset Number of elements to skip at the beginning of the array\r\n * @param {Number} count Number of vec4s to iterate over. If 0 iterates over entire array\r\n * @param {Function} fn Function to call for each vector in the array\r\n * @param {Object} [arg] additional argument to pass to fn\r\n * @returns {Array} a\r\n * @function\r\n */\r\nexport var forEach = function () {\r\n var vec = create();\r\n\r\n return function (a, stride, offset, count, fn, arg) {\r\n var i = void 0,\r\n l = void 0;\r\n if (!stride) {\r\n stride = 4;\r\n }\r\n\r\n if (!offset) {\r\n offset = 0;\r\n }\r\n\r\n if (count) {\r\n l = Math.min(count * stride + offset, a.length);\r\n } else {\r\n l = a.length;\r\n }\r\n\r\n for (i = offset; i < l; i += stride) {\r\n vec[0] = a[i];vec[1] = a[i + 1];vec[2] = a[i + 2];vec[3] = a[i + 3];\r\n fn(vec, vec, arg);\r\n a[i] = vec[0];a[i + 1] = vec[1];a[i + 2] = vec[2];a[i + 3] = vec[3];\r\n }\r\n\r\n return a;\r\n };\r\n}();","import Dispatcher from \"./Dispatcher.js\";\n\nexport default class Actor extends Dispatcher\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\n\t\tthis._Artboards = [];\n\t\tthis._NestedActorAssets = [];\n\t\tthis._Atlases = [];\n\t}\n\n\tgetArtboard(name)\n\t{\n\t\treturn this._Artboards.find(artboard => artboard._Name === name);\n\t}\n\n\tdispose(graphics)\n\t{\n\t\tfor(const artboard of this._Artboards)\n\t\t{\n\t\t\tartboard.dispose(graphics);\n\t\t}\n\t}\n\n\tinitialize(graphics)\n\t{\n\t\tfor(let nested of this._NestedActorAssets)\n\t\t{\n\t\t\tif(nested.actor)\n\t\t\t{\n\t\t\t\tnested.actor.initialize(graphics);\n\t\t\t}\n\t\t}\n\t\tfor(const artboard of this._Artboards)\n\t\t{\n\t\t\tartboard.initialize(graphics);\n\t\t}\n\t}\n\n\tmakeInstance()\n\t{\n\t\treturn (this._Artboards.length && this._Artboards[0].makeInstance()) || null;\n\t}\n\n\tget animations()\n\t{\n\t\treturn (this._Artboards.length && this._Artboards[0]._Animations) || null;\n\t}\n}","import ActorNode from \"./ActorNode.js\";\nimport ActorShape from \"./ActorShape.js\";\nimport ActorImage from \"./ActorImage.js\";\nimport NestedActorNode from \"./NestedActorNode.js\";\nimport AnimationInstance from \"./AnimationInstance.js\";\nimport {mat2d, vec2, vec4} from \"gl-matrix\";\n\nexport default class ActorArtboard\n{\n constructor(actor)\n {\n this._Actor = actor;\n this._Components = [];\n this._Nodes = [];\n this._RootNode = new ActorNode();\n\t\tthis._RootNode._Name = \"Root\";\n\t\tthis._Components.push(this._RootNode);\n this._Drawables = [];\n this._Animations = [];\n\t\tthis._IsImageSortDirty = false;\n\t\tthis._Order = null;\n\t\tthis._IsDirty = false;\n\t\tthis._DirtDepth = 0;\n \n this._Name = \"Artboard\";\n this._Origin = vec2.create();\n this._Translation = vec2.create();\n this._Color = vec4.create();\n this._ClipsContents = true;\n\t\tthis._Width = 0;\n\t\tthis._Height = 0;\n }\n\n get name()\n {\n return this._Name;\n\t}\n\t\n\tget width()\n\t{\n\t\treturn this._Width;\n\t}\n\n\tget height()\n\t{\n\t\treturn this._Height;\n\t}\n\n get origin()\n {\n return this._Name;\n }\n\n get translation()\n {\n return this._Translation;\n }\n\n get color()\n {\n return this._Color;\n }\n\n get clipsContents()\n {\n return this._ClipsContents;\n }\n\n get root()\n {\n return this._RootNode;\n }\n\n get actor()\n {\n return this._Actor;\n }\n\n addDependency(a, b)\n\t{\n\t\t// \"a\" depends on \"b\"\n\t\tlet dependents = b._Dependents;\n\t\tif(!dependents)\n\t\t{\n\t\t\tdependents = b._Dependents = [];\n\t\t}\n\t\tif(dependents.indexOf(a) !== -1)\n\t\t{\n\t\t\treturn false;\n\t\t}\n\t\tdependents.push(a);\n\t\treturn true;\n\t}\n\n\tsortDependencies()\n\t{\n\t\tlet perm = new Set();\n\t\tlet temp = new Set();\n\n\t\tlet order = [];\n\n\t\tfunction visit(n)\n\t\t{\n\t\t\tif(perm.has(n))\n\t\t\t{\n\t\t\t\treturn true;\n\t\t\t}\n\t\t\tif(temp.has(n))\n\t\t\t{\n\t\t\t\tconsole.warn(\"Dependency cycle!\", n);\n\t\t\t\treturn false;\n\t\t\t}\n\t\t\t\n\t\t\ttemp.add(n);\n\n\t\t\tlet dependents = n._Dependents;\n\t\t\tif(dependents)\n\t\t\t{\n\t\t\t\tfor(let d of dependents)\n\t\t\t\t{\n\t\t\t\t\tif(!visit(d))\n\t\t\t\t\t{\n\t\t\t\t\t\treturn false;\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tperm.add(n);\n\t\t\torder.unshift(n);\n\t\t\t\n\t\t\treturn true;\n\t\t}\n\n\t\tif(!visit(this._RootNode))\n\t\t{\n\t\t\t// We have cyclic dependencies.\n\t\t\treturn false;\n\t\t}\n\n\t\tfor(let i = 0; i < order.length; i++)\n\t\t{\n\t\t\tlet component = order[i];\n\t\t\tcomponent._GraphOrder = i;\n\t\t\tcomponent._DirtMask = 255;\n\t\t}\n\t\tthis._Order = order;\n\t\tthis._IsDirty = true;\n\t}\n\n\taddDirt(component, value, recurse)\n\t{\n\t\tif((component._DirtMask & value) === value)\n\t\t{\n\t\t\t// Already marked.\n\t\t\treturn false;\n\t\t}\n\n\t\t// Make sure dirt is set before calling anything that can set more dirt.\n\t\tlet dirt = component._DirtMask | value;\n\t\tcomponent._DirtMask = dirt;\n\n\t\tthis._IsDirty = true;\n\n\t\tcomponent.onDirty(dirt);\n\n\t\t// If the order of this component is less than the current dirt depth, update the dirt depth\n\t\t// so that the update loop can break out early and re-run (something up the tree is dirty).\n\t\tif(component._GraphOrder < this._DirtDepth)\n\t\t{\n\t\t\tthis._DirtDepth = component._GraphOrder;\t\n\t\t}\n\t\tif(!recurse)\n\t\t{\n\t\t\treturn true;\n\t\t}\n\t\tlet dependents = component._Dependents;\n\t\tif(dependents)\n\t\t{\n\t\t\tfor(let d of dependents)\n\t\t\t{\n\t\t\t\tthis.addDirt(d, value, recurse);\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n }\n \n update()\n\t{\n\t\tif(!this._IsDirty)\n\t\t{\n\t\t\treturn false;\n\t\t}\n\t\t\n\t\tlet order = this._Order;\n\t\tlet end = order.length;\n\n\t\tconst maxSteps = 100;\n\t\tlet step = 0;\n\t\twhile(this._IsDirty && step < maxSteps)\n\t\t{\n\t\t\tthis._IsDirty = false;\n\t\t\t// Track dirt depth here so that if something else marks dirty, we restart.\n\t\t\tfor(let i = 0; i < end; i++)\n\t\t\t{\n\t\t\t\tlet component = order[i];\n\t\t\t\tthis._DirtDepth = i;\n\t\t\t\tlet d = component._DirtMask;\n\t\t\t\tif(d === 0)\n\t\t\t\t{\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tcomponent._DirtMask = 0;\n\t\t\t\tcomponent.update(d);\n\n\t\t\t\tif(this._DirtDepth < i)\n\t\t\t\t{\n\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t\tstep++;\n\t\t}\n\n\t\treturn true;\n }\n \n resolveHierarchy()\n\t{\n\t\tlet components = this._Components;\n\t\tfor(let component of components)\n\t\t{\n\t\t\tif(component != null)\n\t\t\t{\n\t\t\t\tcomponent._Actor = this;\n\t\t\t\tcomponent.resolveComponentIndices(components);\n\t\t\t\tif(component.isNode)\n\t\t\t\t{\n\t\t\t\t\tthis._Nodes.push(component);\n\t\t\t\t}\n\t\t\t\tswitch(component.constructor)\n\t\t\t\t{\n\t\t\t\t\tcase NestedActorNode:\n\t\t\t\t\tcase ActorImage:\n\t\t\t\t\t\tthis._Drawables.push(component);\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tfor(let component of components)\n\t\t{\n\t\t\tif(component != null)\n\t\t\t{\n\t\t\t\tcomponent.completeResolve();\n\t\t\t}\n\t\t}\n\n\t\tthis.sortDependencies();\n\n\t\tthis._Drawables.sort(function(a,b)\n\t\t{\n\t\t\treturn a._DrawOrder - b._DrawOrder;\n\t\t});\n\t}\n\n\tdispose(graphics)\n\t{\n\t\tlet drawables = this._Drawables;\n\t\tfor(let drawable of drawables)\n\t\t{\n\t\t\tdrawable.dispose(this, graphics);\n\t\t}\n }\n \n\n\tadvance(seconds)\n\t{\n\t\tthis.update();\n\n\t\tlet components = this._Components;\n\t\t// Advance last (update graphics buffers and such).\n\t\tfor(let component of components)\n\t\t{\n\t\t\tif(component)\n\t\t\t{\n\t\t\t\tcomponent.advance(seconds);\n\t\t\t}\n\t\t}\n\n\t\tif(this._IsImageSortDirty)\n\t\t{\n\t\t\tthis._Drawables.sort(function(a,b)\n\t\t\t{\n\t\t\t\treturn a._DrawOrder - b._DrawOrder;\n\t\t\t});\n\t\t\tthis._IsImageSortDirty = false;\n\t\t}\n\t}\n\n\tdraw(graphics)\n\t{\n\t\tlet drawables = this._Drawables;\n\t\tfor(let drawable of drawables)\n\t\t{\n\t\t\tdrawable.draw(graphics);\n\t\t}\n\t\t// let nodes = this._Nodes;\n\t\t// for(let node of nodes)\n\t\t// {\n\t\t// \tif(node._Name === \"ctrl_look\")\n\t\t// \t{\n\t\t// \t\tconst ctx = graphics.ctx;\n\t\t// \t\tctx.save();\n\t\t// \t\tctx.beginPath();\n\t\t// \t\tctx.arc(node.worldTransform[4], node.worldTransform[5], 20.0, 0, 2*Math.PI);\n\t\t// \t\tctx.stroke();\n\t\t// \t\tctx.restore();\n\t\t// \t}\n\t\t// }\n\t}\n\n\tgetNode(name)\n\t{\n\t\tlet nodes = this._Nodes;\n\t\tfor(let node of nodes)\n\t\t{\n\t\t\tif(node._Name === name)\n\t\t\t{\n\t\t\t\treturn node;\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n\n\tget animations()\n\t{\n\t\treturn this._Animations;\n\t}\n\n\tgetAnimation(name)\n\t{\n\t\tlet animations = this._Animations;\n\t\tfor(let animation of animations)\n\t\t{\n\t\t\tif(animation._Name === name)\n\t\t\t{\n\t\t\t\treturn animation;\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n\n\tgetAnimationInstance(name)\n\t{\n\t\tlet animation = this.getAnimation(name);\n\t\tif(!animation)\n\t\t{\n\t\t\treturn null;\n\t\t}\n\t\treturn new AnimationInstance(this, animation);\n\t}\n\n\tmakeInstance()\n\t{\n\t\tconst actorInstance = new ActorArtboard(this._Actor);\n\t\tactorInstance.copy(this);\n\t\treturn actorInstance;\n\t}\n\n\tartboardAABB()\n\t{\n\t\tconst {_Width:width, _Height:height} = this;\n\t\tconst min_x = -this._Origin[0] * width;\n\t\tconst min_y = -this._Origin[1] * height;\n\t\treturn new Float32Array([min_x, min_y, min_x + width, min_y + height]);\n\t}\n\n\tcomputeAABB()\n\t{\n\t\tlet min_x = Number.MAX_VALUE;\n\t\tlet min_y = Number.MAX_VALUE;\n\t\tlet max_x = -Number.MAX_VALUE;\n\t\tlet max_y = -Number.MAX_VALUE;\n\n\t\tfor(const drawable of this._Drawables)\n\t\t{\n\t\t\tif(drawable.opacity < 0.01)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tconst aabb = drawable.computeAABB();\n\t\t\tif(!aabb)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tif(aabb[0] < min_x)\n\t\t\t{\n\t\t\t\tmin_x = aabb[0];\n\t\t\t}\n\t\t\tif(aabb[1] < min_y)\n\t\t\t{\n\t\t\t\tmin_y = aabb[1];\n\t\t\t}\n\t\t\tif(aabb[2] > max_x)\n\t\t\t{\n\t\t\t\tmax_x = aabb[2];\n\t\t\t}\n\t\t\tif(aabb[3] > max_y)\n\t\t\t{\n\t\t\t\tmax_y = aabb[3];\n\t\t\t}\n\t\t}\n\n\t\treturn new Float32Array([min_x, min_y, max_x, max_y]);\n\t}\n\n\tcopy(artboard)\n\t{\n this._Name = artboard._Name;\n this._Origin = vec2.clone(artboard._Origin);\n this._Translation = vec2.clone(artboard._Translation);\n this._Color = vec4.clone(artboard._Color);\n this._ClipsContents = artboard._ClipContents;\n\t\tthis._Width = artboard._Width;\n\t\tthis._Height = artboard._Height;\n\n\t\tlet components = artboard._Components;\n\t\tthis._Animations = artboard._Animations;\n\t\tthis._Components.length = 0;\n\t\tthis._Nodes.length = 0;\n\t\tthis._Drawables.length = 0;\n\n\t\tfor(let component of components)\n\t\t{\n\t\t\tif(!component)\n\t\t\t{\n\t\t\t\tthis._Components.push(null);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tlet instanceNode = component.makeInstance(this);\n\t\t\tswitch(instanceNode.constructor)\n\t\t\t{\n\t\t\t\tcase ActorShape:\n\t\t\t\tcase NestedActorNode:\n\t\t\t\tcase ActorImage:\n\t\t\t\t\tthis._Drawables.push(instanceNode);\n\t\t\t\t\tbreak;\n\t\t\t}\n\t\t\tif(instanceNode.isNode)\n\t\t\t{\n\t\t\t\tthis._Nodes.push(instanceNode);\n\t\t\t}\n\t\t\tthis._Components.push(instanceNode);\n\t\t}\n\t\tthis._RootNode = this._Components[0];\n\n\t\tfor(let i = 1; i < this._Components.length; i++)\n\t\t{\n\t\t\tlet component = this._Components[i];\n\t\t\tif(component == null)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tcomponent.resolveComponentIndices(this._Components);\n\t\t}\n\n\t\tfor(let i = 1; i < this._Components.length; i++)\n\t\t{\n\t\t\tlet component = this._Components[i];\n\t\t\tif(component == null)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tcomponent.completeResolve();\n\t\t}\n\n\t\tthis.sortDependencies();\n\n\t\tthis._Drawables.sort(function(a,b)\n\t\t{\n\t\t\treturn a._DrawOrder - b._DrawOrder;\n\t\t});\n\t}\n\n\tinitialize(graphics)\n\t{\n\t\tlet drawables = this._Drawables;\n\t\tfor(let drawable of drawables)\n\t\t{\n\t\t\tdrawable.initialize(this, graphics);\n\t\t}\n\t}\n}","import ActorTargetedConstraint from \"./ActorTargetedConstraint.js\";\nimport TransformSpace from \"./TransformSpace.js\";\n\nexport default class ActorAxisConstraint extends ActorTargetedConstraint\n{\n\tconstructor(actor)\n\t{\n\t\tsuper(actor);\n\n\t\tthis._CopyX = false;\n\t\tthis._CopyY = false;\n\t\tthis._ScaleX = 1;\n\t\tthis._ScaleY = 1;\n\t\tthis._EnableMinX = false;\n\t\tthis._MinX = 0;\n\t\tthis._EnableMaxX = false;\n\t\tthis._MaxX = 0;\n\t\tthis._EnableMinY = false;\n\t\tthis._MinY = 0;\n\t\tthis._EnableMaxY = false;\n\t\tthis._MaxY = 0;\n\t\tthis._Offset = false;\n\t\tthis._SourceSpace = TransformSpace.World;\n\t\tthis._DestSpace = TransformSpace.World;\n\t\tthis._MinMaxSpace = TransformSpace.World;\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._CopyX = node._CopyX;\n\t\tthis._CopyY = node._CopyY;\n\t\tthis._ScaleX = node._ScaleX;\n\t\tthis._ScaleY = node._ScaleY;\n\t\tthis._EnableMinX = node._EnableMinX;\n\t\tthis._MinX = node._MinX;\n\t\tthis._EnableMaxX = node._EnableMaxX;\n\t\tthis._MaxX = node._MaxX;\n\t\tthis._EnableMinY = node._EnableMinY;\n\t\tthis._MinY = node._MinY;\n\t\tthis._EnableMaxY = node._EnableMaxY;\n\t\tthis._MaxY = node._MaxY;\n\t\tthis._Offset = node._Offset;\n\t\tthis._SourceSpace = node._SourceSpace;\n\t\tthis._DestSpace = node._DestSpace;\n\t\tthis._MinMaxSpace = node._MinMaxSpace;\n\t}\n\n\tonDirty(dirt)\n\t{\n\t\tthis.markDirty();\n\t}\n}","import ActorBoneBase from \"./ActorBoneBase.js\";\n\nexport default class ActorBone extends ActorBoneBase\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\n\t\tthis._FirstBone = null;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorBone();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcompleteResolve()\n\t{\n\t\tsuper.completeResolve();\n\t\t\n\t\tlet children = this._Children;\n\t\tfor(let child of children)\n\t\t{\n\t\t\tif(child instanceof ActorBone)\n\t\t\t{\n\t\t\t\tthis._FirstBone = child;\n\t\t\t\treturn;\n\t\t\t}\n\t\t}\n\t}\t\n}","import ActorNode from \"./ActorNode.js\";\nimport {vec2, mat2d} from \"gl-matrix\";\n\nexport default class ActorBoneBase extends ActorNode\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\n\t\tthis._Length = 0;\n\t}\n\n\tget tipWorldTranslation()\n\t{\n\t\tconst transform = mat2d.create();\n\t\ttransform[4] = this._Length;\n\t\tmat2d.mul(transform, this._WorldTransform, transform);\n\t\treturn vec2.set(vec2.create(), transform[4], transform[5]);\n\t}\n\n\tget length()\n\t{\n\t\treturn this._Length;\n\t}\n\n\tset length(l)\n\t{\n\t\tif(this._Length === l)\n\t\t{\n\t\t\treturn;\n\t\t}\n\t\tthis._Length = l;\n\t\tthis.markTransformDirty();\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._Length = node._Length;\n\t}\n\n\tget firstBone()\n\t{\n\t\tlet children = this._Children;\n\t\tfor(let child of children)\n\t\t{\n\t\t\tif(child instanceof ActorBoneBase)\n\t\t\t{\n\t\t\t\treturn child;\n\t\t\t}\n\t\t}\n\n\t\treturn null;\n\t}\n}","import ActorNode from \"./ActorNode.js\";\n\nexport default class ActorCollider extends ActorNode\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._IsCollisionEnabled = true;\n\t}\n\n\tget isCollisionEnabled()\n\t{\n\t\treturn this._IsCollisionEnabled;\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._IsCollisionEnabled = node._IsCollisionEnabled;\n\t}\n}","import ActorCollider from \"./ActorCollider.js\";\n\nexport default class ActorColliderCircle extends ActorCollider\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._Radius = 0.0;\n\t}\n\n\tget radius()\n\t{\n\t\treturn this._Radius;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorColliderCircle();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._Radius = node._Radius;\n\t}\n}","import ActorCollider from \"./ActorCollider.js\";\n\nexport default class ActorColliderLine extends ActorCollider\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._Vertices = new Float32Array();\n\t}\n\n\tget vertices()\n\t{\n\t\treturn this._Vertices;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorColliderLine();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._Vertices = node._Vertices;\n\t}\n}","import ActorCollider from \"./ActorCollider.js\";\n\nexport default class ActorColliderPolygon extends ActorCollider\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._ContourVertices = new Float32Array();\n\t}\n\n\tget contourVertices()\n\t{\n\t\treturn this._ContourVertices;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorColliderPolygon();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._ContourVertices = node._ContourVertices;\n\t}\n}","import ActorCollider from \"./ActorCollider.js\";\n\nexport default class ActorColliderRectangle extends ActorCollider\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._Width = 0.0;\n\t\tthis._Height = 0.0;\n\t}\n\n\tget width()\n\t{\n\t\treturn this._Width;\n\t}\n\n\tget height()\n\t{\n\t\treturn this._Height;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorColliderRectangle();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._Width = node._Width;\n\t\tthis._Height = node._Height;\n\t}\n}","import ActorCollider from \"./ActorCollider.js\";\n\nexport default class ActorColliderTriangle extends ActorCollider\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._Width = 0.0;\n\t\tthis._Height = 0.0;\n\t}\n\n\tget width()\n\t{\n\t\treturn this._Width;\n\t}\n\n\tget height()\n\t{\n\t\treturn this._Height;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorColliderTriangle();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._Width = node._Width;\n\t\tthis._Height = node._Height;\n\t}\n}","export default class ActorComponent\n{\n\tconstructor()\n\t{\n\t\tthis._Name = \"Component\";\n\t\tthis._Parent = null;\n\t\tthis._CustomProperties = [];\n\t\tthis._DirtMask = 0;\n\t\tthis._GraphOrder = -1;\n\t\tthis._Dependents = null;\n\t\tthis._Actor = null;\n\t\tthis._ParentIdx = -1;\n\t}\n\n\tget parent()\n\t{\n\t\treturn this._Parent;\n\t}\n\n\tonDirty(dirt)\n\t{\n\n\t}\n\n\tinitialize(actor, graphics)\n\t{\n\n\t}\n\n\tupdate(dirt)\n\t{\n\t\t\n\t}\n\n\tadvance(seconds)\n\t{\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tif(this._ParentIdx !== -1)\n\t\t{\n\t\t\tlet parent = components[this._ParentIdx];\n\t\t\tthis._Parent = parent;\n\t\t\tif(this.isNode && parent && parent._Children)\n\t\t\t{\n\t\t\t\tparent._Children.push(this);\n\t\t\t}\n\t\t\tif(parent)\n\t\t\t{\n\t\t\t\tthis._Actor.addDependency(this, parent);\n\t\t\t}\n\t\t}\n\t}\n\n\tcompleteResolve()\n\t{\n\t}\n\n\tcopy(component, resetActor)\n\t{\n\t\tthis._Name = component._Name;\n\t\tthis._ParentIdx = component._ParentIdx;\n\t\tthis._Idx = component._Idx;\n\t\tthis._Actor = resetActor;\n\t}\n\n\tgetCustomProperty(name)\n\t{\n\t\tlet props = this._CustomProperties;\n\t\tfor(let prop of props)\n\t\t{\n\t\t\tif(prop._Name === name)\n\t\t\t{\n\t\t\t\treturn prop;\n\t\t\t}\n\t\t}\n\t\treturn null;\n\t}\n}","import ActorComponent from \"./ActorComponent.js\";\n\nexport default class ActorConstraint extends ActorComponent\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\n\t\tthis._IsEnabled = true;\n\t\tthis._Strength = 1.0;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorConstraint();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._IsEnabled = node._IsEnabled;\n\t\tthis._Strength = node._Strength;\n\t}\n\n\tonDirty(dirt)\n\t{\n\t\tthis.markDirty();\n\t}\n\n\tmarkDirty()\n\t{\n\t\tthis.parent.markTransformDirty();\n\t}\n\n\tset strength(c)\n\t{\n\t\tif(this._Strength != c)\n\t\t{\n\t\t\tthis._Strength = c;\n\t\t\tthis.markDirty();\n\t\t}\n\t}\n\n\tget isEnabled()\n\t{\n\t\treturn this._IsEnabled;\n\t}\n\n\tset isEnabled(isIt)\n\t{\n\t\tif(this._IsEnabled === isIt)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tthis._IsEnabled = isIt;\n\t\tthis.markDirty();\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\t\tif(this._Parent)\n\t\t{\n\t\t\t// This works because nodes are exported in hierarchy order, so we are assured constraints get added in order as we resolve indices.\n\t\t\tthis._Parent.addConstraint(this);\n\t\t}\n\t}\n}","import ActorTargetedConstraint from \"./ActorTargetedConstraint.js\";\nimport { vec2 } from \"gl-matrix\";\n\nconst DistanceMode =\n{\n\tCloser:0,\n\tFurther:1,\n\tExact:2\n};\n\nexport default class ActorDistanceConstraint extends ActorTargetedConstraint\n{\n\tconstructor(actor)\n\t{\n\t\tsuper(actor);\n\n\t\tthis._Distance = 100.0;\n\t\tthis._Mode = DistanceMode.Closer;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorDistanceConstraint();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tget distance()\n\t{\n\t\treturn this._Distance;\n\t}\n\n\tset distance(distance)\n\t{\n\t\tif(this._Distance === distance)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tthis._Distance = distance;\n\t\tthis.markDirty();\n\t}\n\n\tget mode()\n\t{\n\t\treturn this._Mode;\n\t}\n\n\tset mode(mode)\n\t{\n\t\tif(this._Mode === mode)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tthis._Mode = mode;\n\t\tthis.markDirty();\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._Distance = node._Distance;\n\t\tthis._Mode = node._Mode;\n\t}\n\n\tconstrain(tip)\n\t{\n\t\tlet target = this._Target;\n\t\tif(!target)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tlet parent = this._Parent;\n\n\n\t\tlet targetTranslation = target.worldTranslation;\n\t\tlet ourTranslation = parent.worldTranslation;\n\t\t\n\t\tlet { _Strength:t, _Mode:mode, _Distance:distance } = this;\n\n\t\tlet toTarget = vec2.subtract(vec2.create(), ourTranslation, targetTranslation);\n\t\tlet currentDistance = vec2.length(toTarget);\n\t\tswitch(mode)\n\t\t{\n\t\t\tcase DistanceMode.Closer:\n\t\t\t\tif(currentDistance < distance)\n\t\t\t\t{\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase DistanceMode.Further:\n\t\t\t\tif(currentDistance > distance)\n\t\t\t\t{\n\t\t\t\t\treturn;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t}\n\t\tif(currentDistance < 0.001)\n\t\t{\n\t\t\treturn true;\n\t\t}\n\n\t\tvec2.scale(toTarget, toTarget, 1.0/currentDistance);\n\t\tvec2.scale(toTarget, toTarget, distance);\n\n\t\tlet world = parent.worldTransform;\n\t\tlet position = vec2.lerp(vec2.create(), ourTranslation, vec2.add(vec2.create(), targetTranslation, toTarget), t);\n\t\tworld[4] = position[0];\n\t\tworld[5] = position[1];\n\t}\n}","import ActorProceduralPath from \"./ActorProceduralPath.js\";\n\nexport default class ActorEllipse extends ActorProceduralPath\n{\n constructor(actor)\n {\n super(actor);\n }\n\n resolveComponentIndices(components)\n\t{\n ActorProceduralPath.prototype.resolveComponentIndices.call(this, components);\n }\n \n makeInstance(resetActor)\n\t{\n\t\tconst node = new ActorEllipse();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\n }\n \n getPath()\n\t{\n const path = new Path2D();\n const radiusX = this._Width/2;\n const radiusY = this._Height/2;\n path.moveTo(radiusX, 0.0);\n path.ellipse(0.0, 0.0, radiusX, radiusY, 0.0, 0, Math.PI*2.0, false);\n\t\treturn path;\n\t}\n}","import ActorComponent from \"./ActorComponent.js\";\n\nexport default class ActorEvent extends ActorComponent\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorEvent();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t}\n}","import ActorTargetedConstraint from \"./ActorTargetedConstraint.js\";\nimport {vec2,mat2d} from \"gl-matrix\";\nimport ActorNode from \"./ActorNode.js\";\nimport ActorBone from \"./ActorNode.js\";\nimport { Decompose } from \"./Decompose.js\";\n\nconst PI2 = Math.PI*2;\n\nexport default class ActorIKConstraint extends ActorTargetedConstraint\n{\n\tconstructor(actor)\n\t{\n\t\tsuper(actor);\n\n\t\tthis._InvertDirection = false;\n\t\tthis._InfluencedBones = [];\n\n\t\tthis._FKChain = null;\n\t\tthis._BoneData = null;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorIKConstraint();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._InvertDirection = node._InvertDirection;\n\t\tthis._InfluencedBones = [];\n\t\tif(node._InfluencedBones)\n\t\t{\n\t\t\tfor (let i = 0; i < node._InfluencedBones.length; i++)\n\t\t\t{\n\t\t\t\tconst ib = node._InfluencedBones[i];\n\t\t\t\tif(!ib)\n\t\t\t\t{\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif(ib.constructor === ActorBone)\n\t\t\t\t{\n\t\t\t\t\tthis._InfluencedBones.push(ib._Idx);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tthis._InfluencedBones.push(ib);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\n\t\tconst bones = this._InfluencedBones;\n\t\tif(!bones || !bones.length)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tfor(let j = 0; j < bones.length; j++)\n\t\t{\n\t\t\tlet componentIndex = bones[j];\n\t\t\tif(componentIndex.constructor !== Number)\n\t\t\t{\n\t\t\t\tcomponentIndex = componentIndex._Idx;\n\t\t\t}\n\t\t\tconst bone = components[componentIndex];\n\t\t\tbones[j] = bone;\n\n\t\t\t// Mark peer constraints, N.B. that we're not adding it to the parent bone\n\t\t\t// as we're constraining it anyway.\n\t\t\tif(bone !== this.parent)\n\t\t\t{\n\t\t\t\tbone.addPeerConstraint(this);\n\t\t\t}\n\t\t}\n\t}\n\n\tmarkDirty()\n\t{\n\t\tfor(const item of this._FKChain)\n\t\t{\n\t\t\titem.bone.markTransformDirty();\n\t\t}\n\t}\n\n\tcompleteResolve()\n\t{\n\t\tsuper.completeResolve();\n\t\t\n\t\tconst bones = this._InfluencedBones;\n\t\tif(!bones || !bones.length)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\t// Initialize solver.\n\t\tconst start = bones[0];\n\t\tlet end = bones[bones.length-1];\n\t\tconst chain = this._FKChain = [];\n\t\tconst boneData = this._BoneData = [];\n\t\twhile(end && end !== start._Parent)\n\t\t{\n\t\t\tchain.unshift({bone:end, ikAngle:0, transformComponents:new Float32Array(6), in:false});\n\t\t\tend = end._Parent;\n\t\t}\n\n\t\tconst allIn = chain.length < 3;\n\t\tfor(let i = 0; i < chain.length; i++)\n\t\t{\n\t\t\tlet fk = chain[i];\n\t\t\tfk.idx = i;\n\t\t\tfk.in = allIn;\n\t\t}\n\n\t\tfor(const bone of bones)\n\t\t{\n\t\t\tconst fk = chain.find(fk => fk.bone === bone);\n\t\t\tif(!fk)\n\t\t\t{\n\t\t\t\tconsole.warn(\"Bone not in chain?\", fk, bone);\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tboneData.push(fk);\n\t\t}\n\n\t\tif(!allIn)\n\t\t{\n\t\t\tfor(let i = 0; i < boneData.length-1; i++)\n\t\t\t{\n\t\t\t\tconst fk = boneData[i];\n\t\t\t\tfk.in = true;\n\t\t\t\tchain[fk.idx+1].in = true;\n\t\t\t}\n\t\t}\n\n\t\t// Mark dependencies.\n\t\tconst actor = this._Actor;\n\t\tfor(const bone of bones)\n\t\t{\n\t\t\t// Don't mark dependency on parent as ActorComponent already does this.\n\t\t\tif(bone === this.parent)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tactor.addDependency(this, bone);\n\t\t}\n\t\tif(this._Target)\n\t\t{\n\t\t\tactor.addDependency(this, this._Target);\n\t\t}\n\n\t\t// N.B. Dependency on target already set in ActorTargetedConstrain.\n\n\t\t// All the first level children of the influenced bones should depend on the final bone.\n\t\tif(chain.length)\n\t\t{\n\t\t\tconst tip = chain[chain.length-1];\n\t\t\tfor(const fk of chain)\n\t\t\t{\n\t\t\t\tif(fk === tip)\n\t\t\t\t{\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst bone = fk.bone;\n\t\t\t\tconst children = bone._Children;\n\t\t\t\tfor(const child of children)\n\t\t\t\t{\n\t\t\t\t\tif(!(child instanceof ActorNode))\n\t\t\t\t\t{\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tconst item = chain.find(item => item.bone === child);\n\t\t\t\t\tif(item)\n\t\t\t\t\t{\n\t\t\t\t\t\t// we are in the FK chain.\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tactor.addDependency(child, tip.bone);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tconstrain(tip)\n\t{\n\t\tconst target = this._Target;\n\t\tif(target)\n\t\t{\n\t\t\tconst wt = target.worldTransform;\n\t\t\tthis.solve(vec2.set(vec2.create(), wt[4], wt[5]), this._Strength);\n\t\t}\n\t}\n\n\tsolve1(fk1, worldTargetTranslation)\n\t{\n\t\tconst iworld = fk1.parentWorldInverse;\n\t\tconst pA = fk1.bone.worldTranslation;\n\t\tconst pBT = vec2.copy(vec2.create(), worldTargetTranslation);\n\n\t\t// To target in worldspace\n\t\tconst toTarget = vec2.subtract(vec2.create(), pBT, pA);\n\t\t// Note this is directional, hence not transformMat2d\n\t\tconst toTargetLocal = vec2.transformMat2(vec2.create(), toTarget, iworld);\n\t\tconst r = Math.atan2(toTargetLocal[1], toTargetLocal[0]);\n\t\t\n\t\tconstrainRotation(fk1, r);\n\t\tfk1.ikAngle = r;\n\n\t\treturn true;\n\t}\n\n\tsolve2(fk1, fk2, worldTargetTranslation)\n\t{\n\t\tconst invertDirection = this._InvertDirection;\n\t\tconst b1 = fk1.bone;\n\t\tconst b2 = fk2.bone;\n\t\tconst chain = this._FKChain;\n\t\tconst firstChild = chain[fk1.idx+1];\n\n\t\tconst iworld = fk1.parentWorldInverse;\n\n\t\tlet pA = b1.worldTranslation;\n\t\tlet pC = firstChild.bone.worldTranslation;\n\t\tlet pB = b2.tipWorldTranslation;\n\t\tlet pBT = vec2.copy(vec2.create(), worldTargetTranslation);\n\n\t\tpA = vec2.transformMat2d(pA, pA, iworld);\n\t\tpC = vec2.transformMat2d(pC, pC, iworld);\n\t\tpB = vec2.transformMat2d(pB, pB, iworld);\n\t\tpBT = vec2.transformMat2d(pBT, pBT, iworld);\n\n\t\t// http://mathworld.wolfram.com/LawofCosines.html\n\t\tconst av = vec2.subtract(vec2.create(), pB, pC);\n\t\tconst a = vec2.length(av);\n\n\t\tconst bv = vec2.subtract(vec2.create(), pC, pA);\n\t\tconst b = vec2.length(bv);\n\n\t\tconst cv = vec2.subtract(vec2.create(), pBT, pA);\n\t\tconst c = vec2.length(cv);\n\n\t\tconst A = Math.acos(Math.max(-1,Math.min(1,(-a*a+b*b+c*c)/(2*b*c))));\n\t\tconst C = Math.acos(Math.max(-1, Math.min(1,(a*a+b*b-c*c)/(2*a*b))));\n\n\t\tlet r1, r2;\n\t\tif(b2.parent != b1)\n\t\t{\n\t\t\tconst secondChild = chain[fk1.idx+2];\n\t\t\t\n\t\t\tconst iworld = secondChild.parentWorldInverse;\n\n\t\t\tpC = firstChild.bone.worldTranslation;\n\t\t\tpB = b2.tipWorldTranslation;\n\n\t\t\tconst av = vec2.subtract(vec2.create(), pB, pC);\n\t\t\tconst avLocal = vec2.transformMat2(vec2.create(), av, iworld);\n\t\t\tconst angleCorrection = -Math.atan2(avLocal[1], avLocal[0]);\n\n\t\t\tif(invertDirection)\n\t\t\t{\n\t\t\t\tr1 = Math.atan2(cv[1],cv[0]) - A;\n\t\t\t\tr2 = -C+Math.PI + angleCorrection;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tr1 = A + Math.atan2(cv[1],cv[0]);\n\t\t\t\tr2 = C-Math.PI + angleCorrection;\n\t\t\t}\n\t\t}\n\t\telse if(invertDirection)\n\t\t{\n\t\t\tr1 = Math.atan2(cv[1],cv[0]) - A;\n\t\t\tr2 = -C+Math.PI;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tr1 = A + Math.atan2(cv[1],cv[0]);\n\t\t\tr2 = C-Math.PI;\n\t\t}\n\n\t\tconstrainRotation(fk1, r1);\n\t\tconstrainRotation(firstChild, r2);\n\t\tif(firstChild !== fk2)\n\t\t{\n\t\t\tconst bone = fk2.bone;\n\t\t\tmat2d.mul(bone.worldTransform, bone.parent.worldTransform, bone.transform);\n\t\t}\n\n\t\t// Simple storage, need this for interpolation.\n\t\tfk1.ikAngle = r1;\n\t\tfirstChild.ikAngle = r2;\n\n\t\treturn true;\n\t}\n\n\tsolve(worldTargetTranslation, strength)\n\t{\n\t\tconst bones = this._BoneData;\n\t\tif(!bones.length)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\t// Decompose the chain.\n\t\tconst fkChain = this._FKChain;\n\t\tfor(let i = 0; i < fkChain.length; i++)\n\t\t{\n\t\t\tconst fk = fkChain[i];\n\t\t\tconst parentWorld = fk.bone.parent.worldTransform;\n\t\t\tconst parentWorldInverse = mat2d.invert(mat2d.create(), parentWorld);\n\t\t\tconst local = mat2d.mul(fk.bone.transform, parentWorldInverse, fk.bone.worldTransform);\n\t\t\tDecompose(local, fk.transformComponents);\n\t\t\tfk.parentWorldInverse = parentWorldInverse;\n\t\t}\n\n\t\tif(bones.length === 1)\n\t\t{\n\t\t\tthis.solve1(bones[0], worldTargetTranslation);\n\t\t}\n\t\telse if(bones.length == 2)\n\t\t{\n\t\t\tthis.solve2(bones[0], bones[1], worldTargetTranslation);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tconst tip = bones[bones.length-1];\n\t\t\tfor(let i = 0; i < bones.length-1; i++)\n\t\t\t{\n\t\t\t\tconst fk = bones[i];\n\t\t\t\tthis.solve2(fk, tip, worldTargetTranslation);\n\t\t\t\tfor(let j = fk.idx+1; j < fkChain.length-1; j++)\n\t\t\t\t{\n\t\t\t\t\tconst fk = fkChain[j];\n\t\t\t\t\tconst parentWorld = fk.bone.parent.worldTransform;\n\t\t\t\t\tfk.parentWorldInverse = mat2d.invert(mat2d.create(), parentWorld);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// At the end, mix the FK angle with the IK angle by strength\n\t\tconst m = strength;\n\t\tif(m != 1.0)\n\t\t{\n\t\t\tfor(const fk of fkChain)\n\t\t\t{\n\t\t\t\tif(!fk.in)\n\t\t\t\t{\n\t\t\t\t\tconst bone = fk.bone;\n\t\t\t\t\tmat2d.mul(bone.worldTransform, bone.parent.worldTransform, bone.transform);\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst fromAngle = fk.transformComponents[4]%PI2;\n\t\t\t\tconst toAngle = fk.ikAngle%PI2;\n\t\t\t\tlet diff = toAngle - fromAngle;\n\t\t\t\tif(diff > Math.PI)\n\t\t\t\t{\n\t\t\t\t\tdiff -= PI2;\n\t\t\t\t}\n\t\t\t\telse if(diff < -Math.PI)\n\t\t\t\t{\n\t\t\t\t\tdiff += PI2;\n\t\t\t\t}\n\t\t\t\tconst angle = fromAngle + diff * m;\n\t\t\t\tconstrainRotation(fk, angle);\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction constrainRotation(fk, rotation)\n{\n\tconst parentWorld = fk.bone.parent.worldTransform;\n\n\tconst transform = fk.bone.transform;\n\tconst c = fk.transformComponents;\n\n\tif(rotation === 0)\n\t{\n\t\tmat2d.identity(transform);\n\t}\n\telse\n\t{\n\t\tmat2d.fromRotation(transform, rotation);\n\t}\n\t// Translate\n\ttransform[4] = c[0];\n\ttransform[5] = c[1];\n\t// Scale\n\tconst scaleX = c[2];\n\tconst scaleY = c[3];\n\ttransform[0] *= scaleX;\n\ttransform[1] *= scaleX;\n\ttransform[2] *= scaleY;\n\ttransform[3] *= scaleY;\n\t// Skew\n\tconst skew = c[5];\n\tif(skew !== 0)\n\t{\n\t\ttransform[2] = transform[0] * skew + transform[2];\n\t\ttransform[3] = transform[1] * skew + transform[3];\n\t}\n\n\tmat2d.mul(fk.bone.worldTransform, parentWorld, transform);\n}\n","import ActorNode from \"./ActorNode.js\";\nimport ActorBone from \"./ActorBone.js\";\nimport ActorIKConstraint from \"./ActorIKConstraint.js\";\n\nexport default class ActorIKTarget extends ActorNode\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\n\t\tthis._Order = 0;\n\t\tthis._Strength = 0;\n\t\tthis._InvertDirection = false;\n\t\tthis._InfluencedBones = null;\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\n\t\tconst constraint = new ActorIKConstraint();\n\t\tthis._Constraint = constraint;\n\n\n\t\tconst bones = this._InfluencedBones;\n\t\tconstraint._Actor = this._Actor;\n\t\tconstraint._TargetIdx = this._Idx;\n\t\tconstraint._ParentIdx = bones ? bones[bones.length-1] : -1;\n\t\tconstraint._InvertDirection = this._InvertDirection;\n\t\tconstraint._InfluencedBones = bones;\n\t\tconstraint._Strength = this._Strength;\n\t\tconstraint._IsEnabled = true;\n\t\tconstraint.resolveComponentIndices(components);\n\t}\n\n\tcompleteResolve()\n\t{\n\t\tsuper.completeResolve();\n\t\t\n\t\tthis._Constraint.completeResolve();\n\t}\n\n\tget strength()\n\t{\n\t\tif(this._Constraint)\n\t\t{\n\t\t\treturn this._Constraint.strength;\n\t\t}\n\t\treturn 0;\n\t}\n\n\tset strength(s)\n\t{\n\t\tif(this._Constraint)\n\t\t{\n\t\t\tthis._Constraint.strength = s;\n\t\t}\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorIKTarget();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._Order = node._Order;\n\t\tthis._Strength = node._Strength;\n\t\tthis._InvertDirection = node._InvertDirection;\n\t\tthis._InfluencedBones = [];\n\t\tif(node._InfluencedBones)\n\t\t{\n\t\t\tfor (let i = 0; i < node._InfluencedBones.length; i++)\n\t\t\t{\n\t\t\t\tconst ib = node._InfluencedBones[i];\n\t\t\t\tif(!ib)\n\t\t\t\t{\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tif(ib.constructor === ActorBone)\n\t\t\t\t{\n\t\t\t\t\tthis._InfluencedBones.push(ib._Idx);\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tthis._InfluencedBones.push(ib);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}","import ActorNode from \"./ActorNode.js\";\nimport {mat2d} from \"gl-matrix\";\n\nconst White = [1.0, 1.0, 1.0, 1.0];\nexport default class ActorImage extends ActorNode\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._DrawOrder = 0;\n\t\tthis._BlendMode = ActorImage.BlendModes.Normal;\n\t\tthis._AtlasIndex = -1;\n\t\tthis._NumVertices = 0;\n\t\tthis._HasVertexDeformAnimation = false;\n\t\tthis._AnimationDeformedVertices = null;\n\t\tthis._Vertices = null;\n\t\tthis._Triangles = null;\n\t\tthis._ConnectedBones = null;\n\t\tthis._BoneMatrices = null;\n\t\tthis._IsInstance = false;\n\t\tthis._IsHidden = false;\n\n\t\tthis._VertexBuffer = null;\n\t\tthis._IndexBuffer = null;\n\t\tthis._DeformVertexBuffer = null;\n\n\t\tthis._SequenceFrames = null;\n\t\tthis._SequenceFrame = 0;\n\t\tthis._SequenceUVs = null;\n\t\tthis._SequenceUVBuffer = null;\n\t}\n\n\tget isHidden()\n\t{\n\t\treturn this._IsHidden;\n\t}\n\n\tset isHidden(hidden)\n\t{\n\t\tthis._IsHidden = hidden;\n\t}\n\n\tget hasVertexDeformAnimation()\n\t{\n\t\treturn this._HasVertexDeformAnimation;\n\t}\n\t\t\n\tset hasVertexDeformAnimation(value)\n\t{\n\t\tthis._HasVertexDeformAnimation = value;\n\t\tthis._AnimationDeformedVertices = new Float32Array(this._NumVertices * 2);\n\n\t\t// Copy the deform verts from the rig verts.\n\t\tlet writeIdx = 0;\n\t\tlet readIdx = 0;\n\t\tconst readStride = this._VertexStride;\n\t\tfor(let i = 0; i < this._NumVertices; i++)\n\t\t{\n\t\t\tthis._AnimationDeformedVertices[writeIdx++] = this._Vertices[readIdx];\n\t\t\tthis._AnimationDeformedVertices[writeIdx++] = this._Vertices[readIdx+1];\n\t\t\treadIdx += readStride;\n\t\t}\n\t}\n\n\tcomputeAABB()\n\t{\n\t\tconst worldVertices = this.computeWorldVertices();\n\t\tconst nv = worldVertices.length/2;\n\t\tlet min_x = Number.MAX_VALUE;\n\t\tlet min_y = Number.MAX_VALUE;\n\t\tlet max_x = -Number.MAX_VALUE;\n\t\tlet max_y = -Number.MAX_VALUE;\n\n\t\tlet readIdx = 0;\n\t\tfor(let i = 0; i < nv; i++)\n\t\t{\n\t\t\tlet x = worldVertices[readIdx++];\n\t\t\tlet y = worldVertices[readIdx++];\n\t\t\tif(x < min_x)\n\t\t\t{\n\t\t\t\tmin_x = x;\n\t\t\t}\n\t\t\tif(y < min_y)\n\t\t\t{\n\t\t\t\tmin_y = y;\n\t\t\t}\n\t\t\tif(x > max_x)\n\t\t\t{\n\t\t\t\tmax_x = x;\n\t\t\t}\n\t\t\tif(y > max_y)\n\t\t\t{\n\t\t\t\tmax_y = y;\n\t\t\t}\n\t\t}\n\n\t\treturn new Float32Array([min_x, min_y, max_x, max_y]);\n\t}\n\n\tcomputeWorldVertices()\n\t{\n\t\tconst vertices = this._HasVertexDeformAnimation ? this._AnimationDeformedVertices : this._Vertices;\n\n\t\tconst stride = this._HasVertexDeformAnimation ? 2 : this._VertexStride;\n\t\tlet readIdx = 0;\n\t\tlet writeIdx = 0;\n\n\t\tconst world = this._WorldTransform;\n\n\t\tconst nv = this._NumVertices;\n\t\tconst deformed = new Float32Array(nv*2);\n\n\t\tif(this._ConnectedBones)\n\t\t{\n\t\t\tlet weightIndex = 4;\n\t\t\tconst weightStride = 12;\n\t\t\tconst weightVertices = this._Vertices;\n\n\t\t\tconst bones = this._BoneMatrices;\n\n\t\t\tfor(let i = 0; i < nv; i++)\n\t\t\t{\n\t\t\t\tlet x = vertices[readIdx];\n\t\t\t\tlet y = vertices[readIdx+1];\n\t\t\t\t\n\t\t\t\treadIdx += stride;\n\n\t\t\t\tconst px = world[0] * x + world[2] * y + world[4];\n\t\t\t\tconst py = world[1] * x + world[3] * y + world[5];\n\n\t\t\t\tconst fm = new Float32Array(6);\n\t\t\t\tfor(let wi = 0; wi < 4; wi++)\n\t\t\t\t{\n\t\t\t\t\tconst boneIndex = weightVertices[weightIndex+wi];\n\t\t\t\t\tconst weight = weightVertices[weightIndex+wi+4];\n\n\t\t\t\t\tconst bb = boneIndex*6;\n\n\t\t\t\t\tfor(let j = 0; j < 6; j++)\n\t\t\t\t\t{\n\t\t\t\t\t\tfm[j] += bones[bb+j] * weight;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tweightIndex += weightStride;\n\n\t\t\t\tx = fm[0] * px + fm[2] * py + fm[4];\n\t\t\t\ty = fm[1] * px + fm[3] * py + fm[5];\n\n\t\t\t\tdeformed[writeIdx++] = x;\n\t\t\t\tdeformed[writeIdx++] = y;\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tfor(let i = 0; i < nv; i++)\n\t\t\t{\n\t\t\t\tconst x = vertices[readIdx];\n\t\t\t\tconst y = vertices[readIdx+1];\n\n\t\t\t\tdeformed[writeIdx++] = world[0] * x + world[2] * y + world[4];\n\t\t\t\tdeformed[writeIdx++] = world[1] * x + world[3] * y + world[5];\n\t\t\t\treadIdx += stride;\n\t\t\t}\n\t\t}\n\n\t\treturn deformed;\n\t}\n\n\tdispose(actor, graphics)\n\t{\n\t\tif(this._IsInstance)\n\t\t{\n\t\t\tif(this._DeformVertexBuffer)\n\t\t\t{\n\t\t\t\tthis._DeformVertexBuffer.dispose();\n\t\t\t\tthis._DeformVertexBuffer = null;\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tif(this._VertexBuffer)\n\t\t\t{\n\t\t\t\tthis._VertexBuffer.dispose();\n\t\t\t\tthis._VertexBuffer = null;\n\t\t\t}\n\t\t\tif(this._IndexBuffer)\n\t\t\t{\n\t\t\t\tthis._IndexBuffer.dispose();\n\t\t\t\tthis._IndexBuffer = null;\n\t\t\t}\n\t\t\tif(this._SequenceUVBuffer)\n\t\t\t{\n\t\t\t\tthis._SequenceUVBuffer.dispose();\n\t\t\t\tthis._SequenceUVBuffer = null;\n\t\t\t}\n\t\t}\n\t}\n\n\tinitialize(actor, graphics)\n\t{\n\t\tif(!this._IsInstance)\n\t\t{\n\t\t\tif(this._VertexBuffer)\n\t\t\t{\n\t\t\t\tthis._VertexBuffer.dispose();\n\t\t\t}\n\t\t\tif(this._VertexBuffer)\n\t\t\t{\n\t\t\t\tthis._VertexBuffer.dispose();\n\t\t\t}\n\t\t\tif(this._SequenceUVBuffer)\n\t\t\t{\n\t\t\t\tthis._SequenceUVBuffer.dispose();\n\t\t\t}\n\n\t\t\tthis._VertexBuffer = graphics.makeVertexBuffer(this._Vertices);\n\t\t\tthis._IndexBuffer = graphics.makeIndexBuffer(this._Triangles);\n\n\t\t\tif(this._SequenceUVs)\n\t\t\t{\n\t\t\t\tthis._SequenceUVBuffer = graphics.makeVertexBuffer(this._SequenceUVs);\n\t\t\t}\n\t\t}\n\t\telse if(this._HasVertexDeformAnimation)\n\t\t{\n\t\t\tif(this._DeformVertexBuffer)\n\t\t\t{\n\t\t\t\tthis._DeformVertexBuffer.dispose();\n\t\t\t}\n\t\t\tthis._DeformVertexBuffer = graphics.makeVertexBuffer(this._AnimationDeformedVertices);\n\t\t}\n\n\t\tif(this._IsInstance && this._ConnectedBones)\n\t\t{\n\t\t\tconst bt = this._BoneMatrices = new Float32Array((this._ConnectedBones.length+1) * 6);\n\n\t\t\t// First bone transform is always identity.\n\t\t\tbt[0] = 1;\n\t\t\tbt[1] = 0;\n\t\t\tbt[2] = 0;\n\t\t\tbt[3] = 1;\n\t\t\tbt[4] = 0;\n\t\t\tbt[5] = 0;\n\t\t}\n\t\t// Keep vertices for world calculations.\n\t\t// delete this._Vertices;\n\t\tdelete this._Triangles;\n\t\tdelete this._SequenceUVs;\n\t\tthis._Texture = actor._Atlases[this._AtlasIndex];\n\t}\n\n\tadvance()\n\t{\n\t\tif(this._HasVertexDeformAnimation && this._VerticesDirty)\n\t\t{\n\t\t\tthis._DeformVertexBuffer.update(this._AnimationDeformedVertices);\n\t\t\tthis._VerticesDirty = false;\n\t\t}\n\n\t\tif(this._ConnectedBones)\n\t\t{\n\t\t\tconst bt = this._BoneMatrices;\n\t\t\tlet bidx = 6; // Start after first identity.\n\n\t\t\tconst mat = mat2d.create();\n\n\t\t\tfor(let i = 0; i < this._ConnectedBones.length; i++)\n\t\t\t{\n\t\t\t\tconst cb = this._ConnectedBones[i];\n\t\t\t\tif(!cb.node)\n\t\t\t\t{\n\t\t\t\t\tbt[bidx++] = 1;\n\t\t\t\t\tbt[bidx++] = 0;\n\t\t\t\t\tbt[bidx++] = 0;\n\t\t\t\t\tbt[bidx++] = 1;\n\t\t\t\t\tbt[bidx++] = 0;\n\t\t\t\t\tbt[bidx++] = 0;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\t\t\t\tconst wt = mat2d.mul(mat, cb.node._WorldTransform, cb.ibind);\n\n\t\t\t\tbt[bidx++] = wt[0];\n\t\t\t\tbt[bidx++] = wt[1];\n\t\t\t\tbt[bidx++] = wt[2];\n\t\t\t\tbt[bidx++] = wt[3];\n\t\t\t\tbt[bidx++] = wt[4];\n\t\t\t\tbt[bidx++] = wt[5];\n\t\t\t}\n\t\t}\n\t}\n\n\tdraw(graphics)\n\t{\n\t\tif(this._RenderCollapsed || this._IsHidden)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tconst t = this._WorldTransform;\n\t\tswitch(this._BlendMode)\n\t\t{\n\t\t\tcase ActorImage.BlendModes.Normal:\n\t\t\t\tgraphics.enableBlending();\n\t\t\t\tbreak;\n\t\t\tcase ActorImage.BlendModes.Multiply:\n\t\t\t\tgraphics.enableMultiplyBlending();\n\t\t\t\tbreak;\n\t\t\tcase ActorImage.BlendModes.Screen:\n\t\t\t\tgraphics.enableScreenBlending();\n\t\t\t\tbreak;\n\t\t\tcase ActorImage.BlendModes.Additive:\n\t\t\t\tgraphics.enableAdditiveBlending();\n\t\t\t\tbreak;\n\n\t\t}\n\n\t\tconst uvBuffer = this._SequenceUVBuffer || null;\n\t\tlet uvOffset;\n\t\tif(this._SequenceUVBuffer)\n\t\t{\n\t\t\tconst numFrames = this._SequenceFrames.length;\n\t\t\tlet frame = this._SequenceFrame%numFrames;\n\t\t\tif(uvOffset < 0)\n\t\t\t{\n\t\t\t\tframe += numFrames;\n\t\t\t}\n\t\t\tuvOffset = this._SequenceFrames[frame].offset;\n\t\t}\n\n\t\tgraphics.prep(this._Texture, White, this._RenderOpacity, t, this._VertexBuffer, this._ConnectedBones ? this._BoneMatrices : null, this._DeformVertexBuffer, uvBuffer, uvOffset);\n\t\tgraphics.draw(this._IndexBuffer);\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tActorNode.prototype.resolveComponentIndices.call(this, components);\n\n\t\tif(this._ConnectedBones)\n\t\t{\n\t\t\tfor(let j = 0; j < this._ConnectedBones.length; j++)\n\t\t\t{\n\t\t\t\tconst cb = this._ConnectedBones[j];\n\t\t\t\tcb.node = components[cb.componentIndex];\n\t\t\t\tif(cb.node)\n\t\t\t\t{\n\t\t\t\t\tcb.node._IsConnectedToImage = true;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorImage();\n\t\tnode._IsInstance = true;\n\t\tActorImage.prototype.copy.call(node, this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._DrawOrder = node._DrawOrder;\n\t\tthis._BlendMode = node._BlendMode;\n\t\tthis._AtlasIndex = node._AtlasIndex;\n\t\tthis._NumVertices = node._NumVertices;\n\t\tthis._VertexStride = node._VertexStride;\n\t\tthis._HasVertexDeformAnimation = node._HasVertexDeformAnimation;\n\t\tthis._Vertices = node._Vertices;\n\t\tthis._Triangles = node._Triangles;\n\t\t// N.B. actor.initialize must've been called before instancing.\n\t\tthis._VertexBuffer = node._VertexBuffer;\n\t\tthis._IndexBuffer = node._IndexBuffer;\n\t\tthis._SequenceUVBuffer = node._SequenceUVBuffer;\n\t\tthis._SequenceFrames = node._SequenceFrames;\n\t\tif (node._HasVertexDeformAnimation)\n\t\t{\n\t\t\tconst deformedVertexLength = this._NumVertices * 2;\n\t\t\tthis._AnimationDeformedVertices = new Float32Array(deformedVertexLength);\n\t\t\tfor(let i = 0; i < deformedVertexLength; i++)\n\t\t\t{\n\t\t\t\tthis._AnimationDeformedVertices[i] = node._AnimationDeformedVertices[i];\n\t\t\t}\n\t\t}\n\n\t\tif(node._ConnectedBones)\n\t\t{\n\t\t\tthis._ConnectedBones = [];\n\t\t\tfor(const cb of node._ConnectedBones)\n\t\t\t{\n\t\t\t\t// Copy all props except for the actual node reference which will update in our resolve.\n\t\t\t\tthis._ConnectedBones.push({\n\t\t\t\t\t\tcomponentIndex:cb.componentIndex,\n\t\t\t\t\t\tbind:cb.bind,\n\t\t\t\t\t\tibind:cb.ibind\n\t\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n}\n\n\nActorImage.BlendModes = \n{\n\t\"Normal\":0,\n\t\"Multiply\":1,\n\t\"Screen\":2,\n\t\"Additive\":3\n};\n","import ActorBoneBase from \"./ActorBoneBase.js\";\n\nexport default class ActorJellyBone extends ActorBoneBase\n{\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorJellyBone();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\t\n}","import Animation from \"./Animation.js\";\nimport BinaryReader from \"./Readers/BinaryReader.js\";\nimport JSONReader from \"./Readers/JSONReader.js\";\nimport Actor from \"./Actor.js\";\nimport ActorEvent from \"./ActorEvent.js\";\nimport ActorNode from \"./ActorNode.js\";\nimport ActorNodeSolo from \"./ActorNodeSolo.js\";\nimport ActorBone from \"./ActorBone.js\";\nimport ActorEllipse from \"./ActorEllipse.js\";\nimport ActorPolygon from \"./ActorPolygon.js\";\nimport ActorRectangle from \"./ActorRectangle.js\";\nimport ActorStar from \"./ActorStar.js\";\nimport ActorTriangle from \"./ActorTriangle.js\";\nimport ActorJellyBone from \"./ActorJellyBone.js\";\nimport JellyComponent from \"./JellyComponent.js\";\nimport ActorRootBone from \"./ActorRootBone.js\";\nimport ActorImage from \"./ActorImage.js\";\nimport ActorIKTarget from \"./ActorIKTarget.js\";\nimport ActorColliderRectangle from \"./ActorColliderRectangle.js\";\nimport ActorColliderTriangle from \"./ActorColliderTriangle.js\";\nimport ActorColliderCircle from \"./ActorColliderCircle.js\";\nimport ActorColliderPolygon from \"./ActorColliderPolygon.js\";\nimport ActorColliderLine from \"./ActorColliderLine.js\";\nimport NestedActorNode from \"./NestedActorNode.js\";\nimport CustomProperty from \"./CustomProperty.js\";\nimport AnimatedComponent from \"./AnimatedComponent.js\";\nimport AnimatedProperty from \"./AnimatedProperty.js\";\nimport NestedActorAsset from \"./NestedActorAsset.js\";\nimport ActorIKConstraint from \"./ActorIKConstraint.js\";\nimport ActorDistanceConstraint from \"./ActorDistanceConstraint.js\";\nimport ActorTransformConstraint from \"./ActorTransformConstraint.js\";\nimport ActorTranslationConstraint from \"./ActorTranslationConstraint.js\";\nimport ActorScaleConstraint from \"./ActorScaleConstraint.js\";\nimport ActorRotationConstraint from \"./ActorRotationConstraint.js\";\nimport ActorShape from \"./ActorShape.js\";\nimport ActorPath from \"./ActorPath.js\";\nimport ActorSkin from \"./ActorSkin.js\";\nimport ActorArtboard from \"./ActorArtboard.js\";\nimport {ColorFill, ColorStroke, GradientFill, GradientStroke, RadialGradientFill, RadialGradientStroke} from \"./ColorComponent.js\";\nimport {StraightPathPoint, CubicPathPoint, PointType} from \"./PathPoint.js\";\nimport {KeyFrame, PathsKeyFrame} from \"./KeyFrame.js\";\nimport {mat2d, vec2} from \"gl-matrix\";\nimport {Hold, Linear, Cubic} from \"./Interpolation.js\";\nimport Block from \"./Block.js\";\nconst _BlockTypes = Block.Types;\nconst _AnimatedPropertyTypes = AnimatedProperty.Types;\n\nconst _Readers = {\n\t\"bin\": {\n\t\tstream: BinaryReader,\n\t\tcontainer: Uint8Array,\n\t\textension: \".nma\"\n\t},\n\t\"json\": {\n\t\tstream: JSONReader,\n\t\tcontainer: Object,\n\t\textension: \"nmj\"\n\t}\n};\n\nlet _ReadAtlasesBlock = null;\n\nfunction _ReadNextBlock(reader, error, block)\n{\n\tif(reader.isEOF())\n\t{\n\t\treturn null;\n\t}\n\tlet blockType = 0, container = 0;\n\tconst cType = reader.containerType; // 'bin' || 'json'\n\tconst streamReader = _Readers[cType];\n\ttry\n\t{\n\t\t// blockType = reader.readUint8();\n\t\tblockType = reader.readBlockType(block);\n\t\tif(blockType === undefined)\n\t\t{\n\t\t\treturn null;\n\t\t}\n\t\tconst length = reader.readUint32Length();\n\n\t\tcontainer = new streamReader[\"container\"](length);\n\t\treader.readRaw(container, length);\n\t}\n\tcatch(err)\n\t{\n\t\tconsole.log(err.constructor);\n\t\tif(error)\n\t\t{\n\t\t\terror(err);\n\t\t}\n\t\treturn null;\n\t}\n\treturn {type:blockType, reader: new streamReader.stream(container)};\n}\n\nfunction _ReadComponentsBlock(artboard, reader)\n{\n\tlet componentCount = reader.readUint16Length();\n\tlet actorComponents = artboard._Components;\n\n\t// Guaranteed from the exporter to be in index order.\n\tlet block = null;\n\twhile((block = _ReadNextBlock(reader, function(err) {artboard.actor.error = err;}, Block)) !== null)\n\t{\n\t\tlet component = null;\n\t\tswitch(block.type)\n\t\t{\n\t\t\tcase _BlockTypes.CustomIntProperty:\n\t\t\tcase _BlockTypes.CustomStringProperty:\n\t\t\tcase _BlockTypes.CustomFloatProperty:\n\t\t\tcase _BlockTypes.CustomBooleanProperty:\n\t\t\t\tcomponent = _ReadCustomProperty(block.reader, new CustomProperty(), block.type);\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ColliderRectangle:\n\t\t\t\tcomponent = _ReadRectangleCollider(block.reader, new ActorColliderRectangle());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ColliderTriangle:\n\t\t\t\tcomponent = _ReadTriangleCollider(block.reader, new ActorColliderTriangle());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ColliderCircle:\n\t\t\t\tcomponent = _ReadCircleCollider(block.reader, new ActorColliderCircle());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ColliderPolygon:\n\t\t\t\tcomponent = _ReadPolygonCollider(block.reader, new ActorColliderPolygon());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ColliderLine:\n\t\t\t\tcomponent = _ReadLineCollider(block.reader, new ActorColliderLine());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorEvent:\n\t\t\t\tcomponent = _ReadActorEvent(block.reader, new ActorEvent());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorNode:\n\t\t\t\tcomponent = _ReadActorNode(block.reader, new ActorNode());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorBone:\n\t\t\t\tcomponent = _ReadActorBone(block.reader, new ActorBone());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorJellyBone:\n\t\t\t\tcomponent = _ReadActorJellyBone(block.reader, new ActorJellyBone());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.JellyComponent:\n\t\t\t\tcomponent = _ReadJellyComponent(block.reader, new JellyComponent());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorRootBone:\n\t\t\t\tcomponent = _ReadActorRootBone(block.reader, new ActorRootBone());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorImage:\n\t\t\t\tcomponent = _ReadActorImage(block.reader, new ActorImage());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorImageSequence:\n\t\t\t\tcomponent = _ReadActorImageSequence(block.reader, new ActorImage());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorIKTarget:\n\t\t\t\tcomponent = _ReadActorIKTarget(artboard.actor.dataVersion, block.reader, new ActorIKTarget());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.NestedActorNode:\n\t\t\t\tcomponent = _ReadNestedActor(block.reader, new NestedActorNode(), artboard._NestedActorAssets);\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorNodeSolo:\n\t\t\t\tcomponent = _ReadActorNodeSolo(block.reader, new ActorNodeSolo());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorIKConstraint:\n\t\t\t\tcomponent = _ReadActorIKConstraint(block.reader, new ActorIKConstraint());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorDistanceConstraint:\n\t\t\t\tcomponent = _ReadActorDistanceConstraint(block.reader, new ActorDistanceConstraint());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorTransformConstraint:\n\t\t\t\tcomponent = _ReadActorTransformConstraint(block.reader, new ActorTransformConstraint());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorTranslationConstraint:\n\t\t\t\tcomponent = _ReadAxisConstraint(block.reader, new ActorTranslationConstraint());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorScaleConstraint:\n\t\t\t\tcomponent = _ReadAxisConstraint(block.reader, new ActorScaleConstraint());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorRotationConstraint:\n\t\t\t\tcomponent = _ReadRotationConstraint(block.reader, new ActorRotationConstraint());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorShape:\n\t\t\t\tcomponent = _ReadActorShape(block.reader, new ActorShape());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorPath:\n\t\t\t\tcomponent = _ReadActorPath(block.reader, new ActorPath());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ColorFill:\n\t\t\t\tcomponent = _ReadColorFill(block.reader, new ColorFill());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ColorStroke:\n\t\t\t\tcomponent = _ReadColorStroke(block.reader, new ColorStroke());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.GradientFill:\n\t\t\t\tcomponent = _ReadGradientFill(block.reader, new GradientFill());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.GradientStroke:\n\t\t\t\tcomponent = _ReadGradientStroke(block.reader, new GradientStroke());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.RadialGradientFill:\n\t\t\t\tcomponent = _ReadRadialGradientFill(block.reader, new RadialGradientFill());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.RadialGradientStroke:\n\t\t\t\tcomponent = _ReadRadialGradientStroke(block.reader, new RadialGradientStroke());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorEllipse:\n\t\t\t\tcomponent = _ReadActorEllipse(block.reader, new ActorEllipse());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorRectangle:\n\t\t\t\tcomponent = _ReadActorRectangle(block.reader, new ActorRectangle());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorTriangle:\n\t\t\t\tcomponent = _ReadActorTriangle(block.reader, new ActorTriangle());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorStar:\n\t\t\t\tcomponent = _ReadActorStar(block.reader, new ActorStar());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorPolygon:\n\t\t\t\tcomponent = _ReadActorPolygon(block.reader, new ActorPolygon());\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.ActorSkin:\n\t\t\t\tcomponent = _ReadActorComponent(block.reader, new ActorSkin());\n\t\t\t\tbreak;\n\t\t}\n\t\tif(component)\n\t\t{\n\t\t\tcomponent._Idx = actorComponents.length;\n\t\t}\n\t\tactorComponents.push(component);\n\t}\n\tartboard.resolveHierarchy();\n}\n\nfunction _ReadAnimationBlock(artboard, reader)\n{\n\tconst animation = new Animation(artboard);\n\tartboard._Animations.push(animation);\n\n\tanimation._Name = reader.readString(\"name\");\n\tanimation._FPS = reader.readUint8(\"fps\");\n\tanimation._Duration = reader.readFloat32(\"duration\");\n\tanimation._Loop = reader.readBool(\"isLooping\");\n\n\treader.openArray(\"keyed\");\n\t// Read the number of keyed nodes.\n\tconst numKeyedComponents = reader.readUint16Length();\n\tif(numKeyedComponents > 0)\n\t{\t\n\t\tfor(let i = 0; i < numKeyedComponents; i++)\n\t\t{\n\t\t\treader.openObject(\"component\");\n\t\t\tconst componentIndex = reader.readId(\"component\");\n\t\t\tlet component = artboard._Components[componentIndex];\n\t\t\tif(!component)\n\t\t\t{\n\t\t\t\t\t// Bad component was loaded, read past the animation data.\n\t\t\t\t\t// Note this only works after version 12 as we can read by the entire set of properties.\n\t\t\t\t\t// TODO: test this case with JSON.\n\t\t\t\t\tconst props = reader.readUint16();\n\t\t\t\t\tfor(let j = 0; j < props; j++)\n\t\t\t\t\t{\n\t\t\t\t\t\tlet propertyBlock = _ReadNextBlock(reader, function(err) {artboard.actor.error = err;});\n\t\t\t\t\t}\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tconst animatedComponent = new AnimatedComponent(componentIndex);\n\t\t\t\tif(component.constructor === ActorEvent)\n\t\t\t\t{\n\t\t\t\t\t// N.B. ActorEvents currently only keyframe their trigger so we cn optimize them into a separate array.\n\t\t\t\t\tanimation._TriggerComponents.push(animatedComponent);\t\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tanimation._Components.push(animatedComponent);\n\t\t\t\t}\n\t\t\t\t\n\t\t\t\tconst props = reader.readUint16Length();\n\t\t\t\tfor(let j = 0; j < props; j++)\n\t\t\t\t{\n\t\t\t\t\tlet propertyBlock = _ReadNextBlock(reader, function(err) {artboard.actor.error = err;}, AnimatedProperty);\n\t\t\t\t\tconst propertyReader = propertyBlock.reader;\n\t\t\t\t\tconst propertyType = propertyBlock.type;\n\n\t\t\t\t\tlet validProperty = false;\n\t\t\t\t\tswitch(propertyType)\n\t\t\t\t\t{\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.PosX:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.PosY:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.ScaleX:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.ScaleY:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.Rotation:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.Opacity:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.DrawOrder:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.Length:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.VertexDeform:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.ConstraintStrength:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.Trigger:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.IntProperty:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.FloatProperty:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.StringProperty:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.BooleanProperty:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.IsCollisionEnabled:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.ActiveChildIndex:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.Sequence:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.PathVertices:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.FillColor:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.StrokeColor:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.StrokeWidth:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.FillGradient:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.StrokeGradient:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.FillRadial:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.StrokeRadial:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.StrokeOpacity:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.FillOpacity:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.ShapeWidth:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.ShapeHeight:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.CornerRadius:\n\t\t\t\t\t\tcase _AnimatedPropertyTypes.InnerRadius:\n\t\t\t\t\t\t\tvalidProperty = true;\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tif(!validProperty)\n\t\t\t\t\t{\n\t\t\t\t\t\tcontinue;\n\t\t\t\t\t}\n\t\t\t\t\tconst animatedProperty = new AnimatedProperty(propertyType);\n\t\t\t\t\tanimatedComponent._Properties.push(animatedProperty);\n\n\t\t\t\t\tpropertyReader.openArray(\"frames\");\n\t\t\t\t\tconst keyFrameCount = propertyReader.readUint16Length();\n\t\t\t\t\tlet lastKeyFrame = null;\n\t\t\t\t\tfor(let k = 0; k < keyFrameCount; k++)\n\t\t\t\t\t{\n\t\t\t\t\t\tlet keyFrame = new KeyFrame(animatedProperty);\n\n\t\t\t\t\t\tpropertyReader.openObject(\"frame\");\n\t\t\t\t\t\t\n\t\t\t\t\t\tkeyFrame._Time = propertyReader.readFloat64(\"time\");\n\n\t\t\t\t\t\tswitch(propertyType)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcase _AnimatedPropertyTypes.IsCollisionEnabled:\n\t\t\t\t\t\t\tcase _AnimatedPropertyTypes.BooleanProperty:\n\t\t\t\t\t\t\tcase _AnimatedPropertyTypes.StringProperty:\n\t\t\t\t\t\t\tcase _AnimatedPropertyTypes.Trigger:\n\t\t\t\t\t\t\tcase _AnimatedPropertyTypes.DrawOrder:\n\t\t\t\t\t\t\tcase _AnimatedPropertyTypes.ActiveChildIndex:\n\t\t\t\t\t\t\t\t// These do not interpolate.\n\t\t\t\t\t\t\t\tkeyFrame._Interpolator = Hold.instance;\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\tdefault:\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tconst type = propertyReader.readUint8(\"interpolatorType\");\n\t\t\t\t\t\t\t\tswitch(type)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tcase 0:\n\t\t\t\t\t\t\t\t\t\tkeyFrame._Interpolator = Hold.instance;\n\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\tcase 1:\n\t\t\t\t\t\t\t\t\t\tkeyFrame._Interpolator = Linear.instance;\n\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t\tcase 2:\n\t\t\t\t\t\t\t\t\t\tkeyFrame._Interpolator = new Cubic(\n\t\t\t\t\t\t\t\t\t\t\tpropertyReader.readFloat32(\"cubicX1\"),\n\t\t\t\t\t\t\t\t\t\t\tpropertyReader.readFloat32(\"cubicY1\"), \n\t\t\t\t\t\t\t\t\t\t\tpropertyReader.readFloat32(\"cubicX2\"), \n\t\t\t\t\t\t\t\t\t\t\tpropertyReader.readFloat32(\"cubicY2\")\n\t\t\t\t\t\t\t\t\t\t);\n\t\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tif(propertyType === _AnimatedPropertyTypes.PathVertices)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tconst path = artboard._Components[animatedComponent._ComponentIndex];\n\t\t\t\t\t\t\tconst pointCount = path._Points.length;\n\t\t\t\t\t\t\tconst points = [];\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\tfor(let j = 0; j < pointCount; j++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tconst point = path._Points[j];\n\n\t\t\t\t\t\t\t\tconst pos = propertyReader.readFloat32Array(new Float32Array(2), \"translation\");\n\t\t\t\t\t\t\t\tpoints.push(pos[0], pos[1]);\n\n\t\t\t\t\t\t\t\tif(point.constructor === StraightPathPoint)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tpoints.push(propertyReader.readFloat32(\"radius\"));\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tlet p = propertyReader.readFloat32Array(new Float32Array(2), \"inValue\");\n\t\t\t\t\t\t\t\t\tpoints.push(p[0], p[1]);\n\n\t\t\t\t\t\t\t\t\tp = propertyReader.readFloat32Array(new Float32Array(2), \"outValue\");\n\t\t\t\t\t\t\t\t\tpoints.push(p[0], p[1]);\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\n\t\t\t\t\t\t\tkeyFrame._Value = new Float32Array(points);\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if(propertyType === _AnimatedPropertyTypes.FillColor || propertyType === _AnimatedPropertyTypes.StrokeColor)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tkeyFrame._Value = propertyReader.readFloat32Array(new Float32Array(4), \"value\");\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\telse if(propertyType === _AnimatedPropertyTypes.FillGradient || propertyType === _AnimatedPropertyTypes.StrokeGradient || propertyType === _AnimatedPropertyTypes.StrokeRadial || propertyType === _AnimatedPropertyTypes.FillRadial)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tconst fillLength = propertyReader.readUint16(\"length\");\n\t\t\t\t\t\t\tkeyFrame._Value = propertyReader.readFloat32Array(new Float32Array(fillLength), \"value\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if(propertyType === _AnimatedPropertyTypes.Trigger)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t// No value on keyframe.\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if(propertyType === _AnimatedPropertyTypes.IntProperty)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tkeyFrame._Value = propertyReader.readInt32(\"value\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if(propertyType === _AnimatedPropertyTypes.StringProperty)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tkeyFrame._Value = propertyReader.readString(\"value\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if(propertyType === _AnimatedPropertyTypes.BooleanProperty || propertyType === _AnimatedPropertyTypes.IsCollisionEnabled)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tkeyFrame._Value = propertyReader.readBool(\"value\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if(propertyType === _AnimatedPropertyTypes.DrawOrder)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tpropertyReader.openArray(\"drawOrder\");\n\t\t\t\t\t\t\tconst orderedImages = propertyReader.readUint16Length();\n\t\t\t\t\t\t\tconst orderValue = [];\n\t\t\t\t\t\t\tfor(let l = 0; l < orderedImages; l++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tpropertyReader.openObject(\"order\");\n\t\t\t\t\t\t\t\tconst idx = propertyReader.readId(\"component\");\n\t\t\t\t\t\t\t\tconst order = propertyReader.readUint16(\"order\");\n\t\t\t\t\t\t\t\tpropertyReader.closeObject();\n\t\t\t\t\t\t\t\torderValue.push({\n\t\t\t\t\t\t\t\t\tcomponentIdx:idx,\n\t\t\t\t\t\t\t\t\tvalue:order\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tpropertyReader.closeArray();\n\t\t\t\t\t\t\tkeyFrame._Value = orderValue;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if(propertyType === _AnimatedPropertyTypes.VertexDeform)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tkeyFrame._Value = new Float32Array(component._NumVertices * 2);\n\t\t\t\t\t\t\tcomponent.hasVertexDeformAnimation = true;\n\t\t\t\t\t\t\tpropertyReader.readFloat32Array(keyFrame._Value, \"value\");\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tkeyFrame._Value = propertyReader.readFloat32(\"value\");\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif(propertyType === _AnimatedPropertyTypes.DrawOrder)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\t// Always hold draw order.\n\t\t\t\t\t\t\tkeyFrame._Interpolator = Hold.instance;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse if(propertyType === _AnimatedPropertyTypes.VertexDeform)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tkeyFrame._Interpolator = Linear.instance;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tif(lastKeyFrame)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tlastKeyFrame.setNext(keyFrame);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tanimatedProperty._KeyFrames.push(keyFrame);\n\t\t\t\t\t\tlastKeyFrame = keyFrame;\n\t\t\t\t\t\tpropertyReader.closeObject();\n\t\t\t\t\t}\n\t\t\t\t\tif(lastKeyFrame)\n\t\t\t\t\t{\n\t\t\t\t\t\tlastKeyFrame.setNext(null);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\treader.closeObject();\n\t\t}\n\t\treader.closeArray();\n\t\t\n\t\tanimation._DisplayStart = reader.readFloat32(\"animationStart\");\n\t\tanimation._DisplayEnd = reader.readFloat32(\"animationEnd\");\n\t\t//animation._DisplayStart = 0;\n\t\t//animation._DisplayEnd = 50/60;\n\t}\n\telse\n\t{\n\t\treader.closeArray();\n\t}\n}\n\nfunction _ReadAnimationsBlock(artboard, reader)\n{\n\tconst animationsCount = reader.readUint16Length(); // Keep the reader aligned when using BinaryReader.\n\tlet block = null;\n\t// The animations block only contains a list of animations, so we don't need to track how many we've read in.\n\twhile((block = _ReadNextBlock(reader, function(err) {artboard.actor.error = err;}, Block)) !== null)\n\t{\n\t\tswitch(block.type)\n\t\t{\n\t\t\tcase _BlockTypes.Animation:\n\t\t\t\t_ReadAnimationBlock(artboard, block.reader);\n\t\t\t\tbreak;\n\t\t}\n\t}\n}\n\nfunction _ReadNestedActorAssetBlock(actor, reader)\n{\n\tlet asset = new NestedActorAsset(reader.readString(), reader.readString());\n\tactor._NestedActorAssets.push(asset);\n}\n\nfunction _ReadNestedActorAssets(actor, reader)\n{\n\tlet nestedActorCount = reader.readUint16();\n\tlet block = null;\n\twhile((block=_ReadNextBlock(reader, function(err) {actor.error = err;})) !== null)\n\t{\n\t\tswitch(block.type)\n\t\t{\n\t\t\tcase _BlockTypes.NestedActorAsset:\n\t\t\t\t_ReadNestedActorAssetBlock(actor, block.reader);\n\t\t\t\tbreak;\n\t\t}\n\t}\n}\n\nfunction _BuildJpegAtlas(atlas, img, imga, callback)\n{\n\tconst canvas = document.createElement(\"canvas\");\n\tcanvas.width = img.width;\n canvas.height = img.height;\n const ctx = canvas.getContext(\"2d\");\n\tctx.drawImage(img, 0, 0, img.width, img.height);\n\t\n\tif(imga)\n\t{\n\t\tconst imageDataRGB = ctx.getImageData(0,0,canvas.width, canvas.height);\n\t\tconst dataRGB = imageDataRGB.data;\n\t\tconst canvasAlpha = document.createElement(\"canvas\");\n\n\t\tcanvasAlpha.width = img.width;\n\t\tcanvasAlpha.height = img.height;\n\t\tconst actx = canvasAlpha.getContext(\"2d\");\n\t\tactx.drawImage(imga, 0, 0, imga.width, imga.height);\n\t\n\t\tconst imageDataAlpha = actx.getImageData(0,0,canvasAlpha.width, canvasAlpha.height);\n\t\tconst dataAlpha = imageDataAlpha.data;\n\t\n\t\tconst pixels = dataAlpha.length/4;\n\t\tlet widx = 3;\n\t\n\t\tfor(let j = 0; j < pixels; j++)\n\t\t{\n\t\t\tdataRGB[widx] = dataAlpha[widx-1];\n\t\t\twidx+=4;\n\t\t}\n\t\tctx.putImageData(imageDataRGB, 0, 0);\n\t}\n\n\n\tconst atlasImage = new Image();\n\tconst enc = canvas.toDataURL();\n\tatlasImage.src = enc;\n\tatlasImage.onload = function()\n\t{\n\t\tatlas.img = this;\n\t\tcallback();\n\t};\n}\n\nfunction _JpegAtlas(dataRGB, dataAlpha, callback)\n{\n\tconst _This = this;\n\tconst img = document.createElement(\"img\");\n\tlet imga;\n\tlet c = 0;\n\tlet target = 1;\n\timg.onload = function()\n\t{\n\t\tc++;\n\t\tif(c === target)\n\t\t{\n\t\t\t_BuildJpegAtlas(_This, img, imga, callback);\n\t\t}\n\t};\n\t\n\tif(dataAlpha)\n\t{\n\t\timga = document.createElement(\"img\");\n\t\timga.onload = function()\n\t\t{\n\t\t\tc++;\n\t\t\tif(c == target)\n\t\t\t{\n\t\t\t\t_BuildJpegAtlas(_This, img, imga, callback);\n\t\t\t}\n\t\t};\n\t\timga.src = URL.createObjectURL(dataAlpha);\n\t}\n\timg.src = URL.createObjectURL(dataRGB);\n}\n\nfunction _ReadAtlasesBlock14(actor, reader, callback)\n{\n\t// Read atlases.\n\tconst numAtlases = reader.readUint16();\n\n\tlet waitCount = 0;\n\tlet loadedCount = 0;\n\tfunction loaded()\n\t{\n\t\tloadedCount++;\n\t\tif(loadedCount === waitCount)\n\t\t{\n\t\t\tcallback();\n\t\t}\n\t}\n\n\tfor(let i = 0; i < numAtlases; i++)\n\t{\n\t\tlet size = reader.readUint32();\n\t\tconst atlasDataRGB = new Uint8Array(size);\n\t\treader.readRaw(atlasDataRGB, atlasDataRGB.length);\n\n\t\tsize = reader.readUint32();\n\t\tconst atlasDataAlpha = new Uint8Array(size);\n\t\treader.readRaw(atlasDataAlpha, atlasDataAlpha.length);\n\n\t\tconst rgbSrc = new Blob([atlasDataRGB], {type: \"image/jpeg\"});\n\t\tconst alphaSrc = new Blob([atlasDataAlpha], {type: \"image/jpeg\"});\n\n\t\twaitCount++;\n\t\tconst atlas = new _JpegAtlas(rgbSrc, alphaSrc, loaded);\n\n\t\tactor._Atlases.push(atlas);//new Blob([atlasDataRGB], {type: \"image/jpeg\"}));\n\t}\n\n\t// Return true if we are waiting for atlases\n\treturn waitCount !== loadedCount;\n}\n\nfunction _ReadAtlasesBlock15(actor, reader, callback)\n{\n\t// Internal Callback\n\tfunction loaded()\n\t{\n\t\tloadedCount++;\n\t\tif(loadedCount === waitCount)\n\t\t{\n\t\t\tcallback();\n\t\t}\n\t}\n\t// ==== \n\t\n\t// Read atlases.\n\tconst isOOB = reader.readBool(\"isOOB\");\n\treader.openArray(\"data\");\n\tconst numAtlases = reader.readUint16Length();\n\n\tlet waitCount = 0;\n\tlet loadedCount = 0;\n\n\tfor(let i = 0; i < numAtlases; i++)\n\t{\n\t\twaitCount++;\n\t\tlet readCallback = function(data)\n\t\t{\n\t\t\tif(data.constructor === Blob)\n\t\t\t{\n\t\t\t\tconst atlas = new _JpegAtlas(data, undefined, loaded);\n\t\t\t\tactor._Atlases.push(atlas);\n\t\t\t}\n\t\t\telse if(data.constructor === String)\n\t\t\t{\n\t\t\t\tconst imgElm = document.createElement(\"img\");\n\t\t\t\tconst atlas = {};\n\t\t\t\timgElm.onload = function()\n\t\t\t\t{\n\t\t\t\t\tatlas.img = this;\n\t\t\t\t\tloaded();\n\t\t\t\t};\n\t\t\t\tactor._Atlases.push(atlas);\n\t\t\t\timgElm.src = data;\n\t\t\t}\n\t\t};\n\n\t\treader.readImage(isOOB, readCallback); \n\t}\n\n\treader.closeArray();\n\n\t// Return true if we are waiting for atlases\n\treturn waitCount !== loadedCount;\n}\n\nfunction _LoadNestedAssets(loader, actor, callback)\n{\n\tlet loadCount = actor._NestedActorAssets.length;\n\tlet nestedLoad = loader.loadNestedActor;\n\tif(loadCount == 0 || !nestedLoad)\n\t{\n\t\tcallback(actor);\n\t\treturn;\n\t}\n\n\tfor(let asset of actor._NestedActorAssets)\n\t{\n\t\tnestedLoad(asset, function(nestedActor)\n\t\t{\n\t\t\tasset._Actor = nestedActor;\n\t\t\tloadCount--;\n\t\t\tif(loadCount <= 0)\n\t\t\t{\n\t\t\t\tcallback(actor);\n\t\t\t}\n\t\t});\n\t}\n}\n\nfunction _ReadArtboardsBlock(actor, reader)\n{\n\tconst artboardCount = reader.readUint16Length();\n\tconst actorArtboards = actor._Artboards;\n\n\t// Guaranteed from the exporter to be in index order.\n\tlet block = null;\n\twhile((block = _ReadNextBlock(reader, function(err) {actor.error = err;}, Block)) !== null)\n\t{\n\t\tswitch(block.type)\n\t\t{\n\t\t\tcase _BlockTypes.ActorArtboard:\n\t\t\t{\n\t\t\t\tconst artboard = _ReadActorArtboard(block.reader, new ActorArtboard(actor), block.type);\n\t\t\t\tif(artboard)\n\t\t\t\t{\n\t\t\t\t\tactorArtboards.push(artboard);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t}\n}\n\nfunction _ReadActor(loader, data, callback)\n{\n\tlet reader = new BinaryReader(new Uint8Array(data));\n\t// Check signature\n\tif(reader.readUint8() !== 70 || reader.readUint8() !== 76 || reader.readUint8() !== 65 || reader.readUint8() !== 82 || reader.readUint8() !== 69)\n\t{\n\t\tconst dataView = new DataView(data);\n\t\tconst stringData = new TextDecoder(\"utf-8\").decode(dataView);\n\t\treader = new JSONReader({\"container\": JSON.parse(stringData)});\n\t}\n\n\tconst version = reader.readUint32(\"version\");\n\tconst actor = new Actor();\n\tactor.dataVersion = version;\n\tlet block = null;\n\tlet waitForAtlas = false;\n\twhile((block = _ReadNextBlock(reader, function(err) {actor.error = err;}, Block)) !== null)\n\t{\n\t\tswitch(block.type)\n\t\t{\n\t\t\tcase _BlockTypes.Artboards:\n\t\t\t\t_ReadArtboardsBlock(actor, block.reader);\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.Atlases:\n\n\t\t\t\tif(_ReadAtlasesBlock(actor, block.reader, function()\n\t\t\t\t\t{\n\t\t\t\t\t\t_LoadNestedAssets(loader, actor, callback);\n\t\t\t\t\t}))\n\t\t\t\t{\n\t\t\t\t\twaitForAtlas = true;\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.NestedActorAssets:\n\t\t\t\t_ReadNestedActorAssets(actor, block.reader);\n\t\t\t\tbreak;\n\t\t}\n\t}\n\tif(!waitForAtlas)\n\t{\n\t\t_LoadNestedAssets(loader, actor, callback);\n\t}\n}\n\nfunction _ReadActorArtboard(reader, artboard)\n{\n\tartboard._Name = reader.readString(\"name\");\n\treader.readFloat32Array(artboard._Translation, \"translation\");\n\tartboard._Width = reader.readFloat32(\"width\");\n\tartboard._Height = reader.readFloat32(\"height\");\n\treader.readFloat32Array(artboard._Origin, \"origin\");\n\tartboard._ClipContents = reader.readBool(\"clipContents\");\n\treader.readFloat32Array(artboard._Color, \"color\");\n\n\tlet block = null;\n\twhile((block = _ReadNextBlock(reader, function(err) {artboard.actor.error = err;}, Block)) !== null)\n\t{\n\t\tswitch(block.type)\n\t\t{\n\t\t\tcase _BlockTypes.Nodes:\n\t\t\t\t_ReadComponentsBlock(artboard, block.reader);\n\t\t\t\tbreak;\n\t\t\tcase _BlockTypes.Animations:\n\t\t\t\t_ReadAnimationsBlock(artboard, block.reader);\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\treturn artboard;\n}\n\nfunction _ReadActorComponent(reader, component)\n{\n\tcomponent._Name = reader.readString(\"name\");\n\tcomponent._ParentIdx = reader.readId(\"parent\");\n\treturn component;\n}\n\nfunction _ReadActorPaint(reader, component)\n{\n\t_ReadActorComponent(reader, component);\n\tcomponent._Opacity = reader.readFloat32(\"opacity\");\n\treturn component;\n}\n\nfunction _ReadCustomProperty(reader, component, type)\n{\n\t_ReadActorComponent(reader, component);\n\n\tswitch(type)\n\t{\n\t\tcase _BlockTypes.CustomIntProperty:\n\t\t\tcomponent._PropertyType = CustomProperty.Type.Integer;\n\t\t\tcomponent._Value = reader.readInt32(\"int\");\n\t\t\tbreak;\n\t\tcase _BlockTypes.CustomFloatProperty:\n\t\t\tcomponent._PropertyType = CustomProperty.Type.Float;\n\t\t\tcomponent._Value = reader.readFloat32(\"float\");\n\t\t\tbreak;\n\t\tcase _BlockTypes.CustomStringProperty:\n\t\t\tcomponent._PropertyType = CustomProperty.Type.String;\n\t\t\tcomponent._Value = reader.readString(\"string\");\n\t\t\tbreak;\n\t\tcase _BlockTypes.CustomBooleanProperty:\n\t\t\tcomponent._PropertyType = CustomProperty.Type.Boolean;\n\t\t\tcomponent._Value = reader.readBool(\"bool\");\n\t\t\tbreak;\n\t}\n\n\treturn component;\n}\n\nfunction _ReadCollider(reader, component)\n{\n\t_ReadActorNode(reader, component);\n\tcomponent._IsCollisionEnabled = reader.readBool(\"isCollisionEnabled\");\n\treturn component;\n}\n\nfunction _ReadRectangleCollider(reader, component)\n{\n\t_ReadCollider(reader, component);\n\n\tcomponent._Width = reader.readFloat32(\"width\");\n\tcomponent._Height = reader.readFloat32(\"height\");\n\n\treturn component;\n}\n\nfunction _ReadTriangleCollider(reader, component)\n{\n\t_ReadCollider(reader, component);\n\n\tcomponent._Width = reader.readFloat32(\"width\");\n\tcomponent._Height = reader.readFloat32(\"height\");\n\n\treturn component;\n}\n\nfunction _ReadCircleCollider(reader, component)\n{\n\t_ReadCollider(reader, component);\n\n\tcomponent._Radius = reader.readFloat32(\"radius\");\n\n\treturn component;\n}\n\nfunction _ReadPolygonCollider(reader, component)\n{\n\t_ReadCollider(reader, component);\n\n\tconst numVertices = reader.readUint32(\"cc\");\n\tcomponent._ContourVertices = new Float32Array(numVertices * 2);\n\treader.readFloat32Array(component._ContourVertices, \"countour\");\n\n\treturn component;\n}\n\nfunction _ReadLineCollider(reader, component)\n{\n\t_ReadCollider(reader, component);\n\n\tconst numVertices = reader.readUint32(\"lineDataLength\");\n\tcomponent._Vertices = new Float32Array(numVertices * 2);\n\treader.readFloat32Array(component._Vertices, \"lineData\");\n\n\treturn component;\n}\n\nfunction _ReadActorEvent(reader, component)\n{\n\t_ReadActorComponent(reader, component);\n\treturn component;\n}\n\nfunction _ReadActorNode(reader, component)\n{\n\t_ReadActorComponent(reader, component);\n\n\treader.readFloat32Array(component._Translation, \"translation\");\n\tcomponent._Rotation = reader.readFloat32(\"rotation\");\n\treader.readFloat32Array(component._Scale, \"scale\");\n\tcomponent._Opacity = reader.readFloat32(\"opacity\");\n\tcomponent._IsCollapsedVisibility = reader.readBool(\"isCollapsed\");\n\n\treader.openArray(\"clips\");\n\tconst clipCount = reader.readUint8Length();\n\tif(clipCount)\n\t{\n\t\tcomponent._Clips = [];\n\t\tfor(let i = 0; i < clipCount; i++)\n\t\t{\n\t\t\tcomponent._Clips.push(reader.readId(\"clip\"));\n\t\t}\n\t}\n\treader.closeArray();\n\treturn component;\n}\n\nfunction _ReadActorNodeSolo(reader, component)\n{\n\t_ReadActorNode(reader, component);\n\tcomponent._ActiveChildIndex = reader.readUint32(\"activeChild\");\n\treturn component;\n}\n\nfunction _ReadActorBone(reader, component)\n{\n\t_ReadActorNode(reader, component);\n\tcomponent._Length = reader.readFloat32(\"length\");\n\treturn component;\n}\n\nfunction _ReadActorJellyBone(reader, component)\n{\n\t_ReadActorComponent(reader, component);\n\tcomponent._Opacity = reader.readFloat32(\"opacity\");\n\tcomponent._IsCollapsedVisibility = reader.readBool(\"isCollapsedVisibility\");\n\n\treturn component;\n}\n\nfunction _ReadJellyComponent(reader, component)\n{\n\t_ReadActorComponent(reader, component);\n\tcomponent._EaseIn = reader.readFloat32(\"easeIn\");\n\tcomponent._EaseOut = reader.readFloat32(\"easeOut\");\n\tcomponent._ScaleIn = reader.readFloat32(\"scaleIn\");\n\tcomponent._ScaleOut = reader.readFloat32(\"scaleOut\");\n\tcomponent._InTargetIdx = reader.readId(\"inTarget\");\n\tcomponent._OutTargetIdx = reader.readId(\"outTarget\");\n\n\treturn component;\n}\n\nfunction _ReadActorRootBone(reader, component)\n{\n\t_ReadActorNode(reader, component);\n\n\treturn component;\n}\n\nfunction _ReadActorIKTarget(version, reader, component)\n{\n\t_ReadActorNode(reader, component);\n\n\tcomponent._Strength = reader.readFloat32();\n\tcomponent._InvertDirection = reader.readUint8() === 1;\n\n\tlet numInfluencedBones = reader.readUint8();\n\tif(numInfluencedBones > 0)\n\t{\n\t\tcomponent._InfluencedBones = [];\n\n\t\tfor(let i = 0; i < numInfluencedBones; i++)\n\t\t{\n\t\t\tcomponent._InfluencedBones.push(reader.readUint16());\n\t\t}\n\t}\n\n\treturn component;\n}\n\nfunction _ReadActorConstraint(reader, component)\n{\n\t_ReadActorComponent(reader, component);\n\tcomponent._Strength = reader.readFloat32(\"strength\");\n\tcomponent._IsEnabled = reader.readBool(\"isEnabled\");\n}\n\nfunction _ReadActorTargetedConstraint(reader, component)\n{\n\t_ReadActorConstraint(reader, component);\n\n\tcomponent._TargetIdx = reader.readId(\"target\");\n}\n\nfunction _ReadActorIKConstraint(reader, component)\n{\n\t_ReadActorTargetedConstraint(reader, component);\n\n\tcomponent._InvertDirection = reader.readBool(\"isInverted\");\n\n\treader.openArray(\"bones\");\n\tconst numInfluencedBones = reader.readUint8Length();\n\tif(numInfluencedBones > 0)\n\t{\n\t\tcomponent._InfluencedBones = [];\n\n\t\tfor(let i = 0; i < numInfluencedBones; i++)\n\t\t{\n\t\t\tcomponent._InfluencedBones.push(reader.readId(\"\"));// No need for a label here, since we're just clearing elements from the array.\n\t\t}\n\t}\n\treader.closeArray();\n\treturn component;\n}\n\nfunction _ReadActorDistanceConstraint(reader, component)\n{\n\t_ReadActorTargetedConstraint(reader, component);\n\n\tcomponent._Distance = reader.readFloat32(\"distance\");\n\tcomponent._Mode = reader.readUint8(\"modeId\");\n\n\treturn component;\n}\n\nfunction _ReadActorTransformConstraint(reader, component)\n{\n\t_ReadActorTargetedConstraint(reader, component);\n\n\tcomponent._SourceSpace = reader.readUint8(\"sourceSpaceId\");\n\tcomponent._DestSpace = reader.readUint8(\"destSpaceId\");\n\n\treturn component;\n}\n\nfunction _ReadRotationConstraint(reader, component)\n{\n\t_ReadActorTargetedConstraint(reader, component);\n\n\tif((component._Copy = reader.readBool(\"copy\")))\n\t{\n\t\tcomponent._Scale = reader.readFloat32(\"scale\");\n\t}\n\tif((component._EnableMin = reader.readBool(\"enableMin\")))\n\t{\n\t\tcomponent._Min = reader.readFloat32(\"min\");\n\t}\n\tif((component._EnableMax = reader.readBool(\"enableMax\")))\n\t{\n\t\tcomponent._Max = reader.readFloat32(\"max\");\n\t}\n\t\n\tcomponent._Offset = reader.readBool(\"offset\");\n\tcomponent._SourceSpace = reader.readUint8(\"sourceSpaceId\");\n\tcomponent._DestSpace = reader.readUint8(\"destSpaceId\");\n\tcomponent._MinMaxSpace = reader.readUint8(\"minMaxSpaceId\");\n\n\treturn component;\n}\n\nfunction _ReadAxisConstraint(reader, component)\n{\n\t_ReadActorTargetedConstraint(reader, component);\n\t// X Axis\n\tif((component._CopyX = reader.readBool(\"copyX\")))\n\t{\n\t\tcomponent._ScaleX = reader.readFloat32(\"scaleX\");\n\t}\n\tif((component._EnableMinX = reader.readBool(\"enableMinX\")))\n\t{\n\t\tcomponent._MinX = reader.readFloat32(\"minX\");\n\t}\n\tif((component._EnableMaxX = reader.readBool(\"enableMaxX\")))\n\t{\n\t\tcomponent._MaxX = reader.readFloat32(\"maxX\");\n\t}\n\n\t// Y Axis\n\tif((component._CopyY = reader.readBool(\"copyY\")))\n\t{\n\t\tcomponent._ScaleY = reader.readFloat32(\"scaleY\");\n\t}\n\tif((component._EnableMinY = reader.readBool(\"enableMinY\")))\n\t{\n\t\tcomponent._MinY = reader.readFloat32(\"minY\");\n\t}\n\tif((component._EnableMaxY = reader.readBool(\"enableMaxY\")))\n\t{\n\t\tcomponent._MaxY = reader.readFloat32(\"maxY\");\n\t}\n\n\tcomponent._Offset = reader.readBool(\"offset\");\n\tcomponent._SourceSpace = reader.readUint8(\"sourceSpaceId\");\n\tcomponent._DestSpace = reader.readUint8(\"destSpaceId\");\n\tcomponent._MinMaxSpace = reader.readUint8(\"minMaxSpaceId\");\n\n\treturn component;\n}\n\nfunction _ReadActorShape(reader, component)\n{\n\t_ReadActorNode(reader, component);\n\tcomponent._IsHidden = !reader.readBool(\"isVisible\");\n\t/*component._BlendMode =*/ reader.readUint8(\"blendMode\");\n\tcomponent._DrawOrder = reader.readUint16(\"drawOrder\");\n\n\treturn component;\n}\n\nfunction _ReadProceduralPath(reader, component)\n{\n\t_ReadActorNode(reader, component);\n\tcomponent._Width = reader.readFloat32(\"width\");\n\tcomponent._Height = reader.readFloat32(\"height\");\n\treturn component;\n}\n\nfunction _ReadActorStar(reader, component)\n{\n\t_ReadProceduralPath(reader, component);\n\tcomponent._Points = reader.readUint32(\"points\");\n\tcomponent._InnerRadius = reader.readFloat32(\"innerRadius\");\n\t\n\treturn component;\n}\n\nfunction _ReadActorRectangle(reader, component)\n{\n\t_ReadProceduralPath(reader, component);\n\tcomponent._CornerRadius = reader.readFloat32(\"cornerRadius\");\n\treturn component;\n}\n\nfunction _ReadActorPolygon(reader, component)\n{\n\t_ReadProceduralPath(reader, component);\n\tcomponent._Sides = reader.readUint32(\"sides\");\n\treturn component;\n}\n\nfunction _ReadActorTriangle(reader, component)\n{\n\t_ReadProceduralPath(reader, component);\n\t\n\treturn component;\n}\n\nfunction _ReadActorEllipse(reader, component)\n{\n\t_ReadProceduralPath(reader, component);\n\treturn component;\n}\n\nfunction _ReadColorFill(reader, component)\n{\n\t_ReadActorPaint(reader, component);\n\n\treader.readFloat32Array(component._Color, \"color\");\n\tcomponent._FillRule = reader.readUint8(\"fillRule\");\n\n\treturn component;\n}\n\nfunction _ReadColorStroke(reader, component)\n{\n\t_ReadActorPaint(reader, component);\n\n\treader.readFloat32Array(component._Color, \"color\");\n\tcomponent._Width = reader.readFloat32(\"width\");\n\n\treturn component;\n}\n\nfunction _ReadGradient(reader, component)\n{\n\tconst numStops = reader.readUint8(\"numColorStops\");\n\tconst stops = new Float32Array(numStops*5);\n\treader.readFloat32Array(stops, \"colorStops\");\n\tcomponent._ColorStops = stops;\n\n\treader.readFloat32Array(component._Start, \"start\");\n\treader.readFloat32Array(component._End, \"end\");\n\n\treturn component;\n}\n\nfunction _ReadRadialGradient(reader, component)\n{\n\t_ReadGradient(reader, component);\n\tcomponent._SecondaryRadiusScale = reader.readFloat32(\"secondaryRadiusScale\");\n\n\treturn component;\n}\n\nfunction _ReadGradientFill(reader, component)\n{\n\t_ReadActorPaint(reader, component);\n\n\t_ReadGradient(reader, component);\n\tcomponent._FillRule = reader.readUint8(\"fillRule\");\n\n\treturn component;\n}\n\nfunction _ReadGradientStroke(reader, component)\n{\n\t_ReadActorPaint(reader, component);\n\n\t_ReadGradient(reader, component);\n\tcomponent._Width = reader.readFloat32(\"width\");\n\n\treturn component;\n}\n\nfunction _ReadRadialGradientFill(reader, component)\n{\n\t_ReadActorPaint(reader, component);\n\n\t_ReadRadialGradient(reader, component);\n\tcomponent._FillRule = reader.readUint8(\"fillRule\");\n\n\treturn component;\n}\n\nfunction _ReadRadialGradientStroke(reader, component)\n{\n\t_ReadActorPaint(reader, component);\n\n\t_ReadRadialGradient(reader, component);\n\tcomponent._Width = reader.readFloat32(\"width\");\n\n\treturn component;\n}\n\nfunction _ReadSkinnable(reader, component)\n{\n\t_ReadActorNode(reader, component);\n\n\treader.openArray(\"bones\");\n\tconst numConnectedBones = reader.readUint8Length();\n\tif(numConnectedBones > 0)\n\t{\n\t\tcomponent._ConnectedBones = [];\n\t\tfor(let i = 0; i < numConnectedBones; i++)\n\t\t{\n\t\t\treader.openObject(\"bone\");\n\t\t\tconst bind = mat2d.create();\n\t\t\tconst componentIndex = reader.readId(\"component\");\n\t\t\treader.readFloat32Array(bind, \"bind\");\n\t\t\treader.closeObject();\n\n\t\t\tcomponent._ConnectedBones.push({\n\t\t\t\tcomponentIndex:componentIndex,\n\t\t\t\tbind:bind,\n\t\t\t\tibind:mat2d.invert(mat2d.create(), bind)\n\t\t\t});\n\t\t}\n\t\treader.closeArray();\n\n\t\t// Read the final override parent world.\n\t\tconst overrideWorld = mat2d.create();\n\t\treader.readFloat32Array(overrideWorld, \"worldTransform\");\n\t\tmat2d.copy(component._WorldTransform, overrideWorld);\n\t\tcomponent._OverrideWorldTransform = true;\n\t}\n\telse\n\t{\n\t\t// Close the previously opened JSON Array.\n\t\treader.closeArray();\n\t}\n}\n\nfunction _ReadActorPath(reader, component)\n{\n\t_ReadSkinnable(reader, component);\n\tcomponent._IsHidden = !reader.readBool(\"isVisible\");\n\tcomponent._IsClosed = reader.readBool(\"isClosed\");\n\n\treader.openArray(\"points\");\n\tconst pointCount = reader.readUint16Length();\n\tconst points = new Array(pointCount);\n\tconst isConnectedToBones = component._ConnectedBones && component._ConnectedBones.length > 0;\n\tfor(let i = 0; i < pointCount; i++)\n\t{\n\t\treader.openObject(\"point\");\n\t\tconst type = reader.readUint8(\"pointType\");\n\t\tlet point = null;\n\t\tswitch(type)\n\t\t{\n\t\t\tcase PointType.Straight:\n\t\t\t{\n\t\t\t\tpoint = new StraightPathPoint();\n\t\t\t\treader.readFloat32Array(point._Translation, \"translation\");\n\t\t\t\tpoint._Radius = reader.readFloat32(\"radius\");\n\t\t\t\tif(isConnectedToBones)\n\t\t\t\t{\n\t\t\t\t\tpoint._Weights = new Float32Array(8);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tdefault:\n\t\t\t{\n\t\t\t\tpoint = new CubicPathPoint();\n\t\t\t\treader.readFloat32Array(point._Translation, \"translation\");\n\t\t\t\treader.readFloat32Array(point._In, \"in\");\n\t\t\t\treader.readFloat32Array(point._Out, \"out\");\n\t\t\t\tif(isConnectedToBones)\n\t\t\t\t{\n\t\t\t\t\tpoint._Weights = new Float32Array(24);\n\t\t\t\t}\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\tif(point._Weights)\n\t\t{\n\t\t\treader.readFloat32Array(point._Weights, \"weights\");\n\t\t}\n\t\treader.closeObject();\n\t\tif(!point)\n\t\t{\n\t\t\tthrow new Error(\"Invalid point type \" + type);\n\t\t}\n\t\tpoint._PointType = type;\n\t\tpoints[i] = point;\n\t}\n\treader.closeArray();\n\tcomponent._Points = points;\n\t\n\treturn component;\n}\n\nfunction _ReadActorImage(reader, component)\n{\n\t_ReadActorNode(reader, component);\n\tconst isVisible = reader.readBool(\"isVisible\");\n\tif(isVisible)\n\t{\n\t\tcomponent._BlendMode = reader.readUint8(\"blendMode\");\n\t\tcomponent._DrawOrder = reader.readUint16(\"drawOrder\");\n\t\tcomponent._AtlasIndex = reader.readUint8(\"atlas\");\n\n\t\treader.openArray(\"bones\");\n\t\tconst numConnectedBones = reader.readUint8Length();\n\t\tif(numConnectedBones > 0)\n\t\t{\n\t\t\tcomponent._ConnectedBones = [];\n\t\t\tfor(let i = 0; i < numConnectedBones; i++)\n\t\t\t{\n\t\t\t\treader.openObject(\"bone\");\n\t\t\t\tconst bind = mat2d.create();\n\t\t\t\tconst componentIndex = reader.readId(\"component\");\n\t\t\t\treader.readFloat32Array(bind, \"bind\");\n\t\t\t\treader.closeObject();\n\n\t\t\t\tcomponent._ConnectedBones.push({\n\t\t\t\t\tcomponentIndex:componentIndex,\n\t\t\t\t\tbind:bind,\n\t\t\t\t\tibind:mat2d.invert(mat2d.create(), bind)\n\t\t\t\t});\n\t\t\t}\n\t\t\treader.closeArray();\n\n\t\t\t// Read the final override parent world.\n\t\t\tconst overrideWorld = mat2d.create();\n\t\t\treader.readFloat32Array(overrideWorld, \"worldTransform\");\n\t\t\tmat2d.copy(component._WorldTransform, overrideWorld);\n\t\t\tcomponent._OverrideWorldTransform = true;\n\t\t}\n\t\telse\n\t\t{\n\t\t\t// Close the previously opened JSON Array.\n\t\t\treader.closeArray();\n\t\t}\n\n\t\tconst numVertices = reader.readUint32(\"numVertices\");\n\t\tconst vertexStride = numConnectedBones > 0 ? 12 : 4;\n\t\t\n\t\tcomponent._NumVertices = numVertices;\n\t\tcomponent._VertexStride = vertexStride;\n\t\tcomponent._Vertices = new Float32Array(numVertices * vertexStride);\n\t\treader.readFloat32Array(component._Vertices, \"vertices\");\n\n\t\tconst numTris = reader.readUint32(\"numTriangles\");\n\t\tcomponent._Triangles = new Uint16Array(numTris * 3);\n\t\treader.readUint16Array(component._Triangles, \"triangles\");\n\t}\n\n\treturn component;\n}\n\nfunction _ReadActorImageSequence(reader, component)\n{\n\t_ReadActorImage(reader, component);\n\n\t// See if it was visible to begin with.\n\tif(component._AtlasIndex != -1)\n\t{\n\t\treader.openArray(\"frames\");\n\t\tconst frameCount = reader.readUint16Length();\n\t\tcomponent._SequenceFrames = [];\n\t\tconst uvs = new Float32Array(component._NumVertices*2*frameCount);\n\t\tconst uvStride = component._NumVertices*2;\n\t\tcomponent._SequenceUVs = uvs;\n\t\tconst firstFrame = {\n\t\t\tatlas:component._AtlasIndex,\n\t\t\toffset:0\n\t\t};\n\n\t\tcomponent._SequenceFrames.push(firstFrame);\n\n\t\tlet readIdx = 2;\n\t\tlet writeIdx = 0;\n\t\tfor(let i = 0; i < component._NumVertices; i++)\n\t\t{\n\t\t\tuvs[writeIdx++] = component._Vertices[readIdx];\n\t\t\tuvs[writeIdx++] = component._Vertices[readIdx+1];\n\t\t\treadIdx += component._VertexStride;\n\t\t}\n\n\t\tlet offset = uvStride;\n\t\tfor(let i = 1; i < frameCount; i++)\n\t\t{\n\t\t\treader.openObject(\"frame\");\n\t\t\tlet frame = {\n\t\t\t\tatlas:reader.readUint8(\"atlas\"),\n\t\t\t\toffset:offset*4\n\t\t\t};\n\n\t\t\tcomponent._SequenceFrames.push(frame);\n\t\t\treader.readFloat32ArrayOffset(uvs, uvStride, offset, \"uv\");\n\t\t\treader.closeObject();\n\n\t\t\toffset += uvStride;\n\t\t}\n\t\treader.closeArray();\n\t}\n\n\treturn component;\n}\n\nfunction _ReadNestedActor(reader, component, nestedActorAssets)\n{\n\t_ReadActorNode(reader, component);\n\tlet isVisible = reader.readUint8();\n\tif(isVisible)\n\t{\n\t\t// Draw order\n\t\tcomponent._DrawOrder = reader.readUint16();\n\t\tlet assetIndex = reader.readUint16();\n\t\tif(assetIndex < nestedActorAssets.length)\n\t\t{\n\t\t\tcomponent._Asset = nestedActorAssets[assetIndex];\n\t\t}\n\t}\n\treturn component;\n}\n\nexport default class ActorLoader\n{\n\tload(url, callback)\n\t{\n\t\tlet loader = this;\n\t\tif(url.constructor === String)\n\t\t{\n\t\t\tlet req = new XMLHttpRequest();\n\t\t\treq.open(\"GET\", url, true);\n\t\t\treq.responseType = \"blob\";\n\t\t\treq.onload = function()\n\t\t\t{\n\t\t\t\tlet fileReader = new FileReader();\n\t\t\t\tfileReader.onload = function() \n\t\t\t\t{\n\t\t\t\t\t_ReadActor(loader, this.result, callback);\n\t\t\t\t};\n\t\t\t\tfileReader.readAsArrayBuffer(this.response);\n\t\t\t};\n\t\t\treq.send();\n\t\t}\n\t\telse\n\t\t{\n\t\t\tlet fileReader = new FileReader();\n\t\t\tfileReader.onload = function() \n\t\t\t{\n\t\t\t\t_ReadActor(loader, this.result, callback);\n\t\t\t};\n\t\t\tfileReader.readAsArrayBuffer(url);\n\t\t}\n\t}\n}","import ActorComponent from \"./ActorComponent.js\";\nimport {vec2, mat2d} from \"gl-matrix\";\n\n\nconst TransformDirty = 1<<0;\nconst WorldTransformDirty = 1<<1;\n\nfunction _UpdateTransform(node)\n{\n\tlet r = node._Rotation;\n\tlet t = node._Translation;\n\n\t//t[0] += 0.01;\n\tlet s = node._Scale;\n\tlet transform = node._Transform;\n\n\tmat2d.fromRotation(transform, r);\n\n\ttransform[4] = t[0];\n\ttransform[5] = t[1];\n\n\tmat2d.scale(transform, transform, s);\n\n\treturn transform;\n}\n\nexport default class ActorNode extends ActorComponent\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._Children = [];\n\t\tthis._Transform = mat2d.create();\n\t\tthis._WorldTransform = mat2d.create();\n\t\tthis._OverrideWorldTransform = false;\n\t\tthis._Constraints = null;\n\t\tthis._PeerConstraints = null;\n\n\t\tthis._Translation = vec2.create();\n\t\tthis._Rotation = 0;\n\t\tthis._Scale = vec2.set(vec2.create(), 1, 1);\n\t\tthis._Opacity = 1;\n\t\tthis._RenderOpacity = 1;\n\n\t\tthis._IsCollapsedVisibility = false;\n\t\tthis._RenderCollapsed = false;\n\t\tthis._Clips = null;\n\t}\n\n\teachChildRecursive(cb)\n\t{\n\t\tconst children = this._Children;\n\t\tfor(let child of children)\n\t\t{\n\t\t\tif(cb(child) === false)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif(child.eachChildRecursive)\n\t\t\t{\n\t\t\t\tchild.eachChildRecursive(cb);\n\t\t\t}\n\t\t}\n\t}\n\n\tall(cb)\n\t{\n\t\tif(cb(this) === false)\n\t\t{\n\t\t\treturn false;\n\t\t}\n\t\tconst children = this._Children;\n\t\tfor(let child of children)\n\t\t{\n\t\t\tif(cb(child) === false)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif(child.eachChildRecursive)\n\t\t\t{\n\t\t\t\tchild.eachChildRecursive(cb);\n\t\t\t}\n\t\t}\n\n\t\treturn true;\n\t}\n\n\tget constraints()\n\t{\n\t\treturn this._Constraints;\n\t}\n\n\tget allConstraints()\n\t{\n\t\treturn new Set((this._Constraints || []).concat(this._PeerConstraints || []));\n\t}\n\n\taddConstraint(constraint)\n\t{\n\t\tlet constraints = this._Constraints;\n\t\tif(!constraints)\n\t\t{\n\t\t\tthis._Constraints = constraints = [];\n\t\t}\n\t\tif(constraints.indexOf(constraint) !== -1)\n\t\t{\n\t\t\treturn false;\n\t\t}\n\n\t\tconstraints.push(constraint);\n\n\t\treturn true;\n\t}\n\n\taddPeerConstraint(constraint)\n\t{\n\t\tif(!this._PeerConstraints)\n\t\t{\n\t\t\tthis._PeerConstraints = [];\n\t\t}\n\t\tthis._PeerConstraints.push(constraint);\n\t}\n\n\tmarkTransformDirty()\n\t{\n\t\tlet actor = this._Actor;\n\t\tif(!actor)\n\t\t{\n\t\t\t// Still loading?\n\t\t\treturn;\n\t\t}\n\t\tif(!actor.addDirt(this, TransformDirty))\n\t\t{\n\t\t\treturn;\n\t\t}\n\t\tactor.addDirt(this, WorldTransformDirty, true);\n\t}\n\n\tupdateWorldTransform()\n\t{\n\t\tconst parent = this._Parent;\n\n\t\tthis._RenderOpacity = this._Opacity;\n\t\t\n\t\tif(parent)\n\t\t{\n\t\t\tthis._RenderCollapsed = this._IsCollapsedVisibility || parent._RenderCollapsed;\n\t\t\tthis._RenderOpacity *= parent._RenderOpacity;\n\t\t\tif(!this._OverrideWorldTransform)\n\t\t\t{\n\t\t\t\tmat2d.mul(this._WorldTransform, parent._WorldTransform, this._Transform);\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tmat2d.copy(this._WorldTransform, this._Transform);\n\t\t}\n\t}\n\t\n\tget isNode()\n\t{\n\t\treturn true;\n\t}\n\n\tget translation()\n\t{\n\t\treturn this._Translation;\n\t}\n\n\tset translation(t)\n\t{\n\t\tif(vec2.exactEquals(this._Translation, t))\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tvec2.copy(this._Translation, t);\n\t\tthis.markTransformDirty();\n\t}\n\n\tget scale()\n\t{\n\t\treturn this._Scale;\n\t}\n\n\tset scale(t)\n\t{\n\t\tif(vec2.exactEquals(this._Scale, t))\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tvec2.copy(this._Scale, t);\n\t\tthis.markTransformDirty();\n\t}\n\n\tget x()\n\t{\n\t\treturn this._Translation[0];\n\t}\n\n\tset x(value)\n\t{\n\t\tif(this._Translation[0] != value)\n\t\t{\n\t\t\tthis._Translation[0] = value;\n\t\t\tthis.markTransformDirty();\n\t\t}\n\t}\n\n\tget y()\n\t{\n\t\treturn this._Translation[1];\n\t}\n\n\tset y(value)\n\t{\n\t\tif(this._Translation[1] != value)\n\t\t{\n\t\t\tthis._Translation[1] = value;\n\t\t\tthis.markTransformDirty();\n\t\t}\n\t}\n\n\tget scaleX()\n\t{\n\t\treturn this._Scale[0];\n\t}\n\n\tset scaleX(value)\n\t{\n\t\tif(this._Scale[0] != value)\n\t\t{\n\t\t\tthis._Scale[0] = value;\n\t\t\tthis.markTransformDirty();\n\t\t}\n\t}\n\n\tget scaleY()\n\t{\n\t\treturn this._Scale[1];\n\t}\n\n\tset scaleY(value)\n\t{\n\t\tif(this._Scale[1] != value)\n\t\t{\n\t\t\tthis._Scale[1] = value;\n\t\t\tthis.markTransformDirty();\n\t\t}\n\t}\n\n\tget rotation()\n\t{\n\t\treturn this._Rotation;\n\t}\n\n\tset rotation(value)\n\t{\n\t\tif(this._Rotation != value)\n\t\t{\n\t\t\tthis._Rotation = value;\n\t\t\tthis.markTransformDirty();\n\t\t}\n\t}\n\n\tget opacity()\n\t{\n\t\treturn this._Opacity;\n\t}\n\n\tset opacity(value)\n\t{\n\t\tif(this._Opacity != value)\n\t\t{\n\t\t\tthis._Opacity = value;\n\t\t\tthis.markTransformDirty();\n\t\t}\n\t}\n\n\tupdate(dirt)\n\t{\n\t\tif((dirt & TransformDirty) === TransformDirty)\n\t\t{\n\t\t\t_UpdateTransform(this);\n\t\t}\n\t\tif((dirt & WorldTransformDirty) === WorldTransformDirty)\n\t\t{\n\t\t\tthis.updateWorldTransform();\n\t\t\tlet constraints = this._Constraints;\n\t\t\tif(constraints)\n\t\t\t{\n\t\t\t\tfor(let constraint of constraints)\n\t\t\t\t{\n\t\t\t\t\tif(constraint.isEnabled)\n\t\t\t\t\t{\n\t\t\t\t\t\tconstraint.constrain(this);\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tgetWorldTransform()\n\t{\n\t\tif((this._DirtMask & WorldTransformDirty) !== WorldTransformDirty)\n\t\t{\n\t\t\treturn this._WorldTransform;\n\t\t}\n\n\t\tlet parent = this.parent;\n\t\tlet chain = [this];\n\t\twhile(parent)\n\t\t{\n\t\t\tchain.unshift(parent);\n\t\t\tparent = parent.parent;\n\t\t}\n\t\tfor(let item of chain)\n\t\t{\n\t\t\tif(item instanceof ActorNode)\n\t\t\t{\n\t\t\t\tif((this._DirtMask & TransformDirty) !== TransformDirty)\n\t\t\t\t{\n\t\t\t\t\t_UpdateTransform(this);\n\t\t\t\t}\n\t\t\t\tif((this._DirtMask & WorldTransformDirty) !== WorldTransformDirty)\n\t\t\t\t{\n\t\t\t\t\titem.updateWorldTransform();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn this._WorldTransform;\n\t}\n\n\tget transform()\n\t{\n\t\treturn this._Transform;\n\t}\n\n\tget worldTransform()\n\t{\n\t\treturn this._WorldTransform;\n\t}\n\n\tget worldTranslation()\n\t{\n\t\tconst transform = this._WorldTransform;\n\t\treturn vec2.set(vec2.create(), transform[4], transform[5]);\n\t}\n\n\tsetCollapsedVisibility(v)\n\t{\n\t\tif(this._IsCollapsedVisibility === v)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tthis._IsCollapsedVisibility = v;\n\t\tthis.markTransformDirty();\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorNode();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tmat2d.copy(this._Transform, node._Transform);\n\t\tmat2d.copy(this._WorldTransform, node._WorldTransform);\n\t\tvec2.copy(this._Translation, node._Translation);\n\t\tvec2.copy(this._Scale, node._Scale);\n\t\tthis._Rotation = node._Rotation;\n\t\tthis._Opacity = node._Opacity;\n\t\tthis._RenderOpacity = node._RenderOpacity;\n\t\tthis._OverrideWorldTransform = node._OverrideWorldTransform;\n\t\tif(node._Clips)\n\t\t{\n\t\t\tthis._Clips = [];\t\n\t\t\tfor(let clip of node._Clips)\n\t\t\t{\n\t\t\t\tthis._Clips.push(clip._Idx);\n\t\t\t}\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis._Clips = null;\n\t\t}\n\t}\n\n\toverrideWorldTransform(transform)\n\t{\n\t\tthis._OverrideWorldTransform = transform ? true : false;\n\t\tmat2d.copy(this._WorldTransform, transform);\n\t\tthis.markTransformDirty();\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\t\tlet clips = this._Clips;\n\t\tif(!clips)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tfor(let i = 0; i < clips.length; i++)\n\t\t{\n\t\t\tlet idx = clips[i];\n\t\t\tclips[i] = components[idx];\n\t\t}\n\t}\n}","import ActorNode from \"./ActorNode.js\";\n\nexport default class ActorNodeSolo extends ActorNode\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._ActiveChildIndex = 0;\n\t}\n\n\tsetActiveChildIndex(idx)\n\t{\n\t\tthis._ActiveChildIndex = Math.min(this._Children.length, Math.max(0, idx));\n\n\t\tfor(let i = 0; i < this._Children.length; ++i)\n\t\t{\n\t\t\tconst an = this._Children[i];\n\t\t\tconst cv = i !== (this._ActiveChildIndex - 1);\n\t\t\tan.setCollapsedVisibility(cv);\n\t\t}\n\t}\n\n\tset activeChildIndex(index)\n\t{\n\t\tif(index === this._ActiveChildIndex)\n\t\t{\n\t\t\treturn;\n\t\t}\n\t\tthis.setActiveChildIndex(index);\n\t}\n\n\tget activeChildIndex()\n\t{\n\t\treturn this._ActiveChildIndex;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorNodeSolo();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._ActiveChildIndex = node._ActiveChildIndex;\n\t}\n\n\tcompleteResolve()\n\t{\n\t\tsuper.completeResolve();\n\t\t// Hierarchy is resolved.\n\t\tthis.setActiveChildIndex(this._ActiveChildIndex);\n\t}\n}","import ActorSkinnableNode from \"./ActorSkinnableNode.js\";\nimport {vec2, mat2d} from \"gl-matrix\";\nimport {PathPoint, PointType} from \"./PathPoint.js\";\nimport PathMatrix from \"./PathMatrix.js\";\n\nconst CircleConstant = 0.552284749831;\nconst InverseCircleConstant = 1.0-CircleConstant;\n\nexport default class ActorPath extends ActorSkinnableNode\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._IsClosed = false;\n\t\tthis._IsHidden = false;\n\t\tthis._Points = [];\n\t\tthis._RenderPath = null;\n\t\tthis._Skin = null;\n\t}\n\t\n\tsetSkin(skin)\n\t{\n\t\tthis._Skin = skin;\n\t}\n\t\n\tget isHidden()\n\t{\n\t\treturn this._IsHidden;\n\t}\n\n\tset isHidden(hidden)\n\t{\n\t\tthis._IsHidden = hidden;\n\t}\n\n\tget isClosed()\n\t{\n\t\treturn this._IsClosed;\n\t}\n\n\tset isClosed(closed)\n\t{\n\t\tthis._IsClosed = closed;\n\t}\n\n\tinitialize(actor, graphics)\n\t{\n\t\t\n\t}\n\n\tget numPoints()\n\t{\n\t\treturn this._Points.length;\n\t}\n\n\tgetPathOBB()\n\t{\n\t\tlet min_x = Number.MAX_VALUE;\n\t\tlet min_y = Number.MAX_VALUE;\n\t\tlet max_x = -Number.MAX_VALUE;\n\t\tlet max_y = -Number.MAX_VALUE;\n\n\t\tconst renderPoints = this.makeRenderPoints();\n\t\tfor(let point of renderPoints)\n\t\t{\n\t\t\tlet t = point.translation;\n\t\t\t\n\t\t\tlet x = t[0];\n\t\t\tlet y = t[1];\n\n\t\t\tif(x < min_x)\n\t\t\t{\n\t\t\t\tmin_x = x;\n\t\t\t}\n\t\t\tif(y < min_y)\n\t\t\t{\n\t\t\t\tmin_y = y;\n\t\t\t}\n\t\t\tif(x > max_x)\n\t\t\t{\n\t\t\t\tmax_x = x;\n\t\t\t}\n\t\t\tif(y > max_y)\n\t\t\t{\n\t\t\t\tmax_y = y;\n\t\t\t}\n\n\t\t\tif(point.pointType !== PointType.Straight)\n\t\t\t{\n\t\t\t\tlet t = point.in;\n\t\t\t\tx = t[0];\n\t\t\t\ty = t[1];\n\t\t\t\tif(x < min_x)\n\t\t\t\t{\n\t\t\t\t\tmin_x = x;\n\t\t\t\t}\n\t\t\t\tif(y < min_y)\n\t\t\t\t{\n\t\t\t\t\tmin_y = y;\n\t\t\t\t}\n\t\t\t\tif(x > max_x)\n\t\t\t\t{\n\t\t\t\t\tmax_x = x;\n\t\t\t\t}\n\t\t\t\tif(y > max_y)\n\t\t\t\t{\n\t\t\t\t\tmax_y = y;\n\t\t\t\t}\n\n\t\t\t\tt = point.out;\n\t\t\t\tx = t[0];\n\t\t\t\ty = t[1];\n\t\t\t\tif(x < min_x)\n\t\t\t\t{\n\t\t\t\t\tmin_x = x;\n\t\t\t\t}\n\t\t\t\tif(y < min_y)\n\t\t\t\t{\n\t\t\t\t\tmin_y = y;\n\t\t\t\t}\n\t\t\t\tif(x > max_x)\n\t\t\t\t{\n\t\t\t\t\tmax_x = x;\n\t\t\t\t}\n\t\t\t\tif(y > max_y)\n\t\t\t\t{\n\t\t\t\t\tmax_y = y;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\treturn [min_x, min_y, max_x, max_y];\n\t}\n\n\tgetPathAABB()\n\t{\n\t\tlet min_x = Number.MAX_VALUE;\n\t\tlet min_y = Number.MAX_VALUE;\n\t\tlet max_x = -Number.MAX_VALUE;\n\t\tlet max_y = -Number.MAX_VALUE;\n\n\t\tconst obb = this.getPathOBB();\n\n\t\tconst points = [\n\t\t\tvec2.fromValues(obb[0], obb[1]),\n\t\t\tvec2.fromValues(obb[2], obb[1]),\n\t\t\tvec2.fromValues(obb[2], obb[3]),\n\t\t\tvec2.fromValues(obb[0], obb[3])\n\t\t];\n\t\tlet {_Transform:transform, isConnectedToBones} = this;\n\n\t\tif(isConnectedToBones)\n\t\t{\n\t\t\t// If we're connected to bones, convert the path coordinates into local parent space.\n\t\t\ttransform = mat2d.invert(mat2d.create(), this.parent._WorldTransform);\n\t\t}\n\n\t\tfor(let i = 0; i < points.length; i++)\n\t\t{\n\t\t\tconst pt = points[i];\n\t\t\tconst wp = transform ? vec2.transformMat2d(pt, pt, transform) : pt;\n\t\t\tif(wp[0] < min_x)\n\t\t\t{\n\t\t\t\tmin_x = wp[0];\n\t\t\t}\n\t\t\tif(wp[1] < min_y)\n\t\t\t{\n\t\t\t\tmin_y = wp[1];\n\t\t\t}\n\n\t\t\tif(wp[0] > max_x)\n\t\t\t{\n\t\t\t\tmax_x = wp[0];\n\t\t\t}\n\t\t\tif(wp[1] > max_y)\n\t\t\t{\n\t\t\t\tmax_y = wp[1];\n\t\t\t}\n\t\t}\n\n\t\treturn [min_x, min_y, max_x, max_y];\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorPath();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._IsClosed = node._IsClosed;\n\t\tthis._IsHidden = node._IsHidden;\n\n\t\tconst pointCount = node._Points.length;\n\t\tthis._Points = new Array(pointCount);\n\t\tfor(let i = 0; i < pointCount; i++)\n\t\t{\n\t\t\tlet p = node._Points[i];\n\t\t\tthis._Points[i] = p.makeInstance();\n\t\t}\n\t}\n\n\tget deformedPoints()\n\t{\n\t\tlet boneTransforms = null;\n\t\tif(this._Skin)\n\t\t{\n\t\t\tboneTransforms = this._Skin.boneMatrices;\n\t\t}\n\t\tconst {_Points:points, worldTransform} = this;\n\t\tif(!boneTransforms)\n\t\t{\n\t\t\treturn points;\n\t\t}\n\n\t\tconst deformedPoints = [];\n\t\tfor(const point of points)\n\t\t{\n\t\t\tdeformedPoints.push(point.skin(worldTransform, boneTransforms));\n\t\t}\n\t\treturn deformedPoints;\n\t}\n\n\tmakeRenderPoints()\n\t{\n\t\tlet points = this.deformedPoints;\n\n\t\tlet renderPoints = [];\n\t\t\n\t\tif(points.length)\n\t\t{\n\t\t\tlet pl = points.length;\n\t\t\tconst isClosed = this.isClosed;\n\t\t\tlet previous = isClosed ? points[points.length-1] : null;\n\t\t\tfor(let i = 0; i < points.length; i++)\n\t\t\t{\n\t\t\t\tlet point = points[i];\n\n\t\t\t\tswitch(point.pointType)\n\t\t\t\t{\n\t\t\t\t\tcase PointType.Straight:\n\t\t\t\t\t{\n\t\t\t\t\t\tconst radius = point.radius;\n\t\t\t\t\t\tif(radius > 0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tif(!isClosed && (i === 0 || i === pl-1))\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\trenderPoints.push(point);\n\t\t\t\t\t\t\t\tprevious = point;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tlet next = points[(i+1)%pl];\n\t\t\t\t\t\t\t\tprevious = previous.pointType === PointType.Straight ? previous.translation : previous.out;\n\t\t\t\t\t\t\t\tnext = next.pointType === PointType.Straight ? next.translation : next.in;\n\n\t\t\t\t\t\t\t\tconst pos = point.translation;\n\n\t\t\t\t\t\t\t\tconst toPrev = vec2.subtract(vec2.create(), previous, pos);\n\t\t\t\t\t\t\t\tconst toPrevLength = vec2.length(toPrev);\n\t\t\t\t\t\t\t\ttoPrev[0] /= toPrevLength;\n\t\t\t\t\t\t\t\ttoPrev[1] /= toPrevLength;\n\n\t\t\t\t\t\t\t\tconst toNext = vec2.subtract(vec2.create(), next, pos);\n\t\t\t\t\t\t\t\tconst toNextLength = vec2.length(toNext);\n\t\t\t\t\t\t\t\ttoNext[0] /= toNextLength;\n\t\t\t\t\t\t\t\ttoNext[1] /= toNextLength;\n\n\t\t\t\t\t\t\t\tconst renderRadius = Math.min(toPrevLength, Math.min(toNextLength, radius));\n\n\t\t\t\t\t\t\t\tlet translation = vec2.scaleAndAdd(vec2.create(), pos, toPrev, renderRadius);\n\t\t\t\t\t\t\t\tconst current = {\n\t\t\t\t\t\t\t\t\tpointType:PointType.Disconnected,\n\t\t\t\t\t\t\t\t\ttranslation:translation,\n\t\t\t\t\t\t\t\t\tout:vec2.scaleAndAdd(vec2.create(), pos, toPrev, InverseCircleConstant*renderRadius),\n\t\t\t\t\t\t\t\t\tin:translation\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\trenderPoints.push(current);\n\n\t\t\t\t\t\t\t\ttranslation = vec2.scaleAndAdd(vec2.create(), pos, toNext, renderRadius);\n\n\t\t\t\t\t\t\t\tprevious = {\n\t\t\t\t\t\t\t\t\tpointType:PointType.Disconnected,\n\t\t\t\t\t\t\t\t\ttranslation:translation,\n\t\t\t\t\t\t\t\t\tin:vec2.scaleAndAdd(vec2.create(), pos, toNext, InverseCircleConstant*renderRadius),\n\t\t\t\t\t\t\t\t\tout:translation\n\t\t\t\t\t\t\t\t};\n\t\t\t\t\t\t\t\trenderPoints.push(previous);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\trenderPoints.push(point);\n\t\t\t\t\t\t\tprevious = point;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tcase PointType.Mirror:\n\t\t\t\t\tcase PointType.Disconnected:\n\t\t\t\t\tcase PointType.Asymmetric:\n\t\t\t\t\t\trenderPoints.push(point);\n\t\t\t\t\t\tprevious = point;\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\treturn renderPoints;\n\t}\n\n\tgetPathRenderTransform()\n\t{\n\t\tif(!this.isConnectedToBones)\n\t\t{\n\t\t\treturn this.worldTransform;\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\tgetPathTransform()\n\t{\n\t\tif(!this.isConnectedToBones)\n\t\t{\n\t\t\treturn PathMatrix(this.worldTransform);\n\t\t}\n\t\telse\n\t\t{\n\t\t\treturn undefined;\n\t\t}\n\t}\n\n\tinvalidatePath()\n\t{\n\t\tthis._RenderPath = null;\n\t}\n\n\tgetPath()\n\t{\n\t\tconst renderPath = this._RenderPath;\n\t\tif(renderPath)\n\t\t{\n\t\t\treturn renderPath;\n\t\t}\n\n\t\tconst path = new Path2D();\n\t\t\n\t\tconst renderPoints = this.makeRenderPoints();\n\t\tconst isClosed = this.isClosed;\n\n\t\tif(renderPoints.length)\n\t\t{\n\t\t\tlet firstPoint = renderPoints[0];\n\t\t\tpath.moveTo(firstPoint.translation[0], firstPoint.translation[1]);\n\t\t\tfor(let i = 0, l = isClosed ? renderPoints.length : renderPoints.length-1, pl = renderPoints.length; i < l; i++)\n\t\t\t{\n\t\t\t\tlet point = renderPoints[i];\n\t\t\t\tlet nextPoint = renderPoints[(i+1)%pl];\n\t\t\t\tlet cin = nextPoint.pointType === PointType.Straight ? null : nextPoint.in, cout = point.pointType === PointType.Straight ? null : point.out;\n\t\t\t\tif(cin === null && cout === null)\n\t\t\t\t{\n\t\t\t\t\tpath.lineTo(nextPoint.translation[0], nextPoint.translation[1]);\t\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tif(cout === null)\n\t\t\t\t\t{\n\t\t\t\t\t\tcout = point.translation;\n\t\t\t\t\t}\n\t\t\t\t\tif(cin === null)\n\t\t\t\t\t{\n\t\t\t\t\t\tcin = nextPoint.translation;\n\t\t\t\t\t}\n\t\t\t\t\tpath.bezierCurveTo(\n\t\t\t\t\t\tcout[0], cout[1],\n\n\t\t\t\t\t\tcin[0], cin[1],\n\n\t\t\t\t\t\tnextPoint.translation[0], nextPoint.translation[1]);\n\t\t\t\t}\n\t\t\t}\n\t\t\tif(isClosed)\n\t\t\t{\n\t\t\t\tpath.closePath();\n\t\t\t}\n\t\t}\n\n\n\t\tthis._RenderPath = path;\n\t\treturn path;\n\t}\n}","import ActorProceduralPath from \"./ActorProceduralPath.js\";\nimport {vec2} from \"gl-matrix\";\n\nexport default class ActorPolygon extends ActorProceduralPath\n{\n constructor(actor)\n {\n super(actor);\n this._Sides = 5;\n }\n\n resolveComponentIndices(components)\n\t{\n ActorProceduralPath.prototype.resolveComponentIndices.call(this, components);\n }\n \n makeInstance(resetActor)\n\t{\n\t\tconst node = new ActorPolygon();\n node.copy(this, resetActor);\n\t\treturn node;\n }\n \n copy(node, resetActor)\n {\n super.copy(node, resetActor);\n this._Sides = node._Sides;\n }\n\n draw(ctx)\n {\n const transform = this._WorldTransform;\n ctx.save();\n ctx.transform(transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]);\n\n const radiusX = this._Width/2;\n const radiusY = this._Height/2;\n const sides = this._Sides;\n\n ctx.moveTo(0.0, -radiusY);\n let angle = -Math.PI/2.0;\n const inc = (Math.PI*2.0)/sides;\n for(let i = 0; i < sides; i++)\n {\n ctx.lineTo(\n Math.cos(angle)*radiusX,\n Math.sin(angle)*radiusY\n );\n angle += inc;\n }\n ctx.closePath();\n ctx.restore();\n }\n\n getPathAABB() \n {\n let min_x = Number.MAX_VALUE;\n\t\tlet min_y = Number.MAX_VALUE;\n\t\tlet max_x = -Number.MAX_VALUE;\n\t\tlet max_y = -Number.MAX_VALUE;\n \n const transform = this._WorldTransform;\n\n\t\tfunction addPoint(pt)\n\t\t{\n\t\t\tif(transform)\n\t\t\t{\n\t\t\t\tpt = vec2.transformMat2d(vec2.create(), pt, transform);\n\t\t\t}\n\t\t\tif(pt[0] < min_x)\n\t\t\t{\n\t\t\t\tmin_x = pt[0];\n\t\t\t}\n\t\t\tif(pt[1] < min_y)\n\t\t\t{\n\t\t\t\tmin_y = pt[1];\n\t\t\t}\n\t\t\tif(pt[0] > max_x)\n\t\t\t{\n\t\t\t\tmax_x = pt[0];\n\t\t\t}\n\t\t\tif(pt[1] > max_y)\n\t\t\t{\n\t\t\t\tmax_y = pt[1];\n\t\t\t}\n\t\t}\n\n\t\tconst sides = this._Sides;\n\t\tconst radiusX = this.width/2;\n\t\tconst radiusY = this.height/2;\n\t\tlet angle = -Math.PI/2.0;\n\t\tlet inc = (Math.PI*2.0)/sides;\n\t\taddPoint([0.0, -radiusY]);\n\t\tfor(let i = 0; i < sides; i++)\n\t\t{\n\t\t\taddPoint([Math.cos(angle)*radiusX, Math.sin(angle)*radiusY]);\n\t\t\tangle += inc;\n\t\t}\n\n\t\treturn [vec2.fromValues(min_x, min_y), vec2.fromValues(max_x, max_y)]; \n }\n}","import ActorNode from \"./ActorNode.js\";\nimport {vec2} from \"gl-matrix\";\nimport PathMatrix from \"./PathMatrix.js\";\n\nexport default class ActorProceduralPath extends ActorNode\n{\n constructor(actor)\n {\n super(actor);\n this._Width = 0;\n this._Height = 0;\n }\n\n get width()\n {\n return this._Width;\n }\n\n get height()\n {\n return this._Height;\n }\n \n resolveComponentIndices(components)\n\t{\n ActorNode.prototype.resolveComponentIndices.call(this, components);\n }\n \n makeInstance(resetActor)\n {\n const node = ActorProceduralPath();\n ActorProceduralPath.prototype.copy.call(node, this, resetActor);\n return node;\n }\n\n getPathTransform()\n\t{\n return PathMatrix(this._WorldTransform);\n }\n \n getPathRenderTransform()\n\t{\n\t\treturn this.worldTransform;\n\t}\n\n getPathAABB()\n {\n let min_x = Number.MAX_VALUE;\n let min_y = Number.MAX_VALUE;\n let max_x = Number.MIN_VALUE;\n let max_y = Number.MIN_VALUE;\n\n const transform = this._Transform;\n function addPoint(point)\n {\n if(transform)\n {\n point = vec2.transformMat2d(vec2.create(), point, transform);\n }\n\n if(point[0] < min_x)\n\t\t\t{\n\t\t\t\tmin_x = point[0];\n\t\t\t}\n\t\t\tif(point[1] < min_y)\n\t\t\t{\n\t\t\t\tmin_y = point[1];\n\t\t\t}\n\t\t\tif(point[0] > max_x)\n\t\t\t{\n\t\t\t\tmax_x = point[0];\n\t\t\t}\n\t\t\tif(point[1] > max_y)\n\t\t\t{\n\t\t\t\tmax_y = point[1];\n\t\t\t}\n }\n\n const radiusX = this._Width/2;\n const radiusY = this._Height/2;\n addPoint([-radiusX, -radiusY]);\n addPoint([radiusX, -radiusY]);\n addPoint([-radiusX, radiusY]);\n addPoint([radiusX, radiusY]);\n\n return [min_x, min_y, max_x, max_y];\n }\n\n copy(node, resetActor)\n {\n super.copy(node, resetActor);\n\n this._Width = node._Width;\n this._Height = node._Height;\n }\n}","import ActorProceduralPath from \"./ActorProceduralPath.js\";\n\nexport default class ActorRectangle extends ActorProceduralPath\n{\n constructor(actor)\n {\n super(actor);\n this._CornerRadius = 0.0;\n }\n\n resolveComponentIndices(components)\n\t{\n ActorProceduralPath.prototype.resolveComponentIndices.call(this, components);\n }\n \n makeInstance(resetActor)\n\t{\n\t\tconst node = new ActorRectangle();\n node.copy(this, resetActor);\n\t\treturn node;\n }\n \n copy(node, resetActor)\n {\n super.copy(node, resetActor);\n this._CornerRadius = node._CornerRadius;\n }\n\n draw(ctx)\n {\n const transform = this._WorldTransform;\n ctx.save();\n ctx.transform(transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]);\n\n const halfWidth = Math.max(0, this._Width/2);\n const halfHeight = Math.max(0, this._Height/2);\n ctx.moveTo(-halfWidth, -halfHeight);\n let r = this._CornerRadius;\n if(r > 0)\n {\n this._DrawRoundedRect(ctx, -halfWidth, -halfHeight, this._Width, this._Height, r);\n }\n else\n {\n ctx.rect(-halfWidth, -halfHeight, this._Width, this._Height);\n }\n ctx.restore();\n }\n\n _DrawRoundedRect(ctx, x, y, width, height, radius) \n {\n if (width < 2 * radius) radius = width / 2;\n if (height < 2 * radius) radius = height / 2;\n ctx.beginPath();\n ctx.moveTo(x + radius, y);\n ctx.arcTo(x + width, y, x + width, y + height, radius);\n ctx.arcTo(x + width, y + height, x, y + height, radius);\n ctx.arcTo(x, y + height, x, y, radius);\n ctx.arcTo(x, y, x + width, y, radius);\n ctx.closePath();\n }\n\n getPath()\n {\n let {width, height, _CornerRadius:radius} = this;\n const halfWidth = width/2;\n const halfHeight = height/2;\n const x = -halfWidth;\n const y = -halfHeight;\n const path = new Path2D();\n if(radius > 0.0)\n {\n if (width < 2 * radius) radius = width / 2;\n if (height < 2 * radius) radius = height / 2;\n path.moveTo(x + radius, y);\n path.arcTo(x + width, y, x + width, y + height, radius);\n path.arcTo(x + width, y + height, x, y + height, radius);\n path.arcTo(x, y + height, x, y, radius);\n path.arcTo(x, y, x + width, y, radius);\n path.closePath();\n }\n else\n {\n path.rect(-halfWidth, -halfHeight, width, height);\n }\n return path;\n }\n}","import ActorNode from \"./ActorNode.js\";\n\nexport default class ActorRootBone extends ActorNode\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t}\n\t\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorRootBone();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t}\n}","import ActorTargetedConstraint from \"./ActorTargetedConstraint.js\";\nimport { vec2, mat2d } from \"gl-matrix\";\nimport { Decompose, Compose } from \"./Decompose.js\";\nimport TransformSpace from \"./TransformSpace.js\";\n\nconst PI2 = Math.PI*2;\n\nexport default class ActorRotationConstraint extends ActorTargetedConstraint\n{\n\tconstructor(actor)\n\t{\n\t\tsuper(actor);\n\n\t\tthis._Copy = false;\n\t\tthis._EnableMin = false;\n\t\tthis._EnableMax = false;\n\t\tthis._Offset = false;\n\n\t\tthis._Min = -PI2;\n\t\tthis._Max = PI2;\n\t\tthis._Scale = 1.0;\n\n\t\tthis._SourceSpace = TransformSpace.World;\n\t\tthis._DestSpace = TransformSpace.World;\n\t\tthis._MinMaxSpace = TransformSpace.World;\n\n\t\tthis._ComponentsA = new Float32Array(6);\n\t\tthis._ComponentsB = new Float32Array(6);\n\n\t}\n\n\tonDirty(dirt)\n\t{\n\t\tthis.markDirty();\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorRotationConstraint();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._Copy = node._Copy;\n\t\tthis._EnableMin = node._EnableMin;\n\t\tthis._EnableMax = node._EnableMax;\n\t\tthis._Offset = node._Offset;\n\n\t\tthis._Min = node._Min;\n\t\tthis._Max = node._Max;\n\t\tthis._Scale = node._Scale;\n\n\t\tthis._SourceSpace = node._SourceSpace;\n\t\tthis._DestSpace = node._DestSpace;\n\t\tthis._MinMaxSpace = node._MinMaxSpace;\n\t}\n\n\tconstrain(tip)\n\t{\n\t\tlet target = this._Target;\n\n\t\tlet parent = this._Parent;\n\t\tlet grandParent = parent._Parent;\n\n\t\tlet { _ComponentsA:componentsA, _ComponentsB:componentsB, _Strength:t, _SourceSpace:sourceSpace, _DestSpace:destSpace , _MinMaxSpace:minMaxSpace } = this;\n\n\n\t\tlet transformA = parent.worldTransform;\n\t\tlet transformB = mat2d.create();\n\t\tDecompose(transformA, componentsA);\n\t\tif(!target)\n\t\t{\n\t\t\tmat2d.copy(transformB, transformA);\n\t\t\tcomponentsB[0] = componentsA[0];\n\t\t\tcomponentsB[1] = componentsA[1];\n\t\t\tcomponentsB[2] = componentsA[2];\n\t\t\tcomponentsB[3] = componentsA[3];\n\t\t\tcomponentsB[4] = componentsA[4];\n\t\t\tcomponentsB[5] = componentsA[5];\n\t\t}\n\t\telse\n\t\t{\n\t\t\tmat2d.copy(transformB, target.worldTransform);\n\t\t\tif(sourceSpace === TransformSpace.Local)\n\t\t\t{\n\t\t\t\tlet sourceGrandParent = target.parent;\n\t\t\t\tif(sourceGrandParent)\n\t\t\t\t{\n\t\t\t\t\tlet inverse = mat2d.invert(mat2d.create(), sourceGrandParent.worldTransform);\n\t\t\t\t\ttransformB = mat2d.mul(inverse, inverse, transformB);\n\t\t\t\t}\n\t\t\t}\n\t\t\tDecompose(transformB, componentsB);\n\n\t\t\tif(!this._Copy)\n\t\t\t{\n\t\t\t\tcomponentsB[4] = destSpace === TransformSpace.Local ? 0.0 : componentsA[4];\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tcomponentsB[4] *= this._Scale;\t\n\t\t\t\tif(this._Offset)\n\t\t\t\t{\n\t\t\t\t\tcomponentsB[4] += parent._Rotation;\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif(destSpace === TransformSpace.Local)\n\t\t\t{\n\t\t\t\t// Destination space is in parent transform coordinates.\n\t\t\t\t// Recompose the parent local transform and get it in world, then decompose the world for interpolation.\n\t\t\t\tif(grandParent)\n\t\t\t\t{\n\t\t\t\t\tCompose(transformB, componentsB);\n\t\t\t\t\tmat2d.mul(transformB, grandParent.worldTransform, transformB);\n\t\t\t\t\tDecompose(transformB, componentsB);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t\n\t\tlet clampLocal = (minMaxSpace === TransformSpace.Local && grandParent) ? true : false;\n\t\tif(clampLocal)\n\t\t{\n\t\t\t// Apply min max in local space, so transform to local coordinates first.\n\t\t\tCompose(transformB, componentsB);\n\t\t\tlet inverse = mat2d.invert(mat2d.create(), grandParent.worldTransform);\n\t\t\tmat2d.mul(transformB, inverse, transformB);\n\t\t\tDecompose(transformB, componentsB);\n\t\t}\n\t\tif(this._EnableMax && componentsB[4] > this._Max)\n\t\t{\n\t\t\tcomponentsB[4] = this._Max;\n\t\t}\n\t\tif(this._EnableMin && componentsB[4] < this._Min)\n\t\t{\n\t\t\tcomponentsB[4] = this._Min;\n\t\t}\n\t\tif(clampLocal)\n\t\t{\n\t\t\t// Transform back to world.\n\t\t\tCompose(transformB, componentsB);\n\t\t\tmat2d.mul(transformB, grandParent.worldTransform, transformB);\n\t\t\tDecompose(transformB, componentsB);\n\t\t}\n\n\t\tlet angleA = componentsA[4]%PI2;\n\t\tlet angleB = componentsB[4]%PI2;\n\t\tlet diff = angleB - angleA;\n\t\tif(diff > Math.PI)\n\t\t{\n\t\t\tdiff -= PI2;\n\t\t}\n\t\telse if(diff < -Math.PI)\n\t\t{\n\t\t\tdiff += PI2;\n\t\t}\n\n\t\tcomponentsB[4] = angleA + diff * t;\n\t\tcomponentsB[0] = componentsA[0];\n\t\tcomponentsB[1] = componentsA[1];\n\t\tcomponentsB[2] = componentsA[2];\n\t\tcomponentsB[3] = componentsA[3];\n\t\tcomponentsB[5] = componentsA[5];\n\n\t\tCompose(parent.worldTransform, componentsB);\n\t}\n}","import ActorAxisConstraint from \"./ActorAxisConstraint.js\";\nimport { vec2, mat2d } from \"gl-matrix\";\nimport TransformSpace from \"./TransformSpace.js\";\nimport { Decompose, Compose } from \"./Decompose.js\";\n\nexport default class ActorScaleConstraint extends ActorAxisConstraint\n{\n\tconstructor(actor)\n\t{\n\t\tsuper(actor);\n\n\t\tthis._ComponentsA = new Float32Array(6);\n\t\tthis._ComponentsB = new Float32Array(6);\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorScaleConstraint();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tconstrain(tip)\n\t{\n\t\tlet target = this._Target;\n\n\t\tlet parent = this._Parent;\n\t\tlet grandParent = parent._Parent;\n\n\t\tlet { _ComponentsA:componentsA, _ComponentsB:componentsB,_Strength:t, _SourceSpace:sourceSpace, _DestSpace:destSpace , _MinMaxSpace:minMaxSpace } = this;\n\n\t\tlet transformA = parent.worldTransform;\n\t\tlet transformB = mat2d.create();\n\t\tDecompose(transformA, componentsA);\n\t\tif(!target)\n\t\t{\n\t\t\tmat2d.copy(transformB, transformA);\n\t\t\tcomponentsB[0] = componentsA[0];\n\t\t\tcomponentsB[1] = componentsA[1];\n\t\t\tcomponentsB[2] = componentsA[2];\n\t\t\tcomponentsB[3] = componentsA[3];\n\t\t\tcomponentsB[4] = componentsA[4];\n\t\t\tcomponentsB[5] = componentsA[5];\n\t\t}\n\t\telse\n\t\t{\n\t\t\tmat2d.copy(transformB, target.worldTransform);\n\t\t\tif(sourceSpace === TransformSpace.Local)\n\t\t\t{\n\t\t\t\tlet sourceGrandParent = target.parent;\n\t\t\t\tif(sourceGrandParent)\n\t\t\t\t{\n\t\t\t\t\tlet inverse = mat2d.invert(mat2d.create(), sourceGrandParent.worldTransform);\n\t\t\t\t\ttransformB = mat2d.mul(inverse, inverse, transformB);\n\t\t\t\t}\n\t\t\t}\n\t\t\tDecompose(transformB, componentsB);\n\n\t\t\tif(!this._CopyX)\n\t\t\t{\n\t\t\t\tcomponentsB[2] = destSpace === TransformSpace.Local ? 1.0 : componentsA[2];\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tcomponentsB[2] *= this._ScaleX;\t\n\t\t\t\tif(this._Offset)\n\t\t\t\t{\n\t\t\t\t\tcomponentsB[2] *= parent._Scale[0];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif(!this._CopyY)\n\t\t\t{\n\t\t\t\tcomponentsB[3] = destSpace === TransformSpace.Local ? 0.0 : componentsA[3];\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tcomponentsB[3] *= this._ScaleY;\n\n\t\t\t\tif(this._Offset)\n\t\t\t\t{\n\t\t\t\t\tcomponentsB[3] *= parent._Scale[1];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif(destSpace === TransformSpace.Local)\n\t\t\t{\n\t\t\t\t// Destination space is in parent transform coordinates.\n\t\t\t\t// Recompose the parent local transform and get it in world, then decompose the world for interpolation.\n\t\t\t\tif(grandParent)\n\t\t\t\t{\n\t\t\t\t\tCompose(transformB, componentsB);\n\t\t\t\t\tmat2d.mul(transformB, grandParent.worldTransform, transformB);\n\t\t\t\t\tDecompose(transformB, componentsB);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t\n\t\tlet clampLocal = (minMaxSpace === TransformSpace.Local && grandParent) ? true : false;\n\t\tif(clampLocal)\n\t\t{\n\t\t\t// Apply min max in local space, so transform to local coordinates first.\n\t\t\tCompose(transformB, componentsB);\n\t\t\tlet inverse = mat2d.invert(mat2d.create(), grandParent.worldTransform);\n\t\t\tmat2d.mul(transformB, inverse, transformB);\n\t\t\tDecompose(transformB, componentsB);\n\t\t}\n\t\tif(this._EnableMaxX && componentsB[2] > this._MaxX)\n\t\t{\n\t\t\tcomponentsB[2] = this._MaxX;\t\n\t\t}\n\t\tif(this._EnableMinX && componentsB[2] < this._MinX)\n\t\t{\n\t\t\tcomponentsB[2] = this._MinX;\t\n\t\t}\n\t\tif(this._EnableMaxY && componentsB[3] > this._MaxY)\n\t\t{\n\t\t\tcomponentsB[3] = this._MaxY;\t\n\t\t}\n\t\tif(this._EnableMinY && componentsB[3] < this._MinY)\n\t\t{\n\t\t\tcomponentsB[3] = this._MinY;\t\n\t\t}\n\t\tif(clampLocal)\n\t\t{\n\t\t\t// Transform back to world.\n\t\t\tCompose(transformB, componentsB);\n\t\t\tmat2d.mul(transformB, grandParent.worldTransform, transformB);\n\t\t\tDecompose(transformB, componentsB);\n\t\t}\n\n\t\tlet ti = 1.0-t;\n\n\t\tcomponentsB[4] = componentsA[4];\n\t\tcomponentsB[0] = componentsA[0];\n\t\tcomponentsB[1] = componentsA[1];\n\t\tcomponentsB[2] = componentsA[2] * ti + componentsB[2] * t;\n\t\tcomponentsB[3] = componentsA[3] * ti + componentsB[3] * t;\n\t\tcomponentsB[5] = componentsA[5];\n\n\t\tCompose(parent.worldTransform, componentsB);\n\t}\n}","import ActorNode from \"./ActorNode.js\";\nimport ActorPath from \"./ActorPath.js\";\nimport ActorProceduralPath from \"./ActorProceduralPath.js\";\nimport {RadialGradientFill, GradientFill, ColorFill, ColorStroke, GradientStroke, RadialGradientStroke} from \"./ColorComponent.js\";\n\nimport {vec2, mat2d} from \"gl-matrix\";\n\nexport default class ActorShape extends ActorNode\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._DrawOrder = 0;\n\t\tthis._IsHidden = false;\n\n\t\tthis._Paths = null;\n\t\tthis._Fills = null;\n\t\tthis._Strokes = null;\n\t}\n\n\tget paths()\n\t{\n\t\treturn this._Paths;\n\t}\n\n\taddFill(fill)\n\t{\n\t\tif(!this._Fills)\n\t\t{\n\t\t\tthis._Fills = [];\n\t\t}\n\t\tthis._Fills.push(fill);\n\t}\n\n\taddStroke(stroke)\n\t{\n\t\tif(!this._Strokes)\n\t\t{\n\t\t\tthis._Strokes = [];\n\t\t}\n\t\tthis._Strokes.push(stroke);\n\t}\n\n\tget isHidden()\n\t{\n\t\treturn this._IsHidden;\n\t}\n\n\tset isHidden(hidden)\n\t{\n\t\tthis._IsHidden = hidden;\n\t}\n\n\tinitialize(actor, graphics)\n\t{\n\t\t\n\t}\n\n\tcomputeAABB()\n\t{\n\t\tconst clips = this.getClips();\n\t\tif(clips)\n\t\t{\n\t\t\tlet aabb = null;\n\t\t\tfor(const clip of clips)\n\t\t\t{\n\t\t\t\tclip.all(function(node)\n\t\t\t\t{\n\t\t\t\t\tif(node.constructor === ActorShape)\n\t\t\t\t\t{\n\t\t\t\t\t\tlet bounds = node.computeAABB();\n\t\t\t\t\t\tif(!aabb)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\taabb = bounds;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tif(bounds[0] < aabb[0])\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\taabb[0] = bounds[0];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif(bounds[1] < aabb[1])\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\taabb[1] = bounds[1];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif(bounds[2] > aabb[2])\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\taabb[2] = bounds[2];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tif(bounds[3] > aabb[3])\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\taabb[3] = bounds[3];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t}\n\t\t\treturn aabb;\n\t\t}\n\n\t\tlet aabb = null;\n\t\tlet maxStroke = 0.0;\n\t\tif(this._Strokes)\n\t\t{\n\t\t\tfor(const stroke of this._Strokes)\n\t\t\t{\n\t\t\t\tif(stroke.width > maxStroke)\n\t\t\t\t{\n\t\t\t\t\tmaxStroke = stroke.width;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\tfor(const path of this._Children)\n\t\t{\n\t\t\tif (path.constructor !== ActorPath && !(path instanceof ActorProceduralPath))\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tif(path.numPoints < 2)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\t// This is the axis aligned bounding box in the space of the parent (this case our shape).\n\t\t\tconst pathAABB = path.getPathAABB();\n\n\t\t\tif(!aabb)\n\t\t\t{\n\t\t\t\taabb = pathAABB;\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\t// Combine.\n\t\t\t\taabb[0] = Math.min(aabb[0], pathAABB[0]);\n\t\t\t\taabb[1] = Math.min(aabb[1], pathAABB[1]);\n\n\t\t\t\taabb[2] = Math.max(aabb[2], pathAABB[2]);\n\t\t\t\taabb[3] = Math.max(aabb[3], pathAABB[3]);\n\t\t\t}\n\t\t}\n\n\t\tconst padStroke = maxStroke/2.0;\n\t\taabb[0] -= padStroke;\n\t\taabb[1] -= padStroke;\n\t\taabb[2] += padStroke;\n\t\taabb[3] += padStroke;\n\n\t\tlet min_x = Number.MAX_VALUE;\n\t\tlet min_y = Number.MAX_VALUE;\n\t\tlet max_x = -Number.MAX_VALUE;\n\t\tlet max_y = -Number.MAX_VALUE;\n\n\t\tif(!aabb)\n\t\t{\n\t\t\treturn null;\n\t\t}\n\t\tlet world = this._WorldTransform;\n\n\n\t\tconst points = [\n\t\t\tvec2.set(vec2.create(), aabb[0], aabb[1]),\n\t\t\tvec2.set(vec2.create(), aabb[2], aabb[1]),\n\t\t\tvec2.set(vec2.create(), aabb[2], aabb[3]),\n\t\t\tvec2.set(vec2.create(), aabb[0], aabb[3])\n\t\t];\n\t\tfor(let i = 0; i < points.length; i++)\n\t\t{\n\t\t\tconst pt = points[i];\n\t\t\tconst wp = vec2.transformMat2d(pt, pt, world);\n\t\t\tif(wp[0] < min_x)\n\t\t\t{\n\t\t\t\tmin_x = wp[0];\n\t\t\t}\n\t\t\tif(wp[1] < min_y)\n\t\t\t{\n\t\t\t\tmin_y = wp[1];\n\t\t\t}\n\n\t\t\tif(wp[0] > max_x)\n\t\t\t{\n\t\t\t\tmax_x = wp[0];\n\t\t\t}\n\t\t\tif(wp[1] > max_y)\n\t\t\t{\n\t\t\t\tmax_y = wp[1];\n\t\t\t}\n\t\t}\n\n\t\treturn new Float32Array([min_x, min_y, max_x, max_y]);\n\t}\n\n\tdispose(actor, graphics)\n\t{\n\n\t}\n\n\tdraw(graphics)\n\t{\n\t\tif(this._RenderCollapsed || this._IsHidden)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tconst ctx = graphics.ctx;\n\t\tctx.save();\n\t\tctx.globalAlpha = this._RenderOpacity;\n\t\tthis.clip(ctx);\n\t\tconst shapePath = this.getShapePath();\n\n\t\tconst {_Fills:fills, _Strokes:strokes} = this;\n\t\t\n\t\tif(fills)\n\t\t{\n\t\t\tfor(const fill of fills)\n\t\t\t{\n\t\t\t\tfill.fill(ctx, shapePath);\n\t\t\t}\n\t\t}\n\t\tif(strokes)\n\t\t{\n\t\t\tfor(const stroke of strokes)\n\t\t\t{\n\t\t\t\tif(stroke._Width > 0)\n\t\t\t\t{\n\t\t\t\t\tstroke.stroke(ctx, shapePath);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\t// const aabb = this.computeAABB();\n\t\t// if(aabb)\n\t\t// {\n\t\t// \tctx.fillStyle = \"rgba(255,0,0,0.25)\";\n\t\t// \tctx.beginPath();\n\t\t// \tctx.moveTo(aabb[0], aabb[1]);\n\t\t// \tctx.lineTo(aabb[2], aabb[1]);\n\t\t// \tctx.lineTo(aabb[2], aabb[3]);\n\t\t// \tctx.lineTo(aabb[0], aabb[3]);\n\t\t// \tctx.closePath();\n\t\t// \tctx.fill();\n\t\t// }\n\t\tctx.restore();\n\t}\n\n\tgetShapePath()\n\t{\n\t\tconst paths = this._Paths;\n\t\tconst shapePath = new Path2D();\n\t\tfor(const path of paths)\n\t\t{\n\t\t\tif(path.isHidden)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\t\t\tshapePath.addPath(path.getPath(), path.getPathTransform());\n\t\t}\n\n\t\treturn shapePath;\n\t}\n\n\tgetClips()\n\t{\n\t\t// Find clips.\n\t\tlet clipSearch = this;\n\t\tlet clips = null;\n\t\twhile(clipSearch)\n\t\t{\n\t\t\tif(clipSearch._Clips)\n\t\t\t{\n\t\t\t\tclips = clipSearch._Clips;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t\tclipSearch = clipSearch.parent;\n\t\t}\n\n\t\treturn clips;\n\t}\n\t\n\tclip(ctx)\n\t{\n\t\t// Find clips.\n\t\tconst clips = this.getClips();\n\n\t\tif(clips)\n\t\t{\n\t\t\tconst clipPath = new Path2D();\n\t\t\tfor(let clip of clips)\n\t\t\t{\n\t\t\t\tlet shapes = new Set();\n\t\t\t\tclip.all(function(node)\n\t\t\t\t{\n\t\t\t\t\tif(node.constructor === ActorShape)\n\t\t\t\t\t{\n\t\t\t\t\t\tshapes.add(node);\n\t\t\t\t\t}\n\t\t\t\t});\n\t\t\t\tfor(let shape of shapes)\n\t\t\t\t{\n\t\t\t\t\tconst paths = shape.paths;\n\t\t\t\t\tfor(const path of paths)\n\t\t\t\t\t{\n\t\t\t\t\t\tclipPath.addPath(path.getPath(), path.getPathTransform());\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t\tctx.clip(clipPath);\n\t\t}\n\t}\n\n\tcompleteResolve()\n\t{\n\t\tsuper.completeResolve();\n\t\tthis._Paths = this._Children.filter(child => child.constructor === ActorPath || (child instanceof ActorProceduralPath));\n\t}\t\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorShape();\n\t\tnode._IsInstance = true;\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._DrawOrder = node._DrawOrder;\n\t\tthis._IsHidden = node._IsHidden;\n\t}\n}","import ActorComponent from \"./ActorComponent.js\";\nimport {mat2d} from \"gl-matrix\";\n\nexport default class ActorSkin extends ActorComponent\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._BoneMatrices = null;\n\t}\n\n\tget boneMatrices()\n\t{\n\t\treturn this._BoneMatrices;\n\t}\n\n\tupdate(dirt)\n\t{\n\t\tconst parent = this._Parent;\n\t\t\n\t\tif(parent && parent._ConnectedBones)\n\t\t{\n\t\t\tconst connectedBones = parent._ConnectedBones;\n\t\t\tconst length = (connectedBones.length+1) * 6;\n\t\t\tlet bt = this._BoneMatrices;\n\t\t\tif(!bt || bt.length !== length)\n\t\t\t{\n\t\t\t\tthis._BoneMatrices = bt = new Float32Array(length);\n\t\t\t\t// First bone transform is always identity.\n\t\t\t\tbt[0] = 1;\n\t\t\t\tbt[1] = 0;\n\t\t\t\tbt[2] = 0;\n\t\t\t\tbt[3] = 1;\n\t\t\t\tbt[4] = 0;\n\t\t\t\tbt[5] = 0;\n\t\t\t}\n\n\t\t\tlet bidx = 6; // Start after first identity.\n\n\t\t\tconst mat = mat2d.create();\n\n\t\t\tfor(const cb of connectedBones)\n\t\t\t{\n\t\t\t\tif(!cb.node)\n\t\t\t\t{\n\t\t\t\t\tbt[bidx++] = 1;\n\t\t\t\t\tbt[bidx++] = 0;\n\t\t\t\t\tbt[bidx++] = 0;\n\t\t\t\t\tbt[bidx++] = 1;\n\t\t\t\t\tbt[bidx++] = 0;\n\t\t\t\t\tbt[bidx++] = 0;\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tconst wt = mat2d.mul(mat, cb.node._WorldTransform, cb.ibind);\n\n\t\t\t\tbt[bidx++] = wt[0];\n\t\t\t\tbt[bidx++] = wt[1];\n\t\t\t\tbt[bidx++] = wt[2];\n\t\t\t\tbt[bidx++] = wt[3];\n\t\t\t\tbt[bidx++] = wt[4];\n\t\t\t\tbt[bidx++] = wt[5];\n\t\t\t}\n\t\t}\n\n\t\tparent.invalidatePath();\n\t}\n\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorSkin();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcompleteResolve()\n\t{\n\t\tsuper.completeResolve();\n\t\tconst graph = this._Actor;\n\t\tlet path = this._Parent;\n\t\tif(path)\n\t\t{\n\t\t\tpath.setSkin(this);\n\t\t\tgraph.addDependency(this, path);\n\t\t\tconst connectedBones = path.connectedBones;\n\t\t\tif(connectedBones && connectedBones.length)\n\t\t\t{\n\t\t\t\tfor(const {node} of connectedBones)\n\t\t\t\t{\n\t\t\t\t\tgraph.addDependency(this, node);\n\t\t\t\t\tconst constraints = node.allConstraints;\n\t\t\t\t\t\t\t\t\n\t\t\t\t\tif(constraints)\n\t\t\t\t\t{\n\t\t\t\t\t\tfor(const constraint of constraints)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tgraph.addDependency(this, constraint);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}","import ActorNode from \"./ActorNode.js\";\n\nexport default class ActorSkinnableNode extends ActorNode\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._ConnectedBones = null;\n\t}\n\n\tget connectedBones()\n\t{\n\t\treturn this._ConnectedBones;\n\t}\n\n\tget isConnectedToBones()\n\t{\n\t\treturn this._ConnectedBones && this._ConnectedBones.length > 0;\n\t}\n\t\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\t\tif(this._ConnectedBones)\n\t\t{\n\t\t\tfor(let j = 0; j < this._ConnectedBones.length; j++)\n\t\t\t{\n\t\t\t\tconst cb = this._ConnectedBones[j];\n\t\t\t\tcb.node = components[cb.componentIndex];\n\t\t\t}\n\t\t}\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tif(node._ConnectedBones)\n\t\t{\n\t\t\tthis._ConnectedBones = [];\n\t\t\tfor(const cb of node._ConnectedBones)\n\t\t\t{\n\t\t\t\t// Copy all props except for the actual node reference which will update in our resolve.\n\t\t\t\tthis._ConnectedBones.push({\n\t\t\t\t\t\tcomponentIndex:cb.componentIndex,\n\t\t\t\t\t\tbind:cb.bind,\n\t\t\t\t\t\tibind:cb.ibind\n\t\t\t\t\t});\n\t\t\t}\n\t\t}\n\t}\n}","import ActorProceduralPath from \"./ActorProceduralPath.js\";\nimport {vec2} from \"gl-matrix\";\n\nexport default class ActorStar extends ActorProceduralPath\n{\n constructor(actor)\n {\n super(actor);\n this._Points = 5;\n this._InnerRadius = 0.0;\n }\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorStar();\n node.copy(this, resetActor);\n\t\treturn node;\n }\n \n copy(node, resetActor)\n {\n super.copy(node, resetActor);\n this._Points = node._Points;\n this._InnerRadius = node._InnerRadius;\n }\n\n getOBB(transform)\n\t{\n\t\tlet min_x = Number.MAX_VALUE;\n\t\tlet min_y = Number.MAX_VALUE;\n\t\tlet max_x = -Number.MAX_VALUE;\n\t\tlet max_y = -Number.MAX_VALUE;\n\n\t\tfunction addPoint(pt)\n\t\t{\n\t\t\tif(transform)\n\t\t\t{\n\t\t\t\tpt = vec2.transformMat2d(vec2.create(), pt, transform);\n\t\t\t}\n\t\t\tif(pt[0] < min_x)\n\t\t\t{\n\t\t\t\tmin_x = pt[0];\n\t\t\t}\n\t\t\tif(pt[1] < min_y)\n\t\t\t{\n\t\t\t\tmin_y = pt[1];\n\t\t\t}\n\t\t\tif(pt[0] > max_x)\n\t\t\t{\n\t\t\t\tmax_x = pt[0];\n\t\t\t}\n\t\t\tif(pt[1] > max_y)\n\t\t\t{\n\t\t\t\tmax_y = pt[1];\n\t\t\t}\n }\n \n\t\tconst radiusX = this.width/2;\n const radiusY = this.height/2;\n \n let angle = -Math.PI/2.0;\n \n const inc = (Math.PI*2.0)/this.sides;\n\n const sx = [radiusX, radiusX*this._InnerRadius];\n const sy = [radiusY, radiusY*this._InnerRadius];\n addPoint([0.0, -radiusY]);\n for(let i = 0; i < this.sides; i++)\n {\n addPoint([Math.cos(angle)*sx[i%2], Math.sin(angle)*sy[i%2]]);\n angle += inc;\n }\n\n\t\treturn [vec2.fromValues(min_x, min_y), vec2.fromValues(max_x, max_y)];\n }\n \n getPath()\n {\n //const transform = this._WorldTransform;\n const radius = this._InnerRadius;\n\n const path = new Path2D();\n \n //ctx.save();\n\t\t//ctx.transform(transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]);\n\t\tconst radiusX = this._Width/2;\n\t\tconst radiusY = this._Height/2;\n\n path.moveTo(0.0, -radiusY);\n \n const inc = (Math.PI*2.0)/this.sides;\n const sx = [radiusX, radiusX*radius];\n const sy = [radiusY, radiusY*radius];\n\n let angle = -Math.PI/2.0;\n for(let i = 0; i < this.sides; i++)\n {\n path.lineTo(Math.cos(angle)*sx[i%2], Math.sin(angle)*sy[i%2]);\n angle += inc;\n }\n\t\tpath.closePath();\n //ctx.restore();\n return path;\n }\n\n get sides()\n {\n return this._Points * 2;\n }\n}","import ActorConstraint from \"./ActorConstraint.js\";\n\nexport default class ActorTargetedConstraint extends ActorConstraint\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\n\t\tthis._TargetIdx = 0;\n\t\tthis._Target = null;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorTargetedConstraint();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._TargetIdx = node._TargetIdx;\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\n\t\tif(this._TargetIdx !== 0)\n\t\t{\n\t\t\tconst target = components[this._TargetIdx];\n\t\t\tif(target)\n\t\t\t{\n\t\t\t\tthis._Target = target;\n\t\t\t\t// Add dependency on target.\n\t\t\t\tthis._Actor.addDependency(this._Parent, target);\n\t\t\t}\n\t\t}\n\n\t}\n}","import ActorTargetedConstraint from \"./ActorTargetedConstraint.js\";\nimport { mat2d } from \"gl-matrix\";\nimport { Decompose, Compose } from \"./Decompose.js\";\nimport TransformSpace from \"./TransformSpace.js\";\n\nconst PI2 = Math.PI*2;\n\nexport default class ActorTransformConstraint extends ActorTargetedConstraint\n{\n\tconstructor(actor)\n\t{\n\t\tsuper(actor);\n\n\t\tthis._SourceSpace = TransformSpace.World;\n\t\tthis._DestSpace = TransformSpace.World;\n\n\t\tthis._ComponentsA = new Float32Array(6);\n\t\tthis._ComponentsB = new Float32Array(6);\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorTransformConstraint();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._SourceSpace = node._SourceSpace;\n\t\tthis._DestSpace = node._DestSpace;\n\t}\n\n\tconstrain(tip)\n\t{\n\t\tlet target = this._Target;\n\t\tif(!target)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tlet parent = this._Parent;\n\n\t\tlet { _ComponentsA:componentsA, _ComponentsB:componentsB, _Strength:t, _SourceSpace:sourceSpace, _DestSpace:destSpace } = this;\n\n\t\tlet transformA = parent.worldTransform;\n\t\tlet transformB = mat2d.clone(target.worldTransform);\n\t\tif(sourceSpace === TransformSpace.Local)\n\t\t{\n\t\t\tlet grandParent = target.parent;\n\t\t\tif(grandParent)\n\t\t\t{\n\t\t\t\tlet inverse = mat2d.invert(mat2d.create(), grandParent.worldTransform);\n\t\t\t\ttransformB = mat2d.mul(inverse, inverse, transformB);\n\t\t\t}\n\t\t}\n\t\tif(destSpace === TransformSpace.Local)\n\t\t{\n\t\t\tlet grandParent = parent.parent;\n\t\t\tif(grandParent)\n\t\t\t{\n\t\t\t\tmat2d.mul(transformB, grandParent.worldTransform, transformB);\n\t\t\t}\n\t\t}\n\t\tDecompose(transformA, componentsA);\n\t\tDecompose(transformB, componentsB);\n\n\t\tlet angleA = componentsA[4]%PI2;\n\t\tlet angleB = componentsB[4]%PI2;\n\t\tlet diff = angleB - angleA;\n\t\tif(diff > Math.PI)\n\t\t{\n\t\t\tdiff -= PI2;\n\t\t}\n\t\telse if(diff < -Math.PI)\n\t\t{\n\t\t\tdiff += PI2;\n\t\t}\n\n\t\tlet ti = 1.0-t;\n\n\t\tcomponentsB[4] = angleA + diff * t;\n\t\tcomponentsB[0] = componentsA[0] * ti + componentsB[0] * t;\n\t\tcomponentsB[1] = componentsA[1] * ti + componentsB[1] * t;\n\t\tcomponentsB[2] = componentsA[2] * ti + componentsB[2] * t;\n\t\tcomponentsB[3] = componentsA[3] * ti + componentsB[3] * t;\n\t\tcomponentsB[5] = componentsA[5] * ti + componentsB[5] * t;\n\n\t\tCompose(parent.worldTransform, componentsB);\n\t}\n}","import ActorAxisConstraint from \"./ActorAxisConstraint.js\";\nimport { vec2, mat2d } from \"gl-matrix\";\nimport TransformSpace from \"./TransformSpace.js\";\n\nexport default class ActorTranslationConstraint extends ActorAxisConstraint\n{\n\tconstructor(actor)\n\t{\n\t\tsuper(actor);\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tlet node = new ActorTranslationConstraint();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tconstrain(tip)\n\t{\n\t\tlet target = this._Target;\n\n\t\tlet parent = this._Parent;\n\t\tlet grandParent = parent._Parent;\n\n\t\tlet { _Strength:t, _SourceSpace:sourceSpace, _DestSpace:destSpace , _MinMaxSpace:minMaxSpace } = this;\n\n\t\tlet transformA = parent.worldTransform;\n\t\tlet translationA = vec2.set(vec2.create(), transformA[4], transformA[5]);\n\t\tlet translationB = vec2.create();\n\t\tif(!target)\n\t\t{\n\t\t\tvec2.copy(translationB, translationA);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tlet transformB = mat2d.clone(target.worldTransform);\n\t\t\tif(sourceSpace === TransformSpace.Local)\n\t\t\t{\n\t\t\t\tlet sourceGrandParent = target.parent;\n\t\t\t\tif(sourceGrandParent)\n\t\t\t\t{\n\t\t\t\t\tlet inverse = mat2d.invert(mat2d.create(), sourceGrandParent.worldTransform);\n\t\t\t\t\ttransformB = mat2d.mul(inverse, inverse, transformB);\n\t\t\t\t}\n\t\t\t}\n\t\t\tvec2.set(translationB, transformB[4], transformB[5]);\n\n\t\t\tif(!this._CopyX)\n\t\t\t{\n\t\t\t\ttranslationB[0] = destSpace === TransformSpace.Local ? 0.0 : translationA[0];\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\ttranslationB[0] *= this._ScaleX;\t\n\t\t\t\tif(this._Offset)\n\t\t\t\t{\n\t\t\t\t\ttranslationB[0] += parent._Translation[0];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif(!this._CopyY)\n\t\t\t{\n\t\t\t\ttranslationB[1] = destSpace === TransformSpace.Local ? 0.0 : translationA[1];\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\ttranslationB[1] *= this._ScaleY;\n\n\t\t\t\tif(this._Offset)\n\t\t\t\t{\n\t\t\t\t\ttranslationB[1] += parent._Translation[1];\n\t\t\t\t}\n\t\t\t}\n\n\t\t\tif(destSpace === TransformSpace.Local)\n\t\t\t{\n\t\t\t\t// Destination space is in parent transform coordinates.\n\t\t\t\tif(grandParent)\n\t\t\t\t{\n\t\t\t\t\tvec2.transformMat2d(translationB, translationB, grandParent.worldTransform);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\t\n\t\tlet clampLocal = (minMaxSpace === TransformSpace.Local && grandParent) ? true : false;\n\t\tif(clampLocal)\n\t\t{\n\t\t\t// Apply min max in local space, so transform to local coordinates first.\n\t\t\tlet temp = mat2d.invert(mat2d.create(), grandParent.worldTransform);\n\t\t\t// Get our target world coordinates in parent local.\n\t\t\tvec2.transformMat2d(translationB, translationB, temp);\n\t\t}\n\t\tif(this._EnableMaxX && translationB[0] > this._MaxX)\n\t\t{\n\t\t\ttranslationB[0] = this._MaxX;\t\n\t\t}\n\t\tif(this._EnableMinX && translationB[0] < this._MinX)\n\t\t{\n\t\t\ttranslationB[0] = this._MinX;\t\n\t\t}\n\t\tif(this._EnableMaxY && translationB[1] > this._MaxY)\n\t\t{\n\t\t\ttranslationB[1] = this._MaxY;\t\n\t\t}\n\t\tif(this._EnableMinY && translationB[1] < this._MinY)\n\t\t{\n\t\t\ttranslationB[1] = this._MinY;\t\n\t\t}\n\t\tif(clampLocal)\n\t\t{\n\t\t\t// Transform back to world.\n\t\t\tvec2.transformMat2d(translationB, translationB, grandParent.worldTransform);\n\t\t}\n\n\t\tlet ti = 1.0-t;\n\n\t\t// Just interpolate world translation\n\t\ttransformA[4] = translationA[0] * ti + translationB[0] * t;\n\t\ttransformA[5] = translationA[1] * ti + translationB[1] * t;\n\t}\n}","import ActorProceduralPath from \"./ActorProceduralPath.js\";\nimport {vec2} from \"gl-matrix\";\n\nexport default class ActorTriangle extends ActorProceduralPath\n{\n constructor(actor)\n {\n super(actor);\n }\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ActorTriangle();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\n\t}\n\n getOBB(transform)\n\t{\n\t\tlet min_x = Number.MAX_VALUE;\n\t\tlet min_y = Number.MAX_VALUE;\n\t\tlet max_x = -Number.MAX_VALUE;\n\t\tlet max_y = -Number.MAX_VALUE;\n\n\t\tfunction addPoint(pt)\n\t\t{\n\t\t\tif(transform)\n\t\t\t{\n\t\t\t\tpt = vec2.transformMat2d(vec2.create(), pt, transform);\n\t\t\t}\n\t\t\tif(pt[0] < min_x)\n\t\t\t{\n\t\t\t\tmin_x = pt[0];\n\t\t\t}\n\t\t\tif(pt[1] < min_y)\n\t\t\t{\n\t\t\t\tmin_y = pt[1];\n\t\t\t}\n\t\t\tif(pt[0] > max_x)\n\t\t\t{\n\t\t\t\tmax_x = pt[0];\n\t\t\t}\n\t\t\tif(pt[1] > max_y)\n\t\t\t{\n\t\t\t\tmax_y = pt[1];\n\t\t\t}\n\t\t}\n\n\t\tconst radiusX = this.width/2;\n\t\tconst radiusY = this.height/2;\n\t\taddPoint([0.0, -radiusY-10]);\n\t\taddPoint([radiusX, radiusY]);\n\t\taddPoint([-radiusX, radiusY]);\n\n\t\treturn [vec2.fromValues(min_x, min_y), vec2.fromValues(max_x, max_y)];\n }\n \n draw(ctx)\n {\n const transform = this._WorldTransform;\n\t\tctx.save();\n\t\tctx.transform(transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]);\n\t\tconst radiusX = Math.max(0, this._Width/2);\n\t\tconst radiusY = Math.max(0, this._Height/2);\n\n\t\tctx.moveTo(0.0, -radiusY);\n\t\tctx.lineTo(radiusX, radiusY);\n\t\tctx.lineTo(-radiusX, radiusY);\n\t\tctx.closePath();\n\t\tctx.restore();\n }\n}","export default class AnimatedComponent\n{\n\tconstructor(componentIndex)\n\t{\n\t\tthis._ComponentIndex = componentIndex;\n\t\tthis._Properties = [];\n\t}\n}","function block(id, key) { return {id,key}; }\n\nconst Blocks = \n{\n\tUnknown: block(0, \"unknown\"),\n\tPosX: block(1, \"posX\"),\n\tPosY: block(2, \"posY\"),\n\tScaleX: block(3, \"scaleX\"),\n\tScaleY: block(4, \"scaleY\"),\n\tRotation: block(5, \"rotation\"),\n\tOpacity: block(6, \"opacity\"),\n\tDrawOrder: block(7, \"drawOrder\"),\n\tLength: block(8, \"length\"),\n\tVertexDeform: block(9, \"vertices\"),\n\tConstraintStrength: block(10, \"strength\"),\n\tTrigger: block(11, \"trigger\"),\n\tIntProperty: block(12, \"intValue\"),\n\tFloatProperty: block(13, \"floatValue\"),\n\tStringProperty: block(14, \"stringValue\"),\n\tBooleanProperty: block(15, \"boolValue\"),\n\tIsCollisionEnabled: block(16, \"isCollisionEnabled\"),\n\tSequence: block(17, \"sequence\"),\n\tActiveChildIndex: block(18, \"activeChild\"),\n\tPathVertices: block(19, \"pathVertices\"),\n\tFillColor: block(20, \"fillColor\"),\n\tFillGradient: block(21, \"fillGradient\"),\n\tFillRadial: block(22, \"fillRadial\"),\n\tStrokeColor: block(23, \"strokeColor\"),\n\tStrokeGradient: block(24, \"strokeGradient\"),\n\tStrokeRadial: block(25, \"strokeRadial\"),\n\tStrokeWidth: block(26, \"strokeWidth\"),\n\tStrokeOpacity: block(27, \"strokeOpacity\"),\n\tFillOpacity: block(28, \"fillOpacity\"),\n\tShapeWidth: block(29, \"width\"),\n\tShapeHeight: block(30, \"height\"),\n\tCornerRadius: block(31, \"cornerRadius\"),\n\tInnerRadius: block(32, \"innerRadius\")\n};\n\nconst _Types = {};\nconst _Map = new Map();\nfor(const key in Blocks)\n{\n\tconst value = Blocks[key];\n\t_Types[key] = value.id;\n\t_Map.set(value.key, value.id);\n}\n\nexport default class AnimatedProperty\n{\n\tconstructor(type)\n\t{\n\t\tthis._Type = type;\n\t\tthis._KeyFrames = [];\n\t}\n\n static get Types()\n {\n return _Types;\n }\n\n static fromString(label)\n {\n return _Map.get(label) || 0;\n }\n}\n\n\nAnimatedProperty.Properties = \n{\n\t\n};","import AnimatedProperty from \"./AnimatedProperty.js\";\nimport ActorBone from \"./ActorBone.js\";\nimport {StraightPathPoint} from \"./PathPoint.js\";\nconst AnimatedPropertyTypes = AnimatedProperty.Types;\n\nfunction keyFrameLocation(seconds, list, start, end)\n{\n\tlet mid;\n\tlet element;\n\twhile (start <= end) \n\t{\n\t\tmid = ((start + end) >> 1);\n\t\telement = list[mid]._Time;\n\t\tif (element < seconds) \n\t\t{\n\t\t\tstart = mid + 1;\n\t\t} \n\t\telse if (element > seconds) \n\t\t{\n\t\t\tend = mid - 1;\n\t\t} \n\t\telse \n\t\t{\n\t\t\treturn mid;\n\t\t}\n\t}\n\treturn start;\n}\n\nexport default class Animation\n{\n\tconstructor(artboard)\n\t{\n\t\tthis._Artboard = artboard;\n\t\tthis._Components = [];\n\t\tthis._TriggerComponents = [];\n\t\tthis._DisplayStart = 0;\n\t\tthis._DisplayEnd = 0;\n\n\t\tthis._Name = null;\n\t\tthis._FPS = 60;\n\t\tthis._Duration = 0;\n\t\tthis._Loop = false;\n\t}\n\n\tget duration()\n\t{\n\t\treturn this._Duration;\n\t}\n\n\ttriggerEvents(artboardComponents, fromTime, toTime, triggered)\n\t{\n\t\tconst keyedTriggerComponents = this._TriggerComponents;\n\t\tfor(let i = 0; i < keyedTriggerComponents.length; i++)\n\t\t{\n\t\t\tconst keyedComponent = keyedTriggerComponents[i];\n\t\t\tconst properties = keyedComponent._Properties;\n\t\t\tfor(let j = 0; j < properties.length; j++)\n\t\t\t{\n\t\t\t\tconst property = properties[j];\n\t\t\t\tswitch(property._Type)\n\t\t\t\t{\n\t\t\t\t\tcase AnimatedPropertyTypes.Trigger:\n\t\t\t\t\t{\n\t\t\t\t\t\tconst keyFrames = property._KeyFrames;\n\n\t\t\t\t\t\tconst kfl = keyFrames.length;\n\t\t\t\t\t\tif(kfl === 0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcontinue;\n\t\t\t\t\t\t}\n\n\t\t\t\t\t\tconst idx = keyFrameLocation(toTime, keyFrames, 0, keyFrames.length-1);\n\t\t\t\t\t\tif(idx === 0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tif(keyFrames.length > 0 && keyFrames[0]._Time === toTime)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tconst component = artboardComponents[keyedComponent._ComponentIndex];\n\t\t\t\t\t\t\t\ttriggered.push({\n\t\t\t\t\t\t\t\t\tname:component._Name,\n\t\t\t\t\t\t\t\t\tcomponent:component,\n\t\t\t\t\t\t\t\t\tpropertyType:property._Type,\n\t\t\t\t\t\t\t\t\tkeyFrameTime:toTime,\n\t\t\t\t\t\t\t\t\telapsed:0\n\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfor(let k = idx-1; k >= 0; k--)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tconst frame = keyFrames[k];\t\n\t\t\t\t\t\t\t\tif(frame._Time > fromTime)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tconst component = artboardComponents[keyedComponent._ComponentIndex];\n\t\t\t\t\t\t\t\t\ttriggered.push({\n\t\t\t\t\t\t\t\t\t\tname:component._Name,\n\t\t\t\t\t\t\t\t\t\tcomponent:component,\n\t\t\t\t\t\t\t\t\t\tpropertyType:property._Type,\n\t\t\t\t\t\t\t\t\t\tkeyFrameTime:frame._Time,\n\t\t\t\t\t\t\t\t\t\telapsed:toTime-frame._Time\n\t\t\t\t\t\t\t\t\t});\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tdefault:\n\t\t\t\t\t\tbreak;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n\n\tapply(time, artboard, mix)\n\t{\n\t\tconst components = this._Components;\n\t\tconst imix = 1.0-mix;\n\t\tconst artboardComponents = artboard._Components;\n\t\tfor(let i = 0; i < components.length; i++)\n\t\t{\n\t\t\tconst animatedComponent = components[i];\n\t\t\tconst component = artboardComponents[animatedComponent._ComponentIndex];\n\t\t\tif(!component)\n\t\t\t{\n\t\t\t\tcontinue;\n\t\t\t}\n\n\t\t\tconst properties = animatedComponent._Properties;\n\t\t\tfor(let j = 0; j < properties.length; j++)\n\t\t\t{\n\t\t\t\tconst property = properties[j];\n\t\t\t\tconst keyFrames = property._KeyFrames;\n\n\t\t\t\tconst kfl = keyFrames.length;\n\t\t\t\tif(kfl === 0)\n\t\t\t\t{\n\t\t\t\t\tcontinue;\n\t\t\t\t}\n\n\t\t\t\tconst idx = keyFrameLocation(time, keyFrames, 0, keyFrames.length-1);\n\t\t\t\tlet value = 0.0;\n\n\t\t\t\tif(idx === 0)\n\t\t\t\t{\n\t\t\t\t\tvalue = keyFrames[0]._Value;\n\t\t\t\t}\n\t\t\t\telse\n\t\t\t\t{\n\t\t\t\t\tif(idx < keyFrames.length)\n\t\t\t\t\t{\n\t\t\t\t\t\tconst fromFrame = keyFrames[idx-1];\n\t\t\t\t\t\tconst toFrame = keyFrames[idx];\n\t\t\t\t\t\tif(time == toFrame._Time)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tvalue = toFrame._Value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tlet mix = (time - fromFrame._Time)/(toFrame._Time-fromFrame._Time);\n\t\t\t\t\t\t\tconst interpolator = fromFrame._Interpolator;\n\t\t\t\t\t\t\t\n\t\t\t\t\t\t\tif(interpolator)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tmix = interpolator.getEasedMix(mix);\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tvalue = fromFrame.interpolate(mix, toFrame);\n\t\t\t\t\t\t}\n\t\t\t\t\t}\n\t\t\t\t\telse\n\t\t\t\t\t{\n\t\t\t\t\t\tconst kf = keyFrames[idx-1];\n\t\t\t\t\t\tvalue = kf._Value;\n\t\t\t\t\t}\n\t\t\t\t}\n\n\t\t\t\tlet markDirty = false;\n\t\t\t\tswitch(property._Type)\n\t\t\t\t{\n\t\t\t\t\tcase AnimatedPropertyTypes.PosX:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Translation[0] = value;\t\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Translation[0] = component._Translation[0] * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\tmarkDirty = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.PosY:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Translation[1] = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Translation[1] = component._Translation[1] * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmarkDirty = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.ScaleX:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Scale[0] = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Scale[0] = value * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmarkDirty = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.ScaleY:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Scale[1] = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Scale[1] = value * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmarkDirty = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.Rotation:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Rotation = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Rotation = component._Rotation * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmarkDirty = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.Opacity:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Opacity = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Opacity = component._Opacity * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tmarkDirty = true;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.ConstraintStrength:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent.strength = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent.strength = component._Strength * imix + value * mix;\t\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.DrawOrder:\n\t\t\t\t\t\tif(artboard._LastSetDrawOrder != value)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tartboard._LastSetDrawOrder = value;\n\t\t\t\t\t\t\tfor(let i = 0; i < value.length; i++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tconst v = value[i];\n\t\t\t\t\t\t\t\tartboardComponents[v.componentIdx]._DrawOrder = v.value;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tartboard._IsImageSortDirty = true;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.Length:\n\t\t\t\t\t\tmarkDirty = true;\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Length = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Length = component._Length * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\t\n\t\t\t\t\t\tfor(let l = 0; l < component._Children.length; l++)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tconst chd = component._Children[l];\n\t\t\t\t\t\t\tif(chd.constructor === ActorBone)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tchd._Translation[0] = component._Length;\n\t\t\t\t\t\t\t\tchd._IsDirty = true;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.VertexDeform:\n\t\t\t\t\t{\n\t\t\t\t\t\tcomponent._VerticesDirty = true;\n\t\t\t\t\t\tconst nv = component._NumVertices;\n\t\t\t\t\t\tconst to = component._AnimationDeformedVertices;\n\t\t\t\t\t\tlet tidx = 0;\n\t\t\t\t\t\tlet fidx = 0;\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfor(let l = 0; l < nv; l++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tto[tidx] = value[fidx++];\n\t\t\t\t\t\t\t\tto[tidx+1] = value[fidx++];\n\t\t\t\t\t\t\t\ttidx+=2;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfor(let l = 0; l < nv; l++)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tto[tidx] = to[tidx] * imix + value[fidx++] * mix;\n\t\t\t\t\t\t\t\tto[tidx+1] = to[tidx+1] * imix + value[fidx++] * mix;\n\t\t\t\t\t\t\t\ttidx+=2;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tcase AnimatedPropertyTypes.StringProperty:\n\t\t\t\t\t\tcomponent._Value = value;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.IntProperty:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Value = value;\t\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Value = Math.round(component._Value * imix + value * mix);\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.FloatProperty:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Value = value;\t\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Value = component._Value * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.BooleanProperty:\n\t\t\t\t\t\tcomponent._Value = value;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.IsCollisionEnabled:\n\t\t\t\t\t\tcomponent._IsCollisionEnabled = value;\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.Sequence:\n\t\t\t\t\t\tif(component._SequenceFrames)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tlet frameIndex = Math.floor(value)%component._SequenceFrames.length;\n\t\t\t\t\t\t\tif(frameIndex < 0)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tframeIndex += component._SequenceFrames.length;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\tcomponent._SequenceFrame = frameIndex;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase AnimatedPropertyTypes.ActiveChildIndex:\n\t\t\t\t\t\tcomponent.activeChildIndex = value;\n\t\t\t\t\t\tmarkDirty = true;\n\t\t\t\t\t\tbreak;\n\n\t\t\t\t\tcase AnimatedPropertyTypes.PathVertices:\n\t\t\t\t\t{\n\t\t\t\t\t\tlet readIdx = 0;\n\t\t\t\t\t\tif(mix !== 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfor(const point of component._Points)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tpoint._Translation[0] = point._Translation[0] * imix + value[readIdx++] * mix;\n\t\t\t\t\t\t\t\tpoint._Translation[1] = point._Translation[1] * imix + value[readIdx++] * mix;\n\t\t\t\t\t\t\t\tif(point.constructor === StraightPathPoint)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tpoint._Radius = point._Radius * imix + value[readIdx++] * mix;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tpoint._In[0] = point._In[0] * imix + value[readIdx++] * mix;\n\t\t\t\t\t\t\t\t\tpoint._In[1] = point._In[1] * imix + value[readIdx++] * mix;\n\t\t\t\t\t\t\t\t\tpoint._Out[0] = point._Out[0] * imix + value[readIdx++] * mix;\n\t\t\t\t\t\t\t\t\tpoint._Out[1] = point._Out[1] * imix + value[readIdx++] * mix;\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tfor(const point of component._Points)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tpoint._Translation[0] = value[readIdx++];\n\t\t\t\t\t\t\t\tpoint._Translation[1] = value[readIdx++];\n\t\t\t\t\t\t\t\tif(point.constructor === StraightPathPoint)\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tpoint._Radius = value[readIdx++];\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t\telse\n\t\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\t\tpoint._In[0] = value[readIdx++];\n\t\t\t\t\t\t\t\t\tpoint._In[1] = value[readIdx++];\n\t\t\t\t\t\t\t\t\tpoint._Out[0] = value[readIdx++];\n\t\t\t\t\t\t\t\t\tpoint._Out[1] = value[readIdx++];\n\t\t\t\t\t\t\t\t}\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tcase AnimatedPropertyTypes.ShapeWidth:\n\t\t\t\t\tcase AnimatedPropertyTypes.StrokeWidth:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Width = value;\t\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Width = component._Width * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.FillOpacity:\n\t\t\t\t\tcase AnimatedPropertyTypes.StrokeOpacity:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Opacity = value;\t\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Opacity = component._Opacity * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.FillColor:\n\t\t\t\t\tcase AnimatedPropertyTypes.StrokeColor:\n\t\t\t\t\t{\n\t\t\t\t\t\tconst color = component._Color;\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcolor[0] = value[0];\n\t\t\t\t\t\t\tcolor[1] = value[1];\n\t\t\t\t\t\t\tcolor[2] = value[2];\n\t\t\t\t\t\t\tcolor[3] = value[3];\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcolor[0] = color[0] * imix + value[0] * mix;\n\t\t\t\t\t\t\tcolor[1] = color[1] * imix + value[1] * mix;\n\t\t\t\t\t\t\tcolor[2] = color[2] * imix + value[2] * mix;\n\t\t\t\t\t\t\tcolor[3] = color[3] * imix + value[3] * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tcase AnimatedPropertyTypes.FillGradient:\n\t\t\t\t\tcase AnimatedPropertyTypes.StrokeGradient:\n\t\t\t\t\t{\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tlet ridx = 0;\n\t\t\t\t\t\t\tcomponent._Start[0] = value[ridx++];\n\t\t\t\t\t\t\tcomponent._Start[1] = value[ridx++];\n\t\t\t\t\t\t\tcomponent._End[0] = value[ridx++];\n\t\t\t\t\t\t\tcomponent._End[1] = value[ridx++];\n\n\t\t\t\t\t\t\tconst cs = component._ColorStops;\n\t\t\t\t\t\t\tlet wi = 0;\n\t\t\t\t\t\t\twhile(ridx < value.length && wi < cs.length)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tcs[wi++] = value[ridx++];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tlet ridx = 0;\n\t\t\t\t\t\t\tcomponent._Start[0] = component._Start[0] * imix + value[ridx++] * mix;\n\t\t\t\t\t\t\tcomponent._Start[1] = component._Start[1] * imix + value[ridx++] * mix;\n\t\t\t\t\t\t\tcomponent._End[0] = component._End[0] * imix + value[ridx++] * mix;\n\t\t\t\t\t\t\tcomponent._End[1] = component._End[1] * imix + value[ridx++] * mix;\n\n\t\t\t\t\t\t\tconst cs = component._ColorStops;\n\t\t\t\t\t\t\tlet wi = 0;\n\t\t\t\t\t\t\twhile(ridx < value.length && wi < cs.length)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tcs[wi] = cs[wi] * imix + value[ridx++];\n\t\t\t\t\t\t\t\twi++;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tcase AnimatedPropertyTypes.FillRadial:\n\t\t\t\t\tcase AnimatedPropertyTypes.StrokeRadial:\n\t\t\t\t\t{\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tlet ridx = 0;\n\t\t\t\t\t\t\tcomponent._SecondaryRadiusScale = value[ridx++];\n\t\t\t\t\t\t\tcomponent._Start[0] = value[ridx++];\n\t\t\t\t\t\t\tcomponent._Start[1] = value[ridx++];\n\t\t\t\t\t\t\tcomponent._End[0] = value[ridx++];\n\t\t\t\t\t\t\tcomponent._End[1] = value[ridx++];\n\n\t\t\t\t\t\t\tconst cs = component._ColorStops;\n\t\t\t\t\t\t\tlet wi = 0;\n\t\t\t\t\t\t\twhile(ridx < value.length && wi < cs.length)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tcs[wi++] = value[ridx++];\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tlet ridx = 0;\n\t\t\t\t\t\t\tcomponent._SecondaryRadiusScale = component._SecondaryRadiusScale * imix + value[ridx++] * mix;\n\t\t\t\t\t\t\tcomponent._Start[0] = component._Start[0] * imix + value[ridx++] * mix;\n\t\t\t\t\t\t\tcomponent._Start[1] = component._Start[1] * imix + value[ridx++] * mix;\n\t\t\t\t\t\t\tcomponent._End[0] = component._End[0] * imix + value[ridx++] * mix;\n\t\t\t\t\t\t\tcomponent._End[1] = component._End[1] * imix + value[ridx++] * mix;\n\n\t\t\t\t\t\t\tconst cs = component._ColorStops;\n\t\t\t\t\t\t\tlet wi = 0;\n\t\t\t\t\t\t\twhile(ridx < value.length && wi < cs.length)\n\t\t\t\t\t\t\t{\n\t\t\t\t\t\t\t\tcs[wi] = cs[wi] * imix + value[ridx++];\n\t\t\t\t\t\t\t\twi++;\n\t\t\t\t\t\t\t}\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t}\n\t\t\t\t\tcase AnimatedPropertyTypes.ShapeHeight:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Height = value;\t\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._Height = component._Height * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.CornerRadius:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._CornerRadius = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._CornerRadius = component._CornerRadius * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\tcase AnimatedPropertyTypes.InnerRadius:\n\t\t\t\t\t\tif(mix === 1.0)\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._InnerRadius = value;\n\t\t\t\t\t\t}\n\t\t\t\t\t\telse\n\t\t\t\t\t\t{\n\t\t\t\t\t\t\tcomponent._InnerRadius = component._InnerRadius * imix + value * mix;\n\t\t\t\t\t\t}\n\t\t\t\t\t\tbreak;\n\t\t\t\t\t\t\n\t\t\t\t}\n\n\t\t\t\tif(markDirty)\n\t\t\t\t{\n\t\t\t\t\tcomponent.markTransformDirty();\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t}\n}","import Dispatcher from \"./Dispatcher.js\";\n\nexport default class AnimationInstance extends Dispatcher\n{\n\tconstructor(actor, animation)\n\t{\n\t\tsuper();\n\t\tthis._Actor = actor;\n\t\tthis._Animation = animation;\n\t\tthis._Time = 0;\n\n\t\tthis._Min = animation._DisplayStart || 0;\n\t\tthis._Max = animation._DisplayEnd || animation._Duration;\n\t\tthis._Loop = animation._Loop;\n\t\tthis._Range = this._Max - this._Min;\n\t}\n\n\tget loop()\n\t{\n\t\treturn this._Loop;\n\t}\n\t\n\tset loop(value)\n\t{\n\t\tthis._Loop = value;\n\t}\n\n\tget time()\n\t{\n\t\treturn this._Time;\n\t}\n\n\tget isOver()\n\t{\n\t\treturn this._Time >= this._Max;\n\t}\n\n\tset time(newTime)\n\t{\n\t\tconst delta = newTime - this._Time;\n\t\tlet time = this._Time + (delta % this._Range);\n\n\t\tif(time < this._Min)\n\t\t{\n\t\t\tif(this._Loop)\n\t\t\t{\n\t\t\t\ttime = this._Max - (this._Min - time);\t\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\ttime = this._Min;\n\t\t\t}\n\t\t}\n\t\telse if(time > this._Max)\n\t\t{\n\t\t\tif(this._Loop)\n\t\t\t{\n\t\t\t\ttime = this._Min + (time - this._Max);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\ttime = this._Max;\n\t\t\t}\n\t\t}\n\t\tthis._Time = time;\n\t}\n\n\treset()\n\t{\n\t\tthis._Time = 0.0;\n\t}\n\n\tadvance(seconds)\n\t{\n\t\tconst triggeredEvents = [];\n\t\tconst actorComponents = this._Actor._Components;\n\t\tlet time = this._Time;\n\t\ttime += seconds%this._Range;\n\t\tif(time < this._Min)\n\t\t{\n\t\t\tif(this._Loop)\n\t\t\t{\n\t\t\t\tthis._Animation.triggerEvents(actorComponents, time, this._Time, triggeredEvents);\n\t\t\t\ttime = this._Max - (this._Min - time);\n\t\t\t\tthis._Animation.triggerEvents(actorComponents, time, this._Max, triggeredEvents);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\ttime = this._Min;\n\t\t\t\tif(this._Time != time)\n\t\t\t\t{\n\t\t\t\t\tthis._Animation.triggerEvents(actorComponents, this._Min, this._Time, triggeredEvents);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse if(time > this._Max)\n\t\t{\n\t\t\tif(this._Loop)\n\t\t\t{\n\t\t\t\tthis._Animation.triggerEvents(actorComponents, time, this._Time, triggeredEvents);\n\t\t\t\ttime = this._Min + (time - this._Max);\n\t\t\t\tthis._Animation.triggerEvents(actorComponents, this._Min-0.001, time, triggeredEvents);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\ttime = this._Max;\n\t\t\t\tif(this._Time != time)\n\t\t\t\t{\n\t\t\t\t\tthis._Animation.triggerEvents(actorComponents, this._Time, this._Max, triggeredEvents);\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\t\telse if(time > this._Time)\n\t\t{\n\t\t\tthis._Animation.triggerEvents(actorComponents, this._Time, time, triggeredEvents);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis._Animation.triggerEvents(actorComponents, time, this._Time, triggeredEvents);\n\t\t}\n\n\t\tfor(let i = 0; i < triggeredEvents.length; i++)\n\t\t{\n\t\t\tconst event = triggeredEvents[i];\n\t\t\tthis.dispatch(\"animationEvent\", event);\n\t\t\tthis._Actor.dispatch(\"animationEvent\", event);\n\t\t}\n\t\tthis._Time = time;\n\n\t\treturn triggeredEvents;\n\t}\n\n\tapply(actor, mix)\n\t{\n\t\tthis._Animation.apply(this._Time, actor, mix);\n\t}\n}","function cuberoot(x) \n{\n\tconst y = Math.pow(Math.abs(x), 1/3);\n\treturn x < 0 ? -y : y;\n}\t\n\nfunction yFromT(t, E, F, G, H)\n{\n\tconst y = E*(t*t*t) + F*(t*t) + G*t + H;\n\treturn y;\n}\n\n// http://stackoverflow.com/questions/27176423/function-to-solve-cubic-equation-analytically\nfunction solveCubic(a, b, c, d) \n{\n\tif (Math.abs(a) < Number.EPSILON) \n\t{ \n\t\t// Quadratic case, ax^2+bx+c=0\n\t\ta = b; \n\t\tb = c; \n\t\tc = d;\n\t\tif (Math.abs(a) < Number.EPSILON) \n\t\t{ \n\t\t\t// Linear case, ax+b=0\n\t\t\ta = b; \n\t\t\tb = c;\n\t\t\tif (Math.abs(a) < Number.EPSILON) // Degenerate case\n\t\t\t{\n\t\t\t\treturn [];\n\t\t\t}\n\t\t\treturn [-b/a];\n\t\t}\n\t\t\n\t\tconst D = b*b - 4*a*c;\n\t\tif (Math.abs(D) < Number.EPSILON)\n\t\t\treturn [-b/(2*a)];\n\t\telse if (D > 0)\n\t\t\treturn [(-b+Math.sqrt(D))/(2*a), (-b-Math.sqrt(D))/(2*a)];\n\t\treturn [];\n\t}\n\t\n\t// Convert to depressed cubic t^3+pt+q = 0 (subst x = t - b/3a)\n\tconst p = (3*a*c - b*b)/(3*a*a);\n\tconst q = (2*b*b*b - 9*a*b*c + 27*a*a*d)/(27*a*a*a);\n\tlet roots;\n\n\tif (Math.abs(p) < Number.EPSILON) \n\t{ \n\t\t// p = 0 -> t^3 = -q -> t = -q^1/3\n\t\troots = [cuberoot(-q)];\n\t} \n\telse if (Math.abs(q) < Number.EPSILON) \n\t{ \n\t\t// q = 0 -> t^3 + pt = 0 -> t(t^2+p)=0\n\t\troots = [0].concat(p < 0 ? [Math.sqrt(-p), -Math.sqrt(-p)] : []);\n\t} \n\telse \n\t{\n\t\tconst D = q*q/4 + p*p*p/27;\n\t\tif (Math.abs(D) < Number.EPSILON) \n\t\t{ // D = 0 -> two roots\n\t\t\troots = [-1.5*q/p, 3*q/p];\n\t\t} \n\t\telse if (D > 0) \n\t\t{\n\t\t\t// Only one real root\n\t\t\tconst u = cuberoot(-q/2 - Math.sqrt(D));\n\t\t\troots = [u - p/(3*u)];\n\t\t} \n\t\telse \n\t\t{\n\t\t\t// D < 0, three roots, but needs to use complex numbers/trigonometric solution\n\t\t\tconst u = 2*Math.sqrt(-p/3);\n\t\t\tconst t = Math.acos(3*q/p/u)/3; // D < 0 implies p < 0 and acos argument in [-1..1]\n\t\t\tconst k = 2*Math.PI/3;\n\t\t\troots = [u*Math.cos(t), u*Math.cos(t-k), u*Math.cos(t-2*k)];\n\t\t}\n\t}\n\t\n\t// Convert back from depressed cubic\n\tfor (let i = 0; i < roots.length; i++)\n\t{\n\t\troots[i] -= b/(3*a);\n\t}\n\treturn roots;\n}\n\nexport default class BezierAnimationCurve\n{\n\tconstructor(pos1, control1, control2, pos2)\n\t{\n\t\tconst y0a = pos1[1]; // initial y\n\t\tconst x0a = pos1[0]; // initial x \n\t\tconst y1a = control1[1]; // 1st influence y \n\t\tconst x1a = control1[0]; // 1st influence x \n\t\tconst y2a = control2[1]; // 2nd influence y\n\t\tconst x2a = control2[0]; // 2nd influence x\n\t\tconst y3a = pos2[1]; // final y \n\t\tconst x3a = pos2[0]; // final x \n\n\t\tthis._E = y3a - 3*y2a + 3*y1a - y0a; \n\t\tthis._F = 3*y2a - 6*y1a + 3*y0a; \n\t\tthis._G = 3*y1a - 3*y0a; \n\t\tthis._H = y0a;\n\n\t\tthis._Y0a = y0a;\n\t\tthis._X0a = x0a;\n\t\tthis._Y1a = y1a;\n\t\tthis._X1a = x1a;\n\t\tthis._Y2a = y2a;\n\t\tthis._X2a = x2a;\n\t\tthis._Y3a = y3a;\n\t\tthis._X3a = x3a;\n\t}\n\n\tget(x)\n\t{\n\t\tconst p0 = this._X0a-x;\n\t\tconst p1 = this._X1a-x;\n\t\tconst p2 = this._X2a-x;\n\t\tconst p3 = this._X3a-x;\n\n\t\tconst a = p3 - 3 * p2 + 3 * p1 - p0;\n\t\tconst b = 3 * p2 - 6 * p1 + 3 * p0;\n\t\tconst c = 3 * p1 - 3 * p0;\n\t\tconst d = p0;\n\n\t\tconst roots = solveCubic(a, b, c, d);\n\t\tlet t = 0;\n\t\tfor(let i = 0; i < roots.length; i++)\n\t\t{\n\t\t\tconst r = roots[i];\n\t\t\tif(r >= 0.0 && r <= 1.0)\n\t\t\t{\n\t\t\t\tt = r;\n\t\t\t\tbreak;\n\t\t\t}\n\t\t}\n\t\treturn yFromT(t, this._E, this._F, this._G, this._H);\n\t}\n}","function block(id, key) { return {id,key}; }\n\nconst Blocks = \n{\n\tNodes: block(1, \"nodes\"),\n\tActorNode: block(2, \"node\"),\n\tActorBone: block(3, \"bone\"),\n\tActorRootBone: block(4, \"rootBone\"),\n\tActorImage: block(5, \"image\"),\n\tView: block(6, \"view\"),\n\tAnimation: block(7, \"animation\"),\n\tAnimations: block(8, \"animations\"),\n\tAtlases: block(9, \"atlases\"),\n\tAtlas: block(10, \"atlas\"),\n\tActorEvent: block(12, \"event\"),\n\tCustomIntProperty: block(13, \"customInt\"),\n\tCustomFloatProperty: block(14, \"customFloat\"),\n\tCustomStringProperty: block(15, \"customString\"),\n\tCustomBooleanProperty: block(16, \"customBool\"),\n\tActorImageSequence: block(22, \"imageSequence\"),\n\tActorNodeSolo: block(23, \"solo\"),\n\tJellyComponent: block(28, \"jelly\"),\n\tActorJellyBone: block(29, \"jellyBone\"),\n\tActorIKConstraint: block(30, \"ikConstraint\"),\n\tActorDistanceConstraint: block(31, \"distanceConstraint\"),\n\tActorTranslationConstraint: block(32, \"translationConstraint\"),\n\tActorRotationConstraint: block(33, \"rotationConstraint\"),\n\tActorScaleConstraint: block(34, \"scaleConstraint\"),\n\tActorTransformConstraint: block(35, \"transformConstraint\"),\n\n\tActorShape: block(100, \"shape\"),\n\tActorPath: block(101, \"path\"),\n\tColorFill: block(102, \"colorFill\"),\n\tColorStroke: block(103, \"colorStroke\"),\n\tGradientFill: block(104, \"gradientFill\"),\n\tGradientStroke: block(105, \"gradientStroke\"),\n\tRadialGradientFill: block(106, \"radialGradientFill\"),\n\tRadialGradientStroke: block(107, \"radialGradientStroke\"),\n\tActorEllipse: block(108, \"ellipse\"),\n\tActorRectangle: block(109, \"rectangle\"),\n\tActorTriangle: block(110, \"triangle\"),\n\tActorStar: block(111, \"star\"),\n\tActorPolygon: block(112, \"polygon\"),\n\tActorSkin: block(113, \"skin\"),\n\tActorArtboard: block(114, \"artboard\"),\n\tArtboards: block(115, \"artboards\")\n};\n\nconst _Types = {};\nconst _Map = new Map();\nfor(const key in Blocks)\n{\n\tconst value = Blocks[key];\n\t_Types[key] = value.id;\n\t_Map.set(value.key, value.id);\n}\n\n\nexport default class Block\n{\n static get Types()\n {\n return _Types;\n }\n\n static fromString(label)\n {\n return _Map.get(label) || 0;\n }\n}","import ActorComponent from \"./ActorComponent.js\";\nimport {vec2, vec4, mat2d} from \"gl-matrix\";\n\nexport class FillRule\n{\n\tstatic get EvenOdd()\n\t{\n\t\treturn 0;\n\t}\n\n\tstatic get NonZero()\n\t{\n\t\treturn 1;\n\t}\n}\n\nclass ActorPaint extends ActorComponent\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._Opacity = 1.0;\n\t}\n\t\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._Opacity = node._Opacity;\t\n\t}\n\n\tget opacity()\n\t{\n\t\treturn this._Opacity;\n\t}\n}\n\nexport class ActorColor extends ActorPaint\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._Color = new Float32Array(4);\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tvec4.copy(this._Color, node._Color);\n\t}\n\n\tget cssColor()\n\t{\n\t\tconst c = this._Color;\n\t\treturn \"rgba(\" + Math.round(c[0]*255) + \", \" + Math.round(c[1]*255) + \", \" + Math.round(c[2]*255) + \", \" + (c[3]*this._Opacity) + \")\";\n\t}\n}\n\nexport class ColorFill extends ActorColor\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._FillRule = FillRule.EvenOdd;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ColorFill();\n\t\tColorFill.prototype.copy.call(node, this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._FillRule = node._FillRule;\n\t}\n\n\tfill(ctx, path)\n\t{\n\t\tctx.fillStyle = this.cssColor;\n\t\t\n\t\tswitch(this._FillRule)\n\t\t{\n\t\t\tcase FillRule.EvenOdd:\n\t\t\t\tctx.fill(path, \"evenodd\");\n\t\t\t\tbreak;\n\t\t\tcase FillRule.NonZero:\n\t\t\t\tctx.fill(path, \"nonzero\");\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\t\tif(this._Parent)\n\t\t{\n\t\t\tthis._Parent.addFill(this);\n\t\t}\n\t}\n}\n\nexport class ColorStroke extends ActorColor\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._Width = 0.0;\n\t}\n\n\tget width()\n\t{\n\t\treturn this._Width;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new ColorStroke();\n\t\tColorStroke.prototype.copy.call(node, this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._Width = node._Width;\n\t}\n\n\tstroke(ctx, path)\n\t{\n\t\tctx.strokeStyle = this.cssColor;\n\t\tctx.lineWidth = this._Width;\n\t\tctx.stroke(path);\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\t\tif(this._Parent)\n\t\t{\n\t\t\tthis._Parent.addStroke(this);\n\t\t}\n\t}\n}\n\nexport class GradientColor extends ActorPaint\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._ColorStops = new Float32Array(10);\n\t\tthis._Start = vec2.create();\n\t\tthis._End = vec2.create();\n\t\tthis._RenderStart = vec2.create();\n\t\tthis._RenderEnd = vec2.create();\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._ColorStops = new Float32Array(node._ColorStops);\n\t\tvec2.copy(this._Start, node._Start);\n\t\tvec2.copy(this._End, node._End);\n\t\tvec2.copy(this._RenderStart, node._RenderStart);\n\t\tvec2.copy(this._RenderEnd, node._RenderEnd);\n\t}\n\n\tcompleteResolve()\n\t{\n\t\tsuper.completeResolve();\n\t\tconst graph = this._Actor;\n\t\tconst shape = this._Parent;\n\t\tgraph.addDependency(this, shape);\n\t}\n\n\tupdate(dirt)\n\t{\n\t\tconst shape = this._Parent;\n\t\tconst world = shape.worldTransform;\n\t\tvec2.transformMat2d(this._RenderStart, this._Start, world);\n\t\tvec2.transformMat2d(this._RenderEnd, this._End, world);\n\t}\n}\n\nexport class GradientFill extends GradientColor\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._FillRule = FillRule.EvenOdd;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new GradientFill();\n\t\tGradientFill.prototype.copy.call(node, this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._FillRule = node._FillRule;\n\t}\n\n\tfill(ctx, path)\n\t{\n\t\tconst {_RenderStart:start, _RenderEnd:end, _ColorStops:stops} = this;\n\t\tconst gradient = ctx.createLinearGradient(start[0], start[1], end[0], end[1]);\n\n\t\tconst opacity = this._Opacity;\n\t\tconst numStops = stops.length/5;\n\t\tlet idx = 0;\n\t\tfor(let i = 0; i < numStops; i++)\n\t\t{\n\t\t\tconst style = \"rgba(\" + Math.round(stops[idx++]*255) + \", \" + Math.round(stops[idx++]*255) + \", \" + Math.round(stops[idx++]*255) + \", \" + (stops[idx++]*opacity) + \")\";\n\t\t\tconst value = stops[idx++];\n\t\t\tgradient.addColorStop(value, style);\n\t\t}\n\t\t\n\t\tctx.fillStyle = gradient;\n\t\tswitch(this._FillRule)\n\t\t{\n\t\t\tcase FillRule.EvenOdd:\n\t\t\t\tctx.fill(path, \"evenodd\");\n\t\t\t\tbreak;\n\t\t\tcase FillRule.NonZero:\n\t\t\t\tctx.fill(path, \"nonzero\");\n\t\t\t\tbreak;\n\t\t}\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\t\tif(this._Parent)\n\t\t{\n\t\t\tthis._Parent.addFill(this);\n\t\t}\n\t}\n}\n\nexport class GradientStroke extends GradientColor\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._Width = 0.0;\n\t}\n\n\tget width()\n\t{\n\t\treturn this._Width;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new GradientStroke();\n\t\tGradientStroke.prototype.copy.call(node, this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._Width = node._Width;\n\t}\n\n\tstroke(ctx, path)\n\t{\n\t\tconst {_RenderStart:start, _RenderEnd:end, _ColorStops:stops} = this;\n\t\tconst gradient = ctx.createLinearGradient(start[0], start[1], end[0], end[1]);\n\n\t\tconst opacity = this._Opacity;\n\t\tconst numStops = stops.length/5;\n\t\tlet idx = 0;\n\t\tfor(let i = 0; i < numStops; i++)\n\t\t{\n\t\t\tconst style = \"rgba(\" + Math.round(stops[idx++]*255) + \", \" + Math.round(stops[idx++]*255) + \", \" + Math.round(stops[idx++]*255) + \", \" + (stops[idx++]*opacity) + \")\";\n\t\t\tconst value = stops[idx++];\n\t\t\tgradient.addColorStop(value, style);\n\t\t}\n\t\t\n\t\tctx.lineWidth = this._Width;\n\t\tctx.strokeStyle = gradient;\n\t\tctx.stroke(path);\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\t\tif(this._Parent)\n\t\t{\n\t\t\tthis._Parent.addStroke(this);\n\t\t}\n\t}\n}\n\nexport class RadialGradientColor extends GradientColor\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._SecondaryRadiusScale = 1.0;\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._SecondaryRadiusScale = node._SecondaryRadiusScale;\n\t}\n}\n\nexport class RadialGradientFill extends RadialGradientColor\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._FillRule = FillRule.EvenOdd;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new RadialGradientFill();\n\t\tRadialGradientFill.prototype.copy.call(node, this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._FillRule = node._FillRule;\n\t}\n\n\tfill(ctx, path)\n\t{\n\t\tlet {_RenderStart:start, _RenderEnd:end, _ColorStops:stops, _SecondaryRadiusScale:secondaryRadiusScale} = this;\n\t\tconst gradient = ctx.createRadialGradient(0.0, 0.0, 0.0, 0.0, 0.0, vec2.distance(start, end));\n\n\t\tconst opacity = this._Opacity;\n\t\tconst numStops = stops.length/5;\n\t\tlet idx = 0;\n\t\tfor(let i = 0; i < numStops; i++)\n\t\t{\n\t\t\tconst style = \"rgba(\" + Math.round(stops[idx++]*255) + \", \" + Math.round(stops[idx++]*255) + \", \" + Math.round(stops[idx++]*255) + \", \" + (stops[idx++]*opacity) + \")\";\n\t\t\tconst value = stops[idx++];\n\t\t\tgradient.addColorStop(value, style);\n\t\t}\n\t\t\n\t\tctx.fillStyle = gradient;\n\n\t\t// const squash = Math.max(0.00001, secondaryRadiusScale);\n\t\t// const diff = vec2.subtract(vec2.create(), end, start);\n\t\t// const angle = Math.atan2(diff[1], diff[0]);\n\t\t// ctx.save();\n\t\t// ctx.translate(start[0], start[1]);\n\t\t// ctx.rotate(angle);\n\t\t// ctx.scale(1.0, squash);\n\n\t\tswitch(this._FillRule)\n\t\t{\n\t\t\tcase FillRule.EvenOdd:\n\t\t\t\tctx.fill(path, \"evenodd\");\n\t\t\t\tbreak;\n\t\t\tcase FillRule.NonZero:\n\t\t\t\tctx.fill(path, \"nonzero\");\n\t\t\t\tbreak;\n\t\t}\n\t\t//ctx.restore();\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\t\tif(this._Parent)\n\t\t{\n\t\t\tthis._Parent.addFill(this);\n\t\t}\n\t}\n}\n\nexport class RadialGradientStroke extends RadialGradientColor\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._Width = 0.0;\n\t}\n\n\tget width()\n\t{\n\t\treturn this._Width;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new RadialGradientStroke();\n\t\tRadialGradientStroke.prototype.copy.call(node, this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\n\t\tthis._Width = node._Width;\n\t}\n\n\tstroke(ctx, path)\n\t{\n\t\t\n\t\tconst {_RenderStart:start, _RenderEnd:end, _ColorStops:stops, _SecondaryRadiusScale:secondaryRadiusScale} = this;\n\t\tconst gradient = ctx.createRadialGradient(0.0, 0.0, 0.0, 0.0, 0.0, vec2.distance(start, end));\n\n\t\tconst opacity = this._Opacity;\n\t\tconst numStops = stops.length/5;\n\t\tlet idx = 0;\n\t\tfor(let i = 0; i < numStops; i++)\n\t\t{\n\t\t\tconst style = \"rgba(\" + Math.round(stops[idx++]*255) + \", \" + Math.round(stops[idx++]*255) + \", \" + Math.round(stops[idx++]*255) + \", \" + (stops[idx++]*opacity) + \")\";\n\t\t\tconst value = stops[idx++];\n\t\t\tgradient.addColorStop(value, style);\n\t\t}\n\t\t\n\t\tctx.lineWidth = this._Width;\n\t\tctx.strokeStyle = gradient;\n\n\t\t// const squash = Math.max(0.00001, secondaryRadiusScale);\n\t\t// const angleVector = vec2.subtract(vec2.create(), end, start);\n\t\t// const angle = Math.atan2(angleVector[1], angleVector[0]);\n\t\t\n\t\t// ctx.save();\n\t\t// ctx.translate(start[0], start[1]);\n\t\t// ctx.rotate(angle);\n\t\t// ctx.scale(1.0, squash);\n\t\tctx.stroke(path);\n\t\t// ctx.restore();\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\t\tif(this._Parent)\n\t\t{\n\t\t\tthis._Parent.addStroke(this);\n\t\t}\n\t}\n}","import ActorComponent from \"./ActorComponent.js\";\n\nexport default class CustomProperty extends ActorComponent\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._PropertyType = CustomProperty.Integer;\n\t\tthis._Value = 0;\n\t}\n\n\tget propertyType()\n\t{\n\t\treturn this._PropertyType;\n\t}\n\n\tget value()\n\t{\n\t\treturn this._Value;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new CustomProperty();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._PropertyType = node._PropertyType;\n\t\tthis._Value = node._Value;\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\t\tif(this._ParentIdx !== undefined)\n\t\t{\n\t\t\tthis._Parent = components[this._ParentIdx];\n\t\t\tif(this._Parent)\n\t\t\t{\n\t\t\t\tthis._Parent._CustomProperties.push(this);\t\n\t\t\t}\n\t\t}\n\t}\n}\n\nCustomProperty.Type =\n{\n\tInteger:0,\n\tFloat:1,\n\tString:2,\n\tBoolean:3\n};","import {mat2d} from \"gl-matrix\";\n\nexport function Decompose(m, result)\n{\n\tlet m0 = m[0], m1 = m[1], m2 = m[2], m3 = m[3];\n\n\tlet rotation = Math.atan2(m1, m0);\n\tlet denom = m0*m0 + m1*m1;\n\tlet scaleX = Math.sqrt(denom);\n\tlet scaleY = (m0 * m3 - m2 * m1) / scaleX;\n\tlet skewX = Math.atan2(m0 * m2 + m1 * m3, denom);\n\n\tresult[0] = m[4];\n\tresult[1] = m[5];\n\tresult[2] = scaleX;\n\tresult[3] = scaleY;\n\tresult[4] = rotation;\n\tresult[5] = skewX;\n}\n\nexport function Compose(m, result)\n{\n\tlet r = result[4];\n\n\tif(r !== 0)\n\t{\n\t\tmat2d.fromRotation(m, r);\n\t}\n\telse\n\t{\n\t\tmat2d.identity(m);\n\t}\n\tm[4] = result[0];\n\tm[5] = result[1];\n\tmat2d.scale(m, m, [result[2], result[3]]);\n\n\tlet sk = result[5];\n\tif(sk !== 0.0)\n\t{\n\t\tm[2] = m[0] * sk + m[2];\n\t\tm[3] = m[1] * sk + m[3];\n\t}\n}","export default class Dispatcher\n{\n\tconstructor()\n\t{\n\t\tthis.events = {};\n\t}\n\n\taddEventListener(event, callback)\n\t{\n\t\tlet evt = this.events[event];\n\t\tif(!evt)\n\t\t{\n\t\t\tthis.events[event] = evt = [];\n\t\t}\n\t\tif(evt.indexOf(callback) !== -1)\n\t\t{\n\t\t\treturn;\n\t\t}\n\t\tevt.push(callback);\n\t}\n\n\tremoveEventListener(event, callback)\n\t{\n\t\tlet evt = this.events[event];\n\t\tif(!evt)\n\t\t{\n\t\t\treturn true;\n\t\t}\n\t\tfor(let i = 0; i < evt.length; i++)\n\t\t{\n\t\t\tif(evt[i] === callback)\n\t\t\t{\n\t\t\t\tevt.splice(i, 1);\n\t\t\t\treturn true;\n\t\t\t}\n\t\t}\n\t\treturn false;\n\t}\n\n\tdispatch(event, data, extraContext)\n\t{\n\t\tlet evt = this.events[event];\n\t\tif(evt)\n\t\t{\n\t\t\tfor(let i = 0; i < evt.length; i++)\n\t\t\t{\n\t\t\t\tevt[i].call(this, data, extraContext);\n\t\t\t}\n\t\t}\n\t}\n}","exports.Graphics = require(\"./Graphics.js\").default;\nexports.ActorLoader = require(\"./ActorLoader.js\").default;\nexports.AnimationInstance = require(\"./AnimationInstance.js\").default;\nexports.ActorCollider = require(\"./ActorCollider.js\").default;\nexports.ActorColliderPolygon = require(\"./ActorColliderPolygon.js\").default;\nexports.ActorColliderLine = require(\"./ActorColliderLine.js\").default;\nexports.ActorColliderCircle = require(\"./ActorColliderCircle.js\").default;\nexports.ActorColliderRectangle = require(\"./ActorColliderRectangle.js\").default;\nexports.ActorColliderTriangle = require(\"./ActorColliderTriangle.js\").default;","export default class Graphics\n{\n\tconstructor(canvas)\n\t{\n\t\tif(!canvas)\n\t\t{\n\t\t\tcanvas = document.createElement(\"canvas\");\n\t\t}\n\t\tthis._Canvas = canvas;\n\t\tthis._Context = canvas.getContext(\"2d\");\t\n\t}\n\n\tget canvas()\n\t{\n\t\treturn this._Canvas;\n\t}\n\n\tget ctx()\n\t{\n\t\treturn this._Context;\n\t}\n\n\tdispose()\n\t{\n\n\t}\n\n\tget width()\n\t{\n\t\treturn this._Canvas.width;\n\t}\n\n\tget height()\n\t{\n\t\treturn this._Canvas.height;\n\t}\n\n\tclear(color)\n\t{\n\t\tlet ctx = this._Context;\n\t\tlet cvs = this._Canvas;\n\t\t\n\t\tctx.clearRect(0, 0, cvs.width, cvs.height);\n\t\tctx.save();\n\t\tif(color && color[3])\n\t\t{\n\t\t\tctx.fillStyle = \"rgba(\" + Math.round(color[0]*255) + \",\" + Math.round(color[1]*255) + \",\" + Math.round(color[2]*255) + \",\" + color[3] + \")\";\n\t\t\tctx.rect(0, 0, cvs.width, cvs.height);\n\t\t\tctx.fill();\n\t\t}\n\t}\n\n\tsetView(transform)\n\t{\n\t\tthis.ctx.setTransform(transform[0], transform[1], transform[2], transform[3], transform[4], transform[5]);\n\t}\n\n\tflush()\n\t{\n\t\tlet ctx = this._Context;\n\t\tctx.restore();\n\t}\n\n\tget viewportWidth()\n\t{\n\t\treturn this._Canvas.width;\n\t}\n\n\tget viewportHeight()\n\t{\n\t\treturn this._Canvas.height;\n\t}\n\n\tsetSize(width, height)\n\t{\n\t\tif(this.width !== width || this.height !== height)\n\t\t{\n\t\t\tthis._Canvas.width = width;\n\t\t\tthis._Canvas.height = height;\n\t\t\treturn true;\n\t\t}\n\t\treturn false;\n\t}\n}","import BezierEasing from \"bezier-easing\";\n\nexport class Hold\n{\n\tgetEasedMix(mix)\n\t{\n\t\treturn 0;\n\t}\n}\n\nHold.instance = new Hold();\n\nexport class Linear\n{\n\tgetEasedMix(mix)\n\t{\n\t\treturn mix;\n\t}\n}\n\nLinear.instance = new Linear();\n\nexport class Cubic\n{\n\tconstructor(x1, y1, x2, y2)\n\t{\n\t\tthis._Bezier = BezierEasing(x1, y1, x2, y2);\n\t}\n\n\tgetEasedMix(mix)\n\t{\n\t\treturn this._Bezier(mix);\n\t}\n}","import ActorComponent from \"./ActorComponent.js\";\nimport ActorJellyBone from \"./ActorJellyBone.js\";\nimport ActorBoneBase from \"./ActorBoneBase.js\";\nimport { mat2d, vec2 } from \"gl-matrix\";\n\n// https://stackoverflow.com/questions/1734745/how-to-create-circle-with-b%C3%A9zier-curves\nconst JellyMax = 16;\nconst OptimalDistance = 4*(Math.sqrt(2)-1)/3;\nconst CurveConstant = OptimalDistance * Math.sqrt(2) * 0.5;\n\nfunction ForwardDiffBezier(c0, c1, c2, c3, points, count, offset)\n{\n\tlet f = count;\n\n\tconst p0 = c0;\n\n\tconst p1 = 3.0 * (c1 - c0) / f;\n\n\tf *= count;\n\tconst p2 = 3.0 * (c0 - 2.0 * c1 + c2) / f;\n\t\n\tf *= count;\n\tconst p3 = (c3 - c0 + 3.0 * (c1 - c2)) / f;\n\n\tc0 = p0;\n\tc1 = p1 + p2 + p3;\n\tc2 = 2 * p2 + 6 * p3;\n\tc3 = 6 * p3;\n\n\tfor (let a = 0; a <= count; a++) \n\t{\n\t\tpoints[a][offset] = c0;\n\t\tc0 += c1;\n\t\tc1 += c2;\n\t\tc2 += c3;\n\t}\n}\n\nfunction NormalizeCurve(curve, numSegments)\n{\n\tconst points = [];\n\tconst curvePointCount = curve.length;\n\tconst distances = new Float32Array(curvePointCount);\n\tdistances[0] = 0;\n\tfor(let i = 0; i < curvePointCount-1; i++)\n\t{\n\t\tconst p1 = curve[i];\n\t\tconst p2 = curve[i+1];\n\t\tdistances[i + 1] = distances[i] + vec2.distance(p1, p2);\n\t}\n\tconst totalDistance = distances[curvePointCount-1];\n\n\tconst segmentLength = totalDistance/numSegments;\n\tlet pointIndex = 1;\n\tfor(let i = 1; i <= numSegments; i++)\n\t{\n\t\tconst distance = segmentLength * i;\n\n\t\twhile(pointIndex < curvePointCount-1 && distances[pointIndex] < distance)\n\t\t{\n\t\t\tpointIndex++;\n\t\t}\n\n\t\tconst d = distances[pointIndex];\n\t\tconst lastCurveSegmentLength = d - distances[pointIndex-1];\n\t\tconst remainderOfDesired = d - distance;\n\t\tconst ratio = remainderOfDesired / lastCurveSegmentLength;\n\t\tconst iratio = 1.0-ratio;\n\n\t\tconst p1 = curve[pointIndex-1];\n\t\tconst p2 = curve[pointIndex];\n\t\tpoints.push([p1[0]*ratio+p2[0]*iratio, p1[1]*ratio+p2[1]*iratio]);\n\t}\n\n\treturn points;\n}\n\nconst EPSILON = 0.001; // Intentionally aggressive.\n\nfunction FuzzyEquals(a, b) \n{\n const a0 = a[0], a1 = a[1];\n const b0 = b[0], b1 = b[1];\n return (Math.abs(a0 - b0) <= EPSILON*Math.max(1.0, Math.abs(a0), Math.abs(b0)) &&\n Math.abs(a1 - b1) <= EPSILON*Math.max(1.0, Math.abs(a1), Math.abs(b1)));\n}\n\nexport default class JellyComponent extends ActorComponent\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\n\t\tthis._EaseIn = 0.0;\n\t\tthis._EaseOut = 0.0;\n\t\tthis._ScaleIn = 0.0;\n\t\tthis._ScaleOut = 0.0;\n\t\tthis._InTargetIdx = 0;\n\t\tthis._OutTargetIdx = 0;\n\t\tthis._InTarget = null;\n\t\tthis._OutTarget = null;\n\n\t\tthis._Bones = [];\n\t\tthis._InPoint = vec2.create();\n\t\tthis._InDirection = vec2.create();\n\t\tthis._OutPoint = vec2.create();\n\t\tthis._OutDirection = vec2.create();\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new JellyComponent();\n\t\tnode.copy(this, resetActor);\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._EaseIn = node._EaseIn;\n\t\tthis._EaseOut = node._EaseOut;\n\t\tthis._ScaleIn = node._ScaleIn;\n\t\tthis._ScaleOut = node._ScaleOut;\n\t\tthis._InTargetIdx = node._InTargetIdx;\n\t\tthis._OutTargetIdx = node._OutTargetIdx;\n\t}\n\n\tresolveComponentIndices(components)\n\t{\n\t\tsuper.resolveComponentIndices(components);\n\n\t\tif(this._InTargetIdx !== 0)\n\t\t{\n\t\t\tthis._InTarget = components[this._InTargetIdx];\n\t\t}\n\t\tif(this._OutTargetIdx !== 0)\n\t\t{\n\t\t\tthis._OutTarget = components[this._OutTargetIdx];\n\t\t}\n\n\t\t// Add dependencies.\n\t\tconst {_Actor:actor, _Parent:bone} = this;\n\t\tlet dependencyConstraints = [];\n\t\tif(bone)\n\t\t{\n\t\t\tactor.addDependency(this, bone);\n\t\t\tdependencyConstraints = dependencyConstraints.concat(Array.from(bone.allConstraints));\n\t\t\tlet firstBone = bone.firstBone;\n\t\t\tif(firstBone)\n\t\t\t{\n\t\t\t\tactor.addDependency(this, firstBone);\n\t\t\t\tdependencyConstraints = dependencyConstraints.concat(Array.from(firstBone.allConstraints));\n\n\t\t\t\t// If we don't have an out target and the child jelly does have an in target\n\t\t\t\t// we are dependent on that target's position.\n\t\t\t\tif(!this.outTarget && firstBone.jelly && firstBone.jelly.inTarget)\n\t\t\t\t{\n\t\t\t\t\tactor.addDependency(this, firstBone.jelly.inTarget);\n\t\t\t\t\tdependencyConstraints = dependencyConstraints.concat(Array.from(firstBone.jelly.inTarget.allConstraints));\n\t\t\t\t}\n\t\t\t}\n\t\t\tlet parentBone = bone.parent instanceof ActorBoneBase && bone.parent;\n\t\t\tlet parentBoneJelly = parentBone && parentBone.jelly;\n\t\t\tif(parentBoneJelly && parentBoneJelly.outTarget)\n\t\t\t{\n\t\t\t\tactor.addDependency(this, parentBoneJelly.outTarget);\n\t\t\t\tdependencyConstraints = dependencyConstraints.concat(Array.from(parentBoneJelly.outTarget.allConstraints));\n\t\t\t}\n\t\t}\n\n\t\tif(this._InTarget)\n\t\t{\n\t\t\tactor.addDependency(this, this._InTarget);\n\t\t\tdependencyConstraints = dependencyConstraints.concat(Array.from(this._InTarget.allConstraints));\n\t\t}\n\t\tif(this._OutTarget)\n\t\t{\n\t\t\tactor.addDependency(this, this._OutTarget);\n\t\t\tdependencyConstraints = dependencyConstraints.concat(Array.from(this._OutTarget.allConstraints));\n\t\t}\n\n\t\tdependencyConstraints = new Set(dependencyConstraints);\n\t\t\n\t\tfor(const constraint of dependencyConstraints)\n\t\t{\n\t\t\tactor.addDependency(this, constraint);\n\t\t}\n\t}\n\n\tcompleteResolve()\n\t{\n\t\tsuper.completeResolve();\n\t\t\n\t\tconst {_Actor:actor, _Parent:bone} = this;\n\t\tbone._Jelly = this;\n\n\t\t// Get jellies.\n\t\tconst children = bone._Children;\n\t\tif(!children)\n\t\t{\n\t\t\treturn;\n\t\t}\n\t\tfor(const child of children)\n\t\t{\n\t\t\tif(child.constructor === ActorJellyBone)\n\t\t\t{\n\t\t\t\tthis._Bones.push(child);\n\t\t\t\tactor.addDependency(child, this);\n\t\t\t}\n\t\t}\n\t}\n\n\tupdateJellies()\n\t{\n\t\tconst bone = this._Parent;\n\t\t// We are in local bone space.\n\t\tconst tipPosition = vec2.set(vec2.create(), bone._Length, 0.0);\n\t\tconst jc = this._Cache;\n\n\t\tconst jellies = this._Bones;\n\t\tif(!jellies)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tif(jc && FuzzyEquals(jc.tip, tipPosition) && FuzzyEquals(jc.out, this._OutPoint) && FuzzyEquals(jc.in, this._InPoint) && jc.sin === this._ScaleIn && jc.sout === this._ScaleOut)\n\t\t{\n\t\t\treturn;\n\t\t}\n\n\t\tthis._Cache =\n\t\t{\n\t\t\ttip:tipPosition,\n\t\t\tout:vec2.clone(this._OutPoint),\n\t\t\tin:vec2.clone(this._InPoint),\n\t\t\tsin:this._ScaleIn,\n\t\t\tsout:this._ScaleOut\n\t\t};\n\n\t\tconst q0 = vec2.create();\n\t\tconst q1 = this._InPoint;\n\t\tconst q2 = this._OutPoint;\n\t\tconst q3 = tipPosition;\n\n\n\t\tconst subdivisions = JellyMax;\n\t\tconst points = [];\n\t\tfor(let i = 0; i <= subdivisions; i++)\n\t\t{\n\t\t\tpoints.push(new Float32Array(2));\n\t\t}\n\n\t\tForwardDiffBezier(q0[0], q1[0], q2[0], q3[0], points, subdivisions, 0);\n\t\tForwardDiffBezier(q0[1], q1[1], q2[1], q3[1], points, subdivisions, 1);\n\n\t\tconst normalizedPoints = NormalizeCurve(points, jellies.length);\n\n\t\tlet lastPoint = points[0];\n\n\t\tlet scale = this._ScaleIn;\n\t\tconst scaleInc = (this._ScaleOut - this._ScaleIn)/(jellies.length-1);\n\t\tfor(let i = 0; i < normalizedPoints.length; i++)\n\t\t{\n\t\t\tconst jelly = jellies[i];\n\t\t\tconst p = normalizedPoints[i];\n\n\t\t\t// We could set these by component and allow the mark to happen only if things have changed\n\t\t\t// but it's really likely that we have to mark dirty here, so might as well optimize the general case.\n\t\t\tvec2.copy(jelly._Translation, lastPoint);\n\t\t\tjelly._Length = vec2.distance(p, lastPoint);\n\t\t\tjelly._Scale[1] = scale;\n\t\t\tscale += scaleInc;\n\n\t\t\tconst diff = vec2.subtract(vec2.create(), p, lastPoint);\n\t\t\tjelly._Rotation = Math.atan2(diff[1], diff[0]);\n\t\t\tjelly.markTransformDirty();\n\t\t\tlastPoint = p;\n\t\t}\n\t}\n\n\tget tipPosition()\n\t{\n\t\tconst bone = this._Parent;\n\t\treturn vec2.set(vec2.create(), bone._Length, 0.0);\n\t}\n\n\tupdate(dirt)\n\t{\n\t\tconst bone = this._Parent;\n\n\t\tconst parentBone = bone.parent instanceof ActorBoneBase && bone.parent;\n\t\tconst parentBoneJelly = parentBone && parentBone.jelly;\n\t\tconst inverseWorld = mat2d.invert(mat2d.create(), bone.worldTransform);\n\t\tif(!inverseWorld)\n\t\t{\n\t\t\tconsole.warn(\"Failed to invert transform space\", bone.worldTransform);\n\t\t\treturn;\n\t\t}\n\t\t\n\t\tif(this._InTarget)\n\t\t{\n\t\t\tconst translation = this._InTarget.worldTranslation;\n\t\t\tvec2.transformMat2d(this._InPoint, translation, inverseWorld);\n\t\t\tvec2.normalize(this._InDirection, this._InPoint);\n\t\t}\n\t\telse if(parentBone)\n\t\t{\n\t\t\tif(parentBone._FirstBone === bone && parentBoneJelly && parentBoneJelly._OutTarget)\n\t\t\t{\n\t\t\t\tconst translation = parentBoneJelly._OutTarget.worldTranslation;\n\t\t\t\tconst localParentOut = vec2.transformMat2d(vec2.create(), translation, inverseWorld);\n\t\t\t\tvec2.normalize(localParentOut, localParentOut);\n\t\t\t\tvec2.negate(this._InDirection, localParentOut);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tconst d1 = vec2.set(vec2.create(), 1, 0);\n\t\t\t\tconst d2 = vec2.set(vec2.create(), 1, 0);\n\n\t\t\t\tvec2.transformMat2(d1, d1, parentBone.worldTransform);\n\t\t\t\tvec2.transformMat2(d2, d2, bone.worldTransform);\n\n\t\t\t\tconst sum = vec2.add(vec2.create(), d1, d2);\n\t\t\t\tconst localIn = vec2.transformMat2(this._InDirection, sum, inverseWorld);\n\t\t\t\tvec2.normalize(localIn, localIn);\n\t\t\t}\n\t\t\tvec2.scale(this._InPoint, this._InDirection, this._EaseIn*bone._Length*CurveConstant);\n\t\t}\n\t\telse\n\t\t{\t\t\t\n\t\t\tvec2.set(this._InDirection, 1, 0);\n\t\t\tvec2.set(this._InPoint, this._EaseIn*bone._Length*CurveConstant, 0);\n\t\t}\n\n\t\tif(this._OutTarget)\n\t\t{\n\t\t\tconst translation = this._OutTarget.worldTranslation;\n\t\t\tvec2.transformMat2d(this._OutPoint, translation, inverseWorld);\n\t\t\tconst tip = vec2.set(vec2.create(), bone._Length, 0.0);\n\t\t\tvec2.subtract(this._OutDirection, this._OutPoint, tip);\n\t\t\tvec2.normalize(this._OutDirection, this._OutDirection);\n\t\t}\n\t\telse if(bone._FirstBone)\n\t\t{\n\t\t\tconst firstBone = bone._FirstBone;\n\t\t\tconst firstBoneJelly = firstBone.jelly;\n\t\t\tif(firstBoneJelly && firstBoneJelly._InTarget)\n\t\t\t{\n\t\t\t\tconst translation = firstBoneJelly._InTarget.worldTranslation;\n\t\t\t\tconst worldChildInDir = vec2.subtract(vec2.create(), firstBone.worldTranslation, translation);\n\t\t\t\tvec2.transformMat2(this._OutDirection, worldChildInDir, inverseWorld);\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tconst d1 = vec2.set(vec2.create(), 1, 0);\n\t\t\t\tconst d2 = vec2.set(vec2.create(), 1, 0);\n\n\t\t\t\tvec2.transformMat2(d1, d1, firstBone.worldTransform);\n\t\t\t\tvec2.transformMat2(d2, d2, bone.worldTransform);\n\n\t\t\t\tconst sum = vec2.add(vec2.create(), d1, d2);\n\t\t\t\tvec2.negate(sum, sum);\n\t\t\t\tvec2.transformMat2(this._OutDirection, sum, inverseWorld);\n\t\t\t}\n\t\t\tvec2.normalize(this._OutDirection, this._OutDirection);\n\t\t\tconst scaledOut = vec2.scale(vec2.create(), this._OutDirection, this._EaseOut*bone._Length*CurveConstant);\n\t\t\tvec2.set(this._OutPoint, bone._Length, 0.0);\n\t\t\tvec2.add(this._OutPoint, this._OutPoint, scaledOut);\n\t\t}\n\t\telse\n\t\t{\n\t\t\tvec2.set(this._OutDirection, -1, 0);\n\n\t\t\tconst scaledOut = vec2.scale(vec2.create(), this._OutDirection, this._EaseOut*bone._Length*CurveConstant);\n\t\t\tvec2.set(this._OutPoint, bone._Length, 0.0);\n\t\t\tvec2.add(this._OutPoint, this._OutPoint, scaledOut);\n\t\t}\n\t\t\n\t\tthis.updateJellies();\n\t}\n}","import BezierAnimationCurve from \"./BezierAnimationCurve.js\";\n\nconst MAX_FACTOR = 0.99999;\nconst MIN_FACTOR = 1.0-MAX_FACTOR;\n\nlet TempBuffer = new Float32Array(32);\n\nfunction InterpolateVertexBuffer(buffer, from, to, mix)\n{\n\tif(buffer.length < to.length)\n\t{\n\t\tbuffer = new Float32Array(to.length);\n\t}\n\n\tconst mixi = 1.0 - mix;\n\tconst l = to.length;\n\n\tfor(let i = 0; i < l; i++)\n\t{\n\t\tbuffer[i] = from[i] * mixi + to[i] * mix;\n\t}\n\n\treturn buffer;\n}\n\nexport class KeyFrame\n{\n\tconstructor()\n\t{\n\t\tthis._Value = 0.0;\n\t\tthis._Time = 0.0;\n\t\tthis._Type = 0;\n\t\tthis._Interpolator = null;\n\t}\n\n\tsetNext(nxt)\n\t{\n\t\tif(this._Value.constructor === Float32Array)\n\t\t{\n\t\t\tthis.interpolate = KeyFrame.prototype.interpolateVertexBuffer;\n\t\t}\n\t\telse\n\t\t{\n\t\t\tthis.interpolate = KeyFrame.prototype.interpolateFloat;\n\t\t}\n\t}\n\n\tinterpolateVertexBuffer(mix, nxt)\n\t{\n\t\treturn (TempBuffer=InterpolateVertexBuffer(TempBuffer, this._Value, nxt._Value, mix));\n\t}\n\n\tinterpolateFloat(mix, nxt)\n\t{\n\t\treturn this._Value * (1.0-mix) + nxt._Value * mix;\n\t}\n}\n\nKeyFrame.Type =\n{\n\tHold:0,\n\tLinear:1,\n\tMirrored:2,\n\tAsymmetric:3,\n\tDisconnected:4,\n\tProgression:5\n};","export default class NestedActorAsset\n{\n\tconstructor(name, id)\n\t{\n\t\tthis._Id = id;\n\t\tthis._Name = name;\n\t\tthis._Actor = null;\n\t}\n\n\tget id()\n\t{\n\t\treturn this._Id;\n\t}\n\n\tget name()\n\t{\n\t\treturn this._Name;\n\t}\n\n\tget actor()\n\t{\n\t\treturn this._Actor;\n\t}\n}","import ActorNode from \"./ActorNode.js\";\nimport {vec2, mat2d} from \"gl-matrix\";\n\nexport default class NestedActorNode extends ActorNode\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\n\t\tthis._DrawOrder = 0;\n\t\tthis._Asset = null;\n\t\tthis._Instance = null;\n\t\tthis._Actor = null;\n\t}\n\n\tmakeInstance(resetActor)\n\t{\n\t\tconst node = new NestedActorNode();\n\t\tnode.copy(this, resetActor);\n\t\t\n\t\tif(this._Asset.actor)\n\t\t{\n\t\t\tnode._Actor = this._Asset.actor.makeInstance();\n\t\t}\n\t\treturn node;\t\n\t}\n\n\tcopy(node, resetActor)\n\t{\n\t\tsuper.copy(node, resetActor);\n\t\tthis._Asset = node._Asset;\n\t\tthis._DrawOrder = node._DrawOrder;\n\t}\n\n\tinitialize(actor, graphics)\n\t{\n\t\tif(this._Actor)\n\t\t{\n\t\t\tthis._Actor.initialize(graphics);\n\t\t}\n\t}\n\n\tupdateWorldTransform()\n\t{\n\t\tsuper.updateWorldTransform();\n\t\tif(this._Actor)\n\t\t{\n\t\t\tthis._Actor.root.overrideWorldTransform(this._WorldTransform);\n\t\t}\n\t}\n\n\tcomputeAABB()\n\t{\n\t\tif(this._Actor)\n\t\t{\n\t\t\treturn this._Actor.computeAABB();\n\t\t}\t\n\t\treturn null;\n\t}\n\n\tdraw(graphics)\n\t{\n\t\tif(this._Actor)\n\t\t{\n\t\t\tthis._Actor.draw(graphics);\n\t\t}\n\t}\n\n\tadvance(seconds)\n\t{\n\t\tsuper.advance(seconds);\n\t\tif(this._Actor)\n\t\t{\n\t\t\tthis._Actor.advance(seconds);\n\t\t}\n\t}\n}","import * as SVG from '@svgdotjs/svg.js/dist/svg.node.js'\n\nexport default function make(transform)\n{\n const matrix = new SVG.Matrix();\n matrix.a = transform[0];\n matrix.b = transform[1];\n matrix.c = transform[2];\n matrix.d = transform[3];\n matrix.e = transform[4];\n matrix.f = transform[5];\n\n return matrix;\n}","import {vec2} from \"gl-matrix\";\n\nconst TempMatrix = new Float32Array(6);\n\nexport class PointType\n{\n\tstatic get Straight()\n\t{\n\t\treturn 0;\n\t}\n\n\tstatic get Mirror()\n\t{\n\t\treturn 1;\n\t}\n\n\tstatic get Disconnected()\n\t{\n\t\treturn 2;\n\t}\n\n\tstatic get Asymmetric()\n\t{\n\t\treturn 3;\n\t}\n}\n\nexport class PathPoint\n{\n\tconstructor()\n\t{\n\t\tthis._PointType = PointType.Straight;\n\t\tthis._Translation = vec2.create();\n\t\tthis._Weights = null;\n\t}\n\n\tget pointType()\n\t{\n\t\treturn this._PointType;\n\t}\n\n\tget translation()\n\t{\n\t\treturn this._Translation;\n\t}\n\n\tmakeInstance()\n\t{\n\t\treturn null;\n\t}\n\n\tcopy(from)\n\t{\n\t\tthis._PointType = from._PointType;\n\t\tthis._Weights = from._Weights;\n\t\tvec2.copy(this._Translation, from._Translation);\n\t}\n}\n\nexport class StraightPathPoint extends PathPoint\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._Radius = 0;\n\t}\n\n\tget radius()\n\t{\n\t\treturn this._Radius;\n\t}\n\t\n\tmakeInstance()\n\t{\n\t\tconst node = new StraightPathPoint();\n\t\tStraightPathPoint.prototype.copy.call(node, this);\n\t\treturn node;\t\n\t}\n\n\tcopy(from)\n\t{\n\t\tsuper.copy(from);\n\t\tthis._Radius = from._Radius;\n\t}\n\n\tskin(world, bones)\n\t{\n\t\tlet {_Weights:weights, translation, pointType, radius} = this;\n\n\t\tlet px = world[0] * translation[0] + world[2] * translation[1] + world[4];\n\t\tlet py = world[1] * translation[0] + world[3] * translation[1] + world[5];\n\t\tconst point = { pointType, o:this, radius };\n\t\t\n\t\tconst fm = TempMatrix;\n\t\tfm.fill(0);\n\n\t\tfor(let i = 0; i < 4; i++)\n\t\t{\n\t\t\tconst boneIndex = weights[i];\n\t\t\tconst weight = weights[i+4];\n\t\t\tif(weight > 0)\n\t\t\t{\n\t\t\t\tlet bb = boneIndex*6;\n\t\t\t\tfor(let j = 0; j < 6; j++)\n\t\t\t\t{\n\t\t\t\t\tfm[j] += bones[bb+j] * weight;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tpoint.translation = new Float32Array([\n\t\t\tfm[0] * px + fm[2] * py + fm[4],\n\t\t\tfm[1] * px + fm[3] * py + fm[5]\n\t\t]);\n\t\t\n\t\treturn point;\n\t}\n}\n\nexport class CubicPathPoint extends PathPoint\n{\n\tconstructor()\n\t{\n\t\tsuper();\n\t\tthis._In = vec2.create();\n\t\tthis._Out = vec2.create();\n\t}\n\t\n\tget in()\n\t{\n\t\treturn this._In;\n\t}\n\t\n\tget out()\n\t{\n\t\treturn this._Out;\n\t}\n\t\n\tmakeInstance()\n\t{\n\t\tconst node = new CubicPathPoint();\n\t\tCubicPathPoint.prototype.copy.call(node, this);\n\t\treturn node;\t\n\t}\n\n\tcopy(from)\n\t{\n\t\tsuper.copy(from);\n\t\tvec2.copy(this._In, from._In);\n\t\tvec2.copy(this._Out, from._Out);\n\t}\n\n\tskin(world, bones)\n\t{\n\t\tlet {_Weights:weights, translation, pointType, out:op, in:ip} = this;\n\n\t\tlet px = world[0] * translation[0] + world[2] * translation[1] + world[4];\n\t\tlet py = world[1] * translation[0] + world[3] * translation[1] + world[5];\n\t\tconst point = { pointType, o:this };\n\t\t\n\t\tconst fm = TempMatrix;\n\t\tfm.fill(0);\n\n\t\tfor(let i = 0; i < 4; i++)\n\t\t{\n\t\t\tconst boneIndex = weights[i];\n\t\t\tconst weight = weights[i+4];\n\t\t\tif(weight > 0)\n\t\t\t{\n\t\t\t\tlet bb = boneIndex*6;\n\t\t\t\tfor(let j = 0; j < 6; j++)\n\t\t\t\t{\n\t\t\t\t\tfm[j] += bones[bb+j] * weight;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tpoint.translation = new Float32Array([\n\t\t\tfm[0] * px + fm[2] * py + fm[4],\n\t\t\tfm[1] * px + fm[3] * py + fm[5]\n\t\t]);\n\n\t\n\t\tpx = world[0] * ip[0] + world[2] * ip[1] + world[4];\n\t\tpy = world[1] * ip[0] + world[3] * ip[1] + world[5];\n\t\tfm.fill(0);\n\t\tfor(let i = 8; i < 12; i++)\n\t\t{\n\t\t\tconst boneIndex = weights[i];\n\t\t\tconst weight = weights[i+4];\n\t\t\tif(weight > 0)\n\t\t\t{\n\t\t\t\tlet bb = boneIndex*6;\n\t\t\t\tfor(let j = 0; j < 6; j++)\n\t\t\t\t{\n\t\t\t\t\tfm[j] += bones[bb+j] * weight;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tpoint.in = new Float32Array([\n\t\t\tfm[0] * px + fm[2] * py + fm[4],\n\t\t\tfm[1] * px + fm[3] * py + fm[5]\n\t\t]);\n\n\t\tpx = world[0] * op[0] + world[2] * op[1] + world[4];\n\t\tpy = world[1] * op[0] + world[3] * op[1] + world[5];\n\t\tfm.fill(0);\n\t\tfor(let i = 16; i < 20; i++)\n\t\t{\n\t\t\tconst boneIndex = weights[i];\n\t\t\tconst weight = weights[i+4];\n\t\t\tif(weight > 0)\n\t\t\t{\n\t\t\t\tlet bb = boneIndex*6;\n\t\t\t\tfor(let j = 0; j < 6; j++)\n\t\t\t\t{\n\t\t\t\t\tfm[j] += bones[bb+j] * weight;\n\t\t\t\t}\n\t\t\t}\n\t\t}\n\n\t\tpoint.out = new Float32Array([\n\t\t\tfm[0] * px + fm[2] * py + fm[4],\n\t\t\tfm[1] * px + fm[3] * py + fm[5]\n\t\t]);\n\n\t\treturn point;\n\t}\n}","import StreamReader from \"./StreamReader.js\";\n\nexport default class BinaryReader extends StreamReader\n{\n\tconstructor(uint8Array)\n\t{\n\t\tsuper();\n\t\tthis.isBigEndian = function()\n\t\t{\n\t\t\tconst b = new ArrayBuffer(4);\n\t\t\tconst a = new Uint32Array(b);\n\t\t\tconst c = new Uint8Array(b);\n\t\t\ta[0] = 0xdeadbeef;\n\t\t\treturn c[0] == 0xde;\n\t\t}();\n\n\t\tthis.raw = uint8Array;\n\t\tthis.dataView = new DataView(uint8Array.buffer);\n\t\tthis.readIndex = 0;\n\t}\n\n\treadFloat32()\n\t{\n\t\tconst v = this.dataView.getFloat32(this.readIndex, !this.isBigEndian);\n\t\tthis.readIndex += 4;\n\t\treturn v;\n\t}\n\n\treadFloat32ArrayOffset(ar, length, offset)\n\t{\n\t\tif(!offset)\n\t\t{\n\t\t\toffset = 0;\n\t\t}\n\t\tif (!length)\n\t\t{\n\t\t\tlength = ar.length;\n\t\t}\n\t\tlet end = offset + length;\n\t\tfor (let i = offset; i < end; i++)\n\t\t{\n\t\t\tar[i] = this.dataView.getFloat32(this.readIndex, !this.isBigEndian);\n\t\t\tthis.readIndex += 4;\n\t\t}\n\t\treturn ar;\n\t}\n\n\t\t\n\treadFloat32Array(ar)\n\t{\n\t\tfor (let i = 0; i < ar.length; i++)\n\t\t{\n\t\t\tar[i] = this.dataView.getFloat32(this.readIndex, !this.isBigEndian);\n\t\t\tthis.readIndex += 4;\n\t\t}\n\t\treturn ar;\n\t}\n\n\treadFloat64()\n\t{\n\t\tconst v = this.dataView.getFloat64(this.readIndex, !this.isBigEndian);\n\t\tthis.readIndex += 8;\n\t\treturn v;\n\t}\n\n\treadUint8()\n\t{\n\t\treturn this.raw[this.readIndex++];\n\t}\n\n\tisEOF()\n\t{\n\t\treturn this.readIndex >= this.raw.length;\n\t}\n\n\treadInt8()\n\t{\n\t\tconst v = this.dataView.getInt8(this.readIndex);\n\t\tthis.readIndex += 1;\n\t\treturn v;\n\t}\n\n\treadUint16()\n\t{\n\t\tconst v = this.dataView.getUint16(this.readIndex, !this.isBigEndian);\n\t\tthis.readIndex += 2;\n\t\treturn v;\n\t}\n\n\treadUint16Array(ar, length)\n\t{\n\t\tif (!length)\n\t\t{\n\t\t\tlength = ar.length;\n\t\t}\n\t\tfor (let i = 0; i < length; i++)\n\t\t{\n\t\t\tar[i] = this.dataView.getUint16(this.readIndex, !this.isBigEndian);\n\t\t\tthis.readIndex += 2;\n\t\t}\n\t\treturn ar;\n\t}\n\n\treadInt16()\n\t{\n\t\tconst v = this.dataView.getInt16(this.readIndex, !this.isBigEndian);\n\t\tthis.readIndex += 2;\n\t\treturn v;\n\t}\n\n\treadUint32()\n\t{\n\t\tconst v = this.dataView.getUint32(this.readIndex, !this.isBigEndian);\n\t\tthis.readIndex += 4;\n\t\treturn v;\n\t}\n\n\treadInt32()\n\t{\n\t\tconst v = this.dataView.getInt32(this.readIndex, !this.isBigEndian);\n\t\tthis.readIndex += 4;\n\t\treturn v;\n\t}\n\n\tbyteArrayToString(bytes)\n\t{\n\t\tlet out = [],\n\t\t\tpos = 0,\n\t\t\tc = 0;\n\t\twhile (pos < bytes.length)\n\t\t{\n\t\t\tlet c1 = bytes[pos++];\n\t\t\tif (c1 < 128)\n\t\t\t{\n\t\t\t\tout[c++] = String.fromCharCode(c1);\n\t\t\t}\n\t\t\telse if (c1 > 191 && c1 < 224)\n\t\t\t{\n\t\t\t\tlet c2 = bytes[pos++];\n\t\t\t\tout[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);\n\t\t\t}\n\t\t\telse if (c1 > 239 && c1 < 365)\n\t\t\t{\n\t\t\t\t// Surrogate Pair\n\t\t\t\tlet c2 = bytes[pos++];\n\t\t\t\tlet c3 = bytes[pos++];\n\t\t\t\tlet c4 = bytes[pos++];\n\t\t\t\tlet u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) -\n\t\t\t\t\t0x10000;\n\t\t\t\tout[c++] = String.fromCharCode(0xD800 + (u >> 10));\n\t\t\t\tout[c++] = String.fromCharCode(0xDC00 + (u & 1023));\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tlet c2 = bytes[pos++];\n\t\t\t\tlet c3 = bytes[pos++];\n\t\t\t\tout[c++] =\n\t\t\t\t\tString.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);\n\t\t\t}\n\t\t}\n\t\treturn out.join(\"\");\n\t}\n\n\treadString()\n\t{\n\t\tconst length = this.readUint32();\n\t\tconst ua = new Uint8Array(length);\n\t\tfor (let i = 0; i < length; i++)\n\t\t{\n\t\t\tua[i] = this.raw[this.readIndex++];\n\t\t}\n\t\treturn this.byteArrayToString(ua);\n\t}\n\n\treadRaw(to, length)\n\t{\n\t\tfor (let i = 0; i < length; i++)\n\t\t{\n\t\t\tto[i] = this.raw[this.readIndex++];\n\t\t}\n\t}\n\n\treadBool()\n\t{\n\t\treturn this.readUint8() === 1;\n\t}\n\n\treadBlockType() \n\t{\n\t\treturn this.readUint8();\n\t}\n\n\treadImage(isOOB, cb)\n\t{\n\t\tif(isOOB)\n\t\t{\n\t\t\tconst image = this.readString();\n\t\t\tconst req = new XMLHttpRequest();\n\t\t\treq.open(\"GET\", image, true);\n\t\t\treq.responseType = \"blob\";\n\n\t\t\treq.onload = function()\n\t\t\t{\n\t\t\t\tconst blob = this.response;\n\t\t\t\tcb(blob);\n\t\t\t};\n\t\t\treq.send();\n\t\t}\n\t\telse\n\t\t{\n\t\t\tconst size = this.readUint32();\n\t\t\tconst atlasData = new Uint8Array(size);\n\t\t\tthis.readRaw(atlasData, atlasData.length);\n\t\t\tconst blob = new Blob([atlasData], {type: \"image/png\"});\n\n\t\t\tcb(blob);\n\t\t}\n\t}\n\t\n\treadId(label)\n\t{\n\t\treturn this.readUint16();\n\t}\n\t\n\treadUint8Length() \n\t{\n\t\treturn this.readUint8();\n\t}\n\n\treadUint16Length()\n\t{\n\t\treturn this.readUint16();\n\t}\n\n\treadUint32Length()\n\t{\n\t\treturn this.readUint32();\n\t}\n\n\tget containerType() { return \"bin\"; }\n}\n\nBinaryReader.alignment = 1024;","import StreamReader from \"./StreamReader.js\";\n\nexport default class JSONReader extends StreamReader\n{\n\tconstructor(object)\n\t{\n\t\tsuper();\n\t\tthis._readObject = object[\"container\"];\n\t\tthis._context = [this._readObject];\n\t}\n\n readProp(label)\n {\n\t\tconst head = this._last;\n\t\tif(head.constructor === Object)\n\t\t{\n\t\t\tconst prop = head[label];\n\t\t\tdelete head[label];\n\t\t\treturn prop;\n\t\t}\n\t\telse if(head.constructor === Array)\n\t\t{\n\t\t\treturn head.shift();\n\t\t}\n\t}\n\n\treadFloat32(label)\n\t{\n return this.readProp(label);\n\t}\n\n\t// Reads the array into ar\n\treadFloat32Array(ar, label)\n\t{\n\t\treturn this.readArray(ar, label);\n\t}\n\n\treadFloat32ArrayOffset(ar, length, offset, label)\n\t{\n\t\treturn this.readFloat32Array(ar, label);\n\t}\n\n\treadArray(ar, label)\n\t{\n\t\tconst array = this.readProp(label);\n\t\tif (array) // I think there's a bug here.\n\t\t{\n\t\t\tfor (let i = 0; i < ar.length; i++)\n\t\t\t{\n\t\t\t\tar[i] = array[i];\n\t\t\t}\n\t\t}\n\n\t\treturn ar;\n\t}\n\n\treadFloat64(label)\n\t{\n return this.readProp(label);\n }\n\n\treadUint8(label)\n\t{\n return this.readProp(label);\n\t}\n\n\treadUint8Length()\n\t{\n\t\treturn this._readLength();\n\t}\n\n\tisEOF()\n\t{\n\t\treturn this._context.length <= 1 && Object.keys(this._readObject).length === 0;\n\t}\n\n\treadInt8(label)\n\t{\n return this.readProp(label);\n }\n\n\treadUint16(label)\n\t{\n return this.readProp(label);\n }\n\n\treadUint16Array(ar, label)\n\t{\n\t\treturn this.readArray(ar, label);\n\t}\n\n\treadInt16(label)\n\t{\n return this.readProp(label);\n\t}\n\n\treadUint16Length()\n\t{\n\t\treturn this._readLength();\n\t}\n\n\treadUint32(label)\n\t{\n return this.readProp(label);\n }\n\n\t// This implementation doesn't need this, as it would read a wrong value.\n\t// readUint32Length(label)\n\t// {\n // return this.readProp(label);\n // }\n\n\tbyteArrayToString(bytes)\n\t{\n\t\tlet out = [],\n\t\t\tpos = 0,\n\t\t\tc = 0;\n\t\twhile (pos < bytes.length)\n\t\t{\n\t\t\tlet c1 = bytes[pos++];\n\t\t\tif (c1 < 128)\n\t\t\t{\n\t\t\t\tout[c++] = String.fromCharCode(c1);\n\t\t\t}\n\t\t\telse if (c1 > 191 && c1 < 224)\n\t\t\t{\n\t\t\t\tlet c2 = bytes[pos++];\n\t\t\t\tout[c++] = String.fromCharCode((c1 & 31) << 6 | c2 & 63);\n\t\t\t}\n\t\t\telse if (c1 > 239 && c1 < 365)\n\t\t\t{\n\t\t\t\t// Surrogate Pair\n\t\t\t\tlet c2 = bytes[pos++];\n\t\t\t\tlet c3 = bytes[pos++];\n\t\t\t\tlet c4 = bytes[pos++];\n\t\t\t\tlet u = ((c1 & 7) << 18 | (c2 & 63) << 12 | (c3 & 63) << 6 | c4 & 63) -\n\t\t\t\t\t0x10000;\n\t\t\t\tout[c++] = String.fromCharCode(0xD800 + (u >> 10));\n\t\t\t\tout[c++] = String.fromCharCode(0xDC00 + (u & 1023));\n\t\t\t}\n\t\t\telse\n\t\t\t{\n\t\t\t\tlet c2 = bytes[pos++];\n\t\t\t\tlet c3 = bytes[pos++];\n\t\t\t\tout[c++] =\n\t\t\t\t\tString.fromCharCode((c1 & 15) << 12 | (c2 & 63) << 6 | c3 & 63);\n\t\t\t}\n\t\t}\n\t\treturn out.join(\"\");\n\t}\n\n\treadString(label)\n\t{\n return this.readProp(label);\n\t}\n\n\treadBool(label)\n\t{\n\t\treturn this.readProp(label);\n\t}\n\n\treadRaw(obj, length, label)\n\t{\n\t\tconst context = this._last;\n\t\tconst next = this._peekNext();\n\t\tobj[\"container\"] = next;\n\t\t// Remove the block from here.\n\t\tif(context.constructor === Object)\n\t\t{\n\t\t\tdelete context[this._nextKey];\n\t\t}\n\t\telse if(context.constructor === Array)\n\t\t{\n\t\t\tcontext.shift();\n\t\t}\n\t}\n\n\treadBlockType(block)\n\t{\n\t\tconst next = this._peekNext();\n\t\tlet bType;\n\t\tif(next.constructor === Object)\n\t\t{\n\t\t\tconst last = this._last;\n\t\t\tlet nType;\n\t\t\tif(last.constructor === Object)\n\t\t\t{\n\t\t\t\tnType = this._nextKey;\n\t\t\t}\n\t\t\telse if(last.constructor === Array)\n\t\t\t{\n\t\t\t\t// Objects are serialized with \"type\" property.\n\t\t\t\tnType = next[\"type\"];\n\t\t\t}\n\t\t\tbType = block.fromString(nType) || nType;\n\t\t}\n\t\telse if(next.constructor === Array)\n\t\t{\n\t\t\t// Arrays are serialized as \"type\": [Array].\n\t\t\tconst nKey = this._nextKey;\n\t\t\tbType = block.fromString(nKey) || nKey;\n\t\t}\n\t\treturn bType;\n\t}\n\n\treadImage(isOOB, cb)\n\t{\n\t\tconst image = this.readString();\n\t\tif(isOOB)\n\t\t{\n\t\t\tconst req = new XMLHttpRequest();\n\t\t\treq.open(\"GET\", image, true);\n\t\t\treq.responseType = \"blob\";\n\n\t\t\treq.onload = function()\n\t\t\t{\n\t\t\t\tconst blob = this.response;\n\t\t\t\tcb(blob);\n\t\t\t};\n\t\t\treq.send();\n\t\t}\n\t\telse\n\t\t{\n\t\t\tcb(image);\n\t\t}\n\t}\n\n\treadId(label)\n\t{\n\t\tconst val = this.readUint16(label);\n\t\treturn val !== undefined ? val+1 : 0;\n\t}\n\n\topenArray(label)\n\t{\n\t\tconst array = this.readProp(label);\n\t\tthis._context.unshift(array);\n\t}\n\n\tcloseArray()\n\t{\n\t\tthis._context.shift();\n\t}\n\n\topenObject(label)\n\t{\n\t\tconst o = this.readProp(label);\n\t\tthis._context.unshift(o);\n\t}\n\n\tcloseObject()\n\t{\n\t\tthis._context.shift();\n\t}\n\n\tget containerType()\n\t{\n\t\treturn \"json\";\n\t}\n\n\t_peekNext()\n\t{\n\t\tconst stream = this._last;\n\t\tlet next;\n\t\tif(stream.constructor === Object)\n\t\t{\n\t\t\tnext = stream[this._nextKey];\n\t\t}\n\t\telse if(stream.constructor === Array)\n\t\t{\n\t\t\tnext = stream[0];\n\t\t}\n\t\treturn next;\n\t}\n\n\tget _nextKey()\n\t{\n\t\treturn Object.keys(this._last)[0];\n\t}\n\n\t_readLength()\n\t{\n\t\tconst context = this._last;\n\t\tif(context.constructor === Array)\n\t\t{\n\t\t\treturn context.length;\n\t\t}\n\t\telse if(context.constructor === Object)\n\t\t{\n\t\t\treturn Object.keys(context).length;\n\t\t}\n\t}\n\n\tget _last()\n\t{\n\t\treturn this._context[0];\n\t}\n}","export default class StreamReader\n{\n constructor() {}\n readFloat32() {}\n readFloat32Array(ar, length, offset) {}\n readFloat32ArrayOffset(ar, length, offset) {}\n readFloat64() {}\n isEOF() {}\n readInt8() {}\n readUint8() {}\n readUint8Length() {}\n readUint16() {}\n readUint16Array(ar, length) {}\n readUint16Length() {}\n readInt16() {}\n readUint32() {}\n readUint32Length() {}\n readInt32() {}\n byteArrayToString(bytes) {}\n readString() {}\n readRaw(to, length) {}\n \n readBool() {}\n readBlockType() {}\n readImage(isOOB, cb) {}\n\n readId(label) {}\n\n openArray(label) {}\n closeArray() {}\n openObject(label) {}\n closeObject() {}\n\n get containerType() { return \"stream\"; }\n}\n","const TransformSpace =\n{\n\tLocal:0,\n\tWorld:1\n};\n\nexport default TransformSpace;\n"],"sourceRoot":""} \ No newline at end of file diff --git a/example/example.html b/example/example.html index 33b63a1..c9b5e86 100644 --- a/example/example.html +++ b/example/example.html @@ -5,12 +5,6 @@ 2Dimensions - Flare Example - - - - - - diff --git a/example/example.js b/example/example.js index ed7d13d..c054d45 100644 --- a/example/example.js +++ b/example/example.js @@ -1,179 +1,178 @@ -const FlareExample = (function () +import { mat2d } from 'gl-matrix' +const Flare = require('../source/Flare.js') + +const _ViewCenter = [500.0, 500.0]; +const _Scale = 0.5; + +function FlareExample(canvas) { - const _ViewCenter = [500.0, 500.0]; - const _Scale = 0.5; - const _ScreenScale = 1.0; + this._Graphics = new Flare.Graphics(canvas); + this._LastAdvanceTime = Date.now(); + this._ViewTransform = mat2d.create(); + this._AnimationInstance = null; + this._Animation = null; + this._SoloSkaterAnimation = null; - const _ScreenMouse = vec2.create(); - const _WorldMouse = vec2.create(); + const _This = this; - function FlareExample(canvas) - { - this._Graphics = new Flare.Graphics(canvas); - this._LastAdvanceTime = Date.now(); - this._ViewTransform = mat2d.create(); - this._AnimationInstance = null; - this._Animation = null; - this._SoloSkaterAnimation = null; + _ScheduleAdvance(_This); + _Advance(_This); +} - const _This = this; +function _Advance(_This) +{ + _ScheduleAdvance(_This); - _ScheduleAdvance(_This); - _Advance(_This); + _This.setSize(self.innerWidth, self.innerHeight); - document.addEventListener("keydown", function(ev) - { - // 68 D - // 65 A - // 39 right - // 37 left - switch(ev.keyCode) - { - case 32: // Enter - break; - case 16: // Shift - break; - case 68: // 'D' - case 39: // right - break; - case 65: // 'A' - case 37: // left - break; - case 87: - case 38: - break; + const now = Date.now(); + const elapsed = (now - _This._LastAdvanceTime)/1000.0; + _This._LastAdvanceTime = now; - } - }); + const actor = _This._ActorInstance; + if(_This._AnimationInstance) + { + const ai = _This._AnimationInstance; + ai.time = ai.time + elapsed; + ai.apply(_This._ActorInstance, 1.0); } - function _Advance(_This) + if(actor) { - _This.setSize(window.innerWidth, window.innerHeight); + const graphics = _This._Graphics; - const now = Date.now(); - const elapsed = (now - _This._LastAdvanceTime)/1000.0; - _This._LastAdvanceTime = now; + const w = graphics.viewportWidth; + const h = graphics.viewportHeight; - const actor = _This._ActorInstance; + const vt = _This._ViewTransform; + vt[0] = _Scale; + vt[3] = _Scale; + vt[4] = (-_ViewCenter[0] * _Scale + w/2); + vt[5] = (-_ViewCenter[1] * _Scale + h/2); - if(_This._AnimationInstance) - { - const ai = _This._AnimationInstance; - ai.time = ai.time + elapsed; - ai.apply(_This._ActorInstance, 1.0); - } + actor.advance(elapsed); + } - if(actor) - { - const graphics = _This._Graphics; - - const w = graphics.viewportWidth; - const h = graphics.viewportHeight; - - const vt = _This._ViewTransform; - vt[0] = _Scale; - vt[3] = _Scale; - vt[4] = (-_ViewCenter[0] * _Scale + w/2); - vt[5] = (-_ViewCenter[1] * _Scale + h/2); - - actor.advance(elapsed); - } + _Draw(_This, _This._Graphics); +} - _Draw(_This, _This._Graphics); - _ScheduleAdvance(_This); - } +let count = 0 - function _Draw(viewer, graphics) - { - if(!viewer._Actor) - { - return; - } +setInterval(() => { + console.log(count) - graphics.clear([0.3628, 0.3628, 0.3628, 1.0]); - graphics.setView(viewer._ViewTransform); - viewer._ActorInstance.draw(graphics); - } + count = 0 +}, 1000) - function _ScheduleAdvance(viewer) +function _Draw(viewer, graphics) +{ + if(!viewer._Actor) { - clearTimeout(viewer._AdvanceTimeout); - //if(document.hasFocus()) - { - window.requestAnimationFrame(function() - { - _Advance(viewer); - }); - } - /*else - { - viewer._AdvanceTimeout = setTimeout(function() - { - _Advance(viewer); - }, _LowFrequencyAdvanceTime); - }*/ + return; } - FlareExample.prototype.load = function(url, callback) + count++ + + graphics.clear([0.3628, 0.3628, 0.3628, 1.0]); + graphics.setView(viewer._ViewTransform); + viewer._ActorInstance.draw(graphics); +} + +function _ScheduleAdvance(viewer) +{ { - const loader = new Flare.ActorLoader(); - const _This = this; - loader.load(url, function(actor) - { - if(!actor || actor.error) - { - callback(!actor ? null : actor.error); - } - else + self.requestAnimationFrame(function() { - _This.setActor(actor); - callback(); - } - }); - }; + _Advance(viewer); + }); + } +} - FlareExample.prototype.setActor = function(actor) +FlareExample.prototype.load = function(url, callback) +{ + const loader = new Flare.ActorLoader(); + const _This = this; + loader.load(url, function(actor) { - if(this._Actor) + if(!actor || actor.error) { - this._Actor.dispose(this._Graphics); + callback(!actor ? null : actor.error); } - if(this._ActorInstance) + else { - this._ActorInstance.dispose(this._Graphics); + _This.setActor(actor); + callback(); } - actor.initialize(this._Graphics); + }); +}; - const actorInstance = actor.makeInstance(); - actorInstance.initialize(this._Graphics); - - this._Actor = actor; - this._ActorInstance = actorInstance; +FlareExample.prototype.setActor = function(actor) +{ + if(this._Actor) + { + this._Actor.dispose(this._Graphics); + } + if(this._ActorInstance) + { + this._ActorInstance.dispose(this._Graphics); + } + actor.initialize(this._Graphics); + + const actorInstance = actor.makeInstance(); + actorInstance.initialize(this._Graphics); - if(actorInstance) + this._Actor = actor; + this._ActorInstance = actorInstance; + + if(actorInstance) + { + actorInstance.initialize(this._Graphics); + if(actorInstance._Animations.length) { - actorInstance.initialize(this._Graphics); - if(actorInstance._Animations.length) - { - this._Animation = actorInstance._Animations[0]; - this._AnimationInstance = new Flare.AnimationInstance(this._Animation._Actor, this._Animation); - - if(!this._AnimationInstance) - { - console.log("NO ANIMATION IN HERE!?"); - return; - } + this._Animation = actorInstance._Animations[0]; + this._AnimationInstance = new Flare.AnimationInstance(this._Animation._Actor, this._Animation); + if(!this._AnimationInstance) + { + console.log("NO ANIMATION IN HERE!?"); + return; } + } - }; + } +}; - FlareExample.prototype.setSize = function(width, height) - { - this._Graphics.setSize(width, height); - }; +FlareExample.prototype.setSize = function(width, height) +{ + this._Graphics.setSize(width, height); +}; - return FlareExample; -}()); \ No newline at end of file +let flareExample; + +self.addEventListener("message", (event) => { + switch (event.data.type) + { + case "INIT": + /* + * Window isn't available in WW so we're getting this info + * passed from the main thread and then mocking it. IRL it + * would make sense for the app to have no refs to window. + */ + self.innerWidth = event.data.innerWidth + self.innerHeight = event.data.innerHeight + flareExample = new FlareExample(event.data.canvas); + break; + + case "LOAD": + flareExample.load(event.data.url, function (error) { + if (error) { + console.log("failed to load actor file...", error); + } + }); + break; + + case "SET_SIZE": + flareExample.setSize(event.data.width, event.data.height) + } +}); \ No newline at end of file diff --git a/example/minion.flr b/example/minion.flr new file mode 100644 index 0000000..49d2d95 --- /dev/null +++ b/example/minion.flr @@ -0,0 +1,5133 @@ +{ + "version": 18, + "artboards": [ + { + "name": "Artboard", + "translation": [ + 328.812744140625, + 133.8751220703125 + ], + "width": 1024, + "height": 768, + "origin": [ + 0, + 0 + ], + "clipContents": true, + "color": [ + 0.364705890417099, + 0.364705890417099, + 0.364705890417099, + 1 + ], + "nodes": [ + { + "name": "Legs", + "translation": [ + 514.1832275390625, + 518.8373413085938 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "right", + "parent": 0, + "translation": [ + 32.19793701171875, + -16.36273193359375 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "Shape", + "parent": 1, + "translation": [ + 4.33880615234375, + 61.2327880859375 + ], + "rotation": 0, + "scale": [ + 12.287601470947266, + 12.287601470947266 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 4, + "type": "shape" + }, + { + "name": "Color", + "parent": 2, + "opacity": 1, + "color": [ + 0.27450981736183167, + 0.27843138575553894, + 0.27843138575553894, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 2, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": false, + "points": [ + { + "pointType": 2, + "translation": [ + -1.7007495164871216, + -1.2241008281707764 + ], + "in": [ + -1.7007495164871216, + -1.2241008281707764 + ], + "out": [ + -1.7140495777130127, + -1.1733007431030273 + ] + }, + { + "pointType": 2, + "translation": [ + -1.7007495164871216, + 0.6402992010116577 + ], + "in": [ + -1.7007495164871216, + 0.6402992010116577 + ], + "out": [ + -1.7007495164871216, + 0.6402992010116577 + ] + }, + { + "pointType": 2, + "translation": [ + -1.342049479484558, + 0.7036992311477661 + ], + "in": [ + -1.342049479484558, + 0.7036992311477661 + ], + "out": [ + -1.342049479484558, + 0.7036992311477661 + ] + }, + { + "pointType": 1, + "translation": [ + 0.5978504419326782, + 1.2240992784500122 + ], + "in": [ + -0.611249566078186, + 1.3890992403030396 + ], + "out": [ + 1.8070504665374756, + 1.0590991973876953 + ] + }, + { + "pointType": 1, + "translation": [ + 1.700750470161438, + 0.970299243927002 + ], + "in": [ + 1.700750470161438, + 0.970299243927002 + ], + "out": [ + 1.700750470161438, + 0.970299243927002 + ] + }, + { + "pointType": 2, + "translation": [ + 1.2223504781723022, + -0.36240077018737793 + ], + "in": [ + 1.7671505212783813, + -0.10860077291727066 + ], + "out": [ + 0.6776504516601562, + -0.6163007616996765 + ] + }, + { + "pointType": 2, + "translation": [ + 0.6905504465103149, + -1.1889008283615112 + ], + "in": [ + 0.6639504432678223, + -0.8716007471084595 + ], + "out": [ + 0.6905504465103149, + -1.1889008283615112 + ] + } + ], + "type": "path" + }, + { + "name": "Shape", + "parent": 1, + "translation": [ + 3.6390380859375, + 28.002197265625 + ], + "rotation": 0, + "scale": [ + 12.287601470947266, + 12.287601470947266 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 6, + "type": "shape" + }, + { + "name": "Color", + "parent": 5, + "opacity": 1, + "color": [ + 0.239215686917305, + 0.6078431606292725, + 0.886274516582489, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 5, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": false, + "points": [ + { + "pointType": 2, + "translation": [ + 2.717600107192993, + -1.632401704788208 + ], + "in": [ + 2.717600107192993, + -1.632401704788208 + ], + "out": [ + 2.717600107192993, + -1.632401704788208 + ] + }, + { + "pointType": 3, + "translation": [ + 1.4022001028060913, + 1.2744983434677124 + ], + "in": [ + 1.6945000886917114, + 0.3531983494758606 + ], + "out": [ + 1.335900068283081, + 1.4834983348846436 + ] + }, + { + "pointType": 2, + "translation": [ + 0.9324000477790833, + 1.6323983669281006 + ], + "in": [ + 1.1517000198364258, + 1.6323983669281006 + ], + "out": [ + 0.9324000477790833, + 1.6323983669281006 + ] + }, + { + "pointType": 2, + "translation": [ + -1.2055999040603638, + 1.6323983669281006 + ], + "in": [ + -1.2055999040603638, + 1.6323983669281006 + ], + "out": [ + -1.2055999040603638, + 1.6323983669281006 + ] + }, + { + "pointType": 1, + "translation": [ + -2.1473000049591064, + 0.8452983498573303 + ], + "in": [ + -2.3237998485565186, + 1.800998330116272 + ], + "out": [ + -1.9706999063491821, + -0.11040166765451431 + ] + }, + { + "pointType": 2, + "translation": [ + -2.717599868774414, + -1.038801670074463 + ], + "in": [ + -2.717599868774414, + -1.038801670074463 + ], + "out": [ + -2.717599868774414, + -1.038801670074463 + ] + } + ], + "type": "path" + }, + { + "name": "left", + "parent": 0, + "translation": [ + -33.516357421875, + -14.637985229492188 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "Shape", + "parent": 8, + "translation": [ + -0.733123779296875, + 59.508056640625 + ], + "rotation": 0, + "scale": [ + 12.287601470947266, + 12.287601470947266 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 5, + "type": "shape" + }, + { + "name": "Color", + "parent": 9, + "opacity": 1, + "color": [ + 0.27450981736183167, + 0.27843138575553894, + 0.27843138575553894, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 9, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": false, + "points": [ + { + "pointType": 2, + "translation": [ + 1.7283499240875244, + -1.2241008281707764 + ], + "in": [ + 1.7283499240875244, + -1.2241008281707764 + ], + "out": [ + 1.741649866104126, + -1.1733007431030273 + ] + }, + { + "pointType": 2, + "translation": [ + 1.673149824142456, + 0.6402992010116577 + ], + "in": [ + 1.673149824142456, + 0.6402992010116577 + ], + "out": [ + 1.673149824142456, + 0.6402992010116577 + ] + }, + { + "pointType": 2, + "translation": [ + 1.3144499063491821, + 0.7036992311477661 + ], + "in": [ + 1.3144499063491821, + 0.7036992311477661 + ], + "out": [ + 1.3144499063491821, + 0.7036992311477661 + ] + }, + { + "pointType": 1, + "translation": [ + -0.6254501342773438, + 1.2240992784500122 + ], + "in": [ + 0.5836498737335205, + 1.3890992403030396 + ], + "out": [ + -1.8346501588821411, + 1.0590991973876953 + ] + }, + { + "pointType": 1, + "translation": [ + -1.7283501625061035, + 0.970299243927002 + ], + "in": [ + -1.7283501625061035, + 0.970299243927002 + ], + "out": [ + -1.7283501625061035, + 0.970299243927002 + ] + }, + { + "pointType": 2, + "translation": [ + -1.2499501705169678, + -0.36240077018737793 + ], + "in": [ + -1.7947500944137573, + -0.10860077291727066 + ], + "out": [ + -0.7052501440048218, + -0.6163007616996765 + ] + }, + { + "pointType": 2, + "translation": [ + -0.6859501004219055, + -1.1772007942199707 + ], + "in": [ + -0.6593501567840576, + -0.8599007725715637 + ], + "out": [ + -0.6859501004219055, + -1.1772007942199707 + ] + } + ], + "type": "path" + }, + { + "name": "Shape", + "parent": 8, + "translation": [ + 0.2984619140625, + 25.2833251953125 + ], + "rotation": 0, + "scale": [ + 12.287601470947266, + 12.287601470947266 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 7, + "type": "shape" + }, + { + "name": "Color", + "parent": 12, + "opacity": 1, + "color": [ + 0.239215686917305, + 0.6078431606292725, + 0.886274516582489, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 12, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": false, + "points": [ + { + "pointType": 2, + "translation": [ + -2.657900094985962, + -1.7132995128631592 + ], + "in": [ + -2.657900094985962, + -1.7132995128631592 + ], + "out": [ + -2.657900094985962, + -1.7132995128631592 + ] + }, + { + "pointType": 2, + "translation": [ + -1.3604001998901367, + 1.3918004035949707 + ], + "in": [ + -1.6266001462936401, + 0.45960044860839844 + ], + "out": [ + -1.3053001165390015, + 1.5849003791809082 + ] + }, + { + "pointType": 2, + "translation": [ + -0.9235001802444458, + 1.7133004665374756 + ], + "in": [ + -1.1243001222610474, + 1.7133004665374756 + ], + "out": [ + -0.9235001802444458, + 1.7133004665374756 + ] + }, + { + "pointType": 2, + "translation": [ + 1.2322998046875, + 1.7133004665374756 + ], + "in": [ + 1.2322998046875, + 1.7133004665374756 + ], + "out": [ + 1.2322998046875, + 1.7133004665374756 + ] + }, + { + "pointType": 1, + "translation": [ + 2.1738998889923096, + 0.9262004494667053 + ], + "in": [ + 2.3504998683929443, + 1.881900429725647 + ], + "out": [ + 1.9973998069763184, + -0.029499566182494164 + ] + }, + { + "pointType": 2, + "translation": [ + 2.657899856567383, + -1.0047996044158936 + ], + "in": [ + 2.657899856567383, + -1.0047996044158936 + ], + "out": [ + 2.657899856567383, + -1.0047996044158936 + ] + } + ], + "type": "path" + }, + { + "name": "body", + "translation": [ + 516.013671875, + 379.346923828125 + ], + "rotation": 0, + "scale": [ + 12.287601470947266, + 12.287601470947266 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "right arm", + "parent": 15, + "translation": [ + 9.204228401184082, + 0.2477990835905075 + ], + "rotation": 0.00039833339828418624, + "scale": [ + 0.08138284832239151, + 0.08234841376543045 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "hand", + "parent": 16, + "translation": [ + -4.065072536468506, + -21.127206802368164 + ], + "rotation": -0.00039366396707842845, + "scale": [ + 0.9999999403953552, + 0.9882745742797852 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 2, + "type": "shape" + }, + { + "name": "Path", + "parent": 17, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": false, + "points": [ + { + "pointType": 1, + "translation": [ + -3.1883742809295654, + 4.92755126953125 + ], + "in": [ + -21.629899978637695, + -1.30621337890625 + ], + "out": [ + 15.253150939941406, + 11.16131591796875 + ] + }, + { + "pointType": 2, + "translation": [ + 22.11700439453125, + 66.15670776367188 + ], + "in": [ + 20.22064208984375, + 34.299560546875 + ], + "out": [ + 24.07562255859375, + 99.06051635742188 + ] + }, + { + "pointType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "in": [ + 19.040069580078125, + 128.6617431640625 + ], + "out": [ + 5.375457763671875, + 146.66290283203125 + ] + } + ], + "type": "path" + }, + { + "name": "Color", + "parent": 17, + "opacity": 5, + "color": [ + 1, + 0.8235294222831726, + 0.29019609093666077, + 1 + ], + "width": 24, + "type": "colorStroke" + }, + { + "name": "Node", + "parent": 16, + "translation": [ + 11.763854026794434, + 101.39745330810547 + ], + "rotation": -1.701747250060226e-11, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "fist", + "parent": 20, + "translation": [ + -10.441754341125488, + 29.273775100708008 + ], + "rotation": 0.01069625900144239, + "scale": [ + 12.287585258483887, + 12.143492698669434 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 3, + "type": "shape" + }, + { + "name": "Color", + "parent": 21, + "opacity": 1, + "color": [ + 0.27450981736183167, + 0.27843138575553894, + 0.27843138575553894, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 21, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 2, + "translation": [ + 1.9941506385803223, + -2.0428006649017334 + ], + "in": [ + 1.9941506385803223, + -2.0428006649017334 + ], + "out": [ + 1.9941506385803223, + -2.0428006649017334 + ] + }, + { + "pointType": 1, + "translation": [ + 2.0755505561828613, + -0.5447007417678833 + ], + "in": [ + 1.8438506126403809, + -1.4787007570266724 + ], + "out": [ + 2.307250738143921, + 0.3892992436885834 + ] + }, + { + "pointType": 1, + "translation": [ + 1.7971506118774414, + 1.5706992149353027 + ], + "in": [ + 2.5513505935668945, + 1.417399287223816 + ], + "out": [ + 1.0430506467819214, + 1.7240992784500122 + ] + }, + { + "pointType": 1, + "translation": [ + 0.9245506525039673, + 1.6362992525100708 + ], + "in": [ + 0.9245506525039673, + 1.6362992525100708 + ], + "out": [ + 0.9245506525039673, + 1.6362992525100708 + ] + }, + { + "pointType": 1, + "translation": [ + 0.09475064277648926, + 2.679899215698242 + ], + "in": [ + 0.8225506544113159, + 2.6013991832733154 + ], + "out": [ + -0.6329493522644043, + 2.7584991455078125 + ] + }, + { + "pointType": 2, + "translation": [ + -1.4509493112564087, + 1.161299228668213 + ], + "in": [ + -1.166749358177185, + 2.4294991493225098 + ], + "out": [ + -1.4509493112564087, + 1.161299228668213 + ] + }, + { + "pointType": 1, + "translation": [ + -2.075549364089966, + 0.1937992423772812 + ], + "in": [ + -2.5099494457244873, + 0.8370992541313171 + ], + "out": [ + -1.6411494016647339, + -0.44940075278282166 + ] + }, + { + "pointType": 2, + "translation": [ + -0.2613493502140045, + -2.092000722885132 + ], + "in": [ + -0.033849358558654785, + -0.7885007858276367 + ], + "out": [ + -0.2613493502140045, + -2.092000722885132 + ] + }, + { + "pointType": 0, + "translation": [ + 1.2025506496429443, + -2.679900646209717 + ], + "radius": 0 + } + ], + "type": "path" + }, + { + "name": "rest body", + "parent": 15, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "Node", + "parent": 24, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "Shape", + "parent": 25, + "translation": [ + 8.834002494812012, + 4.068068981170654 + ], + "rotation": 0, + "scale": [ + 1.0004762411117554, + 1.0004762411117554 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 9, + "type": "shape" + }, + { + "name": "Color", + "parent": 26, + "opacity": 1, + "color": [ + 1, + 0.8235294222831726, + 0.29019609093666077, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 26, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 2, + "translation": [ + 0.6787769198417664, + -4.021994590759277 + ], + "in": [ + -1.912373661994934, + -1.792597770690918 + ], + "out": [ + 0.8000781536102295, + -4.021934986114502 + ] + }, + { + "pointType": 1, + "translation": [ + 1.1777344942092896, + 1.1532938480377197 + ], + "in": [ + 1.354279637336731, + -0.4736330807209015 + ], + "out": [ + 1.0011943578720093, + 2.7801015377044678 + ] + }, + { + "pointType": 2, + "translation": [ + 0.17534996569156647, + 4.435700416564941 + ], + "in": [ + 0.17534996569156647, + 4.435700416564941 + ], + "out": [ + 0.17534996569156647, + 4.435700416564941 + ] + }, + { + "pointType": 2, + "translation": [ + 0.8294499516487122, + 1.4806005954742432 + ], + "in": [ + 1.008449912071228, + 3.2816007137298584 + ], + "out": [ + 0.8294499516487122, + 1.4806005954742432 + ] + }, + { + "pointType": 1, + "translation": [ + -2.5884499549865723, + 1.1450005769729614 + ], + "in": [ + -2.0739500522613525, + 2.5458006858825684 + ], + "out": [ + -3.102950096130371, + -0.2558993995189667 + ] + }, + { + "pointType": 2, + "translation": [ + -1.8233500719070435, + -1.9834994077682495 + ], + "in": [ + -1.8233500719070435, + -1.9834994077682495 + ], + "out": [ + -1.8233500719070435, + -1.9834994077682495 + ] + } + ], + "type": "path" + }, + { + "name": "Shape", + "parent": 25, + "translation": [ + 0.12219760566949844, + -8.732078552246094 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 10, + "type": "shape" + }, + { + "name": "Color", + "parent": 29, + "opacity": 1, + "color": [ + 1, + 0.8235294222831726, + 0.29019609093666077, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 29, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 0, + "translation": [ + -9.796250343322754, + 6.376950740814209 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + -8.51455020904541, + 8.423050880432129 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + -5.550350189208984, + 10.521350860595703 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 6.26794958114624, + 9.824450492858887 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 9.796249389648438, + 6.260650634765625 + ], + "radius": 0 + }, + { + "pointType": 2, + "translation": [ + 9.796249389648438, + -0.7250494956970215 + ], + "in": [ + 9.796249389648438, + -0.7250494956970215 + ], + "out": [ + 9.796249389648438, + -6.135349273681641 + ] + }, + { + "pointType": 1, + "translation": [ + -0.00005041992335463874, + -10.521349906921387 + ], + "in": [ + 5.410349369049072, + -10.521349906921387 + ], + "out": [ + -5.410350322723389, + -10.521349906921387 + ] + }, + { + "pointType": 2, + "translation": [ + -9.796250343322754, + -0.7250494956970215 + ], + "in": [ + -9.796250343322754, + -6.135349273681641 + ], + "out": [ + -9.796250343322754, + -0.7250494956970215 + ] + }, + { + "pointType": 0, + "translation": [ + -9.796250343322754, + 6.376950740814209 + ], + "radius": 0 + } + ], + "type": "path" + }, + { + "name": "Shape", + "parent": 25, + "translation": [ + 8.912697792053223, + -10.579878807067871 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 11, + "type": "shape" + }, + { + "name": "Color", + "parent": 32, + "opacity": 1, + "color": [ + 0.27450981736183167, + 0.27843138575553894, + 0.27843138575553894, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 32, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": false, + "points": [ + { + "pointType": 2, + "translation": [ + -1.5267510414123535, + 0.9399498105049133 + ], + "in": [ + -1.5267510414123535, + 0.9399498105049133 + ], + "out": [ + -1.3530510663986206, + 0.9860498309135437 + ] + }, + { + "pointType": 2, + "translation": [ + -1.0925511121749878, + 1.0137498378753662 + ], + "in": [ + -1.1697510480880737, + 1.0137498378753662 + ], + "out": [ + -1.0925511121749878, + 1.0137498378753662 + ] + }, + { + "pointType": 2, + "translation": [ + 1.2372488975524902, + 1.0137498378753662 + ], + "in": [ + 1.2372488975524902, + 1.0137498378753662 + ], + "out": [ + 1.4302489757537842, + 1.0137498378753662 + ] + }, + { + "pointType": 2, + "translation": [ + 1.59424889087677, + 0.6727498173713684 + ], + "in": [ + 1.59424889087677, + 0.857049822807312 + ], + "out": [ + 1.59424889087677, + 0.6727498173713684 + ] + }, + { + "pointType": 2, + "translation": [ + 1.59424889087677, + -0.6727501749992371 + ], + "in": [ + 1.59424889087677, + -0.6727501749992371 + ], + "out": [ + 1.59424889087677, + -0.8570501804351807 + ] + }, + { + "pointType": 2, + "translation": [ + 1.2372488975524902, + -1.0137501955032349 + ], + "in": [ + 1.4302489757537842, + -1.0137501955032349 + ], + "out": [ + 1.2372488975524902, + -1.0137501955032349 + ] + }, + { + "pointType": 2, + "translation": [ + -1.0925511121749878, + -1.0137501955032349 + ], + "in": [ + -1.0925511121749878, + -1.0137501955032349 + ], + "out": [ + -1.1794511079788208, + -1.0137501955032349 + ] + }, + { + "pointType": 2, + "translation": [ + -1.594251036643982, + -0.9216501712799072 + ], + "in": [ + -1.3916510343551636, + -0.9769501686096191 + ], + "out": [ + -1.594251036643982, + -0.9216501712799072 + ] + } + ], + "type": "path" + }, + { + "name": "Shape", + "parent": 25, + "translation": [ + -8.896881103515625, + -10.579878807067871 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 12, + "type": "shape" + }, + { + "name": "Color", + "parent": 35, + "opacity": 1, + "color": [ + 0.27450981736183167, + 0.27843138575553894, + 0.27843138575553894, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 35, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": false, + "points": [ + { + "pointType": 2, + "translation": [ + 1.2323497533798218, + -0.9123501777648926 + ], + "in": [ + 1.2323497533798218, + -0.9123501777648926 + ], + "out": [ + 1.1648497581481934, + -0.9769501686096191 + ] + }, + { + "pointType": 2, + "translation": [ + 0.9815497398376465, + -1.0137501955032349 + ], + "in": [ + 1.0779497623443604, + -1.0137501955032349 + ], + "out": [ + 0.9815497398376465, + -1.0137501955032349 + ] + }, + { + "pointType": 0, + "translation": [ + -0.5087502598762512, + -1.0137501955032349 + ], + "radius": 0 + }, + { + "pointType": 2, + "translation": [ + -0.8753502368927002, + -1.0137501955032349 + ], + "in": [ + -0.8753502368927002, + -1.0137501955032349 + ], + "out": [ + -1.0779502391815186, + -1.0137501955032349 + ] + }, + { + "pointType": 2, + "translation": [ + -1.23235023021698, + -0.6727501749992371 + ], + "in": [ + -1.23235023021698, + -0.8570501804351807 + ], + "out": [ + -1.23235023021698, + -0.6727501749992371 + ] + }, + { + "pointType": 2, + "translation": [ + -1.23235023021698, + 0.6727498173713684 + ], + "in": [ + -1.23235023021698, + 0.6727498173713684 + ], + "out": [ + -1.23235023021698, + 0.857049822807312 + ] + }, + { + "pointType": 2, + "translation": [ + -0.8753502368927002, + 1.0137498378753662 + ], + "in": [ + -1.0779502391815186, + 1.0137498378753662 + ], + "out": [ + -0.8753502368927002, + 1.0137498378753662 + ] + }, + { + "pointType": 0, + "translation": [ + -0.7017502188682556, + 1.0137498378753662 + ], + "radius": 0 + }, + { + "pointType": 2, + "translation": [ + 0.9815497398376465, + 1.0137498378753662 + ], + "in": [ + 0.9815497398376465, + 1.0137498378753662 + ], + "out": [ + 1.049049735069275, + 1.0137498378753662 + ] + }, + { + "pointType": 2, + "translation": [ + 1.1648497581481934, + 0.9584498405456543 + ], + "in": [ + 1.1165497303009033, + 0.9952498078346252 + ], + "out": [ + 1.1648497581481934, + 0.9584498405456543 + ] + } + ], + "type": "path" + }, + { + "name": "Shape", + "parent": 25, + "translation": [ + 4.110846519470215, + -10.415227890014648 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 13, + "type": "shape" + }, + { + "name": "Color", + "parent": 38, + "opacity": 1, + "color": [ + 1, + 1, + 1, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Ellipse", + "parent": 38, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "width": 6.793000221252441, + "height": 6.5920000076293945, + "type": "ellipse" + }, + { + "name": "Shape", + "parent": 25, + "translation": [ + -3.995131731033325, + -10.415227890014648 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 14, + "type": "shape" + }, + { + "name": "Color", + "parent": 41, + "opacity": 1, + "color": [ + 1, + 1, + 1, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Ellipse", + "parent": 41, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "width": 6.793000221252441, + "height": 6.5920000076293945, + "type": "ellipse" + }, + { + "name": "Shape", + "parent": 25, + "translation": [ + 0.059779584407806396, + -10.414027214050293 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 15, + "type": "shape" + }, + { + "name": "Color", + "parent": 44, + "opacity": 1, + "color": [ + 0.8352941274642944, + 0.8352941274642944, + 0.8352941274642944, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 44, + "translation": [ + 0.001667022705078125, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 3, + "translation": [ + 4.0500006675720215, + -4.440000057220459 + ], + "in": [ + 6.62000036239624, + -4.440000057220459 + ], + "out": [ + 2.3100006580352783, + -4.440000057220459 + ] + }, + { + "pointType": 2, + "translation": [ + 5.41381837138033e-7, + -2.179999828338623 + ], + "in": [ + 0.8000005483627319, + -3.5299999713897705 + ], + "out": [ + -0.799999475479126, + -3.5299999713897705 + ] + }, + { + "pointType": 3, + "translation": [ + -4.049999237060547, + -4.440000057220459 + ], + "in": [ + -2.3199994564056396, + -4.440000057220459 + ], + "out": [ + -6.619999408721924, + -4.440000057220459 + ] + }, + { + "pointType": 1, + "translation": [ + -8.699999809265137, + 1.2939453597482498e-7 + ], + "in": [ + -8.699999809265137, + -2.4499998092651367 + ], + "out": [ + -8.699999809265137, + 2.450000047683716 + ] + }, + { + "pointType": 3, + "translation": [ + -4.049999237060547, + 4.440000057220459 + ], + "in": [ + -6.619999408721924, + 4.440000057220459 + ], + "out": [ + -2.3199994564056396, + 4.440000057220459 + ] + }, + { + "pointType": 2, + "translation": [ + 5.41381837138033e-7, + 2.180000066757202 + ], + "in": [ + -0.799999475479126, + 3.5300002098083496 + ], + "out": [ + 0.8000005483627319, + 3.5300002098083496 + ] + }, + { + "pointType": 3, + "translation": [ + 4.0500006675720215, + 4.440000057220459 + ], + "in": [ + 2.3100006580352783, + 4.440000057220459 + ], + "out": [ + 6.62000036239624, + 4.440000057220459 + ] + }, + { + "pointType": 1, + "translation": [ + 8.700000762939453, + 1.2939453597482498e-7 + ], + "in": [ + 8.700000762939453, + 2.450000047683716 + ], + "out": [ + 8.700000762939453, + -2.4499998092651367 + ] + } + ], + "type": "path" + }, + { + "name": "Path", + "parent": 44, + "translation": [ + -4.053333282470703, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 3, + "translation": [ + -0.004999153316020966, + 3.180000066757202 + ], + "in": [ + 1.8350008726119995, + 3.180000066757202 + ], + "out": [ + -1.8349992036819458, + 3.180000066757202 + ] + }, + { + "pointType": 1, + "translation": [ + -3.3249990940093994, + 1.2939453597482498e-7 + ], + "in": [ + -3.3249990940093994, + 1.7500001192092896 + ], + "out": [ + -3.3249990940093994, + -1.7599998712539673 + ] + }, + { + "pointType": 1, + "translation": [ + -0.004999153316020966, + -3.179999828338623 + ], + "in": [ + -1.8349992036819458, + -3.179999828338623 + ], + "out": [ + 1.8350008726119995, + -3.179999828338623 + ] + }, + { + "pointType": 1, + "translation": [ + 3.325000762939453, + 1.2939453597482498e-7 + ], + "in": [ + 3.325000762939453, + -1.7599998712539673 + ], + "out": [ + 3.325000762939453, + 1.7500001192092896 + ] + } + ], + "type": "path" + }, + { + "name": "Path", + "parent": 44, + "translation": [ + 4.051668167114258, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 1, + "translation": [ + -6.030273311807832e-7, + 3.180000066757202 + ], + "in": [ + 1.8399994373321533, + 3.180000066757202 + ], + "out": [ + -1.8400006294250488, + 3.180000066757202 + ] + }, + { + "pointType": 1, + "translation": [ + -3.330000638961792, + 1.2939453597482498e-7 + ], + "in": [ + -3.330000638961792, + 1.7500001192092896 + ], + "out": [ + -3.330000638961792, + -1.7599998712539673 + ] + }, + { + "pointType": 1, + "translation": [ + -6.030273311807832e-7, + -3.179999828338623 + ], + "in": [ + -1.8400006294250488, + -3.179999828338623 + ], + "out": [ + 1.8399994373321533, + -3.179999828338623 + ] + }, + { + "pointType": 1, + "translation": [ + 3.3299994468688965, + 1.2939453597482498e-7 + ], + "in": [ + 3.3299994468688965, + -1.7599998712539673 + ], + "out": [ + 3.3299994468688965, + 1.7500001192092896 + ] + } + ], + "type": "path" + }, + { + "name": "Shape", + "parent": 25, + "translation": [ + 3.42677640914917, + -10.149227142333984 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 16, + "type": "shape" + }, + { + "name": "Color", + "parent": 49, + "opacity": 1, + "color": [ + 0.1882352977991104, + 0.1882352977991104, + 0.18431372940540314, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Ellipse", + "parent": 49, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "width": 2.272900104522705, + "height": 2.1712000370025635, + "type": "ellipse" + }, + { + "name": "Shape", + "parent": 25, + "translation": [ + -3.317735195159912, + -10.149227142333984 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 17, + "type": "shape" + }, + { + "name": "Color", + "parent": 52, + "opacity": 1, + "color": [ + 0.1882352977991104, + 0.1882352977991104, + 0.18431372940540314, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Ellipse", + "parent": 52, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "width": 2.2727999687194824, + "height": 2.1712000370025635, + "type": "ellipse" + }, + { + "name": "Node", + "parent": 25, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "Shape", + "parent": 55, + "translation": [ + -0.1526532918214798, + -2.7778780460357666 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 18, + "type": "shape" + }, + { + "name": "Color", + "parent": 56, + "opacity": 1, + "color": [ + 0.9372549057006836, + 0.7372549176216125, + 0.24705882370471954, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 56, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 1, + "translation": [ + -0.16769957542419434, + 0.6611497402191162 + ], + "in": [ + 2.108600378036499, + 0.6611497402191162 + ], + "out": [ + -1.3429995775222778, + 0.6611497402191162 + ] + }, + { + "pointType": 1, + "translation": [ + -3.9674994945526123, + -0.004850230645388365 + ], + "in": [ + -2.6598994731903076, + 0.494149774312973 + ], + "out": [ + -4.148199558258057, + -0.074250228703022 + ] + }, + { + "pointType": 1, + "translation": [ + -4.169699668884277, + -0.45705023407936096 + ], + "in": [ + -4.238499641418457, + -0.2763502299785614 + ], + "out": [ + -4.100799560546875, + -0.6377502083778381 + ] + }, + { + "pointType": 1, + "translation": [ + -3.7174994945526123, + -0.659150242805481 + ], + "in": [ + -3.8971996307373047, + -0.7285502552986145 + ], + "out": [ + -0.13059957325458527, + 0.7109497785568237 + ] + }, + { + "pointType": 1, + "translation": [ + 3.720900535583496, + -0.6611502170562744 + ], + "in": [ + 3.682800531387329, + -0.6474502086639404 + ], + "out": [ + 3.9006004333496094, + -0.7226502299308777 + ] + }, + { + "pointType": 1, + "translation": [ + 4.169700622558594, + -0.45215022563934326 + ], + "in": [ + 4.10330057144165, + -0.6338502168655396 + ], + "out": [ + 4.236100196838379, + -0.2705502212047577 + ] + }, + { + "pointType": 1, + "translation": [ + 3.961200475692749, + -0.0029502306133508682 + ], + "in": [ + 4.142800331115723, + -0.0693502277135849 + ], + "out": [ + 3.8523004055023193, + 0.0361497700214386 + ] + } + ], + "type": "path" + }, + { + "name": "Node", + "parent": 25, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "Node", + "parent": 59, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "Shape", + "parent": 60, + "translation": [ + 9.249743461608887, + 4.548224925994873 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 19, + "type": "shape" + }, + { + "name": "Color", + "parent": 61, + "opacity": 1, + "color": [ + 0.9372549057006836, + 0.7372549176216125, + 0.24705882370471954, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 61, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 3, + "translation": [ + 0.3227013647556305, + 1.39745032787323 + ], + "in": [ + 0.3374013602733612, + 1.39745032787323 + ], + "out": [ + 0.14940136671066284, + 1.39745032787323 + ] + }, + { + "pointType": 2, + "translation": [ + -0.02399863861501217, + 1.0917503833770752 + ], + "in": [ + -0.0014986377209424973, + 1.2685503959655762 + ], + "out": [ + -0.0741986408829689, + 0.6982503533363342 + ] + }, + { + "pointType": 2, + "translation": [ + -0.6703986525535583, + -0.905349612236023 + ], + "in": [ + -0.28809863328933716, + -0.4277496337890625 + ], + "out": [ + -0.790998637676239, + -1.0566496849060059 + ] + }, + { + "pointType": 2, + "translation": [ + -0.6156986355781555, + -1.3974496126174927 + ], + "in": [ + -0.766598641872406, + -1.276349663734436 + ], + "out": [ + -0.4653986394405365, + -1.5176496505737305 + ] + }, + { + "pointType": 2, + "translation": [ + -0.12359863519668579, + -1.342849612236023 + ], + "in": [ + -0.24509863555431366, + -1.492249608039856 + ], + "out": [ + 0.4502013623714447, + -0.6250496506690979 + ] + }, + { + "pointType": 2, + "translation": [ + 0.6704013347625732, + 1.0038503408432007 + ], + "in": [ + 0.6494013667106628, + 0.8388503789901733 + ], + "out": [ + 0.694801390171051, + 1.195250391960144 + ] + }, + { + "pointType": 2, + "translation": [ + 0.3672013580799103, + 1.3944504261016846 + ], + "in": [ + 0.5591013431549072, + 1.3710503578186035 + ], + "out": [ + 0.35250136256217957, + 1.396450400352478 + ] + } + ], + "type": "path" + }, + { + "name": "Node", + "parent": 59, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "Shape", + "parent": 64, + "translation": [ + -9.034634590148926, + 4.548224925994873 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 20, + "type": "shape" + }, + { + "name": "Color", + "parent": 65, + "opacity": 1, + "color": [ + 0.9372549057006836, + 0.7372549176216125, + 0.24705882370471954, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 65, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 3, + "translation": [ + -0.2890996038913727, + 1.39745032787323 + ], + "in": [ + -0.10889960825443268, + 1.39745032787323 + ], + "out": [ + -0.298799604177475, + 1.39745032787323 + ] + }, + { + "pointType": 2, + "translation": [ + -0.31889960169792175, + 1.396450400352478 + ], + "in": [ + -0.308599591255188, + 1.39745032787323 + ], + "out": [ + -0.5112996101379395, + 1.3808503150939941 + ] + }, + { + "pointType": 2, + "translation": [ + -0.6381996273994446, + 1.0185503959655762 + ], + "in": [ + -0.6542996168136597, + 1.2118504047393799 + ], + "out": [ + -0.6244996190071106, + 0.853450357913971 + ] + }, + { + "pointType": 2, + "translation": [ + 0.09130039811134338, + -1.342849612236023 + ], + "in": [ + -0.4872995913028717, + -0.6191496253013611 + ], + "out": [ + 0.2124003916978836, + -1.492249608039856 + ] + }, + { + "pointType": 2, + "translation": [ + 0.5835003852844238, + -1.3974496126174927 + ], + "in": [ + 0.4326004087924957, + -1.5176496505737305 + ], + "out": [ + 0.7344003915786743, + -1.276349663734436 + ] + }, + { + "pointType": 2, + "translation": [ + 0.6382004022598267, + -0.905349612236023 + ], + "in": [ + 0.7588003873825073, + -1.0566496849060059 + ], + "out": [ + 0.2602003812789917, + -0.4326496124267578 + ] + }, + { + "pointType": 2, + "translation": [ + 0.05910039320588112, + 1.0771503448486328 + ], + "in": [ + 0.09230039268732071, + 0.6855503916740417 + ], + "out": [ + 0.043900396674871445, + 1.2597503662109375 + ] + } + ], + "type": "path" + }, + { + "name": "Node", + "parent": 25, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "Shape", + "parent": 68, + "translation": [ + 0.13264863193035126, + 6.05432653427124 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 21, + "type": "shape" + }, + { + "name": "Color", + "parent": 69, + "opacity": 1, + "color": [ + 0.3137255012989044, + 0.6705882549285889, + 0.9960784316062927, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 69, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 2, + "translation": [ + 8.568799018859863, + -0.5056493282318115 + ], + "in": [ + 8.568799018859863, + -0.5056493282318115 + ], + "out": [ + 7.3423991203308105, + -0.42464932799339294 + ] + }, + { + "pointType": 2, + "translation": [ + 6.954599380493164, + -1.9617493152618408 + ], + "in": [ + 6.954599380493164, + -1.9617493152618408 + ], + "out": [ + 6.954599380493164, + -1.9617493152618408 + ] + }, + { + "pointType": 0, + "translation": [ + 6.954599380493164, + -3.8570492267608643 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 6.208899021148682, + -3.838249444961548 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 5.732699394226074, + -4.537349224090576 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 5.958299160003662, + -5.415149211883545 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + -5.8690009117126465, + -5.415149211883545 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + -5.899000644683838, + -4.729849338531494 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + -6.314400672912598, + -3.939549446105957 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + -7.087100982666016, + -4.027749538421631 + ], + "radius": 0 + }, + { + "pointType": 2, + "translation": [ + -7.1165008544921875, + -1.8797492980957031 + ], + "in": [ + -7.1165008544921875, + -1.8797492980957031 + ], + "out": [ + -7.58720064163208, + -0.03784932568669319 + ] + }, + { + "pointType": 2, + "translation": [ + -9.78580093383789, + -0.6478493213653564 + ], + "in": [ + -9.78580093383789, + -0.6478493213653564 + ], + "out": [ + -9.903100967407227, + 0.9137506484985352 + ] + }, + { + "pointType": 2, + "translation": [ + -9.446701049804688, + 1.8688507080078125 + ], + "in": [ + -9.446701049804688, + 1.8688507080078125 + ], + "out": [ + -7.347900867462158, + 5.919750690460205 + ] + }, + { + "pointType": 2, + "translation": [ + -0.20170077681541443, + 5.4151506423950195 + ], + "in": [ + -0.20170077681541443, + 5.4151506423950195 + ], + "out": [ + 11.040199279785156, + 5.861050605773926 + ] + }, + { + "pointType": 2, + "translation": [ + 9.785799026489258, + -0.5056493282318115 + ], + "in": [ + 9.785799026489258, + -0.5056493282318115 + ], + "out": [ + 9.785799026489258, + -0.5056493282318115 + ] + }, + { + "pointType": 0, + "translation": [ + 8.568799018859863, + -0.5056493282318115 + ], + "radius": 0 + } + ], + "type": "path" + }, + { + "name": "Shape", + "parent": 68, + "translation": [ + -23.962726593017578, + -25.499963760375977 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 22, + "type": "shape" + }, + { + "name": "Color", + "parent": 72, + "opacity": 1, + "color": [ + 0.239215686917305, + 0.6078431606292725, + 0.886274516582489, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 72, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 0, + "translation": [ + 18.93317985534668, + 26.636930465698242 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 18.22637939453125, + 26.139129638671875 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 14.288680076599121, + 23.14483070373535 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 13.663180351257324, + 24.672330856323242 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 17.00827980041504, + 27.52652931213379 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 17.88128089904785, + 28.192930221557617 + ], + "radius": 0 + } + ], + "type": "path" + }, + { + "name": "Shape", + "parent": 68, + "translation": [ + -23.962726593017578, + -25.499963760375977 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 23, + "type": "shape" + }, + { + "name": "Color", + "parent": 75, + "opacity": 1, + "color": [ + 0.239215686917305, + 0.6078431606292725, + 0.886274516582489, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 75, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 0, + "translation": [ + 30.20207977294922, + 28.360530853271484 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 31.04998016357422, + 27.697229385375977 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 34.46968078613281, + 24.672330856323242 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 33.88117980957031, + 23.02853012084961 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 30.053680419921875, + 26.139129638671875 + ], + "radius": 0 + }, + { + "pointType": 0, + "translation": [ + 29.095979690551758, + 26.944629669189453 + ], + "radius": 0 + } + ], + "type": "path" + }, + { + "name": "Node", + "parent": 68, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "Shape", + "parent": 78, + "translation": [ + 6.887976169586182, + 1.092372179031372 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 24, + "type": "shape" + }, + { + "name": "Color", + "parent": 79, + "opacity": 1, + "color": [ + 0.1882352977991104, + 0.1882352977991104, + 0.18431372940540314, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Ellipse", + "parent": 79, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "width": 0.7055000066757202, + "height": 0.6740000247955322, + "type": "ellipse" + }, + { + "name": "Shape", + "parent": 78, + "translation": [ + -6.631098747253418, + 1.137054681777954 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 25, + "type": "shape" + }, + { + "name": "Color", + "parent": 82, + "opacity": 1, + "color": [ + 0.1882352977991104, + 0.1882352977991104, + 0.18431372940540314, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Ellipse", + "parent": 82, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "width": 0.7055000066757202, + "height": 0.6739000082015991, + "type": "ellipse" + }, + { + "name": "Shape", + "parent": 25, + "translation": [ + -8.74470043182373, + 3.1728577613830566 + ], + "rotation": 0, + "scale": [ + -1, + 1.0004762411117554 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 9, + "type": "shape" + }, + { + "name": "Color", + "parent": 85, + "opacity": 1, + "color": [ + 1, + 0.8235294222831726, + 0.29019609093666077, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 85, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 2, + "translation": [ + 0.6787769198417664, + -4.021994590759277 + ], + "in": [ + -1.912373661994934, + -1.792597770690918 + ], + "out": [ + 0.8000781536102295, + -4.021934986114502 + ] + }, + { + "pointType": 1, + "translation": [ + 1.1777344942092896, + 1.1532938480377197 + ], + "in": [ + 1.354279637336731, + -0.4736330807209015 + ], + "out": [ + 1.0011943578720093, + 2.7801015377044678 + ] + }, + { + "pointType": 2, + "translation": [ + 0.17534996569156647, + 4.435700416564941 + ], + "in": [ + 0.17534996569156647, + 4.435700416564941 + ], + "out": [ + 0.17534996569156647, + 4.435700416564941 + ] + }, + { + "pointType": 2, + "translation": [ + 0.8294499516487122, + 1.4806005954742432 + ], + "in": [ + 1.008449912071228, + 3.2816007137298584 + ], + "out": [ + 0.8294499516487122, + 1.4806005954742432 + ] + }, + { + "pointType": 1, + "translation": [ + -2.5884499549865723, + 1.1450005769729614 + ], + "in": [ + -2.0739500522613525, + 2.5458006858825684 + ], + "out": [ + -3.102950096130371, + -0.2558993995189667 + ] + }, + { + "pointType": 2, + "translation": [ + -1.8233500719070435, + -1.9834994077682495 + ], + "in": [ + -1.8233500719070435, + -1.9834994077682495 + ], + "out": [ + -1.8233500719070435, + -1.9834994077682495 + ] + } + ], + "type": "path" + }, + { + "name": "left arm", + "parent": 15, + "translation": [ + -9.025335311889648, + 0.16492441296577454 + ], + "rotation": 0.0003983333982841862, + "scale": [ + -0.07599999755620956, + 0.08234841376543045 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "hand", + "parent": 88, + "translation": [ + -2.9919419288635254, + -21.12683868408203 + ], + "rotation": -0.0003936628611329106, + "scale": [ + 0.9999999403953552, + 0.9882745742797852 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 2, + "type": "shape" + }, + { + "name": "Path", + "parent": 89, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": false, + "points": [ + { + "pointType": 1, + "translation": [ + -3.1883742809295654, + 4.92755126953125 + ], + "in": [ + -21.629899978637695, + -1.30621337890625 + ], + "out": [ + 15.253150939941406, + 11.16131591796875 + ] + }, + { + "pointType": 2, + "translation": [ + 22.11700439453125, + 66.15670776367188 + ], + "in": [ + 20.22064208984375, + 34.299560546875 + ], + "out": [ + 24.07562255859375, + 99.06051635742188 + ] + }, + { + "pointType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "in": [ + 19.040069580078125, + 128.6617431640625 + ], + "out": [ + 5.375457763671875, + 146.66290283203125 + ] + } + ], + "type": "path" + }, + { + "name": "Color", + "parent": 89, + "opacity": 5, + "color": [ + 1, + 0.8235294222831726, + 0.29019609093666077, + 1 + ], + "width": 24, + "type": "colorStroke" + }, + { + "name": "Node", + "parent": 88, + "translation": [ + 11.763854026794434, + 101.39745330810547 + ], + "rotation": -1.701747250060226e-11, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "type": "node" + }, + { + "name": "fist", + "parent": 92, + "translation": [ + -10.441765785217285, + 29.273778915405273 + ], + "rotation": 0.01069625900144239, + "scale": [ + 12.287585258483887, + 12.143492698669434 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "isVisible": true, + "blendMode": 0, + "drawOrder": 3, + "type": "shape" + }, + { + "name": "Color", + "parent": 93, + "opacity": 1, + "color": [ + 0.27450981736183167, + 0.27843138575553894, + 0.27843138575553894, + 1 + ], + "fillRule": 1, + "type": "colorFill" + }, + { + "name": "Path", + "parent": 93, + "translation": [ + 0, + 0 + ], + "rotation": 0, + "scale": [ + 1, + 1 + ], + "opacity": 1, + "isCollapsed": false, + "clips": [], + "bones": [], + "isVisible": true, + "isClosed": true, + "points": [ + { + "pointType": 2, + "translation": [ + 1.9941506385803223, + -2.0428006649017334 + ], + "in": [ + 1.9941506385803223, + -2.0428006649017334 + ], + "out": [ + 1.9941506385803223, + -2.0428006649017334 + ] + }, + { + "pointType": 1, + "translation": [ + 2.0755505561828613, + -0.5447007417678833 + ], + "in": [ + 1.8438506126403809, + -1.4787007570266724 + ], + "out": [ + 2.307250738143921, + 0.3892992436885834 + ] + }, + { + "pointType": 1, + "translation": [ + 1.7971506118774414, + 1.5706992149353027 + ], + "in": [ + 2.5513505935668945, + 1.417399287223816 + ], + "out": [ + 1.0430506467819214, + 1.7240992784500122 + ] + }, + { + "pointType": 1, + "translation": [ + 0.9245506525039673, + 1.6362992525100708 + ], + "in": [ + 0.9245506525039673, + 1.6362992525100708 + ], + "out": [ + 0.9245506525039673, + 1.6362992525100708 + ] + }, + { + "pointType": 1, + "translation": [ + 0.09475064277648926, + 2.679899215698242 + ], + "in": [ + 0.8225506544113159, + 2.6013991832733154 + ], + "out": [ + -0.6329493522644043, + 2.7584991455078125 + ] + }, + { + "pointType": 2, + "translation": [ + -1.4509493112564087, + 1.161299228668213 + ], + "in": [ + -1.166749358177185, + 2.4294991493225098 + ], + "out": [ + -1.4509493112564087, + 1.161299228668213 + ] + }, + { + "pointType": 1, + "translation": [ + -2.075549364089966, + 0.1937992423772812 + ], + "in": [ + -2.5099494457244873, + 0.8370992541313171 + ], + "out": [ + -1.6411494016647339, + -0.44940075278282166 + ] + }, + { + "pointType": 2, + "translation": [ + -0.2613493502140045, + -2.092000722885132 + ], + "in": [ + -0.033849358558654785, + -0.7885007858276367 + ], + "out": [ + -0.2613493502140045, + -2.092000722885132 + ] + }, + { + "pointType": 0, + "translation": [ + 1.2025506496429443, + -2.679900646209717 + ], + "radius": 0 + } + ], + "type": "path" + } + ], + "animations": [ + { + "name": "Stand", + "fps": 60, + "duration": 3, + "isLooping": true, + "keyed": [ + { + "component": 49, + "posX": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": 3.4267756938934326 + }, + { + "time": 0.2833333333333333, + "interpolatorType": 1, + "value": 3.4267756938934326 + }, + { + "time": 0.38333333333333336, + "interpolatorType": 1, + "value": 6.235568523406982 + }, + { + "time": 1.0666666666666667, + "interpolatorType": 1, + "value": 6.235568523406982 + }, + { + "time": 1.1666666666666667, + "interpolatorType": 1, + "value": 1.9863762855529785 + }, + { + "time": 1.7833333333333334, + "interpolatorType": 1, + "value": 1.9863762855529785 + }, + { + "time": 1.8666666666666667, + "interpolatorType": 1, + "value": 3.4267756938934326 + } + ] + ], + "posY": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": -10.149227142333984 + }, + { + "time": 0.2833333333333333, + "interpolatorType": 1, + "value": -10.149227142333984 + }, + { + "time": 1.8666666666666667, + "interpolatorType": 1, + "value": -10.149227142333984 + } + ] + ] + }, + { + "component": 52, + "posX": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": -3.3177332878112793 + }, + { + "time": 0.2833333333333333, + "interpolatorType": 1, + "value": -3.3177332878112793 + }, + { + "time": 0.38333333333333336, + "interpolatorType": 1, + "value": -1.8917300701141357 + }, + { + "time": 1.0666666666666667, + "interpolatorType": 1, + "value": -1.8917300701141357 + }, + { + "time": 1.1666666666666667, + "interpolatorType": 1, + "value": -6.140920162200928 + }, + { + "time": 1.7833333333333334, + "interpolatorType": 1, + "value": -6.140920162200928 + }, + { + "time": 1.8666666666666667, + "interpolatorType": 1, + "value": -3.3177332878112793 + } + ] + ], + "posY": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": -10.149227142333984 + }, + { + "time": 0.2833333333333333, + "interpolatorType": 1, + "value": -10.149227142333984 + }, + { + "time": 1.8666666666666667, + "interpolatorType": 1, + "value": -10.149227142333984 + } + ] + ] + } + ], + "animationStart": 0, + "animationEnd": 1.8666666666666667, + "type": "animation" + }, + { + "name": "Dance", + "fps": 60, + "duration": 2.6666666666666665, + "isLooping": true, + "keyed": [ + { + "component": 16, + "rotation": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": -0.0032222296857224698 + }, + { + "time": 0.25, + "interpolatorType": 1, + "value": -0.0032222296857224698 + }, + { + "time": 0.35, + "interpolatorType": 1, + "value": -1.4480021360827267 + }, + { + "time": 0.9333333333333333, + "interpolatorType": 1, + "value": -1.4480021360827267 + }, + { + "time": 2.533333333333333, + "interpolatorType": 1, + "value": -1.4480021360827267 + }, + { + "time": 2.6333333333333333, + "interpolatorType": 1, + "value": -0.0032222296857224698 + } + ] + ] + }, + { + "component": 18, + "pathVertices": [ + [ + { + "time": 0, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 0.25, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 0.35, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 0.9333333333333333, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 1.0333333333333334, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 29.472455978393555, + 113.38487243652344 + ], + "outValue": [ + -5.056929111480713, + 161.9397735595703 + ] + }, + { + "time": 1.2333333333333334, + "interpolatorType": 1, + "translation": [ + 18.604158401489258, + 144.1521453857422 + ], + "inValue": [ + 8.921080589294434, + 123.74919891357422 + ], + "outValue": [ + 28.28697967529297, + 164.55499267578125 + ] + }, + { + "time": 1.5, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 29.472455978393555, + 113.38487243652344 + ], + "outValue": [ + -5.056929111480713, + 161.9397735595703 + ] + }, + { + "time": 1.6833333333333333, + "interpolatorType": 1, + "translation": [ + 18.604158401489258, + 144.1521453857422 + ], + "inValue": [ + 8.921080589294434, + 123.74919891357422 + ], + "outValue": [ + 28.28697967529297, + 164.55499267578125 + ] + }, + { + "time": 1.8166666666666667, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 29.472455978393555, + 113.38487243652344 + ], + "outValue": [ + -5.056929111480713, + 161.9397735595703 + ] + }, + { + "time": 2.0166666666666666, + "interpolatorType": 1, + "translation": [ + 18.604158401489258, + 144.1521453857422 + ], + "inValue": [ + 8.921080589294434, + 123.74919891357422 + ], + "outValue": [ + 28.28697967529297, + 164.55499267578125 + ] + }, + { + "time": 2.283333333333333, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 29.472455978393555, + 113.38487243652344 + ], + "outValue": [ + -5.056929111480713, + 161.9397735595703 + ] + }, + { + "time": 2.466666666666667, + "interpolatorType": 1, + "translation": [ + 18.604158401489258, + 144.1521453857422 + ], + "inValue": [ + 8.921080589294434, + 123.74919891357422 + ], + "outValue": [ + 28.28697967529297, + 164.55499267578125 + ] + }, + { + "time": 2.533333333333333, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 2.6333333333333333, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + } + ] + ] + }, + { + "component": 88, + "rotation": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": 0.007181109845005642 + }, + { + "time": 0.25, + "interpolatorType": 1, + "value": 0.007181109845005642 + }, + { + "time": 0.35, + "interpolatorType": 1, + "value": 1.2702661301630984 + }, + { + "time": 0.9333333333333333, + "interpolatorType": 1, + "value": 1.2702661301630984 + }, + { + "time": 2.533333333333333, + "interpolatorType": 1, + "value": 1.2702661301630984 + }, + { + "time": 2.6333333333333333, + "interpolatorType": 1, + "value": 0.007181109845005642 + } + ] + ] + }, + { + "component": 90, + "pathVertices": [ + [ + { + "time": 0.35, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 0.9333333333333333, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 1.0333333333333334, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 1.2333333333333334, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 27.941741943359375, + 117.94743347167969 + ], + "outValue": [ + -3.526214599609375, + 157.37721252441406 + ] + }, + { + "time": 1.5, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 1.6833333333333333, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 27.941741943359375, + 117.94743347167969 + ], + "outValue": [ + -3.526214599609375, + 157.37721252441406 + ] + }, + { + "time": 1.8166666666666667, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 2.0166666666666666, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 27.941741943359375, + 117.94743347167969 + ], + "outValue": [ + -3.526214599609375, + 157.37721252441406 + ] + }, + { + "time": 2.283333333333333, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 2.466666666666667, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 27.941741943359375, + 117.94743347167969 + ], + "outValue": [ + -3.526214599609375, + 157.37721252441406 + ] + }, + { + "time": 2.533333333333333, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + } + ] + ] + } + ], + "animationStart": 0, + "animationEnd": 2.6333333333333333, + "type": "animation" + }, + { + "name": "Jump", + "fps": 60, + "duration": 0.6166666666666667, + "isLooping": true, + "keyed": [ + { + "component": 0, + "posY": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": 518.8373413085938 + }, + { + "time": 0.23333333333333334, + "interpolatorType": 1, + "value": 518.8373413085938 + }, + { + "time": 0.35, + "interpolatorType": 1, + "value": 447.3218078613281 + }, + { + "time": 0.5833333333333334, + "interpolatorType": 1, + "value": 518.8373413085938 + }, + { + "time": 0.6166666666666667, + "interpolatorType": 1, + "value": 518.8373413085938 + } + ] + ] + }, + { + "component": 1, + "rotation": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.11666666666666667, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.23333333333333334, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.35, + "interpolatorType": 1, + "value": -0.23374952316206468 + }, + { + "time": 0.5833333333333334, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.6166666666666667, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.7333333333333334, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.8500000000000001, + "interpolatorType": 1, + "value": 0 + } + ] + ] + }, + { + "component": 8, + "rotation": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.11666666666666667, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.23333333333333334, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.35, + "interpolatorType": 1, + "value": 0.23374952316206474 + }, + { + "time": 0.5833333333333334, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.6166666666666667, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.7333333333333334, + "interpolatorType": 1, + "value": 0 + }, + { + "time": 0.8500000000000001, + "interpolatorType": 1, + "value": 0 + } + ] + ] + }, + { + "component": 15, + "posY": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": 379.346923828125 + }, + { + "time": 0.11666666666666667, + "interpolatorType": 1, + "value": 379.346923828125 + }, + { + "time": 0.23333333333333334, + "interpolatorType": 1, + "value": 400.7755126953125 + }, + { + "time": 0.35, + "interpolatorType": 1, + "value": 306.4898986816406 + }, + { + "time": 0.5833333333333334, + "interpolatorType": 1, + "value": 380.7752380371094 + }, + { + "time": 0.6166666666666667, + "interpolatorType": 1, + "value": 379.346923828125 + } + ] + ] + } + ], + "animationStart": 0, + "animationEnd": 0.8500000000000001, + "type": "animation" + }, + { + "name": "Wave", + "fps": 60, + "duration": 3.3333333333333335, + "isLooping": true, + "keyed": [ + { + "component": 15, + "rotation": [ + [ + { + "time": 1.4, + "interpolatorType": 2, + "cubicX1": 0.42, + "cubicY1": 0, + "cubicX2": 0, + "cubicY2": 0.9961340206185567, + "value": -0.003407746702308076 + }, + { + "time": 1.6333333333333333, + "interpolatorType": 2, + "cubicX1": 0.42, + "cubicY1": 0, + "cubicX2": 0, + "cubicY2": 0.9768041237113402, + "value": -0.13416850842293393 + } + ] + ] + }, + { + "component": 16, + "rotation": [ + [ + { + "time": 1.2, + "interpolatorType": 1, + "value": 0.000398333392570116 + }, + { + "time": 1.4, + "interpolatorType": 2, + "cubicX1": 0.13247863247863248, + "cubicY1": -0.009020618556700999, + "cubicX2": 0.44871794871794873, + "cubicY2": 0.970360824742268, + "value": 0.000398333392570116 + }, + { + "time": 1.75, + "interpolatorType": 2, + "cubicX1": 0.3034188034188034, + "cubicY1": 0.0038659793814432852, + "cubicX2": 0, + "cubicY2": 0.9896907216494846, + "value": -2.3881340155038417 + }, + { + "time": 1.9333333333333333, + "interpolatorType": 1, + "value": -1.6817393473437212 + }, + { + "time": 2.1166666666666667, + "interpolatorType": 2, + "cubicX1": 0.3034188034188034, + "cubicY1": 0.0038659793814432852, + "cubicX2": 0, + "cubicY2": 0.9896907216494846, + "value": -2.3881340155038417 + }, + { + "time": 2.3, + "interpolatorType": 1, + "value": -1.6817393473437212 + }, + { + "time": 2.5, + "interpolatorType": 2, + "cubicX1": 0.3034188034188034, + "cubicY1": 0.0038659793814432852, + "cubicX2": 0, + "cubicY2": 0.9896907216494846, + "value": -2.3881340155038417 + }, + { + "time": 2.683333333333333, + "interpolatorType": 1, + "value": -1.6817393473437212 + }, + { + "time": 2.8666666666666667, + "interpolatorType": 2, + "cubicX1": 0.3034188034188034, + "cubicY1": 0.0038659793814432852, + "cubicX2": 0, + "cubicY2": 0.9896907216494846, + "value": -2.3881340155038417 + }, + { + "time": 3.05, + "interpolatorType": 1, + "value": -1.6817393473437212 + }, + { + "time": 3.283333333333333, + "interpolatorType": 1, + "value": 0.000398333392570116 + } + ] + ] + }, + { + "component": 18, + "pathVertices": [ + [ + { + "time": 1.4, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + }, + { + "time": 1.75, + "interpolatorType": 1, + "translation": [ + 16.145925521850586, + 139.5957489013672 + ], + "inValue": [ + 22.978229522705078, + 130.59518432617188 + ], + "outValue": [ + 9.31362247467041, + 148.59632873535156 + ] + }, + { + "time": 1.9333333333333333, + "interpolatorType": 1, + "translation": [ + 13.518263816833496, + 142.21856689453125 + ], + "inValue": [ + 14.751205444335938, + 131.1336212158203 + ], + "outValue": [ + 12.285322189331055, + 153.30352783203125 + ] + }, + { + "time": 2.1166666666666667, + "interpolatorType": 1, + "translation": [ + 16.145925521850586, + 139.5957489013672 + ], + "inValue": [ + 22.978229522705078, + 130.59518432617188 + ], + "outValue": [ + 9.31362247467041, + 148.59632873535156 + ] + }, + { + "time": 2.3, + "interpolatorType": 1, + "translation": [ + 13.518263816833496, + 142.21856689453125 + ], + "inValue": [ + 14.751205444335938, + 131.1336212158203 + ], + "outValue": [ + 12.285322189331055, + 153.30352783203125 + ] + }, + { + "time": 2.5, + "interpolatorType": 1, + "translation": [ + 16.145925521850586, + 139.5957489013672 + ], + "inValue": [ + 22.978229522705078, + 130.59518432617188 + ], + "outValue": [ + 9.31362247467041, + 148.59632873535156 + ] + }, + { + "time": 2.683333333333333, + "interpolatorType": 1, + "translation": [ + 13.518263816833496, + 142.21856689453125 + ], + "inValue": [ + 14.751205444335938, + 131.1336212158203 + ], + "outValue": [ + 12.285322189331055, + 153.30352783203125 + ] + }, + { + "time": 2.8666666666666667, + "interpolatorType": 1, + "translation": [ + 16.145925521850586, + 139.5957489013672 + ], + "inValue": [ + 22.978229522705078, + 130.59518432617188 + ], + "outValue": [ + 9.31362247467041, + 148.59632873535156 + ] + }, + { + "time": 3.05, + "interpolatorType": 1, + "translation": [ + 13.518263816833496, + 142.21856689453125 + ], + "inValue": [ + 14.751205444335938, + 131.1336212158203 + ], + "outValue": [ + 12.285322189331055, + 153.30352783203125 + ] + }, + { + "time": 3.283333333333333, + "interpolatorType": 1, + "translation": [ + 12.207763671875, + 137.66232299804688 + ], + "inValue": [ + 19.040069580078125, + 128.6617431640625 + ], + "outValue": [ + 5.375457763671875, + 146.66290283203125 + ] + } + ] + ] + }, + { + "component": 49, + "posX": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": 3.4267756938934326 + }, + { + "time": 0.2, + "interpolatorType": 1, + "value": 3.4267756938934326 + }, + { + "time": 0.3, + "interpolatorType": 1, + "value": 6.235568523406982 + }, + { + "time": 0.5166666666666667, + "interpolatorType": 1, + "value": 6.235568523406982 + }, + { + "time": 0.6166666666666667, + "interpolatorType": 1, + "value": 1.9863762855529785 + }, + { + "time": 0.9666666666666667, + "interpolatorType": 1, + "value": 1.9863762855529785 + }, + { + "time": 1.1, + "interpolatorType": 1, + "value": 3.4267756938934326 + } + ] + ], + "posY": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": -10.149227142333984 + }, + { + "time": 0.2, + "interpolatorType": 1, + "value": -10.149227142333984 + }, + { + "time": 1.1, + "interpolatorType": 1, + "value": -10.149227142333984 + } + ] + ] + }, + { + "component": 52, + "posX": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": -3.3177332878112793 + }, + { + "time": 0.2, + "interpolatorType": 1, + "value": -3.3177332878112793 + }, + { + "time": 0.3, + "interpolatorType": 1, + "value": -1.8917300701141357 + }, + { + "time": 0.5166666666666667, + "interpolatorType": 1, + "value": -1.8917300701141357 + }, + { + "time": 0.6166666666666667, + "interpolatorType": 1, + "value": -6.140920162200928 + }, + { + "time": 0.9666666666666667, + "interpolatorType": 1, + "value": -6.140920162200928 + }, + { + "time": 1.1, + "interpolatorType": 1, + "value": -3.3177332878112793 + } + ] + ], + "posY": [ + [ + { + "time": 0, + "interpolatorType": 1, + "value": -10.149227142333984 + }, + { + "time": 0.2, + "interpolatorType": 1, + "value": -10.149227142333984 + }, + { + "time": 1.1, + "interpolatorType": 1, + "value": -10.149227142333984 + } + ] + ] + }, + { + "component": 58, + "pathVertices": [ + [ + { + "time": 0.9666666666666667, + "interpolatorType": 1, + "translation": [ + 3.961200475692749, + -0.0029502306133508682 + ], + "inValue": [ + 4.142800331115723, + -0.0693502277135849 + ], + "outValue": [ + 3.8523004055023193, + 0.0361497700214386 + ] + }, + { + "time": 1.0166666666666666, + "interpolatorType": 1, + "translation": [ + 1.5758384466171265, + -0.1993916630744934 + ], + "inValue": [ + 1.5610013008117676, + -0.9393030405044556 + ], + "outValue": [ + 1.5906754732131958, + 0.5405197143554688 + ] + }, + { + "time": 1.7, + "interpolatorType": 1, + "translation": [ + 1.5758384466171265, + -0.1993916630744934 + ], + "inValue": [ + 1.5610013008117676, + -0.9393030405044556 + ], + "outValue": [ + 1.5906754732131958, + 0.5405197143554688 + ] + }, + { + "time": 1.75, + "interpolatorType": 1, + "translation": [ + 3.961200475692749, + -0.0029502306133508682 + ], + "inValue": [ + 4.142800331115723, + -0.0693502277135849 + ], + "outValue": [ + 3.8523004055023193, + 0.0361497700214386 + ] + } + ] + ] + } + ], + "animationStart": 0, + "animationEnd": 3.283333333333333, + "type": "animation" + } + ], + "type": "artboard" + } + ] +} \ No newline at end of file diff --git a/package-lock.json b/package-lock.json index d621979..62069cd 100644 --- a/package-lock.json +++ b/package-lock.json @@ -4,6 +4,11 @@ "lockfileVersion": 1, "requires": true, "dependencies": { + "@svgdotjs/svg.js": { + "version": "3.0.5", + "resolved": "https://repository.stageten.tv/repository/npmjs-stageten/@svgdotjs/svg.js/-/svg.js-3.0.5.tgz", + "integrity": "sha512-isyQc9Exjz3MZuajNZxnyjEO4OD746FbVOHtHh+abHPV7kO+Zd0mmrX77XHqdA41zxN2tIujg4ckeqCPgzWtog==" + }, "@webassemblyjs/ast": { "version": "1.7.8", "resolved": "https://registry.npmjs.org/@webassemblyjs/ast/-/ast-1.7.8.tgz", @@ -3608,7 +3613,7 @@ }, "npm": { "version": "5.10.0", - "resolved": "https://registry.npmjs.org/npm/-/npm-5.10.0.tgz", + "resolved": "https://repository.stageten.tv/repository/npmjs-stageten/npm/-/npm-5.10.0.tgz", "integrity": "sha512-lvjvjgR5wG2RJ2uqak1xtZcVAWMwVOzN5HkUlUj/n8rU1f3A0fNn+7HwOzH9Lyf0Ppyu9ApgsEpHczOSnx1cwA==", "requires": { "JSONStream": "^1.3.2", diff --git a/package.json b/package.json index ff0bf48..e598fe1 100644 --- a/package.json +++ b/package.json @@ -30,6 +30,7 @@ "webpack-cli": "^3.1.0" }, "dependencies": { + "@svgdotjs/svg.js": "^3.0.5", "npm": "^5.10.0" } } diff --git a/source/PathMatrix.js b/source/PathMatrix.js index dedb08d..d8cee79 100644 --- a/source/PathMatrix.js +++ b/source/PathMatrix.js @@ -1,8 +1,8 @@ -const svg = document.createElementNS("http://www.w3.org/2000/svg", "svg"); +import * as SVG from '@svgdotjs/svg.js/dist/svg.node.js' export default function make(transform) { - const matrix = svg.createSVGMatrix(); + const matrix = new SVG.Matrix(); matrix.a = transform[0]; matrix.b = transform[1]; matrix.c = transform[2]; diff --git a/source/Readers/JSONReader.js b/source/Readers/JSONReader.js index 434f3d5..07c8174 100644 --- a/source/Readers/JSONReader.js +++ b/source/Readers/JSONReader.js @@ -28,7 +28,7 @@ export default class JSONReader extends StreamReader { return this.readProp(label); } - + // Reads the array into ar readFloat32Array(ar, label) { @@ -43,10 +43,14 @@ export default class JSONReader extends StreamReader readArray(ar, label) { const array = this.readProp(label); - for (let i = 0; i < ar.length; i++) + if (array) // I think there's a bug here. { - ar[i] = array[i]; + for (let i = 0; i < ar.length; i++) + { + ar[i] = array[i]; + } } + return ar; } @@ -149,7 +153,7 @@ export default class JSONReader extends StreamReader { return this.readProp(label); } - + readBool(label) { return this.readProp(label); diff --git a/webpack.config.js b/webpack.config.js index 2fbac49..6bc9dd0 100644 --- a/webpack.config.js +++ b/webpack.config.js @@ -2,22 +2,21 @@ const path = require("path"); const BUILD_DIR = path.resolve(__dirname, "build/"); const APP_DIR = path.resolve(__dirname, "source/"); +const EXAMPLE_DIR = path.resolve(__dirname, "example/"); const config = { mode: "development", target: "web", devtool: "source-map", - entry: + entry: { - Flare: APP_DIR + "/Flare.js" + Flare: EXAMPLE_DIR + "/example.js" }, output: { - path: BUILD_DIR, - filename: "Flare.min.js", - library: "Flare", - libraryTarget: "umd" + path: EXAMPLE_DIR, + filename: "example.build.js", }, module: {