npm - lyb-pixi-js - Versions diffs - 1.10.7 → 1.10.8 - Mend

lyb-pixi-js 1.10.7 → 1.10.8

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (10) hide show

package/Components/Custom/LibPixiPuzzleBg.d.ts +7 -0
package/Components/Custom/LibPixiPuzzleBg.js +45 -0
package/Components/Custom/LibPixiScrollContainerX.d.ts +1 -1
package/Components/Custom/LibPixiScrollContainerX.js +1 -1
package/Components/Custom/LibPixiScrollContainerY.d.ts +1 -1
package/Components/Custom/LibPixiScrollContainerY.js +1 -1
package/libPixiJs.d.ts +5 -0
package/libPixiJs.js +5 -0
package/lyb-pixi.js +2834 -455
package/package.json +1 -1

package/lyb-pixi.js CHANGED Viewed

@@ -590,14 +590,14 @@
     } while (p2 !== outerNode);
     if (!m2)
       return null;
-    var stop = m2, mx = m2.x, my = m2.y, tanMin = Infinity, tan;
+    var stop = m2, mx = m2.x, my = m2.y, tanMin = Infinity, tan2;
     p2 = m2;
     do {
       if (hx >= p2.x && p2.x >= mx && hx !== p2.x && pointInTriangle(hy < my ? hx : qx, hy, mx, my, hy < my ? qx : hx, hy, p2.x, p2.y)) {
-        tan = Math.abs(hy - p2.y) / (hx - p2.x);
-        if (locallyInside(p2, hole) && (tan < tanMin || tan === tanMin && (p2.x > m2.x || p2.x === m2.x && sectorContainsSector(m2, p2)))) {
+        tan2 = Math.abs(hy - p2.y) / (hx - p2.x);
+        if (locallyInside(p2, hole) && (tan2 < tanMin || tan2 === tanMin && (p2.x > m2.x || p2.x === m2.x && sectorContainsSector(m2, p2)))) {
           m2 = p2;
-          tanMin = tan;
+          tanMin = tan2;
         }
       }
       p2 = p2.next;
@@ -700,10 +700,10 @@
     return p1.x === p2.x && p1.y === p2.y;
   }
   function intersects(p1, q1, p2, q2) {
-    var o1 = sign$3(area(p1, q1, p2));
-    var o2 = sign$3(area(p1, q1, q2));
-    var o3 = sign$3(area(p2, q2, p1));
-    var o4 = sign$3(area(p2, q2, q1));
+    var o1 = sign$4(area(p1, q1, p2));
+    var o2 = sign$4(area(p1, q1, q2));
+    var o3 = sign$4(area(p2, q2, p1));
+    var o4 = sign$4(area(p2, q2, q1));
     if (o1 !== o2 && o3 !== o4)
       return true;
     if (o1 === 0 && onSegment(p1, p2, q1))
@@ -719,7 +719,7 @@
   function onSegment(p2, q, r2) {
     return q.x <= Math.max(p2.x, r2.x) && q.x >= Math.min(p2.x, r2.x) && q.y <= Math.max(p2.y, r2.y) && q.y >= Math.min(p2.y, r2.y);
   }
-  function sign$3(num) {
+  function sign$4(num) {
     return num > 0 ? 1 : num < 0 ? -1 : 0;
   }
   function intersectsPolygon(a2, b2) {
@@ -810,12 +810,12 @@
     return polygonArea === 0 && trianglesArea === 0 ? 0 : Math.abs((trianglesArea - polygonArea) / polygonArea);
   };
   function signedArea(data, start, end, dim) {
-    var sum = 0;
+    var sum2 = 0;
     for (var i2 = start, j2 = end - dim; i2 < end; i2 += dim) {
-      sum += (data[j2] - data[i2]) * (data[i2 + 1] + data[j2 + 1]);
+      sum2 += (data[j2] - data[i2]) * (data[i2 + 1] + data[j2 + 1]);
       j2 = i2;
     }
-    return sum;
+    return sum2;
   }
   earcut.flatten = function(data) {
     var dim = data[0][0].length, result = { vertices: [], holes: [], dimensions: dim }, holeIndex = 0;
@@ -1317,14 +1317,14 @@
       var protoTag = obj instanceof Object ? "" : "null prototype";
       var stringTag = !isPlainObject && toStringTag && Object(obj) === obj && toStringTag in obj ? $slice.call(toStr(obj), 8, -1) : protoTag ? "Object" : "";
       var constructorTag = isPlainObject || typeof obj.constructor !== "function" ? "" : obj.constructor.name ? obj.constructor.name + " " : "";
-      var tag = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat$1.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
+      var tag2 = constructorTag + (stringTag || protoTag ? "[" + $join.call($concat$1.call([], stringTag || [], protoTag || []), ": ") + "] " : "");
       if (ys.length === 0) {
-        return tag + "{}";
+        return tag2 + "{}";
       }
       if (indent) {
-        return tag + "{" + indentedJoin(ys, indent) + "}";
+        return tag2 + "{" + indentedJoin(ys, indent) + "}";
       }
-      return tag + "{ " + $join.call(ys, ", ") + " }";
+      return tag2 + "{ " + $join.call(ys, ", ") + " }";
     }
     return String(obj);
   };
@@ -1698,17 +1698,17 @@
   var ref = ReferenceError;
   var syntax = SyntaxError;
   var uri = URIError;
-  var abs$1 = Math.abs;
-  var floor$1 = Math.floor;
-  var max$1 = Math.max;
-  var min$1 = Math.min;
-  var pow$1 = Math.pow;
-  var round$2 = Math.round;
+  var abs$2 = Math.abs;
+  var floor$2 = Math.floor;
+  var max$2 = Math.max;
+  var min$2 = Math.min;
+  var pow$2 = Math.pow;
+  var round$3 = Math.round;
   var _isNaN = Number.isNaN || function isNaN2(a2) {
     return a2 !== a2;
   };
   var $isNaN = _isNaN;
-  var sign$2 = function sign2(number) {
+  var sign$3 = function sign2(number) {
     if ($isNaN(number) || number === 0) {
       return number;
     }
@@ -2028,13 +2028,13 @@
   var $SyntaxError = syntax;
   var $TypeError$3 = type;
   var $URIError = uri;
-  var abs = abs$1;
-  var floor = floor$1;
-  var max = max$1;
-  var min = min$1;
-  var pow = pow$1;
-  var round$1 = round$2;
-  var sign$1 = sign$2;
+  var abs$1 = abs$2;
+  var floor$1 = floor$2;
+  var max$1 = max$2;
+  var min$1 = min$2;
+  var pow$1 = pow$2;
+  var round$2 = round$3;
+  var sign$2 = sign$3;
   var $Function = Function;
   var getEvalledConstructor = function(expressionSyntax) {
     try {
@@ -2141,13 +2141,13 @@
     "%Function.prototype.apply%": $apply,
     "%Object.defineProperty%": $defineProperty,
     "%Object.getPrototypeOf%": $ObjectGPO,
-    "%Math.abs%": abs,
-    "%Math.floor%": floor,
-    "%Math.max%": max,
-    "%Math.min%": min,
-    "%Math.pow%": pow,
-    "%Math.round%": round$1,
-    "%Math.sign%": sign$1,
+    "%Math.abs%": abs$1,
+    "%Math.floor%": floor$1,
+    "%Math.max%": max$1,
+    "%Math.min%": min$1,
+    "%Math.pow%": pow$1,
+    "%Math.round%": round$2,
+    "%Math.sign%": sign$2,
     "%Reflect.getPrototypeOf%": $ReflectGPO
   };
   if (getProto) {
@@ -4578,7 +4578,7 @@ Deprecated since v${version}`), console.warn(stack))), warnings[message] = true;
   function isPow2(v2) {
     return !(v2 & v2 - 1) && !!v2;
   }
-  function log2(v2) {
+  function log2$1(v2) {
     let r2 = (v2 > 65535 ? 1 : 0) << 4;
     v2 >>>= r2;
     let shift = (v2 > 255 ? 1 : 0) << 3;
@@ -4595,7 +4595,7 @@ Deprecated since v${version}`), console.warn(stack))), warnings[message] = true;
       arr[i2] = arr[i2 + removeCount];
     arr.length = len;
   }
-  function sign(n2) {
+  function sign$1(n2) {
     return n2 === 0 ? 0 : n2 < 0 ? -1 : 1;
   }
   let nextUid = 0;
@@ -6356,8 +6356,8 @@ else `), i2 < maxIfs - 1 && (src += `if(test == ${i2}.0){}`);
      * @returns This matrix. Good for chaining method calls.
      */
     rotate(angle) {
-      const cos = Math.cos(angle), sin = Math.sin(angle), a1 = this.a, c1 = this.c, tx1 = this.tx;
-      return this.a = a1 * cos - this.b * sin, this.b = a1 * sin + this.b * cos, this.c = c1 * cos - this.d * sin, this.d = c1 * sin + this.d * cos, this.tx = tx1 * cos - this.ty * sin, this.ty = tx1 * sin + this.ty * cos, this;
+      const cos2 = Math.cos(angle), sin2 = Math.sin(angle), a1 = this.a, c1 = this.c, tx1 = this.tx;
+      return this.a = a1 * cos2 - this.b * sin2, this.b = a1 * sin2 + this.b * cos2, this.c = c1 * cos2 - this.d * sin2, this.d = c1 * sin2 + this.d * cos2, this.tx = tx1 * cos2 - this.ty * sin2, this.ty = tx1 * sin2 + this.ty * cos2, this;
     }
     /**
      * Appends the given Matrix to this Matrix.
@@ -7871,7 +7871,7 @@ void main(void){
      * @returns - buffer than can hold atleast `size` floats
      */
     getAttributeBuffer(size) {
-      const roundedP2 = nextPow2(Math.ceil(size / 8)), roundedSizeIndex = log2(roundedP2), roundedSize = roundedP2 * 8;
+      const roundedP2 = nextPow2(Math.ceil(size / 8)), roundedSizeIndex = log2$1(roundedP2), roundedSize = roundedP2 * 8;
       this._aBuffers.length <= roundedSizeIndex && (this._iBuffers.length = roundedSizeIndex + 1);
       let buffer = this._aBuffers[roundedSize];
       return buffer || (this._aBuffers[roundedSize] = buffer = new ViewableBuffer(roundedSize * this.vertexSize * 4)), buffer;
@@ -7883,7 +7883,7 @@ void main(void){
      * @returns - buffer that can fit `size` indices.
      */
     getIndexBuffer(size) {
-      const roundedP2 = nextPow2(Math.ceil(size / 12)), roundedSizeIndex = log2(roundedP2), roundedSize = roundedP2 * 12;
+      const roundedP2 = nextPow2(Math.ceil(size / 12)), roundedSizeIndex = log2$1(roundedP2), roundedSize = roundedP2 * 12;
       this._iBuffers.length <= roundedSizeIndex && (this._iBuffers.length = roundedSizeIndex + 1);
       let buffer = this._iBuffers[roundedSizeIndex];
       return buffer || (this._iBuffers[roundedSizeIndex] = buffer = new Uint16Array(roundedSize)), buffer;
@@ -11145,14 +11145,14 @@ void main(void)
      * Systems are attached dynamically to this class when added.
      * @param config - the config for the system manager
      */
-    setup(config) {
-      this.addRunners(...config.runners);
-      const priority = (config.priority ?? []).filter((key) => config.systems[key]), orderByPriority = [
+    setup(config2) {
+      this.addRunners(...config2.runners);
+      const priority = (config2.priority ?? []).filter((key) => config2.systems[key]), orderByPriority = [
         ...priority,
-        ...Object.keys(config.systems).filter((key) => !priority.includes(key))
+        ...Object.keys(config2.systems).filter((key) => !priority.includes(key))
       ];
       for (const i2 of orderByPriority)
-        this.addSystem(config.systems[i2], i2);
+        this.addSystem(config2.systems[i2], i2);
     }
     /**
      * Create a bunch of runners based of a collection of ids
@@ -14341,7 +14341,7 @@ void main(void)
     }
     /** When the texture is updated, this event will fire to update the scale and frame. */
     _onTextureUpdate() {
-      this._textureID = -1, this._textureTrimmedID = -1, this._cachedTint = 16777215, this._width && (this.scale.x = sign(this.scale.x) * this._width / this._texture.orig.width), this._height && (this.scale.y = sign(this.scale.y) * this._height / this._texture.orig.height);
+      this._textureID = -1, this._textureTrimmedID = -1, this._cachedTint = 16777215, this._width && (this.scale.x = sign$1(this.scale.x) * this._width / this._texture.orig.width), this._height && (this.scale.y = sign$1(this.scale.y) * this._height / this._texture.orig.height);
     }
     /** Called when the anchor position updates. */
     _onAnchorUpdate() {
@@ -14460,7 +14460,7 @@ void main(void)
       return Math.abs(this.scale.x) * this._texture.orig.width;
     }
     set width(value) {
-      const s2 = sign(this.scale.x) || 1;
+      const s2 = sign$1(this.scale.x) || 1;
       this.scale.x = s2 * value / this._texture.orig.width, this._width = value;
     }
     /** The height of the sprite, setting this will actually modify the scale to achieve the value set. */
@@ -14468,7 +14468,7 @@ void main(void)
       return Math.abs(this.scale.y) * this._texture.orig.height;
     }
     set height(value) {
-      const s2 = sign(this.scale.y) || 1;
+      const s2 = sign$1(this.scale.y) || 1;
       this.scale.y = s2 * value / this._texture.orig.height, this._height = value;
     }
     /**
@@ -15164,7 +15164,7 @@ void main(void)
      */
     hue(rotation, multiply) {
       rotation = (rotation || 0) / 180 * Math.PI;
-      const cosR = Math.cos(rotation), sinR = Math.sin(rotation), sqrt = Math.sqrt, w2 = 1 / 3, sqrW = sqrt(w2), a00 = cosR + (1 - cosR) * w2, a01 = w2 * (1 - cosR) - sqrW * sinR, a02 = w2 * (1 - cosR) + sqrW * sinR, a10 = w2 * (1 - cosR) + sqrW * sinR, a11 = cosR + w2 * (1 - cosR), a12 = w2 * (1 - cosR) - sqrW * sinR, a20 = w2 * (1 - cosR) - sqrW * sinR, a21 = w2 * (1 - cosR) + sqrW * sinR, a22 = cosR + w2 * (1 - cosR), matrix = [
+      const cosR = Math.cos(rotation), sinR = Math.sin(rotation), sqrt2 = Math.sqrt, w2 = 1 / 3, sqrW = sqrt2(w2), a00 = cosR + (1 - cosR) * w2, a01 = w2 * (1 - cosR) - sqrW * sinR, a02 = w2 * (1 - cosR) + sqrW * sinR, a10 = w2 * (1 - cosR) + sqrW * sinR, a11 = cosR + w2 * (1 - cosR), a12 = w2 * (1 - cosR) - sqrW * sinR, a20 = w2 * (1 - cosR) - sqrW * sinR, a21 = w2 * (1 - cosR) + sqrW * sinR, a22 = cosR + w2 * (1 - cosR), matrix = [
         a00,
         a01,
         a02,
@@ -17784,8 +17784,8 @@ void main()
      */
     constructor(renderer) {
       this.debug = false, this._isActive = false, this._isMobileAccessibility = false, this.pool = [], this.renderId = 0, this.children = [], this.androidUpdateCount = 0, this.androidUpdateFrequency = 500, this._hookDiv = null, (isMobile.tablet || isMobile.phone) && this.createTouchHook();
-      const div = document.createElement("div");
-      div.style.width = `${DIV_TOUCH_SIZE}px`, div.style.height = `${DIV_TOUCH_SIZE}px`, div.style.position = "absolute", div.style.top = `${DIV_TOUCH_POS_X}px`, div.style.left = `${DIV_TOUCH_POS_Y}px`, div.style.zIndex = DIV_TOUCH_ZINDEX.toString(), this.div = div, this.renderer = renderer, this._onKeyDown = this._onKeyDown.bind(this), this._onMouseMove = this._onMouseMove.bind(this), globalThis.addEventListener("keydown", this._onKeyDown, false);
+      const div2 = document.createElement("div");
+      div2.style.width = `${DIV_TOUCH_SIZE}px`, div2.style.height = `${DIV_TOUCH_SIZE}px`, div2.style.position = "absolute", div2.style.top = `${DIV_TOUCH_POS_X}px`, div2.style.left = `${DIV_TOUCH_POS_Y}px`, div2.style.zIndex = DIV_TOUCH_ZINDEX.toString(), this.div = div2, this.renderer = renderer, this._onKeyDown = this._onKeyDown.bind(this), this._onMouseMove = this._onMouseMove.bind(this), globalThis.addEventListener("keydown", this._onKeyDown, false);
     }
     /**
      * Value of `true` if accessibility is currently active and accessibility layers are showing.
@@ -17862,17 +17862,17 @@ void main()
         return;
       this.renderer.lastObjectRendered && this.updateAccessibleObjects(this.renderer.lastObjectRendered);
       const { x: x2, y: y2, width, height } = this.renderer.view.getBoundingClientRect(), { width: viewWidth, height: viewHeight, resolution } = this.renderer, sx = width / viewWidth * resolution, sy = height / viewHeight * resolution;
-      let div = this.div;
-      div.style.left = `${x2}px`, div.style.top = `${y2}px`, div.style.width = `${viewWidth}px`, div.style.height = `${viewHeight}px`;
+      let div2 = this.div;
+      div2.style.left = `${x2}px`, div2.style.top = `${y2}px`, div2.style.width = `${viewWidth}px`, div2.style.height = `${viewHeight}px`;
       for (let i2 = 0; i2 < this.children.length; i2++) {
         const child = this.children[i2];
         if (child.renderId !== this.renderId)
           child._accessibleActive = false, removeItems(this.children, i2, 1), this.div.removeChild(child._accessibleDiv), this.pool.push(child._accessibleDiv), child._accessibleDiv = null, i2--;
         else {
-          div = child._accessibleDiv;
+          div2 = child._accessibleDiv;
           let hitArea = child.hitArea;
           const wt = child.worldTransform;
-          child.hitArea ? (div.style.left = `${(wt.tx + hitArea.x * wt.a) * sx}px`, div.style.top = `${(wt.ty + hitArea.y * wt.d) * sy}px`, div.style.width = `${hitArea.width * wt.a * sx}px`, div.style.height = `${hitArea.height * wt.d * sy}px`) : (hitArea = child.getBounds(), this.capHitArea(hitArea), div.style.left = `${hitArea.x * sx}px`, div.style.top = `${hitArea.y * sy}px`, div.style.width = `${hitArea.width * sx}px`, div.style.height = `${hitArea.height * sy}px`, div.title !== child.accessibleTitle && child.accessibleTitle !== null && (div.title = child.accessibleTitle), div.getAttribute("aria-label") !== child.accessibleHint && child.accessibleHint !== null && div.setAttribute("aria-label", child.accessibleHint)), (child.accessibleTitle !== div.title || child.tabIndex !== div.tabIndex) && (div.title = child.accessibleTitle, div.tabIndex = child.tabIndex, this.debug && this.updateDebugHTML(div));
+          child.hitArea ? (div2.style.left = `${(wt.tx + hitArea.x * wt.a) * sx}px`, div2.style.top = `${(wt.ty + hitArea.y * wt.d) * sy}px`, div2.style.width = `${hitArea.width * wt.a * sx}px`, div2.style.height = `${hitArea.height * wt.d * sy}px`) : (hitArea = child.getBounds(), this.capHitArea(hitArea), div2.style.left = `${hitArea.x * sx}px`, div2.style.top = `${hitArea.y * sy}px`, div2.style.width = `${hitArea.width * sx}px`, div2.style.height = `${hitArea.height * sy}px`, div2.title !== child.accessibleTitle && child.accessibleTitle !== null && (div2.title = child.accessibleTitle), div2.getAttribute("aria-label") !== child.accessibleHint && child.accessibleHint !== null && div2.setAttribute("aria-label", child.accessibleHint)), (child.accessibleTitle !== div2.title || child.tabIndex !== div2.tabIndex) && (div2.title = child.accessibleTitle, div2.tabIndex = child.tabIndex, this.debug && this.updateDebugHTML(div2));
         }
       }
       this.renderId++;
@@ -17882,8 +17882,8 @@ void main()
      * accessability div
      * @param {HTMLElement} div -
      */
-    updateDebugHTML(div) {
-      div.innerHTML = `type: ${div.type}</br> title : ${div.title}</br> tabIndex: ${div.tabIndex}`;
+    updateDebugHTML(div2) {
+      div2.innerHTML = `type: ${div2.type}</br> title : ${div2.title}</br> tabIndex: ${div2.tabIndex}`;
     }
     /**
      * Adjust the hit area based on the bounds of a display object
@@ -17900,8 +17900,8 @@ void main()
      * @param {PIXI.DisplayObject} displayObject - The child to make accessible.
      */
     addChild(displayObject) {
-      let div = this.pool.pop();
-      div || (div = document.createElement("button"), div.style.width = `${DIV_TOUCH_SIZE}px`, div.style.height = `${DIV_TOUCH_SIZE}px`, div.style.backgroundColor = this.debug ? "rgba(255,255,255,0.5)" : "transparent", div.style.position = "absolute", div.style.zIndex = DIV_TOUCH_ZINDEX.toString(), div.style.borderStyle = "none", navigator.userAgent.toLowerCase().includes("chrome") ? div.setAttribute("aria-live", "off") : div.setAttribute("aria-live", "polite"), navigator.userAgent.match(/rv:.*Gecko\//) ? div.setAttribute("aria-relevant", "additions") : div.setAttribute("aria-relevant", "text"), div.addEventListener("click", this._onClick.bind(this)), div.addEventListener("focus", this._onFocus.bind(this)), div.addEventListener("focusout", this._onFocusOut.bind(this))), div.style.pointerEvents = displayObject.accessiblePointerEvents, div.type = displayObject.accessibleType, displayObject.accessibleTitle && displayObject.accessibleTitle !== null ? div.title = displayObject.accessibleTitle : (!displayObject.accessibleHint || displayObject.accessibleHint === null) && (div.title = `displayObject ${displayObject.tabIndex}`), displayObject.accessibleHint && displayObject.accessibleHint !== null && div.setAttribute("aria-label", displayObject.accessibleHint), this.debug && this.updateDebugHTML(div), displayObject._accessibleActive = true, displayObject._accessibleDiv = div, div.displayObject = displayObject, this.children.push(displayObject), this.div.appendChild(displayObject._accessibleDiv), displayObject._accessibleDiv.tabIndex = displayObject.tabIndex;
+      let div2 = this.pool.pop();
+      div2 || (div2 = document.createElement("button"), div2.style.width = `${DIV_TOUCH_SIZE}px`, div2.style.height = `${DIV_TOUCH_SIZE}px`, div2.style.backgroundColor = this.debug ? "rgba(255,255,255,0.5)" : "transparent", div2.style.position = "absolute", div2.style.zIndex = DIV_TOUCH_ZINDEX.toString(), div2.style.borderStyle = "none", navigator.userAgent.toLowerCase().includes("chrome") ? div2.setAttribute("aria-live", "off") : div2.setAttribute("aria-live", "polite"), navigator.userAgent.match(/rv:.*Gecko\//) ? div2.setAttribute("aria-relevant", "additions") : div2.setAttribute("aria-relevant", "text"), div2.addEventListener("click", this._onClick.bind(this)), div2.addEventListener("focus", this._onFocus.bind(this)), div2.addEventListener("focusout", this._onFocusOut.bind(this))), div2.style.pointerEvents = displayObject.accessiblePointerEvents, div2.type = displayObject.accessibleType, displayObject.accessibleTitle && displayObject.accessibleTitle !== null ? div2.title = displayObject.accessibleTitle : (!displayObject.accessibleHint || displayObject.accessibleHint === null) && (div2.title = `displayObject ${displayObject.tabIndex}`), displayObject.accessibleHint && displayObject.accessibleHint !== null && div2.setAttribute("aria-label", displayObject.accessibleHint), this.debug && this.updateDebugHTML(div2), displayObject._accessibleActive = true, displayObject._accessibleDiv = div2, div2.displayObject = displayObject, this.children.push(displayObject), this.div.appendChild(displayObject._accessibleDiv), displayObject._accessibleDiv.tabIndex = displayObject.tabIndex;
     }
     /**
      * Dispatch events with the EventSystem.
@@ -20510,7 +20510,7 @@ Please use Assets.add({ alias, src, data, format, loadParser }) instead.`), asse
       eoy
     ), 2;
   }
-  function round(cx, cy, sx, sy, ex, ey, verts, clockwise) {
+  function round$1(cx, cy, sx, sy, ex, ey, verts, clockwise) {
     const cx2p0x = sx - cx, cy2p0y = sy - cy;
     let angle0 = Math.atan2(cx2p0x, cy2p0y), angle1 = Math.atan2(ex - cx, ey - cy);
     clockwise && angle0 < angle1 ? angle0 += Math.PI * 2 : !clockwise && angle0 > angle1 && (angle1 += Math.PI * 2);
@@ -20577,7 +20577,7 @@ Please use Assets.add({ alias, src, data, format, loadParser }) instead.`), asse
     let x0 = points[0], y0 = points[1], x1 = points[2], y1 = points[3], x2 = 0, y2 = 0, perpx = -(y0 - y1), perpy = x0 - x1, perp1x = 0, perp1y = 0, dist = Math.sqrt(perpx * perpx + perpy * perpy);
     perpx /= dist, perpy /= dist, perpx *= width, perpy *= width;
     const ratio = style.alignment, innerWeight = (1 - ratio) * 2, outerWeight = ratio * 2;
-    closedShape || (style.cap === LINE_CAP.ROUND ? indexCount += round(
+    closedShape || (style.cap === LINE_CAP.ROUND ? indexCount += round$1(
       x0 - perpx * (innerWeight - outerWeight) * 0.5,
       y0 - perpy * (innerWeight - outerWeight) * 0.5,
       x0 - perpx * innerWeight,
@@ -20601,7 +20601,7 @@ Please use Assets.add({ alias, src, data, format, loadParser }) instead.`), asse
           y1 - perpy * innerWeight,
           x1 + perpx * outerWeight,
           y1 + perpy * outerWeight
-        ), dot >= 0 && (style.join === LINE_JOIN.ROUND ? indexCount += round(
+        ), dot >= 0 && (style.join === LINE_JOIN.ROUND ? indexCount += round$1(
           x1,
           y1,
           x1 - perpx * innerWeight,
@@ -20665,7 +20665,7 @@ Please use Assets.add({ alias, src, data, format, loadParser }) instead.`), asse
               imy,
               x1 + perpx * outerWeight,
               y1 + perpy * outerWeight
-            ), indexCount += round(
+            ), indexCount += round$1(
               x1,
               y1,
               x1 + perpx * outerWeight,
@@ -20684,7 +20684,7 @@ Please use Assets.add({ alias, src, data, format, loadParser }) instead.`), asse
               y1 - perpy * innerWeight,
               omx,
               omy
-            ), indexCount += round(
+            ), indexCount += round$1(
               x1,
               y1,
               x1 - perpx * innerWeight,
@@ -20727,7 +20727,7 @@ Please use Assets.add({ alias, src, data, format, loadParser }) instead.`), asse
             break;
           }
           case LINE_JOIN.ROUND: {
-            clockwise ? indexCount += round(
+            clockwise ? indexCount += round$1(
               x1,
               y1,
               x1 + perpx * outerWeight,
@@ -20736,7 +20736,7 @@ Please use Assets.add({ alias, src, data, format, loadParser }) instead.`), asse
               y1 + perp1y * outerWeight,
               verts,
               true
-            ) + 2 : indexCount += round(
+            ) + 2 : indexCount += round$1(
               x1,
               y1,
               x1 - perpx * innerWeight,
@@ -20763,7 +20763,7 @@ Please use Assets.add({ alias, src, data, format, loadParser }) instead.`), asse
       y1 - perpy * innerWeight,
       x1 + perpx * outerWeight,
       y1 + perpy * outerWeight
-    ), closedShape || (style.cap === LINE_CAP.ROUND ? indexCount += round(
+    ), closedShape || (style.cap === LINE_CAP.ROUND ? indexCount += round$1(
       x1 - perpx * (innerWeight - outerWeight) * 0.5,
       y1 - perpy * (innerWeight - outerWeight) * 0.5,
       x1 - perpx * innerWeight,
@@ -23724,7 +23724,7 @@ void main(void){
     }
     set width(value) {
       this.updateText(true);
-      const s2 = sign(this.scale.x) || 1;
+      const s2 = sign$1(this.scale.x) || 1;
       this.scale.x = s2 * value / this._texture.orig.width, this._width = value;
     }
     /** The height of the Text, setting this will actually modify the scale to achieve the value set. */
@@ -23733,7 +23733,7 @@ void main(void){
     }
     set height(value) {
       this.updateText(true);
-      const s2 = sign(this.scale.y) || 1;
+      const s2 = sign$1(this.scale.y) || 1;
       this.scale.y = s2 * value / this._texture.orig.height, this._height = value;
     }
     /**
@@ -25640,7 +25640,7 @@ void main(void)\r
     }
     set width(value) {
       this.updateText(true);
-      const s2 = sign(this.scale.x) || 1;
+      const s2 = sign$1(this.scale.x) || 1;
       this.scale.x = s2 * value / this._image.width / this.resolution, this._width = value;
     }
     /**
@@ -25652,7 +25652,7 @@ void main(void)\r
     }
     set height(value) {
       this.updateText(true);
-      const s2 = sign(this.scale.y) || 1;
+      const s2 = sign$1(this.scale.y) || 1;
       this.scale.y = s2 * value / this._image.height / this.resolution, this._height = value;
     }
     /** The base style to render with text. */
@@ -26134,7 +26134,7 @@ void main(void)\r
     return value < min2 ? min2 : value > max2 ? max2 : value;
   }, getUnit = function getUnit2(value, v2) {
     return !_isString(value) || !(v2 = _unitExp.exec(value)) ? "" : v2[1];
-  }, clamp = function clamp2(min2, max2, value) {
+  }, clamp$1 = function clamp2(min2, max2, value) {
     return _conditionalReturn(value, function(v2) {
       return _clamp(min2, max2, v2);
     });
@@ -26166,14 +26166,14 @@ void main(void)\r
     }
     var vars = _isObject(v2) ? v2 : {
       each: v2
-    }, ease = _parseEase(vars.ease), from = vars.from || 0, base = parseFloat(vars.base) || 0, cache = {}, isDecimal = from > 0 && from < 1, ratios = isNaN(from) || isDecimal, axis = vars.axis, ratioX = from, ratioY = from;
+    }, ease = _parseEase(vars.ease), from = vars.from || 0, base = parseFloat(vars.base) || 0, cache = {}, isDecimal2 = from > 0 && from < 1, ratios = isNaN(from) || isDecimal2, axis = vars.axis, ratioX = from, ratioY = from;
     if (_isString(from)) {
       ratioX = ratioY = {
         center: 0.5,
         edges: 0.5,
         end: 1
       }[from] || 0;
-    } else if (!isDecimal && ratios) {
+    } else if (!isDecimal2 && ratios) {
       ratioX = from[0];
       ratioY = from[1];
     }
@@ -26250,7 +26250,7 @@ void main(void)\r
       closest = !radius || min2 <= radius ? snapTo[closest] : raw;
       return is2D || closest === raw || _isNumber(raw) ? closest : closest + getUnit(raw);
     });
-  }, random = function random2(min2, max2, roundingIncrement, returnFunction) {
+  }, random$1 = function random2(min2, max2, roundingIncrement, returnFunction) {
     return _conditionalReturn(_isArray(min2) ? !max2 : roundingIncrement === true ? !!(roundingIncrement = 0) : !returnFunction, function() {
       return _isArray(min2) ? min2[~~(Math.random() * min2.length)] : (roundingIncrement = roundingIncrement || 1e-5) && (returnFunction = roundingIncrement < 1 ? Math.pow(10, (roundingIncrement + "").length - 2) : 1) && Math.floor(Math.round((min2 - roundingIncrement / 2 + Math.random() * (max2 - min2 + roundingIncrement * 0.99)) / roundingIncrement) * roundingIncrement * returnFunction) / returnFunction;
     });
@@ -26290,7 +26290,7 @@ void main(void)\r
       end = value.indexOf(")", i2);
       isArray2 = value.charAt(i2 + 7) === "[";
       nums = value.substr(i2 + 7, end - i2 - 7).match(isArray2 ? _delimitedValueExp : _strictNumExp);
-      s2 += value.substr(prev, i2 - prev) + random(isArray2 ? nums : +nums[0], isArray2 ? 0 : +nums[1], +nums[2] || 1e-5);
+      s2 += value.substr(prev, i2 - prev) + random$1(isArray2 ? nums : +nums[0], isArray2 ? 0 : +nums[1], +nums[2] || 1e-5);
       prev = end + 1;
     }
     return s2 + value.substr(prev, value.length - prev);
@@ -26367,14 +26367,14 @@ void main(void)\r
     animation.scrollTrigger && animation.scrollTrigger.kill(!!_reverting$1);
     animation.progress() < 1 && _callback(animation, "onInterrupt");
     return animation;
-  }, _quickTween, _registerPluginQueue = [], _createPlugin = function _createPlugin2(config) {
-    if (!config)
+  }, _quickTween, _registerPluginQueue = [], _createPlugin = function _createPlugin2(config2) {
+    if (!config2)
       return;
-    config = !config.name && config["default"] || config;
-    if (_windowExists$1() || config.headless) {
-      var name = config.name, isFunc = _isFunction(config), Plugin = name && !isFunc && config.init ? function() {
+    config2 = !config2.name && config2["default"] || config2;
+    if (_windowExists$1() || config2.headless) {
+      var name = config2.name, isFunc = _isFunction(config2), Plugin = name && !isFunc && config2.init ? function() {
         this._props = [];
-      } : config, instanceDefaults = {
+      } : config2, instanceDefaults = {
         init: _emptyFunc,
         render: _renderPropTweens,
         add: _addPropTween,
@@ -26389,23 +26389,23 @@ void main(void)\r
         register: 0
       };
       _wake();
-      if (config !== Plugin) {
+      if (config2 !== Plugin) {
         if (_plugins[name]) {
           return;
         }
-        _setDefaults(Plugin, _setDefaults(_copyExcluding(config, instanceDefaults), statics));
-        _merge(Plugin.prototype, _merge(instanceDefaults, _copyExcluding(config, statics)));
+        _setDefaults(Plugin, _setDefaults(_copyExcluding(config2, instanceDefaults), statics));
+        _merge(Plugin.prototype, _merge(instanceDefaults, _copyExcluding(config2, statics)));
         _plugins[Plugin.prop = name] = Plugin;
-        if (config.targetTest) {
+        if (config2.targetTest) {
           _harnessPlugins.push(Plugin);
           _reservedProps[name] = 1;
         }
         name = (name === "css" ? "CSS" : name.charAt(0).toUpperCase() + name.substr(1)) + "Plugin";
       }
       _addGlobal(name, Plugin);
-      config.register && config.register(gsap, Plugin, PropTween);
+      config2.register && config2.register(gsap, Plugin, PropTween);
     } else {
-      _registerPluginQueue.push(config);
+      _registerPluginQueue.push(config2);
     }
   }, _255 = 255, _colorLookup = {
     aqua: [0, _255, _255],
@@ -26607,7 +26607,7 @@ void main(void)\r
         _gap = 1e3 / (_fps || 240);
         _nextTime = _self.time * 1e3 + _gap;
       },
-      add: function add(callback, once, prioritize) {
+      add: function add2(callback, once, prioritize) {
         var func = once ? function(t2, d2, f2, v2) {
           callback(t2, d2, f2, v2);
           _self.remove(func);
@@ -26750,7 +26750,7 @@ void main(void)\r
   });
   _insertEase("Back", _configBack("in"), _configBack("out"), _configBack());
   _easeMap.SteppedEase = _easeMap.steps = _globals.SteppedEase = {
-    config: function config(steps, immediateStart) {
+    config: function config2(steps, immediateStart) {
       if (steps === void 0) {
         steps = 1;
       }
@@ -26893,17 +26893,17 @@ void main(void)\r
       var parent = this.parent || this._dp;
       return !parent ? this._tTime : wrapRepeats && (!this._ts || this._repeat && this._time && this.totalProgress() < 1) ? this._tTime % (this._dur + this._rDelay) : !this._ts ? this._tTime : _parentToChildTotalTime(parent.rawTime(wrapRepeats), this);
     };
-    _proto.revert = function revert(config) {
-      if (config === void 0) {
-        config = _revertConfig;
+    _proto.revert = function revert(config2) {
+      if (config2 === void 0) {
+        config2 = _revertConfig;
       }
       var prevIsReverting = _reverting$1;
-      _reverting$1 = config;
+      _reverting$1 = config2;
       if (this._initted || this._startAt) {
-        this.timeline && this.timeline.revert(config);
-        this.totalTime(-0.01, config.suppressEvents);
+        this.timeline && this.timeline.revert(config2);
+        this.totalTime(-0.01, config2.suppressEvents);
       }
-      this.data !== "nested" && config.kill !== false && this.kill();
+      this.data !== "nested" && config2.kill !== false && this.kill();
       _reverting$1 = prevIsReverting;
       return this;
     };
@@ -27240,7 +27240,7 @@ void main(void)\r
       }
       return this;
     };
-    _proto2.add = function add(child, position) {
+    _proto2.add = function add2(child, position) {
       var _this2 = this;
       _isNumber(position) || (position = _parsePosition(this, position, child));
       if (!(child instanceof Animation$3)) {
@@ -28279,7 +28279,7 @@ void main(void)\r
       func && this.add(func);
     }
     var _proto5 = Context2.prototype;
-    _proto5.add = function add(name, func, scope) {
+    _proto5.add = function add2(name, func, scope) {
       if (_isFunction(name)) {
         scope = func;
         func = name;
@@ -28372,8 +28372,8 @@ void main(void)\r
         }
       }
     };
-    _proto5.revert = function revert(config) {
-      this.kill(config || {});
+    _proto5.revert = function revert(config2) {
+      this.kill(config2 || {});
     };
     return Context2;
   }();
@@ -28384,7 +28384,7 @@ void main(void)\r
       _context && _context.data.push(this);
     }
     var _proto6 = MatchMedia2.prototype;
-    _proto6.add = function add(conditions, func, scope) {
+    _proto6.add = function add2(conditions, func, scope) {
       _isObject(conditions) || (conditions = {
         matches: conditions
       });
@@ -28410,8 +28410,8 @@ void main(void)\r
       });
       return this;
     };
-    _proto6.revert = function revert(config) {
-      this.kill(config || {});
+    _proto6.revert = function revert(config2) {
+      this.kill(config2 || {});
     };
     _proto6.kill = function kill(revert) {
       this.contexts.forEach(function(c2) {
@@ -28425,8 +28425,8 @@ void main(void)\r
       for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
         args[_key2] = arguments[_key2];
       }
-      args.forEach(function(config) {
-        return _createPlugin(config);
+      args.forEach(function(config2) {
+        return _createPlugin(config2);
       });
     },
     timeline: function timeline(vars) {
@@ -28483,7 +28483,7 @@ void main(void)\r
       value && value.ease && (value.ease = _parseEase(value.ease, _defaults.ease));
       return _mergeDeep(_defaults, value || {});
     },
-    config: function config(value) {
+    config: function config2(value) {
       return _mergeDeep(_config, value || {});
     },
     registerEffect: function registerEffect(_ref3) {
@@ -28559,11 +28559,11 @@ void main(void)\r
       wrap,
       wrapYoyo,
       distribute,
-      random,
+      random: random$1,
       snap,
       normalize: normalize$1,
       getUnit,
-      clamp,
+      clamp: clamp$1,
       splitColor,
       toArray,
       selector,
@@ -29242,7 +29242,7 @@ void main(void)\r
     if ("x" in cache && !uncache && !cache.uncache) {
       return cache;
     }
-    var style = target.style, invertedScaleX = cache.scaleX < 0, px = "px", deg = "deg", cs = getComputedStyle(target), origin = _getComputedProperty(target, _transformOriginProp) || "0", x2, y2, z2, scaleX, scaleY, rotation, rotationX, rotationY, skewX, skewY, perspective, xOrigin, yOrigin, matrix, angle, cos, sin, a2, b2, c2, d2, a12, a22, t1, t2, t3, a13, a23, a33, a42, a43, a32;
+    var style = target.style, invertedScaleX = cache.scaleX < 0, px = "px", deg = "deg", cs = getComputedStyle(target), origin = _getComputedProperty(target, _transformOriginProp) || "0", x2, y2, z2, scaleX, scaleY, rotation, rotationX, rotationY, skewX, skewY, perspective, xOrigin, yOrigin, matrix, angle, cos2, sin2, a2, b2, c2, d2, a12, a22, t1, t2, t3, a13, a23, a33, a42, a43, a32;
     x2 = y2 = z2 = rotation = rotationX = rotationY = skewX = skewY = perspective = 0;
     scaleX = scaleY = 1;
     cache.svg = !!(target.getCTM && _isSVG(target));
@@ -29295,15 +29295,15 @@ void main(void)\r
         angle = _atan2(a32, a33);
         rotationX = angle * _RAD2DEG;
         if (angle) {
-          cos = Math.cos(-angle);
-          sin = Math.sin(-angle);
-          t1 = a12 * cos + a13 * sin;
-          t2 = a22 * cos + a23 * sin;
-          t3 = a32 * cos + a33 * sin;
-          a13 = a12 * -sin + a13 * cos;
-          a23 = a22 * -sin + a23 * cos;
-          a33 = a32 * -sin + a33 * cos;
-          a43 = a42 * -sin + a43 * cos;
+          cos2 = Math.cos(-angle);
+          sin2 = Math.sin(-angle);
+          t1 = a12 * cos2 + a13 * sin2;
+          t2 = a22 * cos2 + a23 * sin2;
+          t3 = a32 * cos2 + a33 * sin2;
+          a13 = a12 * -sin2 + a13 * cos2;
+          a23 = a22 * -sin2 + a23 * cos2;
+          a33 = a32 * -sin2 + a33 * cos2;
+          a43 = a42 * -sin2 + a43 * cos2;
           a12 = t1;
           a22 = t2;
           a32 = t3;
@@ -29311,12 +29311,12 @@ void main(void)\r
         angle = _atan2(-c2, a33);
         rotationY = angle * _RAD2DEG;
         if (angle) {
-          cos = Math.cos(-angle);
-          sin = Math.sin(-angle);
-          t1 = a2 * cos - a13 * sin;
-          t2 = b2 * cos - a23 * sin;
-          t3 = c2 * cos - a33 * sin;
-          a43 = d2 * sin + a43 * cos;
+          cos2 = Math.cos(-angle);
+          sin2 = Math.sin(-angle);
+          t1 = a2 * cos2 - a13 * sin2;
+          t2 = b2 * cos2 - a23 * sin2;
+          t3 = c2 * cos2 - a33 * sin2;
+          a43 = d2 * sin2 + a43 * cos2;
           a2 = t1;
           b2 = t2;
           c2 = t3;
@@ -29324,12 +29324,12 @@ void main(void)\r
         angle = _atan2(b2, a2);
         rotation = angle * _RAD2DEG;
         if (angle) {
-          cos = Math.cos(angle);
-          sin = Math.sin(angle);
-          t1 = a2 * cos + b2 * sin;
-          t2 = a12 * cos + a22 * sin;
-          b2 = b2 * cos - a2 * sin;
-          a22 = a22 * cos - a12 * sin;
+          cos2 = Math.cos(angle);
+          sin2 = Math.sin(angle);
+          t1 = a2 * cos2 + b2 * sin2;
+          t2 = a12 * cos2 + a22 * sin2;
+          b2 = b2 * cos2 - a2 * sin2;
+          a22 = a22 * cos2 - a12 * sin2;
           a2 = t1;
           a12 = t2;
         }
@@ -29392,12 +29392,12 @@ void main(void)\r
   }, _zeroDeg = "0deg", _zeroPx = "0px", _endParenthesis = ") ", _renderCSSTransforms = function _renderCSSTransforms2(ratio, cache) {
     var _ref = cache || this, xPercent = _ref.xPercent, yPercent = _ref.yPercent, x2 = _ref.x, y2 = _ref.y, z2 = _ref.z, rotation = _ref.rotation, rotationY = _ref.rotationY, rotationX = _ref.rotationX, skewX = _ref.skewX, skewY = _ref.skewY, scaleX = _ref.scaleX, scaleY = _ref.scaleY, transformPerspective = _ref.transformPerspective, force3D = _ref.force3D, target = _ref.target, zOrigin = _ref.zOrigin, transforms = "", use3D = force3D === "auto" && ratio && ratio !== 1 || force3D === true;
     if (zOrigin && (rotationX !== _zeroDeg || rotationY !== _zeroDeg)) {
-      var angle = parseFloat(rotationY) * _DEG2RAD, a13 = Math.sin(angle), a33 = Math.cos(angle), cos;
+      var angle = parseFloat(rotationY) * _DEG2RAD, a13 = Math.sin(angle), a33 = Math.cos(angle), cos2;
       angle = parseFloat(rotationX) * _DEG2RAD;
-      cos = Math.cos(angle);
-      x2 = _addPxTranslate(target, x2, a13 * cos * -zOrigin);
+      cos2 = Math.cos(angle);
+      x2 = _addPxTranslate(target, x2, a13 * cos2 * -zOrigin);
       y2 = _addPxTranslate(target, y2, -Math.sin(angle) * -zOrigin);
-      z2 = _addPxTranslate(target, z2, a33 * cos * -zOrigin + zOrigin);
+      z2 = _addPxTranslate(target, z2, a33 * cos2 * -zOrigin + zOrigin);
     }
     if (transformPerspective !== _zeroPx) {
       transforms += "perspective(" + transformPerspective + _endParenthesis;
@@ -30082,7 +30082,7 @@ void main(void)\r
      *                          true, the Emitter will automatically call
      *                          update via the PIXI shared ticker.
      */
-    constructor(particleParent, config) {
+    constructor(particleParent, config2) {
       this.initBehaviors = [];
       this.updateBehaviors = [];
       this.recycleBehaviors = [];
@@ -30114,8 +30114,8 @@ void main(void)\r
       this._destroyWhenComplete = false;
       this._completeCallback = null;
       this.parent = particleParent;
-      if (config) {
-        this.init(config);
+      if (config2) {
+        this.init(config2);
       }
       this.recycle = this.recycle;
       this.update = this.update;
@@ -30160,41 +30160,41 @@ void main(void)\r
      * Sets up the emitter based on the config settings.
      * @param config A configuration object containing settings for the emitter.
      */
-    init(config) {
-      if (!config) {
+    init(config2) {
+      if (!config2) {
         return;
       }
       this.cleanup();
-      this._origConfig = config;
-      this.minLifetime = config.lifetime.min;
-      this.maxLifetime = config.lifetime.max;
-      if (config.ease) {
-        this.customEase = typeof config.ease === "function" ? config.ease : generateEase(config.ease);
+      this._origConfig = config2;
+      this.minLifetime = config2.lifetime.min;
+      this.maxLifetime = config2.lifetime.max;
+      if (config2.ease) {
+        this.customEase = typeof config2.ease === "function" ? config2.ease : generateEase(config2.ease);
       } else {
         this.customEase = null;
       }
       this.particlesPerWave = 1;
-      if (config.particlesPerWave && config.particlesPerWave > 1) {
-        this.particlesPerWave = config.particlesPerWave;
-      }
-      this.frequency = config.frequency;
-      this.spawnChance = typeof config.spawnChance === "number" && config.spawnChance > 0 ? config.spawnChance : 1;
-      this.emitterLifetime = config.emitterLifetime || -1;
-      this.maxParticles = config.maxParticles > 0 ? config.maxParticles : 1e3;
-      this.addAtBack = !!config.addAtBack;
+      if (config2.particlesPerWave && config2.particlesPerWave > 1) {
+        this.particlesPerWave = config2.particlesPerWave;
+      }
+      this.frequency = config2.frequency;
+      this.spawnChance = typeof config2.spawnChance === "number" && config2.spawnChance > 0 ? config2.spawnChance : 1;
+      this.emitterLifetime = config2.emitterLifetime || -1;
+      this.maxParticles = config2.maxParticles > 0 ? config2.maxParticles : 1e3;
+      this.addAtBack = !!config2.addAtBack;
       this.rotation = 0;
       this.ownerPos.set(0);
-      if (config.pos) {
-        this.spawnPos.copyFrom(config.pos);
+      if (config2.pos) {
+        this.spawnPos.copyFrom(config2.pos);
       } else {
         this.spawnPos.set(0);
       }
       this._prevEmitterPos.copyFrom(this.spawnPos);
       this._prevPosIsValid = false;
       this._spawnTimer = 0;
-      this.emit = config.emit === void 0 ? true : !!config.emit;
-      this.autoUpdate = !!config.autoUpdate;
-      const behaviors = config.behaviors.map((data) => {
+      this.emit = config2.emit === void 0 ? true : !!config2.emit;
+      this.autoUpdate = !!config2.autoUpdate;
+      const behaviors = config2.behaviors.map((data) => {
         const constructor = Emitter.knownBehaviors[data.type];
         if (!constructor) {
           console.error(`Unknown behavior: ${data.type}`);
@@ -30629,11 +30629,11 @@ void main(void)\r
   }
   Emitter.knownBehaviors = {};
   class Rectangle {
-    constructor(config) {
-      this.x = config.x;
-      this.y = config.y;
-      this.w = config.w;
-      this.h = config.h;
+    constructor(config2) {
+      this.x = config2.x;
+      this.y = config2.y;
+      this.w = config2.w;
+      this.h = config2.h;
     }
     getRandPos(particle) {
       particle.x = Math.random() * this.w + this.x;
@@ -30643,12 +30643,12 @@ void main(void)\r
   Rectangle.type = "rect";
   Rectangle.editorConfig = null;
   class Torus {
-    constructor(config) {
-      this.x = config.x || 0;
-      this.y = config.y || 0;
-      this.radius = config.radius;
-      this.innerRadius = config.innerRadius || 0;
-      this.rotation = !!config.affectRotation;
+    constructor(config2) {
+      this.x = config2.x || 0;
+      this.y = config2.y || 0;
+      this.radius = config2.radius;
+      this.innerRadius = config2.innerRadius || 0;
+      this.rotation = !!config2.affectRotation;
     }
     getRandPos(particle) {
       if (this.innerRadius !== this.radius) {
@@ -30739,14 +30739,14 @@ void main(void)\r
   PolygonalChain.type = "polygonalChain";
   PolygonalChain.editorConfig = null;
   class AccelerationBehavior {
-    constructor(config) {
+    constructor(config2) {
       var _a;
       this.order = BehaviorOrder.Late;
-      this.minStart = config.minStart;
-      this.maxStart = config.maxStart;
-      this.accel = config.accel;
-      this.rotate = !!config.rotate;
-      this.maxSpeed = (_a = config.maxSpeed) !== null && _a !== void 0 ? _a : 0;
+      this.minStart = config2.minStart;
+      this.maxStart = config2.maxStart;
+      this.accel = config2.accel;
+      this.rotate = !!config2.rotate;
+      this.maxSpeed = (_a = config2.maxSpeed) !== null && _a !== void 0 ? _a : 0;
     }
     initParticles(first) {
       let next = first;
@@ -30874,10 +30874,10 @@ void main(void)\r
     }
   }
   class AlphaBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
       this.list = new PropertyList(false);
-      this.list.reset(PropertyNode.createList(config.alpha));
+      this.list.reset(PropertyNode.createList(config2.alpha));
     }
     initParticles(first) {
       let next = first;
@@ -30893,9 +30893,9 @@ void main(void)\r
   AlphaBehavior.type = "alpha";
   AlphaBehavior.editorConfig = null;
   class StaticAlphaBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
-      this.value = config.alpha;
+      this.value = config2.alpha;
     }
     initParticles(first) {
       let next = first;
@@ -30930,11 +30930,11 @@ void main(void)\r
     return outTextures;
   }
   class RandomAnimatedTextureBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
       this.anims = [];
-      for (let i2 = 0; i2 < config.anims.length; ++i2) {
-        const anim = config.anims[i2];
+      for (let i2 = 0; i2 < config2.anims.length; ++i2) {
+        const anim = config2.anims[i2];
         const textures = getTextures(anim.textures);
         const framerate = anim.framerate < 0 ? -1 : anim.framerate > 0 ? anim.framerate : 60;
         const parsedAnim = {
@@ -30964,26 +30964,26 @@ void main(void)\r
       }
     }
     updateParticle(particle, deltaSec) {
-      const config = particle.config;
-      const anim = config.anim;
-      config.animElapsed += deltaSec;
-      if (config.animElapsed >= config.animDuration) {
-        if (config.anim.loop) {
-          config.animElapsed = config.animElapsed % config.animDuration;
+      const config2 = particle.config;
+      const anim = config2.anim;
+      config2.animElapsed += deltaSec;
+      if (config2.animElapsed >= config2.animDuration) {
+        if (config2.anim.loop) {
+          config2.animElapsed = config2.animElapsed % config2.animDuration;
         } else {
-          config.animElapsed = config.animDuration - 1e-6;
+          config2.animElapsed = config2.animDuration - 1e-6;
         }
       }
-      const frame = config.animElapsed * config.animFramerate + 1e-7 | 0;
+      const frame = config2.animElapsed * config2.animFramerate + 1e-7 | 0;
       particle.texture = anim.textures[frame] || anim.textures[anim.textures.length - 1] || Texture.EMPTY;
     }
   }
   RandomAnimatedTextureBehavior.type = "animatedRandom";
   RandomAnimatedTextureBehavior.editorConfig = null;
   class SingleAnimatedTextureBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
-      const anim = config.anim;
+      const anim = config2.anim;
       const textures = getTextures(anim.textures);
       const framerate = anim.framerate < 0 ? -1 : anim.framerate > 0 ? anim.framerate : 60;
       this.anim = {
@@ -31011,25 +31011,25 @@ void main(void)\r
     }
     updateParticle(particle, deltaSec) {
       const anim = this.anim;
-      const config = particle.config;
-      config.animElapsed += deltaSec;
-      if (config.animElapsed >= config.animDuration) {
+      const config2 = particle.config;
+      config2.animElapsed += deltaSec;
+      if (config2.animElapsed >= config2.animDuration) {
         if (anim.loop) {
-          config.animElapsed = config.animElapsed % config.animDuration;
+          config2.animElapsed = config2.animElapsed % config2.animDuration;
         } else {
-          config.animElapsed = config.animDuration - 1e-6;
+          config2.animElapsed = config2.animDuration - 1e-6;
         }
       }
-      const frame = config.animElapsed * config.animFramerate + 1e-7 | 0;
+      const frame = config2.animElapsed * config2.animFramerate + 1e-7 | 0;
       particle.texture = anim.textures[frame] || anim.textures[anim.textures.length - 1] || Texture.EMPTY;
     }
   }
   SingleAnimatedTextureBehavior.type = "animatedSingle";
   SingleAnimatedTextureBehavior.editorConfig = null;
   class BlendModeBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
-      this.value = config.blendMode;
+      this.value = config2.blendMode;
     }
     initParticles(first) {
       let next = first;
@@ -31042,11 +31042,11 @@ void main(void)\r
   BlendModeBehavior.type = "blendMode";
   BlendModeBehavior.editorConfig = null;
   class BurstSpawnBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Spawn;
-      this.spacing = config.spacing * DEG_TO_RADS;
-      this.start = config.start * DEG_TO_RADS;
-      this.distance = config.distance;
+      this.spacing = config2.spacing * DEG_TO_RADS;
+      this.start = config2.start * DEG_TO_RADS;
+      this.distance = config2.distance;
     }
     initParticles(first) {
       let count = 0;
@@ -31071,10 +31071,10 @@ void main(void)\r
   BurstSpawnBehavior.type = "spawnBurst";
   BurstSpawnBehavior.editorConfig = null;
   class ColorBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
       this.list = new PropertyList(true);
-      this.list.reset(PropertyNode.createList(config.color));
+      this.list.reset(PropertyNode.createList(config2.color));
     }
     initParticles(first) {
       let next = first;
@@ -31092,9 +31092,9 @@ void main(void)\r
   ColorBehavior.type = "color";
   ColorBehavior.editorConfig = null;
   class StaticColorBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
-      let color = config.color;
+      let color = config2.color;
       if (color.charAt(0) === "#") {
         color = color.substr(1);
       } else if (color.indexOf("0x") === 0) {
@@ -31113,10 +31113,10 @@ void main(void)\r
   StaticColorBehavior.type = "colorStatic";
   StaticColorBehavior.editorConfig = null;
   class OrderedTextureBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
       this.index = 0;
-      this.textures = config.textures.map((tex) => typeof tex === "string" ? GetTextureFromString(tex) : tex);
+      this.textures = config2.textures.map((tex) => typeof tex === "string" ? GetTextureFromString(tex) : tex);
     }
     initParticles(first) {
       let next = first;
@@ -31190,15 +31190,15 @@ void main(void)\r
     return new Function("x", `return ${pathString};`);
   }
   class PathBehavior {
-    constructor(config) {
+    constructor(config2) {
       var _a;
       this.order = BehaviorOrder.Late;
-      if (config.path) {
-        if (typeof config.path === "function") {
-          this.path = config.path;
+      if (config2.path) {
+        if (typeof config2.path === "function") {
+          this.path = config2.path;
         } else {
           try {
-            this.path = parsePath(config.path);
+            this.path = parsePath(config2.path);
           } catch (e2) {
             this.path = null;
           }
@@ -31207,8 +31207,8 @@ void main(void)\r
         this.path = (x2) => x2;
       }
       this.list = new PropertyList(false);
-      this.list.reset(PropertyNode.createList(config.speed));
-      this.minMult = (_a = config.minMult) !== null && _a !== void 0 ? _a : 1;
+      this.list.reset(PropertyNode.createList(config2.speed));
+      this.minMult = (_a = config2.minMult) !== null && _a !== void 0 ? _a : 1;
     }
     initParticles(first) {
       let next = first;
@@ -31248,9 +31248,9 @@ void main(void)\r
   PointSpawnBehavior.type = "spawnPoint";
   PointSpawnBehavior.editorConfig = null;
   class RandomTextureBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
-      this.textures = config.textures.map((tex) => typeof tex === "string" ? GetTextureFromString(tex) : tex);
+      this.textures = config2.textures.map((tex) => typeof tex === "string" ? GetTextureFromString(tex) : tex);
     }
     initParticles(first) {
       let next = first;
@@ -31264,13 +31264,13 @@ void main(void)\r
   RandomTextureBehavior.type = "textureRandom";
   RandomTextureBehavior.editorConfig = null;
   class RotationBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
-      this.minStart = config.minStart * DEG_TO_RADS;
-      this.maxStart = config.maxStart * DEG_TO_RADS;
-      this.minSpeed = config.minSpeed * DEG_TO_RADS;
-      this.maxSpeed = config.maxSpeed * DEG_TO_RADS;
-      this.accel = config.accel * DEG_TO_RADS;
+      this.minStart = config2.minStart * DEG_TO_RADS;
+      this.maxStart = config2.maxStart * DEG_TO_RADS;
+      this.minSpeed = config2.minSpeed * DEG_TO_RADS;
+      this.maxSpeed = config2.maxSpeed * DEG_TO_RADS;
+      this.accel = config2.accel * DEG_TO_RADS;
     }
     initParticles(first) {
       let next = first;
@@ -31297,10 +31297,10 @@ void main(void)\r
   RotationBehavior.type = "rotation";
   RotationBehavior.editorConfig = null;
   class StaticRotationBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
-      this.min = config.min * DEG_TO_RADS;
-      this.max = config.max * DEG_TO_RADS;
+      this.min = config2.min * DEG_TO_RADS;
+      this.max = config2.max * DEG_TO_RADS;
     }
     initParticles(first) {
       let next = first;
@@ -31317,9 +31317,9 @@ void main(void)\r
   StaticRotationBehavior.type = "rotationStatic";
   StaticRotationBehavior.editorConfig = null;
   class NoRotationBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Late + 1;
-      this.rotation = (config.rotation || 0) * DEG_TO_RADS;
+      this.rotation = (config2.rotation || 0) * DEG_TO_RADS;
     }
     initParticles(first) {
       let next = first;
@@ -31332,12 +31332,12 @@ void main(void)\r
   NoRotationBehavior.type = "noRotation";
   NoRotationBehavior.editorConfig = null;
   class ScaleBehavior {
-    constructor(config) {
+    constructor(config2) {
       var _a;
       this.order = BehaviorOrder.Normal;
       this.list = new PropertyList(false);
-      this.list.reset(PropertyNode.createList(config.scale));
-      this.minMult = (_a = config.minMult) !== null && _a !== void 0 ? _a : 1;
+      this.list.reset(PropertyNode.createList(config2.scale));
+      this.minMult = (_a = config2.minMult) !== null && _a !== void 0 ? _a : 1;
     }
     initParticles(first) {
       let next = first;
@@ -31355,10 +31355,10 @@ void main(void)\r
   ScaleBehavior.type = "scale";
   ScaleBehavior.editorConfig = null;
   class StaticScaleBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
-      this.min = config.min;
-      this.max = config.max;
+      this.min = config2.min;
+      this.max = config2.max;
     }
     initParticles(first) {
       let next = first;
@@ -31372,13 +31372,13 @@ void main(void)\r
   StaticScaleBehavior.type = "scaleStatic";
   StaticScaleBehavior.editorConfig = null;
   class ShapeSpawnBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Spawn;
-      const ShapeClass = ShapeSpawnBehavior.shapes[config.type];
+      const ShapeClass = ShapeSpawnBehavior.shapes[config2.type];
       if (!ShapeClass) {
-        throw new Error(`No shape found with type '${config.type}'`);
+        throw new Error(`No shape found with type '${config2.type}'`);
       }
-      this.shape = new ShapeClass(config.data);
+      this.shape = new ShapeClass(config2.data);
     }
     /**
      * Registers a shape to be used by the ShapeSpawn behavior.
@@ -31404,9 +31404,9 @@ void main(void)\r
   ShapeSpawnBehavior.registerShape(Torus);
   ShapeSpawnBehavior.registerShape(Torus, "circle");
   class SingleTextureBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Normal;
-      this.texture = typeof config.texture === "string" ? GetTextureFromString(config.texture) : config.texture;
+      this.texture = typeof config2.texture === "string" ? GetTextureFromString(config2.texture) : config2.texture;
     }
     initParticles(first) {
       let next = first;
@@ -31419,12 +31419,12 @@ void main(void)\r
   SingleTextureBehavior.type = "textureSingle";
   SingleTextureBehavior.editorConfig = null;
   class SpeedBehavior {
-    constructor(config) {
+    constructor(config2) {
       var _a;
       this.order = BehaviorOrder.Late;
       this.list = new PropertyList(false);
-      this.list.reset(PropertyNode.createList(config.speed));
-      this.minMult = (_a = config.minMult) !== null && _a !== void 0 ? _a : 1;
+      this.list.reset(PropertyNode.createList(config2.speed));
+      this.minMult = (_a = config2.minMult) !== null && _a !== void 0 ? _a : 1;
     }
     initParticles(first) {
       let next = first;
@@ -31452,10 +31452,10 @@ void main(void)\r
   SpeedBehavior.type = "moveSpeed";
   SpeedBehavior.editorConfig = null;
   class StaticSpeedBehavior {
-    constructor(config) {
+    constructor(config2) {
       this.order = BehaviorOrder.Late;
-      this.min = config.min;
-      this.max = config.max;
+      this.min = config2.min;
+      this.max = config2.max;
     }
     initParticles(first) {
       let next = first;
@@ -31478,39 +31478,39 @@ void main(void)\r
   }
   StaticSpeedBehavior.type = "moveSpeedStatic";
   StaticSpeedBehavior.editorConfig = null;
-  function upgradeConfig(config, art) {
+  function upgradeConfig(config2, art) {
     var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q, _r, _s, _t, _u, _v, _w;
-    if ("behaviors" in config) {
-      return config;
+    if ("behaviors" in config2) {
+      return config2;
     }
     const out = {
-      lifetime: config.lifetime,
-      ease: config.ease,
-      particlesPerWave: config.particlesPerWave,
-      frequency: config.frequency,
-      spawnChance: config.spawnChance,
-      emitterLifetime: config.emitterLifetime,
-      maxParticles: config.maxParticles,
-      addAtBack: config.addAtBack,
-      pos: config.pos,
-      emit: config.emit,
-      autoUpdate: config.autoUpdate,
+      lifetime: config2.lifetime,
+      ease: config2.ease,
+      particlesPerWave: config2.particlesPerWave,
+      frequency: config2.frequency,
+      spawnChance: config2.spawnChance,
+      emitterLifetime: config2.emitterLifetime,
+      maxParticles: config2.maxParticles,
+      addAtBack: config2.addAtBack,
+      pos: config2.pos,
+      emit: config2.emit,
+      autoUpdate: config2.autoUpdate,
       behaviors: []
     };
-    if (config.alpha) {
-      if ("start" in config.alpha) {
-        if (config.alpha.start === config.alpha.end) {
-          if (config.alpha.start !== 1) {
+    if (config2.alpha) {
+      if ("start" in config2.alpha) {
+        if (config2.alpha.start === config2.alpha.end) {
+          if (config2.alpha.start !== 1) {
             out.behaviors.push({
               type: "alphaStatic",
-              config: { alpha: config.alpha.start }
+              config: { alpha: config2.alpha.start }
             });
           }
         } else {
           const list = {
             list: [
-              { time: 0, value: config.alpha.start },
-              { time: 1, value: config.alpha.end }
+              { time: 0, value: config2.alpha.start },
+              { time: 1, value: config2.alpha.end }
             ]
           };
           out.behaviors.push({
@@ -31518,124 +31518,124 @@ void main(void)\r
             config: { alpha: list }
           });
         }
-      } else if (config.alpha.list.length === 1) {
-        if (config.alpha.list[0].value !== 1) {
+      } else if (config2.alpha.list.length === 1) {
+        if (config2.alpha.list[0].value !== 1) {
           out.behaviors.push({
             type: "alphaStatic",
-            config: { alpha: config.alpha.list[0].value }
+            config: { alpha: config2.alpha.list[0].value }
           });
         }
       } else {
         out.behaviors.push({
           type: "alpha",
-          config: { alpha: config.alpha }
+          config: { alpha: config2.alpha }
         });
       }
     }
-    if (config.acceleration && (config.acceleration.x || config.acceleration.y)) {
+    if (config2.acceleration && (config2.acceleration.x || config2.acceleration.y)) {
       let minStart;
       let maxStart;
-      if ("start" in config.speed) {
-        minStart = config.speed.start * ((_a = config.speed.minimumSpeedMultiplier) !== null && _a !== void 0 ? _a : 1);
-        maxStart = config.speed.start;
+      if ("start" in config2.speed) {
+        minStart = config2.speed.start * ((_a = config2.speed.minimumSpeedMultiplier) !== null && _a !== void 0 ? _a : 1);
+        maxStart = config2.speed.start;
       } else {
-        minStart = config.speed.list[0].value * ((_b = config.minimumSpeedMultiplier) !== null && _b !== void 0 ? _b : 1);
-        maxStart = config.speed.list[0].value;
+        minStart = config2.speed.list[0].value * ((_b = config2.minimumSpeedMultiplier) !== null && _b !== void 0 ? _b : 1);
+        maxStart = config2.speed.list[0].value;
       }
       out.behaviors.push({
         type: "moveAcceleration",
         config: {
-          accel: config.acceleration,
+          accel: config2.acceleration,
           minStart,
           maxStart,
-          rotate: !config.noRotation,
-          maxSpeed: config.maxSpeed
+          rotate: !config2.noRotation,
+          maxSpeed: config2.maxSpeed
         }
       });
-    } else if ((_c = config.extraData) === null || _c === void 0 ? void 0 : _c.path) {
+    } else if ((_c = config2.extraData) === null || _c === void 0 ? void 0 : _c.path) {
       let list;
       let mult;
-      if ("start" in config.speed) {
-        mult = (_d = config.speed.minimumSpeedMultiplier) !== null && _d !== void 0 ? _d : 1;
-        if (config.speed.start === config.speed.end) {
+      if ("start" in config2.speed) {
+        mult = (_d = config2.speed.minimumSpeedMultiplier) !== null && _d !== void 0 ? _d : 1;
+        if (config2.speed.start === config2.speed.end) {
           list = {
-            list: [{ time: 0, value: config.speed.start }]
+            list: [{ time: 0, value: config2.speed.start }]
           };
         } else {
           list = {
             list: [
-              { time: 0, value: config.speed.start },
-              { time: 1, value: config.speed.end }
+              { time: 0, value: config2.speed.start },
+              { time: 1, value: config2.speed.end }
             ]
           };
         }
       } else {
-        list = config.speed;
-        mult = (_e = config.minimumSpeedMultiplier) !== null && _e !== void 0 ? _e : 1;
+        list = config2.speed;
+        mult = (_e = config2.minimumSpeedMultiplier) !== null && _e !== void 0 ? _e : 1;
       }
       out.behaviors.push({
         type: "movePath",
         config: {
-          path: config.extraData.path,
+          path: config2.extraData.path,
           speed: list,
           minMult: mult
         }
       });
     } else {
-      if (config.speed) {
-        if ("start" in config.speed) {
-          if (config.speed.start === config.speed.end) {
+      if (config2.speed) {
+        if ("start" in config2.speed) {
+          if (config2.speed.start === config2.speed.end) {
             out.behaviors.push({
               type: "moveSpeedStatic",
               config: {
-                min: config.speed.start * ((_f = config.speed.minimumSpeedMultiplier) !== null && _f !== void 0 ? _f : 1),
-                max: config.speed.start
+                min: config2.speed.start * ((_f = config2.speed.minimumSpeedMultiplier) !== null && _f !== void 0 ? _f : 1),
+                max: config2.speed.start
               }
             });
           } else {
             const list = {
               list: [
-                { time: 0, value: config.speed.start },
-                { time: 1, value: config.speed.end }
+                { time: 0, value: config2.speed.start },
+                { time: 1, value: config2.speed.end }
               ]
             };
             out.behaviors.push({
               type: "moveSpeed",
-              config: { speed: list, minMult: config.speed.minimumSpeedMultiplier }
+              config: { speed: list, minMult: config2.speed.minimumSpeedMultiplier }
             });
           }
-        } else if (config.speed.list.length === 1) {
+        } else if (config2.speed.list.length === 1) {
           out.behaviors.push({
             type: "moveSpeedStatic",
             config: {
-              min: config.speed.list[0].value * ((_g = config.minimumSpeedMultiplier) !== null && _g !== void 0 ? _g : 1),
-              max: config.speed.list[0].value
+              min: config2.speed.list[0].value * ((_g = config2.minimumSpeedMultiplier) !== null && _g !== void 0 ? _g : 1),
+              max: config2.speed.list[0].value
             }
           });
         } else {
           out.behaviors.push({
             type: "moveSpeed",
-            config: { speed: config.speed, minMult: (_h = config.minimumSpeedMultiplier) !== null && _h !== void 0 ? _h : 1 }
+            config: { speed: config2.speed, minMult: (_h = config2.minimumSpeedMultiplier) !== null && _h !== void 0 ? _h : 1 }
           });
         }
       }
     }
-    if (config.scale) {
-      if ("start" in config.scale) {
-        const mult = (_j = config.scale.minimumScaleMultiplier) !== null && _j !== void 0 ? _j : 1;
-        if (config.scale.start === config.scale.end) {
+    if (config2.scale) {
+      if ("start" in config2.scale) {
+        const mult = (_j = config2.scale.minimumScaleMultiplier) !== null && _j !== void 0 ? _j : 1;
+        if (config2.scale.start === config2.scale.end) {
           out.behaviors.push({
             type: "scaleStatic",
             config: {
-              min: config.scale.start * mult,
-              max: config.scale.start
+              min: config2.scale.start * mult,
+              max: config2.scale.start
             }
           });
         } else {
           const list = {
             list: [
-              { time: 0, value: config.scale.start },
-              { time: 1, value: config.scale.end }
+              { time: 0, value: config2.scale.start },
+              { time: 1, value: config2.scale.end }
             ]
           };
           out.behaviors.push({
@@ -31643,9 +31643,9 @@ void main(void)\r
             config: { scale: list, minMult: mult }
           });
         }
-      } else if (config.scale.list.length === 1) {
-        const mult = (_k = config.minimumScaleMultiplier) !== null && _k !== void 0 ? _k : 1;
-        const scale = config.scale.list[0].value;
+      } else if (config2.scale.list.length === 1) {
+        const mult = (_k = config2.minimumScaleMultiplier) !== null && _k !== void 0 ? _k : 1;
+        const scale = config2.scale.list[0].value;
         out.behaviors.push({
           type: "scaleStatic",
           config: { min: scale * mult, max: scale }
@@ -31653,24 +31653,24 @@ void main(void)\r
       } else {
         out.behaviors.push({
           type: "scale",
-          config: { scale: config.scale, minMult: (_l = config.minimumScaleMultiplier) !== null && _l !== void 0 ? _l : 1 }
+          config: { scale: config2.scale, minMult: (_l = config2.minimumScaleMultiplier) !== null && _l !== void 0 ? _l : 1 }
         });
       }
     }
-    if (config.color) {
-      if ("start" in config.color) {
-        if (config.color.start === config.color.end) {
-          if (config.color.start !== "ffffff") {
+    if (config2.color) {
+      if ("start" in config2.color) {
+        if (config2.color.start === config2.color.end) {
+          if (config2.color.start !== "ffffff") {
             out.behaviors.push({
               type: "colorStatic",
-              config: { color: config.color.start }
+              config: { color: config2.color.start }
             });
           }
         } else {
           const list = {
             list: [
-              { time: 0, value: config.color.start },
-              { time: 1, value: config.color.end }
+              { time: 0, value: config2.color.start },
+              { time: 1, value: config2.color.end }
             ]
           };
           out.behaviors.push({
@@ -31678,51 +31678,51 @@ void main(void)\r
             config: { color: list }
           });
         }
-      } else if (config.color.list.length === 1) {
-        if (config.color.list[0].value !== "ffffff") {
+      } else if (config2.color.list.length === 1) {
+        if (config2.color.list[0].value !== "ffffff") {
           out.behaviors.push({
             type: "colorStatic",
-            config: { color: config.color.list[0].value }
+            config: { color: config2.color.list[0].value }
           });
         }
       } else {
         out.behaviors.push({
           type: "color",
-          config: { color: config.color }
+          config: { color: config2.color }
         });
       }
     }
-    if (config.rotationAcceleration || ((_m = config.rotationSpeed) === null || _m === void 0 ? void 0 : _m.min) || ((_o = config.rotationSpeed) === null || _o === void 0 ? void 0 : _o.max)) {
+    if (config2.rotationAcceleration || ((_m = config2.rotationSpeed) === null || _m === void 0 ? void 0 : _m.min) || ((_o = config2.rotationSpeed) === null || _o === void 0 ? void 0 : _o.max)) {
       out.behaviors.push({
         type: "rotation",
         config: {
-          accel: config.rotationAcceleration || 0,
-          minSpeed: ((_p = config.rotationSpeed) === null || _p === void 0 ? void 0 : _p.min) || 0,
-          maxSpeed: ((_q = config.rotationSpeed) === null || _q === void 0 ? void 0 : _q.max) || 0,
-          minStart: ((_r = config.startRotation) === null || _r === void 0 ? void 0 : _r.min) || 0,
-          maxStart: ((_s = config.startRotation) === null || _s === void 0 ? void 0 : _s.max) || 0
+          accel: config2.rotationAcceleration || 0,
+          minSpeed: ((_p = config2.rotationSpeed) === null || _p === void 0 ? void 0 : _p.min) || 0,
+          maxSpeed: ((_q = config2.rotationSpeed) === null || _q === void 0 ? void 0 : _q.max) || 0,
+          minStart: ((_r = config2.startRotation) === null || _r === void 0 ? void 0 : _r.min) || 0,
+          maxStart: ((_s = config2.startRotation) === null || _s === void 0 ? void 0 : _s.max) || 0
         }
       });
-    } else if (((_t = config.startRotation) === null || _t === void 0 ? void 0 : _t.min) || ((_u = config.startRotation) === null || _u === void 0 ? void 0 : _u.max)) {
+    } else if (((_t = config2.startRotation) === null || _t === void 0 ? void 0 : _t.min) || ((_u = config2.startRotation) === null || _u === void 0 ? void 0 : _u.max)) {
       out.behaviors.push({
         type: "rotationStatic",
         config: {
-          min: ((_v = config.startRotation) === null || _v === void 0 ? void 0 : _v.min) || 0,
-          max: ((_w = config.startRotation) === null || _w === void 0 ? void 0 : _w.max) || 0
+          min: ((_v = config2.startRotation) === null || _v === void 0 ? void 0 : _v.min) || 0,
+          max: ((_w = config2.startRotation) === null || _w === void 0 ? void 0 : _w.max) || 0
         }
       });
     }
-    if (config.noRotation) {
+    if (config2.noRotation) {
       out.behaviors.push({
         type: "noRotation",
         config: {}
       });
     }
-    if (config.blendMode && config.blendMode !== "normal") {
+    if (config2.blendMode && config2.blendMode !== "normal") {
       out.behaviors.push({
         type: "blendMode",
         config: {
-          blendMode: config.blendMode
+          blendMode: config2.blendMode
         }
       });
     }
@@ -31748,7 +31748,7 @@ void main(void)\r
           anim: art
         }
       });
-    } else if (config.orderedArt && Array.isArray(art)) {
+    } else if (config2.orderedArt && Array.isArray(art)) {
       out.behaviors.push({
         type: "textureOrdered",
         config: {
@@ -31770,54 +31770,54 @@ void main(void)\r
         }
       });
     }
-    if (config.spawnType === "burst") {
+    if (config2.spawnType === "burst") {
       out.behaviors.push({
         type: "spawnBurst",
         config: {
-          start: config.angleStart || 0,
-          spacing: config.particleSpacing,
+          start: config2.angleStart || 0,
+          spacing: config2.particleSpacing,
           // older formats bursted from a single point
           distance: 0
         }
       });
-    } else if (config.spawnType === "point") {
+    } else if (config2.spawnType === "point") {
       out.behaviors.push({
         type: "spawnPoint",
         config: {}
       });
     } else {
       let shape;
-      if (config.spawnType === "ring") {
+      if (config2.spawnType === "ring") {
         shape = {
           type: "torus",
           data: {
-            x: config.spawnCircle.x,
-            y: config.spawnCircle.y,
-            radius: config.spawnCircle.r,
-            innerRadius: config.spawnCircle.minR,
+            x: config2.spawnCircle.x,
+            y: config2.spawnCircle.y,
+            radius: config2.spawnCircle.r,
+            innerRadius: config2.spawnCircle.minR,
             affectRotation: true
           }
         };
-      } else if (config.spawnType === "circle") {
+      } else if (config2.spawnType === "circle") {
         shape = {
           type: "torus",
           data: {
-            x: config.spawnCircle.x,
-            y: config.spawnCircle.y,
-            radius: config.spawnCircle.r,
+            x: config2.spawnCircle.x,
+            y: config2.spawnCircle.y,
+            radius: config2.spawnCircle.r,
             innerRadius: 0,
             affectRotation: false
           }
         };
-      } else if (config.spawnType === "rect") {
+      } else if (config2.spawnType === "rect") {
         shape = {
           type: "rect",
-          data: config.spawnRect
+          data: config2.spawnRect
         };
-      } else if (config.spawnType === "polygonalChain") {
+      } else if (config2.spawnType === "polygonalChain") {
         shape = {
           type: "polygonalChain",
-          data: config.spawnPolygon
+          data: config2.spawnPolygon
         };
       }
       if (shape) {
@@ -31908,7 +31908,7 @@ void main(void)\r
         particleConfig,
         onDestroy
       } = params;
-      const config = upgradeConfig(
+      const config2 = upgradeConfig(
         {
           lifetime: particleConfig.lifetime,
           blendMode: particleConfig.blendMode,
@@ -31933,7 +31933,7 @@ void main(void)\r
         this._particleContainer = new Container();
       }
       this.addChild(this._particleContainer);
-      const flyParticle = new Emitter(this._particleContainer, config);
+      const flyParticle = new Emitter(this._particleContainer, config2);
       const path2 = this._createBezierPoints(
         [start, ...control, end],
         100,
@@ -33737,10 +33737,10 @@ void main(void)\r
     }
     computeWorldRotation(bone) {
       const mat = bone.matrix;
-      const cos = MathUtils.cosDeg(this.rotation);
-      const sin = MathUtils.sinDeg(this.rotation);
-      const x2 = cos * mat.a + sin * mat.c;
-      const y2 = cos * mat.b + sin * mat.d;
+      const cos2 = MathUtils.cosDeg(this.rotation);
+      const sin2 = MathUtils.sinDeg(this.rotation);
+      const x2 = cos2 * mat.a + sin2 * mat.c;
+      const y2 = cos2 * mat.b + sin2 * mat.d;
       return Math.atan2(y2, x2) * MathUtils.radDeg;
     }
     copy() {
@@ -33822,16 +33822,16 @@ void main(void)\r
       const localX2 = localX + this.region.width * regionScaleX;
       const localY2 = localY + this.region.height * regionScaleY;
       const radians = this.rotation * Math.PI / 180;
-      const cos = Math.cos(radians);
-      const sin = Math.sin(radians);
-      const localXCos = localX * cos + this.x;
-      const localXSin = localX * sin;
-      const localYCos = localY * cos + this.y;
-      const localYSin = localY * sin;
-      const localX2Cos = localX2 * cos + this.x;
-      const localX2Sin = localX2 * sin;
-      const localY2Cos = localY2 * cos + this.y;
-      const localY2Sin = localY2 * sin;
+      const cos2 = Math.cos(radians);
+      const sin2 = Math.sin(radians);
+      const localXCos = localX * cos2 + this.x;
+      const localXSin = localX * sin2;
+      const localYCos = localY * cos2 + this.y;
+      const localYSin = localY * sin2;
+      const localX2Cos = localX2 * cos2 + this.x;
+      const localX2Sin = localX2 * sin2;
+      const localY2Cos = localY2 * cos2 + this.y;
+      const localY2Sin = localY2 * sin2;
       const offset = this.offset;
       offset[_RegionAttachment$2.OX1] = localXCos - localYSin;
       offset[_RegionAttachment$2.OY1] = localYCos + localXSin;
@@ -36387,10 +36387,10 @@ void main(void)\r
         }
         case TransformMode.NoScale:
         case TransformMode.NoScaleOrReflection: {
-          const cos = MathUtils.cosDeg(rotation);
-          const sin = MathUtils.sinDeg(rotation);
-          let za = (pa * cos + pb * sin) / sx;
-          let zc = (pc * cos + pd * sin) / sy;
+          const cos2 = MathUtils.cosDeg(rotation);
+          const sin2 = MathUtils.sinDeg(rotation);
+          let za = (pa * cos2 + pb * sin2) / sx;
+          let zc = (pc * cos2 + pd * sin2) / sy;
           let s2 = Math.sqrt(za * za + zc * zc);
           if (s2 > 1e-5)
             s2 = 1 / s2;
@@ -36510,16 +36510,16 @@ void main(void)\r
       return local;
     }
     worldToLocalRotation(worldRotation) {
-      const sin = MathUtils.sinDeg(worldRotation);
-      const cos = MathUtils.cosDeg(worldRotation);
+      const sin2 = MathUtils.sinDeg(worldRotation);
+      const cos2 = MathUtils.cosDeg(worldRotation);
       const mat = this.matrix;
-      return Math.atan2(mat.a * sin - mat.b * cos, mat.d * cos - mat.c * sin) * MathUtils.radDeg;
+      return Math.atan2(mat.a * sin2 - mat.b * cos2, mat.d * cos2 - mat.c * sin2) * MathUtils.radDeg;
     }
     localToWorldRotation(localRotation) {
-      const sin = MathUtils.sinDeg(localRotation);
-      const cos = MathUtils.cosDeg(localRotation);
+      const sin2 = MathUtils.sinDeg(localRotation);
+      const cos2 = MathUtils.cosDeg(localRotation);
       const mat = this.matrix;
-      return Math.atan2(cos * mat.b + sin * mat.d, cos * mat.a + sin * mat.c) * MathUtils.radDeg;
+      return Math.atan2(cos2 * mat.b + sin2 * mat.d, cos2 * mat.a + sin2 * mat.c) * MathUtils.radDeg;
     }
     rotateWorld(degrees) {
       const mat = this.matrix;
@@ -36527,12 +36527,12 @@ void main(void)\r
       const b2 = mat.c;
       const c2 = mat.b;
       const d2 = mat.d;
-      const cos = MathUtils.cosDeg(degrees);
-      const sin = MathUtils.sinDeg(degrees);
-      mat.a = cos * a2 - sin * c2;
-      mat.c = cos * b2 - sin * d2;
-      mat.b = sin * a2 + cos * c2;
-      mat.d = sin * b2 + cos * d2;
+      const cos2 = MathUtils.cosDeg(degrees);
+      const sin2 = MathUtils.sinDeg(degrees);
+      mat.a = cos2 * a2 - sin2 * c2;
+      mat.c = cos2 * b2 - sin2 * d2;
+      mat.b = sin2 * a2 + cos2 * c2;
+      mat.d = sin2 * b2 + cos2 * d2;
       this.appliedValid = false;
     }
   }
@@ -36773,16 +36773,16 @@ void main(void)\r
       outer:
         if (u2) {
           l2 *= psx;
-          let cos = (dd - l1 * l1 - l2 * l2) / (2 * l1 * l2);
-          if (cos < -1)
-            cos = -1;
-          else if (cos > 1) {
-            cos = 1;
+          let cos2 = (dd - l1 * l1 - l2 * l2) / (2 * l1 * l2);
+          if (cos2 < -1)
+            cos2 = -1;
+          else if (cos2 > 1) {
+            cos2 = 1;
             if (stretch)
               sx *= (Math.sqrt(dd) / (l1 + l2) - 1) * alpha + 1;
           }
-          a22 = Math.acos(cos) * bendDir;
-          a2 = l1 + l2 * cos;
+          a22 = Math.acos(cos2) * bendDir;
+          a2 = l1 + l2 * cos2;
           b2 = l2 * Math.sin(a22);
           a1 = Math.atan2(ty * a2 - tx * b2, tx * a2 + ty * b2);
         } else {
@@ -37007,8 +37007,8 @@ void main(void)\r
           const c2 = mat.b;
           const d2 = mat.d;
           let r2 = 0;
-          let cos = 0;
-          let sin = 0;
+          let cos2 = 0;
+          let sin2 = 0;
           if (tangents)
             if (tangents)
               r2 = positions[p2 - 1];
@@ -37018,11 +37018,11 @@ void main(void)\r
               r2 = Math.atan2(dy, dx);
           r2 -= Math.atan2(c2, a2);
           if (tip) {
-            cos = Math.cos(r2);
-            sin = Math.sin(r2);
+            cos2 = Math.cos(r2);
+            sin2 = Math.sin(r2);
             const length2 = bone.data.length;
-            boneX += (length2 * (cos * a2 - sin * c2) - dx) * rotateMix;
-            boneY += (length2 * (sin * a2 + cos * c2) - dy) * rotateMix;
+            boneX += (length2 * (cos2 * a2 - sin2 * c2) - dx) * rotateMix;
+            boneY += (length2 * (sin2 * a2 + cos2 * c2) - dy) * rotateMix;
           } else {
             r2 += offsetRotation;
           }
@@ -37031,12 +37031,12 @@ void main(void)\r
           else if (r2 < -MathUtils.PI)
             r2 += MathUtils.PI2;
           r2 *= rotateMix;
-          cos = Math.cos(r2);
-          sin = Math.sin(r2);
-          mat.a = cos * a2 - sin * c2;
-          mat.c = cos * b2 - sin * d2;
-          mat.b = sin * a2 + cos * c2;
-          mat.d = sin * b2 + cos * d2;
+          cos2 = Math.cos(r2);
+          sin2 = Math.sin(r2);
+          mat.a = cos2 * a2 - sin2 * c2;
+          mat.c = cos2 * b2 - sin2 * d2;
+          mat.b = sin2 * a2 + cos2 * c2;
+          mat.d = sin2 * b2 + cos2 * d2;
         }
         bone.appliedValid = false;
       }
@@ -37378,12 +37378,12 @@ void main(void)\r
           else if (r2 < -MathUtils.PI)
             r2 += MathUtils.PI2;
           r2 *= rotateMix;
-          const cos = Math.cos(r2);
-          const sin = Math.sin(r2);
-          mat.a = cos * a2 - sin * c2;
-          mat.c = cos * b2 - sin * d2;
-          mat.b = sin * a2 + cos * c2;
-          mat.d = sin * b2 + cos * d2;
+          const cos2 = Math.cos(r2);
+          const sin2 = Math.sin(r2);
+          mat.a = cos2 * a2 - sin2 * c2;
+          mat.c = cos2 * b2 - sin2 * d2;
+          mat.b = sin2 * a2 + cos2 * c2;
+          mat.d = sin2 * b2 + cos2 * d2;
           modified = true;
         }
         if (translateMix != 0) {
@@ -37457,12 +37457,12 @@ void main(void)\r
           else if (r2 < -MathUtils.PI)
             r2 += MathUtils.PI2;
           r2 *= rotateMix;
-          const cos = Math.cos(r2);
-          const sin = Math.sin(r2);
-          mat.a = cos * a2 - sin * c2;
-          mat.c = cos * b2 - sin * d2;
-          mat.b = sin * a2 + cos * c2;
-          mat.d = sin * b2 + cos * d2;
+          const cos2 = Math.cos(r2);
+          const sin2 = Math.sin(r2);
+          mat.a = cos2 * a2 - sin2 * c2;
+          mat.c = cos2 * b2 - sin2 * d2;
+          mat.b = sin2 * a2 + cos2 * c2;
+          mat.d = sin2 * b2 + cos2 * d2;
           modified = true;
         }
         if (translateMix != 0) {
@@ -40265,10 +40265,10 @@ void main(void)\r
     }
     computeWorldRotation(bone) {
       const mat = bone.matrix;
-      const cos = MathUtils.cosDeg(this.rotation);
-      const sin = MathUtils.sinDeg(this.rotation);
-      const x2 = cos * mat.a + sin * mat.c;
-      const y2 = cos * mat.b + sin * mat.d;
+      const cos2 = MathUtils.cosDeg(this.rotation);
+      const sin2 = MathUtils.sinDeg(this.rotation);
+      const x2 = cos2 * mat.a + sin2 * mat.c;
+      const y2 = cos2 * mat.b + sin2 * mat.d;
       return Math.atan2(y2, x2) * MathUtils.radDeg;
     }
   };
@@ -40342,16 +40342,16 @@ void main(void)\r
       const localX2 = localX + this.region.width * regionScaleX;
       const localY2 = localY + this.region.height * regionScaleY;
       const radians = this.rotation * Math.PI / 180;
-      const cos = Math.cos(radians);
-      const sin = Math.sin(radians);
-      const localXCos = localX * cos + this.x;
-      const localXSin = localX * sin;
-      const localYCos = localY * cos + this.y;
-      const localYSin = localY * sin;
-      const localX2Cos = localX2 * cos + this.x;
-      const localX2Sin = localX2 * sin;
-      const localY2Cos = localY2 * cos + this.y;
-      const localY2Sin = localY2 * sin;
+      const cos2 = Math.cos(radians);
+      const sin2 = Math.sin(radians);
+      const localXCos = localX * cos2 + this.x;
+      const localXSin = localX * sin2;
+      const localYCos = localY * cos2 + this.y;
+      const localYSin = localY * sin2;
+      const localX2Cos = localX2 * cos2 + this.x;
+      const localX2Sin = localX2 * sin2;
+      const localY2Cos = localY2 * cos2 + this.y;
+      const localY2Sin = localY2 * sin2;
       const offset = this.offset;
       offset[_RegionAttachment$1.OX1] = localXCos - localYSin;
       offset[_RegionAttachment$1.OY1] = localYCos + localXSin;
@@ -42983,10 +42983,10 @@ void main(void)\r
     }
     computeWorldRotation(bone) {
       const mat = bone.matrix;
-      const cos = MathUtils.cosDeg(this.rotation);
-      const sin = MathUtils.sinDeg(this.rotation);
-      const x2 = cos * mat.a + sin * mat.c;
-      const y2 = cos * mat.b + sin * mat.d;
+      const cos2 = MathUtils.cosDeg(this.rotation);
+      const sin2 = MathUtils.sinDeg(this.rotation);
+      const x2 = cos2 * mat.a + sin2 * mat.c;
+      const y2 = cos2 * mat.b + sin2 * mat.d;
       return Math.atan2(y2, x2) * MathUtils.radDeg;
     }
     copy() {
@@ -43030,18 +43030,18 @@ void main(void)\r
       const localX2 = localX + this.region.width * regionScaleX;
       const localY2 = localY + this.region.height * regionScaleY;
       const radians = this.rotation * Math.PI / 180;
-      const cos = Math.cos(radians);
-      const sin = Math.sin(radians);
+      const cos2 = Math.cos(radians);
+      const sin2 = Math.sin(radians);
       const x2 = this.x;
       const y2 = this.y;
-      const localXCos = localX * cos + x2;
-      const localXSin = localX * sin;
-      const localYCos = localY * cos + y2;
-      const localYSin = localY * sin;
-      const localX2Cos = localX2 * cos + x2;
-      const localX2Sin = localX2 * sin;
-      const localY2Cos = localY2 * cos + y2;
-      const localY2Sin = localY2 * sin;
+      const localXCos = localX * cos2 + x2;
+      const localXSin = localX * sin2;
+      const localYCos = localY * cos2 + y2;
+      const localYSin = localY * sin2;
+      const localX2Cos = localX2 * cos2 + x2;
+      const localX2Sin = localX2 * sin2;
+      const localY2Cos = localY2 * cos2 + y2;
+      const localY2Sin = localY2 * sin2;
       const offset = this.offset;
       offset[0] = localXCos - localYSin;
       offset[1] = localYCos + localXSin;
@@ -54706,7 +54706,7 @@ void main(void){
     sample *= alpha;
     gl_FragColor = sample;
-}`, P = Object.defineProperty, c = Object.getOwnPropertySymbols, T = Object.prototype.hasOwnProperty, z = Object.prototype.propertyIsEnumerable, _ = (t2, e2, i2) => e2 in t2 ? P(t2, e2, { enumerable: true, configurable: true, writable: true, value: i2 }) : t2[e2] = i2, b = (t2, e2) => {
+}`, P$1 = Object.defineProperty, c = Object.getOwnPropertySymbols, T = Object.prototype.hasOwnProperty, z = Object.prototype.propertyIsEnumerable, _ = (t2, e2, i2) => e2 in t2 ? P$1(t2, e2, { enumerable: true, configurable: true, writable: true, value: i2 }) : t2[e2] = i2, b = (t2, e2) => {
     for (var i2 in e2 || (e2 = {}))
       T.call(e2, i2) && _(t2, i2, e2[i2]);
     if (c)
@@ -54796,14 +54796,14 @@ void main(void){
   };
   let F = o;
   F.defaults = { offset: { x: 4, y: 4 }, color: 0, alpha: 0.5, shadowOnly: false, kernels: null, blur: 2, quality: 3, pixelSize: 1, resolution: settings$1.FILTER_RESOLUTION };
-  const libPixiShadow = (container, config) => {
+  const libPixiShadow = (container, config2) => {
     const {
       color = "#000",
       alpha = 0.25,
       blur = 1,
       distance = 0,
       offset = { x: 0, y: 0 }
-    } = config || {};
+    } = config2 || {};
     const shadowFilter = new F({
       color,
       alpha,
@@ -55419,6 +55419,2381 @@ void main(void){
       this._maxWidth && libPixiScaleContainer(this, this._maxWidth);
     }
   }
+  /*!
+   *  decimal.js v10.4.3
+   *  An arbitrary-precision Decimal type for JavaScript.
+   *  https://github.com/MikeMcl/decimal.js
+   *  Copyright (c) 2022 Michael Mclaughlin <M8ch88l@gmail.com>
+   *  MIT Licence
+   */
+  var EXP_LIMIT = 9e15, MAX_DIGITS = 1e9, NUMERALS = "0123456789abcdef", LN10 = "2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058", PI = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789", DEFAULTS = {
+    // These values must be integers within the stated ranges (inclusive).
+    // Most of these values can be changed at run-time using the `Decimal.config` method.
+    // The maximum number of significant digits of the result of a calculation or base conversion.
+    // E.g. `Decimal.config({ precision: 20 });`
+    precision: 20,
+    // 1 to MAX_DIGITS
+    // The rounding mode used when rounding to `precision`.
+    //
+    // ROUND_UP         0 Away from zero.
+    // ROUND_DOWN       1 Towards zero.
+    // ROUND_CEIL       2 Towards +Infinity.
+    // ROUND_FLOOR      3 Towards -Infinity.
+    // ROUND_HALF_UP    4 Towards nearest neighbour. If equidistant, up.
+    // ROUND_HALF_DOWN  5 Towards nearest neighbour. If equidistant, down.
+    // ROUND_HALF_EVEN  6 Towards nearest neighbour. If equidistant, towards even neighbour.
+    // ROUND_HALF_CEIL  7 Towards nearest neighbour. If equidistant, towards +Infinity.
+    // ROUND_HALF_FLOOR 8 Towards nearest neighbour. If equidistant, towards -Infinity.
+    //
+    // E.g.
+    // `Decimal.rounding = 4;`
+    // `Decimal.rounding = Decimal.ROUND_HALF_UP;`
+    rounding: 4,
+    // 0 to 8
+    // The modulo mode used when calculating the modulus: a mod n.
+    // The quotient (q = a / n) is calculated according to the corresponding rounding mode.
+    // The remainder (r) is calculated as: r = a - n * q.
+    //
+    // UP         0 The remainder is positive if the dividend is negative, else is negative.
+    // DOWN       1 The remainder has the same sign as the dividend (JavaScript %).
+    // FLOOR      3 The remainder has the same sign as the divisor (Python %).
+    // HALF_EVEN  6 The IEEE 754 remainder function.
+    // EUCLID     9 Euclidian division. q = sign(n) * floor(a / abs(n)). Always positive.
+    //
+    // Truncated division (1), floored division (3), the IEEE 754 remainder (6), and Euclidian
+    // division (9) are commonly used for the modulus operation. The other rounding modes can also
+    // be used, but they may not give useful results.
+    modulo: 1,
+    // 0 to 9
+    // The exponent value at and beneath which `toString` returns exponential notation.
+    // JavaScript numbers: -7
+    toExpNeg: -7,
+    // 0 to -EXP_LIMIT
+    // The exponent value at and above which `toString` returns exponential notation.
+    // JavaScript numbers: 21
+    toExpPos: 21,
+    // 0 to EXP_LIMIT
+    // The minimum exponent value, beneath which underflow to zero occurs.
+    // JavaScript numbers: -324  (5e-324)
+    minE: -EXP_LIMIT,
+    // -1 to -EXP_LIMIT
+    // The maximum exponent value, above which overflow to Infinity occurs.
+    // JavaScript numbers: 308  (1.7976931348623157e+308)
+    maxE: EXP_LIMIT,
+    // 1 to EXP_LIMIT
+    // Whether to use cryptographically-secure random number generation, if available.
+    crypto: false
+    // true/false
+  }, inexact, quadrant, external = true, decimalError = "[DecimalError] ", invalidArgument = decimalError + "Invalid argument: ", precisionLimitExceeded = decimalError + "Precision limit exceeded", cryptoUnavailable = decimalError + "crypto unavailable", tag = "[object Decimal]", mathfloor = Math.floor, mathpow = Math.pow, isBinary = /^0b([01]+(\.[01]*)?|\.[01]+)(p[+-]?\d+)?$/i, isHex = /^0x([0-9a-f]+(\.[0-9a-f]*)?|\.[0-9a-f]+)(p[+-]?\d+)?$/i, isOctal = /^0o([0-7]+(\.[0-7]*)?|\.[0-7]+)(p[+-]?\d+)?$/i, isDecimal = /^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i, BASE = 1e7, LOG_BASE = 7, MAX_SAFE_INTEGER = 9007199254740991, LN10_PRECISION = LN10.length - 1, PI_PRECISION = PI.length - 1, P = { toStringTag: tag };
+  P.absoluteValue = P.abs = function() {
+    var x2 = new this.constructor(this);
+    if (x2.s < 0)
+      x2.s = 1;
+    return finalise(x2);
+  };
+  P.ceil = function() {
+    return finalise(new this.constructor(this), this.e + 1, 2);
+  };
+  P.clampedTo = P.clamp = function(min2, max2) {
+    var k2, x2 = this, Ctor = x2.constructor;
+    min2 = new Ctor(min2);
+    max2 = new Ctor(max2);
+    if (!min2.s || !max2.s)
+      return new Ctor(NaN);
+    if (min2.gt(max2))
+      throw Error(invalidArgument + max2);
+    k2 = x2.cmp(min2);
+    return k2 < 0 ? min2 : x2.cmp(max2) > 0 ? max2 : new Ctor(x2);
+  };
+  P.comparedTo = P.cmp = function(y2) {
+    var i2, j2, xdL, ydL, x2 = this, xd = x2.d, yd = (y2 = new x2.constructor(y2)).d, xs = x2.s, ys = y2.s;
+    if (!xd || !yd) {
+      return !xs || !ys ? NaN : xs !== ys ? xs : xd === yd ? 0 : !xd ^ xs < 0 ? 1 : -1;
+    }
+    if (!xd[0] || !yd[0])
+      return xd[0] ? xs : yd[0] ? -ys : 0;
+    if (xs !== ys)
+      return xs;
+    if (x2.e !== y2.e)
+      return x2.e > y2.e ^ xs < 0 ? 1 : -1;
+    xdL = xd.length;
+    ydL = yd.length;
+    for (i2 = 0, j2 = xdL < ydL ? xdL : ydL; i2 < j2; ++i2) {
+      if (xd[i2] !== yd[i2])
+        return xd[i2] > yd[i2] ^ xs < 0 ? 1 : -1;
+    }
+    return xdL === ydL ? 0 : xdL > ydL ^ xs < 0 ? 1 : -1;
+  };
+  P.cosine = P.cos = function() {
+    var pr, rm, x2 = this, Ctor = x2.constructor;
+    if (!x2.d)
+      return new Ctor(NaN);
+    if (!x2.d[0])
+      return new Ctor(1);
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    Ctor.precision = pr + Math.max(x2.e, x2.sd()) + LOG_BASE;
+    Ctor.rounding = 1;
+    x2 = cosine(Ctor, toLessThanHalfPi(Ctor, x2));
+    Ctor.precision = pr;
+    Ctor.rounding = rm;
+    return finalise(quadrant == 2 || quadrant == 3 ? x2.neg() : x2, pr, rm, true);
+  };
+  P.cubeRoot = P.cbrt = function() {
+    var e2, m2, n2, r2, rep, s2, sd, t2, t3, t3plusx, x2 = this, Ctor = x2.constructor;
+    if (!x2.isFinite() || x2.isZero())
+      return new Ctor(x2);
+    external = false;
+    s2 = x2.s * mathpow(x2.s * x2, 1 / 3);
+    if (!s2 || Math.abs(s2) == 1 / 0) {
+      n2 = digitsToString(x2.d);
+      e2 = x2.e;
+      if (s2 = (e2 - n2.length + 1) % 3)
+        n2 += s2 == 1 || s2 == -2 ? "0" : "00";
+      s2 = mathpow(n2, 1 / 3);
+      e2 = mathfloor((e2 + 1) / 3) - (e2 % 3 == (e2 < 0 ? -1 : 2));
+      if (s2 == 1 / 0) {
+        n2 = "5e" + e2;
+      } else {
+        n2 = s2.toExponential();
+        n2 = n2.slice(0, n2.indexOf("e") + 1) + e2;
+      }
+      r2 = new Ctor(n2);
+      r2.s = x2.s;
+    } else {
+      r2 = new Ctor(s2.toString());
+    }
+    sd = (e2 = Ctor.precision) + 3;
+    for (; ; ) {
+      t2 = r2;
+      t3 = t2.times(t2).times(t2);
+      t3plusx = t3.plus(x2);
+      r2 = divide(t3plusx.plus(x2).times(t2), t3plusx.plus(t3), sd + 2, 1);
+      if (digitsToString(t2.d).slice(0, sd) === (n2 = digitsToString(r2.d)).slice(0, sd)) {
+        n2 = n2.slice(sd - 3, sd + 1);
+        if (n2 == "9999" || !rep && n2 == "4999") {
+          if (!rep) {
+            finalise(t2, e2 + 1, 0);
+            if (t2.times(t2).times(t2).eq(x2)) {
+              r2 = t2;
+              break;
+            }
+          }
+          sd += 4;
+          rep = 1;
+        } else {
+          if (!+n2 || !+n2.slice(1) && n2.charAt(0) == "5") {
+            finalise(r2, e2 + 1, 1);
+            m2 = !r2.times(r2).times(r2).eq(x2);
+          }
+          break;
+        }
+      }
+    }
+    external = true;
+    return finalise(r2, e2, Ctor.rounding, m2);
+  };
+  P.decimalPlaces = P.dp = function() {
+    var w2, d2 = this.d, n2 = NaN;
+    if (d2) {
+      w2 = d2.length - 1;
+      n2 = (w2 - mathfloor(this.e / LOG_BASE)) * LOG_BASE;
+      w2 = d2[w2];
+      if (w2)
+        for (; w2 % 10 == 0; w2 /= 10)
+          n2--;
+      if (n2 < 0)
+        n2 = 0;
+    }
+    return n2;
+  };
+  P.dividedBy = P.div = function(y2) {
+    return divide(this, new this.constructor(y2));
+  };
+  P.dividedToIntegerBy = P.divToInt = function(y2) {
+    var x2 = this, Ctor = x2.constructor;
+    return finalise(divide(x2, new Ctor(y2), 0, 1, 1), Ctor.precision, Ctor.rounding);
+  };
+  P.equals = P.eq = function(y2) {
+    return this.cmp(y2) === 0;
+  };
+  P.floor = function() {
+    return finalise(new this.constructor(this), this.e + 1, 3);
+  };
+  P.greaterThan = P.gt = function(y2) {
+    return this.cmp(y2) > 0;
+  };
+  P.greaterThanOrEqualTo = P.gte = function(y2) {
+    var k2 = this.cmp(y2);
+    return k2 == 1 || k2 === 0;
+  };
+  P.hyperbolicCosine = P.cosh = function() {
+    var k2, n2, pr, rm, len, x2 = this, Ctor = x2.constructor, one = new Ctor(1);
+    if (!x2.isFinite())
+      return new Ctor(x2.s ? 1 / 0 : NaN);
+    if (x2.isZero())
+      return one;
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    Ctor.precision = pr + Math.max(x2.e, x2.sd()) + 4;
+    Ctor.rounding = 1;
+    len = x2.d.length;
+    if (len < 32) {
+      k2 = Math.ceil(len / 3);
+      n2 = (1 / tinyPow(4, k2)).toString();
+    } else {
+      k2 = 16;
+      n2 = "2.3283064365386962890625e-10";
+    }
+    x2 = taylorSeries(Ctor, 1, x2.times(n2), new Ctor(1), true);
+    var cosh2_x, i2 = k2, d8 = new Ctor(8);
+    for (; i2--; ) {
+      cosh2_x = x2.times(x2);
+      x2 = one.minus(cosh2_x.times(d8.minus(cosh2_x.times(d8))));
+    }
+    return finalise(x2, Ctor.precision = pr, Ctor.rounding = rm, true);
+  };
+  P.hyperbolicSine = P.sinh = function() {
+    var k2, pr, rm, len, x2 = this, Ctor = x2.constructor;
+    if (!x2.isFinite() || x2.isZero())
+      return new Ctor(x2);
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    Ctor.precision = pr + Math.max(x2.e, x2.sd()) + 4;
+    Ctor.rounding = 1;
+    len = x2.d.length;
+    if (len < 3) {
+      x2 = taylorSeries(Ctor, 2, x2, x2, true);
+    } else {
+      k2 = 1.4 * Math.sqrt(len);
+      k2 = k2 > 16 ? 16 : k2 | 0;
+      x2 = x2.times(1 / tinyPow(5, k2));
+      x2 = taylorSeries(Ctor, 2, x2, x2, true);
+      var sinh2_x, d5 = new Ctor(5), d16 = new Ctor(16), d20 = new Ctor(20);
+      for (; k2--; ) {
+        sinh2_x = x2.times(x2);
+        x2 = x2.times(d5.plus(sinh2_x.times(d16.times(sinh2_x).plus(d20))));
+      }
+    }
+    Ctor.precision = pr;
+    Ctor.rounding = rm;
+    return finalise(x2, pr, rm, true);
+  };
+  P.hyperbolicTangent = P.tanh = function() {
+    var pr, rm, x2 = this, Ctor = x2.constructor;
+    if (!x2.isFinite())
+      return new Ctor(x2.s);
+    if (x2.isZero())
+      return new Ctor(x2);
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    Ctor.precision = pr + 7;
+    Ctor.rounding = 1;
+    return divide(x2.sinh(), x2.cosh(), Ctor.precision = pr, Ctor.rounding = rm);
+  };
+  P.inverseCosine = P.acos = function() {
+    var halfPi, x2 = this, Ctor = x2.constructor, k2 = x2.abs().cmp(1), pr = Ctor.precision, rm = Ctor.rounding;
+    if (k2 !== -1) {
+      return k2 === 0 ? x2.isNeg() ? getPi(Ctor, pr, rm) : new Ctor(0) : new Ctor(NaN);
+    }
+    if (x2.isZero())
+      return getPi(Ctor, pr + 4, rm).times(0.5);
+    Ctor.precision = pr + 6;
+    Ctor.rounding = 1;
+    x2 = x2.asin();
+    halfPi = getPi(Ctor, pr + 4, rm).times(0.5);
+    Ctor.precision = pr;
+    Ctor.rounding = rm;
+    return halfPi.minus(x2);
+  };
+  P.inverseHyperbolicCosine = P.acosh = function() {
+    var pr, rm, x2 = this, Ctor = x2.constructor;
+    if (x2.lte(1))
+      return new Ctor(x2.eq(1) ? 0 : NaN);
+    if (!x2.isFinite())
+      return new Ctor(x2);
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    Ctor.precision = pr + Math.max(Math.abs(x2.e), x2.sd()) + 4;
+    Ctor.rounding = 1;
+    external = false;
+    x2 = x2.times(x2).minus(1).sqrt().plus(x2);
+    external = true;
+    Ctor.precision = pr;
+    Ctor.rounding = rm;
+    return x2.ln();
+  };
+  P.inverseHyperbolicSine = P.asinh = function() {
+    var pr, rm, x2 = this, Ctor = x2.constructor;
+    if (!x2.isFinite() || x2.isZero())
+      return new Ctor(x2);
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    Ctor.precision = pr + 2 * Math.max(Math.abs(x2.e), x2.sd()) + 6;
+    Ctor.rounding = 1;
+    external = false;
+    x2 = x2.times(x2).plus(1).sqrt().plus(x2);
+    external = true;
+    Ctor.precision = pr;
+    Ctor.rounding = rm;
+    return x2.ln();
+  };
+  P.inverseHyperbolicTangent = P.atanh = function() {
+    var pr, rm, wpr, xsd, x2 = this, Ctor = x2.constructor;
+    if (!x2.isFinite())
+      return new Ctor(NaN);
+    if (x2.e >= 0)
+      return new Ctor(x2.abs().eq(1) ? x2.s / 0 : x2.isZero() ? x2 : NaN);
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    xsd = x2.sd();
+    if (Math.max(xsd, pr) < 2 * -x2.e - 1)
+      return finalise(new Ctor(x2), pr, rm, true);
+    Ctor.precision = wpr = xsd - x2.e;
+    x2 = divide(x2.plus(1), new Ctor(1).minus(x2), wpr + pr, 1);
+    Ctor.precision = pr + 4;
+    Ctor.rounding = 1;
+    x2 = x2.ln();
+    Ctor.precision = pr;
+    Ctor.rounding = rm;
+    return x2.times(0.5);
+  };
+  P.inverseSine = P.asin = function() {
+    var halfPi, k2, pr, rm, x2 = this, Ctor = x2.constructor;
+    if (x2.isZero())
+      return new Ctor(x2);
+    k2 = x2.abs().cmp(1);
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    if (k2 !== -1) {
+      if (k2 === 0) {
+        halfPi = getPi(Ctor, pr + 4, rm).times(0.5);
+        halfPi.s = x2.s;
+        return halfPi;
+      }
+      return new Ctor(NaN);
+    }
+    Ctor.precision = pr + 6;
+    Ctor.rounding = 1;
+    x2 = x2.div(new Ctor(1).minus(x2.times(x2)).sqrt().plus(1)).atan();
+    Ctor.precision = pr;
+    Ctor.rounding = rm;
+    return x2.times(2);
+  };
+  P.inverseTangent = P.atan = function() {
+    var i2, j2, k2, n2, px, t2, r2, wpr, x2, x3 = this, Ctor = x3.constructor, pr = Ctor.precision, rm = Ctor.rounding;
+    if (!x3.isFinite()) {
+      if (!x3.s)
+        return new Ctor(NaN);
+      if (pr + 4 <= PI_PRECISION) {
+        r2 = getPi(Ctor, pr + 4, rm).times(0.5);
+        r2.s = x3.s;
+        return r2;
+      }
+    } else if (x3.isZero()) {
+      return new Ctor(x3);
+    } else if (x3.abs().eq(1) && pr + 4 <= PI_PRECISION) {
+      r2 = getPi(Ctor, pr + 4, rm).times(0.25);
+      r2.s = x3.s;
+      return r2;
+    }
+    Ctor.precision = wpr = pr + 10;
+    Ctor.rounding = 1;
+    k2 = Math.min(28, wpr / LOG_BASE + 2 | 0);
+    for (i2 = k2; i2; --i2)
+      x3 = x3.div(x3.times(x3).plus(1).sqrt().plus(1));
+    external = false;
+    j2 = Math.ceil(wpr / LOG_BASE);
+    n2 = 1;
+    x2 = x3.times(x3);
+    r2 = new Ctor(x3);
+    px = x3;
+    for (; i2 !== -1; ) {
+      px = px.times(x2);
+      t2 = r2.minus(px.div(n2 += 2));
+      px = px.times(x2);
+      r2 = t2.plus(px.div(n2 += 2));
+      if (r2.d[j2] !== void 0)
+        for (i2 = j2; r2.d[i2] === t2.d[i2] && i2--; )
+          ;
+    }
+    if (k2)
+      r2 = r2.times(2 << k2 - 1);
+    external = true;
+    return finalise(r2, Ctor.precision = pr, Ctor.rounding = rm, true);
+  };
+  P.isFinite = function() {
+    return !!this.d;
+  };
+  P.isInteger = P.isInt = function() {
+    return !!this.d && mathfloor(this.e / LOG_BASE) > this.d.length - 2;
+  };
+  P.isNaN = function() {
+    return !this.s;
+  };
+  P.isNegative = P.isNeg = function() {
+    return this.s < 0;
+  };
+  P.isPositive = P.isPos = function() {
+    return this.s > 0;
+  };
+  P.isZero = function() {
+    return !!this.d && this.d[0] === 0;
+  };
+  P.lessThan = P.lt = function(y2) {
+    return this.cmp(y2) < 0;
+  };
+  P.lessThanOrEqualTo = P.lte = function(y2) {
+    return this.cmp(y2) < 1;
+  };
+  P.logarithm = P.log = function(base) {
+    var isBase10, d2, denominator, k2, inf, num, sd, r2, arg = this, Ctor = arg.constructor, pr = Ctor.precision, rm = Ctor.rounding, guard = 5;
+    if (base == null) {
+      base = new Ctor(10);
+      isBase10 = true;
+    } else {
+      base = new Ctor(base);
+      d2 = base.d;
+      if (base.s < 0 || !d2 || !d2[0] || base.eq(1))
+        return new Ctor(NaN);
+      isBase10 = base.eq(10);
+    }
+    d2 = arg.d;
+    if (arg.s < 0 || !d2 || !d2[0] || arg.eq(1)) {
+      return new Ctor(d2 && !d2[0] ? -1 / 0 : arg.s != 1 ? NaN : d2 ? 0 : 1 / 0);
+    }
+    if (isBase10) {
+      if (d2.length > 1) {
+        inf = true;
+      } else {
+        for (k2 = d2[0]; k2 % 10 === 0; )
+          k2 /= 10;
+        inf = k2 !== 1;
+      }
+    }
+    external = false;
+    sd = pr + guard;
+    num = naturalLogarithm(arg, sd);
+    denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);
+    r2 = divide(num, denominator, sd, 1);
+    if (checkRoundingDigits(r2.d, k2 = pr, rm)) {
+      do {
+        sd += 10;
+        num = naturalLogarithm(arg, sd);
+        denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);
+        r2 = divide(num, denominator, sd, 1);
+        if (!inf) {
+          if (+digitsToString(r2.d).slice(k2 + 1, k2 + 15) + 1 == 1e14) {
+            r2 = finalise(r2, pr + 1, 0);
+          }
+          break;
+        }
+      } while (checkRoundingDigits(r2.d, k2 += 10, rm));
+    }
+    external = true;
+    return finalise(r2, pr, rm);
+  };
+  P.minus = P.sub = function(y2) {
+    var d2, e2, i2, j2, k2, len, pr, rm, xd, xe, xLTy, yd, x2 = this, Ctor = x2.constructor;
+    y2 = new Ctor(y2);
+    if (!x2.d || !y2.d) {
+      if (!x2.s || !y2.s)
+        y2 = new Ctor(NaN);
+      else if (x2.d)
+        y2.s = -y2.s;
+      else
+        y2 = new Ctor(y2.d || x2.s !== y2.s ? x2 : NaN);
+      return y2;
+    }
+    if (x2.s != y2.s) {
+      y2.s = -y2.s;
+      return x2.plus(y2);
+    }
+    xd = x2.d;
+    yd = y2.d;
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    if (!xd[0] || !yd[0]) {
+      if (yd[0])
+        y2.s = -y2.s;
+      else if (xd[0])
+        y2 = new Ctor(x2);
+      else
+        return new Ctor(rm === 3 ? -0 : 0);
+      return external ? finalise(y2, pr, rm) : y2;
+    }
+    e2 = mathfloor(y2.e / LOG_BASE);
+    xe = mathfloor(x2.e / LOG_BASE);
+    xd = xd.slice();
+    k2 = xe - e2;
+    if (k2) {
+      xLTy = k2 < 0;
+      if (xLTy) {
+        d2 = xd;
+        k2 = -k2;
+        len = yd.length;
+      } else {
+        d2 = yd;
+        e2 = xe;
+        len = xd.length;
+      }
+      i2 = Math.max(Math.ceil(pr / LOG_BASE), len) + 2;
+      if (k2 > i2) {
+        k2 = i2;
+        d2.length = 1;
+      }
+      d2.reverse();
+      for (i2 = k2; i2--; )
+        d2.push(0);
+      d2.reverse();
+    } else {
+      i2 = xd.length;
+      len = yd.length;
+      xLTy = i2 < len;
+      if (xLTy)
+        len = i2;
+      for (i2 = 0; i2 < len; i2++) {
+        if (xd[i2] != yd[i2]) {
+          xLTy = xd[i2] < yd[i2];
+          break;
+        }
+      }
+      k2 = 0;
+    }
+    if (xLTy) {
+      d2 = xd;
+      xd = yd;
+      yd = d2;
+      y2.s = -y2.s;
+    }
+    len = xd.length;
+    for (i2 = yd.length - len; i2 > 0; --i2)
+      xd[len++] = 0;
+    for (i2 = yd.length; i2 > k2; ) {
+      if (xd[--i2] < yd[i2]) {
+        for (j2 = i2; j2 && xd[--j2] === 0; )
+          xd[j2] = BASE - 1;
+        --xd[j2];
+        xd[i2] += BASE;
+      }
+      xd[i2] -= yd[i2];
+    }
+    for (; xd[--len] === 0; )
+      xd.pop();
+    for (; xd[0] === 0; xd.shift())
+      --e2;
+    if (!xd[0])
+      return new Ctor(rm === 3 ? -0 : 0);
+    y2.d = xd;
+    y2.e = getBase10Exponent(xd, e2);
+    return external ? finalise(y2, pr, rm) : y2;
+  };
+  P.modulo = P.mod = function(y2) {
+    var q, x2 = this, Ctor = x2.constructor;
+    y2 = new Ctor(y2);
+    if (!x2.d || !y2.s || y2.d && !y2.d[0])
+      return new Ctor(NaN);
+    if (!y2.d || x2.d && !x2.d[0]) {
+      return finalise(new Ctor(x2), Ctor.precision, Ctor.rounding);
+    }
+    external = false;
+    if (Ctor.modulo == 9) {
+      q = divide(x2, y2.abs(), 0, 3, 1);
+      q.s *= y2.s;
+    } else {
+      q = divide(x2, y2, 0, Ctor.modulo, 1);
+    }
+    q = q.times(y2);
+    external = true;
+    return x2.minus(q);
+  };
+  P.naturalExponential = P.exp = function() {
+    return naturalExponential(this);
+  };
+  P.naturalLogarithm = P.ln = function() {
+    return naturalLogarithm(this);
+  };
+  P.negated = P.neg = function() {
+    var x2 = new this.constructor(this);
+    x2.s = -x2.s;
+    return finalise(x2);
+  };
+  P.plus = P.add = function(y2) {
+    var carry, d2, e2, i2, k2, len, pr, rm, xd, yd, x2 = this, Ctor = x2.constructor;
+    y2 = new Ctor(y2);
+    if (!x2.d || !y2.d) {
+      if (!x2.s || !y2.s)
+        y2 = new Ctor(NaN);
+      else if (!x2.d)
+        y2 = new Ctor(y2.d || x2.s === y2.s ? x2 : NaN);
+      return y2;
+    }
+    if (x2.s != y2.s) {
+      y2.s = -y2.s;
+      return x2.minus(y2);
+    }
+    xd = x2.d;
+    yd = y2.d;
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    if (!xd[0] || !yd[0]) {
+      if (!yd[0])
+        y2 = new Ctor(x2);
+      return external ? finalise(y2, pr, rm) : y2;
+    }
+    k2 = mathfloor(x2.e / LOG_BASE);
+    e2 = mathfloor(y2.e / LOG_BASE);
+    xd = xd.slice();
+    i2 = k2 - e2;
+    if (i2) {
+      if (i2 < 0) {
+        d2 = xd;
+        i2 = -i2;
+        len = yd.length;
+      } else {
+        d2 = yd;
+        e2 = k2;
+        len = xd.length;
+      }
+      k2 = Math.ceil(pr / LOG_BASE);
+      len = k2 > len ? k2 + 1 : len + 1;
+      if (i2 > len) {
+        i2 = len;
+        d2.length = 1;
+      }
+      d2.reverse();
+      for (; i2--; )
+        d2.push(0);
+      d2.reverse();
+    }
+    len = xd.length;
+    i2 = yd.length;
+    if (len - i2 < 0) {
+      i2 = len;
+      d2 = yd;
+      yd = xd;
+      xd = d2;
+    }
+    for (carry = 0; i2; ) {
+      carry = (xd[--i2] = xd[i2] + yd[i2] + carry) / BASE | 0;
+      xd[i2] %= BASE;
+    }
+    if (carry) {
+      xd.unshift(carry);
+      ++e2;
+    }
+    for (len = xd.length; xd[--len] == 0; )
+      xd.pop();
+    y2.d = xd;
+    y2.e = getBase10Exponent(xd, e2);
+    return external ? finalise(y2, pr, rm) : y2;
+  };
+  P.precision = P.sd = function(z2) {
+    var k2, x2 = this;
+    if (z2 !== void 0 && z2 !== !!z2 && z2 !== 1 && z2 !== 0)
+      throw Error(invalidArgument + z2);
+    if (x2.d) {
+      k2 = getPrecision(x2.d);
+      if (z2 && x2.e + 1 > k2)
+        k2 = x2.e + 1;
+    } else {
+      k2 = NaN;
+    }
+    return k2;
+  };
+  P.round = function() {
+    var x2 = this, Ctor = x2.constructor;
+    return finalise(new Ctor(x2), x2.e + 1, Ctor.rounding);
+  };
+  P.sine = P.sin = function() {
+    var pr, rm, x2 = this, Ctor = x2.constructor;
+    if (!x2.isFinite())
+      return new Ctor(NaN);
+    if (x2.isZero())
+      return new Ctor(x2);
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    Ctor.precision = pr + Math.max(x2.e, x2.sd()) + LOG_BASE;
+    Ctor.rounding = 1;
+    x2 = sine(Ctor, toLessThanHalfPi(Ctor, x2));
+    Ctor.precision = pr;
+    Ctor.rounding = rm;
+    return finalise(quadrant > 2 ? x2.neg() : x2, pr, rm, true);
+  };
+  P.squareRoot = P.sqrt = function() {
+    var m2, n2, sd, r2, rep, t2, x2 = this, d2 = x2.d, e2 = x2.e, s2 = x2.s, Ctor = x2.constructor;
+    if (s2 !== 1 || !d2 || !d2[0]) {
+      return new Ctor(!s2 || s2 < 0 && (!d2 || d2[0]) ? NaN : d2 ? x2 : 1 / 0);
+    }
+    external = false;
+    s2 = Math.sqrt(+x2);
+    if (s2 == 0 || s2 == 1 / 0) {
+      n2 = digitsToString(d2);
+      if ((n2.length + e2) % 2 == 0)
+        n2 += "0";
+      s2 = Math.sqrt(n2);
+      e2 = mathfloor((e2 + 1) / 2) - (e2 < 0 || e2 % 2);
+      if (s2 == 1 / 0) {
+        n2 = "5e" + e2;
+      } else {
+        n2 = s2.toExponential();
+        n2 = n2.slice(0, n2.indexOf("e") + 1) + e2;
+      }
+      r2 = new Ctor(n2);
+    } else {
+      r2 = new Ctor(s2.toString());
+    }
+    sd = (e2 = Ctor.precision) + 3;
+    for (; ; ) {
+      t2 = r2;
+      r2 = t2.plus(divide(x2, t2, sd + 2, 1)).times(0.5);
+      if (digitsToString(t2.d).slice(0, sd) === (n2 = digitsToString(r2.d)).slice(0, sd)) {
+        n2 = n2.slice(sd - 3, sd + 1);
+        if (n2 == "9999" || !rep && n2 == "4999") {
+          if (!rep) {
+            finalise(t2, e2 + 1, 0);
+            if (t2.times(t2).eq(x2)) {
+              r2 = t2;
+              break;
+            }
+          }
+          sd += 4;
+          rep = 1;
+        } else {
+          if (!+n2 || !+n2.slice(1) && n2.charAt(0) == "5") {
+            finalise(r2, e2 + 1, 1);
+            m2 = !r2.times(r2).eq(x2);
+          }
+          break;
+        }
+      }
+    }
+    external = true;
+    return finalise(r2, e2, Ctor.rounding, m2);
+  };
+  P.tangent = P.tan = function() {
+    var pr, rm, x2 = this, Ctor = x2.constructor;
+    if (!x2.isFinite())
+      return new Ctor(NaN);
+    if (x2.isZero())
+      return new Ctor(x2);
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    Ctor.precision = pr + 10;
+    Ctor.rounding = 1;
+    x2 = x2.sin();
+    x2.s = 1;
+    x2 = divide(x2, new Ctor(1).minus(x2.times(x2)).sqrt(), pr + 10, 0);
+    Ctor.precision = pr;
+    Ctor.rounding = rm;
+    return finalise(quadrant == 2 || quadrant == 4 ? x2.neg() : x2, pr, rm, true);
+  };
+  P.times = P.mul = function(y2) {
+    var carry, e2, i2, k2, r2, rL, t2, xdL, ydL, x2 = this, Ctor = x2.constructor, xd = x2.d, yd = (y2 = new Ctor(y2)).d;
+    y2.s *= x2.s;
+    if (!xd || !xd[0] || !yd || !yd[0]) {
+      return new Ctor(!y2.s || xd && !xd[0] && !yd || yd && !yd[0] && !xd ? NaN : !xd || !yd ? y2.s / 0 : y2.s * 0);
+    }
+    e2 = mathfloor(x2.e / LOG_BASE) + mathfloor(y2.e / LOG_BASE);
+    xdL = xd.length;
+    ydL = yd.length;
+    if (xdL < ydL) {
+      r2 = xd;
+      xd = yd;
+      yd = r2;
+      rL = xdL;
+      xdL = ydL;
+      ydL = rL;
+    }
+    r2 = [];
+    rL = xdL + ydL;
+    for (i2 = rL; i2--; )
+      r2.push(0);
+    for (i2 = ydL; --i2 >= 0; ) {
+      carry = 0;
+      for (k2 = xdL + i2; k2 > i2; ) {
+        t2 = r2[k2] + yd[i2] * xd[k2 - i2 - 1] + carry;
+        r2[k2--] = t2 % BASE | 0;
+        carry = t2 / BASE | 0;
+      }
+      r2[k2] = (r2[k2] + carry) % BASE | 0;
+    }
+    for (; !r2[--rL]; )
+      r2.pop();
+    if (carry)
+      ++e2;
+    else
+      r2.shift();
+    y2.d = r2;
+    y2.e = getBase10Exponent(r2, e2);
+    return external ? finalise(y2, Ctor.precision, Ctor.rounding) : y2;
+  };
+  P.toBinary = function(sd, rm) {
+    return toStringBinary(this, 2, sd, rm);
+  };
+  P.toDecimalPlaces = P.toDP = function(dp, rm) {
+    var x2 = this, Ctor = x2.constructor;
+    x2 = new Ctor(x2);
+    if (dp === void 0)
+      return x2;
+    checkInt32(dp, 0, MAX_DIGITS);
+    if (rm === void 0)
+      rm = Ctor.rounding;
+    else
+      checkInt32(rm, 0, 8);
+    return finalise(x2, dp + x2.e + 1, rm);
+  };
+  P.toExponential = function(dp, rm) {
+    var str, x2 = this, Ctor = x2.constructor;
+    if (dp === void 0) {
+      str = finiteToString(x2, true);
+    } else {
+      checkInt32(dp, 0, MAX_DIGITS);
+      if (rm === void 0)
+        rm = Ctor.rounding;
+      else
+        checkInt32(rm, 0, 8);
+      x2 = finalise(new Ctor(x2), dp + 1, rm);
+      str = finiteToString(x2, true, dp + 1);
+    }
+    return x2.isNeg() && !x2.isZero() ? "-" + str : str;
+  };
+  P.toFixed = function(dp, rm) {
+    var str, y2, x2 = this, Ctor = x2.constructor;
+    if (dp === void 0) {
+      str = finiteToString(x2);
+    } else {
+      checkInt32(dp, 0, MAX_DIGITS);
+      if (rm === void 0)
+        rm = Ctor.rounding;
+      else
+        checkInt32(rm, 0, 8);
+      y2 = finalise(new Ctor(x2), dp + x2.e + 1, rm);
+      str = finiteToString(y2, false, dp + y2.e + 1);
+    }
+    return x2.isNeg() && !x2.isZero() ? "-" + str : str;
+  };
+  P.toFraction = function(maxD) {
+    var d2, d0, d1, d22, e2, k2, n2, n0, n1, pr, q, r2, x2 = this, xd = x2.d, Ctor = x2.constructor;
+    if (!xd)
+      return new Ctor(x2);
+    n1 = d0 = new Ctor(1);
+    d1 = n0 = new Ctor(0);
+    d2 = new Ctor(d1);
+    e2 = d2.e = getPrecision(xd) - x2.e - 1;
+    k2 = e2 % LOG_BASE;
+    d2.d[0] = mathpow(10, k2 < 0 ? LOG_BASE + k2 : k2);
+    if (maxD == null) {
+      maxD = e2 > 0 ? d2 : n1;
+    } else {
+      n2 = new Ctor(maxD);
+      if (!n2.isInt() || n2.lt(n1))
+        throw Error(invalidArgument + n2);
+      maxD = n2.gt(d2) ? e2 > 0 ? d2 : n1 : n2;
+    }
+    external = false;
+    n2 = new Ctor(digitsToString(xd));
+    pr = Ctor.precision;
+    Ctor.precision = e2 = xd.length * LOG_BASE * 2;
+    for (; ; ) {
+      q = divide(n2, d2, 0, 1, 1);
+      d22 = d0.plus(q.times(d1));
+      if (d22.cmp(maxD) == 1)
+        break;
+      d0 = d1;
+      d1 = d22;
+      d22 = n1;
+      n1 = n0.plus(q.times(d22));
+      n0 = d22;
+      d22 = d2;
+      d2 = n2.minus(q.times(d22));
+      n2 = d22;
+    }
+    d22 = divide(maxD.minus(d0), d1, 0, 1, 1);
+    n0 = n0.plus(d22.times(n1));
+    d0 = d0.plus(d22.times(d1));
+    n0.s = n1.s = x2.s;
+    r2 = divide(n1, d1, e2, 1).minus(x2).abs().cmp(divide(n0, d0, e2, 1).minus(x2).abs()) < 1 ? [n1, d1] : [n0, d0];
+    Ctor.precision = pr;
+    external = true;
+    return r2;
+  };
+  P.toHexadecimal = P.toHex = function(sd, rm) {
+    return toStringBinary(this, 16, sd, rm);
+  };
+  P.toNearest = function(y2, rm) {
+    var x2 = this, Ctor = x2.constructor;
+    x2 = new Ctor(x2);
+    if (y2 == null) {
+      if (!x2.d)
+        return x2;
+      y2 = new Ctor(1);
+      rm = Ctor.rounding;
+    } else {
+      y2 = new Ctor(y2);
+      if (rm === void 0) {
+        rm = Ctor.rounding;
+      } else {
+        checkInt32(rm, 0, 8);
+      }
+      if (!x2.d)
+        return y2.s ? x2 : y2;
+      if (!y2.d) {
+        if (y2.s)
+          y2.s = x2.s;
+        return y2;
+      }
+    }
+    if (y2.d[0]) {
+      external = false;
+      x2 = divide(x2, y2, 0, rm, 1).times(y2);
+      external = true;
+      finalise(x2);
+    } else {
+      y2.s = x2.s;
+      x2 = y2;
+    }
+    return x2;
+  };
+  P.toNumber = function() {
+    return +this;
+  };
+  P.toOctal = function(sd, rm) {
+    return toStringBinary(this, 8, sd, rm);
+  };
+  P.toPower = P.pow = function(y2) {
+    var e2, k2, pr, r2, rm, s2, x2 = this, Ctor = x2.constructor, yn = +(y2 = new Ctor(y2));
+    if (!x2.d || !y2.d || !x2.d[0] || !y2.d[0])
+      return new Ctor(mathpow(+x2, yn));
+    x2 = new Ctor(x2);
+    if (x2.eq(1))
+      return x2;
+    pr = Ctor.precision;
+    rm = Ctor.rounding;
+    if (y2.eq(1))
+      return finalise(x2, pr, rm);
+    e2 = mathfloor(y2.e / LOG_BASE);
+    if (e2 >= y2.d.length - 1 && (k2 = yn < 0 ? -yn : yn) <= MAX_SAFE_INTEGER) {
+      r2 = intPow(Ctor, x2, k2, pr);
+      return y2.s < 0 ? new Ctor(1).div(r2) : finalise(r2, pr, rm);
+    }
+    s2 = x2.s;
+    if (s2 < 0) {
+      if (e2 < y2.d.length - 1)
+        return new Ctor(NaN);
+      if ((y2.d[e2] & 1) == 0)
+        s2 = 1;
+      if (x2.e == 0 && x2.d[0] == 1 && x2.d.length == 1) {
+        x2.s = s2;
+        return x2;
+      }
+    }
+    k2 = mathpow(+x2, yn);
+    e2 = k2 == 0 || !isFinite(k2) ? mathfloor(yn * (Math.log("0." + digitsToString(x2.d)) / Math.LN10 + x2.e + 1)) : new Ctor(k2 + "").e;
+    if (e2 > Ctor.maxE + 1 || e2 < Ctor.minE - 1)
+      return new Ctor(e2 > 0 ? s2 / 0 : 0);
+    external = false;
+    Ctor.rounding = x2.s = 1;
+    k2 = Math.min(12, (e2 + "").length);
+    r2 = naturalExponential(y2.times(naturalLogarithm(x2, pr + k2)), pr);
+    if (r2.d) {
+      r2 = finalise(r2, pr + 5, 1);
+      if (checkRoundingDigits(r2.d, pr, rm)) {
+        e2 = pr + 10;
+        r2 = finalise(naturalExponential(y2.times(naturalLogarithm(x2, e2 + k2)), e2), e2 + 5, 1);
+        if (+digitsToString(r2.d).slice(pr + 1, pr + 15) + 1 == 1e14) {
+          r2 = finalise(r2, pr + 1, 0);
+        }
+      }
+    }
+    r2.s = s2;
+    external = true;
+    Ctor.rounding = rm;
+    return finalise(r2, pr, rm);
+  };
+  P.toPrecision = function(sd, rm) {
+    var str, x2 = this, Ctor = x2.constructor;
+    if (sd === void 0) {
+      str = finiteToString(x2, x2.e <= Ctor.toExpNeg || x2.e >= Ctor.toExpPos);
+    } else {
+      checkInt32(sd, 1, MAX_DIGITS);
+      if (rm === void 0)
+        rm = Ctor.rounding;
+      else
+        checkInt32(rm, 0, 8);
+      x2 = finalise(new Ctor(x2), sd, rm);
+      str = finiteToString(x2, sd <= x2.e || x2.e <= Ctor.toExpNeg, sd);
+    }
+    return x2.isNeg() && !x2.isZero() ? "-" + str : str;
+  };
+  P.toSignificantDigits = P.toSD = function(sd, rm) {
+    var x2 = this, Ctor = x2.constructor;
+    if (sd === void 0) {
+      sd = Ctor.precision;
+      rm = Ctor.rounding;
+    } else {
+      checkInt32(sd, 1, MAX_DIGITS);
+      if (rm === void 0)
+        rm = Ctor.rounding;
+      else
+        checkInt32(rm, 0, 8);
+    }
+    return finalise(new Ctor(x2), sd, rm);
+  };
+  P.toString = function() {
+    var x2 = this, Ctor = x2.constructor, str = finiteToString(x2, x2.e <= Ctor.toExpNeg || x2.e >= Ctor.toExpPos);
+    return x2.isNeg() && !x2.isZero() ? "-" + str : str;
+  };
+  P.truncated = P.trunc = function() {
+    return finalise(new this.constructor(this), this.e + 1, 1);
+  };
+  P.valueOf = P.toJSON = function() {
+    var x2 = this, Ctor = x2.constructor, str = finiteToString(x2, x2.e <= Ctor.toExpNeg || x2.e >= Ctor.toExpPos);
+    return x2.isNeg() ? "-" + str : str;
+  };
+  function digitsToString(d2) {
+    var i2, k2, ws, indexOfLastWord = d2.length - 1, str = "", w2 = d2[0];
+    if (indexOfLastWord > 0) {
+      str += w2;
+      for (i2 = 1; i2 < indexOfLastWord; i2++) {
+        ws = d2[i2] + "";
+        k2 = LOG_BASE - ws.length;
+        if (k2)
+          str += getZeroString(k2);
+        str += ws;
+      }
+      w2 = d2[i2];
+      ws = w2 + "";
+      k2 = LOG_BASE - ws.length;
+      if (k2)
+        str += getZeroString(k2);
+    } else if (w2 === 0) {
+      return "0";
+    }
+    for (; w2 % 10 === 0; )
+      w2 /= 10;
+    return str + w2;
+  }
+  function checkInt32(i2, min2, max2) {
+    if (i2 !== ~~i2 || i2 < min2 || i2 > max2) {
+      throw Error(invalidArgument + i2);
+    }
+  }
+  function checkRoundingDigits(d2, i2, rm, repeating) {
+    var di, k2, r2, rd;
+    for (k2 = d2[0]; k2 >= 10; k2 /= 10)
+      --i2;
+    if (--i2 < 0) {
+      i2 += LOG_BASE;
+      di = 0;
+    } else {
+      di = Math.ceil((i2 + 1) / LOG_BASE);
+      i2 %= LOG_BASE;
+    }
+    k2 = mathpow(10, LOG_BASE - i2);
+    rd = d2[di] % k2 | 0;
+    if (repeating == null) {
+      if (i2 < 3) {
+        if (i2 == 0)
+          rd = rd / 100 | 0;
+        else if (i2 == 1)
+          rd = rd / 10 | 0;
+        r2 = rm < 4 && rd == 99999 || rm > 3 && rd == 49999 || rd == 5e4 || rd == 0;
+      } else {
+        r2 = (rm < 4 && rd + 1 == k2 || rm > 3 && rd + 1 == k2 / 2) && (d2[di + 1] / k2 / 100 | 0) == mathpow(10, i2 - 2) - 1 || (rd == k2 / 2 || rd == 0) && (d2[di + 1] / k2 / 100 | 0) == 0;
+      }
+    } else {
+      if (i2 < 4) {
+        if (i2 == 0)
+          rd = rd / 1e3 | 0;
+        else if (i2 == 1)
+          rd = rd / 100 | 0;
+        else if (i2 == 2)
+          rd = rd / 10 | 0;
+        r2 = (repeating || rm < 4) && rd == 9999 || !repeating && rm > 3 && rd == 4999;
+      } else {
+        r2 = ((repeating || rm < 4) && rd + 1 == k2 || !repeating && rm > 3 && rd + 1 == k2 / 2) && (d2[di + 1] / k2 / 1e3 | 0) == mathpow(10, i2 - 3) - 1;
+      }
+    }
+    return r2;
+  }
+  function convertBase(str, baseIn, baseOut) {
+    var j2, arr = [0], arrL, i2 = 0, strL = str.length;
+    for (; i2 < strL; ) {
+      for (arrL = arr.length; arrL--; )
+        arr[arrL] *= baseIn;
+      arr[0] += NUMERALS.indexOf(str.charAt(i2++));
+      for (j2 = 0; j2 < arr.length; j2++) {
+        if (arr[j2] > baseOut - 1) {
+          if (arr[j2 + 1] === void 0)
+            arr[j2 + 1] = 0;
+          arr[j2 + 1] += arr[j2] / baseOut | 0;
+          arr[j2] %= baseOut;
+        }
+      }
+    }
+    return arr.reverse();
+  }
+  function cosine(Ctor, x2) {
+    var k2, len, y2;
+    if (x2.isZero())
+      return x2;
+    len = x2.d.length;
+    if (len < 32) {
+      k2 = Math.ceil(len / 3);
+      y2 = (1 / tinyPow(4, k2)).toString();
+    } else {
+      k2 = 16;
+      y2 = "2.3283064365386962890625e-10";
+    }
+    Ctor.precision += k2;
+    x2 = taylorSeries(Ctor, 1, x2.times(y2), new Ctor(1));
+    for (var i2 = k2; i2--; ) {
+      var cos2x = x2.times(x2);
+      x2 = cos2x.times(cos2x).minus(cos2x).times(8).plus(1);
+    }
+    Ctor.precision -= k2;
+    return x2;
+  }
+  var divide = function() {
+    function multiplyInteger(x2, k2, base) {
+      var temp, carry = 0, i2 = x2.length;
+      for (x2 = x2.slice(); i2--; ) {
+        temp = x2[i2] * k2 + carry;
+        x2[i2] = temp % base | 0;
+        carry = temp / base | 0;
+      }
+      if (carry)
+        x2.unshift(carry);
+      return x2;
+    }
+    function compare(a2, b2, aL, bL) {
+      var i2, r2;
+      if (aL != bL) {
+        r2 = aL > bL ? 1 : -1;
+      } else {
+        for (i2 = r2 = 0; i2 < aL; i2++) {
+          if (a2[i2] != b2[i2]) {
+            r2 = a2[i2] > b2[i2] ? 1 : -1;
+            break;
+          }
+        }
+      }
+      return r2;
+    }
+    function subtract(a2, b2, aL, base) {
+      var i2 = 0;
+      for (; aL--; ) {
+        a2[aL] -= i2;
+        i2 = a2[aL] < b2[aL] ? 1 : 0;
+        a2[aL] = i2 * base + a2[aL] - b2[aL];
+      }
+      for (; !a2[0] && a2.length > 1; )
+        a2.shift();
+    }
+    return function(x2, y2, pr, rm, dp, base) {
+      var cmp, e2, i2, k2, logBase, more, prod, prodL, q, qd, rem, remL, rem0, sd, t2, xi, xL, yd0, yL, yz, Ctor = x2.constructor, sign2 = x2.s == y2.s ? 1 : -1, xd = x2.d, yd = y2.d;
+      if (!xd || !xd[0] || !yd || !yd[0]) {
+        return new Ctor(
+          // Return NaN if either NaN, or both Infinity or 0.
+          !x2.s || !y2.s || (xd ? yd && xd[0] == yd[0] : !yd) ? NaN : (
+            // Return ±0 if x is 0 or y is ±Infinity, or return ±Infinity as y is 0.
+            xd && xd[0] == 0 || !yd ? sign2 * 0 : sign2 / 0
+          )
+        );
+      }
+      if (base) {
+        logBase = 1;
+        e2 = x2.e - y2.e;
+      } else {
+        base = BASE;
+        logBase = LOG_BASE;
+        e2 = mathfloor(x2.e / logBase) - mathfloor(y2.e / logBase);
+      }
+      yL = yd.length;
+      xL = xd.length;
+      q = new Ctor(sign2);
+      qd = q.d = [];
+      for (i2 = 0; yd[i2] == (xd[i2] || 0); i2++)
+        ;
+      if (yd[i2] > (xd[i2] || 0))
+        e2--;
+      if (pr == null) {
+        sd = pr = Ctor.precision;
+        rm = Ctor.rounding;
+      } else if (dp) {
+        sd = pr + (x2.e - y2.e) + 1;
+      } else {
+        sd = pr;
+      }
+      if (sd < 0) {
+        qd.push(1);
+        more = true;
+      } else {
+        sd = sd / logBase + 2 | 0;
+        i2 = 0;
+        if (yL == 1) {
+          k2 = 0;
+          yd = yd[0];
+          sd++;
+          for (; (i2 < xL || k2) && sd--; i2++) {
+            t2 = k2 * base + (xd[i2] || 0);
+            qd[i2] = t2 / yd | 0;
+            k2 = t2 % yd | 0;
+          }
+          more = k2 || i2 < xL;
+        } else {
+          k2 = base / (yd[0] + 1) | 0;
+          if (k2 > 1) {
+            yd = multiplyInteger(yd, k2, base);
+            xd = multiplyInteger(xd, k2, base);
+            yL = yd.length;
+            xL = xd.length;
+          }
+          xi = yL;
+          rem = xd.slice(0, yL);
+          remL = rem.length;
+          for (; remL < yL; )
+            rem[remL++] = 0;
+          yz = yd.slice();
+          yz.unshift(0);
+          yd0 = yd[0];
+          if (yd[1] >= base / 2)
+            ++yd0;
+          do {
+            k2 = 0;
+            cmp = compare(yd, rem, yL, remL);
+            if (cmp < 0) {
+              rem0 = rem[0];
+              if (yL != remL)
+                rem0 = rem0 * base + (rem[1] || 0);
+              k2 = rem0 / yd0 | 0;
+              if (k2 > 1) {
+                if (k2 >= base)
+                  k2 = base - 1;
+                prod = multiplyInteger(yd, k2, base);
+                prodL = prod.length;
+                remL = rem.length;
+                cmp = compare(prod, rem, prodL, remL);
+                if (cmp == 1) {
+                  k2--;
+                  subtract(prod, yL < prodL ? yz : yd, prodL, base);
+                }
+              } else {
+                if (k2 == 0)
+                  cmp = k2 = 1;
+                prod = yd.slice();
+              }
+              prodL = prod.length;
+              if (prodL < remL)
+                prod.unshift(0);
+              subtract(rem, prod, remL, base);
+              if (cmp == -1) {
+                remL = rem.length;
+                cmp = compare(yd, rem, yL, remL);
+                if (cmp < 1) {
+                  k2++;
+                  subtract(rem, yL < remL ? yz : yd, remL, base);
+                }
+              }
+              remL = rem.length;
+            } else if (cmp === 0) {
+              k2++;
+              rem = [0];
+            }
+            qd[i2++] = k2;
+            if (cmp && rem[0]) {
+              rem[remL++] = xd[xi] || 0;
+            } else {
+              rem = [xd[xi]];
+              remL = 1;
+            }
+          } while ((xi++ < xL || rem[0] !== void 0) && sd--);
+          more = rem[0] !== void 0;
+        }
+        if (!qd[0])
+          qd.shift();
+      }
+      if (logBase == 1) {
+        q.e = e2;
+        inexact = more;
+      } else {
+        for (i2 = 1, k2 = qd[0]; k2 >= 10; k2 /= 10)
+          i2++;
+        q.e = i2 + e2 * logBase - 1;
+        finalise(q, dp ? pr + q.e + 1 : pr, rm, more);
+      }
+      return q;
+    };
+  }();
+  function finalise(x2, sd, rm, isTruncated) {
+    var digits, i2, j2, k2, rd, roundUp, w2, xd, xdi, Ctor = x2.constructor;
+    out:
+      if (sd != null) {
+        xd = x2.d;
+        if (!xd)
+          return x2;
+        for (digits = 1, k2 = xd[0]; k2 >= 10; k2 /= 10)
+          digits++;
+        i2 = sd - digits;
+        if (i2 < 0) {
+          i2 += LOG_BASE;
+          j2 = sd;
+          w2 = xd[xdi = 0];
+          rd = w2 / mathpow(10, digits - j2 - 1) % 10 | 0;
+        } else {
+          xdi = Math.ceil((i2 + 1) / LOG_BASE);
+          k2 = xd.length;
+          if (xdi >= k2) {
+            if (isTruncated) {
+              for (; k2++ <= xdi; )
+                xd.push(0);
+              w2 = rd = 0;
+              digits = 1;
+              i2 %= LOG_BASE;
+              j2 = i2 - LOG_BASE + 1;
+            } else {
+              break out;
+            }
+          } else {
+            w2 = k2 = xd[xdi];
+            for (digits = 1; k2 >= 10; k2 /= 10)
+              digits++;
+            i2 %= LOG_BASE;
+            j2 = i2 - LOG_BASE + digits;
+            rd = j2 < 0 ? 0 : w2 / mathpow(10, digits - j2 - 1) % 10 | 0;
+          }
+        }
+        isTruncated = isTruncated || sd < 0 || xd[xdi + 1] !== void 0 || (j2 < 0 ? w2 : w2 % mathpow(10, digits - j2 - 1));
+        roundUp = rm < 4 ? (rd || isTruncated) && (rm == 0 || rm == (x2.s < 0 ? 3 : 2)) : rd > 5 || rd == 5 && (rm == 4 || isTruncated || rm == 6 && // Check whether the digit to the left of the rounding digit is odd.
+        (i2 > 0 ? j2 > 0 ? w2 / mathpow(10, digits - j2) : 0 : xd[xdi - 1]) % 10 & 1 || rm == (x2.s < 0 ? 8 : 7));
+        if (sd < 1 || !xd[0]) {
+          xd.length = 0;
+          if (roundUp) {
+            sd -= x2.e + 1;
+            xd[0] = mathpow(10, (LOG_BASE - sd % LOG_BASE) % LOG_BASE);
+            x2.e = -sd || 0;
+          } else {
+            xd[0] = x2.e = 0;
+          }
+          return x2;
+        }
+        if (i2 == 0) {
+          xd.length = xdi;
+          k2 = 1;
+          xdi--;
+        } else {
+          xd.length = xdi + 1;
+          k2 = mathpow(10, LOG_BASE - i2);
+          xd[xdi] = j2 > 0 ? (w2 / mathpow(10, digits - j2) % mathpow(10, j2) | 0) * k2 : 0;
+        }
+        if (roundUp) {
+          for (; ; ) {
+            if (xdi == 0) {
+              for (i2 = 1, j2 = xd[0]; j2 >= 10; j2 /= 10)
+                i2++;
+              j2 = xd[0] += k2;
+              for (k2 = 1; j2 >= 10; j2 /= 10)
+                k2++;
+              if (i2 != k2) {
+                x2.e++;
+                if (xd[0] == BASE)
+                  xd[0] = 1;
+              }
+              break;
+            } else {
+              xd[xdi] += k2;
+              if (xd[xdi] != BASE)
+                break;
+              xd[xdi--] = 0;
+              k2 = 1;
+            }
+          }
+        }
+        for (i2 = xd.length; xd[--i2] === 0; )
+          xd.pop();
+      }
+    if (external) {
+      if (x2.e > Ctor.maxE) {
+        x2.d = null;
+        x2.e = NaN;
+      } else if (x2.e < Ctor.minE) {
+        x2.e = 0;
+        x2.d = [0];
+      }
+    }
+    return x2;
+  }
+  function finiteToString(x2, isExp, sd) {
+    if (!x2.isFinite())
+      return nonFiniteToString(x2);
+    var k2, e2 = x2.e, str = digitsToString(x2.d), len = str.length;
+    if (isExp) {
+      if (sd && (k2 = sd - len) > 0) {
+        str = str.charAt(0) + "." + str.slice(1) + getZeroString(k2);
+      } else if (len > 1) {
+        str = str.charAt(0) + "." + str.slice(1);
+      }
+      str = str + (x2.e < 0 ? "e" : "e+") + x2.e;
+    } else if (e2 < 0) {
+      str = "0." + getZeroString(-e2 - 1) + str;
+      if (sd && (k2 = sd - len) > 0)
+        str += getZeroString(k2);
+    } else if (e2 >= len) {
+      str += getZeroString(e2 + 1 - len);
+      if (sd && (k2 = sd - e2 - 1) > 0)
+        str = str + "." + getZeroString(k2);
+    } else {
+      if ((k2 = e2 + 1) < len)
+        str = str.slice(0, k2) + "." + str.slice(k2);
+      if (sd && (k2 = sd - len) > 0) {
+        if (e2 + 1 === len)
+          str += ".";
+        str += getZeroString(k2);
+      }
+    }
+    return str;
+  }
+  function getBase10Exponent(digits, e2) {
+    var w2 = digits[0];
+    for (e2 *= LOG_BASE; w2 >= 10; w2 /= 10)
+      e2++;
+    return e2;
+  }
+  function getLn10(Ctor, sd, pr) {
+    if (sd > LN10_PRECISION) {
+      external = true;
+      if (pr)
+        Ctor.precision = pr;
+      throw Error(precisionLimitExceeded);
+    }
+    return finalise(new Ctor(LN10), sd, 1, true);
+  }
+  function getPi(Ctor, sd, rm) {
+    if (sd > PI_PRECISION)
+      throw Error(precisionLimitExceeded);
+    return finalise(new Ctor(PI), sd, rm, true);
+  }
+  function getPrecision(digits) {
+    var w2 = digits.length - 1, len = w2 * LOG_BASE + 1;
+    w2 = digits[w2];
+    if (w2) {
+      for (; w2 % 10 == 0; w2 /= 10)
+        len--;
+      for (w2 = digits[0]; w2 >= 10; w2 /= 10)
+        len++;
+    }
+    return len;
+  }
+  function getZeroString(k2) {
+    var zs = "";
+    for (; k2--; )
+      zs += "0";
+    return zs;
+  }
+  function intPow(Ctor, x2, n2, pr) {
+    var isTruncated, r2 = new Ctor(1), k2 = Math.ceil(pr / LOG_BASE + 4);
+    external = false;
+    for (; ; ) {
+      if (n2 % 2) {
+        r2 = r2.times(x2);
+        if (truncate(r2.d, k2))
+          isTruncated = true;
+      }
+      n2 = mathfloor(n2 / 2);
+      if (n2 === 0) {
+        n2 = r2.d.length - 1;
+        if (isTruncated && r2.d[n2] === 0)
+          ++r2.d[n2];
+        break;
+      }
+      x2 = x2.times(x2);
+      truncate(x2.d, k2);
+    }
+    external = true;
+    return r2;
+  }
+  function isOdd(n2) {
+    return n2.d[n2.d.length - 1] & 1;
+  }
+  function maxOrMin(Ctor, args, ltgt) {
+    var y2, x2 = new Ctor(args[0]), i2 = 0;
+    for (; ++i2 < args.length; ) {
+      y2 = new Ctor(args[i2]);
+      if (!y2.s) {
+        x2 = y2;
+        break;
+      } else if (x2[ltgt](y2)) {
+        x2 = y2;
+      }
+    }
+    return x2;
+  }
+  function naturalExponential(x2, sd) {
+    var denominator, guard, j2, pow2, sum2, t2, wpr, rep = 0, i2 = 0, k2 = 0, Ctor = x2.constructor, rm = Ctor.rounding, pr = Ctor.precision;
+    if (!x2.d || !x2.d[0] || x2.e > 17) {
+      return new Ctor(x2.d ? !x2.d[0] ? 1 : x2.s < 0 ? 0 : 1 / 0 : x2.s ? x2.s < 0 ? 0 : x2 : 0 / 0);
+    }
+    if (sd == null) {
+      external = false;
+      wpr = pr;
+    } else {
+      wpr = sd;
+    }
+    t2 = new Ctor(0.03125);
+    while (x2.e > -2) {
+      x2 = x2.times(t2);
+      k2 += 5;
+    }
+    guard = Math.log(mathpow(2, k2)) / Math.LN10 * 2 + 5 | 0;
+    wpr += guard;
+    denominator = pow2 = sum2 = new Ctor(1);
+    Ctor.precision = wpr;
+    for (; ; ) {
+      pow2 = finalise(pow2.times(x2), wpr, 1);
+      denominator = denominator.times(++i2);
+      t2 = sum2.plus(divide(pow2, denominator, wpr, 1));
+      if (digitsToString(t2.d).slice(0, wpr) === digitsToString(sum2.d).slice(0, wpr)) {
+        j2 = k2;
+        while (j2--)
+          sum2 = finalise(sum2.times(sum2), wpr, 1);
+        if (sd == null) {
+          if (rep < 3 && checkRoundingDigits(sum2.d, wpr - guard, rm, rep)) {
+            Ctor.precision = wpr += 10;
+            denominator = pow2 = t2 = new Ctor(1);
+            i2 = 0;
+            rep++;
+          } else {
+            return finalise(sum2, Ctor.precision = pr, rm, external = true);
+          }
+        } else {
+          Ctor.precision = pr;
+          return sum2;
+        }
+      }
+      sum2 = t2;
+    }
+  }
+  function naturalLogarithm(y2, sd) {
+    var c2, c0, denominator, e2, numerator, rep, sum2, t2, wpr, x1, x2, n2 = 1, guard = 10, x3 = y2, xd = x3.d, Ctor = x3.constructor, rm = Ctor.rounding, pr = Ctor.precision;
+    if (x3.s < 0 || !xd || !xd[0] || !x3.e && xd[0] == 1 && xd.length == 1) {
+      return new Ctor(xd && !xd[0] ? -1 / 0 : x3.s != 1 ? NaN : xd ? 0 : x3);
+    }
+    if (sd == null) {
+      external = false;
+      wpr = pr;
+    } else {
+      wpr = sd;
+    }
+    Ctor.precision = wpr += guard;
+    c2 = digitsToString(xd);
+    c0 = c2.charAt(0);
+    if (Math.abs(e2 = x3.e) < 15e14) {
+      while (c0 < 7 && c0 != 1 || c0 == 1 && c2.charAt(1) > 3) {
+        x3 = x3.times(y2);
+        c2 = digitsToString(x3.d);
+        c0 = c2.charAt(0);
+        n2++;
+      }
+      e2 = x3.e;
+      if (c0 > 1) {
+        x3 = new Ctor("0." + c2);
+        e2++;
+      } else {
+        x3 = new Ctor(c0 + "." + c2.slice(1));
+      }
+    } else {
+      t2 = getLn10(Ctor, wpr + 2, pr).times(e2 + "");
+      x3 = naturalLogarithm(new Ctor(c0 + "." + c2.slice(1)), wpr - guard).plus(t2);
+      Ctor.precision = pr;
+      return sd == null ? finalise(x3, pr, rm, external = true) : x3;
+    }
+    x1 = x3;
+    sum2 = numerator = x3 = divide(x3.minus(1), x3.plus(1), wpr, 1);
+    x2 = finalise(x3.times(x3), wpr, 1);
+    denominator = 3;
+    for (; ; ) {
+      numerator = finalise(numerator.times(x2), wpr, 1);
+      t2 = sum2.plus(divide(numerator, new Ctor(denominator), wpr, 1));
+      if (digitsToString(t2.d).slice(0, wpr) === digitsToString(sum2.d).slice(0, wpr)) {
+        sum2 = sum2.times(2);
+        if (e2 !== 0)
+          sum2 = sum2.plus(getLn10(Ctor, wpr + 2, pr).times(e2 + ""));
+        sum2 = divide(sum2, new Ctor(n2), wpr, 1);
+        if (sd == null) {
+          if (checkRoundingDigits(sum2.d, wpr - guard, rm, rep)) {
+            Ctor.precision = wpr += guard;
+            t2 = numerator = x3 = divide(x1.minus(1), x1.plus(1), wpr, 1);
+            x2 = finalise(x3.times(x3), wpr, 1);
+            denominator = rep = 1;
+          } else {
+            return finalise(sum2, Ctor.precision = pr, rm, external = true);
+          }
+        } else {
+          Ctor.precision = pr;
+          return sum2;
+        }
+      }
+      sum2 = t2;
+      denominator += 2;
+    }
+  }
+  function nonFiniteToString(x2) {
+    return String(x2.s * x2.s / 0);
+  }
+  function parseDecimal(x2, str) {
+    var e2, i2, len;
+    if ((e2 = str.indexOf(".")) > -1)
+      str = str.replace(".", "");
+    if ((i2 = str.search(/e/i)) > 0) {
+      if (e2 < 0)
+        e2 = i2;
+      e2 += +str.slice(i2 + 1);
+      str = str.substring(0, i2);
+    } else if (e2 < 0) {
+      e2 = str.length;
+    }
+    for (i2 = 0; str.charCodeAt(i2) === 48; i2++)
+      ;
+    for (len = str.length; str.charCodeAt(len - 1) === 48; --len)
+      ;
+    str = str.slice(i2, len);
+    if (str) {
+      len -= i2;
+      x2.e = e2 = e2 - i2 - 1;
+      x2.d = [];
+      i2 = (e2 + 1) % LOG_BASE;
+      if (e2 < 0)
+        i2 += LOG_BASE;
+      if (i2 < len) {
+        if (i2)
+          x2.d.push(+str.slice(0, i2));
+        for (len -= LOG_BASE; i2 < len; )
+          x2.d.push(+str.slice(i2, i2 += LOG_BASE));
+        str = str.slice(i2);
+        i2 = LOG_BASE - str.length;
+      } else {
+        i2 -= len;
+      }
+      for (; i2--; )
+        str += "0";
+      x2.d.push(+str);
+      if (external) {
+        if (x2.e > x2.constructor.maxE) {
+          x2.d = null;
+          x2.e = NaN;
+        } else if (x2.e < x2.constructor.minE) {
+          x2.e = 0;
+          x2.d = [0];
+        }
+      }
+    } else {
+      x2.e = 0;
+      x2.d = [0];
+    }
+    return x2;
+  }
+  function parseOther(x2, str) {
+    var base, Ctor, divisor, i2, isFloat, len, p2, xd, xe;
+    if (str.indexOf("_") > -1) {
+      str = str.replace(/(\d)_(?=\d)/g, "$1");
+      if (isDecimal.test(str))
+        return parseDecimal(x2, str);
+    } else if (str === "Infinity" || str === "NaN") {
+      if (!+str)
+        x2.s = NaN;
+      x2.e = NaN;
+      x2.d = null;
+      return x2;
+    }
+    if (isHex.test(str)) {
+      base = 16;
+      str = str.toLowerCase();
+    } else if (isBinary.test(str)) {
+      base = 2;
+    } else if (isOctal.test(str)) {
+      base = 8;
+    } else {
+      throw Error(invalidArgument + str);
+    }
+    i2 = str.search(/p/i);
+    if (i2 > 0) {
+      p2 = +str.slice(i2 + 1);
+      str = str.substring(2, i2);
+    } else {
+      str = str.slice(2);
+    }
+    i2 = str.indexOf(".");
+    isFloat = i2 >= 0;
+    Ctor = x2.constructor;
+    if (isFloat) {
+      str = str.replace(".", "");
+      len = str.length;
+      i2 = len - i2;
+      divisor = intPow(Ctor, new Ctor(base), i2, i2 * 2);
+    }
+    xd = convertBase(str, base, BASE);
+    xe = xd.length - 1;
+    for (i2 = xe; xd[i2] === 0; --i2)
+      xd.pop();
+    if (i2 < 0)
+      return new Ctor(x2.s * 0);
+    x2.e = getBase10Exponent(xd, xe);
+    x2.d = xd;
+    external = false;
+    if (isFloat)
+      x2 = divide(x2, divisor, len * 4);
+    if (p2)
+      x2 = x2.times(Math.abs(p2) < 54 ? mathpow(2, p2) : Decimal.pow(2, p2));
+    external = true;
+    return x2;
+  }
+  function sine(Ctor, x2) {
+    var k2, len = x2.d.length;
+    if (len < 3) {
+      return x2.isZero() ? x2 : taylorSeries(Ctor, 2, x2, x2);
+    }
+    k2 = 1.4 * Math.sqrt(len);
+    k2 = k2 > 16 ? 16 : k2 | 0;
+    x2 = x2.times(1 / tinyPow(5, k2));
+    x2 = taylorSeries(Ctor, 2, x2, x2);
+    var sin2_x, d5 = new Ctor(5), d16 = new Ctor(16), d20 = new Ctor(20);
+    for (; k2--; ) {
+      sin2_x = x2.times(x2);
+      x2 = x2.times(d5.plus(sin2_x.times(d16.times(sin2_x).minus(d20))));
+    }
+    return x2;
+  }
+  function taylorSeries(Ctor, n2, x2, y2, isHyperbolic) {
+    var j2, t2, u2, x22, pr = Ctor.precision, k2 = Math.ceil(pr / LOG_BASE);
+    external = false;
+    x22 = x2.times(x2);
+    u2 = new Ctor(y2);
+    for (; ; ) {
+      t2 = divide(u2.times(x22), new Ctor(n2++ * n2++), pr, 1);
+      u2 = isHyperbolic ? y2.plus(t2) : y2.minus(t2);
+      y2 = divide(t2.times(x22), new Ctor(n2++ * n2++), pr, 1);
+      t2 = u2.plus(y2);
+      if (t2.d[k2] !== void 0) {
+        for (j2 = k2; t2.d[j2] === u2.d[j2] && j2--; )
+          ;
+        if (j2 == -1)
+          break;
+      }
+      j2 = u2;
+      u2 = y2;
+      y2 = t2;
+      t2 = j2;
+    }
+    external = true;
+    t2.d.length = k2 + 1;
+    return t2;
+  }
+  function tinyPow(b2, e2) {
+    var n2 = b2;
+    while (--e2)
+      n2 *= b2;
+    return n2;
+  }
+  function toLessThanHalfPi(Ctor, x2) {
+    var t2, isNeg = x2.s < 0, pi = getPi(Ctor, Ctor.precision, 1), halfPi = pi.times(0.5);
+    x2 = x2.abs();
+    if (x2.lte(halfPi)) {
+      quadrant = isNeg ? 4 : 1;
+      return x2;
+    }
+    t2 = x2.divToInt(pi);
+    if (t2.isZero()) {
+      quadrant = isNeg ? 3 : 2;
+    } else {
+      x2 = x2.minus(t2.times(pi));
+      if (x2.lte(halfPi)) {
+        quadrant = isOdd(t2) ? isNeg ? 2 : 3 : isNeg ? 4 : 1;
+        return x2;
+      }
+      quadrant = isOdd(t2) ? isNeg ? 1 : 4 : isNeg ? 3 : 2;
+    }
+    return x2.minus(pi).abs();
+  }
+  function toStringBinary(x2, baseOut, sd, rm) {
+    var base, e2, i2, k2, len, roundUp, str, xd, y2, Ctor = x2.constructor, isExp = sd !== void 0;
+    if (isExp) {
+      checkInt32(sd, 1, MAX_DIGITS);
+      if (rm === void 0)
+        rm = Ctor.rounding;
+      else
+        checkInt32(rm, 0, 8);
+    } else {
+      sd = Ctor.precision;
+      rm = Ctor.rounding;
+    }
+    if (!x2.isFinite()) {
+      str = nonFiniteToString(x2);
+    } else {
+      str = finiteToString(x2);
+      i2 = str.indexOf(".");
+      if (isExp) {
+        base = 2;
+        if (baseOut == 16) {
+          sd = sd * 4 - 3;
+        } else if (baseOut == 8) {
+          sd = sd * 3 - 2;
+        }
+      } else {
+        base = baseOut;
+      }
+      if (i2 >= 0) {
+        str = str.replace(".", "");
+        y2 = new Ctor(1);
+        y2.e = str.length - i2;
+        y2.d = convertBase(finiteToString(y2), 10, base);
+        y2.e = y2.d.length;
+      }
+      xd = convertBase(str, 10, base);
+      e2 = len = xd.length;
+      for (; xd[--len] == 0; )
+        xd.pop();
+      if (!xd[0]) {
+        str = isExp ? "0p+0" : "0";
+      } else {
+        if (i2 < 0) {
+          e2--;
+        } else {
+          x2 = new Ctor(x2);
+          x2.d = xd;
+          x2.e = e2;
+          x2 = divide(x2, y2, sd, rm, 0, base);
+          xd = x2.d;
+          e2 = x2.e;
+          roundUp = inexact;
+        }
+        i2 = xd[sd];
+        k2 = base / 2;
+        roundUp = roundUp || xd[sd + 1] !== void 0;
+        roundUp = rm < 4 ? (i2 !== void 0 || roundUp) && (rm === 0 || rm === (x2.s < 0 ? 3 : 2)) : i2 > k2 || i2 === k2 && (rm === 4 || roundUp || rm === 6 && xd[sd - 1] & 1 || rm === (x2.s < 0 ? 8 : 7));
+        xd.length = sd;
+        if (roundUp) {
+          for (; ++xd[--sd] > base - 1; ) {
+            xd[sd] = 0;
+            if (!sd) {
+              ++e2;
+              xd.unshift(1);
+            }
+          }
+        }
+        for (len = xd.length; !xd[len - 1]; --len)
+          ;
+        for (i2 = 0, str = ""; i2 < len; i2++)
+          str += NUMERALS.charAt(xd[i2]);
+        if (isExp) {
+          if (len > 1) {
+            if (baseOut == 16 || baseOut == 8) {
+              i2 = baseOut == 16 ? 4 : 3;
+              for (--len; len % i2; len++)
+                str += "0";
+              xd = convertBase(str, base, baseOut);
+              for (len = xd.length; !xd[len - 1]; --len)
+                ;
+              for (i2 = 1, str = "1."; i2 < len; i2++)
+                str += NUMERALS.charAt(xd[i2]);
+            } else {
+              str = str.charAt(0) + "." + str.slice(1);
+            }
+          }
+          str = str + (e2 < 0 ? "p" : "p+") + e2;
+        } else if (e2 < 0) {
+          for (; ++e2; )
+            str = "0" + str;
+          str = "0." + str;
+        } else {
+          if (++e2 > len)
+            for (e2 -= len; e2--; )
+              str += "0";
+          else if (e2 < len)
+            str = str.slice(0, e2) + "." + str.slice(e2);
+        }
+      }
+      str = (baseOut == 16 ? "0x" : baseOut == 2 ? "0b" : baseOut == 8 ? "0o" : "") + str;
+    }
+    return x2.s < 0 ? "-" + str : str;
+  }
+  function truncate(arr, len) {
+    if (arr.length > len) {
+      arr.length = len;
+      return true;
+    }
+  }
+  function abs(x2) {
+    return new this(x2).abs();
+  }
+  function acos(x2) {
+    return new this(x2).acos();
+  }
+  function acosh(x2) {
+    return new this(x2).acosh();
+  }
+  function add(x2, y2) {
+    return new this(x2).plus(y2);
+  }
+  function asin(x2) {
+    return new this(x2).asin();
+  }
+  function asinh(x2) {
+    return new this(x2).asinh();
+  }
+  function atan(x2) {
+    return new this(x2).atan();
+  }
+  function atanh(x2) {
+    return new this(x2).atanh();
+  }
+  function atan2(y2, x2) {
+    y2 = new this(y2);
+    x2 = new this(x2);
+    var r2, pr = this.precision, rm = this.rounding, wpr = pr + 4;
+    if (!y2.s || !x2.s) {
+      r2 = new this(NaN);
+    } else if (!y2.d && !x2.d) {
+      r2 = getPi(this, wpr, 1).times(x2.s > 0 ? 0.25 : 0.75);
+      r2.s = y2.s;
+    } else if (!x2.d || y2.isZero()) {
+      r2 = x2.s < 0 ? getPi(this, pr, rm) : new this(0);
+      r2.s = y2.s;
+    } else if (!y2.d || x2.isZero()) {
+      r2 = getPi(this, wpr, 1).times(0.5);
+      r2.s = y2.s;
+    } else if (x2.s < 0) {
+      this.precision = wpr;
+      this.rounding = 1;
+      r2 = this.atan(divide(y2, x2, wpr, 1));
+      x2 = getPi(this, wpr, 1);
+      this.precision = pr;
+      this.rounding = rm;
+      r2 = y2.s < 0 ? r2.minus(x2) : r2.plus(x2);
+    } else {
+      r2 = this.atan(divide(y2, x2, wpr, 1));
+    }
+    return r2;
+  }
+  function cbrt(x2) {
+    return new this(x2).cbrt();
+  }
+  function ceil(x2) {
+    return finalise(x2 = new this(x2), x2.e + 1, 2);
+  }
+  function clamp(x2, min2, max2) {
+    return new this(x2).clamp(min2, max2);
+  }
+  function config(obj) {
+    if (!obj || typeof obj !== "object")
+      throw Error(decimalError + "Object expected");
+    var i2, p2, v2, useDefaults = obj.defaults === true, ps = [
+      "precision",
+      1,
+      MAX_DIGITS,
+      "rounding",
+      0,
+      8,
+      "toExpNeg",
+      -EXP_LIMIT,
+      0,
+      "toExpPos",
+      0,
+      EXP_LIMIT,
+      "maxE",
+      0,
+      EXP_LIMIT,
+      "minE",
+      -EXP_LIMIT,
+      0,
+      "modulo",
+      0,
+      9
+    ];
+    for (i2 = 0; i2 < ps.length; i2 += 3) {
+      if (p2 = ps[i2], useDefaults)
+        this[p2] = DEFAULTS[p2];
+      if ((v2 = obj[p2]) !== void 0) {
+        if (mathfloor(v2) === v2 && v2 >= ps[i2 + 1] && v2 <= ps[i2 + 2])
+          this[p2] = v2;
+        else
+          throw Error(invalidArgument + p2 + ": " + v2);
+      }
+    }
+    if (p2 = "crypto", useDefaults)
+      this[p2] = DEFAULTS[p2];
+    if ((v2 = obj[p2]) !== void 0) {
+      if (v2 === true || v2 === false || v2 === 0 || v2 === 1) {
+        if (v2) {
+          if (typeof crypto != "undefined" && crypto && (crypto.getRandomValues || crypto.randomBytes)) {
+            this[p2] = true;
+          } else {
+            throw Error(cryptoUnavailable);
+          }
+        } else {
+          this[p2] = false;
+        }
+      } else {
+        throw Error(invalidArgument + p2 + ": " + v2);
+      }
+    }
+    return this;
+  }
+  function cos(x2) {
+    return new this(x2).cos();
+  }
+  function cosh(x2) {
+    return new this(x2).cosh();
+  }
+  function clone(obj) {
+    var i2, p2, ps;
+    function Decimal2(v2) {
+      var e2, i3, t2, x2 = this;
+      if (!(x2 instanceof Decimal2))
+        return new Decimal2(v2);
+      x2.constructor = Decimal2;
+      if (isDecimalInstance(v2)) {
+        x2.s = v2.s;
+        if (external) {
+          if (!v2.d || v2.e > Decimal2.maxE) {
+            x2.e = NaN;
+            x2.d = null;
+          } else if (v2.e < Decimal2.minE) {
+            x2.e = 0;
+            x2.d = [0];
+          } else {
+            x2.e = v2.e;
+            x2.d = v2.d.slice();
+          }
+        } else {
+          x2.e = v2.e;
+          x2.d = v2.d ? v2.d.slice() : v2.d;
+        }
+        return;
+      }
+      t2 = typeof v2;
+      if (t2 === "number") {
+        if (v2 === 0) {
+          x2.s = 1 / v2 < 0 ? -1 : 1;
+          x2.e = 0;
+          x2.d = [0];
+          return;
+        }
+        if (v2 < 0) {
+          v2 = -v2;
+          x2.s = -1;
+        } else {
+          x2.s = 1;
+        }
+        if (v2 === ~~v2 && v2 < 1e7) {
+          for (e2 = 0, i3 = v2; i3 >= 10; i3 /= 10)
+            e2++;
+          if (external) {
+            if (e2 > Decimal2.maxE) {
+              x2.e = NaN;
+              x2.d = null;
+            } else if (e2 < Decimal2.minE) {
+              x2.e = 0;
+              x2.d = [0];
+            } else {
+              x2.e = e2;
+              x2.d = [v2];
+            }
+          } else {
+            x2.e = e2;
+            x2.d = [v2];
+          }
+          return;
+        } else if (v2 * 0 !== 0) {
+          if (!v2)
+            x2.s = NaN;
+          x2.e = NaN;
+          x2.d = null;
+          return;
+        }
+        return parseDecimal(x2, v2.toString());
+      } else if (t2 !== "string") {
+        throw Error(invalidArgument + v2);
+      }
+      if ((i3 = v2.charCodeAt(0)) === 45) {
+        v2 = v2.slice(1);
+        x2.s = -1;
+      } else {
+        if (i3 === 43)
+          v2 = v2.slice(1);
+        x2.s = 1;
+      }
+      return isDecimal.test(v2) ? parseDecimal(x2, v2) : parseOther(x2, v2);
+    }
+    Decimal2.prototype = P;
+    Decimal2.ROUND_UP = 0;
+    Decimal2.ROUND_DOWN = 1;
+    Decimal2.ROUND_CEIL = 2;
+    Decimal2.ROUND_FLOOR = 3;
+    Decimal2.ROUND_HALF_UP = 4;
+    Decimal2.ROUND_HALF_DOWN = 5;
+    Decimal2.ROUND_HALF_EVEN = 6;
+    Decimal2.ROUND_HALF_CEIL = 7;
+    Decimal2.ROUND_HALF_FLOOR = 8;
+    Decimal2.EUCLID = 9;
+    Decimal2.config = Decimal2.set = config;
+    Decimal2.clone = clone;
+    Decimal2.isDecimal = isDecimalInstance;
+    Decimal2.abs = abs;
+    Decimal2.acos = acos;
+    Decimal2.acosh = acosh;
+    Decimal2.add = add;
+    Decimal2.asin = asin;
+    Decimal2.asinh = asinh;
+    Decimal2.atan = atan;
+    Decimal2.atanh = atanh;
+    Decimal2.atan2 = atan2;
+    Decimal2.cbrt = cbrt;
+    Decimal2.ceil = ceil;
+    Decimal2.clamp = clamp;
+    Decimal2.cos = cos;
+    Decimal2.cosh = cosh;
+    Decimal2.div = div;
+    Decimal2.exp = exp;
+    Decimal2.floor = floor;
+    Decimal2.hypot = hypot;
+    Decimal2.ln = ln;
+    Decimal2.log = log;
+    Decimal2.log10 = log10;
+    Decimal2.log2 = log2;
+    Decimal2.max = max;
+    Decimal2.min = min;
+    Decimal2.mod = mod;
+    Decimal2.mul = mul;
+    Decimal2.pow = pow;
+    Decimal2.random = random;
+    Decimal2.round = round;
+    Decimal2.sign = sign;
+    Decimal2.sin = sin;
+    Decimal2.sinh = sinh;
+    Decimal2.sqrt = sqrt;
+    Decimal2.sub = sub;
+    Decimal2.sum = sum;
+    Decimal2.tan = tan;
+    Decimal2.tanh = tanh;
+    Decimal2.trunc = trunc;
+    if (obj === void 0)
+      obj = {};
+    if (obj) {
+      if (obj.defaults !== true) {
+        ps = ["precision", "rounding", "toExpNeg", "toExpPos", "maxE", "minE", "modulo", "crypto"];
+        for (i2 = 0; i2 < ps.length; )
+          if (!obj.hasOwnProperty(p2 = ps[i2++]))
+            obj[p2] = this[p2];
+      }
+    }
+    Decimal2.config(obj);
+    return Decimal2;
+  }
+  function div(x2, y2) {
+    return new this(x2).div(y2);
+  }
+  function exp(x2) {
+    return new this(x2).exp();
+  }
+  function floor(x2) {
+    return finalise(x2 = new this(x2), x2.e + 1, 3);
+  }
+  function hypot() {
+    var i2, n2, t2 = new this(0);
+    external = false;
+    for (i2 = 0; i2 < arguments.length; ) {
+      n2 = new this(arguments[i2++]);
+      if (!n2.d) {
+        if (n2.s) {
+          external = true;
+          return new this(1 / 0);
+        }
+        t2 = n2;
+      } else if (t2.d) {
+        t2 = t2.plus(n2.times(n2));
+      }
+    }
+    external = true;
+    return t2.sqrt();
+  }
+  function isDecimalInstance(obj) {
+    return obj instanceof Decimal || obj && obj.toStringTag === tag || false;
+  }
+  function ln(x2) {
+    return new this(x2).ln();
+  }
+  function log(x2, y2) {
+    return new this(x2).log(y2);
+  }
+  function log2(x2) {
+    return new this(x2).log(2);
+  }
+  function log10(x2) {
+    return new this(x2).log(10);
+  }
+  function max() {
+    return maxOrMin(this, arguments, "lt");
+  }
+  function min() {
+    return maxOrMin(this, arguments, "gt");
+  }
+  function mod(x2, y2) {
+    return new this(x2).mod(y2);
+  }
+  function mul(x2, y2) {
+    return new this(x2).mul(y2);
+  }
+  function pow(x2, y2) {
+    return new this(x2).pow(y2);
+  }
+  function random(sd) {
+    var d2, e2, k2, n2, i2 = 0, r2 = new this(1), rd = [];
+    if (sd === void 0)
+      sd = this.precision;
+    else
+      checkInt32(sd, 1, MAX_DIGITS);
+    k2 = Math.ceil(sd / LOG_BASE);
+    if (!this.crypto) {
+      for (; i2 < k2; )
+        rd[i2++] = Math.random() * 1e7 | 0;
+    } else if (crypto.getRandomValues) {
+      d2 = crypto.getRandomValues(new Uint32Array(k2));
+      for (; i2 < k2; ) {
+        n2 = d2[i2];
+        if (n2 >= 429e7) {
+          d2[i2] = crypto.getRandomValues(new Uint32Array(1))[0];
+        } else {
+          rd[i2++] = n2 % 1e7;
+        }
+      }
+    } else if (crypto.randomBytes) {
+      d2 = crypto.randomBytes(k2 *= 4);
+      for (; i2 < k2; ) {
+        n2 = d2[i2] + (d2[i2 + 1] << 8) + (d2[i2 + 2] << 16) + ((d2[i2 + 3] & 127) << 24);
+        if (n2 >= 214e7) {
+          crypto.randomBytes(4).copy(d2, i2);
+        } else {
+          rd.push(n2 % 1e7);
+          i2 += 4;
+        }
+      }
+      i2 = k2 / 4;
+    } else {
+      throw Error(cryptoUnavailable);
+    }
+    k2 = rd[--i2];
+    sd %= LOG_BASE;
+    if (k2 && sd) {
+      n2 = mathpow(10, LOG_BASE - sd);
+      rd[i2] = (k2 / n2 | 0) * n2;
+    }
+    for (; rd[i2] === 0; i2--)
+      rd.pop();
+    if (i2 < 0) {
+      e2 = 0;
+      rd = [0];
+    } else {
+      e2 = -1;
+      for (; rd[0] === 0; e2 -= LOG_BASE)
+        rd.shift();
+      for (k2 = 1, n2 = rd[0]; n2 >= 10; n2 /= 10)
+        k2++;
+      if (k2 < LOG_BASE)
+        e2 -= LOG_BASE - k2;
+    }
+    r2.e = e2;
+    r2.d = rd;
+    return r2;
+  }
+  function round(x2) {
+    return finalise(x2 = new this(x2), x2.e + 1, this.rounding);
+  }
+  function sign(x2) {
+    x2 = new this(x2);
+    return x2.d ? x2.d[0] ? x2.s : 0 * x2.s : x2.s || NaN;
+  }
+  function sin(x2) {
+    return new this(x2).sin();
+  }
+  function sinh(x2) {
+    return new this(x2).sinh();
+  }
+  function sqrt(x2) {
+    return new this(x2).sqrt();
+  }
+  function sub(x2, y2) {
+    return new this(x2).sub(y2);
+  }
+  function sum() {
+    var i2 = 0, args = arguments, x2 = new this(args[i2]);
+    external = false;
+    for (; x2.s && ++i2 < args.length; )
+      x2 = x2.plus(args[i2]);
+    external = true;
+    return finalise(x2, this.precision, this.rounding);
+  }
+  function tan(x2) {
+    return new this(x2).tan();
+  }
+  function tanh(x2) {
+    return new this(x2).tanh();
+  }
+  function trunc(x2) {
+    return finalise(x2 = new this(x2), x2.e + 1, 1);
+  }
+  P[Symbol.for("nodejs.util.inspect.custom")] = P.toString;
+  P[Symbol.toStringTag] = "Decimal";
+  var Decimal = P.constructor = clone(DEFAULTS);
+  LN10 = new Decimal(LN10);
+  PI = new Decimal(PI);
+  const libJsDecimal = (num1, num2, operator, point = 2) => {
+    const calc = {
+      "+": (a2, b2) => a2.add(b2),
+      "-": (a2, b2) => a2.sub(b2),
+      "*": (a2, b2) => a2.mul(b2),
+      "/": (a2, b2) => {
+        if (b2.eq(0)) {
+          throw new Error("除数不能为0");
+        }
+        return a2.div(b2);
+      }
+    };
+    const result = calc[operator](new Decimal(num1), new Decimal(num2));
+    return Number(result.toFixed(point));
+  };
+  class LibPixiPuzzleBg extends Container {
+    constructor() {
+      super();
+      this.eventMode = "none";
+      const bg = new Sprite(Assets.get("preload/bg"));
+      this.addChild(bg);
+      bg.visible = false;
+      const config2 = JSON.parse(localStorage.getItem("puzzle_bg_config") || "{}");
+      const { alpha, x: x2, y: y2 } = config2;
+      bg.alpha = alpha || 0.25;
+      bg.position.set(x2 || 0, y2 || 0);
+      document.addEventListener("keydown", (e2) => {
+        if (e2.code === "Space") {
+          bg.visible = !bg.visible;
+        } else if (e2.code === "ArrowUp") {
+          bg.y -= 2;
+        } else if (e2.code === "ArrowDown") {
+          bg.y += 2;
+        } else if (e2.code === "ArrowLeft") {
+          bg.x -= 2;
+        } else if (e2.code === "ArrowRight") {
+          bg.x += 2;
+        }
+        if (e2.code === "NumpadAdd" && bg.alpha < 1) {
+          bg.alpha = libJsDecimal(bg.alpha, 0.1, "+");
+        } else if (e2.code === "NumpadSubtract" && bg.alpha > 0) {
+          bg.alpha = libJsDecimal(bg.alpha, 0.1, "-");
+        }
+        localStorage.setItem("puzzle_bg_config", JSON.stringify({ alpha: bg.alpha, x: bg.x, y: bg.y }));
+      });
+    }
+  }
   const Components = {
     Base: {
       /** @description 自定义位图文本
@@ -55514,7 +57889,11 @@ void main(void){
       /** @description 自适应宽度的标签和值组件
        * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiLabelValue-标签值
        */
-      LibPixiLabelValue
+      LibPixiLabelValue,
+      /** @description 设计图背景拼接
+       * @link 使用方法：https://www.npmjs.com/package/lyb-pixi-js#LibPixiPuzzleBg-设计图背景拼接
+       */
+      LibPixiPuzzleBg
     }
   };
   const Utils = {