rumious 0.0.1 → 0.0.2

package/dist/index.esm.js

@@ -10,8 +10,33 @@ function _assertThisInitialized(e) {
   if (undefined === e) throw new ReferenceError("this hasn't been initialised - super() hasn't been called");
   return e;
 }
+function asyncGeneratorStep(n, t, e, r, o, a, c) {
+  try {
+    var i = n[a](c),
+      u = i.value;
+  } catch (n) {
+    return void e(n);
+  }
+  i.done ? t(u) : Promise.resolve(u).then(r, o);
+}
+function _asyncToGenerator(n) {
+  return function () {
+    var t = this,
+      e = arguments;
+    return new Promise(function (r, o) {
+      var a = n.apply(t, e);
+      function _next(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
+      }
+      function _throw(n) {
+        asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
+      }
+      _next(undefined);
+    });
+  };
+}
 function _callSuper(t, o, e) {
-  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, [], _getPrototypeOf(t).constructor) : o.apply(t, e));
+  return o = _getPrototypeOf(o), _possibleConstructorReturn(t, _isNativeReflectConstruct() ? Reflect.construct(o, e || [], _getPrototypeOf(t).constructor) : o.apply(t, e));
 }
 function _classCallCheck(a, n) {
   if (!(a instanceof n)) throw new TypeError("Cannot call a class as a function");
@@ -34,6 +59,54 @@ function _createClass(e, r, t) {
     writable: false
   }), e;
 }
+function _createForOfIteratorHelper(r, e) {
+  var t = "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
+  if (!t) {
+    if (Array.isArray(r) || (t = _unsupportedIterableToArray(r)) || e) {
+      t && (r = t);
+      var n = 0,
+        F = function () {};
+      return {
+        s: F,
+        n: function () {
+          return n >= r.length ? {
+            done: true
+          } : {
+            done: false,
+            value: r[n++]
+          };
+        },
+        e: function (r) {
+          throw r;
+        },
+        f: F
+      };
+    }
+    throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
+  }
+  var o,
+    a = true,
+    u = false;
+  return {
+    s: function () {
+      t = t.call(r);
+    },
+    n: function () {
+      var r = t.next();
+      return a = r.done, r;
+    },
+    e: function (r) {
+      u = true, o = r;
+    },
+    f: function () {
+      try {
+        a || null == t.return || t.return();
+      } finally {
+        if (u) throw o;
+      }
+    }
+  };
+}
 function _defineProperty(e, r, t) {
   return (r = _toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
     value: t,
@@ -85,7 +158,10 @@ function _iterableToArrayLimit(r, l) {
       f = true,
       o = false;
     try {
-      if (i = (t = t.call(r)).next, 0 === l) ; else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
+      if (i = (t = t.call(r)).next, 0 === l) {
+        if (Object(t) !== t) return;
+        f = !1;
+      } else for (; !(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0);
     } catch (r) {
       o = true, n = r;
     } finally {
@@ -127,6 +203,307 @@ function _possibleConstructorReturn(t, e) {
   if (undefined !== e) throw new TypeError("Derived constructors may only return object or undefined");
   return _assertThisInitialized(t);
 }
+function _regeneratorRuntime() {
+  _regeneratorRuntime = function () {
+    return e;
+  };
+  var t,
+    e = {},
+    r = Object.prototype,
+    n = r.hasOwnProperty,
+    o = Object.defineProperty || function (t, e, r) {
+      t[e] = r.value;
+    },
+    i = "function" == typeof Symbol ? Symbol : {},
+    a = i.iterator || "@@iterator",
+    c = i.asyncIterator || "@@asyncIterator",
+    u = i.toStringTag || "@@toStringTag";
+  function define(t, e, r) {
+    return Object.defineProperty(t, e, {
+      value: r,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    }), t[e];
+  }
+  try {
+    define({}, "");
+  } catch (t) {
+    define = function (t, e, r) {
+      return t[e] = r;
+    };
+  }
+  function wrap(t, e, r, n) {
+    var i = e && e.prototype instanceof Generator ? e : Generator,
+      a = Object.create(i.prototype),
+      c = new Context(n || []);
+    return o(a, "_invoke", {
+      value: makeInvokeMethod(t, r, c)
+    }), a;
+  }
+  function tryCatch(t, e, r) {
+    try {
+      return {
+        type: "normal",
+        arg: t.call(e, r)
+      };
+    } catch (t) {
+      return {
+        type: "throw",
+        arg: t
+      };
+    }
+  }
+  e.wrap = wrap;
+  var h = "suspendedStart",
+    l = "suspendedYield",
+    f = "executing",
+    s = "completed",
+    y = {};
+  function Generator() {}
+  function GeneratorFunction() {}
+  function GeneratorFunctionPrototype() {}
+  var p = {};
+  define(p, a, function () {
+    return this;
+  });
+  var d = Object.getPrototypeOf,
+    v = d && d(d(values([])));
+  v && v !== r && n.call(v, a) && (p = v);
+  var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
+  function defineIteratorMethods(t) {
+    ["next", "throw", "return"].forEach(function (e) {
+      define(t, e, function (t) {
+        return this._invoke(e, t);
+      });
+    });
+  }
+  function AsyncIterator(t, e) {
+    function invoke(r, o, i, a) {
+      var c = tryCatch(t[r], t, o);
+      if ("throw" !== c.type) {
+        var u = c.arg,
+          h = u.value;
+        return h && "object" == typeof h && n.call(h, "__await") ? e.resolve(h.__await).then(function (t) {
+          invoke("next", t, i, a);
+        }, function (t) {
+          invoke("throw", t, i, a);
+        }) : e.resolve(h).then(function (t) {
+          u.value = t, i(u);
+        }, function (t) {
+          return invoke("throw", t, i, a);
+        });
+      }
+      a(c.arg);
+    }
+    var r;
+    o(this, "_invoke", {
+      value: function (t, n) {
+        function callInvokeWithMethodAndArg() {
+          return new e(function (e, r) {
+            invoke(t, n, e, r);
+          });
+        }
+        return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
+      }
+    });
+  }
+  function makeInvokeMethod(e, r, n) {
+    var o = h;
+    return function (i, a) {
+      if (o === f) throw Error("Generator is already running");
+      if (o === s) {
+        if ("throw" === i) throw a;
+        return {
+          value: t,
+          done: true
+        };
+      }
+      for (n.method = i, n.arg = a;;) {
+        var c = n.delegate;
+        if (c) {
+          var u = maybeInvokeDelegate(c, n);
+          if (u) {
+            if (u === y) continue;
+            return u;
+          }
+        }
+        if ("next" === n.method) n.sent = n._sent = n.arg;else if ("throw" === n.method) {
+          if (o === h) throw o = s, n.arg;
+          n.dispatchException(n.arg);
+        } else "return" === n.method && n.abrupt("return", n.arg);
+        o = f;
+        var p = tryCatch(e, r, n);
+        if ("normal" === p.type) {
+          if (o = n.done ? s : l, p.arg === y) continue;
+          return {
+            value: p.arg,
+            done: n.done
+          };
+        }
+        "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
+      }
+    };
+  }
+  function maybeInvokeDelegate(e, r) {
+    var n = r.method,
+      o = e.iterator[n];
+    if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
+    var i = tryCatch(o, e.iterator, r.arg);
+    if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, y;
+    var a = i.arg;
+    return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), r.delegate = null, y);
+  }
+  function pushTryEntry(t) {
+    var e = {
+      tryLoc: t[0]
+    };
+    1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), this.tryEntries.push(e);
+  }
+  function resetTryEntry(t) {
+    var e = t.completion || {};
+    e.type = "normal", delete e.arg, t.completion = e;
+  }
+  function Context(t) {
+    this.tryEntries = [{
+      tryLoc: "root"
+    }], t.forEach(pushTryEntry, this), this.reset(true);
+  }
+  function values(e) {
+    if (e || "" === e) {
+      var r = e[a];
+      if (r) return r.call(e);
+      if ("function" == typeof e.next) return e;
+      if (!isNaN(e.length)) {
+        var o = -1,
+          i = function next() {
+            for (; ++o < e.length;) if (n.call(e, o)) return next.value = e[o], next.done = false, next;
+            return next.value = t, next.done = true, next;
+          };
+        return i.next = i;
+      }
+    }
+    throw new TypeError(typeof e + " is not iterable");
+  }
+  return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
+    value: GeneratorFunctionPrototype,
+    configurable: true
+  }), o(GeneratorFunctionPrototype, "constructor", {
+    value: GeneratorFunction,
+    configurable: true
+  }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), e.isGeneratorFunction = function (t) {
+    var e = "function" == typeof t && t.constructor;
+    return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
+  }, e.mark = function (t) {
+    return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
+  }, e.awrap = function (t) {
+    return {
+      __await: t
+    };
+  }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, function () {
+    return this;
+  }), e.AsyncIterator = AsyncIterator, e.async = function (t, r, n, o, i) {
+    undefined === i && (i = Promise);
+    var a = new AsyncIterator(wrap(t, r, n, o), i);
+    return e.isGeneratorFunction(r) ? a : a.next().then(function (t) {
+      return t.done ? t.value : a.next();
+    });
+  }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, function () {
+    return this;
+  }), define(g, "toString", function () {
+    return "[object Generator]";
+  }), e.keys = function (t) {
+    var e = Object(t),
+      r = [];
+    for (var n in e) r.push(n);
+    return r.reverse(), function next() {
+      for (; r.length;) {
+        var t = r.pop();
+        if (t in e) return next.value = t, next.done = false, next;
+      }
+      return next.done = true, next;
+    };
+  }, e.values = values, Context.prototype = {
+    constructor: Context,
+    reset: function (e) {
+      if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = false, this.delegate = null, this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
+    },
+    stop: function () {
+      this.done = true;
+      var t = this.tryEntries[0].completion;
+      if ("throw" === t.type) throw t.arg;
+      return this.rval;
+    },
+    dispatchException: function (e) {
+      if (this.done) throw e;
+      var r = this;
+      function handle(n, o) {
+        return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), !!o;
+      }
+      for (var o = this.tryEntries.length - 1; o >= 0; --o) {
+        var i = this.tryEntries[o],
+          a = i.completion;
+        if ("root" === i.tryLoc) return handle("end");
+        if (i.tryLoc <= this.prev) {
+          var c = n.call(i, "catchLoc"),
+            u = n.call(i, "finallyLoc");
+          if (c && u) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, true);
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          } else if (c) {
+            if (this.prev < i.catchLoc) return handle(i.catchLoc, true);
+          } else {
+            if (!u) throw Error("try statement without catch or finally");
+            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
+          }
+        }
+      }
+    },
+    abrupt: function (t, e) {
+      for (var r = this.tryEntries.length - 1; r >= 0; --r) {
+        var o = this.tryEntries[r];
+        if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
+          var i = o;
+          break;
+        }
+      }
+      i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
+      var a = i ? i.completion : {};
+      return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, y) : this.complete(a);
+    },
+    complete: function (t, e) {
+      if ("throw" === t.type) throw t.arg;
+      return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), y;
+    },
+    finish: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), y;
+      }
+    },
+    catch: function (t) {
+      for (var e = this.tryEntries.length - 1; e >= 0; --e) {
+        var r = this.tryEntries[e];
+        if (r.tryLoc === t) {
+          var n = r.completion;
+          if ("throw" === n.type) {
+            var o = n.arg;
+            resetTryEntry(r);
+          }
+          return o;
+        }
+      }
+      throw Error("illegal catch attempt");
+    },
+    delegateYield: function (e, r, n) {
+      return this.delegate = {
+        iterator: values(e),
+        resultName: r,
+        nextLoc: n
+      }, "next" === this.method && (this.arg = t), y;
+    }
+  }, e;
+}
 function _setPrototypeOf(t, e) {
   return _setPrototypeOf = Object.setPrototypeOf ? Object.setPrototypeOf.bind() : function (t, e) {
     return t.__proto__ = e, t;
@@ -188,29 +565,2074 @@ function _wrapNativeSuper(t) {
   }, _wrapNativeSuper(t);
 }
 
-var RumiousRenderContext=/*#__PURE__*/_createClass(function RumiousRenderContext(target){_classCallCheck(this,RumiousRenderContext);this.target=target;});
+var RumiousRenderContext = /*#__PURE__*/function () {
+  function RumiousRenderContext(target) {
+    _classCallCheck(this, RumiousRenderContext);
+    this.target = target;
+  }
+  return _createClass(RumiousRenderContext, [{
+    key: "find",
+    value: function find(name) {
+      return this.target[name];
+    }
+  }, {
+    key: "get",
+    value: function get(name) {
+      return this.target[name];
+    }
+  }]);
+}();
 
-var RumiousComponent=/*#__PURE__*/function(){function RumiousComponent(){_classCallCheck(this,RumiousComponent);this.element=null;this.props={};this.renderContext=new RumiousRenderContext(this);this.renderer=null;this.wrapped=null;}return _createClass(RumiousComponent,[{key:"prepare",value:function prepare(element,props){var wrapped=arguments.length>2&&arguments[2]!==undefined?arguments[2]:{};var renderer=arguments.length>3&&arguments[3]!==undefined?arguments[3]:null;this.element=element;this.props=props;this.renderer=renderer;this.wrapped=wrapped;}},{key:"template",value:function template(){return {};}},{key:"requestRender",value:function requestRender(){var template=this.template();var fragment=this.renderer(template,document.createDocumentFragment(),this.renderContext);this.element.appendChild(fragment);this.onRender();}},{key:"onCreate",value:function onCreate(){}},{key:"onRender",value:function onRender(){}},{key:"onUpdate",value:function onUpdate(){}},{key:"onDestroy",value:function onDestroy(){}}]);}();function isComponent(constructor){return Object.getPrototypeOf(constructor)===RumiousComponent;}
+var RumiousComponent = /*#__PURE__*/function () {
+  function RumiousComponent() {
+    _classCallCheck(this, RumiousComponent);
+    this.element = null;
+    this.props = {};
+    this.renderContext = new RumiousRenderContext(this);
+    this.renderer = null;
+    this.wrapped = null;
+  }
+  return _createClass(RumiousComponent, [{
+    key: "prepare",
+    value: function prepare(element, props) {
+      var wrapped = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var renderer = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;
+      this.element = element;
+      this.props = props;
+      this.renderer = renderer;
+      this.wrapped = wrapped;
+    }
+  }, {
+    key: "template",
+    value: function template() {
+      return {};
+    }
+  }, {
+    key: "requestRender",
+    value: function requestRender() {
+      var template = this.template();
+      var fragment = this.renderer(template, document.createDocumentFragment(), this.renderContext);
+      this.element.appendChild(fragment);
+      this.onRender();
+    }
+  }, {
+    key: "requestCleanUp",
+    value: function () {
+      var _requestCleanUp = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee() {
+        var cloned;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              if (this.element) {
+                cloned = this.element.cloneNode(true);
+                this.element.replaceWith(cloned);
+                this.element = cloned;
+                while (this.element.firstChild) {
+                  this.element.removeChild(this.element.firstChild);
+                }
+              }
+            case 1:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function requestCleanUp() {
+        return _requestCleanUp.apply(this, arguments);
+      }
+      return requestCleanUp;
+    }()
+  }, {
+    key: "onInit",
+    value: function onInit() {}
+  }, {
+    key: "onCreate",
+    value: function onCreate() {}
+  }, {
+    key: "onRender",
+    value: function onRender() {}
+  }, {
+    key: "onUpdate",
+    value: function onUpdate() {}
+  }, {
+    key: "onDestroy",
+    value: function onDestroy() {}
+  }]);
+}();
+function isComponent(component) {
+  return Object.getPrototypeOf(component) === RumiousComponent;
+}
 
-var RumiousElement=/*#__PURE__*/_createClass(function RumiousElement(type,props){var children=arguments.length>2&&arguments[2]!==undefined?arguments[2]:[];_classCallCheck(this,RumiousElement);this.type=type;this.props=props;this.children=children;});var RumiousElementList=/*#__PURE__*/function(){function RumiousElementList(list){_classCallCheck(this,RumiousElementList);this.type="ELEMENT_LIST";this.children=list;}return _createClass(RumiousElementList,[{key:"forEach",value:function forEach(callback){this.children.forEach(callback);}}]);}();
+var RumiousElement = /*#__PURE__*/_createClass(function RumiousElement(type, props) {
+  var children = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : [];
+  _classCallCheck(this, RumiousElement);
+  this.type = type;
+  this.props = props;
+  this.children = children;
+});
+var RumiousElementList = /*#__PURE__*/function () {
+  function RumiousElementList(list) {
+    _classCallCheck(this, RumiousElementList);
+    this.type = "ELEMENT_LIST";
+    this.children = list;
+  }
+  return _createClass(RumiousElementList, [{
+    key: "forEach",
+    value: function forEach(callback) {
+      this.children.forEach(callback);
+    }
+  }]);
+}();
 
-function createElement(type,props){for(var _len=arguments.length,children=new Array(_len>2?_len-2:0),_key=2;_key<_len;_key++){children[_key-2]=arguments[_key];}if(isComponent(type)){return createComponent(type,props,children);}if(type===createFragment){return createFragment.apply(undefined,children);}return new RumiousElement(type,props||{},normalizeChildren(children));}function createTextElement(text){return new RumiousElement("TEXT_ELEMENT",{nodeValue:text},[]);}function createComponent(type,props,children){return new RumiousElement("COMPONENT",_objectSpread2({component:type},props),new RumiousElementList(normalizeChildren(children)));}function createFragment(){for(var _len2=arguments.length,children=new Array(_len2),_key2=0;_key2<_len2;_key2++){children[_key2]=arguments[_key2];}return new RumiousElement("FRAGMENT",{},normalizeChildren(children));}function normalizeChildren(children){return children.map(function(child){return _typeof(child)==="object"?child:createTextElement(child);});}window.RUMIOUS_JSX_SUPPORT={createElement:createElement,createFragment:createFragment};
+function isCamelCase(str) {
+  var camelCaseRegex = /^[a-zA-Z]+([A-Z][a-z]*)*$/;
+  return camelCaseRegex.test(str);
+}
+function isFunction(object) {
+  return typeof object === 'function';
+}
 
-function isCamelCase(str){var camelCaseRegex=/^[a-z]+([A-Z][a-z]*)*$/;return camelCaseRegex.test(str);}
+var RumiousDirective = /*#__PURE__*/function () {
+  function RumiousDirective(type, name, value) {
+    _classCallCheck(this, RumiousDirective);
+    this.type = type;
+    this.name = name;
+    this.value = value;
+  }
+  return _createClass(RumiousDirective, [{
+    key: "init",
+    value: function init() {
+      console.warn("Directive haven't handler !");
+    }
+  }]);
+}();
+var RumiousEventBindingDirective = /*#__PURE__*/function (_RumiousDirective) {
+  function RumiousEventBindingDirective() {
+    _classCallCheck(this, RumiousEventBindingDirective);
+    return _callSuper(this, RumiousEventBindingDirective, arguments);
+  }
+  _inherits(RumiousEventBindingDirective, _RumiousDirective);
+  return _createClass(RumiousEventBindingDirective, [{
+    key: "init",
+    value: function () {
+      var _init = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee(dom, renderContext) {
+        var _this = this;
+        var fn, getHandler;
+        return _regeneratorRuntime().wrap(function _callee$(_context) {
+          while (1) switch (_context.prev = _context.next) {
+            case 0:
+              fn = null;
+              getHandler = function getHandler(value) {
+                if (!renderContext.find(value)) {
+                  console.warn("Missing event handler for event: ".concat(_this.name));
+                  return null;
+                }
+                var handler = renderContext.get(value);
+                if (!isFunction(handler)) {
+                  throw "".concat(value, " is not a function!");
+                }
+                return handler.bind(renderContext.target);
+              };
+              if (!(this.value.type === "string")) {
+                _context.next = 6;
+                break;
+              }
+              fn = getHandler(this.value.value);
+              _context.next = 13;
+              break;
+            case 6:
+              if (!(this.value.type === "expression")) {
+                _context.next = 12;
+                break;
+              }
+              fn = this.value.value;
+              if (isFunction(fn)) {
+                _context.next = 10;
+                break;
+              }
+              throw "Event handler requires a function!";
+            case 10:
+              _context.next = 13;
+              break;
+            case 12:
+              if (this.value.type === "dynamic_value") {
+                fn = getHandler(this.value.value.objectName);
+              }
+            case 13:
+              if (fn) {
+                dom.addEventListener(this.name, fn);
+              }
+            case 14:
+            case "end":
+              return _context.stop();
+          }
+        }, _callee, this);
+      }));
+      function init(_x, _x2) {
+        return _init.apply(this, arguments);
+      }
+      return init;
+    }()
+  }]);
+}(RumiousDirective);
+var RumiousPropsBindingDirective = /*#__PURE__*/function (_RumiousDirective2) {
+  function RumiousPropsBindingDirective() {
+    _classCallCheck(this, RumiousPropsBindingDirective);
+    return _callSuper(this, RumiousPropsBindingDirective, arguments);
+  }
+  _inherits(RumiousPropsBindingDirective, _RumiousDirective2);
+  return _createClass(RumiousPropsBindingDirective, [{
+    key: "init",
+    value: function () {
+      var _init2 = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee2(dom, renderContext) {
+        var _this2 = this;
+        var _this$value$evaluator, _this$value, currentStateValue, currentState;
+        return _regeneratorRuntime().wrap(function _callee2$(_context2) {
+          while (1) switch (_context2.prev = _context2.next) {
+            case 0:
+              if (!(this.value.type === "expression")) {
+                _context2.next = 4;
+                break;
+              }
+              _context2.next = 13;
+              break;
+            case 4:
+              if (!(this.value.type === "dynamic_value")) {
+                _context2.next = 13;
+                break;
+              }
+              currentStateValue = (_this$value$evaluator = (_this$value = this.value).evaluator) === null || _this$value$evaluator === undefined ? undefined : _this$value$evaluator.call(_this$value, renderContext.target);
+              currentState = renderContext.find(this.value.value.objectName);
+              if (currentState) {
+                _context2.next = 11;
+                break;
+              }
+              throw "Invalid props value: Directive bind: require a RumiousState Object !";
+            case 11:
+              currentState.reactor.addBinding(function () {
+                var _this2$value$evaluato, _this2$value;
+                var currentStateValue = (_this2$value$evaluato = (_this2$value = _this2.value).evaluator) === null || _this2$value$evaluato === undefined ? undefined : _this2$value$evaluato.call(_this2$value, renderContext.target);
+                _this2.bindAttr(dom, currentStateValue);
+              });
+            case 12:
+              this.bindAttr(dom, currentStateValue);
+            case 13:
+            case "end":
+              return _context2.stop();
+          }
+        }, _callee2, this);
+      }));
+      function init(_x3, _x4) {
+        return _init2.apply(this, arguments);
+      }
+      return init;
+    }()
+  }, {
+    key: "normalizeValue",
+    value: function normalizeValue(value) {
+      if (_typeof(value) === "object") {
+        var _value$toString, _value$toString2;
+        return (_value$toString = (_value$toString2 = value.toString) === null || _value$toString2 === undefined ? undefined : _value$toString2.call(value)) !== null && _value$toString !== undefined ? _value$toString : "";
+      }
+      return value;
+    }
+  }, {
+    key: "bindAttr",
+    value: function () {
+      var _bindAttr = _asyncToGenerator(/*#__PURE__*/_regeneratorRuntime().mark(function _callee3(dom, value) {
+        return _regeneratorRuntime().wrap(function _callee3$(_context3) {
+          while (1) switch (_context3.prev = _context3.next) {
+            case 0:
+              _context3.t0 = this.name;
+              _context3.next = _context3.t0 === "html" ? 3 : 5;
+              break;
+            case 3:
+              dom.innerHTML = this.normalizeValue(value);
+              return _context3.abrupt("break", 5);
+            case 5:
+            case "end":
+              return _context3.stop();
+          }
+        }, _callee3, this);
+      }));
+      function bindAttr(_x5, _x6) {
+        return _bindAttr.apply(this, arguments);
+      }
+      return bindAttr;
+    }()
+  }]);
+}(RumiousDirective);
+var directives = {
+  on: function on(event, value) {
+    return new RumiousEventBindingDirective("on", event, value);
+  },
+  bind: function bind(attr, value) {
+    return new RumiousPropsBindingDirective("bind", attr, value);
+  }
+};
+function registerDirective(type, name, value) {
+  var _directives$type;
+  return (_directives$type = directives[type]) === null || _directives$type === undefined ? undefined : _directives$type.call(directives, name, value);
+}
 
-var RumiousComponentElement=/*#__PURE__*/function(_HTMLElement){function RumiousComponentElement(){var _this;_classCallCheck(this,RumiousComponentElement);_this=_callSuper(this,RumiousComponentElement);_this.instance=null;return _this;}_inherits(RumiousComponentElement,_HTMLElement);return _createClass(RumiousComponentElement,[{key:"init",value:function init(componentConstructor,props){var wrapped=arguments.length>2&&arguments[2]!==undefined?arguments[2]:{};var renderer=arguments.length>3?arguments[3]:undefined;this.instance=new componentConstructor();this.instance.prepare(this,props,wrapped,renderer);}},{key:"connectedCallback",value:function connectedCallback(){this.instance.onCreate();this.instance.requestRender();}}]);}(/*#__PURE__*/_wrapNativeSuper(HTMLElement));function createComponentElement(){return document.createElement("a-component");}window.customElements.define("a-component",RumiousComponentElement);
+function createDirective(type, name, value) {
+  return registerDirective(type, name, value);
+}
+function createElement(type, props) {
+  for (var _len = arguments.length, children = new Array(_len > 2 ? _len - 2 : 0), _key = 2; _key < _len; _key++) {
+    children[_key - 2] = arguments[_key];
+  }
+  if (isComponent(type)) {
+    return createComponent(type, props, children);
+  }
+  if (type === createFragment) {
+    return createFragment.apply(undefined, children);
+  }
+  return new RumiousElement(type, props || {}, normalizeChildren(children));
+}
+function createTextElement(text) {
+  return new RumiousElement("TEXT_ELEMENT", {
+    nodeValue: text
+  }, []);
+}
+function createComponent(type, props, children) {
+  return new RumiousElement("COMPONENT", _objectSpread2({
+    component: type
+  }, props), new RumiousElementList(normalizeChildren(children)));
+}
+function createFragment() {
+  for (var _len2 = arguments.length, children = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
+    children[_key2] = arguments[_key2];
+  }
+  return new RumiousElement("FRAGMENT", {}, normalizeChildren(children));
+}
+function normalizeChildren(children) {
+  return children.map(function (child) {
+    return _typeof(child) === "object" ? child : createTextElement(child);
+  });
+}
+window.RUMIOUS_JSX_SUPPORT = {
+  createElement: createElement,
+  createFragment: createFragment,
+  createDirective: createDirective
+};
 
-function renderComponent(componentConstructor,props,wrapped,renderer){var componentElement=createComponentElement();componentElement.init(componentConstructor,props,wrapped,renderer);return componentElement;}
+var RumiousComponentElement = /*#__PURE__*/function (_HTMLElement) {
+  function RumiousComponentElement() {
+    var _this;
+    _classCallCheck(this, RumiousComponentElement);
+    _this = _callSuper(this, RumiousComponentElement);
+    _this.instance = null;
+    return _this;
+  }
+  _inherits(RumiousComponentElement, _HTMLElement);
+  return _createClass(RumiousComponentElement, [{
+    key: "init",
+    value: function init(componentConstructor, props) {
+      var wrapped = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+      var renderer = arguments.length > 3 ? arguments[3] : undefined;
+      this.instance = new componentConstructor();
+      this.instance.prepare(this, props, wrapped, renderer);
+      this.instance.onInit();
+    }
+  }, {
+    key: "connectedCallback",
+    value: function connectedCallback() {
+      this.instance.onCreate();
+      this.instance.requestRender();
+    }
+  }, {
+    key: "disconnectCallback",
+    value: function disconnectCallback() {
+      this.instance.onDestroy();
+      this.instance.requestCleanUp();
+    }
+  }]);
+}(/*#__PURE__*/_wrapNativeSuper(HTMLElement));
+function createComponentElement() {
+  return document.createElement("a-component");
+}
+window.customElements.define("a-component", RumiousComponentElement);
 
-function render(element,container){var renderContext=arguments.length>2&&arguments[2]!==undefined?arguments[2]:{};if(!element)return container;var dom;if(element.type==="COMPONENT"){dom=renderComponent(element.props.component,element.props,element.children,render);container.appendChild(dom);return container;}if(element.type==="FRAGMENT"||element.type==="ELEMENT_LIST"){element.children.forEach(function(child){return render(child,container,renderContext);});return container;}if(element.type==="TEXT_ELEMENT"){dom=document.createTextNode(element.props.nodeValue);}else {dom=document.createElement(element.type);}Object.entries(element.props||{}).forEach(function(_ref){var _ref2=_slicedToArray(_ref,2),name=_ref2[0],value=_ref2[1];if(name==="ref"){var _renderContext$addRef;(_renderContext$addRef=renderContext.addRef)===null||_renderContext$addRef===undefined||_renderContext$addRef.call(renderContext,value);}else if(name.startsWith("on")&&isCamelCase(name)){dom.addEventListener(name.substring(2).toLowerCase(),value);}else if(dom.nodeType===Node.TEXT_NODE){dom.nodeValue=value;}else {dom.setAttribute(name,value);}});element.children.forEach(function(child){return render(child,dom,renderContext);});container.appendChild(dom);return container;}
+function renderComponent(componentConstructor, props, wrapped, renderer) {
+  var componentElement = createComponentElement();
+  componentElement.init(componentConstructor, props, wrapped, renderer);
+  return componentElement;
+}
+
+function handleComponentElement(element, container, render) {
+  var dom = renderComponent(element.props.component, element.props, element.children, render);
+  container.appendChild(dom);
+  return container;
+}
+function handleFragmentOrElementList(element, container, renderContext) {
+  element.children.forEach(function (child) {
+    return render(child, container, renderContext);
+  });
+  return container;
+}
+function handleTextElement(element) {
+  return document.createTextNode(element.props.nodeValue);
+}
+function handleRegularElement(element, renderContext) {
+  var dom = document.createElement(element.type);
+  Object.entries(element.props || {}).forEach(function (_ref) {
+    var _ref2 = _slicedToArray(_ref, 2),
+      name = _ref2[0],
+      propValue = _ref2[1];
+    if (name.startsWith("on") && isCamelCase(name)) {
+      dom.addEventListener(name.substring(2).toLowerCase(), propValue);
+    } else {
+      setElementProps(dom, name, propValue, renderContext);
+    }
+  });
+  return dom;
+}
+function handleDirective(dom, directive, renderContext) {
+  directive.init(dom, renderContext);
+}
+function setElementProps(dom, name, propValue, renderContext) {
+  if (dom.nodeType === Node.TEXT_NODE) {
+    dom.nodeValue = propValue;
+  } else if (propValue instanceof RumiousDirective) {
+    handleDirective(dom, propValue, renderContext);
+  } else {
+    dom.setAttribute(name, propValue);
+  }
+}
+function render(element, container) {
+  var renderContext = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};
+  if (!element) return container;
+  var dom;
+  if (element.type === "COMPONENT") {
+    return handleComponentElement(element, container, render);
+  }
+  if (element.type === "FRAGMENT" || element.type === "ELEMENT_LIST") {
+    return handleFragmentOrElementList(element, container, renderContext);
+  }
+  if (element.type === "TEXT_ELEMENT") {
+    dom = handleTextElement(element);
+  } else {
+    dom = handleRegularElement(element, renderContext);
+  }
+  element.children.forEach(function (child) {
+    return render(child, dom, renderContext);
+  });
+  container.appendChild(dom);
+  return container;
+}
 
-var RumiousApp=/*#__PURE__*/function(){function RumiousApp(){var root=arguments.length>0&&arguments[0]!==undefined?arguments[0]:document.createElement("span");var configs=arguments.length>1&&arguments[1]!==undefined?arguments[1]:{};_classCallCheck(this,RumiousApp);this.root=root;this.configs=configs;this.renderContext=new RumiousRenderContext(this);}return _createClass(RumiousApp,[{key:"render",value:function render$1(element){render(element,this.root,this.renderContext);}}]);}();
+var RumiousApp = /*#__PURE__*/function () {
+  function RumiousApp() {
+    var root = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : document.createElement("span");
+    var configs = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    _classCallCheck(this, RumiousApp);
+    this.root = root;
+    this.configs = configs;
+    this.renderContext = new RumiousRenderContext(this);
+  }
+  return _createClass(RumiousApp, [{
+    key: "render",
+    value: function render$1(element) {
+      render(element, this.root, this.renderContext);
+    }
+  }]);
+}();
 
-var RumiousReactor=/*#__PURE__*/function(){function RumiousReactor(){var target=arguments.length>0&&arguments[0]!==undefined?arguments[0]:null;var bindings=arguments.length>1&&arguments[1]!==undefined?arguments[1]:[];_classCallCheck(this,RumiousReactor);this.target=target;this.bindings=bindings;}return _createClass(RumiousReactor,[{key:"react",value:function react(){this.bindings.forEach(function(callback){return callback();});}},{key:"addBinding",value:function addBinding(fn){this.bindings.push(fn);}}]);}();
+var RumiousReactor = /*#__PURE__*/function () {
+  function RumiousReactor() {
+    var target = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
+    var bindings = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+    _classCallCheck(this, RumiousReactor);
+    this.target = target;
+    this.bindings = bindings;
+  }
+  return _createClass(RumiousReactor, [{
+    key: "react",
+    value: function react() {
+      this.bindings.forEach(function (callback) {
+        return callback();
+      });
+    }
+  }, {
+    key: "addBinding",
+    value: function addBinding(fn) {
+      this.bindings.push(fn);
+    }
+  }]);
+}();
+
+var RumiousReducer = /*#__PURE__*/function () {
+  function RumiousReducer(state) {
+    var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : "";
+    var fn = arguments.length > 2 ? arguments[2] : undefined;
+    _classCallCheck(this, RumiousReducer);
+    this.state = state;
+    this.path = path;
+    this.fn = fn;
+  }
+  return _createClass(RumiousReducer, [{
+    key: "trigger",
+    value: function trigger() {
+      var value = this.fn.apply(this, arguments);
+      this.state.set(this.path, value);
+    }
+  }]);
+}();
 
-var RumiousState=/*#__PURE__*/function(){function RumiousState(target){var reactor=arguments.length>1&&arguments[1]!==undefined?arguments[1]:null;_classCallCheck(this,RumiousState);this.target=target;this.reactor=reactor!==null&&reactor!==undefined?reactor:new RumiousReactor(this,[]);if(target&&_typeof(target)==='object'){this.wrapProxy(target);}else {this._value=target;}}return _createClass(RumiousState,[{key:"wrapProxy",value:function wrapProxy(target){var _this=this;this._value=new Proxy(target,{get:function get(target,prop){var value=target[prop];return value&&_typeof(value)==='object'?new RumiousState(value,_this.reactor).value:value;},set:function set(target,prop,value){if(value&&_typeof(value)==='object'){value=new RumiousState(value,_this.reactor).proxy;}_this.reactor.react();target[prop]=value;return true;}});}},{key:"value",get:function get(){return this._value;},set:function set(val){if(val&&_typeof(val)==="object"){this.wrapProxy(val);}else {this._value=val;}this.reactor.react();}}]);}();function createState(value){return new RumiousState(value);}
+var Operation = {
+  Remove: 'remove',
+  Replace: 'replace',
+  Add: 'add'
+};
 
-function watcher(state,callback){state.reactor.addBinding(callback);}
+// Don't use `Symbol()` just for 3rd party access the draft
+var PROXY_DRAFT = Symbol["for"]('__MUTATIVE_PROXY_DRAFT__');
+var RAW_RETURN_SYMBOL = Symbol('__MUTATIVE_RAW_RETURN_SYMBOL__');
+var iteratorSymbol = Symbol.iterator;
+var dataTypes = {
+  mutable: 'mutable',
+  immutable: 'immutable'
+};
+var internal = {};
+function has(target, key) {
+  return target instanceof Map ? target.has(key) : Object.prototype.hasOwnProperty.call(target, key);
+}
+function getDescriptor(target, key) {
+  if (key in target) {
+    var prototype = Reflect.getPrototypeOf(target);
+    while (prototype) {
+      var descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);
+      if (descriptor) return descriptor;
+      prototype = Reflect.getPrototypeOf(prototype);
+    }
+  }
+  return;
+}
+function isBaseSetInstance(obj) {
+  return Object.getPrototypeOf(obj) === Set.prototype;
+}
+function isBaseMapInstance(obj) {
+  return Object.getPrototypeOf(obj) === Map.prototype;
+}
+function latest(proxyDraft) {
+  var _a;
+  return (_a = proxyDraft.copy) !== null && _a !== undefined ? _a : proxyDraft.original;
+}
+/**
+ * Check if the value is a draft
+ */
+function isDraft(target) {
+  return !!getProxyDraft(target);
+}
+function getProxyDraft(value) {
+  if (_typeof(value) !== 'object') return null;
+  return value === null || value === undefined ? undefined : value[PROXY_DRAFT];
+}
+function getValue(value) {
+  var _a;
+  var proxyDraft = getProxyDraft(value);
+  return proxyDraft ? (_a = proxyDraft.copy) !== null && _a !== undefined ? _a : proxyDraft.original : value;
+}
+/**
+ * Check if a value is draftable
+ */
+function isDraftable(value, options) {
+  if (!value || _typeof(value) !== 'object') return false;
+  var markResult;
+  return Object.getPrototypeOf(value) === Object.prototype || Array.isArray(value) || value instanceof Map || value instanceof Set || !!(options === null || options === undefined ? undefined : options.mark) && ((markResult = options.mark(value, dataTypes)) === dataTypes.immutable || typeof markResult === 'function');
+}
+function getPath(target) {
+  var path = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : [];
+  if (Object.hasOwnProperty.call(target, 'key')) {
+    // check if the parent is a draft and the original value is not equal to the current value
+    var parentCopy = target.parent.copy;
+    var proxyDraft = getProxyDraft(get(parentCopy, target.key));
+    if (proxyDraft !== null && (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== target.original) {
+      return null;
+    }
+    var isSet = target.parent.type === 3 /* DraftType.Set */;
+    var key = isSet ? Array.from(target.parent.setMap.keys()).indexOf(target.key) : target.key;
+    // check if the key is still in the next state parent
+    if (!(isSet && parentCopy.size > key || has(parentCopy, key))) return null;
+    path.push(key);
+  }
+  if (target.parent) {
+    return getPath(target.parent, path);
+  }
+  // `target` is root draft.
+  path.reverse();
+  try {
+    // check if the path is valid
+    resolvePath(target.copy, path);
+  } catch (e) {
+    return null;
+  }
+  return path;
+}
+function getType(target) {
+  if (Array.isArray(target)) return 1 /* DraftType.Array */;
+  if (target instanceof Map) return 2 /* DraftType.Map */;
+  if (target instanceof Set) return 3 /* DraftType.Set */;
+  return 0 /* DraftType.Object */;
+}
+function get(target, key) {
+  return getType(target) === 2 /* DraftType.Map */ ? target.get(key) : target[key];
+}
+function set(target, key, value) {
+  var type = getType(target);
+  if (type === 2 /* DraftType.Map */) {
+    target.set(key, value);
+  } else {
+    target[key] = value;
+  }
+}
+function peek(target, key) {
+  var state = getProxyDraft(target);
+  var source = state ? latest(state) : target;
+  return source[key];
+}
+function isEqual(x, y) {
+  if (x === y) {
+    return x !== 0 || 1 / x === 1 / y;
+  } else {
+    return x !== x && y !== y;
+  }
+}
+function revokeProxy(proxyDraft) {
+  if (!proxyDraft) return;
+  while (proxyDraft.finalities.revoke.length > 0) {
+    var revoke = proxyDraft.finalities.revoke.pop();
+    revoke();
+  }
+}
+// handle JSON Pointer path with spec https://www.rfc-editor.org/rfc/rfc6901
+function escapePath(path, pathAsArray) {
+  return pathAsArray ? path : [''].concat(path).map(function (_item) {
+    var item = "".concat(_item);
+    if (item.indexOf('/') === -1 && item.indexOf('~') === -1) return item;
+    return item.replace(/~/g, '~0').replace(/\//g, '~1');
+  }).join('/');
+}
+function resolvePath(base, path) {
+  for (var index = 0; index < path.length - 1; index += 1) {
+    var key = path[index];
+    // use `index` in Set draft
+    base = get(getType(base) === 3 /* DraftType.Set */ ? Array.from(base) : base, key);
+    if (_typeof(base) !== 'object') {
+      throw new Error("Cannot resolve patch at '".concat(path.join('/'), "'."));
+    }
+  }
+  return base;
+}
+function strictCopy(target) {
+  var copy = Object.create(Object.getPrototypeOf(target));
+  Reflect.ownKeys(target).forEach(function (key) {
+    var desc = Reflect.getOwnPropertyDescriptor(target, key);
+    if (desc.enumerable && desc.configurable && desc.writable) {
+      copy[key] = target[key];
+      return;
+    }
+    // for freeze
+    if (!desc.writable) {
+      desc.writable = true;
+      desc.configurable = true;
+    }
+    if (desc.get || desc.set) desc = {
+      configurable: true,
+      writable: true,
+      enumerable: desc.enumerable,
+      value: target[key]
+    };
+    Reflect.defineProperty(copy, key, desc);
+  });
+  return copy;
+}
+var propIsEnum = Object.prototype.propertyIsEnumerable;
+function shallowCopy(original, options) {
+  var markResult;
+  if (Array.isArray(original)) {
+    return Array.prototype.concat.call(original);
+  } else if (original instanceof Set) {
+    if (!isBaseSetInstance(original)) {
+      var SubClass = Object.getPrototypeOf(original).constructor;
+      return new SubClass(original.values());
+    }
+    return Set.prototype.difference ? Set.prototype.difference.call(original, new Set()) : new Set(original.values());
+  } else if (original instanceof Map) {
+    if (!isBaseMapInstance(original)) {
+      var _SubClass = Object.getPrototypeOf(original).constructor;
+      return new _SubClass(original);
+    }
+    return new Map(original);
+  } else if ((options === null || options === undefined ? undefined : options.mark) && (markResult = options.mark(original, dataTypes), markResult !== undefined) && markResult !== dataTypes.mutable) {
+    if (markResult === dataTypes.immutable) {
+      return strictCopy(original);
+    } else if (typeof markResult === 'function') {
+      if (options.enablePatches || options.enableAutoFreeze) {
+        throw new Error("You can't use mark and patches or auto freeze together.");
+      }
+      return markResult();
+    }
+    throw new Error("Unsupported mark result: ".concat(markResult));
+  } else if (_typeof(original) === 'object' && Object.getPrototypeOf(original) === Object.prototype) {
+    // For best performance with shallow copies,
+    // don't use `Object.create(Object.getPrototypeOf(obj), Object.getOwnPropertyDescriptors(obj));` by default.
+    var copy = {};
+    Object.keys(original).forEach(function (key) {
+      copy[key] = original[key];
+    });
+    Object.getOwnPropertySymbols(original).forEach(function (key) {
+      if (propIsEnum.call(original, key)) {
+        copy[key] = original[key];
+      }
+    });
+    return copy;
+  } else {
+    throw new Error("Please check mark() to ensure that it is a stable marker draftable function.");
+  }
+}
+function ensureShallowCopy(target) {
+  if (target.copy) return;
+  target.copy = shallowCopy(target.original, target.options);
+}
+function deepClone(target) {
+  if (!isDraftable(target)) return getValue(target);
+  if (Array.isArray(target)) return target.map(deepClone);
+  if (target instanceof Map) {
+    var iterable = Array.from(target.entries()).map(function (_ref) {
+      var _ref2 = _slicedToArray(_ref, 2),
+        k = _ref2[0],
+        v = _ref2[1];
+      return [k, deepClone(v)];
+    });
+    if (!isBaseMapInstance(target)) {
+      var SubClass = Object.getPrototypeOf(target).constructor;
+      return new SubClass(iterable);
+    }
+    return new Map(iterable);
+  }
+  if (target instanceof Set) {
+    var _iterable = Array.from(target).map(deepClone);
+    if (!isBaseSetInstance(target)) {
+      var _SubClass2 = Object.getPrototypeOf(target).constructor;
+      return new _SubClass2(_iterable);
+    }
+    return new Set(_iterable);
+  }
+  var copy = Object.create(Object.getPrototypeOf(target));
+  for (var key in target) copy[key] = deepClone(target[key]);
+  return copy;
+}
+function cloneIfNeeded(target) {
+  return isDraft(target) ? deepClone(target) : target;
+}
+function markChanged(proxyDraft) {
+  var _a;
+  proxyDraft.assignedMap = (_a = proxyDraft.assignedMap) !== null && _a !== undefined ? _a : new Map();
+  if (!proxyDraft.operated) {
+    proxyDraft.operated = true;
+    if (proxyDraft.parent) {
+      markChanged(proxyDraft.parent);
+    }
+  }
+}
+function throwFrozenError() {
+  throw new Error('Cannot modify frozen object');
+}
+function deepFreeze(target, subKey, updatedValues, stack, keys) {
+  {
+    updatedValues = updatedValues !== null && updatedValues !== undefined ? updatedValues : new WeakMap();
+    stack = stack !== null && stack !== undefined ? stack : [];
+    keys = keys !== null && keys !== undefined ? keys : [];
+    var value = updatedValues.has(target) ? updatedValues.get(target) : target;
+    if (stack.length > 0) {
+      var index = stack.indexOf(value);
+      if (value && _typeof(value) === 'object' && index !== -1) {
+        if (stack[0] === value) {
+          throw new Error("Forbids circular reference");
+        }
+        throw new Error("Forbids circular reference: ~/".concat(keys.slice(0, index).map(function (key, index) {
+          if (_typeof(key) === 'symbol') return "[".concat(key.toString(), "]");
+          var parent = stack[index];
+          if (_typeof(key) === 'object' && (parent instanceof Map || parent instanceof Set)) return Array.from(parent.keys()).indexOf(key);
+          return key;
+        }).join('/')));
+      }
+      stack.push(value);
+      keys.push(subKey);
+    } else {
+      stack.push(value);
+    }
+  }
+  if (Object.isFrozen(target) || isDraft(target)) {
+    {
+      stack.pop();
+      keys.pop();
+    }
+    return;
+  }
+  var type = getType(target);
+  switch (type) {
+    case 2 /* DraftType.Map */:
+      var _iterator = _createForOfIteratorHelper(target),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var _step$value = _slicedToArray(_step.value, 2),
+            key = _step$value[0],
+            _value2 = _step$value[1];
+          deepFreeze(key, key, updatedValues, stack, keys);
+          deepFreeze(_value2, key, updatedValues, stack, keys);
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      target.set = target.clear = target["delete"] = throwFrozenError;
+      break;
+    case 3 /* DraftType.Set */:
+      var _iterator2 = _createForOfIteratorHelper(target),
+        _step2;
+      try {
+        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
+          var _value3 = _step2.value;
+          deepFreeze(_value3, _value3, updatedValues, stack, keys);
+        }
+      } catch (err) {
+        _iterator2.e(err);
+      } finally {
+        _iterator2.f();
+      }
+      target.add = target.clear = target["delete"] = throwFrozenError;
+      break;
+    case 1 /* DraftType.Array */:
+      Object.freeze(target);
+      var _index = 0;
+      var _iterator3 = _createForOfIteratorHelper(target),
+        _step3;
+      try {
+        for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
+          var _value4 = _step3.value;
+          deepFreeze(_value4, _index, updatedValues, stack, keys);
+          _index += 1;
+        }
+      } catch (err) {
+        _iterator3.e(err);
+      } finally {
+        _iterator3.f();
+      }
+      break;
+    default:
+      Object.freeze(target);
+      // ignore non-enumerable or symbol properties
+      Object.keys(target).forEach(function (name) {
+        var value = target[name];
+        deepFreeze(value, name, updatedValues, stack, keys);
+      });
+  }
+  {
+    stack.pop();
+    keys.pop();
+  }
+}
+function forEach(target, iter) {
+  var type = getType(target);
+  if (type === 0 /* DraftType.Object */) {
+    Reflect.ownKeys(target).forEach(function (key) {
+      iter(key, target[key], target);
+    });
+  } else if (type === 1 /* DraftType.Array */) {
+    var index = 0;
+    var _iterator4 = _createForOfIteratorHelper(target),
+      _step4;
+    try {
+      for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
+        var entry = _step4.value;
+        iter(index, entry, target);
+        index += 1;
+      }
+    } catch (err) {
+      _iterator4.e(err);
+    } finally {
+      _iterator4.f();
+    }
+  } else {
+    target.forEach(function (entry, index) {
+      return iter(index, entry, target);
+    });
+  }
+}
+function handleValue(target, handledSet, options) {
+  if (isDraft(target) || !isDraftable(target, options) || handledSet.has(target) || Object.isFrozen(target)) return;
+  var isSet = target instanceof Set;
+  var setMap = isSet ? new Map() : undefined;
+  handledSet.add(target);
+  forEach(target, function (key, value) {
+    var _a;
+    if (isDraft(value)) {
+      var proxyDraft = getProxyDraft(value);
+      ensureShallowCopy(proxyDraft);
+      // A draft where a child node has been changed, or assigned a value
+      var updatedValue = ((_a = proxyDraft.assignedMap) === null || _a === void 0 ? void 0 : _a.size) || proxyDraft.operated ? proxyDraft.copy : proxyDraft.original;
+      // final update value
+      set(isSet ? setMap : target, key, updatedValue);
+    } else {
+      handleValue(value, handledSet, options);
+    }
+  });
+  if (setMap) {
+    var _set = target;
+    var values = Array.from(_set);
+    _set.clear();
+    values.forEach(function (value) {
+      _set.add(setMap.has(value) ? setMap.get(value) : value);
+    });
+  }
+}
+function finalizeAssigned(proxyDraft, key) {
+  // handle the draftable assigned values， and the value is not a draft
+  var copy = proxyDraft.type === 3 /* DraftType.Set */ ? proxyDraft.setMap : proxyDraft.copy;
+  if (proxyDraft.finalities.revoke.length > 1 && proxyDraft.assignedMap.get(key) && copy) {
+    handleValue(get(copy, key), proxyDraft.finalities.handledSet, proxyDraft.options);
+  }
+}
+function finalizeSetValue(target) {
+  if (target.type === 3 /* DraftType.Set */ && target.copy) {
+    target.copy.clear();
+    target.setMap.forEach(function (value) {
+      target.copy.add(getValue(value));
+    });
+  }
+}
+function finalizePatches(target, generatePatches, patches, inversePatches) {
+  var shouldFinalize = target.operated && target.assignedMap && target.assignedMap.size > 0 && !target.finalized;
+  if (shouldFinalize) {
+    if (patches && inversePatches) {
+      var basePath = getPath(target);
+      if (basePath) {
+        generatePatches(target, basePath, patches, inversePatches);
+      }
+    }
+    target.finalized = true;
+  }
+}
+function markFinalization(target, key, value, generatePatches) {
+  var proxyDraft = getProxyDraft(value);
+  if (proxyDraft) {
+    // !case: assign the draft value
+    if (!proxyDraft.callbacks) {
+      proxyDraft.callbacks = [];
+    }
+    proxyDraft.callbacks.push(function (patches, inversePatches) {
+      var _a;
+      var copy = target.type === 3 /* DraftType.Set */ ? target.setMap : target.copy;
+      if (isEqual(get(copy, key), value)) {
+        var updatedValue = proxyDraft.original;
+        if (proxyDraft.copy) {
+          updatedValue = proxyDraft.copy;
+        }
+        finalizeSetValue(target);
+        finalizePatches(target, generatePatches, patches, inversePatches);
+        if (target.options.enableAutoFreeze) {
+          target.options.updatedValues = (_a = target.options.updatedValues) !== null && _a !== undefined ? _a : new WeakMap();
+          target.options.updatedValues.set(updatedValue, proxyDraft.original);
+        }
+        // final update value
+        set(copy, key, updatedValue);
+      }
+    });
+    if (target.options.enableAutoFreeze) {
+      // !case: assign the draft value in cross draft tree
+      if (proxyDraft.finalities !== target.finalities) {
+        target.options.enableAutoFreeze = false;
+      }
+    }
+  }
+  if (isDraftable(value, target.options)) {
+    // !case: assign the non-draft value
+    target.finalities.draft.push(function () {
+      var copy = target.type === 3 /* DraftType.Set */ ? target.setMap : target.copy;
+      if (isEqual(get(copy, key), value)) {
+        finalizeAssigned(target, key);
+      }
+    });
+  }
+}
+function generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray) {
+  var original = proxyState.original,
+    assignedMap = proxyState.assignedMap,
+    options = proxyState.options;
+  var copy = proxyState.copy;
+  if (copy.length < original.length) {
+    var _ref3 = [copy, original];
+    original = _ref3[0];
+    copy = _ref3[1];
+    var _ref4 = [inversePatches, patches];
+    patches = _ref4[0];
+    inversePatches = _ref4[1];
+  }
+  for (var index = 0; index < original.length; index += 1) {
+    if (assignedMap.get(index.toString()) && copy[index] !== original[index]) {
+      var _path = basePath.concat([index]);
+      var path = escapePath(_path, pathAsArray);
+      patches.push({
+        op: Operation.Replace,
+        path: path,
+        // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+        value: cloneIfNeeded(copy[index])
+      });
+      inversePatches.push({
+        op: Operation.Replace,
+        path: path,
+        // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+        value: cloneIfNeeded(original[index])
+      });
+    }
+  }
+  for (var _index2 = original.length; _index2 < copy.length; _index2 += 1) {
+    var _path2 = basePath.concat([_index2]);
+    var _path3 = escapePath(_path2, pathAsArray);
+    patches.push({
+      op: Operation.Add,
+      path: _path3,
+      // If it is a draft, it needs to be deep cloned, and it may also be non-draft.
+      value: cloneIfNeeded(copy[_index2])
+    });
+  }
+  if (original.length < copy.length) {
+    // https://www.rfc-editor.org/rfc/rfc6902#appendix-A.4
+    // For performance, here we only generate an operation that replaces the length of the array,
+    // which is inconsistent with JSON Patch specification
+    var _options$enablePatche = options.enablePatches.arrayLengthAssignment,
+      arrayLengthAssignment = _options$enablePatche === undefined ? true : _options$enablePatche;
+    if (arrayLengthAssignment) {
+      var _path4 = basePath.concat(['length']);
+      var _path5 = escapePath(_path4, pathAsArray);
+      inversePatches.push({
+        op: Operation.Replace,
+        path: _path5,
+        value: original.length
+      });
+    } else {
+      for (var _index3 = copy.length; original.length < _index3; _index3 -= 1) {
+        var _path6 = basePath.concat([_index3 - 1]);
+        var _path7 = escapePath(_path6, pathAsArray);
+        inversePatches.push({
+          op: Operation.Remove,
+          path: _path7
+        });
+      }
+    }
+  }
+}
+function generatePatchesFromAssigned(_ref5, basePath, patches, inversePatches, pathAsArray) {
+  var original = _ref5.original,
+    copy = _ref5.copy,
+    assignedMap = _ref5.assignedMap;
+  assignedMap.forEach(function (assignedValue, key) {
+    var originalValue = get(original, key);
+    var value = cloneIfNeeded(get(copy, key));
+    var op = !assignedValue ? Operation.Remove : has(original, key) ? Operation.Replace : Operation.Add;
+    if (isEqual(originalValue, value) && op === Operation.Replace) return;
+    var _path = basePath.concat(key);
+    var path = escapePath(_path, pathAsArray);
+    patches.push(op === Operation.Remove ? {
+      op: op,
+      path: path
+    } : {
+      op: op,
+      path: path,
+      value: value
+    });
+    inversePatches.push(op === Operation.Add ? {
+      op: Operation.Remove,
+      path: path
+    } : op === Operation.Remove ? {
+      op: Operation.Add,
+      path: path,
+      value: originalValue
+    } : {
+      op: Operation.Replace,
+      path: path,
+      value: originalValue
+    });
+  });
+}
+function generateSetPatches(_ref6, basePath, patches, inversePatches, pathAsArray) {
+  var original = _ref6.original,
+    copy = _ref6.copy;
+  var index = 0;
+  original.forEach(function (value) {
+    if (!copy.has(value)) {
+      var _path = basePath.concat([index]);
+      var path = escapePath(_path, pathAsArray);
+      patches.push({
+        op: Operation.Remove,
+        path: path,
+        value: value
+      });
+      inversePatches.unshift({
+        op: Operation.Add,
+        path: path,
+        value: value
+      });
+    }
+    index += 1;
+  });
+  index = 0;
+  copy.forEach(function (value) {
+    if (!original.has(value)) {
+      var _path = basePath.concat([index]);
+      var path = escapePath(_path, pathAsArray);
+      patches.push({
+        op: Operation.Add,
+        path: path,
+        value: value
+      });
+      inversePatches.unshift({
+        op: Operation.Remove,
+        path: path,
+        value: value
+      });
+    }
+    index += 1;
+  });
+}
+function generatePatches(proxyState, basePath, patches, inversePatches) {
+  var _proxyState$options$e = proxyState.options.enablePatches.pathAsArray,
+    pathAsArray = _proxyState$options$e === undefined ? true : _proxyState$options$e;
+  switch (proxyState.type) {
+    case 0 /* DraftType.Object */:
+    case 2 /* DraftType.Map */:
+      return generatePatchesFromAssigned(proxyState, basePath, patches, inversePatches, pathAsArray);
+    case 1 /* DraftType.Array */:
+      return generateArrayPatches(proxyState, basePath, patches, inversePatches, pathAsArray);
+    case 3 /* DraftType.Set */:
+      return generateSetPatches(proxyState, basePath, patches, inversePatches, pathAsArray);
+  }
+}
+var checkReadable = function checkReadable(value, options) {
+  var ignoreCheckDraftable = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;
+  if (_typeof(value) === 'object' && value !== null && (!isDraftable(value, options) || ignoreCheckDraftable) && true) {
+    throw new Error("Strict mode: Mutable data cannot be accessed directly, please use 'unsafe(callback)' wrap.");
+  }
+};
+var mapHandler = _defineProperty({
+  get size() {
+    var current = latest(getProxyDraft(this));
+    return current.size;
+  },
+  has: function has(key) {
+    return latest(getProxyDraft(this)).has(key);
+  },
+  set: function set(key, value) {
+    var target = getProxyDraft(this);
+    var source = latest(target);
+    if (!source.has(key) || !isEqual(source.get(key), value)) {
+      ensureShallowCopy(target);
+      markChanged(target);
+      target.assignedMap.set(key, true);
+      target.copy.set(key, value);
+      markFinalization(target, key, value, generatePatches);
+    }
+    return this;
+  },
+  "delete": function _delete(key) {
+    if (!this.has(key)) {
+      return false;
+    }
+    var target = getProxyDraft(this);
+    ensureShallowCopy(target);
+    markChanged(target);
+    if (target.original.has(key)) {
+      target.assignedMap.set(key, false);
+    } else {
+      target.assignedMap["delete"](key);
+    }
+    target.copy["delete"](key);
+    return true;
+  },
+  clear: function clear() {
+    var target = getProxyDraft(this);
+    if (!this.size) return;
+    ensureShallowCopy(target);
+    markChanged(target);
+    target.assignedMap = new Map();
+    var _iterator5 = _createForOfIteratorHelper(target.original),
+      _step5;
+    try {
+      for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
+        var _step5$value = _slicedToArray(_step5.value, 1),
+          key = _step5$value[0];
+        target.assignedMap.set(key, false);
+      }
+    } catch (err) {
+      _iterator5.e(err);
+    } finally {
+      _iterator5.f();
+    }
+    target.copy.clear();
+  },
+  forEach: function forEach(callback, thisArg) {
+    var _this = this;
+    var target = getProxyDraft(this);
+    latest(target).forEach(function (_value, _key) {
+      callback.call(thisArg, _this.get(_key), _key, _this);
+    });
+  },
+  get: function get(key) {
+    var _a, _b;
+    var target = getProxyDraft(this);
+    var value = latest(target).get(key);
+    var mutable = ((_b = (_a = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
+    if (target.options.strict) {
+      checkReadable(value, target.options, mutable);
+    }
+    if (mutable) {
+      return value;
+    }
+    if (target.finalized || !isDraftable(value, target.options)) {
+      return value;
+    }
+    // drafted or reassigned
+    if (value !== target.original.get(key)) {
+      return value;
+    }
+    var draft = internal.createDraft({
+      original: value,
+      parentDraft: target,
+      key: key,
+      finalities: target.finalities,
+      options: target.options
+    });
+    ensureShallowCopy(target);
+    target.copy.set(key, draft);
+    return draft;
+  },
+  keys: function keys() {
+    return latest(getProxyDraft(this)).keys();
+  },
+  values: function values() {
+    var _this2 = this;
+    var iterator = this.keys();
+    return _defineProperty(_defineProperty({}, iteratorSymbol, function () {
+      return _this2.values();
+    }), "next", function next() {
+      var result = iterator.next();
+      if (result.done) return result;
+      var value = _this2.get(result.value);
+      return {
+        done: false,
+        value: value
+      };
+    });
+  },
+  entries: function entries() {
+    var _this3 = this;
+    var iterator = this.keys();
+    return _defineProperty(_defineProperty({}, iteratorSymbol, function () {
+      return _this3.entries();
+    }), "next", function next() {
+      var result = iterator.next();
+      if (result.done) return result;
+      var value = _this3.get(result.value);
+      return {
+        done: false,
+        value: [result.value, value]
+      };
+    });
+  }
+}, iteratorSymbol, function () {
+  return this.entries();
+});
+var mapHandlerKeys = Reflect.ownKeys(mapHandler);
+var getNextIterator = function getNextIterator(target, iterator, _ref9) {
+  var isValuesIterator = _ref9.isValuesIterator;
+  return function () {
+    var _a, _b;
+    var result = iterator.next();
+    if (result.done) return result;
+    var key = result.value;
+    var value = target.setMap.get(key);
+    var currentDraft = getProxyDraft(value);
+    var mutable = ((_b = (_a = target.options).mark) === null || _b === undefined ? undefined : _b.call(_a, value, dataTypes)) === dataTypes.mutable;
+    if (target.options.strict) {
+      checkReadable(key, target.options, mutable);
+    }
+    if (!mutable && !currentDraft && isDraftable(key, target.options) && !target.finalized && target.original.has(key)) {
+      // draft a draftable original set item
+      var proxy = internal.createDraft({
+        original: key,
+        parentDraft: target,
+        key: key,
+        finalities: target.finalities,
+        options: target.options
+      });
+      target.setMap.set(key, proxy);
+      value = proxy;
+    } else if (currentDraft) {
+      // drafted
+      value = currentDraft.proxy;
+    }
+    return {
+      done: false,
+      value: isValuesIterator ? value : [value, value]
+    };
+  };
+};
+var setHandler = _defineProperty(_defineProperty({
+  get size() {
+    var target = getProxyDraft(this);
+    return target.setMap.size;
+  },
+  has: function has(value) {
+    var target = getProxyDraft(this);
+    // reassigned or non-draftable values
+    if (target.setMap.has(value)) return true;
+    ensureShallowCopy(target);
+    var valueProxyDraft = getProxyDraft(value);
+    // drafted
+    if (valueProxyDraft && target.setMap.has(valueProxyDraft.original)) return true;
+    return false;
+  },
+  add: function add(value) {
+    var target = getProxyDraft(this);
+    if (!this.has(value)) {
+      ensureShallowCopy(target);
+      markChanged(target);
+      target.assignedMap.set(value, true);
+      target.setMap.set(value, value);
+      markFinalization(target, value, value, generatePatches);
+    }
+    return this;
+  },
+  "delete": function _delete(value) {
+    if (!this.has(value)) {
+      return false;
+    }
+    var target = getProxyDraft(this);
+    ensureShallowCopy(target);
+    markChanged(target);
+    var valueProxyDraft = getProxyDraft(value);
+    if (valueProxyDraft && target.setMap.has(valueProxyDraft.original)) {
+      // delete drafted
+      target.assignedMap.set(valueProxyDraft.original, false);
+      return target.setMap["delete"](valueProxyDraft.original);
+    }
+    if (!valueProxyDraft && target.setMap.has(value)) {
+      // non-draftable values
+      target.assignedMap.set(value, false);
+    } else {
+      // reassigned
+      target.assignedMap["delete"](value);
+    }
+    // delete reassigned or non-draftable values
+    return target.setMap["delete"](value);
+  },
+  clear: function clear() {
+    if (!this.size) return;
+    var target = getProxyDraft(this);
+    ensureShallowCopy(target);
+    markChanged(target);
+    var _iterator6 = _createForOfIteratorHelper(target.original),
+      _step6;
+    try {
+      for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
+        var value = _step6.value;
+        target.assignedMap.set(value, false);
+      }
+    } catch (err) {
+      _iterator6.e(err);
+    } finally {
+      _iterator6.f();
+    }
+    target.setMap.clear();
+  },
+  values: function values() {
+    var _this4 = this;
+    var target = getProxyDraft(this);
+    ensureShallowCopy(target);
+    var iterator = target.setMap.keys();
+    return _defineProperty(_defineProperty({}, Symbol.iterator, function () {
+      return _this4.values();
+    }), "next", getNextIterator(target, iterator, {
+      isValuesIterator: true
+    }));
+  },
+  entries: function entries() {
+    var _this5 = this;
+    var target = getProxyDraft(this);
+    ensureShallowCopy(target);
+    var iterator = target.setMap.keys();
+    return _defineProperty(_defineProperty({}, Symbol.iterator, function () {
+      return _this5.entries();
+    }), "next", getNextIterator(target, iterator, {
+      isValuesIterator: false
+    }));
+  },
+  keys: function keys() {
+    return this.values();
+  }
+}, iteratorSymbol, function () {
+  return this.values();
+}), "forEach", function forEach(callback, thisArg) {
+  var iterator = this.values();
+  var result = iterator.next();
+  while (!result.done) {
+    callback.call(thisArg, result.value, result.value, this);
+    result = iterator.next();
+  }
+});
+if (Set.prototype.difference) {
+  // for compatibility with new Set methods
+  // https://github.com/tc39/proposal-set-methods
+  // And `https://github.com/tc39/proposal-set-methods/blob/main/details.md#symbolspecies` has some details about the `@@species` symbol.
+  // So we can't use SubSet instance constructor to get the constructor of the SubSet instance.
+  Object.assign(setHandler, {
+    intersection: function intersection(other) {
+      return Set.prototype.intersection.call(new Set(this.values()), other);
+    },
+    union: function union(other) {
+      return Set.prototype.union.call(new Set(this.values()), other);
+    },
+    difference: function difference(other) {
+      return Set.prototype.difference.call(new Set(this.values()), other);
+    },
+    symmetricDifference: function symmetricDifference(other) {
+      return Set.prototype.symmetricDifference.call(new Set(this.values()), other);
+    },
+    isSubsetOf: function isSubsetOf(other) {
+      return Set.prototype.isSubsetOf.call(new Set(this.values()), other);
+    },
+    isSupersetOf: function isSupersetOf(other) {
+      return Set.prototype.isSupersetOf.call(new Set(this.values()), other);
+    },
+    isDisjointFrom: function isDisjointFrom(other) {
+      return Set.prototype.isDisjointFrom.call(new Set(this.values()), other);
+    }
+  });
+}
+var setHandlerKeys = Reflect.ownKeys(setHandler);
+var draftsCache = new WeakSet();
+var proxyHandler = {
+  get: function get(target, key, receiver) {
+    var _a, _b;
+    var copy = (_a = target.copy) === null || _a === undefined ? undefined : _a[key];
+    // Improve draft reading performance by caching the draft copy.
+    if (copy && draftsCache.has(copy)) {
+      return copy;
+    }
+    if (key === PROXY_DRAFT) return target;
+    var markResult;
+    if (target.options.mark) {
+      // handle `Uncaught TypeError: Method get Map.prototype.size called on incompatible receiver #<Map>`
+      // or `Uncaught TypeError: Method get Set.prototype.size called on incompatible receiver #<Set>`
+      var _value5 = key === 'size' && (target.original instanceof Map || target.original instanceof Set) ? Reflect.get(target.original, key) : Reflect.get(target.original, key, receiver);
+      markResult = target.options.mark(_value5, dataTypes);
+      if (markResult === dataTypes.mutable) {
+        if (target.options.strict) {
+          checkReadable(_value5, target.options, true);
+        }
+        return _value5;
+      }
+    }
+    var source = latest(target);
+    if (source instanceof Map && mapHandlerKeys.includes(key)) {
+      if (key === 'size') {
+        return Object.getOwnPropertyDescriptor(mapHandler, 'size').get.call(target.proxy);
+      }
+      var handle = mapHandler[key];
+      if (handle) {
+        return handle.bind(target.proxy);
+      }
+    }
+    if (source instanceof Set && setHandlerKeys.includes(key)) {
+      if (key === 'size') {
+        return Object.getOwnPropertyDescriptor(setHandler, 'size').get.call(target.proxy);
+      }
+      var _handle = setHandler[key];
+      if (_handle) {
+        return _handle.bind(target.proxy);
+      }
+    }
+    if (!has(source, key)) {
+      var desc = getDescriptor(source, key);
+      return desc ? "value" in desc ? desc.value :
+      // !case: support for getter
+      (_b = desc.get) === null || _b === undefined ? undefined : _b.call(target.proxy) : undefined;
+    }
+    var value = source[key];
+    if (target.options.strict) {
+      checkReadable(value, target.options);
+    }
+    if (target.finalized || !isDraftable(value, target.options)) {
+      return value;
+    }
+    // Ensure that the assigned values are not drafted
+    if (value === peek(target.original, key)) {
+      ensureShallowCopy(target);
+      target.copy[key] = createDraft({
+        original: target.original[key],
+        parentDraft: target,
+        key: target.type === 1 /* DraftType.Array */ ? Number(key) : key,
+        finalities: target.finalities,
+        options: target.options
+      });
+      // !case: support for custom shallow copy function
+      if (typeof markResult === 'function') {
+        var subProxyDraft = getProxyDraft(target.copy[key]);
+        ensureShallowCopy(subProxyDraft);
+        // Trigger a custom shallow copy to update to a new copy
+        markChanged(subProxyDraft);
+        return subProxyDraft.copy;
+      }
+      return target.copy[key];
+    }
+    return value;
+  },
+  set: function set(target, key, value) {
+    var _a;
+    if (target.type === 3 /* DraftType.Set */ || target.type === 2 /* DraftType.Map */) {
+      throw new Error("Map/Set draft does not support any property assignment.");
+    }
+    var _key;
+    if (target.type === 1 /* DraftType.Array */ && key !== 'length' && !(Number.isInteger(_key = Number(key)) && _key >= 0 && (key === 0 || _key === 0 || String(_key) === String(key)))) {
+      throw new Error("Only supports setting array indices and the 'length' property.");
+    }
+    var desc = getDescriptor(latest(target), key);
+    if (desc === null || desc === undefined ? undefined : desc.set) {
+      // !case: cover the case of setter
+      desc.set.call(target.proxy, value);
+      return true;
+    }
+    var current = peek(latest(target), key);
+    var currentProxyDraft = getProxyDraft(current);
+    if (currentProxyDraft && isEqual(currentProxyDraft.original, value)) {
+      // !case: ignore the case of assigning the original draftable value to a draft
+      target.copy[key] = value;
+      target.assignedMap = (_a = target.assignedMap) !== null && _a !== undefined ? _a : new Map();
+      target.assignedMap.set(key, false);
+      return true;
+    }
+    // !case: handle new props with value 'undefined'
+    if (isEqual(value, current) && (value !== undefined || has(target.original, key))) return true;
+    ensureShallowCopy(target);
+    markChanged(target);
+    if (has(target.original, key) && isEqual(value, target.original[key])) {
+      // !case: handle the case of assigning the original non-draftable value to a draft
+      target.assignedMap["delete"](key);
+    } else {
+      target.assignedMap.set(key, true);
+    }
+    target.copy[key] = value;
+    markFinalization(target, key, value, generatePatches);
+    return true;
+  },
+  has: function has(target, key) {
+    return key in latest(target);
+  },
+  ownKeys: function ownKeys(target) {
+    return Reflect.ownKeys(latest(target));
+  },
+  getOwnPropertyDescriptor: function getOwnPropertyDescriptor(target, key) {
+    var source = latest(target);
+    var descriptor = Reflect.getOwnPropertyDescriptor(source, key);
+    if (!descriptor) return descriptor;
+    return {
+      writable: true,
+      configurable: target.type !== 1 /* DraftType.Array */ || key !== 'length',
+      enumerable: descriptor.enumerable,
+      value: source[key]
+    };
+  },
+  getPrototypeOf: function getPrototypeOf(target) {
+    return Reflect.getPrototypeOf(target.original);
+  },
+  setPrototypeOf: function setPrototypeOf() {
+    throw new Error("Cannot call 'setPrototypeOf()' on drafts");
+  },
+  defineProperty: function defineProperty() {
+    throw new Error("Cannot call 'defineProperty()' on drafts");
+  },
+  deleteProperty: function deleteProperty(target, key) {
+    var _a;
+    if (target.type === 1 /* DraftType.Array */) {
+      return proxyHandler.set.call(this, target, key, undefined, target.proxy);
+    }
+    if (peek(target.original, key) !== undefined || key in target.original) {
+      // !case: delete an existing key
+      ensureShallowCopy(target);
+      markChanged(target);
+      target.assignedMap.set(key, false);
+    } else {
+      target.assignedMap = (_a = target.assignedMap) !== null && _a !== undefined ? _a : new Map();
+      // The original non-existent key has been deleted
+      target.assignedMap["delete"](key);
+    }
+    if (target.copy) delete target.copy[key];
+    return true;
+  }
+};
+function createDraft(createDraftOptions) {
+  var original = createDraftOptions.original,
+    parentDraft = createDraftOptions.parentDraft,
+    key = createDraftOptions.key,
+    finalities = createDraftOptions.finalities,
+    options = createDraftOptions.options;
+  var type = getType(original);
+  var proxyDraft = {
+    type: type,
+    finalized: false,
+    parent: parentDraft,
+    original: original,
+    copy: null,
+    proxy: null,
+    finalities: finalities,
+    options: options,
+    // Mapping of draft Set items to their corresponding draft values.
+    setMap: type === 3 /* DraftType.Set */ ? new Map(original.entries()) : undefined
+  };
+  // !case: undefined as a draft map key
+  if (key || 'key' in createDraftOptions) {
+    proxyDraft.key = key;
+  }
+  var _Proxy$revocable = Proxy.revocable(type === 1 /* DraftType.Array */ ? Object.assign([], proxyDraft) : proxyDraft, proxyHandler),
+    proxy = _Proxy$revocable.proxy,
+    revoke = _Proxy$revocable.revoke;
+  finalities.revoke.push(revoke);
+  draftsCache.add(proxy);
+  proxyDraft.proxy = proxy;
+  if (parentDraft) {
+    var target = parentDraft;
+    target.finalities.draft.push(function (patches, inversePatches) {
+      var _a, _b;
+      var oldProxyDraft = getProxyDraft(proxy);
+      // if target is a Set draft, `setMap` is the real Set copies proxy mapping.
+      var copy = target.type === 3 /* DraftType.Set */ ? target.setMap : target.copy;
+      var draft = get(copy, key);
+      var proxyDraft = getProxyDraft(draft);
+      if (proxyDraft) {
+        // assign the updated value to the copy object
+        var updatedValue = proxyDraft.original;
+        if (proxyDraft.operated) {
+          updatedValue = getValue(draft);
+        }
+        finalizeSetValue(proxyDraft);
+        finalizePatches(proxyDraft, generatePatches, patches, inversePatches);
+        if (target.options.enableAutoFreeze) {
+          target.options.updatedValues = (_a = target.options.updatedValues) !== null && _a !== undefined ? _a : new WeakMap();
+          target.options.updatedValues.set(updatedValue, proxyDraft.original);
+        }
+        // final update value
+        set(copy, key, updatedValue);
+      }
+      // !case: handle the deleted key
+      (_b = oldProxyDraft.callbacks) === null || _b === undefined ? undefined : _b.forEach(function (callback) {
+        callback(patches, inversePatches);
+      });
+    });
+  } else {
+    // !case: handle the root draft
+    var _target = getProxyDraft(proxy);
+    _target.finalities.draft.push(function (patches, inversePatches) {
+      finalizeSetValue(_target);
+      finalizePatches(_target, generatePatches, patches, inversePatches);
+    });
+  }
+  return proxy;
+}
+internal.createDraft = createDraft;
+function finalizeDraft(result, returnedValue, patches, inversePatches, enableAutoFreeze) {
+  var _a;
+  var proxyDraft = getProxyDraft(result);
+  var original = (_a = proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== null && _a !== undefined ? _a : result;
+  var hasReturnedValue = !!returnedValue.length;
+  if (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.operated) {
+    while (proxyDraft.finalities.draft.length > 0) {
+      var finalize = proxyDraft.finalities.draft.pop();
+      finalize(patches, inversePatches);
+    }
+  }
+  var state = hasReturnedValue ? returnedValue[0] : proxyDraft ? proxyDraft.operated ? proxyDraft.copy : proxyDraft.original : result;
+  if (proxyDraft) revokeProxy(proxyDraft);
+  if (enableAutoFreeze) {
+    deepFreeze(state, state, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options.updatedValues);
+  }
+  return [state, patches && hasReturnedValue ? [{
+    op: Operation.Replace,
+    path: [],
+    value: returnedValue[0]
+  }] : patches, inversePatches && hasReturnedValue ? [{
+    op: Operation.Replace,
+    path: [],
+    value: original
+  }] : inversePatches];
+}
+function draftify(baseState, options) {
+  var _a;
+  var finalities = {
+    draft: [],
+    revoke: [],
+    handledSet: new WeakSet()
+  };
+  var patches;
+  var inversePatches;
+  if (options.enablePatches) {
+    patches = [];
+    inversePatches = [];
+  }
+  var isMutable = ((_a = options.mark) === null || _a === undefined ? undefined : _a.call(options, baseState, dataTypes)) === dataTypes.mutable || !isDraftable(baseState, options);
+  var draft = isMutable ? baseState : createDraft({
+    original: baseState,
+    parentDraft: null,
+    finalities: finalities,
+    options: options
+  });
+  return [draft, function () {
+    var returnedValue = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : [];
+    var _finalizeDraft = finalizeDraft(draft, returnedValue, patches, inversePatches, options.enableAutoFreeze),
+      _finalizeDraft2 = _slicedToArray(_finalizeDraft, 3),
+      finalizedState = _finalizeDraft2[0],
+      finalizedPatches = _finalizeDraft2[1],
+      finalizedInversePatches = _finalizeDraft2[2];
+    return options.enablePatches ? [finalizedState, finalizedPatches, finalizedInversePatches] : finalizedState;
+  }];
+}
+function handleReturnValue(options) {
+  var rootDraft = options.rootDraft,
+    value = options.value,
+    _options$useRawReturn = options.useRawReturn,
+    useRawReturn = _options$useRawReturn === undefined ? false : _options$useRawReturn,
+    _options$isRoot = options.isRoot,
+    isRoot = _options$isRoot === undefined ? true : _options$isRoot;
+  forEach(value, function (key, item, source) {
+    var proxyDraft = getProxyDraft(item);
+    // just handle the draft which is created by the same rootDraft
+    if (proxyDraft && rootDraft && proxyDraft.finalities === rootDraft.finalities) {
+      options.isContainDraft = true;
+      var currentValue = proxyDraft.original;
+      // final update value, but just handle return value
+      if (source instanceof Set) {
+        var arr = Array.from(source);
+        source.clear();
+        arr.forEach(function (_item) {
+          return source.add(key === _item ? currentValue : _item);
+        });
+      } else {
+        set(source, key, currentValue);
+      }
+    } else if (_typeof(item) === 'object' && item !== null) {
+      options.value = item;
+      options.isRoot = false;
+      handleReturnValue(options);
+    }
+  });
+  if (isRoot) {
+    if (!options.isContainDraft) console.warn("The return value does not contain any draft, please use 'rawReturn()' to wrap the return value to improve performance.");
+    if (useRawReturn) {
+      console.warn("The return value contains drafts, please don't use 'rawReturn()' to wrap the return value.");
+    }
+  }
+}
+function getCurrent(target) {
+  var _a;
+  var proxyDraft = getProxyDraft(target);
+  if (!isDraftable(target, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options)) return target;
+  var type = getType(target);
+  if (proxyDraft && !proxyDraft.operated) return proxyDraft.original;
+  var currentValue;
+  function ensureShallowCopy() {
+    currentValue = type === 2 /* DraftType.Map */ ? !isBaseMapInstance(target) ? new (Object.getPrototypeOf(target).constructor)(target) : new Map(target) : type === 3 /* DraftType.Set */ ? Array.from(proxyDraft.setMap.values()) : shallowCopy(target, proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.options);
+  }
+  if (proxyDraft) {
+    // It's a proxy draft, let's create a shallow copy eagerly
+    proxyDraft.finalized = true;
+    try {
+      ensureShallowCopy();
+    } finally {
+      proxyDraft.finalized = false;
+    }
+  } else {
+    // It's not a proxy draft, let's use the target directly and let's see
+    // lazily if we need to create a shallow copy
+    currentValue = target;
+  }
+  forEach(currentValue, function (key, value) {
+    if (proxyDraft && isEqual(get(proxyDraft.original, key), value)) return;
+    var newValue = getCurrent(value);
+    if (newValue !== value) {
+      if (currentValue === target) ensureShallowCopy();
+      set(currentValue, key, newValue);
+    }
+  });
+  if (type === 3 /* DraftType.Set */) {
+    var value = (_a = proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.original) !== null && _a !== undefined ? _a : currentValue;
+    return !isBaseSetInstance(value) ? new (Object.getPrototypeOf(value).constructor)(currentValue) : new Set(currentValue);
+  }
+  return currentValue;
+}
+function current(target) {
+  if (!isDraft(target)) {
+    throw new Error("current() is only used for Draft, parameter: ".concat(target));
+  }
+  return getCurrent(target);
+}
+
+/**
+ * `makeCreator(options)` to make a creator function.
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { makeCreator } from '../index';
+ *
+ * const baseState = { foo: { bar: 'str' }, arr: [] };
+ * const create = makeCreator({ enableAutoFreeze: true });
+ * const state = create(
+ *   baseState,
+ *   (draft) => {
+ *     draft.foo.bar = 'str2';
+ *   },
+ * );
+ *
+ * expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });
+ * expect(state).not.toBe(baseState);
+ * expect(state.foo).not.toBe(baseState.foo);
+ * expect(state.arr).toBe(baseState.arr);
+ * expect(Object.isFrozen(state)).toBeTruthy();
+ * ```
+ */
+var makeCreator = function makeCreator(arg) {
+  return function create(arg0, arg1, arg2) {
+    var _a, _b, _c;
+    if (typeof arg0 === 'function' && typeof arg1 !== 'function') {
+      return function (base) {
+        var _this6 = this;
+        for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key2 = 1; _key2 < _len; _key2++) {
+          args[_key2 - 1] = arguments[_key2];
+        }
+        return create(base, function (draft) {
+          return arg0.call.apply(arg0, [_this6, draft].concat(args));
+        }, arg1);
+      };
+    }
+    var base = arg0;
+    var mutate = arg1;
+    var options = arg2;
+    if (typeof arg1 !== 'function') {
+      options = arg1;
+    }
+    if (options !== undefined && Object.prototype.toString.call(options) !== '[object Object]') {
+      throw new Error("Invalid options: ".concat(options, ", 'options' should be an object."));
+    }
+    options = Object.assign(Object.assign({}, arg), options);
+    var state = isDraft(base) ? current(base) : base;
+    var mark = Array.isArray(options.mark) ? function (value, types) {
+      var _iterator7 = _createForOfIteratorHelper(options.mark),
+        _step7;
+      try {
+        for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {
+          var _mark = _step7.value;
+          if (typeof _mark !== 'function') {
+            throw new Error("Invalid mark: ".concat(_mark, ", 'mark' should be a function."));
+          }
+          var _result = _mark(value, types);
+          if (_result) {
+            return _result;
+          }
+        }
+      } catch (err) {
+        _iterator7.e(err);
+      } finally {
+        _iterator7.f();
+      }
+      return;
+    } : options.mark;
+    var enablePatches = (_a = options.enablePatches) !== null && _a !== undefined ? _a : false;
+    var strict = (_b = options.strict) !== null && _b !== undefined ? _b : false;
+    var enableAutoFreeze = (_c = options.enableAutoFreeze) !== null && _c !== undefined ? _c : false;
+    var _options = {
+      enableAutoFreeze: enableAutoFreeze,
+      mark: mark,
+      strict: strict,
+      enablePatches: enablePatches
+    };
+    if (!isDraftable(state, _options) && _typeof(state) === 'object' && state !== null) {
+      throw new Error("Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.");
+    }
+    var _draftify = draftify(state, _options),
+      _draftify2 = _slicedToArray(_draftify, 2),
+      draft = _draftify2[0],
+      finalize = _draftify2[1];
+    if (typeof arg1 !== 'function') {
+      if (!isDraftable(state, _options)) {
+        throw new Error("Invalid base state: create() only supports plain objects, arrays, Set, Map or using mark() to mark the state as immutable.");
+      }
+      return [draft, finalize];
+    }
+    var result;
+    try {
+      result = mutate(draft);
+    } catch (error) {
+      revokeProxy(getProxyDraft(draft));
+      throw error;
+    }
+    var returnValue = function returnValue(value) {
+      var proxyDraft = getProxyDraft(draft);
+      if (!isDraft(value)) {
+        if (value !== undefined && !isEqual(value, draft) && (proxyDraft === null || proxyDraft === undefined ? undefined : proxyDraft.operated)) {
+          throw new Error("Either the value is returned as a new non-draft value, or only the draft is modified without returning any value.");
+        }
+        var rawReturnValue = value === null || value === undefined ? undefined : value[RAW_RETURN_SYMBOL];
+        if (rawReturnValue) {
+          var _value = rawReturnValue[0];
+          if (_options.strict && _typeof(value) === 'object' && value !== null) {
+            handleReturnValue({
+              rootDraft: proxyDraft,
+              value: value,
+              useRawReturn: true
+            });
+          }
+          return finalize([_value]);
+        }
+        if (value !== undefined) {
+          if (_typeof(value) === 'object' && value !== null) {
+            handleReturnValue({
+              rootDraft: proxyDraft,
+              value: value
+            });
+          }
+          return finalize([value]);
+        }
+      }
+      if (value === draft || value === undefined) {
+        return finalize([]);
+      }
+      var returnedProxyDraft = getProxyDraft(value);
+      if (_options === returnedProxyDraft.options) {
+        if (returnedProxyDraft.operated) {
+          throw new Error("Cannot return a modified child draft.");
+        }
+        return finalize([current(value)]);
+      }
+      return finalize([value]);
+    };
+    if (result instanceof Promise) {
+      return result.then(returnValue, function (error) {
+        revokeProxy(getProxyDraft(draft));
+        throw error;
+      });
+    }
+    return returnValue(result);
+  };
+};
+
+/**
+ * `create(baseState, callback, options)` to create the next state
+ *
+ * ## Example
+ *
+ * ```ts
+ * import { create } from '../index';
+ *
+ * const baseState = { foo: { bar: 'str' }, arr: [] };
+ * const state = create(
+ *   baseState,
+ *   (draft) => {
+ *     draft.foo.bar = 'str2';
+ *   },
+ * );
+ *
+ * expect(state).toEqual({ foo: { bar: 'str2' }, arr: [] });
+ * expect(state).not.toBe(baseState);
+ * expect(state.foo).not.toBe(baseState.foo);
+ * expect(state.arr).toBe(baseState.arr);
+ * ```
+ */
+var create = makeCreator();
+Object.prototype.constructor.toString();
+
+function produceState(state, fn) {
+  state.set(create(state.get(), fn));
+}
+
+var RumiousState = /*#__PURE__*/function () {
+  function RumiousState(target) {
+    var reactor = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
+    _classCallCheck(this, RumiousState);
+    this.value = target;
+    this.reactor = reactor !== null && reactor !== undefined ? reactor : new RumiousReactor(this, []);
+  }
+  return _createClass(RumiousState, [{
+    key: "produce",
+    value: function produce(recipe) {
+      return produceState(this, recipe);
+    }
+  }, {
+    key: "reducer",
+    value: function reducer() {
+      var computedObj;
+      if (arguments.length === 1) {
+        computedObj = new RumiousReducer(this, "", arguments.length <= 0 ? undefined : arguments[0]);
+      } else {
+        computedObj = new RumiousReducer(this, arguments.length <= 0 ? undefined : arguments[0], arguments.length <= 1 ? undefined : arguments[1]);
+      }
+      return computedObj.trigger.bind(computedObj);
+    }
+  }, {
+    key: "setObjectByPath",
+    value: function setObjectByPath() {
+      var path = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : "";
+      var value = arguments.length > 1 ? arguments[1] : undefined;
+      if (path.length == 0) {
+        this.value = value;
+        return;
+      }
+      if (typeof path !== 'string' || !path) {
+        throw new Error('Invalid path');
+      }
+      var keys = path.split('.');
+      var obj = this.value;
+      for (var i = 0; i < keys.length - 1; i++) {
+        var key = keys[i];
+        if (!(key in obj)) {
+          obj[key] = {};
+        }
+        obj = obj[key];
+      }
+      obj[keys[keys.length - 1]] = value;
+    }
+  }, {
+    key: "set",
+    value: function set() {
+      if (arguments.length === 1) {
+        this.value = arguments.length <= 0 ? undefined : arguments[0];
+      } else {
+        var path = arguments.length <= 0 ? undefined : arguments[0];
+        var value = arguments.length <= 1 ? undefined : arguments[1];
+        this.setObjectByPath(path, value);
+      }
+      this.reactor.react();
+    }
+  }, {
+    key: "get",
+    value: function get() {
+      return this.value;
+    }
+  }]);
+}();
+function createState(value) {
+  return new RumiousState(value);
+}
+function isState(obj) {
+  return obj instanceof RumiousState;
+}
+
+function watcher(state, callback) {
+  state.reactor.addBinding(callback);
+}
 
-export { RumiousApp, RumiousComponent, RumiousComponentElement, RumiousState, createComponentElement, createState, isComponent, watcher };
+export { RumiousApp, RumiousComponent, RumiousComponentElement, RumiousState, createComponentElement, createState, isComponent, isState, watcher };
 //# sourceMappingURL=index.esm.js.map