eddyter 1.4.11 → 1.4.12

package/dist/LazySignatureCanvas-Cck44R9l.js

@@ -0,0 +1,528 @@
+import { jsx as j } from "react/jsx-runtime";
+import A, { Component as q, forwardRef as I } from "react";
+import { _ as V, a as $ } from "./objectWithoutPropertiesLoose-DO0w4vQT.js";
+import { g as N } from "./index-Dh0oRk6u.js";
+function H(e, n) {
+  if (e == null)
+    return {};
+  var r, t, o = V(e, n);
+  if (Object.getOwnPropertySymbols) {
+    var a = Object.getOwnPropertySymbols(e);
+    for (t = 0; t < a.length; t++)
+      r = a[t], n.indexOf(r) === -1 && {}.propertyIsEnumerable.call(e, r) && (o[r] = e[r]);
+  }
+  return o;
+}
+function O(e) {
+  "@babel/helpers - typeof";
+  return O = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(n) {
+    return typeof n;
+  } : function(n) {
+    return n && typeof Symbol == "function" && n.constructor === Symbol && n !== Symbol.prototype ? "symbol" : typeof n;
+  }, O(e);
+}
+function Y(e, n, r) {
+  return Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), e;
+}
+function X(e, n) {
+  if (!(e instanceof n))
+    throw new TypeError("Cannot call a class as a function");
+}
+function M(e, n) {
+  return M = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function(r, t) {
+    return r.__proto__ = t, r;
+  }, M(e, n);
+}
+function G(e, n) {
+  if (typeof n != "function" && n !== null)
+    throw new TypeError("Super expression must either be null or a function");
+  e.prototype = Object.create(n && n.prototype, {
+    constructor: {
+      value: e,
+      writable: !0,
+      configurable: !0
+    }
+  }), Object.defineProperty(e, "prototype", {
+    writable: !1
+  }), n && M(e, n);
+}
+function T(e) {
+  return T = Object.setPrototypeOf ? Object.getPrototypeOf.bind() : function(n) {
+    return n.__proto__ || Object.getPrototypeOf(n);
+  }, T(e);
+}
+function U() {
+  try {
+    var e = !Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function() {
+    }));
+  } catch {
+  }
+  return (U = function() {
+    return !!e;
+  })();
+}
+function J(e) {
+  if (e === void 0)
+    throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
+  return e;
+}
+function K(e, n) {
+  if (n && (O(n) == "object" || typeof n == "function"))
+    return n;
+  if (n !== void 0)
+    throw new TypeError("Derived constructors may only return object or undefined");
+  return J(e);
+}
+function Q(e) {
+  var n = U();
+  return function() {
+    var r, t = T(e);
+    if (n) {
+      var o = T(this).constructor;
+      r = Reflect.construct(t, arguments, o);
+    } else
+      r = t.apply(this, arguments);
+    return K(this, r);
+  };
+}
+var S = { exports: {} }, R, L;
+function Z() {
+  if (L)
+    return R;
+  L = 1;
+  var e = "SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED";
+  return R = e, R;
+}
+var D, k;
+function tt() {
+  if (k)
+    return D;
+  k = 1;
+  var e = /* @__PURE__ */ Z();
+  function n() {
+  }
+  function r() {
+  }
+  return r.resetWarningCache = n, D = function() {
+    function t(c, i, h, s, u, p) {
+      if (p !== e) {
+        var l = new Error(
+          "Calling PropTypes validators directly is not supported by the `prop-types` package. Use PropTypes.checkPropTypes() to call them. Read more at http://fb.me/use-check-prop-types"
+        );
+        throw l.name = "Invariant Violation", l;
+      }
+    }
+    t.isRequired = t;
+    function o() {
+      return t;
+    }
+    var a = {
+      array: t,
+      bigint: t,
+      bool: t,
+      func: t,
+      number: t,
+      object: t,
+      string: t,
+      symbol: t,
+      any: t,
+      arrayOf: o,
+      element: t,
+      elementType: t,
+      instanceOf: o,
+      node: t,
+      objectOf: o,
+      oneOf: o,
+      oneOfType: o,
+      shape: o,
+      exact: o,
+      checkPropTypes: r,
+      resetWarningCache: n
+    };
+    return a.PropTypes = a, a;
+  }, D;
+}
+var z;
+function et() {
+  return z || (z = 1, S.exports = /* @__PURE__ */ tt()()), S.exports;
+}
+var nt = /* @__PURE__ */ et();
+const g = /* @__PURE__ */ N(nt);
+function b(e, n, r) {
+  this.x = e, this.y = n, this.time = r || (/* @__PURE__ */ new Date()).getTime();
+}
+b.prototype.velocityFrom = function(e) {
+  return this.time !== e.time ? this.distanceTo(e) / (this.time - e.time) : 1;
+};
+b.prototype.distanceTo = function(e) {
+  return Math.sqrt(Math.pow(this.x - e.x, 2) + Math.pow(this.y - e.y, 2));
+};
+b.prototype.equals = function(e) {
+  return this.x === e.x && this.y === e.y && this.time === e.time;
+};
+function W(e, n, r, t) {
+  this.startPoint = e, this.control1 = n, this.control2 = r, this.endPoint = t;
+}
+W.prototype.length = function() {
+  for (var e = 10, n = 0, r = void 0, t = void 0, o = 0; o <= e; o += 1) {
+    var a = o / e, c = this._point(a, this.startPoint.x, this.control1.x, this.control2.x, this.endPoint.x), i = this._point(a, this.startPoint.y, this.control1.y, this.control2.y, this.endPoint.y);
+    if (o > 0) {
+      var h = c - r, s = i - t;
+      n += Math.sqrt(h * h + s * s);
+    }
+    r = c, t = i;
+  }
+  return n;
+};
+W.prototype._point = function(e, n, r, t, o) {
+  return n * (1 - e) * (1 - e) * (1 - e) + 3 * r * (1 - e) * (1 - e) * e + 3 * t * (1 - e) * e * e + o * e * e * e;
+};
+function rt(e, n, r) {
+  var t, o, a, c = null, i = 0;
+  r || (r = {});
+  var h = function() {
+    i = r.leading === !1 ? 0 : Date.now(), c = null, a = e.apply(t, o), c || (t = o = null);
+  };
+  return function() {
+    var s = Date.now();
+    !i && r.leading === !1 && (i = s);
+    var u = n - (s - i);
+    return t = this, o = arguments, u <= 0 || u > n ? (c && (clearTimeout(c), c = null), i = s, a = e.apply(t, o), c || (t = o = null)) : !c && r.trailing !== !1 && (c = setTimeout(h, u)), a;
+  };
+}
+function d(e, n) {
+  var r = this, t = n || {};
+  this.velocityFilterWeight = t.velocityFilterWeight || 0.7, this.minWidth = t.minWidth || 0.5, this.maxWidth = t.maxWidth || 2.5, this.throttle = "throttle" in t ? t.throttle : 16, this.minDistance = "minDistance" in t ? t.minDistance : 5, this.throttle ? this._strokeMoveUpdate = rt(d.prototype._strokeUpdate, this.throttle) : this._strokeMoveUpdate = d.prototype._strokeUpdate, this.dotSize = t.dotSize || function() {
+    return (this.minWidth + this.maxWidth) / 2;
+  }, this.penColor = t.penColor || "black", this.backgroundColor = t.backgroundColor || "rgba(0,0,0,0)", this.onBegin = t.onBegin, this.onEnd = t.onEnd, this._canvas = e, this._ctx = e.getContext("2d"), this.clear(), this._handleMouseDown = function(o) {
+    o.which === 1 && (r._mouseButtonDown = !0, r._strokeBegin(o));
+  }, this._handleMouseMove = function(o) {
+    r._mouseButtonDown && r._strokeMoveUpdate(o);
+  }, this._handleMouseUp = function(o) {
+    o.which === 1 && r._mouseButtonDown && (r._mouseButtonDown = !1, r._strokeEnd(o));
+  }, this._handleTouchStart = function(o) {
+    if (o.targetTouches.length === 1) {
+      var a = o.changedTouches[0];
+      r._strokeBegin(a);
+    }
+  }, this._handleTouchMove = function(o) {
+    o.preventDefault();
+    var a = o.targetTouches[0];
+    r._strokeMoveUpdate(a);
+  }, this._handleTouchEnd = function(o) {
+    var a = o.target === r._canvas;
+    a && (o.preventDefault(), r._strokeEnd(o));
+  }, this.on();
+}
+d.prototype.clear = function() {
+  var e = this._ctx, n = this._canvas;
+  e.fillStyle = this.backgroundColor, e.clearRect(0, 0, n.width, n.height), e.fillRect(0, 0, n.width, n.height), this._data = [], this._reset(), this._isEmpty = !0;
+};
+d.prototype.fromDataURL = function(e) {
+  var n = this, r = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : {}, t = new Image(), o = r.ratio || window.devicePixelRatio || 1, a = r.width || this._canvas.width / o, c = r.height || this._canvas.height / o;
+  this._reset(), t.src = e, t.onload = function() {
+    n._ctx.drawImage(t, 0, 0, a, c);
+  }, this._isEmpty = !1;
+};
+d.prototype.toDataURL = function(e) {
+  var n;
+  switch (e) {
+    case "image/svg+xml":
+      return this._toSVG();
+    default:
+      for (var r = arguments.length, t = Array(r > 1 ? r - 1 : 0), o = 1; o < r; o++)
+        t[o - 1] = arguments[o];
+      return (n = this._canvas).toDataURL.apply(n, [e].concat(t));
+  }
+};
+d.prototype.on = function() {
+  this._handleMouseEvents(), this._handleTouchEvents();
+};
+d.prototype.off = function() {
+  this._canvas.removeEventListener("mousedown", this._handleMouseDown), this._canvas.removeEventListener("mousemove", this._handleMouseMove), document.removeEventListener("mouseup", this._handleMouseUp), this._canvas.removeEventListener("touchstart", this._handleTouchStart), this._canvas.removeEventListener("touchmove", this._handleTouchMove), this._canvas.removeEventListener("touchend", this._handleTouchEnd);
+};
+d.prototype.isEmpty = function() {
+  return this._isEmpty;
+};
+d.prototype._strokeBegin = function(e) {
+  this._data.push([]), this._reset(), this._strokeUpdate(e), typeof this.onBegin == "function" && this.onBegin(e);
+};
+d.prototype._strokeUpdate = function(e) {
+  var n = e.clientX, r = e.clientY, t = this._createPoint(n, r), o = this._data[this._data.length - 1], a = o && o[o.length - 1], c = a && t.distanceTo(a) < this.minDistance;
+  if (!(a && c)) {
+    var i = this._addPoint(t), h = i.curve, s = i.widths;
+    h && s && this._drawCurve(h, s.start, s.end), this._data[this._data.length - 1].push({
+      x: t.x,
+      y: t.y,
+      time: t.time,
+      color: this.penColor
+    });
+  }
+};
+d.prototype._strokeEnd = function(e) {
+  var n = this.points.length > 2, r = this.points[0];
+  if (!n && r && this._drawDot(r), r) {
+    var t = this._data[this._data.length - 1], o = t[t.length - 1];
+    r.equals(o) || t.push({
+      x: r.x,
+      y: r.y,
+      time: r.time,
+      color: this.penColor
+    });
+  }
+  typeof this.onEnd == "function" && this.onEnd(e);
+};
+d.prototype._handleMouseEvents = function() {
+  this._mouseButtonDown = !1, this._canvas.addEventListener("mousedown", this._handleMouseDown), this._canvas.addEventListener("mousemove", this._handleMouseMove), document.addEventListener("mouseup", this._handleMouseUp);
+};
+d.prototype._handleTouchEvents = function() {
+  this._canvas.style.msTouchAction = "none", this._canvas.style.touchAction = "none", this._canvas.addEventListener("touchstart", this._handleTouchStart), this._canvas.addEventListener("touchmove", this._handleTouchMove), this._canvas.addEventListener("touchend", this._handleTouchEnd);
+};
+d.prototype._reset = function() {
+  this.points = [], this._lastVelocity = 0, this._lastWidth = (this.minWidth + this.maxWidth) / 2, this._ctx.fillStyle = this.penColor;
+};
+d.prototype._createPoint = function(e, n, r) {
+  var t = this._canvas.getBoundingClientRect();
+  return new b(e - t.left, n - t.top, r || (/* @__PURE__ */ new Date()).getTime());
+};
+d.prototype._addPoint = function(e) {
+  var n = this.points, r = void 0;
+  if (n.push(e), n.length > 2) {
+    n.length === 3 && n.unshift(n[0]), r = this._calculateCurveControlPoints(n[0], n[1], n[2]);
+    var t = r.c2;
+    r = this._calculateCurveControlPoints(n[1], n[2], n[3]);
+    var o = r.c1, a = new W(n[1], t, o, n[2]), c = this._calculateCurveWidths(a);
+    return n.shift(), { curve: a, widths: c };
+  }
+  return {};
+};
+d.prototype._calculateCurveControlPoints = function(e, n, r) {
+  var t = e.x - n.x, o = e.y - n.y, a = n.x - r.x, c = n.y - r.y, i = { x: (e.x + n.x) / 2, y: (e.y + n.y) / 2 }, h = { x: (n.x + r.x) / 2, y: (n.y + r.y) / 2 }, s = Math.sqrt(t * t + o * o), u = Math.sqrt(a * a + c * c), p = i.x - h.x, l = i.y - h.y, f = u / (s + u), y = { x: h.x + p * f, y: h.y + l * f }, v = n.x - y.x, _ = n.y - y.y;
+  return {
+    c1: new b(i.x + v, i.y + _),
+    c2: new b(h.x + v, h.y + _)
+  };
+};
+d.prototype._calculateCurveWidths = function(e) {
+  var n = e.startPoint, r = e.endPoint, t = { start: null, end: null }, o = this.velocityFilterWeight * r.velocityFrom(n) + (1 - this.velocityFilterWeight) * this._lastVelocity, a = this._strokeWidth(o);
+  return t.start = this._lastWidth, t.end = a, this._lastVelocity = o, this._lastWidth = a, t;
+};
+d.prototype._strokeWidth = function(e) {
+  return Math.max(this.maxWidth / (e + 1), this.minWidth);
+};
+d.prototype._drawPoint = function(e, n, r) {
+  var t = this._ctx;
+  t.moveTo(e, n), t.arc(e, n, r, 0, 2 * Math.PI, !1), this._isEmpty = !1;
+};
+d.prototype._drawCurve = function(e, n, r) {
+  var t = this._ctx, o = r - n, a = Math.floor(e.length());
+  t.beginPath();
+  for (var c = 0; c < a; c += 1) {
+    var i = c / a, h = i * i, s = h * i, u = 1 - i, p = u * u, l = p * u, f = l * e.startPoint.x;
+    f += 3 * p * i * e.control1.x, f += 3 * u * h * e.control2.x, f += s * e.endPoint.x;
+    var y = l * e.startPoint.y;
+    y += 3 * p * i * e.control1.y, y += 3 * u * h * e.control2.y, y += s * e.endPoint.y;
+    var v = n + s * o;
+    this._drawPoint(f, y, v);
+  }
+  t.closePath(), t.fill();
+};
+d.prototype._drawDot = function(e) {
+  var n = this._ctx, r = typeof this.dotSize == "function" ? this.dotSize() : this.dotSize;
+  n.beginPath(), this._drawPoint(e.x, e.y, r), n.closePath(), n.fill();
+};
+d.prototype._fromData = function(e, n, r) {
+  for (var t = 0; t < e.length; t += 1) {
+    var o = e[t];
+    if (o.length > 1)
+      for (var a = 0; a < o.length; a += 1) {
+        var c = o[a], i = new b(c.x, c.y, c.time), h = c.color;
+        if (a === 0)
+          this.penColor = h, this._reset(), this._addPoint(i);
+        else if (a !== o.length - 1) {
+          var s = this._addPoint(i), u = s.curve, p = s.widths;
+          u && p && n(u, p, h);
+        }
+      }
+    else {
+      this._reset();
+      var l = o[0];
+      r(l);
+    }
+  }
+};
+d.prototype._toSVG = function() {
+  var e = this, n = this._data, r = this._canvas, t = Math.max(window.devicePixelRatio || 1, 1), o = 0, a = 0, c = r.width / t, i = r.height / t, h = document.createElementNS("http://www.w3.org/2000/svg", "svg");
+  h.setAttributeNS(null, "width", r.width), h.setAttributeNS(null, "height", r.height), this._fromData(n, function(m, x, P) {
+    var w = document.createElement("path");
+    if (!isNaN(m.control1.x) && !isNaN(m.control1.y) && !isNaN(m.control2.x) && !isNaN(m.control2.y)) {
+      var B = "M " + m.startPoint.x.toFixed(3) + "," + m.startPoint.y.toFixed(3) + " " + ("C " + m.control1.x.toFixed(3) + "," + m.control1.y.toFixed(3) + " ") + (m.control2.x.toFixed(3) + "," + m.control2.y.toFixed(3) + " ") + (m.endPoint.x.toFixed(3) + "," + m.endPoint.y.toFixed(3));
+      w.setAttribute("d", B), w.setAttribute("stroke-width", (x.end * 2.25).toFixed(3)), w.setAttribute("stroke", P), w.setAttribute("fill", "none"), w.setAttribute("stroke-linecap", "round"), h.appendChild(w);
+    }
+  }, function(m) {
+    var x = document.createElement("circle"), P = typeof e.dotSize == "function" ? e.dotSize() : e.dotSize;
+    x.setAttribute("r", P), x.setAttribute("cx", m.x), x.setAttribute("cy", m.y), x.setAttribute("fill", m.color), h.appendChild(x);
+  });
+  var s = "data:image/svg+xml;base64,", u = '<svg xmlns="http://www.w3.org/2000/svg" xmlns:xlink="http://www.w3.org/1999/xlink"' + (' viewBox="' + o + " " + a + " " + c + " " + i + '"') + (' width="' + c + '"') + (' height="' + i + '"') + ">", p = h.innerHTML;
+  if (p === void 0) {
+    var l = document.createElement("dummy"), f = h.childNodes;
+    l.innerHTML = "";
+    for (var y = 0; y < f.length; y += 1)
+      l.appendChild(f[y].cloneNode(!0));
+    p = l.innerHTML;
+  }
+  var v = "</svg>", _ = u + p + v;
+  return s + btoa(_);
+};
+d.prototype.fromData = function(e) {
+  var n = this;
+  this.clear(), this._fromData(e, function(r, t) {
+    return n._drawCurve(r, t.start, t.end);
+  }, function(r) {
+    return n._drawDot(r);
+  }), this._data = e;
+};
+d.prototype.toData = function() {
+  return this._data;
+};
+var C = { exports: {} }, ot = C.exports, F;
+function it() {
+  return F || (F = 1, function(e, n) {
+    (function(r, t) {
+      e.exports = t();
+    })(ot, function() {
+      return function(r) {
+        function t(a) {
+          if (o[a])
+            return o[a].exports;
+          var c = o[a] = { exports: {}, id: a, loaded: !1 };
+          return r[a].call(c.exports, c, c.exports, t), c.loaded = !0, c.exports;
+        }
+        var o = {};
+        return t.m = r, t.c = o, t.p = "", t(0);
+      }([function(r, t) {
+        function o(s) {
+          var u = s.getContext("2d"), p = s.width, l = s.height, f = u.getImageData(0, 0, p, l).data, y = i(!0, p, l, f), v = i(!1, p, l, f), _ = h(!0, p, l, f), m = h(!1, p, l, f), x = m - _ + 1, P = v - y + 1, w = u.getImageData(_, y, x, P);
+          return s.width = x, s.height = P, u.clearRect(0, 0, x, P), u.putImageData(w, 0, 0), s;
+        }
+        function a(s, u, p, l) {
+          return { red: l[4 * (p * u + s)], green: l[4 * (p * u + s) + 1], blue: l[4 * (p * u + s) + 2], alpha: l[4 * (p * u + s) + 3] };
+        }
+        function c(s, u, p, l) {
+          return a(s, u, p, l).alpha;
+        }
+        function i(s, u, p, l) {
+          for (var f = s ? 1 : -1, y = s ? 0 : p - 1, v = y; s ? v < p : v > -1; v += f)
+            for (var _ = 0; _ < u; _++)
+              if (c(_, v, u, l))
+                return v;
+          return null;
+        }
+        function h(s, u, p, l) {
+          for (var f = s ? 1 : -1, y = s ? 0 : u - 1, v = y; s ? v < u : v > -1; v += f)
+            for (var _ = 0; _ < p; _++)
+              if (c(v, _, u, l))
+                return v;
+          return null;
+        }
+        Object.defineProperty(t, "__esModule", { value: !0 }), t.default = o;
+      }]);
+    });
+  }(C)), C.exports;
+}
+var at = it();
+const st = /* @__PURE__ */ N(at);
+var ct = ["canvasProps", "clearOnResize"], E = /* @__PURE__ */ function(e) {
+  G(r, e);
+  var n = Q(r);
+  function r() {
+    var t;
+    X(this, r);
+    for (var o = arguments.length, a = new Array(o), c = 0; c < o; c++)
+      a[c] = arguments[c];
+    return t = n.call.apply(n, [this].concat(a)), t.staticThis = t.constructor, t._sigPad = null, t._canvas = null, t.setRef = function(i) {
+      t._canvas = i, t._canvas === null && (t._sigPad = null);
+    }, t._excludeOurProps = function() {
+      var i = t.props;
+      i.canvasProps, i.clearOnResize;
+      var h = H(i, ct);
+      return h;
+    }, t.componentDidMount = function() {
+      var i = t.getCanvas();
+      t._sigPad = new d(i, t._excludeOurProps()), t._resizeCanvas(), t.on();
+    }, t.componentWillUnmount = function() {
+      t.off();
+    }, t.componentDidUpdate = function() {
+      Object.assign(t._sigPad, t._excludeOurProps());
+    }, t.getCanvas = function() {
+      if (t._canvas === null)
+        throw t.staticThis.refNullError;
+      return t._canvas;
+    }, t.getTrimmedCanvas = function() {
+      var i = t.getCanvas(), h = document.createElement("canvas");
+      return h.width = i.width, h.height = i.height, h.getContext("2d").drawImage(i, 0, 0), st(h);
+    }, t.getSignaturePad = function() {
+      if (t._sigPad === null)
+        throw t.staticThis.refNullError;
+      return t._sigPad;
+    }, t._checkClearOnResize = function() {
+      t.props.clearOnResize && t._resizeCanvas();
+    }, t._resizeCanvas = function() {
+      var i, h, s = (i = t.props.canvasProps) !== null && i !== void 0 ? i : {}, u = s.width, p = s.height;
+      if (!(typeof u < "u" && typeof p < "u")) {
+        var l = t.getCanvas(), f = Math.max((h = window.devicePixelRatio) !== null && h !== void 0 ? h : 1, 1);
+        typeof u > "u" && (l.width = l.offsetWidth * f), typeof p > "u" && (l.height = l.offsetHeight * f), l.getContext("2d").scale(f, f), t.clear();
+      }
+    }, t.render = function() {
+      var i = t.props.canvasProps;
+      return /* @__PURE__ */ A.createElement("canvas", $({
+        ref: t.setRef
+      }, i));
+    }, t.on = function() {
+      return window.addEventListener("resize", t._checkClearOnResize), t.getSignaturePad().on();
+    }, t.off = function() {
+      return window.removeEventListener("resize", t._checkClearOnResize), t.getSignaturePad().off();
+    }, t.clear = function() {
+      return t.getSignaturePad().clear();
+    }, t.isEmpty = function() {
+      return t.getSignaturePad().isEmpty();
+    }, t.fromDataURL = function(i, h) {
+      return t.getSignaturePad().fromDataURL(i, h);
+    }, t.toDataURL = function(i, h) {
+      return t.getSignaturePad().toDataURL(i, h);
+    }, t.fromData = function(i) {
+      return t.getSignaturePad().fromData(i);
+    }, t.toData = function() {
+      return t.getSignaturePad().toData();
+    }, t;
+  }
+  return Y(r);
+}(q);
+E.propTypes = {
+  // signature_pad's props
+  velocityFilterWeight: g.number,
+  minWidth: g.number,
+  maxWidth: g.number,
+  minDistance: g.number,
+  dotSize: g.oneOfType([g.number, g.func]),
+  penColor: g.string,
+  throttle: g.number,
+  onEnd: g.func,
+  onBegin: g.func,
+  // props specific to the React wrapper
+  canvasProps: g.object,
+  clearOnResize: g.bool
+};
+E.defaultProps = {
+  clearOnResize: !0
+};
+E.refNullError = new Error("react-signature-canvas is currently mounting or unmounting: React refs are null during this phase.");
+const ht = I(
+  (e, n) => /* @__PURE__ */ j(E, { ref: n, ...e })
+);
+ht.displayName = "LazySignatureCanvas";
+export {
+  ht as default
+};