@fecp/mobile 1.0.78 → 1.1.0

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/core/curve.js

@@ -0,0 +1,344 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const vector = require("./vector.js");
+var mathPow = Math.pow;
+var mathSqrt = Math.sqrt;
+var EPSILON = 1e-8;
+var EPSILON_NUMERIC = 1e-4;
+var THREE_SQRT = mathSqrt(3);
+var ONE_THIRD = 1 / 3;
+var _v0 = vector.create();
+var _v1 = vector.create();
+var _v2 = vector.create();
+function isAroundZero(val) {
+  return val > -1e-8 && val < EPSILON;
+}
+function isNotAroundZero(val) {
+  return val > EPSILON || val < -1e-8;
+}
+function cubicAt(p0, p1, p2, p3, t) {
+  var onet = 1 - t;
+  return onet * onet * (onet * p0 + 3 * t * p1) + t * t * (t * p3 + 3 * onet * p2);
+}
+function cubicDerivativeAt(p0, p1, p2, p3, t) {
+  var onet = 1 - t;
+  return 3 * (((p1 - p0) * onet + 2 * (p2 - p1) * t) * onet + (p3 - p2) * t * t);
+}
+function cubicRootAt(p0, p1, p2, p3, val, roots) {
+  var a = p3 + 3 * (p1 - p2) - p0;
+  var b = 3 * (p2 - p1 * 2 + p0);
+  var c = 3 * (p1 - p0);
+  var d = p0 - val;
+  var A = b * b - 3 * a * c;
+  var B = b * c - 9 * a * d;
+  var C = c * c - 3 * b * d;
+  var n = 0;
+  if (isAroundZero(A) && isAroundZero(B)) {
+    if (isAroundZero(b)) {
+      roots[0] = 0;
+    } else {
+      var t1 = -c / b;
+      if (t1 >= 0 && t1 <= 1) {
+        roots[n++] = t1;
+      }
+    }
+  } else {
+    var disc = B * B - 4 * A * C;
+    if (isAroundZero(disc)) {
+      var K = B / A;
+      var t1 = -b / a + K;
+      var t2 = -K / 2;
+      if (t1 >= 0 && t1 <= 1) {
+        roots[n++] = t1;
+      }
+      if (t2 >= 0 && t2 <= 1) {
+        roots[n++] = t2;
+      }
+    } else if (disc > 0) {
+      var discSqrt = mathSqrt(disc);
+      var Y1 = A * b + 1.5 * a * (-B + discSqrt);
+      var Y2 = A * b + 1.5 * a * (-B - discSqrt);
+      if (Y1 < 0) {
+        Y1 = -mathPow(-Y1, ONE_THIRD);
+      } else {
+        Y1 = mathPow(Y1, ONE_THIRD);
+      }
+      if (Y2 < 0) {
+        Y2 = -mathPow(-Y2, ONE_THIRD);
+      } else {
+        Y2 = mathPow(Y2, ONE_THIRD);
+      }
+      var t1 = (-b - (Y1 + Y2)) / (3 * a);
+      if (t1 >= 0 && t1 <= 1) {
+        roots[n++] = t1;
+      }
+    } else {
+      var T = (2 * A * b - 3 * a * B) / (2 * mathSqrt(A * A * A));
+      var theta = Math.acos(T) / 3;
+      var ASqrt = mathSqrt(A);
+      var tmp = Math.cos(theta);
+      var t1 = (-b - 2 * ASqrt * tmp) / (3 * a);
+      var t2 = (-b + ASqrt * (tmp + THREE_SQRT * Math.sin(theta))) / (3 * a);
+      var t3 = (-b + ASqrt * (tmp - THREE_SQRT * Math.sin(theta))) / (3 * a);
+      if (t1 >= 0 && t1 <= 1) {
+        roots[n++] = t1;
+      }
+      if (t2 >= 0 && t2 <= 1) {
+        roots[n++] = t2;
+      }
+      if (t3 >= 0 && t3 <= 1) {
+        roots[n++] = t3;
+      }
+    }
+  }
+  return n;
+}
+function cubicExtrema(p0, p1, p2, p3, extrema) {
+  var b = 6 * p2 - 12 * p1 + 6 * p0;
+  var a = 9 * p1 + 3 * p3 - 3 * p0 - 9 * p2;
+  var c = 3 * p1 - 3 * p0;
+  var n = 0;
+  if (isAroundZero(a)) {
+    if (isNotAroundZero(b)) {
+      var t1 = -c / b;
+      if (t1 >= 0 && t1 <= 1) {
+        extrema[n++] = t1;
+      }
+    }
+  } else {
+    var disc = b * b - 4 * a * c;
+    if (isAroundZero(disc)) {
+      extrema[0] = -b / (2 * a);
+    } else if (disc > 0) {
+      var discSqrt = mathSqrt(disc);
+      var t1 = (-b + discSqrt) / (2 * a);
+      var t2 = (-b - discSqrt) / (2 * a);
+      if (t1 >= 0 && t1 <= 1) {
+        extrema[n++] = t1;
+      }
+      if (t2 >= 0 && t2 <= 1) {
+        extrema[n++] = t2;
+      }
+    }
+  }
+  return n;
+}
+function cubicSubdivide(p0, p1, p2, p3, t, out) {
+  var p01 = (p1 - p0) * t + p0;
+  var p12 = (p2 - p1) * t + p1;
+  var p23 = (p3 - p2) * t + p2;
+  var p012 = (p12 - p01) * t + p01;
+  var p123 = (p23 - p12) * t + p12;
+  var p0123 = (p123 - p012) * t + p012;
+  out[0] = p0;
+  out[1] = p01;
+  out[2] = p012;
+  out[3] = p0123;
+  out[4] = p0123;
+  out[5] = p123;
+  out[6] = p23;
+  out[7] = p3;
+}
+function cubicProjectPoint(x0, y0, x1, y1, x2, y2, x3, y3, x, y, out) {
+  var t;
+  var interval = 5e-3;
+  var d = Infinity;
+  var prev;
+  var next;
+  var d1;
+  var d2;
+  _v0[0] = x;
+  _v0[1] = y;
+  for (var _t = 0; _t < 1; _t += 0.05) {
+    _v1[0] = cubicAt(x0, x1, x2, x3, _t);
+    _v1[1] = cubicAt(y0, y1, y2, y3, _t);
+    d1 = vector.distSquare(_v0, _v1);
+    if (d1 < d) {
+      t = _t;
+      d = d1;
+    }
+  }
+  d = Infinity;
+  for (var i = 0; i < 32; i++) {
+    if (interval < EPSILON_NUMERIC) {
+      break;
+    }
+    prev = t - interval;
+    next = t + interval;
+    _v1[0] = cubicAt(x0, x1, x2, x3, prev);
+    _v1[1] = cubicAt(y0, y1, y2, y3, prev);
+    d1 = vector.distSquare(_v1, _v0);
+    if (prev >= 0 && d1 < d) {
+      t = prev;
+      d = d1;
+    } else {
+      _v2[0] = cubicAt(x0, x1, x2, x3, next);
+      _v2[1] = cubicAt(y0, y1, y2, y3, next);
+      d2 = vector.distSquare(_v2, _v0);
+      if (next <= 1 && d2 < d) {
+        t = next;
+        d = d2;
+      } else {
+        interval *= 0.5;
+      }
+    }
+  }
+  if (out) {
+    out[0] = cubicAt(x0, x1, x2, x3, t);
+    out[1] = cubicAt(y0, y1, y2, y3, t);
+  }
+  return mathSqrt(d);
+}
+function cubicLength(x0, y0, x1, y1, x2, y2, x3, y3, iteration) {
+  var px = x0;
+  var py = y0;
+  var d = 0;
+  var step = 1 / iteration;
+  for (var i = 1; i <= iteration; i++) {
+    var t = i * step;
+    var x = cubicAt(x0, x1, x2, x3, t);
+    var y = cubicAt(y0, y1, y2, y3, t);
+    var dx = x - px;
+    var dy = y - py;
+    d += Math.sqrt(dx * dx + dy * dy);
+    px = x;
+    py = y;
+  }
+  return d;
+}
+function quadraticAt(p0, p1, p2, t) {
+  var onet = 1 - t;
+  return onet * (onet * p0 + 2 * t * p1) + t * t * p2;
+}
+function quadraticDerivativeAt(p0, p1, p2, t) {
+  return 2 * ((1 - t) * (p1 - p0) + t * (p2 - p1));
+}
+function quadraticRootAt(p0, p1, p2, val, roots) {
+  var a = p0 - 2 * p1 + p2;
+  var b = 2 * (p1 - p0);
+  var c = p0 - val;
+  var n = 0;
+  if (isAroundZero(a)) {
+    if (isNotAroundZero(b)) {
+      var t1 = -c / b;
+      if (t1 >= 0 && t1 <= 1) {
+        roots[n++] = t1;
+      }
+    }
+  } else {
+    var disc = b * b - 4 * a * c;
+    if (isAroundZero(disc)) {
+      var t1 = -b / (2 * a);
+      if (t1 >= 0 && t1 <= 1) {
+        roots[n++] = t1;
+      }
+    } else if (disc > 0) {
+      var discSqrt = mathSqrt(disc);
+      var t1 = (-b + discSqrt) / (2 * a);
+      var t2 = (-b - discSqrt) / (2 * a);
+      if (t1 >= 0 && t1 <= 1) {
+        roots[n++] = t1;
+      }
+      if (t2 >= 0 && t2 <= 1) {
+        roots[n++] = t2;
+      }
+    }
+  }
+  return n;
+}
+function quadraticExtremum(p0, p1, p2) {
+  var divider = p0 + p2 - 2 * p1;
+  if (divider === 0) {
+    return 0.5;
+  } else {
+    return (p0 - p1) / divider;
+  }
+}
+function quadraticSubdivide(p0, p1, p2, t, out) {
+  var p01 = (p1 - p0) * t + p0;
+  var p12 = (p2 - p1) * t + p1;
+  var p012 = (p12 - p01) * t + p01;
+  out[0] = p0;
+  out[1] = p01;
+  out[2] = p012;
+  out[3] = p012;
+  out[4] = p12;
+  out[5] = p2;
+}
+function quadraticProjectPoint(x0, y0, x1, y1, x2, y2, x, y, out) {
+  var t;
+  var interval = 5e-3;
+  var d = Infinity;
+  _v0[0] = x;
+  _v0[1] = y;
+  for (var _t = 0; _t < 1; _t += 0.05) {
+    _v1[0] = quadraticAt(x0, x1, x2, _t);
+    _v1[1] = quadraticAt(y0, y1, y2, _t);
+    var d1 = vector.distSquare(_v0, _v1);
+    if (d1 < d) {
+      t = _t;
+      d = d1;
+    }
+  }
+  d = Infinity;
+  for (var i = 0; i < 32; i++) {
+    if (interval < EPSILON_NUMERIC) {
+      break;
+    }
+    var prev = t - interval;
+    var next = t + interval;
+    _v1[0] = quadraticAt(x0, x1, x2, prev);
+    _v1[1] = quadraticAt(y0, y1, y2, prev);
+    var d1 = vector.distSquare(_v1, _v0);
+    if (prev >= 0 && d1 < d) {
+      t = prev;
+      d = d1;
+    } else {
+      _v2[0] = quadraticAt(x0, x1, x2, next);
+      _v2[1] = quadraticAt(y0, y1, y2, next);
+      var d2 = vector.distSquare(_v2, _v0);
+      if (next <= 1 && d2 < d) {
+        t = next;
+        d = d2;
+      } else {
+        interval *= 0.5;
+      }
+    }
+  }
+  if (out) {
+    out[0] = quadraticAt(x0, x1, x2, t);
+    out[1] = quadraticAt(y0, y1, y2, t);
+  }
+  return mathSqrt(d);
+}
+function quadraticLength(x0, y0, x1, y1, x2, y2, iteration) {
+  var px = x0;
+  var py = y0;
+  var d = 0;
+  var step = 1 / iteration;
+  for (var i = 1; i <= iteration; i++) {
+    var t = i * step;
+    var x = quadraticAt(x0, x1, x2, t);
+    var y = quadraticAt(y0, y1, y2, t);
+    var dx = x - px;
+    var dy = y - py;
+    d += Math.sqrt(dx * dx + dy * dy);
+    px = x;
+    py = y;
+  }
+  return d;
+}
+exports.cubicAt = cubicAt;
+exports.cubicDerivativeAt = cubicDerivativeAt;
+exports.cubicExtrema = cubicExtrema;
+exports.cubicLength = cubicLength;
+exports.cubicProjectPoint = cubicProjectPoint;
+exports.cubicRootAt = cubicRootAt;
+exports.cubicSubdivide = cubicSubdivide;
+exports.quadraticAt = quadraticAt;
+exports.quadraticDerivativeAt = quadraticDerivativeAt;
+exports.quadraticExtremum = quadraticExtremum;
+exports.quadraticLength = quadraticLength;
+exports.quadraticProjectPoint = quadraticProjectPoint;
+exports.quadraticRootAt = quadraticRootAt;
+exports.quadraticSubdivide = quadraticSubdivide;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/core/dom.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const env = require("./env.js");
+const fourPointsTransform = require("./fourPointsTransform.js");
+var EVENT_SAVED_PROP = "___zrEVENTSAVED";
+var _calcOut = [];
+function transformLocalCoord(out, elFrom, elTarget, inX, inY) {
+  return transformCoordWithViewport(_calcOut, elFrom, inX, inY, true) && transformCoordWithViewport(out, elTarget, _calcOut[0], _calcOut[1]);
+}
+function transformCoordWithViewport(out, el, inX, inY, inverse) {
+  if (el.getBoundingClientRect && env.default.domSupported && !isCanvasEl(el)) {
+    var saved = el[EVENT_SAVED_PROP] || (el[EVENT_SAVED_PROP] = {});
+    var markers = prepareCoordMarkers(el, saved);
+    var transformer = preparePointerTransformer(markers, saved, inverse);
+    if (transformer) {
+      transformer(out, inX, inY);
+      return true;
+    }
+  }
+  return false;
+}
+function prepareCoordMarkers(el, saved) {
+  var markers = saved.markers;
+  if (markers) {
+    return markers;
+  }
+  markers = saved.markers = [];
+  var propLR = ["left", "right"];
+  var propTB = ["top", "bottom"];
+  for (var i = 0; i < 4; i++) {
+    var marker = document.createElement("div");
+    var stl = marker.style;
+    var idxLR = i % 2;
+    var idxTB = (i >> 1) % 2;
+    stl.cssText = [
+      "position: absolute",
+      "visibility: hidden",
+      "padding: 0",
+      "margin: 0",
+      "border-width: 0",
+      "user-select: none",
+      "width:0",
+      "height:0",
+      propLR[idxLR] + ":0",
+      propTB[idxTB] + ":0",
+      propLR[1 - idxLR] + ":auto",
+      propTB[1 - idxTB] + ":auto",
+      ""
+    ].join("!important;");
+    el.appendChild(marker);
+    markers.push(marker);
+  }
+  return markers;
+}
+function preparePointerTransformer(markers, saved, inverse) {
+  var transformerName = inverse ? "invTrans" : "trans";
+  var transformer = saved[transformerName];
+  var oldSrcCoords = saved.srcCoords;
+  var srcCoords = [];
+  var destCoords = [];
+  var oldCoordTheSame = true;
+  for (var i = 0; i < 4; i++) {
+    var rect = markers[i].getBoundingClientRect();
+    var ii = 2 * i;
+    var x = rect.left;
+    var y = rect.top;
+    srcCoords.push(x, y);
+    oldCoordTheSame = oldCoordTheSame && oldSrcCoords && x === oldSrcCoords[ii] && y === oldSrcCoords[ii + 1];
+    destCoords.push(markers[i].offsetLeft, markers[i].offsetTop);
+  }
+  return oldCoordTheSame && transformer ? transformer : (saved.srcCoords = srcCoords, saved[transformerName] = inverse ? fourPointsTransform.buildTransformer(destCoords, srcCoords) : fourPointsTransform.buildTransformer(srcCoords, destCoords));
+}
+function isCanvasEl(el) {
+  return el.nodeName.toUpperCase() === "CANVAS";
+}
+var replaceReg = /([&<>"'])/g;
+var replaceMap = {
+  "&": "&amp;",
+  "<": "&lt;",
+  ">": "&gt;",
+  '"': "&quot;",
+  "'": "&#39;"
+};
+function encodeHTML(source) {
+  return source == null ? "" : (source + "").replace(replaceReg, function(str, c) {
+    return replaceMap[c];
+  });
+}
+exports.encodeHTML = encodeHTML;
+exports.isCanvasEl = isCanvasEl;
+exports.transformCoordWithViewport = transformCoordWithViewport;
+exports.transformLocalCoord = transformLocalCoord;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/core/env.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+var Browser = /* @__PURE__ */ function() {
+  function Browser2() {
+    this.firefox = false;
+    this.ie = false;
+    this.edge = false;
+    this.newEdge = false;
+    this.weChat = false;
+  }
+  return Browser2;
+}();
+var Env = /* @__PURE__ */ function() {
+  function Env2() {
+    this.browser = new Browser();
+    this.node = false;
+    this.wxa = false;
+    this.worker = false;
+    this.svgSupported = false;
+    this.touchEventsSupported = false;
+    this.pointerEventsSupported = false;
+    this.domSupported = false;
+    this.transformSupported = false;
+    this.transform3dSupported = false;
+    this.hasGlobalWindow = typeof window !== "undefined";
+  }
+  return Env2;
+}();
+var env = new Env();
+if (typeof wx === "object" && typeof wx.getSystemInfoSync === "function") {
+  env.wxa = true;
+  env.touchEventsSupported = true;
+} else if (typeof document === "undefined" && typeof self !== "undefined") {
+  env.worker = true;
+} else if (!env.hasGlobalWindow || "Deno" in window) {
+  env.node = true;
+  env.svgSupported = true;
+} else {
+  detect(navigator.userAgent, env);
+}
+function detect(ua, env2) {
+  var browser = env2.browser;
+  var firefox = ua.match(/Firefox\/([\d.]+)/);
+  var ie = ua.match(/MSIE\s([\d.]+)/) || ua.match(/Trident\/.+?rv:(([\d.]+))/);
+  var edge = ua.match(/Edge?\/([\d.]+)/);
+  var weChat = /micromessenger/i.test(ua);
+  if (firefox) {
+    browser.firefox = true;
+    browser.version = firefox[1];
+  }
+  if (ie) {
+    browser.ie = true;
+    browser.version = ie[1];
+  }
+  if (edge) {
+    browser.edge = true;
+    browser.version = edge[1];
+    browser.newEdge = +edge[1].split(".")[0] > 18;
+  }
+  if (weChat) {
+    browser.weChat = true;
+  }
+  env2.svgSupported = typeof SVGRect !== "undefined";
+  env2.touchEventsSupported = "ontouchstart" in window && !browser.ie && !browser.edge;
+  env2.pointerEventsSupported = "onpointerdown" in window && (browser.edge || browser.ie && +browser.version >= 11);
+  env2.domSupported = typeof document !== "undefined";
+  var style = document.documentElement.style;
+  env2.transform3dSupported = (browser.ie && "transition" in style || browser.edge || "WebKitCSSMatrix" in window && "m11" in new WebKitCSSMatrix() || "MozPerspective" in style) && !("OTransition" in style);
+  env2.transformSupported = env2.transform3dSupported || browser.ie && +browser.version >= 9;
+}
+exports.default = env;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/core/event.js

@@ -0,0 +1,100 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const env = require("./env.js");
+const dom = require("./dom.js");
+var MOUSE_EVENT_REG = /^(?:mouse|pointer|contextmenu|drag|drop)|click/;
+var _calcOut = [];
+var firefoxNotSupportOffsetXY = env.default.browser.firefox && +env.default.browser.version.split(".")[0] < 39;
+function clientToLocal(el, e, out, calculate) {
+  out = out || {};
+  if (calculate) {
+    calculateZrXY(el, e, out);
+  } else if (firefoxNotSupportOffsetXY && e.layerX != null && e.layerX !== e.offsetX) {
+    out.zrX = e.layerX;
+    out.zrY = e.layerY;
+  } else if (e.offsetX != null) {
+    out.zrX = e.offsetX;
+    out.zrY = e.offsetY;
+  } else {
+    calculateZrXY(el, e, out);
+  }
+  return out;
+}
+function calculateZrXY(el, e, out) {
+  if (env.default.domSupported && el.getBoundingClientRect) {
+    var ex = e.clientX;
+    var ey = e.clientY;
+    if (dom.isCanvasEl(el)) {
+      var box = el.getBoundingClientRect();
+      out.zrX = ex - box.left;
+      out.zrY = ey - box.top;
+      return;
+    } else {
+      if (dom.transformCoordWithViewport(_calcOut, el, ex, ey)) {
+        out.zrX = _calcOut[0];
+        out.zrY = _calcOut[1];
+        return;
+      }
+    }
+  }
+  out.zrX = out.zrY = 0;
+}
+function getNativeEvent(e) {
+  return e || window.event;
+}
+function normalizeEvent(el, e, calculate) {
+  e = getNativeEvent(e);
+  if (e.zrX != null) {
+    return e;
+  }
+  var eventType = e.type;
+  var isTouch = eventType && eventType.indexOf("touch") >= 0;
+  if (!isTouch) {
+    clientToLocal(el, e, e, calculate);
+    var wheelDelta = getWheelDeltaMayPolyfill(e);
+    e.zrDelta = wheelDelta ? wheelDelta / 120 : -(e.detail || 0) / 3;
+  } else {
+    var touch = eventType !== "touchend" ? e.targetTouches[0] : e.changedTouches[0];
+    touch && clientToLocal(el, touch, e, calculate);
+  }
+  var button = e.button;
+  if (e.which == null && button !== void 0 && MOUSE_EVENT_REG.test(e.type)) {
+    e.which = button & 1 ? 1 : button & 2 ? 3 : button & 4 ? 2 : 0;
+  }
+  return e;
+}
+function getWheelDeltaMayPolyfill(e) {
+  var rawWheelDelta = e.wheelDelta;
+  if (rawWheelDelta) {
+    return rawWheelDelta;
+  }
+  var deltaX = e.deltaX;
+  var deltaY = e.deltaY;
+  if (deltaX == null || deltaY == null) {
+    return rawWheelDelta;
+  }
+  var delta = deltaY !== 0 ? Math.abs(deltaY) : Math.abs(deltaX);
+  var sign = deltaY > 0 ? -1 : deltaY < 0 ? 1 : deltaX > 0 ? -1 : 1;
+  return 3 * delta * sign;
+}
+function addEventListener(el, name, handler, opt) {
+  el.addEventListener(name, handler, opt);
+}
+function removeEventListener(el, name, handler, opt) {
+  el.removeEventListener(name, handler, opt);
+}
+var stop = function(e) {
+  e.preventDefault();
+  e.stopPropagation();
+  e.cancelBubble = true;
+};
+function isMiddleOrRightButtonOnMouseUpDown(e) {
+  return e.which === 2 || e.which === 3;
+}
+exports.addEventListener = addEventListener;
+exports.clientToLocal = clientToLocal;
+exports.getNativeEvent = getNativeEvent;
+exports.isMiddleOrRightButtonOnMouseUpDown = isMiddleOrRightButtonOnMouseUpDown;
+exports.normalizeEvent = normalizeEvent;
+exports.removeEventListener = removeEventListener;
+exports.stop = stop;

package/lib/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/core/fourPointsTransform.js

@@ -0,0 +1,59 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+var LN2 = Math.log(2);
+function determinant(rows, rank, rowStart, rowMask, colMask, detCache) {
+  var cacheKey = rowMask + "-" + colMask;
+  var fullRank = rows.length;
+  if (detCache.hasOwnProperty(cacheKey)) {
+    return detCache[cacheKey];
+  }
+  if (rank === 1) {
+    var colStart = Math.round(Math.log((1 << fullRank) - 1 & ~colMask) / LN2);
+    return rows[rowStart][colStart];
+  }
+  var subRowMask = rowMask | 1 << rowStart;
+  var subRowStart = rowStart + 1;
+  while (rowMask & 1 << subRowStart) {
+    subRowStart++;
+  }
+  var sum = 0;
+  for (var j = 0, colLocalIdx = 0; j < fullRank; j++) {
+    var colTag = 1 << j;
+    if (!(colTag & colMask)) {
+      sum += (colLocalIdx % 2 ? -1 : 1) * rows[rowStart][j] * determinant(rows, rank - 1, subRowStart, subRowMask, colMask | colTag, detCache);
+      colLocalIdx++;
+    }
+  }
+  detCache[cacheKey] = sum;
+  return sum;
+}
+function buildTransformer(src, dest) {
+  var mA = [
+    [src[0], src[1], 1, 0, 0, 0, -dest[0] * src[0], -dest[0] * src[1]],
+    [0, 0, 0, src[0], src[1], 1, -dest[1] * src[0], -dest[1] * src[1]],
+    [src[2], src[3], 1, 0, 0, 0, -dest[2] * src[2], -dest[2] * src[3]],
+    [0, 0, 0, src[2], src[3], 1, -dest[3] * src[2], -dest[3] * src[3]],
+    [src[4], src[5], 1, 0, 0, 0, -dest[4] * src[4], -dest[4] * src[5]],
+    [0, 0, 0, src[4], src[5], 1, -dest[5] * src[4], -dest[5] * src[5]],
+    [src[6], src[7], 1, 0, 0, 0, -dest[6] * src[6], -dest[6] * src[7]],
+    [0, 0, 0, src[6], src[7], 1, -dest[7] * src[6], -dest[7] * src[7]]
+  ];
+  var detCache = {};
+  var det = determinant(mA, 8, 0, 0, 0, detCache);
+  if (det === 0) {
+    return;
+  }
+  var vh = [];
+  for (var i = 0; i < 8; i++) {
+    for (var j = 0; j < 8; j++) {
+      vh[j] == null && (vh[j] = 0);
+      vh[j] += ((i + j) % 2 ? -1 : 1) * determinant(mA, 7, i === 0 ? 1 : 0, 1 << i, 1 << j, detCache) / det * dest[i];
+    }
+  }
+  return function(out, srcPointX, srcPointY) {
+    var pk = srcPointX * vh[6] + srcPointY * vh[7] + 1;
+    out[0] = (srcPointX * vh[0] + srcPointY * vh[1] + vh[2]) / pk;
+    out[1] = (srcPointX * vh[3] + srcPointY * vh[4] + vh[5]) / pk;
+  };
+}
+exports.buildTransformer = buildTransformer;