@idraw/util 0.2.0-alpha.9 → 0.3.0-0.3.0-beta.6.0

package/dist/index.global.js

@@ -1,288 +1,714 @@
-var iDrawUtil = (function () {
-  'use strict';
-
-  function compose(middleware) {
-      return function (context, next) {
-          return dispatch(0);
-          function dispatch(i) {
-              var fn = middleware[i];
-              if (i === middleware.length && next) {
-                  fn = next;
-              }
-              if (!fn)
-                  return Promise.resolve();
-              try {
-                  return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
-              }
-              catch (err) {
-                  return Promise.reject(err);
-              }
-          }
-      };
-  }
-  function delay(time) {
-      return new Promise(function (resolve) {
-          setTimeout(function () {
-              resolve();
-          }, time);
-      });
-  }
-  function throttle(fn, timeout) {
-      var timer = -1;
-      return function () {
-          var args = [];
-          for (var _i = 0; _i < arguments.length; _i++) {
-              args[_i] = arguments[_i];
-          }
-          if (timer > 0) {
-              return;
-          }
-          timer = setTimeout(function () {
-              fn.apply(void 0, args);
-              timer = -1;
-          }, timeout);
-      };
-  }
-
-  function downloadImageFromCanvas(canvas, opts) {
-      var filename = opts.filename, _a = opts.type, type = _a === void 0 ? 'image/jpeg' : _a;
-      var stream = canvas.toDataURL(type);
-      var downloadLink = document.createElement('a');
-      downloadLink.href = stream;
-      downloadLink.download = filename;
-      var downloadClickEvent = document.createEvent('MouseEvents');
-      downloadClickEvent.initEvent('click', true, false);
-      downloadLink.dispatchEvent(downloadClickEvent);
-  }
-
-  function toColorHexNum(color) {
-      return parseInt(color.replace(/^\#/, '0x'));
-  }
-  function toColorHexStr(color) {
-      return '#' + color.toString(16);
-  }
-  function isColorStr(color) {
-      return typeof color === 'string' && /^\#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(color);
-  }
-
-  function createUUID() {
-      function str4() {
-          return (((1 + Math.random()) * 0x10000) | 0).toString(16).substring(1);
-      }
-      return "" + str4() + str4() + "-" + str4() + "-" + str4() + "-" + str4() + "-" + str4() + str4() + str4();
-  }
-
-  function deepClone(target) {
-      function _clone(t) {
-          var type = is(t);
-          if (['Null', 'Number', 'String', 'Boolean', 'Undefined'].indexOf(type) >= 0) {
-              return t;
-          }
-          else if (type === 'Array') {
-              var arr_1 = [];
-              t.forEach(function (item) {
-                  arr_1.push(_clone(item));
-              });
-              return arr_1;
-          }
-          else if (type === 'Object') {
-              var obj_1 = {};
-              var keys = Object.keys(t);
-              keys.forEach(function (key) {
-                  obj_1[key] = _clone(t[key]);
-              });
-              return obj_1;
-          }
-      }
-      return _clone(target);
-  }
-  function is(data) {
-      return Object.prototype.toString.call(data).replace(/[\]|\[]{1,1}/ig, '').split(' ')[1];
-  }
-
-  function parsePrototype(data) {
-      var typeStr = Object.prototype.toString.call(data) || '';
-      var result = typeStr.replace(/(\[object|\])/ig, '').trim();
-      return result;
-  }
-  var istype = {
-      type: function (data, lowerCase) {
-          var result = parsePrototype(data);
-          return lowerCase === true ? result.toLocaleLowerCase() : result;
-      },
-      array: function (data) {
-          return parsePrototype(data) === 'Array';
-      },
-      json: function (data) {
-          return parsePrototype(data) === 'Object';
-      },
-      function: function (data) {
-          return parsePrototype(data) === 'Function';
-      },
-      asyncFunction: function (data) {
-          return parsePrototype(data) === 'AsyncFunction';
-      },
-      string: function (data) {
-          return parsePrototype(data) === 'String';
-      },
-      number: function (data) {
-          return parsePrototype(data) === 'Number';
-      },
-      undefined: function (data) {
-          return parsePrototype(data) === 'Undefined';
-      },
-      null: function (data) {
-          return parsePrototype(data) === 'Null';
-      },
-      promise: function (data) {
-          return parsePrototype(data) === 'Promise';
-      },
+var iDrawUtil = function(exports) {
+  "use strict";
+  function compose(middleware) {
+    return function(context, next) {
+      return dispatch(0);
+      function dispatch(i) {
+        let fn = middleware[i];
+        if (i === middleware.length && next) {
+          fn = next;
+        }
+        if (!fn)
+          return Promise.resolve();
+        try {
+          return Promise.resolve(fn(context, dispatch.bind(null, i + 1)));
+        } catch (err) {
+          return Promise.reject(err);
+        }
+      }
+    };
+  }
+  function delay(time) {
+    return new Promise((resolve) => {
+      setTimeout(() => {
+        resolve();
+      }, time);
+    });
+  }
+  function throttle(fn, timeout) {
+    let timer = -1;
+    return function(...args) {
+      if (timer > 0) {
+        return;
+      }
+      timer = setTimeout(() => {
+        fn(...args);
+        timer = -1;
+      }, timeout);
+    };
+  }
+  function downloadImageFromCanvas(canvas, opts) {
+    const { filename, type = "image/jpeg" } = opts;
+    const stream = canvas.toDataURL(type);
+    const downloadLink = document.createElement("a");
+    downloadLink.href = stream;
+    downloadLink.download = filename;
+    const downloadClickEvent = document.createEvent("MouseEvents");
+    downloadClickEvent.initEvent("click", true, false);
+    downloadLink.dispatchEvent(downloadClickEvent);
+  }
+  function toColorHexNum(color2) {
+    return parseInt(color2.replace(/^\#/, "0x"));
+  }
+  function toColorHexStr(color2) {
+    return "#" + color2.toString(16);
+  }
+  function isColorStr(color2) {
+    return typeof color2 === "string" && /^\#([0-9a-f]{3}|[0-9a-f]{6}|[0-9a-f]{8})$/i.test(color2);
+  }
+  function createUUID() {
+    function str4() {
+      return ((1 + Math.random()) * 65536 | 0).toString(16).substring(1);
+    }
+    return `${str4()}${str4()}-${str4()}-${str4()}-${str4()}-${str4()}${str4()}${str4()}`;
+  }
+  function deepClone(target) {
+    function _clone(t) {
+      const type = is$1(t);
+      if (["Null", "Number", "String", "Boolean", "Undefined"].indexOf(type) >= 0) {
+        return t;
+      } else if (type === "Array") {
+        const arr = [];
+        t.forEach((item) => {
+          arr.push(_clone(item));
+        });
+        return arr;
+      } else if (type === "Object") {
+        const obj = {};
+        const keys = Object.keys(t);
+        keys.forEach((key) => {
+          obj[key] = _clone(t[key]);
+        });
+        return obj;
+      }
+    }
+    return _clone(target);
+  }
+  function is$1(data) {
+    return Object.prototype.toString.call(data).replace(/[\]|\[]{1,1}/ig, "").split(" ")[1];
+  }
+  function parsePrototype(data) {
+    const typeStr = Object.prototype.toString.call(data) || "";
+    const result = typeStr.replace(/(\[object|\])/ig, "").trim();
+    return result;
+  }
+  const istype = {
+    type(data, lowerCase) {
+      const result = parsePrototype(data);
+      return lowerCase === true ? result.toLocaleLowerCase() : result;
+    },
+    array(data) {
+      return parsePrototype(data) === "Array";
+    },
+    json(data) {
+      return parsePrototype(data) === "Object";
+    },
+    function(data) {
+      return parsePrototype(data) === "Function";
+    },
+    asyncFunction(data) {
+      return parsePrototype(data) === "AsyncFunction";
+    },
+    string(data) {
+      return parsePrototype(data) === "String";
+    },
+    number(data) {
+      return parsePrototype(data) === "Number";
+    },
+    undefined(data) {
+      return parsePrototype(data) === "Undefined";
+    },
+    null(data) {
+      return parsePrototype(data) === "Null";
+    },
+    promise(data) {
+      return parsePrototype(data) === "Promise";
+    }
+    // nodeList (data: any): boolean {
+    //   return parsePrototype(data) === 'NodeList';
+    // },
+    // imageData(data: any): boolean {
+    //   return parsePrototype(data) === 'ImageData';
+    // }
   };
-
-  function __awaiter(thisArg, _arguments, P, generator) {
-      function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-      return new (P || (P = Promise))(function (resolve, reject) {
-          function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-          function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-          function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-          step((generator = generator.apply(thisArg, _arguments || [])).next());
-      });
-  }
-  function __generator(thisArg, body) {
-      var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-      return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-      function verb(n) { return function (v) { return step([n, v]); }; }
-      function step(op) {
-          if (f) throw new TypeError("Generator is already executing.");
-          while (_) try {
-              if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-              if (y = 0, t) op = [op[0] & 2, t.value];
-              switch (op[0]) {
-                  case 0: case 1: t = op; break;
-                  case 4: _.label++; return { value: op[1], done: false };
-                  case 5: _.label++; y = op[1]; op = [0]; continue;
-                  case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                  default:
-                      if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                      if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                      if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                      if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                      if (t[2]) _.ops.pop();
-                      _.trys.pop(); continue;
-              }
-              op = body.call(thisArg, _);
-          } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-          if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+  function parseHTMLToDataURL(html2, opts) {
+    const { width, height } = opts;
+    return new Promise((resolve, reject) => {
+      const _svg = `
+    <svg xmlns="http://www.w3.org/2000/svg" width="${width || ""}" height = "${height || ""}">
+      <foreignObject width="100%" height="100%">
+        <div xmlns = "http://www.w3.org/1999/xhtml">
+          ${html2}
+        </div>
+      </foreignObject>
+    </svg>
+    `;
+      const blob = new Blob([_svg], { type: "image/svg+xml;charset=utf-8" });
+      const reader = new FileReader();
+      reader.readAsDataURL(blob);
+      reader.onload = function(event) {
+        var _a;
+        const base64 = (_a = event == null ? void 0 : event.target) == null ? void 0 : _a.result;
+        resolve(base64);
+      };
+      reader.onerror = function(err) {
+        reject(err);
+      };
+    });
+  }
+  function parseSVGToDataURL(svg2) {
+    return new Promise((resolve, reject) => {
+      const _svg = svg2;
+      const blob = new Blob([_svg], { type: "image/svg+xml;charset=utf-8" });
+      const reader = new FileReader();
+      reader.readAsDataURL(blob);
+      reader.onload = function(event) {
+        var _a;
+        const base64 = (_a = event == null ? void 0 : event.target) == null ? void 0 : _a.result;
+        resolve(base64);
+      };
+      reader.onerror = function(err) {
+        reject(err);
+      };
+    });
+  }
+  const { Image } = window;
+  function loadImage(src) {
+    return new Promise((resolve, reject) => {
+      const img = new Image();
+      img.crossOrigin = "anonymous";
+      img.onload = function() {
+        resolve(img);
+      };
+      img.onabort = reject;
+      img.onerror = reject;
+      img.src = src;
+    });
+  }
+  async function loadSVG(svg2) {
+    const dataURL = await parseSVGToDataURL(svg2);
+    const image = await loadImage(dataURL);
+    return image;
+  }
+  function filterAmpersand(str) {
+    return str.replace(/\&/ig, "&amp;");
+  }
+  async function loadHTML(html2, opts) {
+    html2 = filterAmpersand(html2);
+    const dataURL = await parseHTMLToDataURL(html2, opts);
+    const image = await loadImage(dataURL);
+    return image;
+  }
+  class Context {
+    // private _scale: number;
+    // private _scrollX: number;
+    // private _scrollY: number;
+    constructor(ctx, opts) {
+      this._opts = opts;
+      this._ctx = ctx;
+      this._transform = {
+        scale: 1,
+        scrollX: 0,
+        scrollY: 0
+      };
+    }
+    getContext() {
+      return this._ctx;
+    }
+    resetSize(opts) {
+      this._opts = { ...this._opts, ...opts };
+    }
+    calcDeviceNum(num) {
+      return num * this._opts.devicePixelRatio;
+    }
+    calcScreenNum(num) {
+      return num / this._opts.devicePixelRatio;
+    }
+    getSize() {
+      return {
+        width: this._opts.width,
+        height: this._opts.height,
+        contextWidth: this._opts.contextWidth,
+        contextHeight: this._opts.contextHeight,
+        devicePixelRatio: this._opts.devicePixelRatio
+      };
+    }
+    setTransform(config) {
+      this._transform = { ...this._transform, ...config };
+    }
+    getTransform() {
+      return {
+        scale: this._transform.scale,
+        scrollX: this._transform.scrollX,
+        scrollY: this._transform.scrollY
+      };
+    }
+    setFillStyle(color2) {
+      this._ctx.fillStyle = color2;
+    }
+    fill(fillRule) {
+      return this._ctx.fill(fillRule || "nonzero");
+    }
+    arc(x2, y2, radius, startAngle, endAngle, anticlockwise) {
+      return this._ctx.arc(
+        this._doSize(x2),
+        this._doSize(y2),
+        this._doSize(radius),
+        startAngle,
+        endAngle,
+        anticlockwise
+      );
+    }
+    rect(x2, y2, w2, h2) {
+      return this._ctx.rect(
+        this._doSize(x2),
+        this._doSize(y2),
+        this._doSize(w2),
+        this._doSize(h2)
+      );
+    }
+    fillRect(x2, y2, w2, h2) {
+      return this._ctx.fillRect(
+        this._doSize(x2),
+        this._doSize(y2),
+        this._doSize(w2),
+        this._doSize(h2)
+      );
+    }
+    clearRect(x2, y2, w2, h2) {
+      return this._ctx.clearRect(
+        this._doSize(x2),
+        this._doSize(y2),
+        this._doSize(w2),
+        this._doSize(h2)
+      );
+    }
+    beginPath() {
+      return this._ctx.beginPath();
+    }
+    closePath() {
+      return this._ctx.closePath();
+    }
+    lineTo(x2, y2) {
+      return this._ctx.lineTo(this._doSize(x2), this._doSize(y2));
+    }
+    moveTo(x2, y2) {
+      return this._ctx.moveTo(this._doSize(x2), this._doSize(y2));
+    }
+    arcTo(x1, y1, x2, y2, radius) {
+      return this._ctx.arcTo(
+        this._doSize(x1),
+        this._doSize(y1),
+        this._doSize(x2),
+        this._doSize(y2),
+        this._doSize(radius)
+      );
+    }
+    setLineWidth(w2) {
+      return this._ctx.lineWidth = this._doSize(w2);
+    }
+    setLineDash(nums) {
+      return this._ctx.setLineDash(nums.map((n) => this._doSize(n)));
+    }
+    isPointInPath(x2, y2) {
+      return this._ctx.isPointInPath(this._doX(x2), this._doY(y2));
+    }
+    isPointInPathWithoutScroll(x2, y2) {
+      return this._ctx.isPointInPath(this._doSize(x2), this._doSize(y2));
+    }
+    setStrokeStyle(color2) {
+      this._ctx.strokeStyle = color2;
+    }
+    stroke() {
+      return this._ctx.stroke();
+    }
+    translate(x2, y2) {
+      return this._ctx.translate(this._doSize(x2), this._doSize(y2));
+    }
+    rotate(angle2) {
+      return this._ctx.rotate(angle2);
+    }
+    drawImage(...args) {
+      const image = args[0];
+      const sx = args[1];
+      const sy = args[2];
+      const sw = args[3];
+      const sh = args[4];
+      const dx = args[args.length - 4];
+      const dy = args[args.length - 3];
+      const dw = args[args.length - 2];
+      const dh = args[args.length - 1];
+      if (args.length === 9) {
+        return this._ctx.drawImage(
+          image,
+          this._doSize(sx),
+          this._doSize(sy),
+          this._doSize(sw),
+          this._doSize(sh),
+          this._doSize(dx),
+          this._doSize(dy),
+          this._doSize(dw),
+          this._doSize(dh)
+        );
+      } else {
+        return this._ctx.drawImage(
+          image,
+          this._doSize(dx),
+          this._doSize(dy),
+          this._doSize(dw),
+          this._doSize(dh)
+        );
+      }
+    }
+    createPattern(image, repetition) {
+      return this._ctx.createPattern(image, repetition);
+    }
+    measureText(text2) {
+      return this._ctx.measureText(text2);
+    }
+    setTextAlign(align) {
+      this._ctx.textAlign = align;
+    }
+    fillText(text2, x2, y2, maxWidth) {
+      if (maxWidth !== void 0) {
+        return this._ctx.fillText(
+          text2,
+          this._doSize(x2),
+          this._doSize(y2),
+          this._doSize(maxWidth)
+        );
+      } else {
+        return this._ctx.fillText(text2, this._doSize(x2), this._doSize(y2));
       }
+    }
+    strokeText(text2, x2, y2, maxWidth) {
+      if (maxWidth !== void 0) {
+        return this._ctx.strokeText(
+          text2,
+          this._doSize(x2),
+          this._doSize(y2),
+          this._doSize(maxWidth)
+        );
+      } else {
+        return this._ctx.strokeText(text2, this._doSize(x2), this._doSize(y2));
+      }
+    }
+    setFont(opts) {
+      const strList = [];
+      if (opts.fontWeight === "bold") {
+        strList.push(`${opts.fontWeight}`);
+      }
+      strList.push(`${this._doSize(opts.fontSize || 12)}px`);
+      strList.push(`${opts.fontFamily || "sans-serif"}`);
+      this._ctx.font = `${strList.join(" ")}`;
+    }
+    setTextBaseline(baseline) {
+      this._ctx.textBaseline = baseline;
+    }
+    setGlobalAlpha(alpha) {
+      this._ctx.globalAlpha = alpha;
+    }
+    save() {
+      this._ctx.save();
+    }
+    restore() {
+      this._ctx.restore();
+    }
+    scale(ratioX, ratioY) {
+      this._ctx.scale(ratioX, ratioY);
+    }
+    setShadowColor(color2) {
+      this._ctx.shadowColor = color2;
+    }
+    setShadowOffsetX(offsetX) {
+      this._ctx.shadowOffsetX = this._doSize(offsetX);
+    }
+    setShadowOffsetY(offsetY) {
+      this._ctx.shadowOffsetY = this._doSize(offsetY);
+    }
+    setShadowBlur(blur) {
+      this._ctx.shadowBlur = this._doSize(blur);
+    }
+    ellipse(x2, y2, radiusX, radiusY, rotation, startAngle, endAngle, counterclockwise) {
+      this._ctx.ellipse(
+        this._doSize(x2),
+        this._doSize(y2),
+        this._doSize(radiusX),
+        this._doSize(radiusY),
+        rotation,
+        startAngle,
+        endAngle,
+        counterclockwise
+      );
+    }
+    _doSize(num) {
+      return this._opts.devicePixelRatio * num;
+    }
+    _doX(x2) {
+      const { scale, scrollX } = this._transform;
+      const _x = (x2 - scrollX) / scale;
+      return this._doSize(_x);
+    }
+    _doY(y2) {
+      const { scale, scrollY } = this._transform;
+      const _y = (y2 - scrollY) / scale;
+      return this._doSize(_y);
+    }
+  }
+  function number(value) {
+    return typeof value === "number" && (value > 0 || value <= 0);
+  }
+  function x(value) {
+    return number(value);
+  }
+  function y(value) {
+    return number(value);
+  }
+  function w(value) {
+    return typeof value === "number" && value >= 0;
+  }
+  function h(value) {
+    return typeof value === "number" && value >= 0;
   }
-
-  function parseHTMLToDataURL(html, opts) {
-      var width = opts.width, height = opts.height;
-      return new Promise(function (resolve, reject) {
-          var _svg = "\n    <svg xmlns=\"http://www.w3.org/2000/svg\" width=\"" + (width || '') + "\" height = \"" + (height || '') + "\">\n      <foreignObject width=\"100%\" height=\"100%\">\n        <div xmlns = \"http://www.w3.org/1999/xhtml\">\n          " + html + "\n        </div>\n      </foreignObject>\n    </svg>\n    ";
-          var blob = new Blob([_svg], { type: 'image/svg+xml;charset=utf-8' });
-          var reader = new FileReader();
-          reader.readAsDataURL(blob);
-          reader.onload = function (event) {
-              var _a;
-              var base64 = (_a = event === null || event === void 0 ? void 0 : event.target) === null || _a === void 0 ? void 0 : _a.result;
-              resolve(base64);
-          };
-          reader.onerror = function (err) {
-              reject(err);
-          };
-      });
-  }
-  function parseSVGToDataURL(svg) {
-      return new Promise(function (resolve, reject) {
-          var _svg = svg;
-          var blob = new Blob([_svg], { type: 'image/svg+xml;charset=utf-8' });
-          var reader = new FileReader();
-          reader.readAsDataURL(blob);
-          reader.onload = function (event) {
-              var _a;
-              var base64 = (_a = event === null || event === void 0 ? void 0 : event.target) === null || _a === void 0 ? void 0 : _a.result;
-              resolve(base64);
-          };
-          reader.onerror = function (err) {
-              reject(err);
-          };
-      });
-  }
-
-  var Image = window.Image;
-  function loadImage(src) {
-      return new Promise(function (resolve, reject) {
-          var img = new Image;
-          img.onload = function () {
-              resolve(img);
-          };
-          img.onabort = reject;
-          img.onerror = reject;
-          img.src = src;
-      });
-  }
-  function loadSVG(svg) {
-      return __awaiter(this, void 0, void 0, function () {
-          var dataURL, image;
-          return __generator(this, function (_a) {
-              switch (_a.label) {
-                  case 0: return [4, parseSVGToDataURL(svg)];
-                  case 1:
-                      dataURL = _a.sent();
-                      return [4, loadImage(dataURL)];
-                  case 2:
-                      image = _a.sent();
-                      return [2, image];
-              }
-          });
-      });
-  }
-  function loadHTML(html, opts) {
-      return __awaiter(this, void 0, void 0, function () {
-          var dataURL, image;
-          return __generator(this, function (_a) {
-              switch (_a.label) {
-                  case 0: return [4, parseHTMLToDataURL(html, opts)];
-                  case 1:
-                      dataURL = _a.sent();
-                      return [4, loadImage(dataURL)];
-                  case 2:
-                      image = _a.sent();
-                      return [2, image];
-              }
-          });
-      });
-  }
-
-  var index = {
-      time: {
-          delay: delay,
-          compose: compose,
-          throttle: throttle,
-      },
-      loader: {
-          loadImage: loadImage,
-          loadSVG: loadSVG,
-          loadHTML: loadHTML,
-      },
-      file: {
-          downloadImageFromCanvas: downloadImageFromCanvas,
-      },
-      color: {
-          toColorHexStr: toColorHexStr,
-          toColorHexNum: toColorHexNum,
-          isColorStr: isColorStr,
-      },
-      uuid: {
-          createUUID: createUUID
-      },
-      istype: istype,
-      data: {
-          deepClone: deepClone,
-      }
+  function angle(value) {
+    return typeof value === "number" && value >= -360 && value <= 360;
+  }
+  function borderWidth(value) {
+    return w(value);
+  }
+  function borderRadius(value) {
+    return number(value) && value >= 0;
+  }
+  function color(value) {
+    return isColorStr(value);
+  }
+  function imageURL(value) {
+    return typeof value === "string" && /^(http:\/\/|https:\/\/|\.\/|\/)/.test(`${value}`);
+  }
+  function imageBase64(value) {
+    return typeof value === "string" && /^(data:image\/)/.test(`${value}`);
+  }
+  function imageSrc(value) {
+    return imageBase64(value) || imageURL(value);
+  }
+  function svg(value) {
+    return typeof value === "string" && /^(<svg[\s]{1,}|<svg>)/i.test(`${value}`.trim()) && /<\/[\s]{0,}svg>$/i.test(`${value}`.trim());
+  }
+  function html(value) {
+    let result = false;
+    if (typeof value === "string") {
+      let div = document.createElement("div");
+      div.innerHTML = value;
+      if (div.children.length > 0) {
+        result = true;
+      }
+      div = null;
+    }
+    return result;
+  }
+  function text(value) {
+    return typeof value === "string";
+  }
+  function fontSize(value) {
+    return number(value) && value > 0;
+  }
+  function lineHeight(value) {
+    return number(value) && value > 0;
+  }
+  function strokeWidth(value) {
+    return number(value) && value > 0;
+  }
+  function textAlign(value) {
+    return ["center", "left", "right"].includes(value);
+  }
+  function fontFamily(value) {
+    return typeof value === "string" && value.length > 0;
+  }
+  function fontWeight(value) {
+    return ["bold"].includes(value);
+  }
+  const is = {
+    x,
+    y,
+    w,
+    h,
+    angle,
+    number,
+    borderWidth,
+    borderRadius,
+    color,
+    imageSrc,
+    imageURL,
+    imageBase64,
+    svg,
+    html,
+    text,
+    fontSize,
+    lineHeight,
+    textAlign,
+    fontFamily,
+    fontWeight,
+    strokeWidth
+  };
+  function attrs(attrs2) {
+    const { x: x2, y: y2, w: w2, h: h2, angle: angle2 } = attrs2;
+    if (!(is.x(x2) && is.y(y2) && is.w(w2) && is.h(h2) && is.angle(angle2))) {
+      return false;
+    }
+    if (!(angle2 >= -360 && angle2 <= 360)) {
+      return false;
+    }
+    return true;
+  }
+  function box(desc = {}) {
+    const { borderColor, borderRadius: borderRadius2, borderWidth: borderWidth2 } = desc;
+    if (desc.hasOwnProperty("borderColor") && !is.color(borderColor)) {
+      return false;
+    }
+    if (desc.hasOwnProperty("borderRadius") && !is.number(borderRadius2)) {
+      return false;
+    }
+    if (desc.hasOwnProperty("borderWidth") && !is.number(borderWidth2)) {
+      return false;
+    }
+    return true;
+  }
+  function rectDesc(desc) {
+    const { bgColor } = desc;
+    if (desc.hasOwnProperty("bgColor") && !is.color(bgColor)) {
+      return false;
+    }
+    if (!box(desc)) {
+      return false;
+    }
+    return true;
+  }
+  function circleDesc(desc) {
+    const { bgColor, borderColor, borderWidth: borderWidth2 } = desc;
+    if (desc.hasOwnProperty("bgColor") && !is.color(bgColor)) {
+      return false;
+    }
+    if (desc.hasOwnProperty("borderColor") && !is.color(borderColor)) {
+      return false;
+    }
+    if (desc.hasOwnProperty("borderWidth") && !is.number(borderWidth2)) {
+      return false;
+    }
+    return true;
+  }
+  function imageDesc(desc) {
+    const { src } = desc;
+    if (!is.imageSrc(src)) {
+      return false;
+    }
+    return true;
+  }
+  function svgDesc(desc) {
+    const { svg: svg2 } = desc;
+    if (!is.svg(svg2)) {
+      return false;
+    }
+    return true;
+  }
+  function htmlDesc(desc) {
+    const { html: html2 } = desc;
+    if (!is.html(html2)) {
+      return false;
+    }
+    return true;
+  }
+  function textDesc(desc) {
+    const {
+      text: text2,
+      color: color2,
+      fontSize: fontSize2,
+      lineHeight: lineHeight2,
+      fontFamily: fontFamily2,
+      textAlign: textAlign2,
+      fontWeight: fontWeight2,
+      bgColor,
+      strokeWidth: strokeWidth2,
+      strokeColor
+    } = desc;
+    if (!is.text(text2)) {
+      return false;
+    }
+    if (!is.color(color2)) {
+      return false;
+    }
+    if (!is.fontSize(fontSize2)) {
+      return false;
+    }
+    if (desc.hasOwnProperty("bgColor") && !is.color(bgColor)) {
+      return false;
+    }
+    if (desc.hasOwnProperty("fontWeight") && !is.fontWeight(fontWeight2)) {
+      return false;
+    }
+    if (desc.hasOwnProperty("lineHeight") && !is.lineHeight(lineHeight2)) {
+      return false;
+    }
+    if (desc.hasOwnProperty("fontFamily") && !is.fontFamily(fontFamily2)) {
+      return false;
+    }
+    if (desc.hasOwnProperty("textAlign") && !is.textAlign(textAlign2)) {
+      return false;
+    }
+    if (desc.hasOwnProperty("strokeWidth") && !is.strokeWidth(strokeWidth2)) {
+      return false;
+    }
+    if (desc.hasOwnProperty("strokeColor") && !is.color(strokeColor)) {
+      return false;
+    }
+    if (!box(desc)) {
+      return false;
+    }
+    return true;
+  }
+  const check = {
+    attrs,
+    textDesc,
+    rectDesc,
+    circleDesc,
+    imageDesc,
+    svgDesc,
+    htmlDesc
+  };
+  const index = {
+    is,
+    check,
+    delay,
+    compose,
+    throttle,
+    loadImage,
+    loadSVG,
+    loadHTML,
+    downloadImageFromCanvas,
+    toColorHexStr,
+    toColorHexNum,
+    isColorStr,
+    createUUID,
+    istype,
+    deepClone,
+    Context
   };
-
-  return index;
-
-})();
+  exports.Context = Context;
+  exports.check = check;
+  exports.compose = compose;
+  exports.createUUID = createUUID;
+  exports.deepClone = deepClone;
+  exports.default = index;
+  exports.delay = delay;
+  exports.downloadImageFromCanvas = downloadImageFromCanvas;
+  exports.is = is;
+  exports.isColorStr = isColorStr;
+  exports.istype = istype;
+  exports.loadHTML = loadHTML;
+  exports.loadImage = loadImage;
+  exports.loadSVG = loadSVG;
+  exports.throttle = throttle;
+  exports.toColorHexNum = toColorHexNum;
+  exports.toColorHexStr = toColorHexStr;
+  Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+  return exports;
+}({});