@fecp/mobile 1.0.78 → 1.1.0

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/core/util.mjs

@@ -0,0 +1,559 @@
+import { platformApi } from "./platform.mjs";
+var BUILTIN_OBJECT = reduce([
+  "Function",
+  "RegExp",
+  "Date",
+  "Error",
+  "CanvasGradient",
+  "CanvasPattern",
+  "Image",
+  "Canvas"
+], function(obj, val) {
+  obj["[object " + val + "]"] = true;
+  return obj;
+}, {});
+var TYPED_ARRAY = reduce([
+  "Int8",
+  "Uint8",
+  "Uint8Clamped",
+  "Int16",
+  "Uint16",
+  "Int32",
+  "Uint32",
+  "Float32",
+  "Float64"
+], function(obj, val) {
+  obj["[object " + val + "Array]"] = true;
+  return obj;
+}, {});
+var objToString = Object.prototype.toString;
+var arrayProto = Array.prototype;
+var nativeForEach = arrayProto.forEach;
+var nativeFilter = arrayProto.filter;
+var nativeSlice = arrayProto.slice;
+var nativeMap = arrayProto.map;
+var ctorFunction = (function() {
+}).constructor;
+var protoFunction = ctorFunction ? ctorFunction.prototype : null;
+var protoKey = "__proto__";
+var idStart = 2311;
+function guid() {
+  return idStart++;
+}
+function logError() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  if (typeof console !== "undefined") {
+    console.error.apply(console, args);
+  }
+}
+function clone(source) {
+  if (source == null || typeof source !== "object") {
+    return source;
+  }
+  var result = source;
+  var typeStr = objToString.call(source);
+  if (typeStr === "[object Array]") {
+    if (!isPrimitive(source)) {
+      result = [];
+      for (var i = 0, len = source.length; i < len; i++) {
+        result[i] = clone(source[i]);
+      }
+    }
+  } else if (TYPED_ARRAY[typeStr]) {
+    if (!isPrimitive(source)) {
+      var Ctor = source.constructor;
+      if (Ctor.from) {
+        result = Ctor.from(source);
+      } else {
+        result = new Ctor(source.length);
+        for (var i = 0, len = source.length; i < len; i++) {
+          result[i] = source[i];
+        }
+      }
+    }
+  } else if (!BUILTIN_OBJECT[typeStr] && !isPrimitive(source) && !isDom(source)) {
+    result = {};
+    for (var key in source) {
+      if (source.hasOwnProperty(key) && key !== protoKey) {
+        result[key] = clone(source[key]);
+      }
+    }
+  }
+  return result;
+}
+function merge(target, source, overwrite) {
+  if (!isObject(source) || !isObject(target)) {
+    return overwrite ? clone(source) : target;
+  }
+  for (var key in source) {
+    if (source.hasOwnProperty(key) && key !== protoKey) {
+      var targetProp = target[key];
+      var sourceProp = source[key];
+      if (isObject(sourceProp) && isObject(targetProp) && !isArray(sourceProp) && !isArray(targetProp) && !isDom(sourceProp) && !isDom(targetProp) && !isBuiltInObject(sourceProp) && !isBuiltInObject(targetProp) && !isPrimitive(sourceProp) && !isPrimitive(targetProp)) {
+        merge(targetProp, sourceProp, overwrite);
+      } else if (overwrite || !(key in target)) {
+        target[key] = clone(source[key]);
+      }
+    }
+  }
+  return target;
+}
+function mergeAll(targetAndSources, overwrite) {
+  var result = targetAndSources[0];
+  for (var i = 1, len = targetAndSources.length; i < len; i++) {
+    result = merge(result, targetAndSources[i], overwrite);
+  }
+  return result;
+}
+function extend(target, source) {
+  if (Object.assign) {
+    Object.assign(target, source);
+  } else {
+    for (var key in source) {
+      if (source.hasOwnProperty(key) && key !== protoKey) {
+        target[key] = source[key];
+      }
+    }
+  }
+  return target;
+}
+function defaults(target, source, overlay) {
+  var keysArr = keys(source);
+  for (var i = 0, len = keysArr.length; i < len; i++) {
+    var key = keysArr[i];
+    if (overlay ? source[key] != null : target[key] == null) {
+      target[key] = source[key];
+    }
+  }
+  return target;
+}
+var createCanvas = platformApi.createCanvas;
+function indexOf(array, value) {
+  if (array) {
+    if (array.indexOf) {
+      return array.indexOf(value);
+    }
+    for (var i = 0, len = array.length; i < len; i++) {
+      if (array[i] === value) {
+        return i;
+      }
+    }
+  }
+  return -1;
+}
+function inherits(clazz, baseClazz) {
+  var clazzPrototype = clazz.prototype;
+  function F() {
+  }
+  F.prototype = baseClazz.prototype;
+  clazz.prototype = new F();
+  for (var prop in clazzPrototype) {
+    if (clazzPrototype.hasOwnProperty(prop)) {
+      clazz.prototype[prop] = clazzPrototype[prop];
+    }
+  }
+  clazz.prototype.constructor = clazz;
+  clazz.superClass = baseClazz;
+}
+function mixin(target, source, override) {
+  target = "prototype" in target ? target.prototype : target;
+  source = "prototype" in source ? source.prototype : source;
+  if (Object.getOwnPropertyNames) {
+    var keyList = Object.getOwnPropertyNames(source);
+    for (var i = 0; i < keyList.length; i++) {
+      var key = keyList[i];
+      if (key !== "constructor") {
+        if (override ? source[key] != null : target[key] == null) {
+          target[key] = source[key];
+        }
+      }
+    }
+  } else {
+    defaults(target, source, override);
+  }
+}
+function isArrayLike(data) {
+  if (!data) {
+    return false;
+  }
+  if (typeof data === "string") {
+    return false;
+  }
+  return typeof data.length === "number";
+}
+function each(arr, cb, context) {
+  if (!(arr && cb)) {
+    return;
+  }
+  if (arr.forEach && arr.forEach === nativeForEach) {
+    arr.forEach(cb, context);
+  } else if (arr.length === +arr.length) {
+    for (var i = 0, len = arr.length; i < len; i++) {
+      cb.call(context, arr[i], i, arr);
+    }
+  } else {
+    for (var key in arr) {
+      if (arr.hasOwnProperty(key)) {
+        cb.call(context, arr[key], key, arr);
+      }
+    }
+  }
+}
+function map(arr, cb, context) {
+  if (!arr) {
+    return [];
+  }
+  if (!cb) {
+    return slice(arr);
+  }
+  if (arr.map && arr.map === nativeMap) {
+    return arr.map(cb, context);
+  } else {
+    var result = [];
+    for (var i = 0, len = arr.length; i < len; i++) {
+      result.push(cb.call(context, arr[i], i, arr));
+    }
+    return result;
+  }
+}
+function reduce(arr, cb, memo, context) {
+  if (!(arr && cb)) {
+    return;
+  }
+  for (var i = 0, len = arr.length; i < len; i++) {
+    memo = cb.call(context, memo, arr[i], i, arr);
+  }
+  return memo;
+}
+function filter(arr, cb, context) {
+  if (!arr) {
+    return [];
+  }
+  if (!cb) {
+    return slice(arr);
+  }
+  if (arr.filter && arr.filter === nativeFilter) {
+    return arr.filter(cb, context);
+  } else {
+    var result = [];
+    for (var i = 0, len = arr.length; i < len; i++) {
+      if (cb.call(context, arr[i], i, arr)) {
+        result.push(arr[i]);
+      }
+    }
+    return result;
+  }
+}
+function find(arr, cb, context) {
+  if (!(arr && cb)) {
+    return;
+  }
+  for (var i = 0, len = arr.length; i < len; i++) {
+    if (cb.call(context, arr[i], i, arr)) {
+      return arr[i];
+    }
+  }
+}
+function keys(obj) {
+  if (!obj) {
+    return [];
+  }
+  if (Object.keys) {
+    return Object.keys(obj);
+  }
+  var keyList = [];
+  for (var key in obj) {
+    if (obj.hasOwnProperty(key)) {
+      keyList.push(key);
+    }
+  }
+  return keyList;
+}
+function bindPolyfill(func, context) {
+  var args = [];
+  for (var _i = 2; _i < arguments.length; _i++) {
+    args[_i - 2] = arguments[_i];
+  }
+  return function() {
+    return func.apply(context, args.concat(nativeSlice.call(arguments)));
+  };
+}
+var bind = protoFunction && isFunction(protoFunction.bind) ? protoFunction.call.bind(protoFunction.bind) : bindPolyfill;
+function curry(func) {
+  var args = [];
+  for (var _i = 1; _i < arguments.length; _i++) {
+    args[_i - 1] = arguments[_i];
+  }
+  return function() {
+    return func.apply(this, args.concat(nativeSlice.call(arguments)));
+  };
+}
+function isArray(value) {
+  if (Array.isArray) {
+    return Array.isArray(value);
+  }
+  return objToString.call(value) === "[object Array]";
+}
+function isFunction(value) {
+  return typeof value === "function";
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isStringSafe(value) {
+  return objToString.call(value) === "[object String]";
+}
+function isNumber(value) {
+  return typeof value === "number";
+}
+function isObject(value) {
+  var type = typeof value;
+  return type === "function" || !!value && type === "object";
+}
+function isBuiltInObject(value) {
+  return !!BUILTIN_OBJECT[objToString.call(value)];
+}
+function isTypedArray(value) {
+  return !!TYPED_ARRAY[objToString.call(value)];
+}
+function isDom(value) {
+  return typeof value === "object" && typeof value.nodeType === "number" && typeof value.ownerDocument === "object";
+}
+function isGradientObject(value) {
+  return value.colorStops != null;
+}
+function isImagePatternObject(value) {
+  return value.image != null;
+}
+function isRegExp(value) {
+  return objToString.call(value) === "[object RegExp]";
+}
+function eqNaN(value) {
+  return value !== value;
+}
+function retrieve() {
+  var args = [];
+  for (var _i = 0; _i < arguments.length; _i++) {
+    args[_i] = arguments[_i];
+  }
+  for (var i = 0, len = args.length; i < len; i++) {
+    if (args[i] != null) {
+      return args[i];
+    }
+  }
+}
+function retrieve2(value0, value1) {
+  return value0 != null ? value0 : value1;
+}
+function retrieve3(value0, value1, value2) {
+  return value0 != null ? value0 : value1 != null ? value1 : value2;
+}
+function slice(arr) {
+  var args = [];
+  for (var _i = 1; _i < arguments.length; _i++) {
+    args[_i - 1] = arguments[_i];
+  }
+  return nativeSlice.apply(arr, args);
+}
+function normalizeCssArray(val) {
+  if (typeof val === "number") {
+    return [val, val, val, val];
+  }
+  var len = val.length;
+  if (len === 2) {
+    return [val[0], val[1], val[0], val[1]];
+  } else if (len === 3) {
+    return [val[0], val[1], val[2], val[1]];
+  }
+  return val;
+}
+function assert(condition, message) {
+  if (!condition) {
+    throw new Error(message);
+  }
+}
+function trim(str) {
+  if (str == null) {
+    return null;
+  } else if (typeof str.trim === "function") {
+    return str.trim();
+  } else {
+    return str.replace(/^[\s\uFEFF\xA0]+|[\s\uFEFF\xA0]+$/g, "");
+  }
+}
+var primitiveKey = "__ec_primitive__";
+function setAsPrimitive(obj) {
+  obj[primitiveKey] = true;
+}
+function isPrimitive(obj) {
+  return obj[primitiveKey];
+}
+var MapPolyfill = function() {
+  function MapPolyfill2() {
+    this.data = {};
+  }
+  MapPolyfill2.prototype["delete"] = function(key) {
+    var existed = this.has(key);
+    if (existed) {
+      delete this.data[key];
+    }
+    return existed;
+  };
+  MapPolyfill2.prototype.has = function(key) {
+    return this.data.hasOwnProperty(key);
+  };
+  MapPolyfill2.prototype.get = function(key) {
+    return this.data[key];
+  };
+  MapPolyfill2.prototype.set = function(key, value) {
+    this.data[key] = value;
+    return this;
+  };
+  MapPolyfill2.prototype.keys = function() {
+    return keys(this.data);
+  };
+  MapPolyfill2.prototype.forEach = function(callback) {
+    var data = this.data;
+    for (var key in data) {
+      if (data.hasOwnProperty(key)) {
+        callback(data[key], key);
+      }
+    }
+  };
+  return MapPolyfill2;
+}();
+var isNativeMapSupported = typeof Map === "function";
+function maybeNativeMap() {
+  return isNativeMapSupported ? /* @__PURE__ */ new Map() : new MapPolyfill();
+}
+var HashMap = function() {
+  function HashMap2(obj) {
+    var isArr = isArray(obj);
+    this.data = maybeNativeMap();
+    var thisMap = this;
+    obj instanceof HashMap2 ? obj.each(visit) : obj && each(obj, visit);
+    function visit(value, key) {
+      isArr ? thisMap.set(value, key) : thisMap.set(key, value);
+    }
+  }
+  HashMap2.prototype.hasKey = function(key) {
+    return this.data.has(key);
+  };
+  HashMap2.prototype.get = function(key) {
+    return this.data.get(key);
+  };
+  HashMap2.prototype.set = function(key, value) {
+    this.data.set(key, value);
+    return value;
+  };
+  HashMap2.prototype.each = function(cb, context) {
+    this.data.forEach(function(value, key) {
+      cb.call(context, value, key);
+    });
+  };
+  HashMap2.prototype.keys = function() {
+    var keys2 = this.data.keys();
+    return isNativeMapSupported ? Array.from(keys2) : keys2;
+  };
+  HashMap2.prototype.removeKey = function(key) {
+    this.data["delete"](key);
+  };
+  return HashMap2;
+}();
+function createHashMap(obj) {
+  return new HashMap(obj);
+}
+function concatArray(a, b) {
+  var newArray = new a.constructor(a.length + b.length);
+  for (var i = 0; i < a.length; i++) {
+    newArray[i] = a[i];
+  }
+  var offset = a.length;
+  for (var i = 0; i < b.length; i++) {
+    newArray[i + offset] = b[i];
+  }
+  return newArray;
+}
+function createObject(proto, properties) {
+  var obj;
+  if (Object.create) {
+    obj = Object.create(proto);
+  } else {
+    var StyleCtor = function() {
+    };
+    StyleCtor.prototype = proto;
+    obj = new StyleCtor();
+  }
+  if (properties) {
+    extend(obj, properties);
+  }
+  return obj;
+}
+function disableUserSelect(dom) {
+  var domStyle = dom.style;
+  domStyle.webkitUserSelect = "none";
+  domStyle.userSelect = "none";
+  domStyle.webkitTapHighlightColor = "rgba(0,0,0,0)";
+  domStyle["-webkit-touch-callout"] = "none";
+}
+function hasOwn(own, prop) {
+  return own.hasOwnProperty(prop);
+}
+function noop() {
+}
+var RADIAN_TO_DEGREE = 180 / Math.PI;
+export {
+  HashMap,
+  RADIAN_TO_DEGREE,
+  assert,
+  bind,
+  clone,
+  concatArray,
+  createCanvas,
+  createHashMap,
+  createObject,
+  curry,
+  defaults,
+  disableUserSelect,
+  each,
+  eqNaN,
+  extend,
+  filter,
+  find,
+  guid,
+  hasOwn,
+  indexOf,
+  inherits,
+  isArray,
+  isArrayLike,
+  isBuiltInObject,
+  isDom,
+  isFunction,
+  isGradientObject,
+  isImagePatternObject,
+  isNumber,
+  isObject,
+  isPrimitive,
+  isRegExp,
+  isString,
+  isStringSafe,
+  isTypedArray,
+  keys,
+  logError,
+  map,
+  merge,
+  mergeAll,
+  mixin,
+  noop,
+  normalizeCssArray,
+  reduce,
+  retrieve,
+  retrieve2,
+  retrieve3,
+  setAsPrimitive,
+  slice,
+  trim
+};

package/es/node_modules/.pnpm/zrender@5.6.1/node_modules/zrender/lib/core/vector.mjs

@@ -0,0 +1,136 @@
+function create(x, y) {
+  if (x == null) {
+    x = 0;
+  }
+  if (y == null) {
+    y = 0;
+  }
+  return [x, y];
+}
+function copy(out, v) {
+  out[0] = v[0];
+  out[1] = v[1];
+  return out;
+}
+function clone(v) {
+  return [v[0], v[1]];
+}
+function set(out, a, b) {
+  out[0] = a;
+  out[1] = b;
+  return out;
+}
+function add(out, v1, v2) {
+  out[0] = v1[0] + v2[0];
+  out[1] = v1[1] + v2[1];
+  return out;
+}
+function scaleAndAdd(out, v1, v2, a) {
+  out[0] = v1[0] + v2[0] * a;
+  out[1] = v1[1] + v2[1] * a;
+  return out;
+}
+function sub(out, v1, v2) {
+  out[0] = v1[0] - v2[0];
+  out[1] = v1[1] - v2[1];
+  return out;
+}
+function len(v) {
+  return Math.sqrt(lenSquare(v));
+}
+var length = len;
+function lenSquare(v) {
+  return v[0] * v[0] + v[1] * v[1];
+}
+var lengthSquare = lenSquare;
+function mul(out, v1, v2) {
+  out[0] = v1[0] * v2[0];
+  out[1] = v1[1] * v2[1];
+  return out;
+}
+function div(out, v1, v2) {
+  out[0] = v1[0] / v2[0];
+  out[1] = v1[1] / v2[1];
+  return out;
+}
+function dot(v1, v2) {
+  return v1[0] * v2[0] + v1[1] * v2[1];
+}
+function scale(out, v, s) {
+  out[0] = v[0] * s;
+  out[1] = v[1] * s;
+  return out;
+}
+function normalize(out, v) {
+  var d = len(v);
+  if (d === 0) {
+    out[0] = 0;
+    out[1] = 0;
+  } else {
+    out[0] = v[0] / d;
+    out[1] = v[1] / d;
+  }
+  return out;
+}
+function distance(v1, v2) {
+  return Math.sqrt((v1[0] - v2[0]) * (v1[0] - v2[0]) + (v1[1] - v2[1]) * (v1[1] - v2[1]));
+}
+var dist = distance;
+function distanceSquare(v1, v2) {
+  return (v1[0] - v2[0]) * (v1[0] - v2[0]) + (v1[1] - v2[1]) * (v1[1] - v2[1]);
+}
+var distSquare = distanceSquare;
+function negate(out, v) {
+  out[0] = -v[0];
+  out[1] = -v[1];
+  return out;
+}
+function lerp(out, v1, v2, t) {
+  out[0] = v1[0] + t * (v2[0] - v1[0]);
+  out[1] = v1[1] + t * (v2[1] - v1[1]);
+  return out;
+}
+function applyTransform(out, v, m) {
+  var x = v[0];
+  var y = v[1];
+  out[0] = m[0] * x + m[2] * y + m[4];
+  out[1] = m[1] * x + m[3] * y + m[5];
+  return out;
+}
+function min(out, v1, v2) {
+  out[0] = Math.min(v1[0], v2[0]);
+  out[1] = Math.min(v1[1], v2[1]);
+  return out;
+}
+function max(out, v1, v2) {
+  out[0] = Math.max(v1[0], v2[0]);
+  out[1] = Math.max(v1[1], v2[1]);
+  return out;
+}
+export {
+  add,
+  applyTransform,
+  clone,
+  copy,
+  create,
+  dist,
+  distSquare,
+  distance,
+  distanceSquare,
+  div,
+  dot,
+  len,
+  lenSquare,
+  length,
+  lengthSquare,
+  lerp,
+  max,
+  min,
+  mul,
+  negate,
+  normalize,
+  scale,
+  scaleAndAdd,
+  set,
+  sub
+};