sun-card-design 1.1.31 → 1.1.32

package/dist/pc/sun-card-design-pc.es2122.js

@@ -1,254 +1,589 @@
-import { isString, isFunction, extend, defaults, isArray, isNumber } from "./sun-card-design-pc.es932.js";
-import { parseDate } from "./sun-card-design-pc.es1982.js";
-import { getLocaleModel, getDefaultLocaleModel, SYSTEM_LANG } from "./sun-card-design-pc.es1839.js";
-import Model from "./sun-card-design-pc.es1853.js";
-var ONE_SECOND = 1e3;
-var ONE_MINUTE = ONE_SECOND * 60;
-var ONE_HOUR = ONE_MINUTE * 60;
-var ONE_DAY = ONE_HOUR * 24;
-var ONE_YEAR = ONE_DAY * 365;
-var defaultLeveledFormatter = {
-  year: "{yyyy}",
-  month: "{MMM}",
-  day: "{d}",
-  hour: "{HH}:{mm}",
-  minute: "{HH}:{mm}",
-  second: "{HH}:{mm}:{ss}",
-  millisecond: "{HH}:{mm}:{ss} {SSS}",
-  none: "{yyyy}-{MM}-{dd} {HH}:{mm}:{ss} {SSS}"
-};
-var fullDayFormatter = "{yyyy}-{MM}-{dd}";
-var fullLeveledFormatter = {
-  year: "{yyyy}",
-  month: "{yyyy}-{MM}",
-  day: fullDayFormatter,
-  hour: fullDayFormatter + " " + defaultLeveledFormatter.hour,
-  minute: fullDayFormatter + " " + defaultLeveledFormatter.minute,
-  second: fullDayFormatter + " " + defaultLeveledFormatter.second,
-  millisecond: defaultLeveledFormatter.none
-};
-var primaryTimeUnits = ["year", "month", "day", "hour", "minute", "second", "millisecond"];
-var timeUnits = ["year", "half-year", "quarter", "month", "week", "half-week", "day", "half-day", "quarter-day", "hour", "minute", "second", "millisecond"];
-function pad(str, len) {
-  str += "";
-  return "0000".substr(0, len - str.length) + str;
-}
-function getPrimaryTimeUnit(timeUnit) {
-  switch (timeUnit) {
-    case "half-year":
-    case "quarter":
-      return "month";
-    case "week":
-    case "half-week":
-      return "day";
-    case "half-day":
-    case "quarter-day":
-      return "hour";
-    default:
-      return timeUnit;
-  }
-}
-function isPrimaryTimeUnit(timeUnit) {
-  return timeUnit === getPrimaryTimeUnit(timeUnit);
-}
-function getDefaultFormatPrecisionOfInterval(timeUnit) {
-  switch (timeUnit) {
-    case "year":
-    case "month":
-      return "day";
-    case "millisecond":
-      return "millisecond";
-    default:
-      return "second";
-  }
-}
-function format(time, template, isUTC, lang) {
-  var date = parseDate(time);
-  var y = date[fullYearGetterName(isUTC)]();
-  var M = date[monthGetterName(isUTC)]() + 1;
-  var q = Math.floor((M - 1) / 3) + 1;
-  var d = date[dateGetterName(isUTC)]();
-  var e = date["get" + (isUTC ? "UTC" : "") + "Day"]();
-  var H = date[hoursGetterName(isUTC)]();
-  var h = (H - 1) % 12 + 1;
-  var m = date[minutesGetterName(isUTC)]();
-  var s = date[secondsGetterName(isUTC)]();
-  var S = date[millisecondsGetterName(isUTC)]();
-  var a = H >= 12 ? "pm" : "am";
-  var A = a.toUpperCase();
-  var localeModel = lang instanceof Model ? lang : getLocaleModel(lang || SYSTEM_LANG) || getDefaultLocaleModel();
-  var timeModel = localeModel.getModel("time");
-  var month = timeModel.get("month");
-  var monthAbbr = timeModel.get("monthAbbr");
-  var dayOfWeek = timeModel.get("dayOfWeek");
-  var dayOfWeekAbbr = timeModel.get("dayOfWeekAbbr");
-  return (template || "").replace(/{a}/g, a + "").replace(/{A}/g, A + "").replace(/{yyyy}/g, y + "").replace(/{yy}/g, pad(y % 100 + "", 2)).replace(/{Q}/g, q + "").replace(/{MMMM}/g, month[M - 1]).replace(/{MMM}/g, monthAbbr[M - 1]).replace(/{MM}/g, pad(M, 2)).replace(/{M}/g, M + "").replace(/{dd}/g, pad(d, 2)).replace(/{d}/g, d + "").replace(/{eeee}/g, dayOfWeek[e]).replace(/{ee}/g, dayOfWeekAbbr[e]).replace(/{e}/g, e + "").replace(/{HH}/g, pad(H, 2)).replace(/{H}/g, H + "").replace(/{hh}/g, pad(h + "", 2)).replace(/{h}/g, h + "").replace(/{mm}/g, pad(m, 2)).replace(/{m}/g, m + "").replace(/{ss}/g, pad(s, 2)).replace(/{s}/g, s + "").replace(/{SSS}/g, pad(S, 3)).replace(/{S}/g, S + "");
-}
-function leveledFormat(tick, idx, formatter, lang, isUTC) {
-  var template = null;
-  if (isString(formatter)) {
-    template = formatter;
-  } else if (isFunction(formatter)) {
-    template = formatter(tick.value, idx, {
-      level: tick.level
-    });
-  } else {
-    var defaults$1 = extend({}, defaultLeveledFormatter);
-    if (tick.level > 0) {
-      for (var i = 0; i < primaryTimeUnits.length; ++i) {
-        defaults$1[primaryTimeUnits[i]] = "{primary|" + defaults$1[primaryTimeUnits[i]] + "}";
-      }
+import { cubicSubdivide } from "./sun-card-design-pc.es2167.js";
+import Path from "./sun-card-design-pc.es1758.js";
+import { defaults, map } from "./sun-card-design-pc.es930.js";
+import { lerp } from "./sun-card-design-pc.es1973.js";
+import { clonePath } from "./sun-card-design-pc.es1971.js";
+import Transformable from "./sun-card-design-pc.es1974.js";
+import { split } from "./sun-card-design-pc.es2196.js";
+import { pathToBezierCurves } from "./sun-card-design-pc.es2197.js";
+function alignSubpath(subpath1, subpath2) {
+  var len1 = subpath1.length;
+  var len2 = subpath2.length;
+  if (len1 === len2) {
+    return [subpath1, subpath2];
+  }
+  var tmpSegX = [];
+  var tmpSegY = [];
+  var shorterPath = len1 < len2 ? subpath1 : subpath2;
+  var shorterLen = Math.min(len1, len2);
+  var diff = Math.abs(len2 - len1) / 6;
+  var shorterBezierCount = (shorterLen - 2) / 6;
+  var eachCurveSubDivCount = Math.ceil(diff / shorterBezierCount) + 1;
+  var newSubpath = [shorterPath[0], shorterPath[1]];
+  var remained = diff;
+  for (var i = 2; i < shorterLen; ) {
+    var x0 = shorterPath[i - 2];
+    var y0 = shorterPath[i - 1];
+    var x1 = shorterPath[i++];
+    var y1 = shorterPath[i++];
+    var x2 = shorterPath[i++];
+    var y2 = shorterPath[i++];
+    var x3 = shorterPath[i++];
+    var y3 = shorterPath[i++];
+    if (remained <= 0) {
+      newSubpath.push(x1, y1, x2, y2, x3, y3);
+      continue;
     }
-    var mergedFormatter = formatter ? formatter.inherit === false ? formatter : defaults(formatter, defaults$1) : defaults$1;
-    var unit = getUnitFromValue(tick.value, isUTC);
-    if (mergedFormatter[unit]) {
-      template = mergedFormatter[unit];
-    } else if (mergedFormatter.inherit) {
-      var targetId = timeUnits.indexOf(unit);
-      for (var i = targetId - 1; i >= 0; --i) {
-        if (mergedFormatter[unit]) {
-          template = mergedFormatter[unit];
-          break;
-        }
-      }
-      template = template || defaults$1.none;
-    }
-    if (isArray(template)) {
-      var levelId = tick.level == null ? 0 : tick.level >= 0 ? tick.level : template.length + tick.level;
-      levelId = Math.min(levelId, template.length - 1);
-      template = template[levelId];
-    }
-  }
-  return format(new Date(tick.value), template, isUTC, lang);
-}
-function getUnitFromValue(value, isUTC) {
-  var date = parseDate(value);
-  var M = date[monthGetterName(isUTC)]() + 1;
-  var d = date[dateGetterName(isUTC)]();
-  var h = date[hoursGetterName(isUTC)]();
-  var m = date[minutesGetterName(isUTC)]();
-  var s = date[secondsGetterName(isUTC)]();
-  var S = date[millisecondsGetterName(isUTC)]();
-  var isSecond = S === 0;
-  var isMinute = isSecond && s === 0;
-  var isHour = isMinute && m === 0;
-  var isDay = isHour && h === 0;
-  var isMonth = isDay && d === 1;
-  var isYear = isMonth && M === 1;
-  if (isYear) {
-    return "year";
-  } else if (isMonth) {
-    return "month";
-  } else if (isDay) {
-    return "day";
-  } else if (isHour) {
-    return "hour";
-  } else if (isMinute) {
-    return "minute";
-  } else if (isSecond) {
-    return "second";
-  } else {
-    return "millisecond";
+    var actualSubDivCount = Math.min(remained, eachCurveSubDivCount - 1) + 1;
+    for (var k = 1; k <= actualSubDivCount; k++) {
+      var p = k / actualSubDivCount;
+      cubicSubdivide(x0, x1, x2, x3, p, tmpSegX);
+      cubicSubdivide(y0, y1, y2, y3, p, tmpSegY);
+      x0 = tmpSegX[3];
+      y0 = tmpSegY[3];
+      newSubpath.push(tmpSegX[1], tmpSegY[1], tmpSegX[2], tmpSegY[2], x0, y0);
+      x1 = tmpSegX[5];
+      y1 = tmpSegY[5];
+      x2 = tmpSegX[6];
+      y2 = tmpSegY[6];
+    }
+    remained -= actualSubDivCount - 1;
   }
+  return shorterPath === subpath1 ? [newSubpath, subpath2] : [subpath1, newSubpath];
 }
-function getUnitValue(value, unit, isUTC) {
-  var date = isNumber(value) ? parseDate(value) : value;
-  unit = unit || getUnitFromValue(value, isUTC);
-  switch (unit) {
-    case "year":
-      return date[fullYearGetterName(isUTC)]();
-    case "half-year":
-      return date[monthGetterName(isUTC)]() >= 6 ? 1 : 0;
-    case "quarter":
-      return Math.floor((date[monthGetterName(isUTC)]() + 1) / 4);
-    case "month":
-      return date[monthGetterName(isUTC)]();
-    case "day":
-      return date[dateGetterName(isUTC)]();
-    case "half-day":
-      return date[hoursGetterName(isUTC)]() / 24;
-    case "hour":
-      return date[hoursGetterName(isUTC)]();
-    case "minute":
-      return date[minutesGetterName(isUTC)]();
-    case "second":
-      return date[secondsGetterName(isUTC)]();
-    case "millisecond":
-      return date[millisecondsGetterName(isUTC)]();
+function createSubpath(lastSubpathSubpath, otherSubpath) {
+  var len = lastSubpathSubpath.length;
+  var lastX = lastSubpathSubpath[len - 2];
+  var lastY = lastSubpathSubpath[len - 1];
+  var newSubpath = [];
+  for (var i = 0; i < otherSubpath.length; ) {
+    newSubpath[i++] = lastX;
+    newSubpath[i++] = lastY;
   }
+  return newSubpath;
 }
-function fullYearGetterName(isUTC) {
-  return isUTC ? "getUTCFullYear" : "getFullYear";
+function alignBezierCurves(array1, array2) {
+  var _a;
+  var lastSubpath1;
+  var lastSubpath2;
+  var newArray1 = [];
+  var newArray2 = [];
+  for (var i = 0; i < Math.max(array1.length, array2.length); i++) {
+    var subpath1 = array1[i];
+    var subpath2 = array2[i];
+    var newSubpath1 = void 0;
+    var newSubpath2 = void 0;
+    if (!subpath1) {
+      newSubpath1 = createSubpath(lastSubpath1 || subpath2, subpath2);
+      newSubpath2 = subpath2;
+    } else if (!subpath2) {
+      newSubpath2 = createSubpath(lastSubpath2 || subpath1, subpath1);
+      newSubpath1 = subpath1;
+    } else {
+      _a = alignSubpath(subpath1, subpath2), newSubpath1 = _a[0], newSubpath2 = _a[1];
+      lastSubpath1 = newSubpath1;
+      lastSubpath2 = newSubpath2;
+    }
+    newArray1.push(newSubpath1);
+    newArray2.push(newSubpath2);
+  }
+  return [newArray1, newArray2];
 }
-function monthGetterName(isUTC) {
-  return isUTC ? "getUTCMonth" : "getMonth";
+function centroid(array) {
+  var signedArea = 0;
+  var cx = 0;
+  var cy = 0;
+  var len = array.length;
+  for (var i = 0, j = len - 2; i < len; j = i, i += 2) {
+    var x0 = array[j];
+    var y0 = array[j + 1];
+    var x1 = array[i];
+    var y1 = array[i + 1];
+    var a = x0 * y1 - x1 * y0;
+    signedArea += a;
+    cx += (x0 + x1) * a;
+    cy += (y0 + y1) * a;
+  }
+  if (signedArea === 0) {
+    return [array[0] || 0, array[1] || 0];
+  }
+  return [cx / signedArea / 3, cy / signedArea / 3, signedArea];
 }
-function dateGetterName(isUTC) {
-  return isUTC ? "getUTCDate" : "getDate";
+function findBestRingOffset(fromSubBeziers, toSubBeziers, fromCp, toCp) {
+  var bezierCount = (fromSubBeziers.length - 2) / 6;
+  var bestScore = Infinity;
+  var bestOffset = 0;
+  var len = fromSubBeziers.length;
+  var len2 = len - 2;
+  for (var offset = 0; offset < bezierCount; offset++) {
+    var cursorOffset = offset * 6;
+    var score = 0;
+    for (var k = 0; k < len; k += 2) {
+      var idx = k === 0 ? cursorOffset : (cursorOffset + k - 2) % len2 + 2;
+      var x0 = fromSubBeziers[idx] - fromCp[0];
+      var y0 = fromSubBeziers[idx + 1] - fromCp[1];
+      var x1 = toSubBeziers[k] - toCp[0];
+      var y1 = toSubBeziers[k + 1] - toCp[1];
+      var dx = x1 - x0;
+      var dy = y1 - y0;
+      score += dx * dx + dy * dy;
+    }
+    if (score < bestScore) {
+      bestScore = score;
+      bestOffset = offset;
+    }
+  }
+  return bestOffset;
 }
-function hoursGetterName(isUTC) {
-  return isUTC ? "getUTCHours" : "getHours";
+function reverse(array) {
+  var newArr = [];
+  var len = array.length;
+  for (var i = 0; i < len; i += 2) {
+    newArr[i] = array[len - i - 2];
+    newArr[i + 1] = array[len - i - 1];
+  }
+  return newArr;
 }
-function minutesGetterName(isUTC) {
-  return isUTC ? "getUTCMinutes" : "getMinutes";
+function findBestMorphingRotation(fromArr, toArr, searchAngleIteration, searchAngleRange) {
+  var result = [];
+  var fromNeedsReverse;
+  for (var i = 0; i < fromArr.length; i++) {
+    var fromSubpathBezier = fromArr[i];
+    var toSubpathBezier = toArr[i];
+    var fromCp = centroid(fromSubpathBezier);
+    var toCp = centroid(toSubpathBezier);
+    if (fromNeedsReverse == null) {
+      fromNeedsReverse = fromCp[2] < 0 !== toCp[2] < 0;
+    }
+    var newFromSubpathBezier = [];
+    var newToSubpathBezier = [];
+    var bestAngle = 0;
+    var bestScore = Infinity;
+    var tmpArr = [];
+    var len = fromSubpathBezier.length;
+    if (fromNeedsReverse) {
+      fromSubpathBezier = reverse(fromSubpathBezier);
+    }
+    var offset = findBestRingOffset(fromSubpathBezier, toSubpathBezier, fromCp, toCp) * 6;
+    var len2 = len - 2;
+    for (var k = 0; k < len2; k += 2) {
+      var idx = (offset + k) % len2 + 2;
+      newFromSubpathBezier[k + 2] = fromSubpathBezier[idx] - fromCp[0];
+      newFromSubpathBezier[k + 3] = fromSubpathBezier[idx + 1] - fromCp[1];
+    }
+    newFromSubpathBezier[0] = fromSubpathBezier[offset] - fromCp[0];
+    newFromSubpathBezier[1] = fromSubpathBezier[offset + 1] - fromCp[1];
+    {
+      var step = searchAngleRange / searchAngleIteration;
+      for (var angle = -searchAngleRange / 2; angle <= searchAngleRange / 2; angle += step) {
+        var sa = Math.sin(angle);
+        var ca = Math.cos(angle);
+        var score = 0;
+        for (var k = 0; k < fromSubpathBezier.length; k += 2) {
+          var x0 = newFromSubpathBezier[k];
+          var y0 = newFromSubpathBezier[k + 1];
+          var x1 = toSubpathBezier[k] - toCp[0];
+          var y1 = toSubpathBezier[k + 1] - toCp[1];
+          var newX1 = x1 * ca - y1 * sa;
+          var newY1 = x1 * sa + y1 * ca;
+          tmpArr[k] = newX1;
+          tmpArr[k + 1] = newY1;
+          var dx = newX1 - x0;
+          var dy = newY1 - y0;
+          score += dx * dx + dy * dy;
+        }
+        if (score < bestScore) {
+          bestScore = score;
+          bestAngle = angle;
+          for (var m = 0; m < tmpArr.length; m++) {
+            newToSubpathBezier[m] = tmpArr[m];
+          }
+        }
+      }
+    }
+    result.push({
+      from: newFromSubpathBezier,
+      to: newToSubpathBezier,
+      fromCp,
+      toCp,
+      rotation: -bestAngle
+    });
+  }
+  return result;
 }
-function secondsGetterName(isUTC) {
-  return isUTC ? "getUTCSeconds" : "getSeconds";
+function isCombineMorphing(path) {
+  return path.__isCombineMorphing;
 }
-function millisecondsGetterName(isUTC) {
-  return isUTC ? "getUTCMilliseconds" : "getMilliseconds";
+var SAVED_METHOD_PREFIX = "__mOriginal_";
+function saveAndModifyMethod(obj, methodName, modifiers) {
+  var savedMethodName = SAVED_METHOD_PREFIX + methodName;
+  var originalMethod = obj[savedMethodName] || obj[methodName];
+  if (!obj[savedMethodName]) {
+    obj[savedMethodName] = obj[methodName];
+  }
+  var replace = modifiers.replace;
+  var after = modifiers.after;
+  var before = modifiers.before;
+  obj[methodName] = function() {
+    var args = arguments;
+    var res;
+    before && before.apply(this, args);
+    if (replace) {
+      res = replace.apply(this, args);
+    } else {
+      res = originalMethod.apply(this, args);
+    }
+    after && after.apply(this, args);
+    return res;
+  };
 }
-function fullYearSetterName(isUTC) {
-  return isUTC ? "setUTCFullYear" : "setFullYear";
+function restoreMethod(obj, methodName) {
+  var savedMethodName = SAVED_METHOD_PREFIX + methodName;
+  if (obj[savedMethodName]) {
+    obj[methodName] = obj[savedMethodName];
+    obj[savedMethodName] = null;
+  }
 }
-function monthSetterName(isUTC) {
-  return isUTC ? "setUTCMonth" : "setMonth";
+function applyTransformOnBeziers(bezierCurves, mm) {
+  for (var i = 0; i < bezierCurves.length; i++) {
+    var subBeziers = bezierCurves[i];
+    for (var k = 0; k < subBeziers.length; ) {
+      var x = subBeziers[k];
+      var y = subBeziers[k + 1];
+      subBeziers[k++] = mm[0] * x + mm[2] * y + mm[4];
+      subBeziers[k++] = mm[1] * x + mm[3] * y + mm[5];
+    }
+  }
 }
-function dateSetterName(isUTC) {
-  return isUTC ? "setUTCDate" : "setDate";
+function prepareMorphPath(fromPath, toPath) {
+  var fromPathProxy = fromPath.getUpdatedPathProxy();
+  var toPathProxy = toPath.getUpdatedPathProxy();
+  var _a = alignBezierCurves(pathToBezierCurves(fromPathProxy), pathToBezierCurves(toPathProxy)), fromBezierCurves = _a[0], toBezierCurves = _a[1];
+  var fromPathTransform = fromPath.getComputedTransform();
+  var toPathTransform = toPath.getComputedTransform();
+  function updateIdentityTransform() {
+    this.transform = null;
+  }
+  fromPathTransform && applyTransformOnBeziers(fromBezierCurves, fromPathTransform);
+  toPathTransform && applyTransformOnBeziers(toBezierCurves, toPathTransform);
+  saveAndModifyMethod(toPath, "updateTransform", { replace: updateIdentityTransform });
+  toPath.transform = null;
+  var morphingData = findBestMorphingRotation(fromBezierCurves, toBezierCurves, 10, Math.PI);
+  var tmpArr = [];
+  saveAndModifyMethod(toPath, "buildPath", { replace: function(path) {
+    var t = toPath.__morphT;
+    var onet = 1 - t;
+    var newCp = [];
+    for (var i = 0; i < morphingData.length; i++) {
+      var item = morphingData[i];
+      var from = item.from;
+      var to = item.to;
+      var angle = item.rotation * t;
+      var fromCp = item.fromCp;
+      var toCp = item.toCp;
+      var sa = Math.sin(angle);
+      var ca = Math.cos(angle);
+      lerp(newCp, fromCp, toCp, t);
+      for (var m = 0; m < from.length; m += 2) {
+        var x0_1 = from[m];
+        var y0_1 = from[m + 1];
+        var x1 = to[m];
+        var y1 = to[m + 1];
+        var x = x0_1 * onet + x1 * t;
+        var y = y0_1 * onet + y1 * t;
+        tmpArr[m] = x * ca - y * sa + newCp[0];
+        tmpArr[m + 1] = x * sa + y * ca + newCp[1];
+      }
+      var x0 = tmpArr[0];
+      var y0 = tmpArr[1];
+      path.moveTo(x0, y0);
+      for (var m = 2; m < from.length; ) {
+        var x1 = tmpArr[m++];
+        var y1 = tmpArr[m++];
+        var x2 = tmpArr[m++];
+        var y2 = tmpArr[m++];
+        var x3 = tmpArr[m++];
+        var y3 = tmpArr[m++];
+        if (x0 === x1 && y0 === y1 && x2 === x3 && y2 === y3) {
+          path.lineTo(x3, y3);
+        } else {
+          path.bezierCurveTo(x1, y1, x2, y2, x3, y3);
+        }
+        x0 = x3;
+        y0 = y3;
+      }
+    }
+  } });
 }
-function hoursSetterName(isUTC) {
-  return isUTC ? "setUTCHours" : "setHours";
+function morphPath(fromPath, toPath, animationOpts) {
+  if (!fromPath || !toPath) {
+    return toPath;
+  }
+  var oldDone = animationOpts.done;
+  var oldDuring = animationOpts.during;
+  prepareMorphPath(fromPath, toPath);
+  toPath.__morphT = 0;
+  function restoreToPath() {
+    restoreMethod(toPath, "buildPath");
+    restoreMethod(toPath, "updateTransform");
+    toPath.__morphT = -1;
+    toPath.createPathProxy();
+    toPath.dirtyShape();
+  }
+  toPath.animateTo({
+    __morphT: 1
+  }, defaults({
+    during: function(p) {
+      toPath.dirtyShape();
+      oldDuring && oldDuring(p);
+    },
+    done: function() {
+      restoreToPath();
+      oldDone && oldDone();
+    }
+  }, animationOpts));
+  return toPath;
 }
-function minutesSetterName(isUTC) {
-  return isUTC ? "setUTCMinutes" : "setMinutes";
+function hilbert(x, y, minX, minY, maxX, maxY) {
+  var bits = 16;
+  x = maxX === minX ? 0 : Math.round(32767 * (x - minX) / (maxX - minX));
+  y = maxY === minY ? 0 : Math.round(32767 * (y - minY) / (maxY - minY));
+  var d = 0;
+  var tmp;
+  for (var s = (1 << bits) / 2; s > 0; s /= 2) {
+    var rx = 0;
+    var ry = 0;
+    if ((x & s) > 0) {
+      rx = 1;
+    }
+    if ((y & s) > 0) {
+      ry = 1;
+    }
+    d += s * s * (3 * rx ^ ry);
+    if (ry === 0) {
+      if (rx === 1) {
+        x = s - 1 - x;
+        y = s - 1 - y;
+      }
+      tmp = x;
+      x = y;
+      y = tmp;
+    }
+  }
+  return d;
 }
-function secondsSetterName(isUTC) {
-  return isUTC ? "setUTCSeconds" : "setSeconds";
+function sortPaths(pathList) {
+  var xMin = Infinity;
+  var yMin = Infinity;
+  var xMax = -Infinity;
+  var yMax = -Infinity;
+  var cps = map(pathList, function(path) {
+    var rect = path.getBoundingRect();
+    var m = path.getComputedTransform();
+    var x = rect.x + rect.width / 2 + (m ? m[4] : 0);
+    var y = rect.y + rect.height / 2 + (m ? m[5] : 0);
+    xMin = Math.min(x, xMin);
+    yMin = Math.min(y, yMin);
+    xMax = Math.max(x, xMax);
+    yMax = Math.max(y, yMax);
+    return [x, y];
+  });
+  var items = map(cps, function(cp, idx) {
+    return {
+      cp,
+      z: hilbert(cp[0], cp[1], xMin, yMin, xMax, yMax),
+      path: pathList[idx]
+    };
+  });
+  return items.sort(function(a, b) {
+    return a.z - b.z;
+  }).map(function(item) {
+    return item.path;
+  });
 }
-function millisecondsSetterName(isUTC) {
-  return isUTC ? "setUTCMilliseconds" : "setMilliseconds";
+function defaultDividePath(param) {
+  return split(param.path, param.count);
+}
+function createEmptyReturn() {
+  return {
+    fromIndividuals: [],
+    toIndividuals: [],
+    count: 0
+  };
+}
+function combineMorph(fromList, toPath, animationOpts) {
+  var fromPathList = [];
+  function addFromPath(fromList2) {
+    for (var i2 = 0; i2 < fromList2.length; i2++) {
+      var from2 = fromList2[i2];
+      if (isCombineMorphing(from2)) {
+        addFromPath(from2.childrenRef());
+      } else if (from2 instanceof Path) {
+        fromPathList.push(from2);
+      }
+    }
+  }
+  addFromPath(fromList);
+  var separateCount = fromPathList.length;
+  if (!separateCount) {
+    return createEmptyReturn();
+  }
+  var dividePath = animationOpts.dividePath || defaultDividePath;
+  var toSubPathList = dividePath({
+    path: toPath,
+    count: separateCount
+  });
+  if (toSubPathList.length !== separateCount) {
+    console.error("Invalid morphing: unmatched splitted path");
+    return createEmptyReturn();
+  }
+  fromPathList = sortPaths(fromPathList);
+  toSubPathList = sortPaths(toSubPathList);
+  var oldDone = animationOpts.done;
+  var oldDuring = animationOpts.during;
+  var individualDelay = animationOpts.individualDelay;
+  var identityTransform = new Transformable();
+  for (var i = 0; i < separateCount; i++) {
+    var from = fromPathList[i];
+    var to = toSubPathList[i];
+    to.parent = toPath;
+    to.copyTransform(identityTransform);
+    if (!individualDelay) {
+      prepareMorphPath(from, to);
+    }
+  }
+  toPath.__isCombineMorphing = true;
+  toPath.childrenRef = function() {
+    return toSubPathList;
+  };
+  function addToSubPathListToZr(zr) {
+    for (var i2 = 0; i2 < toSubPathList.length; i2++) {
+      toSubPathList[i2].addSelfToZr(zr);
+    }
+  }
+  saveAndModifyMethod(toPath, "addSelfToZr", {
+    after: function(zr) {
+      addToSubPathListToZr(zr);
+    }
+  });
+  saveAndModifyMethod(toPath, "removeSelfFromZr", {
+    after: function(zr) {
+      for (var i2 = 0; i2 < toSubPathList.length; i2++) {
+        toSubPathList[i2].removeSelfFromZr(zr);
+      }
+    }
+  });
+  function restoreToPath() {
+    toPath.__isCombineMorphing = false;
+    toPath.__morphT = -1;
+    toPath.childrenRef = null;
+    restoreMethod(toPath, "addSelfToZr");
+    restoreMethod(toPath, "removeSelfFromZr");
+  }
+  var toLen = toSubPathList.length;
+  if (individualDelay) {
+    var animating_1 = toLen;
+    var eachDone = function() {
+      animating_1--;
+      if (animating_1 === 0) {
+        restoreToPath();
+        oldDone && oldDone();
+      }
+    };
+    for (var i = 0; i < toLen; i++) {
+      var indivdualAnimationOpts = individualDelay ? defaults({
+        delay: (animationOpts.delay || 0) + individualDelay(i, toLen, fromPathList[i], toSubPathList[i]),
+        done: eachDone
+      }, animationOpts) : animationOpts;
+      morphPath(fromPathList[i], toSubPathList[i], indivdualAnimationOpts);
+    }
+  } else {
+    toPath.__morphT = 0;
+    toPath.animateTo({
+      __morphT: 1
+    }, defaults({
+      during: function(p) {
+        for (var i2 = 0; i2 < toLen; i2++) {
+          var child = toSubPathList[i2];
+          child.__morphT = toPath.__morphT;
+          child.dirtyShape();
+        }
+        oldDuring && oldDuring(p);
+      },
+      done: function() {
+        restoreToPath();
+        for (var i2 = 0; i2 < fromList.length; i2++) {
+          restoreMethod(fromList[i2], "updateTransform");
+        }
+        oldDone && oldDone();
+      }
+    }, animationOpts));
+  }
+  if (toPath.__zr) {
+    addToSubPathListToZr(toPath.__zr);
+  }
+  return {
+    fromIndividuals: fromPathList,
+    toIndividuals: toSubPathList,
+    count: toLen
+  };
+}
+function separateMorph(fromPath, toPathList, animationOpts) {
+  var toLen = toPathList.length;
+  var fromPathList = [];
+  var dividePath = animationOpts.dividePath || defaultDividePath;
+  function addFromPath(fromList) {
+    for (var i2 = 0; i2 < fromList.length; i2++) {
+      var from = fromList[i2];
+      if (isCombineMorphing(from)) {
+        addFromPath(from.childrenRef());
+      } else if (from instanceof Path) {
+        fromPathList.push(from);
+      }
+    }
+  }
+  if (isCombineMorphing(fromPath)) {
+    addFromPath(fromPath.childrenRef());
+    var fromLen = fromPathList.length;
+    if (fromLen < toLen) {
+      var k = 0;
+      for (var i = fromLen; i < toLen; i++) {
+        fromPathList.push(clonePath(fromPathList[k++ % fromLen]));
+      }
+    }
+    fromPathList.length = toLen;
+  } else {
+    fromPathList = dividePath({ path: fromPath, count: toLen });
+    var fromPathTransform = fromPath.getComputedTransform();
+    for (var i = 0; i < fromPathList.length; i++) {
+      fromPathList[i].setLocalTransform(fromPathTransform);
+    }
+    if (fromPathList.length !== toLen) {
+      console.error("Invalid morphing: unmatched splitted path");
+      return createEmptyReturn();
+    }
+  }
+  fromPathList = sortPaths(fromPathList);
+  toPathList = sortPaths(toPathList);
+  var individualDelay = animationOpts.individualDelay;
+  for (var i = 0; i < toLen; i++) {
+    var indivdualAnimationOpts = individualDelay ? defaults({
+      delay: (animationOpts.delay || 0) + individualDelay(i, toLen, fromPathList[i], toPathList[i])
+    }, animationOpts) : animationOpts;
+    morphPath(fromPathList[i], toPathList[i], indivdualAnimationOpts);
+  }
+  return {
+    fromIndividuals: fromPathList,
+    toIndividuals: toPathList,
+    count: toPathList.length
+  };
 }
 export {
-  ONE_DAY,
-  ONE_HOUR,
-  ONE_MINUTE,
-  ONE_SECOND,
-  ONE_YEAR,
-  dateGetterName,
-  dateSetterName,
-  defaultLeveledFormatter,
-  format,
-  fullLeveledFormatter,
-  fullYearGetterName,
-  fullYearSetterName,
-  getDefaultFormatPrecisionOfInterval,
-  getPrimaryTimeUnit,
-  getUnitFromValue,
-  getUnitValue,
-  hoursGetterName,
-  hoursSetterName,
-  isPrimaryTimeUnit,
-  leveledFormat,
-  millisecondsGetterName,
-  millisecondsSetterName,
-  minutesGetterName,
-  minutesSetterName,
-  monthGetterName,
-  monthSetterName,
-  pad,
-  primaryTimeUnits,
-  secondsGetterName,
-  secondsSetterName,
-  timeUnits
+  alignBezierCurves,
+  centroid,
+  combineMorph,
+  split as defaultDividePath,
+  isCombineMorphing,
+  morphPath,
+  separateMorph
 };