text: /*! Select2 4.0.13 | https://github.com/select2/select2/blob/master/LICENSE.md */
  !function(n){"function"==typeof define&&define.amd?define(["jquery"],n):"object"==typeof module&&module.exports?module.exports=function(e,t){return void 0===t&&(t="undefined"!=typeof window?require("jquery"):require("jquery")(e)),n(t),t}:n(jQuery)}(function(u){var e=function(){if(u&&u.fn&&u.fn.select2&&u.fn.select2.amd)var e=u.fn.select2.amd;var t,n,r,h,o,s,f,g,m,v,y,_,i,a,b;function w(e,t){return i.call(e,t)}function l(e,t){var n,r,i,o,s,a,l,c,u,d,p,h=t&&t.split("/"),f=y.map,g=f&&f["*"]||{};if(e){for(s=(e=e.split("/")).length-1,y.nodeIdCompat&&b.test(e[s])&&(e[s]=e[s].replace(b,"")),"."===e[0].charAt(0)&&h&&(e=h.slice(0,h.length-1).concat(e)),u=0;u<e.length;u++)if("."===(p=e[u]))e.splice(u,1),u-=1;else if(".."===p){if(0===u||1===u&&".."===e[2]||".."===e[u-1])continue;0<u&&(e.splice(u-1,2),u-=2)}e=e.join("/")}if((h||g)&&f){for(u=(n=e.split("/")).length;0<u;u-=1){if(r=n.slice(0,u).join("/"),h)for(d=h.length;0<d;d-=1)if(i=(i=f[h.slice(0,d).join("/")])&&i[r]){o=i,a=u;break}if(o)break;!l&&g&&g[r]&&(l=g[r],c=u)}!o&&l&&(o=l,a=c),o&&(n.splice(0,a,o),e=n.join("/"))}return e}function A(t,n){return function(){var e=a.call(arguments,0);return"string"!=typeof e[0]&&1===e.length&&e.push(null),s.apply(h,e.concat([t,n]))}}function x(t){return function(e){m[t]=e}}function D(e){if(w(v,e)){var t=v[e];delete v[e],_[e]=!0,o.apply(h,t)}if(!w(m,e)&&!w(_,e))throw new Error("No "+e);return m[e]}function c(e){var t,n=e?e.indexOf("!"):-1;return-1<n&&(t=e.substring(0,n),e=e.substring(n+1,e.length)),[t,e]}function S(e){return e?c(e):[]}return e&&e.requirejs||(e?n=e:e={},m={},v={},y={},_={},i=Object.prototype.hasOwnProperty,a=[].slice,b=/\.js$/,f=function(e,t){var n,r=c(e),i=r[0],o=t[1];return e=r[1],i&&(n=D(i=l(i,o))),i?e=n&&n.normalize?n.normalize(e,function(t){return function(e){return l(e,t)}}(o)):l(e,o):(i=(r=c(e=l(e,o)))[0],e=r[1],i&&(n=D(i))),{f:i?i+"!"+e:e,n:e,pr:i,p:n}},g={require:function(e){return A(e)},exports:function(e){var t=m[e];return void 0!==t?t:m[e]={}},module:function(e){return{id:e,uri:"",exports:m[e],config:function(e){return function(){return y&&y.config&&y.config[e]||{}}}(e)}}},o=function(e,t,n,r){var i,o,s,a,l,c,u,d=[],p=typeof n;if(c=S(r=r||e),"undefined"==p||"function"==p){for(t=!t.length&&n.length?["require","exports","module"]:t,l=0;l<t.length;l+=1)if("require"===(o=(a=f(t[l],c)).f))d[l]=g.require(e);else if("exports"===o)d[l]=g.exports(e),u=!0;else if("module"===o)i=d[l]=g.module(e);else if(w(m,o)||w(v,o)||w(_,o))d[l]=D(o);else{if(!a.p)throw new Error(e+" missing "+o);a.p.load(a.n,A(r,!0),x(o),{}),d[l]=m[o]}s=n?n.apply(m[e],d):void 0,e&&(i&&i.exports!==h&&i.exports!==m[e]?m[e]=i.exports:s===h&&u||(m[e]=s))}else e&&(m[e]=n)},t=n=s=function(e,t,n,r,i){if("string"==typeof e)return g[e]?g[e](t):D(f(e,S(t)).f);if(!e.splice){if((y=e).deps&&s(y.deps,y.callback),!t)return;t.splice?(e=t,t=n,n=null):e=h}return t=t||function(){},"function"==typeof n&&(n=r,r=i),r?o(h,e,t,n):setTimeout(function(){o(h,e,t,n)},4),s},s.config=function(e){return s(e)},t._defined=m,(r=function(e,t,n){if("string"!=typeof e)throw new Error("See almond README: incorrect module build, no module name");t.splice||(n=t,t=[]),w(m,e)||w(v,e)||(v[e]=[e,t,n])}).amd={jQuery:!0},e.requirejs=t,e.require=n,e.define=r),e.define("almond",function(){}),e.define("jquery",[],function(){var e=u||$;return null==e&&console&&console.error&&console.error("Select2: An instance of jQuery or a jQuery-compatible library was not found. Make sure that you are including jQuery before Select2 on your web page."),e}),e.define("select2/utils",["jquery"],function(o){var i={};function u(e){var t=e.prototype,n=[];for(var r in t){"function"==typeof t[r]&&"constructor"!==r&&n.push(r)}return n}i.Extend=function(e,t){var n={}.hasOwnProperty;function r(){this.constructor=e}for(var i in t)n.call(t,i)&&(e[i]=t[i]);return r.prototype=t.prototype,e.prototype=new r,e.__super__=t.prototype,e},i.Decorate=function(r,i){var e=u(i),t=u(r);function o(){var e=Array.prototype.unshift,t=i.prototype.constructor.length,n=r.prototype.constructor;0<t&&(e.call(arguments,r.prototype.constructor),n=i.prototype.constructor),n.apply(this,arguments)}i.displayName=r.displayName,o.prototype=new function(){this.constructor=o};for(var n=0;n<t.length;n++){var s=t[n];o.prototype[s]=r.prototype[s]}function a(e){var t=function(){};e in o.prototype&&(t=o.prototype[e]);var n=i.prototype[e];return function(){return Array.prototype.unshift.call(arguments,t),n.apply(this,arguments)}}for(var l=0;l<e.length;l++){var c=e[l];o.prototype[c]=a(c)}return o};function e(){this.listeners={}}e.prototype.on=function(e,t){this.listeners=this.listeners||{},e in this.listeners?this.listeners[e].push(t):this.listeners[e]=[t]},e.prototype.trigger=function(e){var t=Array.prototype.slice,n=t.call(arguments,1);this.listeners=this.listeners||{},null==n&&(n=[]),0===n.length&&n.push({}),(n[0]._type=e)in this.listeners&&this.invoke(this.listeners[e],t.call(arguments,1)),"*"in this.listeners&&this.invoke(this.listeners["*"],arguments)},e.prototype.invoke=function(e,t){for(var n=0,r=e.length;n<r;n++)e[n].apply(this,t)},i.Observable=e,i.generateChars=function(e){for(var t="",n=0;n<e;n++){t+=Math.floor(36*Math.random()).toString(36)}return t},i.bind=function(e,t){return function(){e.apply(t,arguments)}},i._convertData=function(e){for(var t in e){var n=t.split("-"),r=e;if(1!==n.length){for(var i=0;i<n.length;i++){var o=n[i];(o=o.substring(0,1).toLowerCase()+o.substring(1))in r||(r[o]={}),i==n.length-1&&(r[o]=e[t]),r=r[o]}delete e[t]}}return e},i.hasScroll=function(e,t){var n=o(t),r=t.style.overflowX,i=t.style.overflowY;return(r!==i||"hidden"!==i&&"visible"!==i)&&("scroll"===r||"scroll"===i||(n.innerHeight()<t.scrollHeight||n.innerWidth()<t.scrollWidth))},i.escapeMarkup=function(e){var t={"\\":"&#92;","&":"&amp;","<":"&lt;",">":"&gt;",'"':"&quot;","'":"&#39;","/":"&#47;"};return"string"!=typeof e?e:String(e).replace(/[&<>"'\/\\]/g,function(e){return t[e]})},i.appendMany=function(e,t){if("1.7"===o.fn.jquery.substr(0,3)){var n=o();o.map(t,function(e){n=n.add(e)}),t=n}e.append(t)},i.__cache={};var n=0;return i.GetUniqueElementId=function(e){var t=e.getAttribute("data-select2-id");return null==t&&(e.id?(t=e.id,e.setAttribute("data-select2-id",t)):(e.setAttribute("data-select2-id",++n),t=n.toString())),t},i.StoreData=function(e,t,n){var r=i.GetUniqueElementId(e);i.__cache[r]||(i.__cache[r]={}),i.__cache[r][t]=n},i.GetData=function(e,t){var n=i.GetUniqueElementId(e);return t?i.__cache[n]&&null!=i.__cache[n][t]?i.__cache[n][t]:o(e).data(t):i.__cache[n]},i.RemoveData=function(e){var t=i.GetUniqueElementId(e);null!=i.__cache[t]&&delete i.__cache[t],e.removeAttribute("data-select2-id")},i}),e.define("select2/results",["jquery","./utils"],function(h,f){function r(e,t,n){this.$element=e,this.data=n,this.options=t,r.__super__.constructor.call(this)}return f.Extend(r,f.Observable),r.prototype.render=function(){var e=h('<ul class="select2-results__options" role="listbox"></ul>');return this.options.get("multiple")&&e.attr("aria-multiselectable","true"),this.$results=e},r.prototype.clear=function(){this.$results.empty()},r.prototype.displayMessage=function(e){var t=this.options.get("escapeMarkup");this.clear(),this.hideLoading();var n=h('<li role="alert" aria-live="assertive" class="select2-results__option"></li>'),r=this.options.get("translations").get(e.message);n.append(t(r(e.args))),n[0].className+=" select2-results__message",this.$results.append(n)},r.prototype.hideMessages=function(){this.$results.find(".select2-results__message").remove()},r.prototype.append=function(e){this.hideLoading();var t=[];if(null!=e.results&&0!==e.results.length){e.results=this.sort(e.results);for(var n=0;n<e.results.length;n++){var r=e.results[n],i=this.option(r);t.push(i)}this.$results.append(t)}else 0===this.$results.children().length&&this.trigger("results:message",{message:"noResults"})},r.prototype.position=function(e,t){t.find(".select2-results").append(e)},r.prototype.sort=function(e){return this.options.get("sorter")(e)},r.prototype.highlightFirstItem=function(){var e=this.$results.find(".select2-results__option[aria-selected]"),t=e.filter("[aria-selected=true]");0<t.length?t.first().trigger("mouseenter"):e.first().trigger("mouseenter"),this.ensureHighlightVisible()},r.prototype.setClasses=function(){var t=this;this.data.current(function(e){var r=h.map(e,function(e){return e.id.toString()});t.$results.find(".select2-results__option[aria-selected]").each(function(){var e=h(this),t=f.GetData(this,"data"),n=""+t.id;null!=t.element&&t.element.selected||null==t.element&&-1<h.inArray(n,r)?e.attr("aria-selected","true"):e.attr("aria-selected","false")})})},r.prototype.showLoading=function(e){this.hideLoading();var t={disabled:!0,loading:!0,text:this.options.get("translations").get("searching")(e)},n=this.option(t);n.className+=" loading-results",this.$results.prepend(n)},r.prototype.hideLoading=function(){this.$results.find(".loading-results").remove()},r.prototype.option=function(e){var t=document.createElement("li");t.className="select2-results__option";var n={role:"option","aria-selected":"false"},r=window.Element.prototype.matches||window.Element.prototype.msMatchesSelector||window.Element.prototype.webkitMatchesSelector;for(var i in(null!=e.element&&r.call(e.element,":disabled")||null==e.element&&e.disabled)&&(delete n["aria-selected"],n["aria-disabled"]="true"),null==e.id&&delete n["aria-selected"],null!=e._resultId&&(t.id=e._resultId),e.title&&(t.title=e.title),e.children&&(n.role="group",n["aria-label"]=e.text,delete n["aria-selected"]),n){var o=n[i];t.setAttribute(i,o)}if(e.children){var s=h(t),a=document.createElement("strong");a.className="select2-results__group";h(a);this.template(e,a);for(var l=[],c=0;c<e.children.length;c++){var u=e.children[c],d=this.option(u);l.push(d)}var p=h("<ul></ul>",{class:"select2-results__options select2-results__options--nested"});p.append(l),s.append(a),s.append(p)}else this.template(e,t);return f.StoreData(t,"data",e),t},r.prototype.bind=function(t,e){var l=this,n=t.id+"-results";this.$results.attr("id",n),t.on("results:all",function(e){l.clear(),l.append(e.data),t.isOpen()&&(l.setClasses(),l.highlightFirstItem())}),t.on("results:append",function(e){l.append(e.data),t.isOpen()&&l.setClasses()}),t.on("query",function(e){l.hideMessages(),l.showLoading(e)}),t.on("select",function(){t.isOpen()&&(l.setClasses(),l.options.get("scrollAfterSelect")&&l.highlightFirstItem())}),t.on("unselect",function(){t.isOpen()&&(l.setClasses(),l.options.get("scrollAfterSelect")&&l.highlightFirstItem())}),t.on("open",function(){l.$results.attr("aria-expanded","true"),l.$results.attr("aria-hidden","false"),l.setClasses(),l.ensureHighlightVisible()}),t.on("close",function(){l.$results.attr("aria-expanded","false"),l.$results.attr("aria-hidden","true"),l.$results.removeAttr("aria-activedescendant")}),t.on("results:toggle",function(){var e=l.getHighlightedResults();0!==e.length&&e.trigger("mouseup")}),t.on("results:select",function(){var e=l.getHighlightedResults();if(0!==e.length){var t=f.GetData(e[0],"data");"true"==e.attr("aria-selected")?l.trigger("close",{}):l.trigger("select",{data:t})}}),t.on("results:previous",function(){var e=l.getHighlightedResults(),t=l.$results.find("[aria-selected]"),n=t.index(e);if(!(n<=0)){var r=n-1;0===e.length&&(r=0);var i=t.eq(r);i.trigger("mouseenter");var o=l.$results.offset().top,s=i.offset().top,a=l.$results.scrollTop()+(s-o);0===r?l.$results.scrollTop(0):s-o<0&&l.$results.scrollTop(a)}}),t.on("results:next",function(){var e=l.getHighlightedResults(),t=l.$results.find("[aria-selected]"),n=t.index(e)+1;if(!(n>=t.length)){var r=t.eq(n);r.trigger("mouseenter");var i=l.$results.offset().top+l.$results.outerHeight(!1),o=r.offset().top+r.outerHeight(!1),s=l.$results.scrollTop()+o-i;0===n?l.$results.scrollTop(0):i<o&&l.$results.scrollTop(s)}}),t.on("results:focus",function(e){e.element.addClass("select2-results__option--highlighted")}),t.on("results:message",function(e){l.displayMessage(e)}),h.fn.mousewheel&&this.$results.on("mousewheel",function(e){var t=l.$results.scrollTop(),n=l.$results.get(0).scrollHeight-t+e.deltaY,r=0<e.deltaY&&t-e.deltaY<=0,i=e.deltaY<0&&n<=l.$results.height();r?(l.$results.scrollTop(0),e.preventDefault(),e.stopPropagation()):i&&(l.$results.scrollTop(l.$results.get(0).scrollHeight-l.$results.height()),e.preventDefault(),e.stopPropagation())}),this.$results.on("mouseup",".select2-results__option[aria-selected]",function(e){var t=h(this),n=f.GetData(this,"data");"true"!==t.attr("aria-selected")?l.trigger("select",{originalEvent:e,data:n}):l.options.get("multiple")?l.trigger("unselect",{originalEvent:e,data:n}):l.trigger("close",{})}),this.$results.on("mouseenter",".select2-results__option[aria-selected]",function(e){var t=f.GetData(this,"data");l.getHighlightedResults().removeClass("select2-results__option--highlighted"),l.trigger("results:focus",{data:t,element:h(this)})})},r.prototype.getHighlightedResults=function(){return this.$results.find(".select2-results__option--highlighted")},r.prototype.destroy=function(){this.$results.remove()},r.prototype.ensureHighlightVisible=function(){var e=this.getHighlightedResults();if(0!==e.length){var t=this.$results.find("[aria-selected]").index(e),n=this.$results.offset().top,r=e.offset().top,i=this.$results.scrollTop()+(r-n),o=r-n;i-=2*e.outerHeight(!1),t<=2?this.$results.scrollTop(0):(o>this.$results.outerHeight()||o<0)&&this.$results.scrollTop(i)}},r.prototype.template=function(e,t){var n=this.options.get("templateResult"),r=this.options.get("escapeMarkup"),i=n(e,t);null==i?t.style.display="none":"string"==typeof i?t.innerHTML=r(i):h(t).append(i)},r}),e.define("select2/keys",[],function(){return{BACKSPACE:8,TAB:9,ENTER:13,SHIFT:16,CTRL:17,ALT:18,ESC:27,SPACE:32,PAGE_UP:33,PAGE_DOWN:34,END:35,HOME:36,LEFT:37,UP:38,RIGHT:39,DOWN:40,DELETE:46}}),e.define("select2/selection/base",["jquery","../utils","../keys"],function(n,r,i){function o(e,t){this.$element=e,this.options=t,o.__super__.constructor.call(this)}return r.Extend(o,r.Observable),o.prototype.render=function(){var e=n('<span class="select2-selection" role="combobox"  aria-haspopup="true" aria-expanded="false"></span>');return this._tabindex=0,null!=r.GetData(this.$element[0],"old-tabindex")?this._tabindex=r.GetData(this.$element[0],"old-tabindex"):null!=this.$element.attr("tabindex")&&(this._tabindex=this.$element.attr("tabindex")),e.attr("title",this.$element.attr("title")),e.attr("tabindex",this._tabindex),e.attr("aria-disabled","false"),this.$selection=e},o.prototype.bind=function(e,t){var n=this,r=e.id+"-results";this.container=e,this.$selection.on("focus",function(e){n.trigger("focus",e)}),this.$selection.on("blur",function(e){n._handleBlur(e)}),this.$selection.on("keydown",function(e){n.trigger("keypress",e),e.which===i.SPACE&&e.preventDefault()}),e.on("results:focus",function(e){n.$selection.attr("aria-activedescendant",e.data._resultId)}),e.on("selection:update",function(e){n.update(e.data)}),e.on("open",function(){n.$selection.attr("aria-expanded","true"),n.$selection.attr("aria-owns",r),n._attachCloseHandler(e)}),e.on("close",function(){n.$selection.attr("aria-expanded","false"),n.$selection.removeAttr("aria-activedescendant"),n.$selection.removeAttr("aria-owns"),n.$selection.trigger("focus"),n._detachCloseHandler(e)}),e.on("enable",function(){n.$selection.attr("tabindex",n._tabindex),n.$selection.attr("aria-disabled","false")}),e.on("disable",function(){n.$selection.attr("tabindex","-1"),n.$selection.attr("aria-disabled","true")})},o.prototype._handleBlur=function(e){var t=this;window.setTimeout(function(){document.activeElement==t.$selection[0]||n.contains(t.$selection[0],document.activeElement)||t.trigger("blur",e)},1)},o.prototype._attachCloseHandler=function(e){n(document.body).on("mousedown.select2."+e.id,function(e){var t=n(e.target).closest(".select2");n(".select2.select2-container--open").each(function(){this!=t[0]&&r.GetData(this,"element").select2("close")})})},o.prototype._detachCloseHandler=function(e){n(document.body).off("mousedown.select2."+e.id)},o.prototype.position=function(e,t){t.find(".selection").append(e)},o.prototype.destroy=function(){this._detachCloseHandler(this.container)},o.prototype.update=function(e){throw new Error("The `update` method must be defined in child classes.")},o.prototype.isEnabled=function(){return!this.isDisabled()},o.prototype.isDisabled=function(){return this.options.get("disabled")},o}),e.define("select2/selection/single",["jquery","./base","../utils","../keys"],function(e,t,n,r){function i(){i.__super__.constructor.apply(this,arguments)}return n.Extend(i,t),i.prototype.render=function(){var e=i.__super__.render.call(this);return e.addClass("select2-selection--single"),e.html('<span class="select2-selection__rendered"></span><span class="select2-selection__arrow" role="presentation"><b role="presentation"></b></span>'),e},i.prototype.bind=function(t,e){var n=this;i.__super__.bind.apply(this,arguments);var r=t.id+"-container";this.$selection.find(".select2-selection__rendered").attr("id",r).attr("role","textbox").attr("aria-readonly","true"),this.$selection.attr("aria-labelledby",r),this.$selection.on("mousedown",function(e){1===e.which&&n.trigger("toggle",{originalEvent:e})}),this.$selection.on("focus",function(e){}),this.$selection.on("blur",function(e){}),t.on("focus",function(e){t.isOpen()||n.$selection.trigger("focus")})},i.prototype.clear=function(){var e=this.$selection.find(".select2-selection__rendered");e.empty(),e.removeAttr("title")},i.prototype.display=function(e,t){var n=this.options.get("templateSelection");return this.options.get("escapeMarkup")(n(e,t))},i.prototype.selectionContainer=function(){return e("<span></span>")},i.prototype.update=function(e){if(0!==e.length){var t=e[0],n=this.$selection.find(".select2-selection__rendered"),r=this.display(t,n);n.empty().append(r);var i=t.title||t.text;i?n.attr("title",i):n.removeAttr("title")}else this.clear()},i}),e.define("select2/selection/multiple",["jquery","./base","../utils"],function(i,e,l){function n(e,t){n.__super__.constructor.apply(this,arguments)}return l.Extend(n,e),n.prototype.render=function(){var e=n.__super__.render.call(this);return e.addClass("select2-selection--multiple"),e.html('<ul class="select2-selection__rendered"></ul>'),e},n.prototype.bind=function(e,t){var r=this;n.__super__.bind.apply(this,arguments),this.$selection.on("click",function(e){r.trigger("toggle",{originalEvent:e})}),this.$selection.on("click",".select2-selection__choice__remove",function(e){if(!r.isDisabled()){var t=i(this).parent(),n=l.GetData(t[0],"data");r.trigger("unselect",{originalEvent:e,data:n})}})},n.prototype.clear=function(){var e=this.$selection.find(".select2-selection__rendered");e.empty(),e.removeAttr("title")},n.prototype.display=function(e,t){var n=this.options.get("templateSelection");return this.options.get("escapeMarkup")(n(e,t))},n.prototype.selectionContainer=function(){return i('<li class="select2-selection__choice"><span class="select2-selection__choice__remove" role="presentation">&times;</span></li>')},n.prototype.update=function(e){if(this.clear(),0!==e.length){for(var t=[],n=0;n<e.length;n++){var r=e[n],i=this.selectionContainer(),o=this.display(r,i);i.append(o);var s=r.title||r.text;s&&i.attr("title",s),l.StoreData(i[0],"data",r),t.push(i)}var a=this.$selection.find(".select2-selection__rendered");l.appendMany(a,t)}},n}),e.define("select2/selection/placeholder",["../utils"],function(e){function t(e,t,n){this.placeholder=this.normalizePlaceholder(n.get("placeholder")),e.call(this,t,n)}return t.prototype.normalizePlaceholder=function(e,t){return"string"==typeof t&&(t={id:"",text:t}),t},t.prototype.createPlaceholder=function(e,t){var n=this.selectionContainer();return n.html(this.display(t)),n.addClass("select2-selection__placeholder").removeClass("select2-selection__choice"),n},t.prototype.update=function(e,t){var n=1==t.length&&t[0].id!=this.placeholder.id;if(1<t.length||n)return e.call(this,t);this.clear();var r=this.createPlaceholder(this.placeholder);this.$selection.find(".select2-selection__rendered").append(r)},t}),e.define("select2/selection/allowClear",["jquery","../keys","../utils"],function(i,r,a){function e(){}return e.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),null==this.placeholder&&this.options.get("debug")&&window.console&&console.error&&console.error("Select2: The `allowClear` option should be used in combination with the `placeholder` option."),this.$selection.on("mousedown",".select2-selection__clear",function(e){r._handleClear(e)}),t.on("keypress",function(e){r._handleKeyboardClear(e,t)})},e.prototype._handleClear=function(e,t){if(!this.isDisabled()){var n=this.$selection.find(".select2-selection__clear");if(0!==n.length){t.stopPropagation();var r=a.GetData(n[0],"data"),i=this.$element.val();this.$element.val(this.placeholder.id);var o={data:r};if(this.trigger("clear",o),o.prevented)this.$element.val(i);else{for(var s=0;s<r.length;s++)if(o={data:r[s]},this.trigger("unselect",o),o.prevented)return void this.$element.val(i);this.$element.trigger("input").trigger("change"),this.trigger("toggle",{})}}}},e.prototype._handleKeyboardClear=function(e,t,n){n.isOpen()||t.which!=r.DELETE&&t.which!=r.BACKSPACE||this._handleClear(t)},e.prototype.update=function(e,t){if(e.call(this,t),!(0<this.$selection.find(".select2-selection__placeholder").length||0===t.length)){var n=this.options.get("translations").get("removeAllItems"),r=i('<span class="select2-selection__clear" title="'+n()+'">&times;</span>');a.StoreData(r[0],"data",t),this.$selection.find(".select2-selection__rendered").prepend(r)}},e}),e.define("select2/selection/search",["jquery","../utils","../keys"],function(r,a,l){function e(e,t,n){e.call(this,t,n)}return e.prototype.render=function(e){var t=r('<li class="select2-search select2-search--inline"><input class="select2-search__field" type="search" tabindex="-1" autocomplete="off" autocorrect="off" autocapitalize="none" spellcheck="false" role="searchbox" aria-autocomplete="list" /></li>');this.$searchContainer=t,this.$search=t.find("input");var n=e.call(this);return this._transferTabIndex(),n},e.prototype.bind=function(e,t,n){var r=this,i=t.id+"-results";e.call(this,t,n),t.on("open",function(){r.$search.attr("aria-controls",i),r.$search.trigger("focus")}),t.on("close",function(){r.$search.val(""),r.$search.removeAttr("aria-controls"),r.$search.removeAttr("aria-activedescendant"),r.$search.trigger("focus")}),t.on("enable",function(){r.$search.prop("disabled",!1),r._transferTabIndex()}),t.on("disable",function(){r.$search.prop("disabled",!0)}),t.on("focus",function(e){r.$search.trigger("focus")}),t.on("results:focus",function(e){e.data._resultId?r.$search.attr("aria-activedescendant",e.data._resultId):r.$search.removeAttr("aria-activedescendant")}),this.$selection.on("focusin",".select2-search--inline",function(e){r.trigger("focus",e)}),this.$selection.on("focusout",".select2-search--inline",function(e){r._handleBlur(e)}),this.$selection.on("keydown",".select2-search--inline",function(e){if(e.stopPropagation(),r.trigger("keypress",e),r._keyUpPrevented=e.isDefaultPrevented(),e.which===l.BACKSPACE&&""===r.$search.val()){var t=r.$searchContainer.prev(".select2-selection__choice");if(0<t.length){var n=a.GetData(t[0],"data");r.searchRemoveChoice(n),e.preventDefault()}}}),this.$selection.on("click",".select2-search--inline",function(e){r.$search.val()&&e.stopPropagation()});var o=document.documentMode,s=o&&o<=11;this.$selection.on("input.searchcheck",".select2-search--inline",function(e){s?r.$selection.off("input.search input.searchcheck"):r.$selection.off("keyup.search")}),this.$selection.on("keyup.search input.search",".select2-search--inline",function(e){if(s&&"input"===e.type)r.$selection.off("input.search input.searchcheck");else{var t=e.which;t!=l.SHIFT&&t!=l.CTRL&&t!=l.ALT&&t!=l.TAB&&r.handleSearch(e)}})},e.prototype._transferTabIndex=function(e){this.$search.attr("tabindex",this.$selection.attr("tabindex")),this.$selection.attr("tabindex","-1")},e.prototype.createPlaceholder=function(e,t){this.$search.attr("placeholder",t.text)},e.prototype.update=function(e,t){var n=this.$search[0]==document.activeElement;this.$search.attr("placeholder",""),e.call(this,t),this.$selection.find(".select2-selection__rendered").append(this.$searchContainer),this.resizeSearch(),n&&this.$search.trigger("focus")},e.prototype.handleSearch=function(){if(this.resizeSearch(),!this._keyUpPrevented){var e=this.$search.val();this.trigger("query",{term:e})}this._keyUpPrevented=!1},e.prototype.searchRemoveChoice=function(e,t){this.trigger("unselect",{data:t}),this.$search.val(t.text),this.handleSearch()},e.prototype.resizeSearch=function(){this.$search.css("width","25px");var e="";""!==this.$search.attr("placeholder")?e=this.$selection.find(".select2-selection__rendered").width():e=.75*(this.$search.val().length+1)+"em";this.$search.css("width",e)},e}),e.define("select2/selection/eventRelay",["jquery"],function(s){function e(){}return e.prototype.bind=function(e,t,n){var r=this,i=["open","opening","close","closing","select","selecting","unselect","unselecting","clear","clearing"],o=["opening","closing","selecting","unselecting","clearing"];e.call(this,t,n),t.on("*",function(e,t){if(-1!==s.inArray(e,i)){t=t||{};var n=s.Event("select2:"+e,{params:t});r.$element.trigger(n),-1!==s.inArray(e,o)&&(t.prevented=n.isDefaultPrevented())}})},e}),e.define("select2/translation",["jquery","require"],function(t,n){function r(e){this.dict=e||{}}return r.prototype.all=function(){return this.dict},r.prototype.get=function(e){return this.dict[e]},r.prototype.extend=function(e){this.dict=t.extend({},e.all(),this.dict)},r._cache={},r.loadPath=function(e){if(!(e in r._cache)){var t=n(e);r._cache[e]=t}return new r(r._cache[e])},r}),e.define("select2/diacritics",[],function(){return{"Ⓐ":"A","Ａ":"A","À":"A","Á":"A","Â":"A","Ầ":"A","Ấ":"A","Ẫ":"A","Ẩ":"A","Ã":"A","Ā":"A","Ă":"A","Ằ":"A","Ắ":"A","Ẵ":"A","Ẳ":"A","Ȧ":"A","Ǡ":"A","Ä":"A","Ǟ":"A","Ả":"A","Å":"A","Ǻ":"A","Ǎ":"A","Ȁ":"A","Ȃ":"A","Ạ":"A","Ậ":"A","Ặ":"A","Ḁ":"A","Ą":"A","Ⱥ":"A","Ɐ":"A","Ꜳ":"AA","Æ":"AE","Ǽ":"AE","Ǣ":"AE","Ꜵ":"AO","Ꜷ":"AU","Ꜹ":"AV","Ꜻ":"AV","Ꜽ":"AY","Ⓑ":"B","Ｂ":"B","Ḃ":"B","Ḅ":"B","Ḇ":"B","Ƀ":"B","Ƃ":"B","Ɓ":"B","Ⓒ":"C","Ｃ":"C","Ć":"C","Ĉ":"C","Ċ":"C","Č":"C","Ç":"C","Ḉ":"C","Ƈ":"C","Ȼ":"C","Ꜿ":"C","Ⓓ":"D","Ｄ":"D","Ḋ":"D","Ď":"D","Ḍ":"D","Ḑ":"D","Ḓ":"D","Ḏ":"D","Đ":"D","Ƌ":"D","Ɗ":"D","Ɖ":"D","Ꝺ":"D","Ǳ":"DZ","Ǆ":"DZ","ǲ":"Dz","ǅ":"Dz","Ⓔ":"E","Ｅ":"E","È":"E","É":"E","Ê":"E","Ề":"E","Ế":"E","Ễ":"E","Ể":"E","Ẽ":"E","Ē":"E","Ḕ":"E","Ḗ":"E","Ĕ":"E","Ė":"E","Ë":"E","Ẻ":"E","Ě":"E","Ȅ":"E","Ȇ":"E","Ẹ":"E","Ệ":"E","Ȩ":"E","Ḝ":"E","Ę":"E","Ḙ":"E","Ḛ":"E","Ɛ":"E","Ǝ":"E","Ⓕ":"F","Ｆ":"F","Ḟ":"F","Ƒ":"F","Ꝼ":"F","Ⓖ":"G","Ｇ":"G","Ǵ":"G","Ĝ":"G","Ḡ":"G","Ğ":"G","Ġ":"G","Ǧ":"G","Ģ":"G","Ǥ":"G","Ɠ":"G","Ꞡ":"G","Ᵹ":"G","Ꝿ":"G","Ⓗ":"H","Ｈ":"H","Ĥ":"H","Ḣ":"H","Ḧ":"H","Ȟ":"H","Ḥ":"H","Ḩ":"H","Ḫ":"H","Ħ":"H","Ⱨ":"H","Ⱶ":"H","Ɥ":"H","Ⓘ":"I","Ｉ":"I","Ì":"I","Í":"I","Î":"I","Ĩ":"I","Ī":"I","Ĭ":"I","İ":"I","Ï":"I","Ḯ":"I","Ỉ":"I","Ǐ":"I","Ȉ":"I","Ȋ":"I","Ị":"I","Į":"I","Ḭ":"I","Ɨ":"I","Ⓙ":"J","Ｊ":"J","Ĵ":"J","Ɉ":"J","Ⓚ":"K","Ｋ":"K","Ḱ":"K","Ǩ":"K","Ḳ":"K","Ķ":"K","Ḵ":"K","Ƙ":"K","Ⱪ":"K","Ꝁ":"K","Ꝃ":"K","Ꝅ":"K","Ꞣ":"K","Ⓛ":"L","Ｌ":"L","Ŀ":"L","Ĺ":"L","Ľ":"L","Ḷ":"L","Ḹ":"L","Ļ":"L","Ḽ":"L","Ḻ":"L","Ł":"L","Ƚ":"L","Ɫ":"L","Ⱡ":"L","Ꝉ":"L","Ꝇ":"L","Ꞁ":"L","Ǉ":"LJ","ǈ":"Lj","Ⓜ":"M","Ｍ":"M","Ḿ":"M","Ṁ":"M","Ṃ":"M","Ɱ":"M","Ɯ":"M","Ⓝ":"N","Ｎ":"N","Ǹ":"N","Ń":"N","Ñ":"N","Ṅ":"N","Ň":"N","Ṇ":"N","Ņ":"N","Ṋ":"N","Ṉ":"N","Ƞ":"N","Ɲ":"N","Ꞑ":"N","Ꞥ":"N","Ǌ":"NJ","ǋ":"Nj","Ⓞ":"O","Ｏ":"O","Ò":"O","Ó":"O","Ô":"O","Ồ":"O","Ố":"O","Ỗ":"O","Ổ":"O","Õ":"O","Ṍ":"O","Ȭ":"O","Ṏ":"O","Ō":"O","Ṑ":"O","Ṓ":"O","Ŏ":"O","Ȯ":"O","Ȱ":"O","Ö":"O","Ȫ":"O","Ỏ":"O","Ő":"O","Ǒ":"O","Ȍ":"O","Ȏ":"O","Ơ":"O","Ờ":"O","Ớ":"O","Ỡ":"O","Ở":"O","Ợ":"O","Ọ":"O","Ộ":"O","Ǫ":"O","Ǭ":"O","Ø":"O","Ǿ":"O","Ɔ":"O","Ɵ":"O","Ꝋ":"O","Ꝍ":"O","Œ":"OE","Ƣ":"OI","Ꝏ":"OO","Ȣ":"OU","Ⓟ":"P","Ｐ":"P","Ṕ":"P","Ṗ":"P","Ƥ":"P","Ᵽ":"P","Ꝑ":"P","Ꝓ":"P","Ꝕ":"P","Ⓠ":"Q","Ｑ":"Q","Ꝗ":"Q","Ꝙ":"Q","Ɋ":"Q","Ⓡ":"R","Ｒ":"R","Ŕ":"R","Ṙ":"R","Ř":"R","Ȑ":"R","Ȓ":"R","Ṛ":"R","Ṝ":"R","Ŗ":"R","Ṟ":"R","Ɍ":"R","Ɽ":"R","Ꝛ":"R","Ꞧ":"R","Ꞃ":"R","Ⓢ":"S","Ｓ":"S","ẞ":"S","Ś":"S","Ṥ":"S","Ŝ":"S","Ṡ":"S","Š":"S","Ṧ":"S","Ṣ":"S","Ṩ":"S","Ș":"S","Ş":"S","Ȿ":"S","Ꞩ":"S","Ꞅ":"S","Ⓣ":"T","Ｔ":"T","Ṫ":"T","Ť":"T","Ṭ":"T","Ț":"T","Ţ":"T","Ṱ":"T","Ṯ":"T","Ŧ":"T","Ƭ":"T","Ʈ":"T","Ⱦ":"T","Ꞇ":"T","Ꜩ":"TZ","Ⓤ":"U","Ｕ":"U","Ù":"U","Ú":"U","Û":"U","Ũ":"U","Ṹ":"U","Ū":"U","Ṻ":"U","Ŭ":"U","Ü":"U","Ǜ":"U","Ǘ":"U","Ǖ":"U","Ǚ":"U","Ủ":"U","Ů":"U","Ű":"U","Ǔ":"U","Ȕ":"U","Ȗ":"U","Ư":"U","Ừ":"U","Ứ":"U","Ữ":"U","Ử":"U","Ự":"U","Ụ":"U","Ṳ":"U","Ų":"U","Ṷ":"U","Ṵ":"U","Ʉ":"U","Ⓥ":"V","Ｖ":"V","Ṽ":"V","Ṿ":"V","Ʋ":"V","Ꝟ":"V","Ʌ":"V","Ꝡ":"VY","Ⓦ":"W","Ｗ":"W","Ẁ":"W","Ẃ":"W","Ŵ":"W","Ẇ":"W","Ẅ":"W","Ẉ":"W","Ⱳ":"W","Ⓧ":"X","Ｘ":"X","Ẋ":"X","Ẍ":"X","Ⓨ":"Y","Ｙ":"Y","Ỳ":"Y","Ý":"Y","Ŷ":"Y","Ỹ":"Y","Ȳ":"Y","Ẏ":"Y","Ÿ":"Y","Ỷ":"Y","Ỵ":"Y","Ƴ":"Y","Ɏ":"Y","Ỿ":"Y","Ⓩ":"Z","Ｚ":"Z","Ź":"Z","Ẑ":"Z","Ż":"Z","Ž":"Z","Ẓ":"Z","Ẕ":"Z","Ƶ":"Z","Ȥ":"Z","Ɀ":"Z","Ⱬ":"Z","Ꝣ":"Z","ⓐ":"a","ａ":"a","ẚ":"a","à":"a","á":"a","â":"a","ầ":"a","ấ":"a","ẫ":"a","ẩ":"a","ã":"a","ā":"a","ă":"a","ằ":"a","ắ":"a","ẵ":"a","ẳ":"a","ȧ":"a","ǡ":"a","ä":"a","ǟ":"a","ả":"a","å":"a","ǻ":"a","ǎ":"a","ȁ":"a","ȃ":"a","ạ":"a","ậ":"a","ặ":"a","ḁ":"a","ą":"a","ⱥ":"a","ɐ":"a","ꜳ":"aa","æ":"ae","ǽ":"ae","ǣ":"ae","ꜵ":"ao","ꜷ":"au","ꜹ":"av","ꜻ":"av","ꜽ":"ay","ⓑ":"b","ｂ":"b","ḃ":"b","ḅ":"b","ḇ":"b","ƀ":"b","ƃ":"b","ɓ":"b","ⓒ":"c","ｃ":"c","ć":"c","ĉ":"c","ċ":"c","č":"c","ç":"c","ḉ":"c","ƈ":"c","ȼ":"c","ꜿ":"c","ↄ":"c","ⓓ":"d","ｄ":"d","ḋ":"d","ď":"d","ḍ":"d","ḑ":"d","ḓ":"d","ḏ":"d","đ":"d","ƌ":"d","ɖ":"d","ɗ":"d","ꝺ":"d","ǳ":"dz","ǆ":"dz","ⓔ":"e","ｅ":"e","è":"e","é":"e","ê":"e","ề":"e","ế":"e","ễ":"e","ể":"e","ẽ":"e","ē":"e","ḕ":"e","ḗ":"e","ĕ":"e","ė":"e","ë":"e","ẻ":"e","ě":"e","ȅ":"e","ȇ":"e","ẹ":"e","ệ":"e","ȩ":"e","ḝ":"e","ę":"e","ḙ":"e","ḛ":"e","ɇ":"e","ɛ":"e","ǝ":"e","ⓕ":"f","ｆ":"f","ḟ":"f","ƒ":"f","ꝼ":"f","ⓖ":"g","ｇ":"g","ǵ":"g","ĝ":"g","ḡ":"g","ğ":"g","ġ":"g","ǧ":"g","ģ":"g","ǥ":"g","ɠ":"g","ꞡ":"g","ᵹ":"g","ꝿ":"g","ⓗ":"h","ｈ":"h","ĥ":"h","ḣ":"h","ḧ":"h","ȟ":"h","ḥ":"h","ḩ":"h","ḫ":"h","ẖ":"h","ħ":"h","ⱨ":"h","ⱶ":"h","ɥ":"h","ƕ":"hv","ⓘ":"i","ｉ":"i","ì":"i","í":"i","î":"i","ĩ":"i","ī":"i","ĭ":"i","ï":"i","ḯ":"i","ỉ":"i","ǐ":"i","ȉ":"i","ȋ":"i","ị":"i","į":"i","ḭ":"i","ɨ":"i","ı":"i","ⓙ":"j","ｊ":"j","ĵ":"j","ǰ":"j","ɉ":"j","ⓚ":"k","ｋ":"k","ḱ":"k","ǩ":"k","ḳ":"k","ķ":"k","ḵ":"k","ƙ":"k","ⱪ":"k","ꝁ":"k","ꝃ":"k","ꝅ":"k","ꞣ":"k","ⓛ":"l","ｌ":"l","ŀ":"l","ĺ":"l","ľ":"l","ḷ":"l","ḹ":"l","ļ":"l","ḽ":"l","ḻ":"l","ſ":"l","ł":"l","ƚ":"l","ɫ":"l","ⱡ":"l","ꝉ":"l","ꞁ":"l","ꝇ":"l","ǉ":"lj","ⓜ":"m","ｍ":"m","ḿ":"m","ṁ":"m","ṃ":"m","ɱ":"m","ɯ":"m","ⓝ":"n","ｎ":"n","ǹ":"n","ń":"n","ñ":"n","ṅ":"n","ň":"n","ṇ":"n","ņ":"n","ṋ":"n","ṉ":"n","ƞ":"n","ɲ":"n","ŉ":"n","ꞑ":"n","ꞥ":"n","ǌ":"nj","ⓞ":"o","ｏ":"o","ò":"o","ó":"o","ô":"o","ồ":"o","ố":"o","ỗ":"o","ổ":"o","õ":"o","ṍ":"o","ȭ":"o","ṏ":"o","ō":"o","ṑ":"o","ṓ":"o","ŏ":"o","ȯ":"o","ȱ":"o","ö":"o","ȫ":"o","ỏ":"o","ő":"o","ǒ":"o","ȍ":"o","ȏ":"o","ơ":"o","ờ":"o","ớ":"o","ỡ":"o","ở":"o","ợ":"o","ọ":"o","ộ":"o","ǫ":"o","ǭ":"o","ø":"o","ǿ":"o","ɔ":"o","ꝋ":"o","ꝍ":"o","ɵ":"o","œ":"oe","ƣ":"oi","ȣ":"ou","ꝏ":"oo","ⓟ":"p","ｐ":"p","ṕ":"p","ṗ":"p","ƥ":"p","ᵽ":"p","ꝑ":"p","ꝓ":"p","ꝕ":"p","ⓠ":"q","ｑ":"q","ɋ":"q","ꝗ":"q","ꝙ":"q","ⓡ":"r","ｒ":"r","ŕ":"r","ṙ":"r","ř":"r","ȑ":"r","ȓ":"r","ṛ":"r","ṝ":"r","ŗ":"r","ṟ":"r","ɍ":"r","ɽ":"r","ꝛ":"r","ꞧ":"r","ꞃ":"r","ⓢ":"s","ｓ":"s","ß":"s","ś":"s","ṥ":"s","ŝ":"s","ṡ":"s","š":"s","ṧ":"s","ṣ":"s","ṩ":"s","ș":"s","ş":"s","ȿ":"s","ꞩ":"s","ꞅ":"s","ẛ":"s","ⓣ":"t","ｔ":"t","ṫ":"t","ẗ":"t","ť":"t","ṭ":"t","ț":"t","ţ":"t","ṱ":"t","ṯ":"t","ŧ":"t","ƭ":"t","ʈ":"t","ⱦ":"t","ꞇ":"t","ꜩ":"tz","ⓤ":"u","ｕ":"u","ù":"u","ú":"u","û":"u","ũ":"u","ṹ":"u","ū":"u","ṻ":"u","ŭ":"u","ü":"u","ǜ":"u","ǘ":"u","ǖ":"u","ǚ":"u","ủ":"u","ů":"u","ű":"u","ǔ":"u","ȕ":"u","ȗ":"u","ư":"u","ừ":"u","ứ":"u","ữ":"u","ử":"u","ự":"u","ụ":"u","ṳ":"u","ų":"u","ṷ":"u","ṵ":"u","ʉ":"u","ⓥ":"v","ｖ":"v","ṽ":"v","ṿ":"v","ʋ":"v","ꝟ":"v","ʌ":"v","ꝡ":"vy","ⓦ":"w","ｗ":"w","ẁ":"w","ẃ":"w","ŵ":"w","ẇ":"w","ẅ":"w","ẘ":"w","ẉ":"w","ⱳ":"w","ⓧ":"x","ｘ":"x","ẋ":"x","ẍ":"x","ⓨ":"y","ｙ":"y","ỳ":"y","ý":"y","ŷ":"y","ỹ":"y","ȳ":"y","ẏ":"y","ÿ":"y","ỷ":"y","ẙ":"y","ỵ":"y","ƴ":"y","ɏ":"y","ỿ":"y","ⓩ":"z","ｚ":"z","ź":"z","ẑ":"z","ż":"z","ž":"z","ẓ":"z","ẕ":"z","ƶ":"z","ȥ":"z","ɀ":"z","ⱬ":"z","ꝣ":"z","Ά":"Α","Έ":"Ε","Ή":"Η","Ί":"Ι","Ϊ":"Ι","Ό":"Ο","Ύ":"Υ","Ϋ":"Υ","Ώ":"Ω","ά":"α","έ":"ε","ή":"η","ί":"ι","ϊ":"ι","ΐ":"ι","ό":"ο","ύ":"υ","ϋ":"υ","ΰ":"υ","ώ":"ω","ς":"σ","’":"'"}}),e.define("select2/data/base",["../utils"],function(r){function n(e,t){n.__super__.constructor.call(this)}return r.Extend(n,r.Observable),n.prototype.current=function(e){throw new Error("The `current` method must be defined in child classes.")},n.prototype.query=function(e,t){throw new Error("The `query` method must be defined in child classes.")},n.prototype.bind=function(e,t){},n.prototype.destroy=function(){},n.prototype.generateResultId=function(e,t){var n=e.id+"-result-";return n+=r.generateChars(4),null!=t.id?n+="-"+t.id.toString():n+="-"+r.generateChars(4),n},n}),e.define("select2/data/select",["./base","../utils","jquery"],function(e,a,l){function n(e,t){this.$element=e,this.options=t,n.__super__.constructor.call(this)}return a.Extend(n,e),n.prototype.current=function(e){var n=[],r=this;this.$element.find(":selected").each(function(){var e=l(this),t=r.item(e);n.push(t)}),e(n)},n.prototype.select=function(i){var o=this;if(i.selected=!0,l(i.element).is("option"))return i.element.selected=!0,void this.$element.trigger("input").trigger("change");if(this.$element.prop("multiple"))this.current(function(e){var t=[];(i=[i]).push.apply(i,e);for(var n=0;n<i.length;n++){var r=i[n].id;-1===l.inArray(r,t)&&t.push(r)}o.$element.val(t),o.$element.trigger("input").trigger("change")});else{var e=i.id;this.$element.val(e),this.$element.trigger("input").trigger("change")}},n.prototype.unselect=function(i){var o=this;if(this.$element.prop("multiple")){if(i.selected=!1,l(i.element).is("option"))return i.element.selected=!1,void this.$element.trigger("input").trigger("change");this.current(function(e){for(var t=[],n=0;n<e.length;n++){var r=e[n].id;r!==i.id&&-1===l.inArray(r,t)&&t.push(r)}o.$element.val(t),o.$element.trigger("input").trigger("change")})}},n.prototype.bind=function(e,t){var n=this;(this.container=e).on("select",function(e){n.select(e.data)}),e.on("unselect",function(e){n.unselect(e.data)})},n.prototype.destroy=function(){this.$element.find("*").each(function(){a.RemoveData(this)})},n.prototype.query=function(r,e){var i=[],o=this;this.$element.children().each(function(){var e=l(this);if(e.is("option")||e.is("optgroup")){var t=o.item(e),n=o.matches(r,t);null!==n&&i.push(n)}}),e({results:i})},n.prototype.addOptions=function(e){a.appendMany(this.$element,e)},n.prototype.option=function(e){var t;e.children?(t=document.createElement("optgroup")).label=e.text:void 0!==(t=document.createElement("option")).textContent?t.textContent=e.text:t.innerText=e.text,void 0!==e.id&&(t.value=e.id),e.disabled&&(t.disabled=!0),e.selected&&(t.selected=!0),e.title&&(t.title=e.title);var n=l(t),r=this._normalizeItem(e);return r.element=t,a.StoreData(t,"data",r),n},n.prototype.item=function(e){var t={};if(null!=(t=a.GetData(e[0],"data")))return t;if(e.is("option"))t={id:e.val(),text:e.text(),disabled:e.prop("disabled"),selected:e.prop("selected"),title:e.prop("title")};else if(e.is("optgroup")){t={text:e.prop("label"),children:[],title:e.prop("title")};for(var n=e.children("option"),r=[],i=0;i<n.length;i++){var o=l(n[i]),s=this.item(o);r.push(s)}t.children=r}return(t=this._normalizeItem(t)).element=e[0],a.StoreData(e[0],"data",t),t},n.prototype._normalizeItem=function(e){e!==Object(e)&&(e={id:e,text:e});return null!=(e=l.extend({},{text:""},e)).id&&(e.id=e.id.toString()),null!=e.text&&(e.text=e.text.toString()),null==e._resultId&&e.id&&null!=this.container&&(e._resultId=this.generateResultId(this.container,e)),l.extend({},{selected:!1,disabled:!1},e)},n.prototype.matches=function(e,t){return this.options.get("matcher")(e,t)},n}),e.define("select2/data/array",["./select","../utils","jquery"],function(e,f,g){function r(e,t){this._dataToConvert=t.get("data")||[],r.__super__.constructor.call(this,e,t)}return f.Extend(r,e),r.prototype.bind=function(e,t){r.__super__.bind.call(this,e,t),this.addOptions(this.convertToOptions(this._dataToConvert))},r.prototype.select=function(n){var e=this.$element.find("option").filter(function(e,t){return t.value==n.id.toString()});0===e.length&&(e=this.option(n),this.addOptions(e)),r.__super__.select.call(this,n)},r.prototype.convertToOptions=function(e){var t=this,n=this.$element.find("option"),r=n.map(function(){return t.item(g(this)).id}).get(),i=[];function o(e){return function(){return g(this).val()==e.id}}for(var s=0;s<e.length;s++){var a=this._normalizeItem(e[s]);if(0<=g.inArray(a.id,r)){var l=n.filter(o(a)),c=this.item(l),u=g.extend(!0,{},a,c),d=this.option(u);l.replaceWith(d)}else{var p=this.option(a);if(a.children){var h=this.convertToOptions(a.children);f.appendMany(p,h)}i.push(p)}}return i},r}),e.define("select2/data/ajax",["./array","../utils","jquery"],function(e,t,o){function n(e,t){this.ajaxOptions=this._applyDefaults(t.get("ajax")),null!=this.ajaxOptions.processResults&&(this.processResults=this.ajaxOptions.processResults),n.__super__.constructor.call(this,e,t)}return t.Extend(n,e),n.prototype._applyDefaults=function(e){var t={data:function(e){return o.extend({},e,{q:e.term})},transport:function(e,t,n){var r=o.ajax(e);return r.then(t),r.fail(n),r}};return o.extend({},t,e,!0)},n.prototype.processResults=function(e){return e},n.prototype.query=function(n,r){var i=this;null!=this._request&&(o.isFunction(this._request.abort)&&this._request.abort(),this._request=null);var t=o.extend({type:"GET"},this.ajaxOptions);function e(){var e=t.transport(t,function(e){var t=i.processResults(e,n);i.options.get("debug")&&window.console&&console.error&&(t&&t.results&&o.isArray(t.results)||console.error("Select2: The AJAX results did not return an array in the `results` key of the response.")),r(t)},function(){"status"in e&&(0===e.status||"0"===e.status)||i.trigger("results:message",{message:"errorLoading"})});i._request=e}"function"==typeof t.url&&(t.url=t.url.call(this.$element,n)),"function"==typeof t.data&&(t.data=t.data.call(this.$element,n)),this.ajaxOptions.delay&&null!=n.term?(this._queryTimeout&&window.clearTimeout(this._queryTimeout),this._queryTimeout=window.setTimeout(e,this.ajaxOptions.delay)):e()},n}),e.define("select2/data/tags",["jquery"],function(u){function e(e,t,n){var r=n.get("tags"),i=n.get("createTag");void 0!==i&&(this.createTag=i);var o=n.get("insertTag");if(void 0!==o&&(this.insertTag=o),e.call(this,t,n),u.isArray(r))for(var s=0;s<r.length;s++){var a=r[s],l=this._normalizeItem(a),c=this.option(l);this.$element.append(c)}}return e.prototype.query=function(e,c,u){var d=this;this._removeOldTags(),null!=c.term&&null==c.page?e.call(this,c,function e(t,n){for(var r=t.results,i=0;i<r.length;i++){var o=r[i],s=null!=o.children&&!e({results:o.children},!0);if((o.text||"").toUpperCase()===(c.term||"").toUpperCase()||s)return!n&&(t.data=r,void u(t))}if(n)return!0;var a=d.createTag(c);if(null!=a){var l=d.option(a);l.attr("data-select2-tag",!0),d.addOptions([l]),d.insertTag(r,a)}t.results=r,u(t)}):e.call(this,c,u)},e.prototype.createTag=function(e,t){var n=u.trim(t.term);return""===n?null:{id:n,text:n}},e.prototype.insertTag=function(e,t,n){t.unshift(n)},e.prototype._removeOldTags=function(e){this.$element.find("option[data-select2-tag]").each(function(){this.selected||u(this).remove()})},e}),e.define("select2/data/tokenizer",["jquery"],function(d){function e(e,t,n){var r=n.get("tokenizer");void 0!==r&&(this.tokenizer=r),e.call(this,t,n)}return e.prototype.bind=function(e,t,n){e.call(this,t,n),this.$search=t.dropdown.$search||t.selection.$search||n.find(".select2-search__field")},e.prototype.query=function(e,t,n){var r=this;t.term=t.term||"";var i=this.tokenizer(t,this.options,function(e){var t=r._normalizeItem(e);if(!r.$element.find("option").filter(function(){return d(this).val()===t.id}).length){var n=r.option(t);n.attr("data-select2-tag",!0),r._removeOldTags(),r.addOptions([n])}!function(e){r.trigger("select",{data:e})}(t)});i.term!==t.term&&(this.$search.length&&(this.$search.val(i.term),this.$search.trigger("focus")),t.term=i.term),e.call(this,t,n)},e.prototype.tokenizer=function(e,t,n,r){for(var i=n.get("tokenSeparators")||[],o=t.term,s=0,a=this.createTag||function(e){return{id:e.term,text:e.term}};s<o.length;){var l=o[s];if(-1!==d.inArray(l,i)){var c=o.substr(0,s),u=a(d.extend({},t,{term:c}));null!=u?(r(u),o=o.substr(s+1)||"",s=0):s++}else s++}return{term:o}},e}),e.define("select2/data/minimumInputLength",[],function(){function e(e,t,n){this.minimumInputLength=n.get("minimumInputLength"),e.call(this,t,n)}return e.prototype.query=function(e,t,n){t.term=t.term||"",t.term.length<this.minimumInputLength?this.trigger("results:message",{message:"inputTooShort",args:{minimum:this.minimumInputLength,input:t.term,params:t}}):e.call(this,t,n)},e}),e.define("select2/data/maximumInputLength",[],function(){function e(e,t,n){this.maximumInputLength=n.get("maximumInputLength"),e.call(this,t,n)}return e.prototype.query=function(e,t,n){t.term=t.term||"",0<this.maximumInputLength&&t.term.length>this.maximumInputLength?this.trigger("results:message",{message:"inputTooLong",args:{maximum:this.maximumInputLength,input:t.term,params:t}}):e.call(this,t,n)},e}),e.define("select2/data/maximumSelectionLength",[],function(){function e(e,t,n){this.maximumSelectionLength=n.get("maximumSelectionLength"),e.call(this,t,n)}return e.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("select",function(){r._checkIfMaximumSelected()})},e.prototype.query=function(e,t,n){var r=this;this._checkIfMaximumSelected(function(){e.call(r,t,n)})},e.prototype._checkIfMaximumSelected=function(e,n){var r=this;this.current(function(e){var t=null!=e?e.length:0;0<r.maximumSelectionLength&&t>=r.maximumSelectionLength?r.trigger("results:message",{message:"maximumSelected",args:{maximum:r.maximumSelectionLength}}):n&&n()})},e}),e.define("select2/dropdown",["jquery","./utils"],function(t,e){function n(e,t){this.$element=e,this.options=t,n.__super__.constructor.call(this)}return e.Extend(n,e.Observable),n.prototype.render=function(){var e=t('<span class="select2-dropdown"><span class="select2-results"></span></span>');return e.attr("dir",this.options.get("dir")),this.$dropdown=e},n.prototype.bind=function(){},n.prototype.position=function(e,t){},n.prototype.destroy=function(){this.$dropdown.remove()},n}),e.define("select2/dropdown/search",["jquery","../utils"],function(o,e){function t(){}return t.prototype.render=function(e){var t=e.call(this),n=o('<span class="select2-search select2-search--dropdown"><input class="select2-search__field" type="search" tabindex="-1" autocomplete="off" autocorrect="off" autocapitalize="none" spellcheck="false" role="searchbox" aria-autocomplete="list" /></span>');return this.$searchContainer=n,this.$search=n.find("input"),t.prepend(n),t},t.prototype.bind=function(e,t,n){var r=this,i=t.id+"-results";e.call(this,t,n),this.$search.on("keydown",function(e){r.trigger("keypress",e),r._keyUpPrevented=e.isDefaultPrevented()}),this.$search.on("input",function(e){o(this).off("keyup")}),this.$search.on("keyup input",function(e){r.handleSearch(e)}),t.on("open",function(){r.$search.attr("tabindex",0),r.$search.attr("aria-controls",i),r.$search.trigger("focus"),window.setTimeout(function(){r.$search.trigger("focus")},0)}),t.on("close",function(){r.$search.attr("tabindex",-1),r.$search.removeAttr("aria-controls"),r.$search.removeAttr("aria-activedescendant"),r.$search.val(""),r.$search.trigger("blur")}),t.on("focus",function(){t.isOpen()||r.$search.trigger("focus")}),t.on("results:all",function(e){null!=e.query.term&&""!==e.query.term||(r.showSearch(e)?r.$searchContainer.removeClass("select2-search--hide"):r.$searchContainer.addClass("select2-search--hide"))}),t.on("results:focus",function(e){e.data._resultId?r.$search.attr("aria-activedescendant",e.data._resultId):r.$search.removeAttr("aria-activedescendant")})},t.prototype.handleSearch=function(e){if(!this._keyUpPrevented){var t=this.$search.val();this.trigger("query",{term:t})}this._keyUpPrevented=!1},t.prototype.showSearch=function(e,t){return!0},t}),e.define("select2/dropdown/hidePlaceholder",[],function(){function e(e,t,n,r){this.placeholder=this.normalizePlaceholder(n.get("placeholder")),e.call(this,t,n,r)}return e.prototype.append=function(e,t){t.results=this.removePlaceholder(t.results),e.call(this,t)},e.prototype.normalizePlaceholder=function(e,t){return"string"==typeof t&&(t={id:"",text:t}),t},e.prototype.removePlaceholder=function(e,t){for(var n=t.slice(0),r=t.length-1;0<=r;r--){var i=t[r];this.placeholder.id===i.id&&n.splice(r,1)}return n},e}),e.define("select2/dropdown/infiniteScroll",["jquery"],function(n){function e(e,t,n,r){this.lastParams={},e.call(this,t,n,r),this.$loadingMore=this.createLoadingMore(),this.loading=!1}return e.prototype.append=function(e,t){this.$loadingMore.remove(),this.loading=!1,e.call(this,t),this.showLoadingMore(t)&&(this.$results.append(this.$loadingMore),this.loadMoreIfNeeded())},e.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("query",function(e){r.lastParams=e,r.loading=!0}),t.on("query:append",function(e){r.lastParams=e,r.loading=!0}),this.$results.on("scroll",this.loadMoreIfNeeded.bind(this))},e.prototype.loadMoreIfNeeded=function(){var e=n.contains(document.documentElement,this.$loadingMore[0]);if(!this.loading&&e){var t=this.$results.offset().top+this.$results.outerHeight(!1);this.$loadingMore.offset().top+this.$loadingMore.outerHeight(!1)<=t+50&&this.loadMore()}},e.prototype.loadMore=function(){this.loading=!0;var e=n.extend({},{page:1},this.lastParams);e.page++,this.trigger("query:append",e)},e.prototype.showLoadingMore=function(e,t){return t.pagination&&t.pagination.more},e.prototype.createLoadingMore=function(){var e=n('<li class="select2-results__option select2-results__option--load-more"role="option" aria-disabled="true"></li>'),t=this.options.get("translations").get("loadingMore");return e.html(t(this.lastParams)),e},e}),e.define("select2/dropdown/attachBody",["jquery","../utils"],function(f,a){function e(e,t,n){this.$dropdownParent=f(n.get("dropdownParent")||document.body),e.call(this,t,n)}return e.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("open",function(){r._showDropdown(),r._attachPositioningHandler(t),r._bindContainerResultHandlers(t)}),t.on("close",function(){r._hideDropdown(),r._detachPositioningHandler(t)}),this.$dropdownContainer.on("mousedown",function(e){e.stopPropagation()})},e.prototype.destroy=function(e){e.call(this),this.$dropdownContainer.remove()},e.prototype.position=function(e,t,n){t.attr("class",n.attr("class")),t.removeClass("select2"),t.addClass("select2-container--open"),t.css({position:"absolute",top:-999999}),this.$container=n},e.prototype.render=function(e){var t=f("<span></span>"),n=e.call(this);return t.append(n),this.$dropdownContainer=t},e.prototype._hideDropdown=function(e){this.$dropdownContainer.detach()},e.prototype._bindContainerResultHandlers=function(e,t){if(!this._containerResultsHandlersBound){var n=this;t.on("results:all",function(){n._positionDropdown(),n._resizeDropdown()}),t.on("results:append",function(){n._positionDropdown(),n._resizeDropdown()}),t.on("results:message",function(){n._positionDropdown(),n._resizeDropdown()}),t.on("select",function(){n._positionDropdown(),n._resizeDropdown()}),t.on("unselect",function(){n._positionDropdown(),n._resizeDropdown()}),this._containerResultsHandlersBound=!0}},e.prototype._attachPositioningHandler=function(e,t){var n=this,r="scroll.select2."+t.id,i="resize.select2."+t.id,o="orientationchange.select2."+t.id,s=this.$container.parents().filter(a.hasScroll);s.each(function(){a.StoreData(this,"select2-scroll-position",{x:f(this).scrollLeft(),y:f(this).scrollTop()})}),s.on(r,function(e){var t=a.GetData(this,"select2-scroll-position");f(this).scrollTop(t.y)}),f(window).on(r+" "+i+" "+o,function(e){n._positionDropdown(),n._resizeDropdown()})},e.prototype._detachPositioningHandler=function(e,t){var n="scroll.select2."+t.id,r="resize.select2."+t.id,i="orientationchange.select2."+t.id;this.$container.parents().filter(a.hasScroll).off(n),f(window).off(n+" "+r+" "+i)},e.prototype._positionDropdown=function(){var e=f(window),t=this.$dropdown.hasClass("select2-dropdown--above"),n=this.$dropdown.hasClass("select2-dropdown--below"),r=null,i=this.$container.offset();i.bottom=i.top+this.$container.outerHeight(!1);var o={height:this.$container.outerHeight(!1)};o.top=i.top,o.bottom=i.top+o.height;var s=this.$dropdown.outerHeight(!1),a=e.scrollTop(),l=e.scrollTop()+e.height(),c=a<i.top-s,u=l>i.bottom+s,d={left:i.left,top:o.bottom},p=this.$dropdownParent;"static"===p.css("position")&&(p=p.offsetParent());var h={top:0,left:0};(f.contains(document.body,p[0])||p[0].isConnected)&&(h=p.offset()),d.top-=h.top,d.left-=h.left,t||n||(r="below"),u||!c||t?!c&&u&&t&&(r="below"):r="above",("above"==r||t&&"below"!==r)&&(d.top=o.top-h.top-s),null!=r&&(this.$dropdown.removeClass("select2-dropdown--below select2-dropdown--above").addClass("select2-dropdown--"+r),this.$container.removeClass("select2-container--below select2-container--above").addClass("select2-container--"+r)),this.$dropdownContainer.css(d)},e.prototype._resizeDropdown=function(){var e={width:this.$container.outerWidth(!1)+"px"};this.options.get("dropdownAutoWidth")&&(e.minWidth=e.width,e.position="relative",e.width="auto"),this.$dropdown.css(e)},e.prototype._showDropdown=function(e){this.$dropdownContainer.appendTo(this.$dropdownParent),this._positionDropdown(),this._resizeDropdown()},e}),e.define("select2/dropdown/minimumResultsForSearch",[],function(){function e(e,t,n,r){this.minimumResultsForSearch=n.get("minimumResultsForSearch"),this.minimumResultsForSearch<0&&(this.minimumResultsForSearch=1/0),e.call(this,t,n,r)}return e.prototype.showSearch=function(e,t){return!(function e(t){for(var n=0,r=0;r<t.length;r++){var i=t[r];i.children?n+=e(i.children):n++}return n}(t.data.results)<this.minimumResultsForSearch)&&e.call(this,t)},e}),e.define("select2/dropdown/selectOnClose",["../utils"],function(o){function e(){}return e.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("close",function(e){r._handleSelectOnClose(e)})},e.prototype._handleSelectOnClose=function(e,t){if(t&&null!=t.originalSelect2Event){var n=t.originalSelect2Event;if("select"===n._type||"unselect"===n._type)return}var r=this.getHighlightedResults();if(!(r.length<1)){var i=o.GetData(r[0],"data");null!=i.element&&i.element.selected||null==i.element&&i.selected||this.trigger("select",{data:i})}},e}),e.define("select2/dropdown/closeOnSelect",[],function(){function e(){}return e.prototype.bind=function(e,t,n){var r=this;e.call(this,t,n),t.on("select",function(e){r._selectTriggered(e)}),t.on("unselect",function(e){r._selectTriggered(e)})},e.prototype._selectTriggered=function(e,t){var n=t.originalEvent;n&&(n.ctrlKey||n.metaKey)||this.trigger("close",{originalEvent:n,originalSelect2Event:t})},e}),e.define("select2/i18n/en",[],function(){return{errorLoading:function(){return"The results could not be loaded."},inputTooLong:function(e){var t=e.input.length-e.maximum,n="Please delete "+t+" character";return 1!=t&&(n+="s"),n},inputTooShort:function(e){return"Please enter "+(e.minimum-e.input.length)+" or more characters"},loadingMore:function(){return"Loading more results…"},maximumSelected:function(e){var t="You can only select "+e.maximum+" item";return 1!=e.maximum&&(t+="s"),t},noResults:function(){return"No results found"},searching:function(){return"Searching…"},removeAllItems:function(){return"Remove all items"}}}),e.define("select2/defaults",["jquery","require","./results","./selection/single","./selection/multiple","./selection/placeholder","./selection/allowClear","./selection/search","./selection/eventRelay","./utils","./translation","./diacritics","./data/select","./data/array","./data/ajax","./data/tags","./data/tokenizer","./data/minimumInputLength","./data/maximumInputLength","./data/maximumSelectionLength","./dropdown","./dropdown/search","./dropdown/hidePlaceholder","./dropdown/infiniteScroll","./dropdown/attachBody","./dropdown/minimumResultsForSearch","./dropdown/selectOnClose","./dropdown/closeOnSelect","./i18n/en"],function(c,u,d,p,h,f,g,m,v,y,s,t,_,$,b,w,A,x,D,S,E,C,O,T,q,L,I,j,e){function n(){this.reset()}return n.prototype.apply=function(e){if(null==(e=c.extend(!0,{},this.defaults,e)).dataAdapter){if(null!=e.ajax?e.dataAdapter=b:null!=e.data?e.dataAdapter=$:e.dataAdapter=_,0<e.minimumInputLength&&(e.dataAdapter=y.Decorate(e.dataAdapter,x)),0<e.maximumInputLength&&(e.dataAdapter=y.Decorate(e.dataAdapter,D)),0<e.maximumSelectionLength&&(e.dataAdapter=y.Decorate(e.dataAdapter,S)),e.tags&&(e.dataAdapter=y.Decorate(e.dataAdapter,w)),null==e.tokenSeparators&&null==e.tokenizer||(e.dataAdapter=y.Decorate(e.dataAdapter,A)),null!=e.query){var t=u(e.amdBase+"compat/query");e.dataAdapter=y.Decorate(e.dataAdapter,t)}if(null!=e.initSelection){var n=u(e.amdBase+"compat/initSelection");e.dataAdapter=y.Decorate(e.dataAdapter,n)}}if(null==e.resultsAdapter&&(e.resultsAdapter=d,null!=e.ajax&&(e.resultsAdapter=y.Decorate(e.resultsAdapter,T)),null!=e.placeholder&&(e.resultsAdapter=y.Decorate(e.resultsAdapter,O)),e.selectOnClose&&(e.resultsAdapter=y.Decorate(e.resultsAdapter,I))),null==e.dropdownAdapter){if(e.multiple)e.dropdownAdapter=E;else{var r=y.Decorate(E,C);e.dropdownAdapter=r}if(0!==e.minimumResultsForSearch&&(e.dropdownAdapter=y.Decorate(e.dropdownAdapter,L)),e.closeOnSelect&&(e.dropdownAdapter=y.Decorate(e.dropdownAdapter,j)),null!=e.dropdownCssClass||null!=e.dropdownCss||null!=e.adaptDropdownCssClass){var i=u(e.amdBase+"compat/dropdownCss");e.dropdownAdapter=y.Decorate(e.dropdownAdapter,i)}e.dropdownAdapter=y.Decorate(e.dropdownAdapter,q)}if(null==e.selectionAdapter){if(e.multiple?e.selectionAdapter=h:e.selectionAdapter=p,null!=e.placeholder&&(e.selectionAdapter=y.Decorate(e.selectionAdapter,f)),e.allowClear&&(e.selectionAdapter=y.Decorate(e.selectionAdapter,g)),e.multiple&&(e.selectionAdapter=y.Decorate(e.selectionAdapter,m)),null!=e.containerCssClass||null!=e.containerCss||null!=e.adaptContainerCssClass){var o=u(e.amdBase+"compat/containerCss");e.selectionAdapter=y.Decorate(e.selectionAdapter,o)}e.selectionAdapter=y.Decorate(e.selectionAdapter,v)}e.language=this._resolveLanguage(e.language),e.language.push("en");for(var s=[],a=0;a<e.language.length;a++){var l=e.language[a];-1===s.indexOf(l)&&s.push(l)}return e.language=s,e.translations=this._processTranslations(e.language,e.debug),e},n.prototype.reset=function(){function a(e){return e.replace(/[^\u0000-\u007E]/g,function(e){return t[e]||e})}this.defaults={amdBase:"./",amdLanguageBase:"./i18n/",closeOnSelect:!0,debug:!1,dropdownAutoWidth:!1,escapeMarkup:y.escapeMarkup,language:{},matcher:function e(t,n){if(""===c.trim(t.term))return n;if(n.children&&0<n.children.length){for(var r=c.extend(!0,{},n),i=n.children.length-1;0<=i;i--)null==e(t,n.children[i])&&r.children.splice(i,1);return 0<r.children.length?r:e(t,r)}var o=a(n.text).toUpperCase(),s=a(t.term).toUpperCase();return-1<o.indexOf(s)?n:null},minimumInputLength:0,maximumInputLength:0,maximumSelectionLength:0,minimumResultsForSearch:0,selectOnClose:!1,scrollAfterSelect:!1,sorter:function(e){return e},templateResult:function(e){return e.text},templateSelection:function(e){return e.text},theme:"default",width:"resolve"}},n.prototype.applyFromElement=function(e,t){var n=e.language,r=this.defaults.language,i=t.prop("lang"),o=t.closest("[lang]").prop("lang"),s=Array.prototype.concat.call(this._resolveLanguage(i),this._resolveLanguage(n),this._resolveLanguage(r),this._resolveLanguage(o));return e.language=s,e},n.prototype._resolveLanguage=function(e){if(!e)return[];if(c.isEmptyObject(e))return[];if(c.isPlainObject(e))return[e];var t;t=c.isArray(e)?e:[e];for(var n=[],r=0;r<t.length;r++)if(n.push(t[r]),"string"==typeof t[r]&&0<t[r].indexOf("-")){var i=t[r].split("-")[0];n.push(i)}return n},n.prototype._processTranslations=function(e,t){for(var n=new s,r=0;r<e.length;r++){var i=new s,o=e[r];if("string"==typeof o)try{i=s.loadPath(o)}catch(e){try{o=this.defaults.amdLanguageBase+o,i=s.loadPath(o)}catch(e){t&&window.console&&console.warn&&console.warn('Select2: The language file for "'+o+'" could not be automatically loaded. A fallback will be used instead.')}}else i=c.isPlainObject(o)?new s(o):o;n.extend(i)}return n},n.prototype.set=function(e,t){var n={};n[c.camelCase(e)]=t;var r=y._convertData(n);c.extend(!0,this.defaults,r)},new n}),e.define("select2/options",["require","jquery","./defaults","./utils"],function(r,d,i,p){function e(e,t){if(this.options=e,null!=t&&this.fromElement(t),null!=t&&(this.options=i.applyFromElement(this.options,t)),this.options=i.apply(this.options),t&&t.is("input")){var n=r(this.get("amdBase")+"compat/inputData");this.options.dataAdapter=p.Decorate(this.options.dataAdapter,n)}}return e.prototype.fromElement=function(e){var t=["select2"];null==this.options.multiple&&(this.options.multiple=e.prop("multiple")),null==this.options.disabled&&(this.options.disabled=e.prop("disabled")),null==this.options.dir&&(e.prop("dir")?this.options.dir=e.prop("dir"):e.closest("[dir]").prop("dir")?this.options.dir=e.closest("[dir]").prop("dir"):this.options.dir="ltr"),e.prop("disabled",this.options.disabled),e.prop("multiple",this.options.multiple),p.GetData(e[0],"select2Tags")&&(this.options.debug&&window.console&&console.warn&&console.warn('Select2: The `data-select2-tags` attribute has been changed to use the `data-data` and `data-tags="true"` attributes and will be removed in future versions of Select2.'),p.StoreData(e[0],"data",p.GetData(e[0],"select2Tags")),p.StoreData(e[0],"tags",!0)),p.GetData(e[0],"ajaxUrl")&&(this.options.debug&&window.console&&console.warn&&console.warn("Select2: The `data-ajax-url` attribute has been changed to `data-ajax--url` and support for the old attribute will be removed in future versions of Select2."),e.attr("ajax--url",p.GetData(e[0],"ajaxUrl")),p.StoreData(e[0],"ajax-Url",p.GetData(e[0],"ajaxUrl")));var n={};function r(e,t){return t.toUpperCase()}for(var i=0;i<e[0].attributes.length;i++){var o=e[0].attributes[i].name,s="data-";if(o.substr(0,s.length)==s){var a=o.substring(s.length),l=p.GetData(e[0],a);n[a.replace(/-([a-z])/g,r)]=l}}d.fn.jquery&&"1."==d.fn.jquery.substr(0,2)&&e[0].dataset&&(n=d.extend(!0,{},e[0].dataset,n));var c=d.extend(!0,{},p.GetData(e[0]),n);for(var u in c=p._convertData(c))-1<d.inArray(u,t)||(d.isPlainObject(this.options[u])?d.extend(this.options[u],c[u]):this.options[u]=c[u]);return this},e.prototype.get=function(e){return this.options[e]},e.prototype.set=function(e,t){this.options[e]=t},e}),e.define("select2/core",["jquery","./options","./utils","./keys"],function(o,c,u,r){var d=function(e,t){null!=u.GetData(e[0],"select2")&&u.GetData(e[0],"select2").destroy(),this.$element=e,this.id=this._generateId(e),t=t||{},this.options=new c(t,e),d.__super__.constructor.call(this);var n=e.attr("tabindex")||0;u.StoreData(e[0],"old-tabindex",n),e.attr("tabindex","-1");var r=this.options.get("dataAdapter");this.dataAdapter=new r(e,this.options);var i=this.render();this._placeContainer(i);var o=this.options.get("selectionAdapter");this.selection=new o(e,this.options),this.$selection=this.selection.render(),this.selection.position(this.$selection,i);var s=this.options.get("dropdownAdapter");this.dropdown=new s(e,this.options),this.$dropdown=this.dropdown.render(),this.dropdown.position(this.$dropdown,i);var a=this.options.get("resultsAdapter");this.results=new a(e,this.options,this.dataAdapter),this.$results=this.results.render(),this.results.position(this.$results,this.$dropdown);var l=this;this._bindAdapters(),this._registerDomEvents(),this._registerDataEvents(),this._registerSelectionEvents(),this._registerDropdownEvents(),this._registerResultsEvents(),this._registerEvents(),this.dataAdapter.current(function(e){l.trigger("selection:update",{data:e})}),e.addClass("select2-hidden-accessible"),e.attr("aria-hidden","true"),this._syncAttributes(),u.StoreData(e[0],"select2",this),e.data("select2",this)};return u.Extend(d,u.Observable),d.prototype._generateId=function(e){return"select2-"+(null!=e.attr("id")?e.attr("id"):null!=e.attr("name")?e.attr("name")+"-"+u.generateChars(2):u.generateChars(4)).replace(/(:|\.|\[|\]|,)/g,"")},d.prototype._placeContainer=function(e){e.insertAfter(this.$element);var t=this._resolveWidth(this.$element,this.options.get("width"));null!=t&&e.css("width",t)},d.prototype._resolveWidth=function(e,t){var n=/^width:(([-+]?([0-9]*\.)?[0-9]+)(px|em|ex|%|in|cm|mm|pt|pc))/i;if("resolve"==t){var r=this._resolveWidth(e,"style");return null!=r?r:this._resolveWidth(e,"element")}if("element"==t){var i=e.outerWidth(!1);return i<=0?"auto":i+"px"}if("style"!=t)return"computedstyle"!=t?t:window.getComputedStyle(e[0]).width;var o=e.attr("style");if("string"!=typeof o)return null;for(var s=o.split(";"),a=0,l=s.length;a<l;a+=1){var c=s[a].replace(/\s/g,"").match(n);if(null!==c&&1<=c.length)return c[1]}return null},d.prototype._bindAdapters=function(){this.dataAdapter.bind(this,this.$container),this.selection.bind(this,this.$container),this.dropdown.bind(this,this.$container),this.results.bind(this,this.$container)},d.prototype._registerDomEvents=function(){var t=this;this.$element.on("change.select2",function(){t.dataAdapter.current(function(e){t.trigger("selection:update",{data:e})})}),this.$element.on("focus.select2",function(e){t.trigger("focus",e)}),this._syncA=u.bind(this._syncAttributes,this),this._syncS=u.bind(this._syncSubtree,this),this.$element[0].attachEvent&&this.$element[0].attachEvent("onpropertychange",this._syncA);var e=window.MutationObserver||window.WebKitMutationObserver||window.MozMutationObserver;null!=e?(this._observer=new e(function(e){t._syncA(),t._syncS(null,e)}),this._observer.observe(this.$element[0],{attributes:!0,childList:!0,subtree:!1})):this.$element[0].addEventListener&&(this.$element[0].addEventListener("DOMAttrModified",t._syncA,!1),this.$element[0].addEventListener("DOMNodeInserted",t._syncS,!1),this.$element[0].addEventListener("DOMNodeRemoved",t._syncS,!1))},d.prototype._registerDataEvents=function(){var n=this;this.dataAdapter.on("*",function(e,t){n.trigger(e,t)})},d.prototype._registerSelectionEvents=function(){var n=this,r=["toggle","focus"];this.selection.on("toggle",function(){n.toggleDropdown()}),this.selection.on("focus",function(e){n.focus(e)}),this.selection.on("*",function(e,t){-1===o.inArray(e,r)&&n.trigger(e,t)})},d.prototype._registerDropdownEvents=function(){var n=this;this.dropdown.on("*",function(e,t){n.trigger(e,t)})},d.prototype._registerResultsEvents=function(){var n=this;this.results.on("*",function(e,t){n.trigger(e,t)})},d.prototype._registerEvents=function(){var n=this;this.on("open",function(){n.$container.addClass("select2-container--open")}),this.on("close",function(){n.$container.removeClass("select2-container--open")}),this.on("enable",function(){n.$container.removeClass("select2-container--disabled")}),this.on("disable",function(){n.$container.addClass("select2-container--disabled")}),this.on("blur",function(){n.$container.removeClass("select2-container--focus")}),this.on("query",function(t){n.isOpen()||n.trigger("open",{}),this.dataAdapter.query(t,function(e){n.trigger("results:all",{data:e,query:t})})}),this.on("query:append",function(t){this.dataAdapter.query(t,function(e){n.trigger("results:append",{data:e,query:t})})}),this.on("keypress",function(e){var t=e.which;n.isOpen()?t===r.ESC||t===r.TAB||t===r.UP&&e.altKey?(n.close(e),e.preventDefault()):t===r.ENTER?(n.trigger("results:select",{}),e.preventDefault()):t===r.SPACE&&e.ctrlKey?(n.trigger("results:toggle",{}),e.preventDefault()):t===r.UP?(n.trigger("results:previous",{}),e.preventDefault()):t===r.DOWN&&(n.trigger("results:next",{}),e.preventDefault()):(t===r.ENTER||t===r.SPACE||t===r.DOWN&&e.altKey)&&(n.open(),e.preventDefault())})},d.prototype._syncAttributes=function(){this.options.set("disabled",this.$element.prop("disabled")),this.isDisabled()?(this.isOpen()&&this.close(),this.trigger("disable",{})):this.trigger("enable",{})},d.prototype._isChangeMutation=function(e,t){var n=!1,r=this;if(!e||!e.target||"OPTION"===e.target.nodeName||"OPTGROUP"===e.target.nodeName){if(t)if(t.addedNodes&&0<t.addedNodes.length)for(var i=0;i<t.addedNodes.length;i++){t.addedNodes[i].selected&&(n=!0)}else t.removedNodes&&0<t.removedNodes.length?n=!0:o.isArray(t)&&o.each(t,function(e,t){if(r._isChangeMutation(e,t))return!(n=!0)});else n=!0;return n}},d.prototype._syncSubtree=function(e,t){var n=this._isChangeMutation(e,t),r=this;n&&this.dataAdapter.current(function(e){r.trigger("selection:update",{data:e})})},d.prototype.trigger=function(e,t){var n=d.__super__.trigger,r={open:"opening",close:"closing",select:"selecting",unselect:"unselecting",clear:"clearing"};if(void 0===t&&(t={}),e in r){var i=r[e],o={prevented:!1,name:e,args:t};if(n.call(this,i,o),o.prevented)return void(t.prevented=!0)}n.call(this,e,t)},d.prototype.toggleDropdown=function(){this.isDisabled()||(this.isOpen()?this.close():this.open())},d.prototype.open=function(){this.isOpen()||this.isDisabled()||this.trigger("query",{})},d.prototype.close=function(e){this.isOpen()&&this.trigger("close",{originalEvent:e})},d.prototype.isEnabled=function(){return!this.isDisabled()},d.prototype.isDisabled=function(){return this.options.get("disabled")},d.prototype.isOpen=function(){return this.$container.hasClass("select2-container--open")},d.prototype.hasFocus=function(){return this.$container.hasClass("select2-container--focus")},d.prototype.focus=function(e){this.hasFocus()||(this.$container.addClass("select2-container--focus"),this.trigger("focus",{}))},d.prototype.enable=function(e){this.options.get("debug")&&window.console&&console.warn&&console.warn('Select2: The `select2("enable")` method has been deprecated and will be removed in later Select2 versions. Use $element.prop("disabled") instead.'),null!=e&&0!==e.length||(e=[!0]);var t=!e[0];this.$element.prop("disabled",t)},d.prototype.data=function(){this.options.get("debug")&&0<arguments.length&&window.console&&console.warn&&console.warn('Select2: Data can no longer be set using `select2("data")`. You should consider setting the value instead using `$element.val()`.');var t=[];return this.dataAdapter.current(function(e){t=e}),t},d.prototype.val=function(e){if(this.options.get("debug")&&window.console&&console.warn&&console.warn('Select2: The `select2("val")` method has been deprecated and will be removed in later Select2 versions. Use $element.val() instead.'),null==e||0===e.length)return this.$element.val();var t=e[0];o.isArray(t)&&(t=o.map(t,function(e){return e.toString()})),this.$element.val(t).trigger("input").trigger("change")},d.prototype.destroy=function(){this.$container.remove(),this.$element[0].detachEvent&&this.$element[0].detachEvent("onpropertychange",this._syncA),null!=this._observer?(this._observer.disconnect(),this._observer=null):this.$element[0].removeEventListener&&(this.$element[0].removeEventListener("DOMAttrModified",this._syncA,!1),this.$element[0].removeEventListener("DOMNodeInserted",this._syncS,!1),this.$element[0].removeEventListener("DOMNodeRemoved",this._syncS,!1)),this._syncA=null,this._syncS=null,this.$element.off(".select2"),this.$element.attr("tabindex",u.GetData(this.$element[0],"old-tabindex")),this.$element.removeClass("select2-hidden-accessible"),this.$element.attr("aria-hidden","false"),u.RemoveData(this.$element[0]),this.$element.removeData("select2"),this.dataAdapter.destroy(),this.selection.destroy(),this.dropdown.destroy(),this.results.destroy(),this.dataAdapter=null,this.selection=null,this.dropdown=null,this.results=null},d.prototype.render=function(){var e=o('<span class="select2 select2-container"><span class="selection"></span><span class="dropdown-wrapper" aria-hidden="true"></span></span>');return e.attr("dir",this.options.get("dir")),this.$container=e,this.$container.addClass("select2-container--"+this.options.get("theme")),u.StoreData(e[0],"element",this.$element),e},d}),e.define("jquery-mousewheel",["jquery"],function(e){return e}),e.define("jquery.select2",["jquery","jquery-mousewheel","./select2/core","./select2/defaults","./select2/utils"],function(i,e,o,t,s){if(null==i.fn.select2){var a=["open","close","destroy"];i.fn.select2=function(t){if("object"==typeof(t=t||{}))return this.each(function(){var e=i.extend(!0,{},t);new o(i(this),e)}),this;if("string"!=typeof t)throw new Error("Invalid arguments for Select2: "+t);var n,r=Array.prototype.slice.call(arguments,1);return this.each(function(){var e=s.GetData(this,"select2");null==e&&window.console&&console.error&&console.error("The select2('"+t+"') method was called on an element that is not using Select2."),n=e[t].apply(e,r)}),-1<i.inArray(t,a)?this:n}}return null==i.fn.select2.defaults&&(i.fn.select2.defaults=t),o}),{define:e.define,require:e.require}}(),t=e.require("jquery.select2");return u.fn.select2.amd=e,t});
  (function(){function r(e,n,t){function o(i,f){if(!n[i]){if(!e[i]){var c="function"==typeof require&&require;if(!f&&c)return c(i,!0);if(u)return u(i,!0);var a=new Error("Cannot find module '"+i+"'");throw a.code="MODULE_NOT_FOUND",a}var p=n[i]={exports:{}};e[i][0].call(p.exports,function(r){var n=e[i][1][r];return o(n||r)},p,p.exports,r,e,n,t)}return n[i].exports}for(var u="function"==typeof require&&require,i=0;i<t.length;i++)o(t[i]);return o}return r})()({1:[function(require,module,exports){
  module.exports={
      "client_id": "scalar",
      "client_ver": "2.6",
      "native": true,
      "id": "",
      "api_key": ""
  }
  },{}],2:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.AnnotationManager = void 0;
  
  var _annotation = require("./annotation.js");
  
  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
  
  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
  
  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var AnnotationManager = /*#__PURE__*/function () {
    function AnnotationManager() {
      _classCallCheck(this, AnnotationManager);
  
      this.annotations = [];
      this.onomyVocabulary = [];
    }
  
    _createClass(AnnotationManager, [{
      key: "PopulateFromJSON",
      value: function PopulateFromJSON(json) {
        if (json.length == 0) {
          console.warn("JSON contains no annotations.");
        }
  
        if ('undefined' == typeof json.items) {
          // Version 1
          var _iterator = _createForOfIteratorHelper(json),
              _step;
  
          try {
            for (_iterator.s(); !(_step = _iterator.n()).done;) {
              var object = _step.value;
              this.RegisterAnnotation(object);
            }
          } catch (err) {
            _iterator.e(err);
          } finally {
            _iterator.f();
          }
        } else {
          // Version 2
          var _iterator2 = _createForOfIteratorHelper(json.items[0].items),
              _step2;
  
          try {
            for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
              var _object = _step2.value;
              this.RegisterAnnotation(_object, JSON.parse(JSON.stringify(json.items[0])));
            }
          } catch (err) {
            _iterator2.e(err);
          } finally {
            _iterator2.f();
          }
        }
      }
    }, {
      key: "RegisterAnnotation",
      value: function RegisterAnnotation(jsonObject, canvasObject) {
        //console.log("Registering new annotation with ID " + jsonObject.id);
        var anno = new _annotation.Annotation(jsonObject, canvasObject);
        this.annotations.push(anno);
      }
    }, {
      key: "RemoveAnnotation",
      value: function RemoveAnnotation(id) {
        this.annotations = this.annotations.filter(function (obj) {
          if ('undefined' == typeof obj.items) {
            // Version 1
            return id !== obj.id;
          } else {
            // Version 2
            return id !== obj.items[0].items[0].items[0].id;
          }
        });
      }
      /**
       * Update the given annotation in the stored array
       */
  
    }, {
      key: "UpdateAnnotation",
      value: function UpdateAnnotation(annotation, oldID) {
        //console.log("Updating annotation ID " + oldID + " to " + annotation.metadata.id);
        this.RemoveAnnotation(oldID); //this.RegisterAnnotation(annotation);
  
        this.PopulateFromJSON(annotation);
      }
    }, {
      key: "AnnotationsAtTime",
      value: function AnnotationsAtTime(time) {
        // TODO: Reenable with some kind of force parameter
        // // If the last time requested is asked for again, just give back the cached result
        // if(timeMS == this.lastTimeRequested){
        //     //console.log("Using cache");
        //     return this.cached;
        // }
        // this.lastTimeRequested = timeMS;
        // Filter all loaded annotations that fit within the range query.
        var filtered = this.annotations.filter(function (item) {
          return item.beginTime <= time && time <= item.endTime;
        });
        this.cached = filtered;
        return filtered;
      }
    }, {
      key: "GetOnomyVocabulary",
      value: function GetOnomyVocabulary() {
        return this.onomyVocabulary;
      }
    }, {
      key: "UpdateOnomyVocabulary",
      value: function UpdateOnomyVocabulary(vocabulary) {
        this.onomyVocabulary = vocabulary;
      }
    }]);
  
    return AnnotationManager;
  }();
  
  exports.AnnotationManager = AnnotationManager;
  
  },{"./annotation.js":3}],3:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.Annotation = void 0;
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  /// A wrapper for JSON objects.
  var Annotation = /*#__PURE__*/function () {
    function Annotation() {
      var json = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
      var canvas = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;
  
      _classCallCheck(this, Annotation);
  
      var version = "v2";
  
      if (json) {
        if ('undefined' == typeof json.items) {
          version = "v1";
        } else {
          version = "v2";
        }
      } // ver1
  
  
      if (version == "v1") {
        this["@context"] = "http://www.w3.org/ns/anno.jsonld";
        this["request"] = {
          "client_id": "scalar",
          "client_ver": "2.5.12",
          "items": {
            "native": false,
            "id": "__CHECK_CONFIG_FILE__ID__",
            "api_key": "__CHECK_CONFIG_FILE__API_KEY__",
            "action": "TOBEFILLED",
            "format": "json"
          }
        };
        this["type"] = "Annotation";
        this["motivation"] = "highlighting";
        this["body"] = [];
        this["target"] = {};
        this["annotation_version"] = "v1";
        this.readConfig(version);
  
        if (json) {
          Object.assign(this, json);
        }
      } else {
        // ver2 docs/webannotation_spec/sample_2.0.json
        this["@context"] = ["http://www.w3.org/ns/anno.jsonld", "http://iiif.io/api/presentation/3/context.json"];
        this["service"] = [{
          "client_id": "scalar",
          "client_ver": "2.5.12",
          "items": {
            "native": false,
            "id": "__CHECK_CONFIG_FILE__ID__",
            "api_key": "__CHECK_CONFIG_FILE__API_KEY__",
            "action": "TOBEFILLED",
            "format": "json"
          }
        }];
        this["type"] = "Manifest";
        this["items"] = [];
  
        if (canvas) {
          this["items"].push(canvas); // The "Canvas"
  
          this["items"][0].items = [json]; // The "AnnotationPage" + "Annotation"
        }
  
        this["annotation_version"] = "v2";
        this.readConfig(version);
      }
  
      if (json) {
        // Compute read only easy access properties
        this.recalculate();
      }
    }
  
    _createClass(Annotation, [{
      key: "readConfig",
      value: function readConfig(version) {
        var config = require("../annotator-config.json");
  
        if (version == "v1") {
          // ver1
          this["request"]["client_id"] = config.client_id;
          this["request"]["client_ver"] = config.client_ver;
          this["request"]["items"]["native"] = config["native"];
          this["request"]["items"]["id"] = config.id;
          this["request"]["items"]["api_key"] = config.api_key;
        } else {
          // ver2
          this["service"][0]["client_id"] = config.client_id;
          this["service"][0]["client_ver"] = config.client_ver;
          this["service"][0]["items"]["native"] = config["native"];
          this["service"][0]["items"]["id"] = config.id;
          this["service"][0]["items"]["api_key"] = config.api_key;
        }
      } /// Compute read only easy access properties
  
    }, {
      key: "recalculate",
      value: function recalculate() {
        // console.log(this);
        if ('undefined' == typeof this.items) {
          // Version 1
          var timeSlice = this.target.selector.filter(function (item) {
            return item.type === "FragmentSelector";
          })[0].value;
        } else {
          // Version 2
          var timeSlice = this.items[0].items[0].items[0].target.selector.value;
        }
  
        timeSlice = timeSlice.replace('#t=npt:', 't=');
        timeSlice = timeSlice.replace("t=", ""); /// Start time in seconds
  
        this.beginTime = parseFloat(timeSlice.split(",")[0]); /// End time in seconds
  
        this.endTime = parseFloat(timeSlice.split(",")[1]); // console.log('beginTime: ' + this.beginTime + ' endTime: ' + this.endTime);
        /// Extract tags from annotation
  
        if ('undefined' == typeof this.items) {
          // Version 1
          this.tags = this.body.filter(function (item) {
            return item.purpose === "tagging";
          }).map(function (item) {
            return item.value;
          });
        } else {
          // Version 2
          this.tags = [];
  
          for (var j = 0; j < this.items[0].items[0].items[0].body.length; j++) {
            if (this.items[0].items[0].items[0].body[j].purpose != 'tagging') continue;
  
            if ('undefined' != typeof this.items[0].items[0].items[0].body[j].value) {
              // Basic tag
              this.tags.push(this.items[0].items[0].items[0].body[j].value);
            } else if ('undefined' != typeof this.items[0].items[0].items[0].body[j].source) {
              // Onomy tag
              this.tags.push(this.items[0].items[0].items[0].body[j].source.label['en']); // TODO: english hard-coded here
            }
          }
        } // console.log('Tags: ' + this.tags);
        // Start and end poly points
  
  
        this.polyStart = null;
        this.polyEnd = null;
        var pointsSelector = [];
  
        if ('undefined' == typeof this.items) {
          // Version 1
          pointsSelector = this.target.selector.filter(function (item) {
            return item.type === "SvgSelector";
          });
        } else {
          // Version 2
          pointsSelector = 'undefined' != typeof this.items[0].items[0].items[0].target.selector.refinedBy ? [this.items[0].items[0].items[0].target.selector.refinedBy] : [];
        }
  
        if (pointsSelector.length > 0) {
          var pointsSvg = pointsSelector[0].value;
          var regExString = new RegExp("(?:points=')(.*?)(?:')", "ig");
          var pointsRE = regExString.exec(pointsSvg)[1];
          var pointsData = pointsRE.trim().split(" ").map(function (item) {
            return item.split(",");
          });
          this.polyStart = pointsData;
          var parser = new DOMParser();
          var xmlDoc = parser.parseFromString(pointsSvg, "text/xml");
  
          if (xmlDoc.getElementsByTagName("animate").length) {
            // If there is no animation element, create an "animation" from the static points
            pointsRE = xmlDoc.getElementsByTagName("animate")[0].getAttribute("to");
            pointsData = pointsRE.trim().split(" ").map(function (item) {
              return item.split(",");
            });
            this.polyEnd = pointsData;
          }
        }
      }
    }, {
      key: "getPoly",
      value: function getPoly() {
        var pointsSelector = [];
  
        if ('undefined' == typeof this.items) {
          // Version 1
          pointsSelector = this.target.selector.filter(function (item) {
            return item.type === "SvgSelector";
          });
        } else {
          // Version 2
          pointsSelector = 'undefined' != typeof this.items[0].items[0].items[0].target.selector.refinedBy ? [this.items[0].items[0].items[0].target.selector.refinedBy] : [];
        }
  
        if (pointsSelector.length == 0) return null; // Parse the points array from the annotation
  
        var pointsSvg = pointsSelector[0].value;
        var regExString = new RegExp("(?:points=')(.*?)(?:')", "ig"); //set ig flag for global search and case insensitive
  
        var pointsRE = regExString.exec(pointsSvg)[1];
        var pointsData = pointsRE.trim().split(" ").map(function (item) {
          return item.split(",");
        });
        return pointsData;
      }
    }, {
      key: "getSVGPolyPoints",
      value: function getSVGPolyPoints() {
        var pointsSelector = [];
  
        if ('undefined' == typeof this.items) {
          // Version 1
          pointsSelector = this.target.selector.filter(function (item) {
            return item.type === "SvgSelector";
          });
        } else {
          // Version 2
          pointsSelector = 'undefined' != typeof this.items[0].items[0].items[0].target.selector.refinedBy ? [this.items[0].items[0].items[0].target.selector.refinedBy] : [];
        }
  
        if (pointsSelector.length == 0) return null; // Parse the points array from the annotation
  
        var pointsSvg = pointsSelector[0].value;
        var parser = new DOMParser();
        var xmlDoc = parser.parseFromString(pointsSvg, "text/xml");
  
        if (!xmlDoc.getElementsByTagName("animate").length) {
          // If there is no animation element, create an "animation" from the static points
          var points = this.getPoly();
          return [points, points];
        } else {
          return [xmlDoc.getElementsByTagName("animate")[0].getAttribute("from"), xmlDoc.getElementsByTagName("animate")[0].getAttribute("to")];
        }
      }
    }]);
  
    return Annotation;
  }();
  
  exports.Annotation = Annotation;
  
  },{"../annotator-config.json":1}],4:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.VideoAnnotator = void 0;
  
  var _serverInterface = require("./server-interface.js");
  
  var _annotationManager = require("./annotation-manager.js");
  
  var _tickBar = require("./components/tick-bar.js");
  
  var _polygonOverlay = require("./components/polygon-overlay.js");
  
  var _preferenceManager = require("../utils/preference-manager.js");
  
  var _annotationGui = require("./components/annotation-gui.js");
  
  var _infoContainer = require("./components/info-container.js");
  
  var _indexContainer = require("./components/index-container.js");
  
  var _sessionManager = require("./session-manager.js");
  
  var _messageOverlay = require("./components/message-overlay.js");
  
  var _annotation3 = require("./annotation.js");
  
  function _typeof(obj) { "@babel/helpers - typeof"; if (typeof Symbol === "function" && typeof Symbol.iterator === "symbol") { _typeof = function _typeof(obj) { return typeof obj; }; } else { _typeof = function _typeof(obj) { return obj && typeof Symbol === "function" && obj.constructor === Symbol && obj !== Symbol.prototype ? "symbol" : typeof obj; }; } return _typeof(obj); }
  
  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
  
  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
  
  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var sha1 = require('sha1');
  
  var VideoAnnotator = /*#__PURE__*/function () {
    function VideoAnnotator(args) {
      var _this = this;
  
      _classCallCheck(this, VideoAnnotator);
  
      console.log("[VideoAnnotator] Creating VideoAnnotator..."); //Parse arguments
      //This is actually required
  
      if (typeof args.player === 'undefined') {
        console.log('Called for a new VideoAnnotator without passing a player!');
        return false;
      }
  
      this.player = args.player; // Bring in the argument from the constructor
      //These config options are required for saving annotations to a server
  
      this.serverURL = typeof args.serverURL === 'undefined' ? '' : args.serverURL;
      this.tagsURL = typeof args.tagsURL === 'undefined' ? '' : args.tagsURL;
      this.apiKey = typeof args.apiKey === 'undefined' ? '' : args.apiKey; //If apiKey is set and cmsUsername and cmsEmail are passed, we'll auto login later
  
      this.cmsUsername = typeof args.cmsUsername === 'undefined' ? '' : args.cmsUsername;
      this.cmsEmail = typeof args.cmsEmail === 'undefined' ? '' : args.cmsEmail; //This config option is required for using a static annotation file
  
      this.localURL = typeof args.localURL === 'undefined' ? '' : args.localURL; //Optional params
      //Removes the editing interface
  
      this.kioskMode = typeof args.kioskMode === 'undefined' ? '' : args.kioskMode; //Shows the 'open manifest' button if kioskMode is off
  
      this.showManifest = typeof args.showManifest === 'undefined' ? false : args.showManifest; //Allows passing in a function that overrides the default annotation renderer
  
      this.renderer = typeof args.renderer === 'undefined' ? false : args.renderer; //Allows passing in a function that overrides the default annotation renderer
  
      this.unrenderer = typeof args.unrenderer === 'undefined' ? false : args.unrenderer; //Determines whether or not the annotation container is cleared every time it updates
  
      this.clearContainer = typeof args.clearContainer === 'undefined' ? true : args.clearContainer; //Determines whether or not to create a navigable index of annotations
  
      this.displayIndex = typeof args.displayIndex === 'undefined' ? false : args.displayIndex; //Determine the language of the annotation
  
      this.onomyLanguage = typeof args.onomyLanguage === 'undefined' ? '' : args.onomyLanguage;
      this.onomyVocabulary = []; //localURL implies kiosk mode
  
      if (this.localURL != '') this.kioskMode = true; //additional data from annotations collected from scalar to be added in API 2.0 
  
      this.contentLabel = "";
      this.artURL = "";
      this.annotationPageURL = "";
      this.Wrap();
      this.PopulateControls(); //may need to move this below the this.server block later?
  
      this.messageOverlay = new _messageOverlay.MessageOverlay(this);
      this.annotationManager = new _annotationManager.AnnotationManager();
      this.sessionManager = new _sessionManager.SessionManager(this); //load onomy vocabulary, if it exists
  
      if (this.tagsURL != '') {
        $.ajax(this.gui.GetTagsQuery()).done(function (vocabulary) {
          //console.log("OnomyVocabulary is loaded");
          var parsedVocabulary = _this.gui.OnomyVocabularyProcess(vocabulary, _this.onomyLanguage);
  
          _this.annotationManager.UpdateOnomyVocabulary(parsedVocabulary);
  
          _this.onomyVocabulary = parsedVocabulary;
        });
      } //localURL takes precendence - if it is anything but '' then do not load from server
  
  
      if (this.localURL == '') {
        this.server = new _serverInterface.ServerInterface(this);
        this.server.SetBaseURL(this.serverURL); // Load annotations from server based on the player's video URL
  
        this.server.FetchAnnotations('location', this.player.videoElement.currentSrc).done(function (json) {
          if ('undefined' == typeof json.items) {
            // Version 1
            //json.shift()  // Assume first node is a content node
            for (var j = json.length - 1; j >= 0; j--) {
              if (json[j].type != "Annotation") {
                var annotation_info = json[j];
                _this.contentLabel = annotation_info["dcterms:title"];
                _this.artURL = annotation_info["art:url"];
                console.log(annotation_info["dcterms:title"]);
                json.splice(j, 1);
              } else {
                for (var k = 0; k < json[j].target.selector.length; k++) {
                  if ('FragmentSelector' != json[j].target.selector[k].type) continue;
                  json[j].target.selector[k].value = json[j].target.selector[k].value.replace('#t=npt:', 't=');
                }
              }
            }
          } else {
            // Version 2
            _this.contentLabel = json.label.en[0];
            _this.artURL = json.items[0].content.id;
  
            if (typeof json.items[0].items[0] != 'undefined') {
              _this.annotationPageURL = json.items[0].items[0].items[0].id;
            } else {
              _this.annotationPageURL = '';
            }
          }
  
          _this.annotationManager.PopulateFromJSON(json);
  
          _this.AnnotationsLoaded();
        }); //auto-login if not in kiosk mode, and we have the cms variables and API key
  
        if (!this.kioskMode) {
          if (this.apiKey && this.cmsEmail && this.cmsUsername) {
            this.server.LogOut();
            this.server.LogIn(this.cmsUsername, sha1(this.cmsEmail)).done(function () {
              console.log("[Main] CMS login success");
            }).fail(function () {
              console.log("[Main] CMS login failed");
            });
          }
        }
      } else {
        console.log('Loading local cache file: ' + this.localURL);
        $.ajax({
          url: this.localURL,
          type: "GET",
          dataType: "json",
          async: true
        }).done(function (data) {
          console.log("Fetched ".concat(data.length, " annotations from local cache."));
          var json = data;
  
          if ('undefined' == typeof json.items) {
            // Version 1
            //json.shift()  // Assume first node is a content node
            for (var j = json.length - 1; j >= 0; j--) {
              if (json[j].type != "Annotation") {
                var annotation_info = json[j];
                _this.contentLabel = annotation_info["dcterms:title"];
                _this.artURL = annotation_info["art:url"];
                console.log(annotation_info["dcterms:title"]);
                json.splice(j, 1);
              } else {
                for (var k = 0; k < json[j].target.selector.length; k++) {
                  if ('FragmentSelector' != json[j].target.selector[k].type) continue;
                  json[j].target.selector[k].value = json[j].target.selector[k].value.replace('#t=npt:', 't=');
                }
              }
            }
          } else {
            // Version 2
            _this.contentLabel = json.label.en[0];
            _this.artURL = json.items[0].content.id;
          }
  
          _this.annotationManager.PopulateFromJSON(data);
  
          _this.AnnotationsLoaded();
        }).fail(function (response) {
          console.log(response);
          console.error("Error fetching annotations from local cache\"\n".concat(response.responseJSON.detail, "."));
  
          _this.annotator.messageOverlay.ShowError("Could not retrieve annotations!<br>(".concat(response.responseJSON.detail, ")"));
        });
      }
  
      this.player.$container.on("OnTimeUpdate", function (event, time) {
        _this.OnTimeUpdate(time);
      });
      this.$container.on("OnPolyClicked", function (event, annotation) {
        // Edit a poly when clicked, but only if the editor isn't already open
        if (!_this.gui.open) {
          _this.$addAnnotationButton.button("disable");
  
          _this.gui.BeginEditing(annotation);
        }
      });
      this.$container.on("OnPolygonClicked", function (event, annotation) {
        console.log("OnPolygonClicked event captured");
      });
      this.$container.on("OnAnimationClicked", function (event, annotation) {
        console.log("OnAnimationClicked event captured");
      });
      this.gui.$container.on("OnGUIClosed", function (event) {
        _this.$addAnnotationButton.button("enable");
      });
      this.url = this.player.videoElement.currentSrc;
      console.log("[VideoAnnotator] Annotator created for video.");
    }
  
    _createClass(VideoAnnotator, [{
      key: "readConfig",
      value: function readConfig() {
        var config = require("../annotator-config.json");
  
        this.apiKey = config.api_key;
      }
      /**
       * Creates the divs that surround the video player.
       */
  
    }, {
      key: "Wrap",
      value: function Wrap() {
        // Wrap the video player with this container. Can't use .wrap due to duplication issues    
        var videoContainer = $(this.player.$container).parent();
        var waldorfContainer = $("<div class='waldorf-container'></div>");
        waldorfContainer.insertBefore($(this.player.$container));
        waldorfContainer.append(this.player.$container);
        this.$container = videoContainer.parent(); // Set the container to the width of the video player
  
        this.$container.width(this.player.$container.width()); // Allow the video player container to grow
        //this.player.$container.width("100%");
        //this.player.$container.height("100%");
        // Copy the video styles to the container
        // console.log(this.player.originalStyles);
  
        this.$container.css(this.player.originalStyles);
      }
    }, {
      key: "PopulateControls",
      value: function PopulateControls() {
        var _this2 = this;
  
        // Create the tick bar
        this.tickBar = new _tickBar.TickBar(this); // Create the polygon overlay
  
        this.polyOverlay = new _polygonOverlay.PolygonOverlay(this);
  
        if (!this.kioskMode && this.showManifest) {
          this.$debugControls = $("<div class='waldorf-debug-controls'></div>").appendTo(this.$container);
          var $showAllAnnotationsButton = this.$debugControls.append('<button>Open Annotation Manifest in New Window</button>');
          $showAllAnnotationsButton.click(function () {
            var url = _this2.player.videoElement.currentSrc;
  
            _this2.server.FetchAnnotations("location", url).done(function (json) {
              var win = window.open();
  
              if (win === null) {
                console.error("Couldn't show annotation manifest; please allow pop-ups.");
  
                _this2.messageOverlay.ShowError("Couldn't show annotation manifest; please allow pop-ups.");
              } else {
                win.document.open();
                win.document.write("<title>Annotation Manifest for ".concat(url, "</title>"));
                win.document.write("<pre>");
                win.document.write(JSON.stringify(json, null, 2).escapeHTML());
                win.document.write("</pre>");
                win.document.close();
              }
            });
          });
        } // Wrap all the buttons with the list tag
        //this.$debugControls.wrapInner("<ul></ul>");
        // Wrap each button with the list element tag
        //this.$debugControls.find("button").wrap("<li></li>");
        // Create the info container
  
  
        this.infoContainer = new _infoContainer.InfoContainer(this);
        if (this.displayIndex) this.indexContainer = new _indexContainer.IndexContainer(this); // Inject the annotation edit button into the toolbar
  
        if (!this.kioskMode) {
          this.$addAnnotationButton = $("<button>Add New Annotation</button>").button({
            icon: "fa fa-plus",
            showLabel: false
          }).click(function () {
            _this2.$addAnnotationButton.button("disable");
  
            _this2.gui.BeginEditing();
          });
          this.player.controlBar.RegisterElement(this.$addAnnotationButton, 3, 'flex-end'); // Inject the annotation upload button into the toolbar
  
          this.$uploadAnnotationButton = $("<button type='file'>Import Annotation From File</button>").button({
            icon: "fa fa-upload",
            showLabel: false
          }).click(function () {
            _this2.LoadFromFile();
          });
          this.player.controlBar.RegisterElement(this.$uploadAnnotationButton, 2, 'flex-end');
        }
  
        this.gui = new _annotationGui.AnnotationGUI(this);
      }
    }, {
      key: "AnnotationsLoaded",
      value: function AnnotationsLoaded() {
        //Send annotation loaded event
        this.$container.trigger("OnAnnotationsLoaded", this.annotationManager);
      }
    }, {
      key: "OnTimeUpdate",
      value: function OnTimeUpdate(time) {
        this.annotationsNow = this.annotationManager.AnnotationsAtTime(time);
  
        if (this.annotationsNow.equals(this.lastAnnotationSet)) {
          this.SetAnnotationTimePosition(time);
          return;
        }
  
        this.lastAnnotationSet = this.annotationsNow;
        this.UpdateViews();
      }
    }, {
      key: "SetAnnotationTimePosition",
      value: function SetAnnotationTimePosition(time) {
        //console.log("time: " + time);
        //Check safari and multiple geometric annotation
        if (this.IsSafari() && this.annotationsNow.length > 1) {
          var msg = "Multiple geometric annotations are detected.<br>";
          msg += "Safari doesn't support multiple geometric annotations.<br>";
          msg += "Chrome or Firefox are recommended.";
          this.messageOverlay.ShowMessage(msg, 2.0);
          return; //no animation for safari browser with multiple geometric annotation
        }
  
        for (var i = 0; i < this.annotationsNow.length; i++) {
          var annotation_id = this.annotationsNow[i].id;
  
          if (this.polyOverlay.svgElementsHash[annotation_id]) {
            this.polyOverlay.svgElementsHash[annotation_id].animate.beginElement();
            var time_diff = time - this.annotationsNow[i].beginTime;
            var current_time = this.polyOverlay.svgElementsHash[annotation_id].svgElement.getCurrentTime(); //console.log("\t i:" + i + " (" + annotation_id + "), svg current_time:" + current_time + ", animate time_diff: " + time_diff);
  
            this.polyOverlay.svgElementsHash[annotation_id].svgElement.setCurrentTime(current_time + time_diff);
            this.polyOverlay.svgElementsHash[annotation_id].animate.endElement();
          }
        }
      }
    }, {
      key: "UpdateViews",
      value: function UpdateViews() {
        //console.log("annotator.js:267 UpdateViews");
        this.annotationsNow = this.annotationManager.AnnotationsAtTime(this.player.videoElement.currentTime); // Update the info container
  
        this.infoContainer.Rebuild(this.annotationsNow, this.clearContainer);
        this.$container.trigger("OnNewAnnotationSet", [this.annotationsNow]);
        this.SetAnnotationTimePosition(this.player.videoElement.currentTime);
      }
    }, {
      key: "GetAnnotations",
      value: function GetAnnotations() {
        var ordered = this.annotationManager.annotations.slice();
  
        var orderByStart = function orderByStart(a, b) {
          var aTime = a.beginTime;
          var bTime = b.beginTime;
          return aTime < bTime ? -1 : aTime > bTime ? 1 : 0;
        };
  
        ordered.sort(orderByStart);
        return ordered;
      }
    }, {
      key: "RegisterNewAnnotation",
      value: function RegisterNewAnnotation(annotation) {
        //console.log(annotation);
        //this.annotationManager.RegisterAnnotation(annotation);
        this.annotationManager.PopulateFromJSON(annotation); // Throw event for listening objects (e.g. tick-bar)
  
        this.$container.trigger("OnAnnotationRegistered", [annotation]); // Update dependent views
  
        this.UpdateViews();
      }
    }, {
      key: "UpdateAnnotation",
      value: function UpdateAnnotation(annotation, oldID) {
        this.annotationManager.UpdateAnnotation(annotation, oldID); // Throw event for listening objects (e.g. tick-bar)
  
        this.$container.trigger("OnAnnotationRemoved", [oldID]);
        this.$container.trigger("OnAnnotationRegistered", [annotation]); // Update dependent views
  
        this.UpdateViews();
      }
    }, {
      key: "DeregisterAnnotation",
      value: function DeregisterAnnotation(annotation) {
        var id = '';
  
        if ('undefined' == typeof annotation.items) {
          // Ver 1
          id = annotation.id;
        } else {
          // Ver 2
          id = annotation.items[0].items[0].items[0].id;
        }
  
        this.annotationManager.RemoveAnnotation(id); //this.annotationsNow = this.annotationManager.AnnotationsAtTime(this.player.videoElement.currentTime);
        // Throw event for listening objects (e.g. tick-bar)
  
        this.$container.trigger("OnAnnotationRemoved", [id]); // Update dependent views
  
        this.UpdateViews();
      }
    }, {
      key: "LoadFromFile",
      value: function LoadFromFile() {
        var _this3 = this;
  
        // Create the dialog
        var $container = $("<div class='waldorf-session-modal' title='Import Annotation'></div>"); // Outermost HTML
  
        var $headText = $("<p class='validateTips'>Annotations must be W3C OA compliant in JSON format.</p>").appendTo($container);
        var $errorText = $("<p class='validateTips modal-error-text'></p>").appendTo($container);
        $errorText.hide();
        var $form = $("<form></form>").appendTo($container);
        var $importField;
        $("<label for='importFile'>Select File</label>").appendTo($form);
        $importField = $("<input type='file' name='importFile' class='file ui-widget-content ui-corner-all'>").appendTo($form);
        $form.wrapInner("<fieldset />");
  
        var error = function error(message) {
          console.error(message);
          $errorText.html(message);
          $errorText.show();
        };
  
        var self = this;
        $importField.on('change', function () {
          var files = $importField.get(0).files;
          var fr = new FileReader();
  
          fr.onload = function (localFile) {
            // If the JSON is malformed, show an error and stop here.
            try {
              JSON.parse(localFile.target.result);
            } catch (e) {
              error("JSON file is malformed!");
              return;
            }
  
            var localJson = JSON.parse(localFile.target.result);
  
            if (typeof localJson.target != "undefined") {
              var _annotation = new _annotation3.Annotation(localJson);
  
              if (_this3.ValidateAnnotation(_annotation, 1)) {
                // Open the GUI and populate it with this annotation's data.
                _this3.gui.BeginEditing(_annotation, true);
  
                _this3.gui.CommitAnnotationToServer(function () {
                  return;
                });
              } else {
                error("JSON is invalid!");
              }
            } else if (typeof localJson.items != 'undefined') {
              // ver2
              var _iterator = _createForOfIteratorHelper(localJson.items[0].items),
                  _step;
  
              try {
                for (_iterator.s(); !(_step = _iterator.n()).done;) {
                  var object = _step.value;
  
                  // Per AnnotationPage
                  for (var j = 0; j < object.items.length; j++) {
                    // Per Annotation
                    var theAnnotation = JSON.parse(JSON.stringify(object.items[j]));
                    var theObject = JSON.parse(JSON.stringify(object));
                    theObject.items = [theAnnotation];
                    var annotation = new _annotation3.Annotation(theObject, JSON.parse(JSON.stringify(localJson.items[0])));
                    console.log(annotation);
  
                    _this3.gui.BeginEditing(annotation, true);
  
                    _this3.gui.CommitAnnotationToServer(function (annotation) {
                      _this3.RegisterNewAnnotation(annotation);
                    });
  
                    _this3.gui.Close();
                  }
                }
              } catch (err) {
                _iterator.e(err);
              } finally {
                _iterator.f();
              }
            } else {
              // ver1
              for (var i = 0; i < localJson.length; i++) {
                var _annotation2 = new _annotation3.Annotation(localJson[i]);
  
                if (_this3.ValidateAnnotation(_annotation2, i + 1)) {
                  // // Open the GUI and populate it with this annotation's data.
                  _this3.gui.BeginEditing(_annotation2, true);
  
                  _this3.gui.CommitAnnotationToServer(function (annotation) {
                    _this3.RegisterNewAnnotation(annotation);
                  });
  
                  _this3.gui.Close();
                } else {
                  error("JSON is invalid!");
                }
              }
            }
  
            $dialog.dialog("close");
          };
  
          fr.readAsText(files[0]);
        });
        var $dialog = $container.dialog({
          autoOpen: true,
          draggable: false,
          modal: true,
          buttons: {
            Cancel: function Cancel() {
              $dialog.dialog("close");
            }
          },
          close: function close() {
            $dialog.find("form")[0].reset();
            $dialog.find("input").removeClass("ui-state-error"); //this.OnModalClose();
          }
        });
      }
    }, {
      key: "ValidateAnnotation",
      value: function ValidateAnnotation(annotation, idx) {
        // TODO: Validate annotation here. Return false if any
        // required properties are not present. Right now, this is only for v1.
        //Required fields:
        //- beginTime
        // - endTime
        // - annotation_version
        // - body type textualBody
        // -- value
        // - creator
        // -- nickname
        // -- email
        // Note that tags and targets are _not_ required elements in the v1 format when
        //moving annotations around because tags are always optional and targets are
        //assumed to change when importing
        var requiredFields = ["beginTime", "endTime", "annotation_version", "body", "creator"];
  
        for (var i = 0; i < requiredFields.length; i++) {
          if (typeof annotation[requiredFields[i]] == 'undefined' || annotation[requiredFields[i]] == '') {
            this.messageOverlay.ShowMessage("Skipped annotation " + idx + ": missing " + requiredFields[i]);
            return false;
          }
        }
  
        if (_typeof(annotation.creator) != 'object') {
          this.messageOverlay.ShowMessage("Skipped annotation " + idx + ": malformed creator node");
          return false;
        }
  
        if (typeof annotation.creator.nickname == 'undefined' || annotation.creator.nickname == '') {
          this.messageOverlay.ShowMessage("Skipped annotation " + idx + ": missing creator name");
          return false;
        }
  
        if (typeof annotation.creator.email == 'undefined' || annotation.creator.email == '') {
          this.messageOverlay.ShowMessage("Skipped annotation " + idx + ": missing creator email");
          return false;
        }
  
        if (_typeof(annotation.body) != 'object' || annotation.body.length == 0) {
          this.messageOverlay.ShowMessage("Skipped annotation " + idx + ": malformed body node");
          return false;
        }
  
        var textNode = '';
  
        for (var _i = 0; _i < annotation.body.length; _i++) {
          if (typeof annotation.body[_i].purpose != 'undefined' && annotation.body[_i].purpose == 'describing') {
            if (typeof annotation.body[_i].value != 'undefined') textNode = annotation.body[_i].value;
            continue;
          }
        }
  
        if (textNode == '') {
          this.messageOverlay.ShowMessage("Skipped annotation " + idx + ": missing body text node");
          return false;
        }
  
        return true;
      } // checking whether the browser is safari or not
  
    }, {
      key: "IsSafari",
      value: function IsSafari() {
        //ref: https://stackoverflow.com/questions/49872111/detect-safari-and-stop-script
        var isSafari = /^((?!chrome|android).)*safari/i.test(navigator.userAgent);
        return isSafari;
      }
    }]);
  
    return VideoAnnotator;
  }();
  
  exports.VideoAnnotator = VideoAnnotator;
  
  },{"../annotator-config.json":1,"../utils/preference-manager.js":19,"./annotation-manager.js":2,"./annotation.js":3,"./components/annotation-gui.js":5,"./components/index-container.js":6,"./components/info-container.js":7,"./components/message-overlay.js":8,"./components/polygon-overlay.js":10,"./components/tick-bar.js":11,"./server-interface.js":12,"./session-manager.js":13,"sha1":118}],5:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.AnnotationGUI = void 0;
  
  var _time = require("../../utils/time.js");
  
  var _polygonEditor = require("./polygon-editor.js");
  
  var _annotation = require("../annotation.js");
  
  var _types = require("@babel/types");
  
  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
  
  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
  
  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var AnnotationGUI = /*#__PURE__*/function () {
    function AnnotationGUI(annotator) {
      var _this = this;
  
      _classCallCheck(this, AnnotationGUI);
  
      this.annotator = annotator;
      this.Create();
      this.open = false; //Hide the container
  
      this.isVisible = false;
      this.$container.makeVisible(false);
      this.polyEditor = new _polygonEditor.PolygonEditor(this.annotator);
      this.annotator.$container.on("OnPolygonEditingEnded", function () {
        _this.SetVisible(true);
  
        _this.polyEditor.ShowJustPolygon();
      });
    }
  
    _createClass(AnnotationGUI, [{
      key: "Create",
      value: function Create() {
        var _this2 = this;
  
        /*
         * //new UI
         * 
         */
        this.$container = $("<div id='create-dialog' class='ui-widget-content center'>").appendTo(this.annotator.player.$container);
        this.$container.draggable();
        this.$title = $("<div class='dialog-title'>Create Annotation</div>").appendTo(this.$container); // Make cancel button
  
        var $exitButton = $("<button>Exit Annotation Editing</button>").button({
          icons: {
            primary: 'fa fa-remove'
          },
          showLabel: false
        });
        $exitButton.css("float", "right");
        $exitButton.attr('title', "Exit annotation editing");
        $exitButton.addClass("waldorf-cancel-button");
        $exitButton.click(function () {
          _this2.polyEditor.ResetPolygons();
  
          _this2.Close();
        });
        this.RegisterElement($exitButton, this.$title, -1);
        this.$tabs = $("<div id='tabs'></div>").appendTo(this.$container);
        var $tabUI = $("<ul></ul>");
        var $startUI = $("<li><a href='#start_tab'>Start </a></li>");
        var $bodyUI = $("<li><a href='#body_tab'>Body </a></li>");
        var $stopUI = $("<li><a href='#stop_tab'>Stop </a></li>");
        this.RegisterElement($tabUI, this.$tabs, -1);
        this.RegisterElement($startUI, $tabUI, -1);
        this.RegisterElement($bodyUI, $tabUI, -1);
        this.RegisterElement($stopUI, $tabUI, -1); //Create tabs
  
        var $startTab = $("<div id='start_tab' class='ui-field-contain'></div>");
        this.RegisterElement($startTab, this.$tabs, -1);
        var $bodyTab = $("<div id='body_tab'></div>");
        this.RegisterElement($bodyTab, this.$tabs, -1);
        var $stopTab = $("<div id='stop_tab'></div>");
        this.RegisterElement($stopTab, this.$tabs, -1); //Add hidden fields for creator info
  
        this.$creatorNameField = $('<input type="hidden" name="creator-nickname" id="creator-nickname" value="">');
        this.$creatorNameField.appendTo($startTab);
        this.$creatorEmailField = $('<input type="hidden" name="creator-email" id="creator-email" value="">');
        this.$creatorEmailField.appendTo($startTab); //Begin filling start tab
        // Make "Start time" label and field
  
        this.$timeStartField = $('<input type="text" name="time-start" id="time-start" value="">');
        this.$timeStartField.width(72);
        this.$timeStartField.css("font-family", "Courier, monospace");
        this.$timeStartField.css("margin-right", "2px");
        this.$timeStartField.addClass("ui-widget ui-widget-content ui-corner-all");
        this.$timeStartField.attr('title', "Start time (hh:mm:ss.ss)");
        this.$timeStartField.on('keypress', function (event) {
          if (event.keyCode == 46 || event.keyCode >= 48 && event.keyCode <= 58) {
            //0-9, period, and colon
            return true;
          }
  
          return false;
        }); //add start marker button
  
        this.$startTimeMarker = $("<button style='padding:0; line-height:1.4'>Set Start</button> ").button({
          icon: "fa fa-map-marker",
          showLabel: false
        }).click(function () {
          _this2.$timeStartField[0].value = (0, _time.GetFormattedTime)(_this2.annotator.player.videoElement.currentTime);
        });
        this.RegisterElement(this.$startTimeMarker, $startTab);
        $("<label for='time-start'>Start Time: </label> ").appendTo($startTab);
        this.$timeStartField.appendTo($startTab);
        this.$startTimeJump = $("<i class='fa fa-clock-o' style='cursor: pointer; padding:0; line-height:1.4; color: white;'></i><br><br>").click(function () {
          _this2.annotator.player.videoElement.currentTime = (0, _time.GetSecondsFromHMS)(_this2.$timeStartField[0].value);
        });
        this.RegisterElement(this.$startTimeJump, $startTab); //Make "Edit polygon" button
  
        var $editPolyButton = $("<button style='padding:0; line-height:1.4'>Edit Polygon</button>").button({
          icon: "fa fa-pencil",
          showLabel: false
        }).click(function () {
          _this2.SetVisible(false); //console.log("annotation-gui:353 Create");
  
  
          _this2.polyEditor.BeginEditing('start');
        });
        $editPolyButton.attr('title', "Edit polygon");
        this.RegisterElement($editPolyButton, $startTab, -1);
        var $startTargetLabel = $("<label>Start Target</label> ");
        $startTargetLabel.css("color", "white");
        this.RegisterElement($startTargetLabel, $startTab, -1); // Add tags input field
  
        this.$tagsField = $('<select class="form-control" multiple="multiple"></select>');
        this.$tagsField.width("100%");
        this.$tagsField.css("margin-top", "-8px");
        this.RegisterElement(this.$tagsField, $bodyTab, -1);
  
        if (this.annotator.tagsURL == '') {
          this.$tagsField.select2({
            tags: true,
            placeholder: "Tags",
            data: [{
              id: 0,
              text: "No taxonomy; type tags above",
              disabled: true
            }],
            selectOnBlur: true,
            // Allow manually entered text in drop down.
            createTag: function createTag(params) {
              return {
                id: params.term,
                text: params.term // newOption: true
  
              };
            }
          });
        } else {
          this.$tagsField.select2({
            tags: true,
            placeholder: "Tags",
            ajax: this.GetTagsQuery(),
            selectOnBlur: true,
            // Allow manually entered text in drop down.
            createTag: function createTag(params) {
              return {
                id: params.term,
                text: params.term // newOption: true
  
              };
            }
          });
        } // Add custom class for bringing the dropdown to the front (fullscreen fix)
  
  
        this.$tagsField.data('select2').$dropdown.addClass("select2-dropdown-annotator"); // Make notes text field
  
        this.$textField = $('<textarea type="text" name="anno-text" id="anno-text" value="" placeholder="Notes">');
        this.$textField.css("margin-top", "2px");
        this.$textField.width("98.5%");
        this.$textField.addClass("ui-widget ui-widget-content ui-corner-all");
        this.$textField.attr('title', 'Annotation text');
        this.$textField.css("flex-grow", 2);
        this.RegisterElement(this.$textField, $bodyTab, -1); // Make "Stop time" label and field
  
        this.$timeEndField = $('<input type="text" name="time-stop" id="time-stop" value="">');
        this.$timeEndField.width(72);
        this.$timeEndField.css("font-family", "Courier, monospace");
        this.$timeEndField.css("margin-right", "2px");
        this.$timeEndField.addClass("ui-widget ui-widget-content ui-corner-all");
        this.$timeEndField.attr('title', "End time (hh:mm:ss.ss)");
        this.$timeEndField.on('keypress', function (event) {
          if (event.keyCode == 46 || event.keyCode >= 48 && event.keyCode <= 58) {
            //0-9, period, and colon
            return true;
          }
  
          return false;
        }); //add end marker button
  
        this.$endTimeMarker = $("<button style='padding:0; line-height:1.4'>Set End</button>").button({
          icon: "fa fa-map-marker",
          showLabel: false
        }).click(function () {
          _this2.$timeEndField[0].value = (0, _time.GetFormattedTime)(_this2.annotator.player.videoElement.currentTime);
        });
        this.RegisterElement(this.$endTimeMarker, $stopTab);
        $("<label for='stop_time'>Stop Time: </label> ").appendTo($stopTab);
        this.$timeEndField.appendTo($stopTab);
        this.$endTimeJump = $("<i class='fa fa-clock-o' style='cursor: pointer; padding:0; line-height:1.4; color: white;'></i><br><br>").click(function () {
          _this2.annotator.player.videoElement.currentTime = (0, _time.GetSecondsFromHMS)(_this2.$timeEndField[0].value);
        });
        this.RegisterElement(this.$endTimeJump, $stopTab); //Make "Edit polygon" button
  
        var $editStopPolyButton = $("<button style='padding:0; line-height:1.4'>Edit Polygon</button>").button({
          icon: "fa fa-pencil",
          showLabel: false
        }).click(function () {
          _this2.SetVisible(false); //console.log("annotation-gui:353 Create");
  
  
          _this2.polyEditor.BeginEditing('stop');
        });
        $editStopPolyButton.attr('title', "Edit polygon");
        this.RegisterElement($editStopPolyButton, $stopTab, -1);
        var $stopTargetLabel = $("<label>Stop Target</label> ");
        $stopTargetLabel.css("color", "white");
        this.RegisterElement($stopTargetLabel, $stopTab, -1); //stop point polygon is added
  
        this.$endPolygonSet = $("<button style='padding:0; line-height:1.4'>End Polygon Set</button>").button({
          icon: "fa fa-check-square-o",
          showLabel: false
        }); //this.$endPolygonSet.css("visibility", "inherit");
  
        this.$endPolygonSet.css("visibility", "hidden"); //this.$endPolygonSet.addClass("waldorf-confirm-button");
        //Add some error checking...
  
        this.$timeEndField.blur(function () {
          var e = $(_this2.$timeEndField).val();
          var s = $(_this2.$timeStartField).val();
  
          if ((0, _time.GetSecondsFromHMS)(s + 1) > (0, _time.GetSecondsFromHMS)(e)) {
            $(_this2.$timeEndField).val((0, _time.GetFormattedTime)((0, _time.GetSecondsFromHMS)(s) + .01));
          }
        });
        this.$timeStartField.blur(function () {
          var e = $(_this2.$timeEndField).val();
          var s = $(_this2.$timeStartField).val();
  
          if ((0, _time.GetSecondsFromHMS)(s + 1) > (0, _time.GetSecondsFromHMS)(e)) {
            $(_this2.$timeEndField).val((0, _time.GetFormattedTime)((0, _time.GetSecondsFromHMS)(s) + .01));
          }
        });
        this.RegisterElement(this.$endPolygonSet, $stopTab, -2);
        var $buttonPanel = $("<div class='button_panel'></div>").appendTo(this.$container); // Make delete button. This should only appear if we're editing, not if it's a new annotation
  
        this.$deleteButton = $("<button id='delete_annotation_button'>Delete</button>").button({
          // icon: "fa fa-bomb",
          showLabel: true
        }); // this.$deleteButton.hide();
  
        this.$deleteButton.attr('title', "Delete annotation");
        this.$deleteButton.click(function () {
          _this2.annotator.server.DeleteAnnotation(_this2.originalAnnotation, function () {
            _this2.annotator.DeregisterAnnotation(_this2.originalAnnotation);
  
            _this2.Close();
          });
        });
        this.RegisterElement(this.$deleteButton, $buttonPanel, -1); // Make cancel button
  
        var $cancelButton = $("<button>Cancel</button>").button({
          showLabel: true
        }).click(function () {
          _this2.polyEditor.ResetPolygons();
  
          _this2.Close();
        });
        $cancelButton.attr('title', "Exit annotation editing"); //$cancel_button.addClass("waldorf-cancel-button");
  
        this.RegisterElement($cancelButton, $buttonPanel, -1); // Make save button
  
        var $saveButton = $("<button>Save</button>").button({
          showLabel: true
        }).click(function () {
          _this2.CommitAnnotationToServer(function (annotation, oldID) {
            if (_this2.editMode) {
              _this2.annotator.UpdateAnnotation(annotation, oldID);
            } else {
              _this2.annotator.RegisterNewAnnotation(annotation);
            }
  
            _this2.polyEditor.ResetPolygons();
  
            _this2.Close();
          });
        });
        $saveButton.attr('title', "Save annotation");
        this.RegisterElement($saveButton, $buttonPanel, -1); //https://stackoverflow.com/questions/13837304/jquery-ui-non-ajax-tab-loading-whole-website-into-itself
  
        $('base').remove();
        this.$tabs.tabs().addClass('ui-tabs-vertical'); //let $script_section = $
        //this.$container.hide();
      }
    }, {
      key: "RegisterElement",
      value: function RegisterElement($element, $container, order) {
        var justification = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'flex-start';
        $element.css('order', order);
        $element.css('align-self', justification); // Sets grow [shrink] [basis]
        //$element.css('flex', '0 0 auto');
  
        $container.append($element);
      }
    }, {
      key: "SetVisible",
      value: function SetVisible(isVisible) {
        var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
  
        //console.log(isVisible + " " + duration);
        if (isVisible) {
          this.$container.fadeTo(duration, 1.0);
          this.$container.makeVisible(true);
        } else {
          this.$container.stop(true, true);
          this.$container.fadeTo(duration, 0.0);
          this.$container.makeVisible(false);
        }
  
        this.isVisible = isVisible;
      }
    }, {
      key: "ToggleOpen",
      value: function ToggleOpen() {
        if (this.open) {
          this.Close();
        } else {
          this.Open();
        }
      }
    }, {
      key: "Open",
      value: function Open() {
        this.SetVisible(true);
        this.open = true;
        this.polyEditor.Done(); // Disable autofading when the gui is visible
        // this.annotator.player.SetAutoFade(false);
      }
    }, {
      key: "Close",
      value: function Close() {
        this.SetVisible(false);
        this.open = false;
        this.polyEditor.Done(); // Re-enable autofading when the gui is hidden
        // this.annotator.player.SetAutoFade(true);
  
        this.$container.trigger("OnGUIClosed");
      }
    }, {
      key: "ToggleVisible",
      value: function ToggleVisible() {
        this.SetVisible(!this.isVisible, 0);
      }
    }, {
      key: "BeginEditing",
      value: function BeginEditing() {
        var annotation = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;
        var forceNew = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : false;
  
        if (this.open) {
          this.annotator.messageOverlay.ShowMessage("Please save or close the current annotation.");
          return;
        } // Open the GUI if it isn't already
  
  
        this.Open(); // Populate data from the passed in annotation
  
        if (annotation || forceNew) {
          // Populate the fields from the annotation
          this.editMode = true; // Flip edit mode back to false if forceNew. We want to
          // populate from the entire passed in annotation, but treat
          // it as new.
  
          if (forceNew) this.editMode = false;
          this.originalAnnotation = annotation;
          console.log("Populated from an existing annotation");
          console.log(annotation);
          this.$timeStartField.val((0, _time.GetFormattedTime)(annotation.beginTime));
          this.$timeEndField.val((0, _time.GetFormattedTime)(annotation.endTime));
  
          if ('undefined' == typeof annotation.items) {
            // Version 1
            this.$textField.val(annotation.body.filter(function (item) {
              return item.purpose == "describing";
            })[0].value); // Version 1 doesn't have a this.id context
  
            if (typeof annotation.creator != 'undefined' && typeof annotation.creator.nickname != 'undefined') this.$creatorNameField.val(annotation.creator.nickname);else this.$creatorNameField.val(localStorage.getItem('waldorf_user_name'));
            if (typeof annotation.creator != 'undefined' && typeof annotation.creator.email_sha1 != 'undefined') this.$creatorEmailField.val(annotation.creator.email_sha1);else this.$creatorEmailField.val(localStorage.getItem('waldorf_user_email'));
          } else {
            // Version 2
            this.$textField.val(annotation.items[0].items[0].items[0].body.filter(function (item) {
              return item.purpose == "describing";
            })[0].value);
            this.id = annotation.items[0].items[0].items[0].id;
  
            if (typeof annotation.items[0].items[0].items[0].creator != 'undefined' && typeof annotation.items[0].items[0].items[0].creator.nickname != 'undefined') {
              this.$creatorNameField.val(annotation.items[0].items[0].items[0].creator.nickname);
            } else this.$creatorNameField.val(localStorage.getItem('waldorf_user_name'));
  
            if (typeof annotation.items[0].items[0].items[0].creator != 'undefined' && typeof annotation.items[0].items[0].items[0].creator.email_sha1 != 'undefined') {
              this.$creatorEmailField.val(annotation.items[0].items[0].items[0].creator.email_sha1);
            } else this.$creatorEmailField.val(localStorage.getItem('waldorf_user_email'));
          } // Reset the tags field
  
  
          this.$tagsField.val("").trigger("change");
          this.$tagsField.find("option:not([disabled])").remove();
  
          var _iterator = _createForOfIteratorHelper(annotation.tags),
              _step;
  
          try {
            for (_iterator.s(); !(_step = _iterator.n()).done;) {
              var tag = _step.value;
              this.$tagsField.append("<option value='" + tag + "' selected>" + tag + "</option>");
              this.$tagsField.trigger("change");
            }
          } catch (err) {
            _iterator.e(err);
          } finally {
            _iterator.f();
          }
  
          this.polyEditor.InitPoly(annotation.polyStart, annotation.polyEnd);
        } // Insert template data if no annotation is given
        else {
          // Populate fields if no annotation is given
          this.editMode = false;
          this.originalAnnotation = null;
          this.id = null; // console.log("Populated with template data");
  
          this.$timeStartField.val((0, _time.GetFormattedTime)(this.annotator.player.videoElement.currentTime));
          this.$timeEndField.val((0, _time.GetFormattedTime)(this.annotator.player.videoElement.duration));
          this.$creatorNameField.val(localStorage.getItem('waldorf_user_name'));
          this.$creatorEmailField.val(localStorage.getItem('waldorf_user_email'));
          this.$textField.val(""); // Reset the tags field
  
          this.$tagsField.val("").trigger("change");
          this.$tagsField.find("option:not([disabled])").remove();
          this.polyEditor.InitPoly();
        } // Modify GUI based on edit mode
  
  
        if (this.editMode) {
          this.$title.text("Edit Annotation");
          this.$deleteButton.button("enable");
          this.$deleteButton.show();
        } else {
          this.$title.text("Create Annotation");
          this.$deleteButton.button("disable");
          this.$deleteButton.hide();
        }
      }
    }, {
      key: "CommitAnnotationToServer",
      value: function CommitAnnotationToServer(callback) {
        if (this.editMode) {
          // console.log("Sending edited annotation to server...");
          this.annotator.server.EditAnnotation(callback);
        } else {
          // console.log("Sending new annotation to server...");
          this.annotator.server.PostAnnotation(callback);
        }
      } // Build an object from the data.
  
    }, {
      key: "GetAnnotationObject",
      value: function GetAnnotationObject() {
        var annotation = new _annotation.Annotation();
  
        if ('undefined' == typeof annotation.items) {
          // Version 1
          annotation["body"] = this.BuildAnnotationBodyV1();
          annotation["target"] = this.BuildAnnotationTarget(true);
          annotation["creator"] = this.BuildCreatorTemplate();
        } else {
          // Version 2
          annotation["label"] = {
            "en": [this.annotator.contentLabel]
          };
          annotation["items"] = this.BuildAnnotationItems();
        } // Recompute read-only access properties after all other properties have been set
  
  
        annotation.recalculate(); // Clone the object so we don't modify anything by changing this object
  
        var clone = JSON.parse(JSON.stringify(annotation));
        return clone;
      }
    }, {
      key: "BuildAnnotationItems",
      value: function BuildAnnotationItems() {
        var buildTime = new Date().toISOString(); //"2020-08-16T12:00:00Z"
  
        var videoDuration = this.annotator.player.videoElement.duration;
        var videoWidth = this.annotator.player.videoElement.videoWidth;
        var videoHeight = this.annotator.player.videoElement.videoHeight; // let videoDimension = this.annotator.player.GetVideoDimensions()
        // videoWidth = videoDimension.width;
        // videoHeight = videoDimension.height;
  
        var items = [{
          "id": this.annotator.url,
          //TODO: scalar specific url - should be supplied to plugin 
          "type": "Canvas",
          "height": videoHeight,
          "width": videoWidth,
          "duration": videoDuration,
          "content": {
            "id": this.annotator.url,
            "type": "Video",
            "height": videoHeight,
            "width": videoWidth,
            "duration": videoDuration,
            "label": {
              "en": this.annotator.contentLabel //"dcterms:title" from the annotation json file from scalar
  
            },
            "description": {
              "en": ""
            }
          },
          "items": [{
            "id": this.annotator.url,
            "type": "AnnotationPage",
            "generator": "http://github.com/anvc/scalar",
            "generated": buildTime,
            "items": [{
              "id": this.id,
              // URL to the annotation-page JPB
              "type": "Annotation",
              "generator": "http://github.com/novomancy/waldorf-scalar",
              "motivation": "highlighting",
              "creator": this.BuildCreatorTemplate(),
              "created": buildTime,
              "rights": "https://creativecommons.org/licenses/by/4.0/",
              "body": this.BuildAnnotationBodyV2(),
              "target": this.BuildAnnotationTarget(false)
            }]
          }]
        }];
        return items;
      }
    }, {
      key: "BuildCreatorTemplate",
      value: function BuildCreatorTemplate() {
        return {
          "type": "Person",
          "nickname": this.$creatorNameField.val(),
          "email_sha1": this.$creatorEmailField.val()
        };
      } //Build with tags entries from onomy
  
    }, {
      key: "BuildAnnotationBodyV2",
      value: function BuildAnnotationBodyV2() {
        var body = []; // Build text descriptor
  
        var bodyText = {
          "type": "TextualBody",
          "value": this.$textField.val(),
          "format": "text/plain",
          "language": "en",
          "purpose": "describing"
        };
        body.push(bodyText); // Build tag descriptors
        //let tags = this.$tagsField.select2("data").map((item) => { return item.text; });
  
        var selected_tags = this.$tagsField.select2("data").map(function (item) {
          return {
            id: item.id,
            text: item.text
          };
        });
        var onomy_map = {};
  
        if (typeof this.annotator.annotationManager.onomyVocabulary.results != 'undefined') {
          onomy_map = this.annotator.annotationManager.onomyVocabulary.results.reduce(function (acc, curr) {
            acc[curr['id']] = curr;
            return acc;
          }, {});
        }
  
        var _iterator2 = _createForOfIteratorHelper(selected_tags),
            _step2;
  
        try {
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
            var tag = _step2.value;
            var onomy_ref = onomy_map[tag.id];
            var bodyTag = {};
  
            if (onomy_ref) {
              bodyTag = {
                "type": "SpecificResource",
                "purpose": "tagging",
                "source": {
                  "id": onomy_ref.terms_id,
                  "format": "application/json",
                  "label": {
                    "en": onomy_ref.text
                  },
                  "description": {
                    "en": onomy_ref.comment
                  }
                }
              };
            } else {
              bodyTag = {
                "type": "TextualBody",
                "purpose": "tagging",
                "value": tag.text
              };
            }
  
            body.push(bodyTag);
          }
        } catch (err) {
          _iterator2.e(err);
        } finally {
          _iterator2.f();
        }
  
        return body;
      }
    }, {
      key: "BuildAnnotationBodyV1",
      value: function BuildAnnotationBodyV1() {
        var body = []; // Build text descriptor
  
        var bodyText = {
          "type": "TextualBody",
          "value": this.$textField.val(),
          "format": "text/plain",
          "language": "en",
          "purpose": "describing"
        };
        body.push(bodyText); // Build tag descriptors
  
        var tags = this.$tagsField.select2("data").map(function (item) {
          return item.text;
        });
  
        var _iterator3 = _createForOfIteratorHelper(tags),
            _step3;
  
        try {
          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
            var tagStr = _step3.value;
            var bodyTag = {
              "type": "TextualBody",
              "purpose": "tagging",
              "value": tagStr
            };
            body.push(bodyTag);
          }
        } catch (err) {
          _iterator3.e(err);
        } finally {
          _iterator3.f();
        }
  
        return body;
      } //used both v1 and v2
  
    }, {
      key: "BuildAnnotationTarget",
      value: function BuildAnnotationTarget(selectorsInArray) {
        if ('undefined' == typeof selectorsInArray) selectorsInArray = false;
        var target = {
          "id": this.annotator.url,
          // URL of the video
          "type": "Video"
        };
        var selectors = [];
        var safeEndTime = (0, _time.GetSecondsFromHMS)(this.$timeStartField.val());
  
        if ((0, _time.GetSecondsFromHMS)(this.$timeEndField.val()) > (0, _time.GetSecondsFromHMS)(this.$timeStartField.val())) {
          safeEndTime = (0, _time.GetSecondsFromHMS)(this.$timeEndField.val());
        }
  
        var startTime = (0, _time.GetSecondsFromHMS)(this.$timeStartField.val()); // Build time selector
  
        var timeSelector = {
          "type": "FragmentSelector",
          "conformsTo": "http://www.w3.org/TR/media-frags/",
          // See media fragment specification
          "value": "t=".concat(startTime, ",").concat(safeEndTime) // Time interval in seconds
  
        }; //Build SvgSelector
  
        if (typeof this.polyEditor.$vertices.start != 'undefined' && this.polyEditor.$vertices.start.length > 0) {
          var pointsStr = this.polyEditor.$vertices.start.map(function (item) {
            return "".concat(item[0], ",").concat(item[1]);
          }).join(" ");
          var value = "<svg viewBox='0 0 100 100' preserveAspectRatio='none'>";
          value += "<polygon points='" + pointsStr + "' />";
  
          if (this.polyEditor.IsAnimated()) {
            var animeStr = this.polyEditor.$vertices.stop.map(function (item) {
              return "".concat(item[0], ",").concat(item[1]);
            }).join(" ");
            value += "<animate attributeName='points' from='" + pointsStr + "' to='" + animeStr + "'";
            value += " start='" + startTime + "' end='" + safeEndTime + "' />";
          }
  
          value += "</svg>";
          var polygonSelector = {
            "type": "SvgSelector",
            "conformsTo": "http://www.w3.org/TR/SVG/",
            //added for v2
            "value": "".concat(value) // http://stackoverflow.com/a/24898728
  
          };
  
          if (selectorsInArray) {
            selectors.push(polygonSelector);
          } else {
            timeSelector["refinedBy"] = polygonSelector;
          }
        }
  
        if (selectorsInArray) {
          selectors.push(timeSelector);
          target["selector"] = selectors;
        } else {
          target["selector"] = timeSelector;
        }
  
        return target;
      }
    }, {
      key: "GetTagsQuery",
      value: function GetTagsQuery() {
        if (this.annotator.annotationManager != undefined && this.annotator.annotationManager.onomyVocabulary.length > 0) {
          return this.annotator.annotationManager.onomyVocabulary;
        }
  
        if (!this.annotator.tagsURL) return {
          results: []
        };
        return {
          url: this.annotator.tagsURL,
          dataType: 'json',
          delay: 250,
          cache: true,
          onomyLanguage: this.annotator.onomyLanguage,
          annotationManager: this.annotator.annotationManager,
          parseFunction: this.OnomyVocabularyProcess,
          processResults: function processResults(data) {
            return this.ajaxOptions.parseFunction(data, this.ajaxOptions.onomyLanguage);
          }
        };
      }
    }, {
      key: "OnomyVocabularyProcess",
      value: function OnomyVocabularyProcess(data, onomyLanguage) {
        // Parse the labels into the format expected by Select2
        // multilingual tags
        var multilingual_tags = [];
        var m_comments = {};
        var comments = {};
        var m_index = 1;
        var tags = [];
        var index = 1;
  
        var _iterator4 = _createForOfIteratorHelper(data["terms"]),
            _step4;
  
        try {
          for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {
            var term = _step4.value;
            //if onomyLanguage is defined collect multilingual tags
            var terms_id = term["rdfs:about"];
            var terms_comment = term["rdfs:comment"];
  
            if (onomyLanguage != '' && term['labels'] != undefined) {
              var t_label = "";
              var t_comment = ""; //get labels
  
              var _iterator5 = _createForOfIteratorHelper(term["labels"]),
                  _step5;
  
              try {
                for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {
                  var label = _step5.value;
                  var xml_lang = label["xml:lang"];
                  var m_label = label["rdfs:label"];
  
                  if (xml_lang == onomyLanguage && m_label && m_label.trim != "") {
                    t_label = m_label;
                  }
                } //get comments
  
              } catch (err) {
                _iterator5.e(err);
              } finally {
                _iterator5.f();
              }
  
              var _iterator6 = _createForOfIteratorHelper(term['comments']),
                  _step6;
  
              try {
                for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {
                  var _label = _step6.value;
                  var _xml_lang = _label["xml:lang"];
                  var m_comment = _label["rdfs:comments"]; //TODO: change to comment after fixing Onomy
  
                  if (_xml_lang == onomyLanguage && m_comment) {
                    t_comment = m_comment;
                  }
                } // use the term comment value if comment is blank
  
              } catch (err) {
                _iterator6.e(err);
              } finally {
                _iterator6.f();
              }
  
              if (t_comment == undefined || t_comment.trim == "") {
                t_comment = terms_comment;
              }
  
              multilingual_tags.push({
                id: m_index,
                text: t_label,
                terms_id: terms_id,
                comment: t_comment
              });
              m_index++;
            }
  
            tags.push({
              id: index,
              text: term["rdfs:label"],
              terms_id: term["rdfs:about"],
              comment: term["rdfs:comment"]
            });
            index++;
          }
        } catch (err) {
          _iterator4.e(err);
        } finally {
          _iterator4.f();
        }
  
        var return_tags = multilingual_tags;
  
        if (return_tags.length == 0) {
          return_tags = tags;
        }
  
        return {
          results: return_tags
        };
      }
    }]);
  
    return AnnotationGUI;
  }();
  
  exports.AnnotationGUI = AnnotationGUI;
  
  },{"../../utils/time.js":22,"../annotation.js":3,"./polygon-editor.js":9,"@babel/types":74}],6:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.IndexContainer = void 0;
  
  var _time = require("../../utils/time.js");
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var sha1 = require('sha1');
  
  var IndexContainer = /*#__PURE__*/function () {
    function IndexContainer(annotator) {
      var _this = this;
  
      _classCallCheck(this, IndexContainer);
  
      console.log("[Index Container] Creating annotation index");
      this.annotator = annotator;
      var container = $(".waldorf-index");
  
      if (container.length > 0) {
        this.$container = container.first();
      } else {
        this.$container = $("<div class='waldorf-index' aria-live='polite' role='navigation'></div>").appendTo(this.annotator.$container);
      }
  
      this.annotationList = $("<ul class='waldorf-annotation-list' role='menubar'></ul>").appendTo(this.$container); // Attach event handlers
  
      this.annotator.$container.on("OnAnnotationsLoaded", function (event, annotationManager) {
        return _this.Rebuild();
      });
      this.annotator.$container.on("OnAnnotationRegistered", function (event, annotation) {
        return _this.Rebuild();
      });
      this.annotator.$container.on("OnAnnotationRemoved", function (event, id) {
        return _this.Rebuild();
      });
    }
  
    _createClass(IndexContainer, [{
      key: "Rebuild",
      value: function Rebuild() {
        this.annotationList.empty(); // if(this.annotator.unrenderer) this.annotator.unrenderer(this.annotator);
        // let plural = annotations.length == 1 ? "" : "s";
        // let totalAnnotations = this.annotator.annotationManager.annotations.length;
        // this.$container.html(`<p>Showing ${annotations.length} annotation${plural} (${totalAnnotations} total).</p>`);
        // Add each annotation to the readout
  
        var ordered = this.annotator.GetAnnotations();
  
        for (var i = 0; i < ordered.length; i++) {
          this.annotationList.append(this.MakeContainer(this.annotator, ordered[i], i));
        }
      }
    }, {
      key: "MakeContainer",
      value: function MakeContainer(annotator, annotation) {
        //TODO: ARIA and general screen reader compatibility
        var $panel = $("<li role='presentation' data-creator=" + annotation.creator.email + " data-tags='" + annotation.tags.join(", ").replace("'", "%27") + "'></li>"); //let text = JSON.stringify(annotation.AsOpenAnnotation(), null, 2);
  
        var headerText = (0, _time.GetFormattedTime)(annotation.beginTime) + " - " + (0, _time.GetFormattedTime)(annotation.endTime); // Add clickable header that brings up the edit interface.
  
        var $header = $("<a href='' title='Go to Annotation' role='menuitem'>" + headerText + "</a><br>");
        $header.click(function (event) {
          event.preventDefault();
          annotator.player.videoElement.currentTime = annotation.beginTime; // if(annotator.player.videoElement.annotationTimeout) clearTimeout(annotator.player.videoElement.annotationTimeout);
          // annotator.player.videoElement.annotationTimeout = setTimeout(function(){
          //     annotator.player.videoElement.pause()}, (annotation.endTime-annotation.beginTime) * 1000
          // );
          //annotator.player.videoElement.src=annotator.url + "#t=" + annotation.beginTime +","+annotation.endTime;
          //annotator.player.videoElement.play();
  
          annotator.player.Play();
          annotator.player.endTime = annotation.endTime;
  
          if (annotation.beginTime + 1 > annotation.endTime) {
            annotator.player.Pause();
          }
        });
        $panel.append($header);
        var $content = $("<p></p>");
        $content.append("<b>Text: </b> " + annotation.body.filter(function (item) {
          return item.purpose === "describing";
        })[0].value);
        $content.append("<br>");
        $content.append("<b>Tags: </b> " + annotation.tags.join(", "));
        $content.append("<br>");
        $panel.append($content);
        $panel.appendTo(annotator.$annotationList); // console.log($panel);
  
        return $panel;
      }
    }]);
  
    return IndexContainer;
  }();
  
  exports.IndexContainer = IndexContainer;
  
  },{"../../utils/time.js":22,"sha1":118}],7:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.InfoContainer = void 0;
  
  var _time = require("../../utils/time.js");
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var sha1 = require('sha1');
  
  var InfoContainer = /*#__PURE__*/function () {
    function InfoContainer(annotator) {
      _classCallCheck(this, InfoContainer);
  
      this.annotator = annotator;
      var container = $(".waldorf-info"); //if(container.length > 0){
      //    this.$container = container.first();
      //} else {
  
      this.$container = $("<div class='waldorf-info' aria-live='polite' aria-atomic='true'></div>").appendTo(this.annotator.$container); //}
    }
  
    _createClass(InfoContainer, [{
      key: "Rebuild",
      value: function Rebuild(annotations, clearContainer) {
        if (clearContainer) this.$container.empty();
        if (this.annotator.unrenderer) this.annotator.unrenderer(this.annotator); // let plural = annotations.length == 1 ? "" : "s";
        // let totalAnnotations = this.annotator.annotationManager.annotations.length;
        // this.$container.html(`<p>Showing ${annotations.length} annotation${plural} (${totalAnnotations} total).</p>`);
        // Add each annotation to the readout
  
        var renderer = this.annotator.renderer === false ? this.MakeContainer : this.annotator.renderer;
  
        for (var i = 0; i < annotations.length; i++) {
          this.$container.append(renderer(this.annotator, annotations[i], i));
        }
      }
    }, {
      key: "MakeContainer",
      value: function MakeContainer(annotator, annotation, index) {
        var $panel = $("<p></p>").appendTo($("<div></div>").appendTo(annotator.$container)); //let text = JSON.stringify(annotation.AsOpenAnnotation(), null, 2);
        // Add clickable header that brings up the edit interface.
  
        var $header = $("<b>Annotation ".concat(index + 1, ":</b><br>"));
  
        if (annotator.kioskMode == false) {
          $header = $("<a href='' title='Edit Annotation'><b>Annotation ".concat(index + 1, ":</b><br></a>"));
          $header.click(function (event) {
            event.preventDefault();
            annotator.gui.BeginEditing(annotation);
          });
        }
  
        $panel.append($header);
        var $content = $("<p></p>");
  
        if ('undefined' == typeof annotation.items) {
          // Version 1
          var annotation_body = annotation.body.filter(function (item) {
            return item.purpose === "describing";
          })[0];
          var annotation_creator = annotation.creator != null ? annotation.creator : {};
        } else {
          // Version 2
          var annotation_body = annotation.items[0].items[0].items[0].body.filter(function (item) {
            return item.purpose === "describing";
          })[0];
          var annotation_creator = annotation.items[0].items[0].items[0].creator;
        }
  
        $content.append("<b>Text: </b> " + annotation_body.value);
        $content.append("<br>");
        $content.append("<b>Tags: </b> " + annotation.tags.join(", "));
        $content.append("<br>");
        $content.append("<b>Time: </b> " + (0, _time.GetFormattedTime)(annotation.beginTime) + " - " + (0, _time.GetFormattedTime)(annotation.endTime));
        $content.append("<br>");
        $content.append("<b>Submitter:</b> " + ('undefined' != typeof annotation_creator.nickname && annotation_creator.nickname.length ? annotation_creator.nickname : "<i>Not available</i>")); //$paragraph.append("<strong>Annotation " + (index + 1) + ":</strong><br><pre>" + text.escapeHTML() + "</pre>");
  
        $panel.append($content);
        return $panel;
      }
    }]);
  
    return InfoContainer;
  }();
  
  exports.InfoContainer = InfoContainer;
  
  },{"../../utils/time.js":22,"sha1":118}],8:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.MessageOverlay = void 0;
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var MessageOverlay = /*#__PURE__*/function () {
    function MessageOverlay(annotator) {
      _classCallCheck(this, MessageOverlay);
  
      this.annotator = annotator;
      this.$container = $("<div class='waldorf-message-overlay'></div>");
      this.$container.appendTo(this.annotator.player.$container);
      this.$text = $("<p role='alert' aria-live='assertive' aria-atomic='true'></p>").appendTo(this.$container);
      this.$container.fadeOut(0);
    }
  
    _createClass(MessageOverlay, [{
      key: "ShowError",
      value: function ShowError(message) {
        var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 3.0;
        this.$container.addClass("waldorf-message-overlay-error");
  
        this._ShowText(message, duration);
      }
    }, {
      key: "ShowMessage",
      value: function ShowMessage(message) {
        var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5.0;
        this.$container.removeClass("waldorf-message-overlay-error");
  
        this._ShowText(message, duration);
      }
    }, {
      key: "_ShowText",
      value: function _ShowText(message) {
        var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 5.0;
        this.$text.html(message); //this.$container.stop(true, true);
  
        this.$container.finish();
        this.$container.fadeIn(0).delay(duration * 1000).fadeOut(400);
      }
    }]);
  
    return MessageOverlay;
  }();
  
  exports.MessageOverlay = MessageOverlay;
  
  },{}],9:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.PolygonEditor = void 0;
  
  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
  
  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
  
  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  /**
   * Manages the creating or editing of a single polygon on the video.
   * Consists of a toolbar, an overlay, and the polygon inside the overlay.
   *
   * Click to place or remove a draggable point. Points should be
   * put down in clockwise order.
   */
  var PolygonEditor = /*#__PURE__*/function () {
    function PolygonEditor(annotator) {
      var _this = this;
  
      _classCallCheck(this, PolygonEditor);
  
      this.annotator = annotator;
      this.baseZ = 2147483649;
      this.$breadcrumbs = [];
      this.$vertices = {
        'start': [],
        'stop': []
      }; //arrays of vertices for start/stop polys
  
      this.$polygons = {
        'start': null,
        'stop': null
      }; //DOM nodes for the actual polygons
      // this.$tempBreadCrumbs = [];
  
      this.$startStop = null; // Create the video overlay
  
      this.$clickSurface = $("<div class='waldorf-edit-overlay waldorf-vp-click-surface'></div>").appendTo(this.annotator.player.$container); //this.$clickSurface.css("z-index", this.baseZ);
  
      this.$clickSurface.click(function (event) {
        _this.OnSurfaceClick(event);
      }); // Initialize the polygon DOM nodes
      // this.$polygons.start = $("<div class='waldorf-start-poly'></div>").appendTo(this.$clickSurface);
  
      this.$polygons.start = $("<div class='waldorf-start-poly'></div>").appendTo(this.annotator.polyOverlay.$videoOverlay);
      this.$polygons.start.css("z-index", this.baseZ + 1); // this.$polygons.stop = $("<div class='waldorf-stop-poly'></div>").appendTo(this.$clickSurface);
  
      this.$polygons.stop = $("<div class='waldorf-stop-poly'></div>").appendTo(this.annotator.polyOverlay.$videoOverlay);
      this.$polygons.stop.css("z-index", this.baseZ + 1);
      this.ResizeOverlay();
      this.annotator.player.$container.on("OnFullscreenChange", function (event, setFullscreen) {
        return _this.ResizeOverlay();
      });
      /* 
      * new UI
      */
  
      this.$editDialog = $("<div id='edit-dialog' class='waldorf-edit-overlay waldorf-vp-click-surface'></div>").appendTo(this.annotator.player.$container);
      this.$editDialog.draggable();
      this.$editDialog.css('z-index', this.baseZ + 100);
      this.$editDialog.click(function (event) {
        _this.OnSurfaceClick(event);
      });
      this.$space = $("<div>&nbsp;</div><hr>");
      this.RegisterElement(this.$space, this.$editDialog, 1, 'flex-end'); // Create undo button
  
      this.$undoButton = $("<button>Remove Last Point</button>").button({
        icon: "fa fa-undo",
        showLabel: false
      });
      this.$undoButton.css("margin", "0px 5px 4px 5px");
      this.$undoButton.attr('title', "Remove last point");
      this.$undoButton.css('z-index', this.baseZ + 105);
      this.$undoButton.click(function () {
        _this.RemoveLastBreadcrumb();
      });
      this.RegisterElement(this.$undoButton, this.$editDialog, 1, 'flex-end'); // Make "Collect Polygon state" button
  
      this.$capPolyButton = $("<button>Capture Polygon</button>").button({
        icon: "fa fa-camera-retro",
        showLabel: false
      }).click(function () {
        _this.AddPolygonSet();
      });
      this.$capPolyButton.css("margin", "0px 5px 4px 5px");
      this.$capPolyButton.attr('title', "Capture Polygon");
      this.$capPolyButton.css('z-index', this.baseZ + 105);
      this.RegisterElement(this.$capPolyButton, this.$editDialog, 1, 'flex-end'); // Create the cancel button
  
      this.$cancelButton = $("<button>Stop polygon editing</button>").button({
        icon: "fa fa-remove",
        showLabel: false
      });
      this.$cancelButton.css("margin", "0px 5px 4px 5px");
      this.$cancelButton.addClass("waldorf-cancel-button");
      this.$cancelButton.attr('title', "Stop Polygon Editing");
      this.$cancelButton.click(function () {
        //Restore the original state
        //this.Restore();
        _this.RemoveAllBreadcrumbs();
  
        _this.annotator.$container.trigger("OnPolygonEditingEnded");
  
        _this.Done();
      });
      this.RegisterElement(this.$cancelButton, this.$editDialog, 2, 'flex-end');
      $(window).resize(function () {
        return _this.ResizeOverlay();
      });
      this.Done();
    }
  
    _createClass(PolygonEditor, [{
      key: "OnSurfaceClick",
      value: function OnSurfaceClick(event) {
        if ($(event.currentTarget).attr("id") == "edit-dialog" || this.$startStop != "start") {
          return;
        } // Add a breadcrumb on click, but only for the start polygon. End vertices can only be dragged
  
  
        var target = $(event.currentTarget);
        var x = event.pageX - target.offset().left;
        var y = event.pageY - target.offset().top;
        var xPercent = x / target.width() * 100;
        var yPercent = y / target.height() * 100;
        this.AddBreadcrumb(xPercent, yPercent); //this.newPolyPoints.push([xPercent.toFixed(3), yPercent.toFixed(3)]);
  
        this.UpdatePolyClipping();
      }
      /**
       * Creates a new breadcrumb at the given (x, y) point on the
       * clickSurface, where x and y are percentages from 0 to 100.
       */
  
    }, {
      key: "AddBreadcrumb",
      value: function AddBreadcrumb(xPercent, yPercent) {
        var _this2 = this;
  
        var $breadcrumb = $("<div class='breadcrumb'></div>");
        $breadcrumb.appendTo(this.$clickSurface);
        $breadcrumb.css("position", "absolute"); // Percentage representations of breadcrumb width and height
  
        var offPercentX = $breadcrumb.outerWidth() / this.$clickSurface.width() * 100;
        var offPercentY = $breadcrumb.outerHeight() / this.$clickSurface.height() * 100; // Percentage representations of breadcrumb width and height
  
        $breadcrumb.css("left", (xPercent - offPercentX / 2).toString() + "%");
        $breadcrumb.css("top", (yPercent - offPercentY / 2).toString() + "%"); //$breadcrumb.css("z-index", this.baseZ - 50);
  
        $breadcrumb.draggable({
          //containment: "parent",
          drag: function drag() {
            // Recalculate percentages (mangled by jQuery UI draggable code)
            // See http://stackoverflow.com/a/23673462
            var l = 100 * parseFloat($breadcrumb.css("left")) / parseFloat($breadcrumb.parent().css("width")) + "%";
            var t = 100 * parseFloat($breadcrumb.css("top")) / parseFloat($breadcrumb.parent().css("height")) + "%";
            $breadcrumb.css("left", l);
            $breadcrumb.css("top", t);
  
            _this2.UpdatePolyClipping();
          }
        });
  
        if (this.$startStop == "start") {
          //breadcrumbs can only be added or removed in the first polygon
          $breadcrumb.click(function (event) {
            // Remove the breadcrumb on click
            event.stopPropagation();
            $breadcrumb.remove();
  
            _this2.$breadcrumbs.splice(_this2.$breadcrumbs.indexOf($breadcrumb), 1);
  
            _this2.UpdatePolyClipping();
  
            _this2.UpdateBreadcrumbColoring();
          });
        }
  
        this.$breadcrumbs.push($breadcrumb); //this.UpdatePolyClipping();
  
        this.UpdateBreadcrumbColoring();
      }
      /**
       * Removes the last-placed breadcrumb from the list
       * and updates the view.
       */
  
    }, {
      key: "RemoveLastBreadcrumb",
      value: function RemoveLastBreadcrumb() {
        var $removed = this.$breadcrumbs.pop();
        $removed.remove();
        this.UpdatePolyClipping();
        this.UpdateBreadcrumbColoring();
      }
    }, {
      key: "RemoveAllBreadcrumbs",
      value: function RemoveAllBreadcrumbs() {
        while (this.$breadcrumbs.length > 0) {
          this.RemoveLastBreadcrumb();
        }
      }
      /**
       * Gets the center of the breadcrumb as an (x, y) pair
       * representing the percentage distance from the top and left
       * of the click surface (0% - 100%).
       */
  
    }, {
      key: "GetCenterPercentage",
      value: function GetCenterPercentage($breadcrumb) {
        var topPercent = $breadcrumb.position().top / $breadcrumb.parent().height() * 100;
        var leftPercent = $breadcrumb.position().left / $breadcrumb.parent().width() * 100; // Percentage values for the dimensions of the breadcrumb relative to the click surface
  
        var offPercentX = $breadcrumb.outerWidth() / $breadcrumb.parent().width() * 100;
        var offPercentY = $breadcrumb.outerHeight() / $breadcrumb.parent().height() * 100;
        return {
          x: leftPercent + offPercentX / 2.0,
          y: topPercent + offPercentY / 2.0
        };
      }
    }, {
      key: "Reset",
      value: function Reset() {
        // Remove all breadcrumbs
        var _iterator = _createForOfIteratorHelper(this.$breadcrumbs),
            _step;
  
        try {
          for (_iterator.s(); !(_step = _iterator.n()).done;) {
            var $breadcrumb = _step.value;
            $breadcrumb.remove();
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }
  
        this.$breadcrumbs = [];
      }
    }, {
      key: "ResetPolygons",
      value: function ResetPolygons() {
        if (this.$polygons.start) {
          this.$polygons.start.makeVisible(false);
          this.$polygons.start.css("clip-path", "");
        }
  
        if (this.$polygons.stop) {
          this.$polygons.stop.makeVisible(false);
          this.$polygons.stop.css("clip-path", "");
        }
  
        this.$vertices = {
          'start': [],
          'stop': []
        };
        this.UpdatePolyClipping();
        this.RemoveAllBreadcrumbs();
      }
    }, {
      key: "Restore",
      value: function Restore() {
        this.InitPoly(this.originalJSON[0], this.originalJSON[1]);
      }
    }, {
      key: "InitPoly",
      value: function InitPoly(startPoints, stopPoints) {
        this.Reset();
        if (startPoints != null) this.$vertices.start = startPoints;
        if (startPoints != null && stopPoints == null) this.$vertices.stop = startPoints;
        if (stopPoints != null) this.$vertices.stop = stopPoints;
        this.UpdatePolyClipping();
        this.originalJSON = [startPoints, stopPoints];
      }
    }, {
      key: "DrawPolygons",
      value: function DrawPolygons() {
        var _this3 = this;
  
        this.RemoveAllBreadcrumbs();
  
        if (this.$vertices.start != []) {
          //let startPolygon = this.$vertices.start; //.map(item => { return `${item[0]},${item[1]}` }).join(" ");;
          // Create the poly objects
          // this.$polygons.start = $("<div class='waldorf-start-poly'></div>").appendTo(this.$clickSurface);
          // this.$polygons.start.css("z-index", this.baseZ + 1000);
          if (this.$vertices.start.length < 3) {
            this.$polygons.start.makeVisible(false);
            this.$polygons.start.clipPath([], {
              svgDefId: 'annotatorStartPolySvg'
            });
          } else {
            this.$polygons.start.makeVisible(true);
            this.$polygons.start.clipPath(this.$vertices.start, {
              isPercentage: true,
              svgDefId: 'annotatorStartPolySvg'
            });
  
            if (this.$startStop == "start") {
              this.$vertices.start.map(function (point) {
                _this3.AddBreadcrumb(point[0], point[1]);
              });
            }
          }
        }
  
        if (this.$vertices.stop != []) {
          if (this.$vertices.stop.length < 3) {
            this.$polygons.stop.clipPath([], {
              svgDefId: 'annotatorStopPolySvg'
            });
          } else {
            this.$polygons.stop.makeVisible(true);
            this.$polygons.stop.clipPath(this.$vertices.stop, {
              isPercentage: true,
              svgDefId: 'annotatorStopPolySvg'
            });
  
            if (this.$startStop == "stop") {
              this.$vertices.stop.map(function (point) {
                _this3.AddBreadcrumb(point[0], point[1]);
              });
            }
          }
        }
      }
    }, {
      key: "UpdatePolyClipping",
      value: function UpdatePolyClipping() {
        var _this4 = this;
  
        if (this.$startStop == null) return;
        var svgId = this.$startStop == "start" ? "annotatorStartPolySvg" : "annotatorStopPolySvg";
  
        if (this.$breadcrumbs.length < 3) {
          this.$polygons[this.$startStop].makeVisible(false);
          this.$polygons[this.$startStop].clipPath([], {
            svgDefId: svgId
          });
        } else {
          var points = this.$breadcrumbs.map(function ($crumb) {
            var pos = _this4.GetCenterPercentage($crumb);
  
            return [pos.x, pos.y];
          });
          this.$polygons[this.$startStop].makeVisible(true);
          this.$polygons[this.$startStop].clipPath(points, {
            isPercentage: true,
            svgDefId: svgId
          });
        }
      }
    }, {
      key: "UpdateBreadcrumbColoring",
      value: function UpdateBreadcrumbColoring() {
        for (var i = 0; i < this.$breadcrumbs.length; i++) {
          var $crumb = this.$breadcrumbs[i]; // Recolor each breadcrumb
  
          var color = "#000000";
  
          if (i == this.$breadcrumbs.length - 1) {
            color = "#FF0000";
          } else if (i == 0) {
            color = "#00FF00";
          }
  
          this.$breadcrumbs[i].css("border-color", color);
        }
      }
      /**
       * Gets an array of percentages representing the x and y percentages of each
       * point in the polygon.
       */
  
    }, {
      key: "GetJSON",
      value: function GetJSON() {
        // Extract the coordinates from the crumbs and put them in the array
        var points = [];
  
        var _iterator2 = _createForOfIteratorHelper(this.$breadcrumbs),
            _step2;
  
        try {
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
            var crumb = _step2.value;
            var point = this.GetCenterPercentage(crumb);
            points.push([point.x.toString(), point.y.toString()]);
          }
        } catch (err) {
          _iterator2.e(err);
        } finally {
          _iterator2.f();
        }
  
        return JSON.stringify(points);
      }
      /**
       * Gets an array of percentages representing the x and y percentages of each
       * point in the polygon.
       */
  
    }, {
      key: "GetPoints",
      value: function GetPoints() {
        var points = [];
  
        var _iterator3 = _createForOfIteratorHelper(this.$breadcrumbs),
            _step3;
  
        try {
          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
            var crumb = _step3.value;
            var point = this.GetCenterPercentage(crumb);
            points.push([point.x, point.y]);
          }
        } catch (err) {
          _iterator3.e(err);
        } finally {
          _iterator3.f();
        }
  
        return points;
      }
      /**
       * Determines if all start vertices match stop vertices
       * returns true if the vertices don't match exactly
       */
  
    }, {
      key: "IsAnimated",
      value: function IsAnimated() {
        var comp = this.$vertices.start;
        var startString = JSON.stringify(comp);
        comp = this.$vertices.stop;
        var stopString = JSON.stringify(comp);
        return JSON.stringify(startString) != JSON.stringify(stopString);
      }
    }, {
      key: "BeginEditing",
      value: function BeginEditing(startStop) {
        this.$startStop = startStop; //startStop is either 'start' or 'stop', depending on which polygon is being edited
  
        this.$clickSurface.makeVisible(true);
        this.$editDialog.makeVisible(true);
        this.$polygons.start.makeVisible(false);
        this.$polygons.stop.makeVisible(false); //-3//this.$bar.makeVisible(true);
  
        this.DrawPolygons();
        this.UpdatePolyClipping();
        if (typeof this.annotator.tickbar != 'undefined') this.annotator.tickbar.Hide();
        this.annotator.player.SetVisible(false);
      }
    }, {
      key: "Done",
      value: function Done() {
        this.$clickSurface.makeVisible(false);
        this.$editDialog.makeVisible(false);
        this.$polygons.start.makeVisible(false);
        this.$polygons.stop.makeVisible(false);
        if (typeof this.annotator.tickbar != 'undefined') this.annotator.tickbar.Show();
        this.annotator.player.SetVisible(true);
      }
    }, {
      key: "ResizeOverlay",
      value: function ResizeOverlay() {
        // Resize video overlay to fit actual video dimensions
        var videoDims = this.annotator.player.GetVideoDimensions();
        this.$clickSurface.css('width', videoDims.width);
        this.$clickSurface.css('height', videoDims.height);
        var heightDiff = (this.annotator.player.$video.height() - videoDims.height) / 2;
        this.$clickSurface.css('top', heightDiff);
        var widthDiff = (this.annotator.player.$video.width() - videoDims.width) / 2;
        this.$clickSurface.css('left', widthDiff);
        this.$polygons.start.width(videoDims.width);
        this.$polygons.start.height(videoDims.height);
        this.$polygons.start.css("top", heightDiff);
        this.$polygons.start.css("left", widthDiff);
        this.$polygons.start.css("position", "absolute");
        this.$polygons.start.makeVisible(false);
        this.$polygons.stop.width(videoDims.width);
        this.$polygons.stop.height(videoDims.height);
        this.$polygons.stop.css("top", heightDiff);
        this.$polygons.stop.css("left", widthDiff);
        this.$polygons.stop.css("position", "absolute");
        this.$polygons.stop.makeVisible(false);
      }
    }, {
      key: "RegisterElement",
      value: function RegisterElement($element, $container, order) {
        var justification = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : 'flex-start';
        $element.css('order', order);
        $element.css('align-self', justification); // Sets grow [shrink] [basis]
        //$element.css('flex', '0 0 auto');
  
        $container.append($element);
      }
    }, {
      key: "ShowJustPolygon",
      value: function ShowJustPolygon() {
        this.DrawPolygons();
      }
    }, {
      key: "AddPolygonSet",
      value: function AddPolygonSet() {
        //This is saving a set of breadcrumbs into the vertices for a polygon
        this.$vertices[this.$startStop] = this.GetPoints();
  
        if (this.$startStop == "start" && this.$vertices.stop.length != this.$vertices.start.length) {
          this.$vertices.stop = this.GetPoints();
        }
  
        this.RemoveAllBreadcrumbs();
        this.annotator.messageOverlay.ShowMessage("Captured " + this.$startStop + " polygon."); // if (this.$vertices.length > 1) {
        //     this.$polygons = [];
        //     this.$tempBreadCrumbs = [];
        // }
        // if (!this.$polygons.length) {
        //     this.$polygons.start = this.GetPoints();
        //     this.$tempBreadCrumbs[0] = [this.$breadcrumbs];
        //     var msg = "Successfully captured first polygon.";
        // } else {
        //     this.$polygons.stop = this.GetPoints();
        //     this.$tempBreadCrumbs[1] = [this.$breadcrumbs];
        //     var msg = "Successfully captured second polygon.";
        // } 
  
        this.annotator.$container.trigger("OnPolygonEditingEnded");
        this.Done();
        this.ShowJustPolygon();
      }
    }]);
  
    return PolygonEditor;
  }();
  
  exports.PolygonEditor = PolygonEditor;
  
  },{}],10:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.PolygonOverlay = void 0;
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var PolygonOverlay = /*#__PURE__*/function () {
    function PolygonOverlay(annotator) {
      var _this = this;
  
      _classCallCheck(this, PolygonOverlay);
  
      this.annotator = annotator;
      this.polyElements = [];
      this.svgElements = [];
      this.animateElements = [];
      this.baseZ = 2147483649;
      this.lastAnnotations = [];
      this.svgElementsHash = {}; // Create the video overlay
  
      this.$videoOverlay = $("<div class='waldorf-video-overlay'></div>").appendTo(this.annotator.player.$container);
      this.ResizeOverlay();
      this.annotator.player.$container.on("OnFullscreenChange", function (event, setFullscreen) {
        return _this.ResizeOverlay();
      });
      this.annotator.$container.on("OnNewAnnotationSet", function (event, annotations) {
        return _this.Update(annotations);
      });
      this.videoDims = this.annotator.player.GetVideoDimensions();
      $(window).resize(function () {
        return _this.ResizeOverlay();
      });
    }
  
    _createClass(PolygonOverlay, [{
      key: "Update",
      value: function Update(annotations) {
        this.Clear(); // let prevSet = new Set(this.lastAnnotations);
        // let newSet = new Set(annotations);
        // // in newSet and not in prevSet
        // let toAdd = new Set(
        //     [...newSet].filter(x => !prevSet.has(x)));
        // // in prevAnnotations and not in annotations
        // let toDestroy = new Set(
        //     [...prevSet].filter(x => !newSet.has(x)));
        // console.log(Array.from(toAdd));
        // console.log(Array.from(toDestroy));
        //Sort polygon order by size (ascending)
        // polygons.sort(function(a, b) {
        //     return this.GetArea(a) > this.GetArea(b);
        // })
  
        for (var i = 0; i < annotations.length; i++) {
          var annotationPolyPoints = annotations[i].getPoly();
  
          if (annotationPolyPoints == null) {
            // Ignore this annotation if it has no polygon
            continue;
          }
  
          var svgPolyPoints = annotations[i].getSVGPolyPoints();
          var duration = annotations[i].endTime - annotations[i].beginTime; // Create the poly object
  
          var $svg = void 0;
  
          if (this.svgElements.length == 0) {
            $svg = document.createElementNS("http://www.w3.org/2000/svg", "svg");
            $svg.setAttribute('width', '100%');
            $svg.setAttribute('height', '100%');
            $svg.setAttribute('viewBox', '0 0 100 100');
            $svg.setAttribute('preserveAspectRatio', 'none'); //$svg.addEventListener("click", this.ClickEvent);
  
            this.$videoOverlay.append($svg);
            this.svgElements.push($svg);
          } else {
            $svg = this.svgElements[0];
          }
  
          var $polygon = document.createElementNS('http://www.w3.org/2000/svg', 'polygon');
          $polygon.setAttribute('points', svgPolyPoints[0]);
          $polygon.setAttribute('fill', 'rgba(0, 118, 255, 0.55)');
          $svg.appendChild($polygon);
          var $animate = document.createElementNS('http://www.w3.org/2000/svg', 'animate');
          $animate.setAttribute('attributeName', 'points');
          $animate.setAttribute('fill', 'freeze');
          $animate.setAttribute('from', svgPolyPoints[0]);
          $animate.setAttribute('to', svgPolyPoints[1]);
          $animate.setAttribute('begin', 'indefinite');
          $animate.setAttribute('dur', duration + "s");
          $polygon.appendChild($animate);
          var $svgHash = {
            svgElement: $svg,
            polygon: $polygon,
            animate: $animate,
            beginTime: annotations[i].beginTime
          };
          this.svgElementsHash[annotations[i].id] = $svgHash; // Create the poly object
          // let $poly = $("<div class='waldorf-overlay-poly'></div>").appendTo(this.$videoOverlay);
          // $poly.clipPath(annotationPolyPoints, {
          //     isPercentage: true,
          //     svgDefId: 'annotatorPolySvg'
          // });
          // $poly.click(() => {
          //     this.annotator.$container.trigger("OnPolyClicked", annotations[i]);
          // });
          // this.AddTooltip($poly, annotations[i]);
          // this.polyElements.push($poly);
  
          this.polyElements.push($polygon);
          this.animateElements.push($animate);
        } //this.lastAnnotations = annotations;
  
      }
    }, {
      key: "ClickEvent",
      value: function ClickEvent(event) {
        console.log("animate is clicked");
      }
    }, {
      key: "AddTooltip",
      value: function AddTooltip($poly, annotation) {
        $.fn.qtip.zindex = this.baseZ + 1;
        $poly.qtip({
          content: {
            title: annotation.id,
            text: annotation.body.filter(function (item) {
              return item.purpose === "describing";
            })[0].value
          },
          position: {
            my: 'bottom right',
            at: 'top left',
            target: 'mouse',
            // Follow the mouse
            adjust: {
              mouse: true,
              method: "shift shift" // horizontal, vertical
  
            },
            viewport: this.annotator.player.$container
          },
          hide: {
            delay: 0 // No hide delay by default
  
          },
          style: {
            classes: 'qtip-dark qtip-rounded annotator-qtip'
          }
        });
      }
    }, {
      key: "Clear",
      value: function Clear() {
        // Clear all  animate element from the DOM
        for (var ai = 0; ai < this.animateElements.length; ai++) {
          //this.polyElements[i].data("qtip").destroy(true);
          this.animateElements[ai].remove();
        } // Clear all polygons 
  
  
        for (var pi = 0; pi < this.polyElements.length; pi++) {
          this.polyElements[pi].remove();
        } // Clear all  svg elements from the DOM
  
  
        for (var si = 0; si < this.svgElements.length; si++) {
          this.svgElements[si].remove();
        } // Mark the array as empty
  
  
        this.animateElements = [];
        this.polyElements = [];
        this.svgElements = [];
        this.svgElementsHash = {};
      }
    }, {
      key: "ResizeOverlay",
      value: function ResizeOverlay() {
        // Resize video overlay to fit actual video dimensions
        var videoDims = this.annotator.player.GetVideoDimensions();
        this.$videoOverlay.css('width', videoDims.width);
        this.$videoOverlay.css('height', videoDims.height);
        var heightDiff = (this.annotator.player.$video.height() - videoDims.height) / 2;
        this.$videoOverlay.css('top', heightDiff);
        var widthDiff = (this.annotator.player.$video.width() - videoDims.width) / 2;
        this.$videoOverlay.css('left', widthDiff);
      }
    }, {
      key: "getPlayerSize",
      value: function getPlayerSize() {
        return this.annotator.player.GetVideoDimensions();
      }
    }]);
  
    return PolygonOverlay;
  }();
  
  exports.PolygonOverlay = PolygonOverlay;
  
  },{}],11:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.TickBar = void 0;
  
  function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, 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 normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it["return"] != null) it["return"](); } finally { if (didErr) throw err; } } }; }
  
  function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
  
  function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var TickBar = /*#__PURE__*/function () {
    function TickBar(annotator) {
      var _this = this;
  
      _classCallCheck(this, TickBar);
  
      this.annotator = annotator;
      this.ticks = []; // Create the element
  
      this.$tickBar = $("<div class='waldorf-tickbar'></div>");
      this.annotator.player.controlBar.$container.append(this.$tickBar); // Attach event handlers
  
      this.annotator.$container.on("OnAnnotationsLoaded", function (event, annotationManager) {
        return _this.LoadAnnotations(annotationManager);
      });
      this.annotator.$container.on("OnAnnotationRegistered", function (event, annotation) {
        return _this.LoadAnnotation(annotation);
      });
      this.annotator.$container.on("OnAnnotationRemoved", function (event, id) {
        return _this.RemoveAnnotation(id);
      });
    }
  
    _createClass(TickBar, [{
      key: "LoadAnnotations",
      value: function LoadAnnotations(annotationManager) {
        this.Clear();
  
        var _iterator = _createForOfIteratorHelper(annotationManager.annotations),
            _step;
  
        try {
          for (_iterator.s(); !(_step = _iterator.n()).done;) {
            var annotation = _step.value;
            this.LoadAnnotation(annotation);
          }
        } catch (err) {
          _iterator.e(err);
        } finally {
          _iterator.f();
        }
      }
    }, {
      key: "LoadAnnotation",
      value: function LoadAnnotation(annotation) {
        var $tick = $("<div class='waldorf-tickbar-tick'></div>").appendTo(this.$tickBar); // Add the ID of the annotation to its corresponding tick so we can reference it later
  
        if ('undefined' == typeof annotation.items) {
          // Ver 1
          $tick.data("annotation-id", annotation.id);
        } else {
          // Ver 2
          $tick.data("annotation-id", annotation.items[0].items[0].items[0].id);
        }
  
        var beginTime = annotation.beginTime;
        var beginPercent = beginTime / this.annotator.player.videoElement.duration;
        $tick.css('left', (beginPercent * 100).toString() + "%");
        var endTime = annotation.endTime;
        var endPercent = endTime / this.annotator.player.videoElement.duration;
        $tick.css('width', ((endPercent - beginPercent) * 100).toString() + "%");
        this.ticks.push($tick);
      }
    }, {
      key: "RemoveAnnotation",
      value: function RemoveAnnotation(id) {
        //console.log("Removing tick " + id);
        // Remove the object from the document, and the array
        var newTicks = [];
  
        var _iterator2 = _createForOfIteratorHelper(this.ticks),
            _step2;
  
        try {
          for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {
            var $tick = _step2.value;
  
            // console.log('Tick: ' + $tick.data("annotation-id"));
            if ($tick.data("annotation-id") == id) {
              // console.log(`Removed tick ${id}`);
              $tick.remove();
            } else {
              newTicks.push($tick);
            }
          }
        } catch (err) {
          _iterator2.e(err);
        } finally {
          _iterator2.f();
        }
  
        this.ticks = newTicks;
      }
    }, {
      key: "Hide",
      value: function Hide() {
        this.$tickBar.hide();
      }
    }, {
      key: "Show",
      value: function Show() {
        this.$tickBar.show();
      }
    }, {
      key: "Clear",
      value: function Clear() {
        var _iterator3 = _createForOfIteratorHelper(this.ticks),
            _step3;
  
        try {
          for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {
            var $tick = _step3.value;
            $tick.remove();
          }
        } catch (err) {
          _iterator3.e(err);
        } finally {
          _iterator3.f();
        }
  
        this.ticks = [];
      }
    }]);
  
    return TickBar;
  }();
  
  exports.TickBar = TickBar;
  
  },{}],12:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.ServerInterface = void 0;
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var sha1 = require('sha1');
  
  var ServerInterface = /*#__PURE__*/function () {
    function ServerInterface(annotator) {
      _classCallCheck(this, ServerInterface);
  
      this.annotator = annotator; //localStorage.removeItem('waldorf_auth_token');
    }
  
    _createClass(ServerInterface, [{
      key: "SetBaseURL",
      value: function SetBaseURL(url) {
        this.baseURL = url;
      }
    }, {
      key: "make_base_auth",
      value: function make_base_auth(user, password) {
        var tok = user + ':' + password;
        var hash = btoa(tok);
        return 'Basic ' + hash;
      }
    }, {
      key: "make_write_auth",
      value: function make_write_auth(text) {
        if (this.annotator.apiKey) {
          return 'ApiKey ' + text;
        } else {
          return 'Token ' + text;
        }
      }
    }, {
      key: "LoggedIn",
      value: function LoggedIn() {
        if (this.annotator.apiKey) {
          // Return true if an email has been entered
          var user_email = localStorage.getItem('waldorf_user_email');
          return user_email !== null;
        } else {
          // Return true if a token has been registered
          var auth_token = localStorage.getItem('waldorf_auth_token');
          return auth_token !== null;
        }
      }
    }, {
      key: "LogIn",
      value: function LogIn(username, password) {
        var _this = this;
  
        // If API key is used, just store the email address
        if (this.annotator.apiKey) {
          console.log("[Server Interface] Successfully logged in.");
          localStorage.setItem('waldorf_user_email', password);
          localStorage.setItem('waldorf_user_name', username);
          this.annotator.messageOverlay.ShowMessage("Logged in as " + username);
          return $.Deferred().resolve();
        }
  
        return $.ajax({
          url: this.baseURL + "/api/login",
          type: "POST",
          async: true,
          context: this,
          beforeSend: function beforeSend(xhr) {
            xhr.setRequestHeader('Authorization', this.make_base_auth(username, password));
          }
        }).done(function (data) {
          console.log("[Server Interface] Successfully logged in.");
          localStorage.setItem('waldorf_auth_token', data.auth_token);
        }).fail(function (response) {
          console.error("[Server Interface] Could not log in.");
  
          _this.annotator.messageOverlay.ShowError("Could not log in!");
        });
      }
    }, {
      key: "LogOut",
      value: function LogOut() {
        // If API key is used, just remove the email from local storage.
        if (this.annotator.apiKey) {
          console.log("[Server Interface] Successfully logged out.");
          localStorage.removeItem('waldorf_user_email');
          localStorage.removeItem('waldorf_user_name');
          return $.Deferred().resolve();
        }
  
        return $.ajax({
          url: this.baseURL + "/api/logout",
          type: "DELETE",
          async: true,
          context: this,
          beforeSend: function beforeSend(xhr) {
            var auth_token = localStorage.getItem('waldorf_auth_token') || "";
            console.log("[Server Interface] token: ".concat(auth_token));
            xhr.setRequestHeader('Authorization', this.make_write_auth(auth_token));
          }
        }).done(function (data) {
          console.log("[Server Interface] Successfully logged out.");
          localStorage.removeItem('waldorf_auth_token');
        }).fail(function (response) {
          console.error("[Server Interface] Could not log out.");
          localStorage.removeItem('waldorf_auth_token');
        });
      }
    }, {
      key: "FetchAnnotations",
      value: function FetchAnnotations(searchKey, searchParam) {
        //This is replaced by this.baseURL, which is defined in config
        //var book_url = 'http://scalar.usc.edu/dev/semantic-annotation-tool/';  // This will be defined in the Book's JS
        //https://scalar.usc.edu/dev/semantic-annotation-tool/rdf/file/media/Inception%20Corgi%20Flop.mp4?format=oac&prov=1&rec=2
        // var ajax_url = this.baseURL + 'rdf/file/' + searchParam.replace(this.baseURL, '') + '?format=oac&prov=1&rec=2';
        var ajax_url = this.baseURL + 'rdf/file/' + searchParam.replace(this.baseURL, '') + '?format=iiif&prov=1&rec=2'; //console.log("ajax_url: " + ajax_url);
  
        return $.ajax({
          url: ajax_url,
          type: "GET",
          jsonp: "callback",
          dataType: "jsonp",
          async: true
        }).done(function (data) {
          console.log('[Server Interface] Fetched ' + ('undefined' == typeof data.items ? data.length - 1 : data.items[0].items.length) + ' annotations for ' + searchKey + ': "' + searchParam + '".');
        }).fail(function (response) {
          var returned_response = response.responseJSON.error.code[0].value + " : " + response.responseJSON.error.message[0].value;
          console.error('[Server Interface] Error fetching annotations for ' + searchKey + ': "' + searchParam + '"\n ' + returned_response);
  
          _this2.annotator.messageOverlay.ShowError('Could not retrieve annotations!<br>(' + returned_response + ')');
        });
      }
    }, {
      key: "PostAnnotation",
      value: function PostAnnotation(callback) {
        var _this3 = this;
  
        console.log("Posting annotation...");
        var annotation = this.annotator.gui.GetAnnotationObject();
        console.log(annotation);
        var key;
  
        if (this.annotator.apiKey) {
          key = this.annotator.apiKey; // let email_storage = localStorage.getItem('waldorf_user_email');
          // let name_storage = localStorage.getItem('waldorf_user_name');
          // if(name_storage == null) name_storage = email_storage;
        } else {
          key = localStorage.getItem('waldorf_auth_token');
        } // if(this.annotator.apiKey){
        //     if(annotation["creator"] == null) annotation["creator"] = {};
        //     annotation["creator"]["email"] = localStorage.getItem('waldorf_user_email');
        //     annotation["creator"]["nickname"] = localStorage.getItem('waldorf_user_name');
        // }
  
  
        if (annotation["annotation_version"] == "v1") {
          annotation["request"]["items"]["action"] = "add";
          delete annotation["items"];
        } else {
          annotation["service"][0]["items"]["action"] = "add";
          delete annotation["target"];
          delete annotation["body"];
        }
  
        delete annotation["annotation_version"];
        annotation["id"] = this.baseURL + "api/add";
        console.log("PostAnnotation payload: " + JSON.stringify(annotation));
        $.ajax({
          //url: this.baseURL + "/api/addAnnotation",
          url: this.baseURL + "api/add",
          type: "POST",
          dataType: 'json',
          // Necessary for Rails to see this data type correctly
          contentType: 'application/json',
          // Necessary for Rails to see this data type correctly
          data: JSON.stringify(annotation),
          // Stringify necessary for Rails to see this data type correctly
          async: true,
          context: this,
          beforeSend: function beforeSend(xhr) {
            xhr.setRequestHeader('Authorization', this.make_write_auth(key));
          },
          success: function success(data) {
            _this3.annotator.messageOverlay.ShowMessage("Successfully created new annotation."); //The callback expects the annotation in memory to be formatted like one from JSON,
            //so we need to reorganize things a bit. Note that this assume Scalar is the back end
            // console.log(data);
  
  
            var ids = $.map(data, function (e, k) {
              return k;
            }); //Need to remove Scalar's version ID, which is appended to the URL after a .
  
            var idParts = ids[0].split('.');
            idParts.pop();
            var newID = idParts.join('.'); // annotation.id = ids[0]; // Append the ID given by the response
  
            annotation.items[0].id = newID;
            annotation.items[0].items[0].id = newID; //these should be different, but irrelevant here
  
            annotation.items[0].items[0].items[0].id = newID; //these should be different, but irrelevant here
  
            if (callback) callback(annotation);
          },
          error: function error(response) {
            var returned_response = "undefined error while editing the annotation";
  
            if (response.responseJSON) {
              returned_response = response.responseJSON.error.code[0].value + " : " + response.responseJSON.error.message[0].value;
            }
  
            console.error("Could not edit the annotation! Message:\n ".concat(returned_response));
  
            _this3.annotator.messageOverlay.ShowError("Could not edit the annotation!<br>(".concat(returned_response, ")"));
          }
        });
      }
    }, {
      key: "EditAnnotation",
      value: function EditAnnotation(callback) {
        var _this4 = this;
  
        console.log("Editing annotation...");
        var annotation = this.annotator.gui.GetAnnotationObject();
        console.log(annotation);
        var key;
  
        if (this.annotator.apiKey) {
          key = this.annotator.apiKey; // let email_storage = localStorage.getItem('waldorf_user_email');
          // let name_storage = localStorage.getItem('waldorf_user_name');
          // if(name_storage == null) name_storage = email_storage;
        } else {
          key = localStorage.getItem('waldorf_auth_token');
        } // if(this.annotator.apiKey){
        //     if(annotation["creator"] == null) annotation["creator"] = {};
        //     annotation["creator"]["email"] = localStorage.getItem('waldorf_user_email');
        //     annotation["creator"]["nickname"] = localStorage.getItem('waldorf_user_name');
        // }
  
  
        if (annotation["annotation_version"] == "v1") {
          annotation["request"]["items"]["action"] = "update";
          delete annotation["items"];
        } else {
          annotation["service"][0]["items"]["action"] = "update";
          delete annotation["target"];
          delete annotation["body"];
        }
  
        delete annotation["annotation_version"];
        var oldID = '';
  
        if ('undefined' == typeof annotation.items) {
          // Version 1
          oldID = annotation.id;
        } else {
          // Version 2
          oldID = annotation.items[0].items[0].items[0].id;
        }
  
        console.log("Modifying annotation: " + oldID);
        $.ajax({
          url: this.baseURL + "api/update",
          type: "POST",
          dataType: 'json',
          contentType: 'application/json',
          data: JSON.stringify(annotation),
          async: true,
          context: this,
          beforeSend: function beforeSend(xhr) {
            xhr.setRequestHeader('Authorization', this.make_write_auth(key));
          },
          success: function success(data) {
            //console.log(annotation);
            // annotation.id = data.id; // Append the ID given by the response
            //console.log("Successfully edited the annotation. (ID is now " + data.id + ")");
            //The callback expects the annotation in memory to be formatted like one from JSON,
            //so we need to reorganize things a bit. Note that this assume Scalar is the back end
            // console.log(data);
            var ids = $.map(data, function (e, k) {
              return k;
            }); //Need to remove Scalar's version ID, which is appended to the URL after a .
  
            var idParts = ids[0].split('.');
            idParts.pop();
            var newID = idParts.join('.'); // annotation.id = ids[0]; // Append the ID given by the response
  
            annotation.items[0].id = newID;
            annotation.items[0].items[0].id = newID; //these should be different, but irrelevant here
  
            annotation.items[0].items[0].items[0].id = newID; //these should be different, but irrelevant here
  
            _this4.annotator.messageOverlay.ShowMessage("Successfully edited the anotation.");
  
            if (callback) callback(annotation, oldID);
          },
          error: function error(response) {
            //console.error(`Could not edit the annotation! Message:\n ${response.responseJSON.detail}`);
            //this.annotator.messageOverlay.ShowError(`Could not edit the annotation!<br>(${response.responseJSON.detail})`);
            var returned_response = "undefined error while editing the annotation";
  
            if (response.responseJSON) {
              returned_response = response.responseJSON.error.code[0].value + " : " + response.responseJSON.error.message[0].value;
            }
  
            console.error("Could not edit the annotation! Message:\n ".concat(returned_response));
  
            _this4.annotator.messageOverlay.ShowError("Could not edit the annotation!<br>(".concat(returned_response, ")"));
          }
        });
      }
    }, {
      key: "DeleteAnnotation",
      value: function DeleteAnnotation(annotation, callback) {
        var _this5 = this;
  
        if (!confirm('Are you sure you wish to delete this annotation?')) {
          return;
        }
  
        var key;
  
        if (this.annotator.apiKey) {
          key = this.annotator.apiKey;
          var email_storage = localStorage.getItem('waldorf_user_email');
          var name_storage = localStorage.getItem('waldorf_user_name');
          if (name_storage == null) name_storage = email_storage;
        } else {
          key = localStorage.getItem('waldorf_auth_token');
        }
  
        if (this.annotator.apiKey) {
          if (annotation["creator"] == null) annotation["creator"] = {};
          annotation["creator"]["email"] = localStorage.getItem('waldorf_user_email');
          annotation["creator"]["nickname"] = localStorage.getItem('waldorf_user_name');
        }
  
        if (annotation["annotation_version"] == "v1") {
          annotation["request"]["items"]["action"] = "update";
          delete annotation["items"];
        } else {
          annotation["service"][0]["items"]["action"] = "update";
          delete annotation["target"];
          delete annotation["body"];
        }
  
        delete annotation["annotation_version"];
        var oldID = '';
  
        if ('undefined' == typeof annotation.items) {
          // Version 1
          oldID = annotation.id;
        } else {
          // Version 2
          oldID = annotation.items[0].items[0].items[0].id;
        }
  
        console.log("Deleting annotation: " + oldID);
  
        if ('undefined' == typeof annotation.items) {
          // Version 1
          var del_data = {
            "scalar:urn": "urn:scalar:version:" + annotation.id,
            "native": annotation.request.items["native"],
            "action": "DELETE",
            "api_key": annotation.request.items.api_key,
            "id": annotation.request.items.id
          };
          return $.post(this.baseURL + "api/delete", del_data, function (response) {
            {
              console.log("Delete error response");
              console.log(response);
              console.log(response.responseText);
            }
          }).done(function (response) {
            console.log("Successfully deleted the annotation.");
  
            _this5.annotator.messageOverlay.ShowMessage("Successfully deleted the annotation.");
  
            if (callback) callback(annotation, oldID);
          }).fail(function (response) {
            var returned_response = "undefined failure while deleting the annotation";
  
            if (response.responseJSON) {
              response.responseJSON.error.code[0].value + " : " + response.responseJSON.error.message[0].value;
            }
  
            console.error("Could not delete the annotation. Message:\n ".concat(returned_response));
  
            _this5.annotator.messageOverlay.ShowError("Could not delete the annotation!<br>(".concat(returned_response, ")"));
          });
        } else {
          // Version 2
          annotation["service"][0]["items"]["action"] = "delete";
          delete annotation["target"];
          delete annotation["body"];
          delete annotation["annotation_version"];
          $.ajax({
            url: this.baseURL + "api/delete",
            type: "POST",
            dataType: 'json',
            contentType: 'application/json',
            data: JSON.stringify(annotation),
            async: true,
            context: this,
            beforeSend: function beforeSend(xhr) {
              xhr.setRequestHeader('Authorization', this.make_write_auth(key));
            },
            success: function success(data) {
              _this5.annotator.messageOverlay.ShowMessage("Successfully deleted the anotation.");
  
              if (callback) callback(annotation, oldID);
            },
            error: function error(response) {
              var returned_response = "undefined error while deleting the annotation";
  
              if (response.responseJSON) {
                returned_response = response.responseJSON.error.code[0].value + " : " + response.responseJSON.error.message[0].value;
              }
  
              console.error("Could not delete the annotation! Message:\n ".concat(returned_response));
  
              _this5.annotator.messageOverlay.ShowError("Could not delete the annotation!<br>(".concat(returned_response, ")"));
            }
          });
        }
      }
    }]);
  
    return ServerInterface;
  }();
  
  exports.ServerInterface = ServerInterface;
  
  },{"sha1":118}],13:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.SessionManager = void 0;
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var sha1 = require('sha1');
  /**
   * Manages the user session for communicating with the backend.
   */
  
  
  var SessionManager = /*#__PURE__*/function () {
    function SessionManager(annotator) {
      var _this = this;
  
      _classCallCheck(this, SessionManager);
  
      console.log("[Session Manager] Creating SessionManager...");
      this.annotator = annotator;
      this.modalOpen = false; // Inject the button for logging in/out into the toolbar
  
      if (!annotator.kioskMode && annotator.cmsEmail == '') {
        this.$userButton = $("<button>Session</button>").button({
          icon: "fa fa-user",
          showLabel: false
        }).click(function () {
          _this.PresentModal();
        });
        this.annotator.player.controlBar.RegisterElement(this.$userButton, 1, 'flex-end');
      } //this.$dialog.dialog("open");
  
  
      console.log("[Session Manager] SessionManager created.");
    }
  
    _createClass(SessionManager, [{
      key: "ShowLoginModal",
      value: function ShowLoginModal() {
        var _this2 = this;
  
        // Create the dialog
        var $container = $("<div class='waldorf-session-modal' title='Log In'></div>"); // Outermost HTML
  
        var $headText = $("<p class='validateTips'>All fields are required.</p>").appendTo($container);
        var $form = $("<form></form>").appendTo($container);
        var $nicknameField;
        var $usernameField;
        var $passwordField;
  
        if (this.annotator.apiKey) {
          $("<label for='username'>Name</label>").appendTo($form);
          $nicknameField = $("<input type='text' name='username' value='' class='text ui-widget-content ui-corner-all'>").appendTo($form);
          $("<label for='username'>Email Address</label>").appendTo($form);
          $usernameField = $("<input type='text' name='email' value='' class='text ui-widget-content ui-corner-all'>").appendTo($form);
        } else {
          $("<label for='username'>Username</label>").appendTo($form);
          $usernameField = $("<input type='text' name='username' value='' class='text ui-widget-content ui-corner-all'>").appendTo($form);
          $("<label for='password'>Password</label>").appendTo($form);
          $passwordField = $("<input type='password' name='password' value='' class='text ui-widget-content ui-corner-all'>").appendTo($form);
        }
  
        $form.wrapInner("<fieldset />");
  
        var login = function login() {
          if (_this2.annotator.apiKey) {
            var nickName = $nicknameField.val();
            var userName = sha1($usernameField.val());
  
            _this2.annotator.server.LogIn(nickName, userName).done(function () {
              console.log("API key login success");
              $dialog.dialog("close");
            }).fail(function () {
              $headText.html("<p>Invalid email address.</p>");
              $headText.css("color", "red");
            });
          } else {
            var userPass = sha1($passwordField.val());
  
            _this2.annotator.server.LogIn($usernameField.val(), userPass).done(function () {
              $dialog.dialog("close");
            }).fail(function () {
              $headText.html("<p>Invalid username or password.</p>");
              $headText.css("color", "red");
            });
          }
        };
  
        var $dialog = $container.dialog({
          autoOpen: true,
          draggable: false,
          modal: true,
          buttons: {
            "Log In": login,
            Cancel: function Cancel() {
              $dialog.dialog("close");
            }
          },
          close: function close() {
            $dialog.find("form")[0].reset();
            $dialog.find("input").removeClass("ui-state-error");
  
            _this2.OnModalClose();
          }
        });
      }
    }, {
      key: "ShowLogoutModal",
      value: function ShowLogoutModal() {
        var _this3 = this;
  
        var $container = $("<div title='Log Out'></div>");
        var $headText = $container.html("<p class='validateTips'>Are you sure you want to log out?</p>");
        var $dialog = $container.dialog({
          autoOpen: true,
          draggable: false,
          modal: true,
          buttons: {
            "Log Out": function LogOut() {
              _this3.annotator.server.LogOut().done(function () {
                $dialog.dialog("close");
              });
            },
            Cancel: function Cancel() {
              $dialog.dialog("close");
            }
          },
          close: function close() {
            _this3.OnModalClose();
          }
        });
      }
    }, {
      key: "PresentModal",
      value: function PresentModal() {
        // Early out if the modal is already open
        if (this.modalOpen) return; // Turn off fullscreen if it's on
  
        this.annotator.player.SetFullscreen(false);
  
        if (this.annotator.server.LoggedIn()) {
          this.ShowLogoutModal();
        } else {
          this.ShowLoginModal();
        }
  
        this.OnModalOpen();
      }
    }, {
      key: "OnModalOpen",
      value: function OnModalOpen() {
        this.$userButton.button("disable");
        this.modalOpen = true;
      }
    }, {
      key: "OnModalClose",
      value: function OnModalClose() {
        this.$userButton.button("enable");
        this.modalOpen = false;
      }
    }]);
  
    return SessionManager;
  }();
  
  exports.SessionManager = SessionManager;
  
  },{"sha1":118}],14:[function(require,module,exports){
  module.exports={
      "configFile": "annotator-config.json"
  }
  },{}],15:[function(require,module,exports){
  "use strict";
  
  require("./vendor.js");
  
  require("./utils/array-extensions.js");
  
  require("./utils/jquery-extensions.js");
  
  require("./utils/string-extensions.js");
  
  var _preferenceManager = require("./utils/preference-manager.js");
  
  var _requirements = require("./utils/requirements.js");
  
  var _videoPlayer = require("./video-player/video-player.js");
  
  /*
  Entry point for the whole project. Any jQuery extensions should
  be registered here.
  */
  // Import npm module dependencies
  // require("../vendor/select2.min.js"); moved this to be concatenated in grunt since it was out of order
  $.fn.annotate = function (args) {
    // let serverURL = args.serverURL || '';
    // let tagsURL = args.tagsURL || '';
    // let apiKey = args.apiKey || '';
    // let kioskMode = args.kioskMode || false;
    // let localURL = args.localURL || '';
    // let renderer = function(...) || false;
    // Error out early if "this" is not a video
    if ($(this).prop('tagName').toLowerCase() != "video") {
      console.error("Cannot wrap a non-video element!");
      return;
    }
  
    if (!(0, _requirements.VerifyRequirements)()) {
      return;
    } // preferences.GetJSON((data) => {
    //     //console.log(data);
    // });
  
  
    new _videoPlayer.AnnotatorVideoPlayer($(this), args);
  };
  
  },{"./utils/array-extensions.js":16,"./utils/jquery-extensions.js":18,"./utils/preference-manager.js":19,"./utils/requirements.js":20,"./utils/string-extensions.js":21,"./vendor.js":23,"./video-player/video-player.js":26}],16:[function(require,module,exports){
  "use strict";
  
  // From http://stackoverflow.com/a/14853974/7138792
  // Warn if overriding existing method
  if (Array.prototype.equals) console.warn("Overriding existing Array.prototype.equals. Possible causes: New API defines the method, \
      there's a framework conflict or you've got double inclusions in your code."); // attach the .equals method to Array's prototype to call it on any array
  
  Array.prototype.equals = function (array) {
    // if the other array is a falsy value, return
    if (!array) return false; // compare lengths - can save a lot of time 
  
    if (this.length != array.length) return false;
  
    for (var i = 0, l = this.length; i < l; i++) {
      // Check if we have nested arrays
      if (this[i] instanceof Array && array[i] instanceof Array) {
        // recurse into the nested arrays
        if (!this[i].equals(array[i])) return false;
      } else if (this[i] != array[i]) {
        // Warning - two different object instances will never be equal: {x:20} != {x:20}
        return false;
      }
    }
  
    return true;
  }; // Hide method from for-in loops
  
  
  Object.defineProperty(Array.prototype, "equals", {
    enumerable: false
  });
  
  },{}],17:[function(require,module,exports){
  (function (global){
  "use strict";
  
  /*!
   * jQuery clip-path-polygon Plugin v0.1.15 (2020-06-24)
   * jQuery plugin that makes easy to use clip-path on whatever tag under different browsers
   * https://github.com/andrusieczko/clip-path-polygon
   * 
   * Copyright 2020 Karol Andrusieczko
   * Released under MIT license
   */
  var globalVariable = window || root;
  
  var jQuery = jQuery || globalVariable.jQuery || (typeof window !== "undefined" ? window['$'] : typeof global !== "undefined" ? global['$'] : null);
  
  (function ($) {
    var id = 0;
  
    var ClipPath = function ClipPath(jQuery, $el, points, options) {
      this.$ = jQuery;
      this.$el = $el;
      this.points = points;
      this.svgDefId = 'clipPathPolygonGenId' + id++;
      this.processOptions(options);
    };
  
    if (typeof exports !== 'undefined') {
      if (typeof module !== 'undefined' && module.exports) {
        exports = module.exports = ClipPath;
      }
  
      exports.ClipPath = ClipPath;
    } else {
      globalVariable.ClipPath = ClipPath;
    }
  
    ClipPath.prototype = {
      $: null,
      $el: null,
      points: null,
      isForWebkit: true,
      isForSvg: true,
      svgDefId: null,
      isPercentage: false,
      create: function create() {
        this._createClipPath(this.points);
      },
      _createClipPath: function _createClipPath(points) {
        this._createSvgDefs();
  
        if (this.isForSvg) {
          this._createSvgBasedClipPath(points);
        }
  
        if (this.isForWebkit) {
          this._createWebkitClipPath(points);
        }
      },
      _createWebkitClipPath: function _createWebkitClipPath(points) {
        var clipPath = "polygon(" + this._translatePoints(points, true, this.isPercentage) + ")";
        this.$el.css('-webkit-clip-path', clipPath);
      },
      _createSvgBasedClipPath: function _createSvgBasedClipPath(points) {
        var clipPath = "polygon(" + this._translatePoints(points, true, this.isPercentage) + ")";
        this.$el.css('clip-path', clipPath);
      },
      // Firefox no longer seems to work with this but does with the webkit version, so I copied it above.
      // _createSvgBasedClipPath: function(points) {
      //   this.$('#' + this.svgDefId + '').find('polygon').attr('points', this._translatePoints(points, false, this.isPercentage));
      //   this.$el.css('clip-path', 'url(#' + this.svgDefId + ')');
      // },
      _translatePoints: function _translatePoints(points, withUnit, isPercentage) {
        var result = [];
  
        for (var i in points) {
          var x = this._handlePxs(points[i][0], withUnit, isPercentage);
  
          var y = this._handlePxs(points[i][1], withUnit, isPercentage);
  
          result.push(x + ' ' + y);
        }
  
        return result.join(', ');
      },
      _handlePxs: function _handlePxs(number, withUnit, isPercentage) {
        if (number === 0) {
          return number;
        }
  
        if (!withUnit) {
          if (isPercentage) {
            return number / 100;
          }
  
          return number;
        }
  
        return number + (isPercentage ? "%" : "px");
      },
      _createSvgElement: function _createSvgElement(elementName) {
        return this.$(document.createElementNS('http://www.w3.org/2000/svg', elementName));
      },
      _createSvgDefs: function _createSvgDefs() {
        if (this.$('#' + this.svgDefId + '').length === 0) {
          var $svg = this._createSvgElement('svg').attr('width', 0).attr('height', 0).css({
            'position': 'absolute',
            'visibility': 'hidden',
            'width': 0,
            'height': 0
          });
  
          var $defs = this._createSvgElement('defs');
  
          $svg.append($defs);
  
          var $clippath = this._createSvgElement('clipPath').attr('id', this.svgDefId);
  
          if (this.isPercentage) {
            $clippath.get(0).setAttribute('clipPathUnits', 'objectBoundingBox');
          }
  
          $defs.append($clippath);
  
          var $polygon = this._createSvgElement('polygon');
  
          $clippath.append($polygon);
          this.$('body').append($svg);
        }
      },
      processOptions: function processOptions(options) {
        this.isForWebkit = options && typeof options.isForWebkit !== "undefined" ? options.isForWebkit : this.isForWebkit;
        this.isForSvg = options && typeof options.isForSvg !== "undefined" ? options.isForSvg : this.isForSvg;
        this.isPercentage = options && options.isPercentage || this.isPercentage;
        this.svgDefId = options && options.svgDefId || this.svgDefId;
      }
    };
  
    $.fn.clipPath = function (points, options) {
      return this.each(function () {
        var $el = $(this);
        var clipPath = new ClipPath($, $el, points, options);
        clipPath.create();
      });
    };
  }).call(void 0, jQuery);
  
  }).call(this,typeof global !== "undefined" ? global : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : {})
  },{}],18:[function(require,module,exports){
  "use strict";
  
  /**
   * Sets the visibility of the element while disabling interaction.
   * Doesn't mess with jQuery's positioning calculations like show()
   * and hide().
   */
  $.fn.makeVisible = function (show) {
    if (show) {
      $(this).css({
        "visibility": "visible",
        "pointer-events": ""
      });
    } else {
      $(this).css({
        "visibility": "hidden",
        "pointer-events": "none"
      });
    }
  };
  /*
  Copyright 2014 Mike Dunn
  http://upshots.org/
  Permission is hereby granted, free of charge, to any person obtaining
  a copy of this software and associated documentation files (the
  "Software"), to deal in the Software without restriction, including
  without limitation the rights to use, copy, modify, merge, publish,
  distribute, sublicense, and/or sell copies of the Software, and to
  permit persons to whom the Software is furnished to do so, subject to
  the following conditions:
  The above copyright notice and this permission notice shall be
  included in all copies or substantial portions of the Software.
  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
  EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
  MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
  NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
  LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
  OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
  
  https://github.com/moagrius/copycss
  
  */
  
  
  $.fn.getStyles = function (only, except) {
    // the map to return with requested styles and values as KVP
    var product = {}; // the style object from the DOM element we need to iterate through
  
    var style; // recycle the name of the style attribute
  
    var name; // if it's a limited list, no need to run through the entire style object
  
    if (only && only instanceof Array) {
      for (var i = 0, l = only.length; i < l; i++) {
        // since we have the name already, just return via built-in .css method
        name = only[i];
        product[name] = this.css(name);
      }
    } else {
      // prevent from empty selector
      if (this.length) {
        // otherwise, we need to get everything
        var dom = this.get(0); // standards
  
        if (window.getComputedStyle) {
          // convenience methods to turn css case ('background-image') to camel ('backgroundImage')
          var pattern = /\-([a-z])/g;
  
          var uc = function uc(a, b) {
            return b.toUpperCase();
          };
  
          var camelize = function camelize(string) {
            return string.replace(pattern, uc);
          }; // make sure we're getting a good reference
  
  
          if (style = window.getComputedStyle(dom, null)) {
            var camel, value; // opera doesn't give back style.length - use truthy since a 0 length may as well be skipped anyways
  
            if (style.length) {
              for (var i = 0, l = style.length; i < l; i++) {
                name = style[i];
                camel = camelize(name);
                value = style.getPropertyValue(name);
                product[camel] = value;
              }
            } else {
              // opera
              for (name in style) {
                camel = camelize(name);
                value = style.getPropertyValue(name) || style[name];
                product[camel] = value;
              }
            }
          }
        } // IE - first try currentStyle, then normal style object - don't bother with runtimeStyle
        else if (style = dom.currentStyle) {
          for (name in style) {
            product[name] = style[name];
          }
        } else if (style = dom.style) {
          for (name in style) {
            if (typeof style[name] != 'function') {
              product[name] = style[name];
            }
          }
        }
      }
    } // remove any styles specified...
    // be careful on blacklist - sometimes vendor-specific values aren't obvious but will be visible...  e.g., excepting 'color' will still let '-webkit-text-fill-color' through, which will in fact color the text
  
  
    if (except && except instanceof Array) {
      for (var i = 0, l = except.length; i < l; i++) {
        name = except[i];
        delete product[name];
      }
    } // one way out so we can process blacklist in one spot
  
  
    return product;
  }; // sugar - source is the selector, dom element or jQuery instance to copy from - only and except are optional
  
  
  $.fn.copyCSS = function (source, only, except) {
    var styles = source.getStyles(only, except);
    this.css(styles);
    return this;
  };
  
  },{}],19:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.preferences = void 0;
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  // Bring in build config options
  var metaconfig = require("../config.json");
  
  var PreferenceManager = /*#__PURE__*/function () {
    function PreferenceManager() {
      _classCallCheck(this, PreferenceManager);
    }
  
    _createClass(PreferenceManager, [{
      key: "GetJSON",
      value: function GetJSON(callback) {
        var _this = this;
  
        //let loc = window.location.pathname;
        //let dir = loc.substring(0, loc.lastIndexOf('/'));
        var dir = "./dist/"; //console.log(dir + metaconfig.configFile);
  
        if (this.cachedJSON != null) {
          callback(this.cached);
        } else {
          $.ajax({
            dataType: "json",
            url: dir + metaconfig.configFile,
            success: function success(data) {
              _this.cachedJSON = data;
              callback(_this.cachedJSON);
            }
          });
        }
      }
    }]);
  
    return PreferenceManager;
  }();
  
  var preferences = new PreferenceManager();
  exports.preferences = preferences;
  
  },{"../config.json":14}],20:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.VerifyRequirements = VerifyRequirements;
  
  /**
   * Returns false if running on an unsupported platform or missing jQuery, otherwise true.
   * 
   */
  function VerifyRequirements() {
    // Stop running if we're on an unsupported platform (mobile for now)
    // if( /Android|webOS|iPhone|iPad|iPod|BlackBerry|IEMobile|Opera Mini/i.test(navigator.userAgent) ) {
    //     console.error("Platform is unsupported!");
    //     //let unsupportedDiv = document.createElement("div");
    //     //unsupportedDiv.appendChild(document.createTextNode("Your platform is unsupported!"));
    //     //document.body.appendChild(unsupportedDiv);
    //     return false;
    // }
    // Check if we don't have jQuery loaded
    if (!window.jQuery) {
      console.error("JQuery must be present!"); //let unsupportedDiv = document.createElement("div");
      //unsupportedDiv.appendChild(document.createTextNode("Your platform is unsupported!"));
      //document.body.appendChild(unsupportedDiv);
  
      return false;
    }
  
    return true;
  }
  
  },{}],21:[function(require,module,exports){
  "use strict";
  
  /**
   * Escapes the string so it can embed directly in an HTML document.
   */
  // http://stackoverflow.com/a/12034334
  Object.defineProperty(String.prototype, 'escapeHTML', {
    value: function value() {
      var entityMap = {
        '&': '&amp;',
        '<': '&lt;',
        '>': '&gt;',
        '"': '&quot;',
        "'": '&#39;',
        '/': '&#x2F;',
        '`': '&#x60;',
        '=': '&#x3D;'
      };
      return String(this).replace(/[&<>"'`=\/]/g, function (s) {
        return entityMap[s];
      });
    }
  });
  
  },{}],22:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.GetFormattedTime = GetFormattedTime;
  exports.GetSecondsFromHMS = GetSecondsFromHMS;
  
  // http://stackoverflow.com/a/34841026
  function GetFormattedTime(timeInSeconds) {
    if (isNaN(timeInSeconds)) return 0;
    var time = timeInSeconds | 0; //Truncate to integer
  
    var hours = Math.floor(time / 3600) % 24;
    var minutes = Math.floor(time / 60) % 60;
    var seconds = time % 60;
    var formatted = [hours, minutes, seconds].map(function (v) {
      return v < 10 ? "0" + v : v;
    }).filter(function (v, i) {
      return v !== "00" || i > 0;
    }).join(":");
  
    if (formatted.charAt(0) == "0") {
      formatted = formatted.substr(1);
    }
  
    var ms = (timeInSeconds % 1).toFixed(2);
    formatted += ms.toString().substr(1);
    return formatted;
  } // From http://stackoverflow.com/a/9640417/7138792
  
  
  function GetSecondsFromHMS(hms) {
    var parts = hms.split('.');
    var ms = "0";
    if (parts.length > 1) ms = '.' + parts[1];
    var p = parts[0].split(':'),
        s = 0,
        m = 1;
  
    while (p.length > 0) {
      s += m * parseInt(p.pop(), 10);
      m *= 60;
    }
  
    s += parseFloat(ms);
    return s;
  }
  
  },{}],23:[function(require,module,exports){
  "use strict";
  
  require("qtip2");
  
  /**
   * Use this file to import what you need from the bundled npm modules.
   */
  // Must import from node_modules folder or it won't see the shimmed jquery instance
  // Removed from here because they weren't being loaded in the right order - JPB
  // import '../node_modules/select2/dist/js/select2.js';
  // import "../node_modules/select2/dist/css/select2.css";
  //require("../node_modules/qtip2/dist/jquery.qtip.min.js");
  //import "../node_modules/qtip2/dist/jquery.qtip.min.css";
  require("./utils/clip-path-polygon-1.0.15.js"); //let screenfull = require('screenfull');
  //import screenfull from "screenfull";
  // CDN resources
  // Font-Awesome
  //$("head").append($("<script src='https://use.fontawesome.com/a703e2e5bf.js'></script>"));
  
  },{"./utils/clip-path-polygon-1.0.15.js":17,"qtip2":116}],24:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.SeekbarTooltip = void 0;
  
  var _time = require("../utils/time.js");
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var SeekbarTooltip = /*#__PURE__*/function () {
    function SeekbarTooltip($parent, player) {
      var _this = this;
  
      _classCallCheck(this, SeekbarTooltip);
  
      this.$parent = $parent;
      this.player = player;
      this.$tooltip = $("<div class='waldorf-seekbar-tooltip'></div>").appendTo($parent);
      this.text = "Test";
      this.$content = $("<p>" + this.text + "</p>").appendTo(this.$tooltip);
      this.hoverOffset = -10;
      this.padding = 5;
      this.Hide();
      this.$parent.mousemove(function (event) {
        _this.Show(); //Add and update tooltip on mouse movement to show where the mouse is hovering.
  
  
        var mouseX = event.pageX - player.$container.offset().left;
  
        var percent = mouseX / _this.$parent.width();
  
        var timeAtCursor = percent * player.videoElement.duration;
  
        _this.Move(mouseX, 0);
  
        _this.SetContent((0, _time.GetFormattedTime)(timeAtCursor));
      });
      this.$parent.mouseout(function () {
        _this.Hide();
      });
    }
  
    _createClass(SeekbarTooltip, [{
      key: "Move",
      value: function Move(x, y) {
        // Get initial positions
        var left = x - this.GetWidth() / 2;
        var top = y - this.GetHeight() + this.hoverOffset; // Offset if necessary (keep on-screen)
  
        if (left - this.padding < 0) {
          left = this.padding;
        }
  
        if (left + this.padding + this.GetWidth() > this.$parent.width()) {
          left = this.$parent.width() - this.GetWidth() - this.padding;
        } // Apply positions
  
  
        this.$tooltip.css({
          top: top,
          left: left
        });
      }
    }, {
      key: "GetWidth",
      value: function GetWidth() {
        return this.$tooltip.width();
      }
    }, {
      key: "GetHeight",
      value: function GetHeight() {
        return this.$tooltip.height();
      }
    }, {
      key: "Show",
      value: function Show() {
        this.$tooltip.makeVisible(true);
      }
    }, {
      key: "Hide",
      value: function Hide() {
        this.$tooltip.makeVisible(false);
      }
    }, {
      key: "SetContent",
      value: function SetContent(text) {
        //console.log(text);
        this.$content.text(text);
      }
    }]);
  
    return SeekbarTooltip;
  }();
  
  exports.SeekbarTooltip = SeekbarTooltip;
  
  },{"../utils/time.js":22}],25:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.VideoPlayerBar = void 0;
  
  var _time = require("../utils/time.js");
  
  var _seekbarTooltip = require("./seekbar-tooltip.js");
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  var VideoPlayerBar = /*#__PURE__*/function () {
    function VideoPlayerBar(player) {
      var _this = this;
  
      _classCallCheck(this, VideoPlayerBar);
  
      this.player = player;
      this.$container = $("<div class='waldorf-player-toolbar flex-toolbar'></div>").appendTo(player.$container);
      this.PopulateElements();
      this.scrubbingTimeSlider = false;
      this.videoPlayingBeforeTimeScrub = false; // Hook up to events from video player
  
      this.player.$container.on("OnVisibilityChange", function (event, isVisible, duration) {
        return _this.SetVisible(isVisible, duration);
      });
      this.player.$container.on("OnPlayStateChange", function (event, playing) {
        return _this.OnPlayStateChange(playing);
      });
      this.player.$container.on("OnTimeUpdate", function (event, time) {
        return _this.OnTimeUpdate(time);
      });
      this.player.$container.on("OnMuteStateChange", function (event, muted) {
        return _this.OnMuteStateChange(muted);
      });
      this.player.$container.on("OnVolumeChange", function (event, volume) {
        return _this.OnVolumeChange(volume);
      });
    }
  
    _createClass(VideoPlayerBar, [{
      key: "PopulateElements",
      value: function PopulateElements() {
        var _this2 = this;
  
        this.$seekBar = $("<div id='seek-bar'><div id='seek-handle' class='ui-slider-handle'></div></div>");
        var $seekSlider = this.$seekBar.slider({
          min: 0.0,
          max: 1.0,
          step: 0.001
        });
        $seekSlider.on("slide", function () {
          return _this2.UpdateVideoTime();
        });
        $seekSlider.on("slidestart", function () {
          return _this2.TimeDragStarted();
        });
        $seekSlider.on("slidestop", function () {
          _this2.TimeDragFinished();
  
          _this2.UpdateVideoTime();
        });
        this.$container.append(this.$seekBar);
        this.seekbarTooltip = new _seekbarTooltip.SeekbarTooltip(this.$seekBar, this.player);
        this.$seekProgress = $("<div id='seek-fill'></div>");
        this.$container.append(this.$seekProgress); //Jump Back button
  
        this.$jumpBackButton = $("<button>Jump Back</button>").button({
          icon: "fa fa-fast-backward",
          showLabel: false
        }).click(function () {
          return _this2.player.JumpBackward();
        });
        this.RegisterElement(this.$jumpBackButton, -8); //Nudge Back button
  
        this.$nudgeBackButton = $("<button>Nudge Back</button>").button({
          icon: "fa fa-step-backward",
          showLabel: false
        }).click(function () {
          return _this2.player.StepBackward();
        });
        this.RegisterElement(this.$nudgeBackButton, -7); // Play button
  
        this.$playButton = $("<button>Play</button>").button({
          icon: "fa fa-play",
          showLabel: false
        }).click(function () {
          return _this2.player.TogglePlayState();
        });
        this.RegisterElement(this.$playButton, -6); //Nudge button
  
        this.$nudgeButton = $("<button>Nudge</button>").button({
          icon: "fa fa-step-forward",
          showLabel: false
        }).click(function () {
          return _this2.player.StepForward();
        });
        this.RegisterElement(this.$nudgeButton, -5); //Jump button
  
        this.$jumpButton = $("<button>Nudge</button>").button({
          icon: "fa fa-fast-forward",
          showLabel: false
        }).click(function () {
          return _this2.player.JumpForward();
        });
        this.RegisterElement(this.$jumpButton, -4); // Time text
  
        var zero = (0, _time.GetFormattedTime)(0.000);
        this.$timeText = $("<p>${zero}/${zero}</p>");
        this.RegisterElement(this.$timeText, -3); // Mute button
  
        this.$muteButton = $("<button>Mute</button>").button({
          icon: "fa fa-volume-up",
          showLabel: false
        }).click(function () {
          return _this2.player.ToggleMuteState();
        });
        this.RegisterElement(this.$muteButton, -2); // Volume bar
  
        this.$volumeBar = $("<div id='volume-bar'><div id='volume-handle' class='ui-slider-handle'></div></div>");
        this.$volumeBar.slider({
          range: "min",
          max: 1.0,
          value: 1.0,
          step: 0.05
        }).on("slide", function (event, ui) {
          return _this2.player.SetVolume(ui.value);
        });
        this.RegisterElement(this.$volumeBar, -1); // Fullscreen button
  
        this.$fullScreenButton = $("<button>Fullscreen</button>").button({
          icon: "fa fa-arrows-alt",
          showLabel: false
        }).click(function () {
          return _this2.player.ToggleFullscreen();
        });
        this.RegisterElement(this.$fullScreenButton, 999, 'flex-end'); // Create empty element between left floating and right floating toolbar items to space them out properly
  
        this.$container.append($("<div></div>").css("flex-grow", 1).css("order", 0)); //Initialize controls
  
        this.OnTimeUpdate();
        this.$volumeBar.slider("value", this.player.videoElement.volume);
      }
    }, {
      key: "RegisterElement",
      value: function RegisterElement($element, order) {
        var justification = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : 'flex-start';
        $element.css('order', order);
        $element.css('align-self', justification); // Sets grow [shrink] [basis]
        //$element.css('flex', '0 0 auto');
  
        this.$container.append($element);
      }
    }, {
      key: "SetVisible",
      value: function SetVisible(isVisible, duration) {
        var _this3 = this;
  
        //console.log(isVisible + " " + duration);
        this.$container.stop(true, true);
  
        if (isVisible) {
          this.$container.fadeTo(duration, 1.0, function () {
            _this3.$container.makeVisible(true);
          });
        } else {
          this.$container.fadeTo(duration, 0.0, function () {
            _this3.$container.makeVisible(false);
          });
        }
      }
    }, {
      key: "UpdateVideoTime",
      value: function UpdateVideoTime() {
        // Calculate the new time
        var time = this.player.videoElement.duration * this.$seekBar.slider("value");
        this.player.endTime = false;
        this.player.videoElement.currentTime = time;
      }
    }, {
      key: "TimeDragStarted",
      value: function TimeDragStarted() {
        this.videoPlayingBeforeTimeScrub = !this.player.videoElement.paused;
        this.player.videoElement.pause();
      }
    }, {
      key: "TimeDragFinished",
      value: function TimeDragFinished() {
        // Start playing the video again if it was playing before the scrub started
        if (this.videoPlayingBeforeTimeScrub) {
          this.player.videoElement.play();
        }
      } ///
      /// ----- Event Listeners -----
      /// The following update the visual state of the bar
      /// upon changes to the video player. These are hooked
      /// up in the constructor.
      ///
  
    }, {
      key: "OnPlayStateChange",
      value: function OnPlayStateChange(playing) {
        this.$playButton.button("option", {
          icon: playing ? "fa fa-pause" : "fa fa-play"
        });
      }
    }, {
      key: "OnTimeUpdate",
      value: function OnTimeUpdate(time) {
        //console.log("video-player-bar.js:185 OnTimeUpdate is called");
        var duration = this.player.videoElement.duration; // Update the time text
  
        this.$timeText.text((0, _time.GetFormattedTime)(time) + "/" + (0, _time.GetFormattedTime)(duration));
        var progress = time / duration;
        this.$seekProgress.width((progress * 100).toString() + "%");
      }
    }, {
      key: "OnVolumeChange",
      value: function OnVolumeChange(volume) {
        this.$volumeBar.slider("value", volume);
      }
    }, {
      key: "OnMuteStateChange",
      value: function OnMuteStateChange(muted) {
        this.$muteButton.button("option", {
          icon: muted ? "fa fa-volume-up" : "fa fa-volume-off"
        });
      }
    }]);
  
    return VideoPlayerBar;
  }();
  
  exports.VideoPlayerBar = VideoPlayerBar;
  
  },{"../utils/time.js":22,"./seekbar-tooltip.js":24}],26:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.AnnotatorVideoPlayer = void 0;
  
  var _videoPlayerBar = require("./video-player-bar.js");
  
  var _annotator = require("../annotator/annotator.js");
  
  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
  
  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
  
  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); return Constructor; }
  
  //import * as screenfull from "screenfull";
  //import 'jquery-ui/dist/jquery-ui.js';
  var screenfull = require('screenfull');
  
  var AnnotatorVideoPlayer = /*#__PURE__*/function () {
    function AnnotatorVideoPlayer($video, annotatorArgs) {
      var _this = this;
  
      _classCallCheck(this, AnnotatorVideoPlayer);
  
      console.log("[AnnotatorVideoPlayer] Creating AnnotatorVideoPlayer for video...");
      this.$video = $video;
      this.videoElement = this.$video.get(0); // Store the original styling of the video element before we alter it
  
      this.originalStyles = this.$video.getStyles(null, ["height", "WebkitTextFillColor", "color"]); //["width", "top", "left", "margin", "padding"]
  
      this.Wrap();
      this.PopulateControls();
      this.SetVisible(true); // Hook up events
  
      this.HookUpEvents(); // Play / pause the video when clicked.
  
      this.$video.on("click", function () {
        return _this.TogglePlayState();
      });
      this.allowAutoFade = true; /// Inactivity timer for the mouse.
  
      this.mouseTimer = null; /// Set to true if the time slider is currently being dragged by the user.
  
      this.draggingTimeSlider = false; /// Seconds before the UI fades due to mouse inactivity.
  
      this.idleSecondsBeforeFade = 3;
      this.fadeDuration = 300;
      this.endTime = false;
      this.$container.mousemove(function () {
        return _this.OnMouseMove();
      });
      this.SetAutoFade(true); // If screenfull is enabled, create the event to handle it.
  
      if (screenfull !== 'undefined') {
        screenfull.onchange(function () {
          _this.OnFullscreenChange();
  
          _this.$container.trigger("OnFullscreenChange");
        });
      }
  
      this.videoElement.ontimeupdate = function () {
        _this.OnTimeUpdate(_this.videoElement.currentTime);
      };
  
      this.$container.on("OnVideoReady", function () {
        if (annotatorArgs.annotator == null) {
          console.log("[AnnotatorVideoPlayer] Player sent OnVideoReady, attempting to wrap with annotator..."); // Add annotator once video has loaded
  
          console.log("[AnnotatorVideoPlayer] Wrapping video with annotator...");
          annotatorArgs.player = _this;
          annotatorArgs.annotator = new _annotator.VideoAnnotator(annotatorArgs);
          if (typeof annotatorArgs.callback == "function") annotatorArgs.callback(annotatorArgs.annotator);
        }
      });
  
      this.videoElement.onloadedmetadata = function () {
        _this.$container.trigger("OnVideoReady");
      };
  
      if (this.videoElement.duration != null) {
        // If the metadata is already prepared, throw the event since
        // onloadedmetadata won't be fired
        this.$container.trigger("OnVideoReady");
      }
  
      console.log("[AnnotatorVideoPlayer] AnnotatorVideoPlayer created for video.");
    }
  
    _createClass(AnnotatorVideoPlayer, [{
      key: "Wrap",
      value: function Wrap() {
        // Remove the default controls from the video
        this.videoElement.removeAttribute("controls"); // Wrap the video element with the container
  
        this.$container = this.$video.wrap("<div class='waldorf-video-player'></div>").parent(); // Resize container to fit the dimensions of the video
  
        this.$container.width(this.$video.width());
        this.$container.height(this.$video.height());
      }
    }, {
      key: "PopulateControls",
      value: function PopulateControls() {
        this.controlBar = new _videoPlayerBar.VideoPlayerBar(this);
      }
    }, {
      key: "SetVisible",
      value: function SetVisible(isVisible) {
        var duration = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;
        this.$container.trigger("OnVisibilityChange", [isVisible, duration]);
      }
    }, {
      key: "HookUpEvents",
      value: function HookUpEvents() {}
    }, {
      key: "TogglePlayState",
      value: function TogglePlayState() {
        if (this.videoElement.paused) {
          this.Play();
        } else {
          this.Pause();
        }
      }
    }, {
      key: "StepForward",
      value: function StepForward() {
        var newTime = this.videoElement.currentTime + 0.1;
        this.videoElement.currentTime = newTime > this.videoElement.duration ? this.videoElement.duration : newTime;
      }
    }, {
      key: "JumpForward",
      value: function JumpForward() {
        var newTime = this.videoElement.currentTime + 1;
        this.videoElement.currentTime = newTime > this.videoElement.duration ? this.videoElement.duration : newTime;
      }
    }, {
      key: "StepBackward",
      value: function StepBackward() {
        var newTime = this.videoElement.currentTime - 0.1;
        this.videoElement.currentTime = newTime < 0 ? 0 : newTime;
      }
    }, {
      key: "JumpBackward",
      value: function JumpBackward() {
        var newTime = this.videoElement.currentTime - 1;
        this.videoElement.currentTime = newTime < 0 ? 0 : newTime;
      }
    }, {
      key: "Play",
      value: function Play() {
        this.videoElement.play();
        if (this.endTime) this.endTime = false;
        this.SetAutoFade(true);
        this.$container.trigger("OnPlayStateChange", !this.videoElement.paused);
      }
    }, {
      key: "Pause",
      value: function Pause() {
        if (this.endTime) this.endTime = false;
        this.videoElement.pause();
        this.SetAutoFade(false);
        this.$container.trigger("OnPlayStateChange", !this.videoElement.paused);
      }
    }, {
      key: "ToggleMuteState",
      value: function ToggleMuteState() {
        var muted = this.videoElement.muted;
        this.videoElement.muted = !muted;
        this.$container.trigger("OnMuteStateChange", muted);
      }
    }, {
      key: "SetVolume",
      value: function SetVolume(volume) {
        this.videoElement.volume = volume;
        this.$container.trigger("OnVolumeChange", volume);
      }
    }, {
      key: "ToggleFullscreen",
      value: function ToggleFullscreen() {
        if (screenfull === 'undefined') return;
        screenfull.toggle(this.$container[0]);
      }
    }, {
      key: "OnFullscreenChange",
      value: function OnFullscreenChange() {
        if (screenfull.isFullscreen) {
          this.$container.addClass("waldorf-fullscreen");
        } else {
          this.$container.removeClass("waldorf-fullscreen");
        }
      }
    }, {
      key: "SetFullscreen",
      value: function SetFullscreen(fullscreen) {
        if (screenfull === 'undefined' || !screenfull.enabled) {
          return;
        }
  
        if (fullscreen) {
          screenfull.request(this.$container[0]);
        } else {
          screenfull.exit();
        }
      }
      /**
       * Called when the mouse moves in the video container.
       */
  
    }, {
      key: "OnMouseMove",
      value: function OnMouseMove() {
        // Reset the timer
        clearTimeout(this.mouseTimer);
        this.mouseTimer = 0; // Restart fading if allowed to
  
        if (this.allowAutoFade) {
          this.RestartFading();
        }
      }
    }, {
      key: "OnTimeUpdate",
      value: function OnTimeUpdate(time) {
        if (this.endTime && this.endTime <= this.videoElement.currentTime) {
          this.Pause();
          this.endTime = false;
        }
  
        this.$container.trigger("OnTimeUpdate", time);
      }
    }, {
      key: "RestartFading",
      value: function RestartFading() {
        var _this2 = this;
  
        // Restore visibility
        this.SetVisible(true, this.fadeDuration); // Start the timer over again
  
        this.mouseTimer = setTimeout(function () {
          _this2.SetVisible(false, _this2.fadeDuration);
        }, this.idleSecondsBeforeFade * 1000);
      }
    }, {
      key: "SetAutoFade",
      value: function SetAutoFade(allow) {
        this.allowAutoFade = allow; // Reset the mouse timer
  
        clearTimeout(this.mouseTimer);
        this.mouseTimer = 0; // Make elements visible
  
        this.SetVisible(true); // Restart the fading behavior if desired
  
        if (allow) {
          this.RestartFading();
        }
      } // IsPlaying(){
      //     // http://stackoverflow.com/a/31133401
      //     return !!(this.videoElement.currentTime > 0 && !this.videoElement.paused && 
      //               !this.videoElement.ended && this.videoElement.readyState > 2);
      // }
      // From https://gist.github.com/Nateowami/7a947e93f09c45a1097e783dc00560e1
  
    }, {
      key: "GetVideoDimensions",
      value: function GetVideoDimensions() {
        var video = this.videoElement; // Ratio of the video's intrisic dimensions
  
        var videoRatio = video.videoWidth / video.videoHeight; // The width and height of the video element
  
        var width = video.offsetWidth;
        var height = video.offsetHeight; // The ratio of the element's width to its height
  
        var elementRatio = width / height; // If the video element is short and wide
  
        if (elementRatio > videoRatio) width = height * videoRatio; // It must be tall and thin, or exactly equal to the original ratio
        else height = width / videoRatio;
        return {
          width: width,
          height: height
        };
      }
    }]);
  
    return AnnotatorVideoPlayer;
  }();
  
  exports.AnnotatorVideoPlayer = AnnotatorVideoPlayer;
  
  },{"../annotator/annotator.js":4,"./video-player-bar.js":25,"screenfull":117}],27:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.isIdentifierStart = isIdentifierStart;
  exports.isIdentifierChar = isIdentifierChar;
  exports.isIdentifierName = isIdentifierName;
  let nonASCIIidentifierStartChars = "\xaa\xb5\xba\xc0-\xd6\xd8-\xf6\xf8-\u02c1\u02c6-\u02d1\u02e0-\u02e4\u02ec\u02ee\u0370-\u0374\u0376\u0377\u037a-\u037d\u037f\u0386\u0388-\u038a\u038c\u038e-\u03a1\u03a3-\u03f5\u03f7-\u0481\u048a-\u052f\u0531-\u0556\u0559\u0560-\u0588\u05d0-\u05ea\u05ef-\u05f2\u0620-\u064a\u066e\u066f\u0671-\u06d3\u06d5\u06e5\u06e6\u06ee\u06ef\u06fa-\u06fc\u06ff\u0710\u0712-\u072f\u074d-\u07a5\u07b1\u07ca-\u07ea\u07f4\u07f5\u07fa\u0800-\u0815\u081a\u0824\u0828\u0840-\u0858\u0860-\u086a\u0870-\u0887\u0889-\u088e\u08a0-\u08c9\u0904-\u0939\u093d\u0950\u0958-\u0961\u0971-\u0980\u0985-\u098c\u098f\u0990\u0993-\u09a8\u09aa-\u09b0\u09b2\u09b6-\u09b9\u09bd\u09ce\u09dc\u09dd\u09df-\u09e1\u09f0\u09f1\u09fc\u0a05-\u0a0a\u0a0f\u0a10\u0a13-\u0a28\u0a2a-\u0a30\u0a32\u0a33\u0a35\u0a36\u0a38\u0a39\u0a59-\u0a5c\u0a5e\u0a72-\u0a74\u0a85-\u0a8d\u0a8f-\u0a91\u0a93-\u0aa8\u0aaa-\u0ab0\u0ab2\u0ab3\u0ab5-\u0ab9\u0abd\u0ad0\u0ae0\u0ae1\u0af9\u0b05-\u0b0c\u0b0f\u0b10\u0b13-\u0b28\u0b2a-\u0b30\u0b32\u0b33\u0b35-\u0b39\u0b3d\u0b5c\u0b5d\u0b5f-\u0b61\u0b71\u0b83\u0b85-\u0b8a\u0b8e-\u0b90\u0b92-\u0b95\u0b99\u0b9a\u0b9c\u0b9e\u0b9f\u0ba3\u0ba4\u0ba8-\u0baa\u0bae-\u0bb9\u0bd0\u0c05-\u0c0c\u0c0e-\u0c10\u0c12-\u0c28\u0c2a-\u0c39\u0c3d\u0c58-\u0c5a\u0c5d\u0c60\u0c61\u0c80\u0c85-\u0c8c\u0c8e-\u0c90\u0c92-\u0ca8\u0caa-\u0cb3\u0cb5-\u0cb9\u0cbd\u0cdd\u0cde\u0ce0\u0ce1\u0cf1\u0cf2\u0d04-\u0d0c\u0d0e-\u0d10\u0d12-\u0d3a\u0d3d\u0d4e\u0d54-\u0d56\u0d5f-\u0d61\u0d7a-\u0d7f\u0d85-\u0d96\u0d9a-\u0db1\u0db3-\u0dbb\u0dbd\u0dc0-\u0dc6\u0e01-\u0e30\u0e32\u0e33\u0e40-\u0e46\u0e81\u0e82\u0e84\u0e86-\u0e8a\u0e8c-\u0ea3\u0ea5\u0ea7-\u0eb0\u0eb2\u0eb3\u0ebd\u0ec0-\u0ec4\u0ec6\u0edc-\u0edf\u0f00\u0f40-\u0f47\u0f49-\u0f6c\u0f88-\u0f8c\u1000-\u102a\u103f\u1050-\u1055\u105a-\u105d\u1061\u1065\u1066\u106e-\u1070\u1075-\u1081\u108e\u10a0-\u10c5\u10c7\u10cd\u10d0-\u10fa\u10fc-\u1248\u124a-\u124d\u1250-\u1256\u1258\u125a-\u125d\u1260-\u1288\u128a-\u128d\u1290-\u12b0\u12b2-\u12b5\u12b8-\u12be\u12c0\u12c2-\u12c5\u12c8-\u12d6\u12d8-\u1310\u1312-\u1315\u1318-\u135a\u1380-\u138f\u13a0-\u13f5\u13f8-\u13fd\u1401-\u166c\u166f-\u167f\u1681-\u169a\u16a0-\u16ea\u16ee-\u16f8\u1700-\u1711\u171f-\u1731\u1740-\u1751\u1760-\u176c\u176e-\u1770\u1780-\u17b3\u17d7\u17dc\u1820-\u1878\u1880-\u18a8\u18aa\u18b0-\u18f5\u1900-\u191e\u1950-\u196d\u1970-\u1974\u1980-\u19ab\u19b0-\u19c9\u1a00-\u1a16\u1a20-\u1a54\u1aa7\u1b05-\u1b33\u1b45-\u1b4c\u1b83-\u1ba0\u1bae\u1baf\u1bba-\u1be5\u1c00-\u1c23\u1c4d-\u1c4f\u1c5a-\u1c7d\u1c80-\u1c88\u1c90-\u1cba\u1cbd-\u1cbf\u1ce9-\u1cec\u1cee-\u1cf3\u1cf5\u1cf6\u1cfa\u1d00-\u1dbf\u1e00-\u1f15\u1f18-\u1f1d\u1f20-\u1f45\u1f48-\u1f4d\u1f50-\u1f57\u1f59\u1f5b\u1f5d\u1f5f-\u1f7d\u1f80-\u1fb4\u1fb6-\u1fbc\u1fbe\u1fc2-\u1fc4\u1fc6-\u1fcc\u1fd0-\u1fd3\u1fd6-\u1fdb\u1fe0-\u1fec\u1ff2-\u1ff4\u1ff6-\u1ffc\u2071\u207f\u2090-\u209c\u2102\u2107\u210a-\u2113\u2115\u2118-\u211d\u2124\u2126\u2128\u212a-\u2139\u213c-\u213f\u2145-\u2149\u214e\u2160-\u2188\u2c00-\u2ce4\u2ceb-\u2cee\u2cf2\u2cf3\u2d00-\u2d25\u2d27\u2d2d\u2d30-\u2d67\u2d6f\u2d80-\u2d96\u2da0-\u2da6\u2da8-\u2dae\u2db0-\u2db6\u2db8-\u2dbe\u2dc0-\u2dc6\u2dc8-\u2dce\u2dd0-\u2dd6\u2dd8-\u2dde\u3005-\u3007\u3021-\u3029\u3031-\u3035\u3038-\u303c\u3041-\u3096\u309b-\u309f\u30a1-\u30fa\u30fc-\u30ff\u3105-\u312f\u3131-\u318e\u31a0-\u31bf\u31f0-\u31ff\u3400-\u4dbf\u4e00-\ua48c\ua4d0-\ua4fd\ua500-\ua60c\ua610-\ua61f\ua62a\ua62b\ua640-\ua66e\ua67f-\ua69d\ua6a0-\ua6ef\ua717-\ua71f\ua722-\ua788\ua78b-\ua7ca\ua7d0\ua7d1\ua7d3\ua7d5-\ua7d9\ua7f2-\ua801\ua803-\ua805\ua807-\ua80a\ua80c-\ua822\ua840-\ua873\ua882-\ua8b3\ua8f2-\ua8f7\ua8fb\ua8fd\ua8fe\ua90a-\ua925\ua930-\ua946\ua960-\ua97c\ua984-\ua9b2\ua9cf\ua9e0-\ua9e4\ua9e6-\ua9ef\ua9fa-\ua9fe\uaa00-\uaa28\uaa40-\uaa42\uaa44-\uaa4b\uaa60-\uaa76\uaa7a\uaa7e-\uaaaf\uaab1\uaab5\uaab6\uaab9-\uaabd\uaac0\uaac2\uaadb-\uaadd\uaae0-\uaaea\uaaf2-\uaaf4\uab01-\uab06\uab09-\uab0e\uab11-\uab16\uab20-\uab26\uab28-\uab2e\uab30-\uab5a\uab5c-\uab69\uab70-\uabe2\uac00-\ud7a3\ud7b0-\ud7c6\ud7cb-\ud7fb\uf900-\ufa6d\ufa70-\ufad9\ufb00-\ufb06\ufb13-\ufb17\ufb1d\ufb1f-\ufb28\ufb2a-\ufb36\ufb38-\ufb3c\ufb3e\ufb40\ufb41\ufb43\ufb44\ufb46-\ufbb1\ufbd3-\ufd3d\ufd50-\ufd8f\ufd92-\ufdc7\ufdf0-\ufdfb\ufe70-\ufe74\ufe76-\ufefc\uff21-\uff3a\uff41-\uff5a\uff66-\uffbe\uffc2-\uffc7\uffca-\uffcf\uffd2-\uffd7\uffda-\uffdc";
  let nonASCIIidentifierChars = "\u200c\u200d\xb7\u0300-\u036f\u0387\u0483-\u0487\u0591-\u05bd\u05bf\u05c1\u05c2\u05c4\u05c5\u05c7\u0610-\u061a\u064b-\u0669\u0670\u06d6-\u06dc\u06df-\u06e4\u06e7\u06e8\u06ea-\u06ed\u06f0-\u06f9\u0711\u0730-\u074a\u07a6-\u07b0\u07c0-\u07c9\u07eb-\u07f3\u07fd\u0816-\u0819\u081b-\u0823\u0825-\u0827\u0829-\u082d\u0859-\u085b\u0898-\u089f\u08ca-\u08e1\u08e3-\u0903\u093a-\u093c\u093e-\u094f\u0951-\u0957\u0962\u0963\u0966-\u096f\u0981-\u0983\u09bc\u09be-\u09c4\u09c7\u09c8\u09cb-\u09cd\u09d7\u09e2\u09e3\u09e6-\u09ef\u09fe\u0a01-\u0a03\u0a3c\u0a3e-\u0a42\u0a47\u0a48\u0a4b-\u0a4d\u0a51\u0a66-\u0a71\u0a75\u0a81-\u0a83\u0abc\u0abe-\u0ac5\u0ac7-\u0ac9\u0acb-\u0acd\u0ae2\u0ae3\u0ae6-\u0aef\u0afa-\u0aff\u0b01-\u0b03\u0b3c\u0b3e-\u0b44\u0b47\u0b48\u0b4b-\u0b4d\u0b55-\u0b57\u0b62\u0b63\u0b66-\u0b6f\u0b82\u0bbe-\u0bc2\u0bc6-\u0bc8\u0bca-\u0bcd\u0bd7\u0be6-\u0bef\u0c00-\u0c04\u0c3c\u0c3e-\u0c44\u0c46-\u0c48\u0c4a-\u0c4d\u0c55\u0c56\u0c62\u0c63\u0c66-\u0c6f\u0c81-\u0c83\u0cbc\u0cbe-\u0cc4\u0cc6-\u0cc8\u0cca-\u0ccd\u0cd5\u0cd6\u0ce2\u0ce3\u0ce6-\u0cef\u0d00-\u0d03\u0d3b\u0d3c\u0d3e-\u0d44\u0d46-\u0d48\u0d4a-\u0d4d\u0d57\u0d62\u0d63\u0d66-\u0d6f\u0d81-\u0d83\u0dca\u0dcf-\u0dd4\u0dd6\u0dd8-\u0ddf\u0de6-\u0def\u0df2\u0df3\u0e31\u0e34-\u0e3a\u0e47-\u0e4e\u0e50-\u0e59\u0eb1\u0eb4-\u0ebc\u0ec8-\u0ecd\u0ed0-\u0ed9\u0f18\u0f19\u0f20-\u0f29\u0f35\u0f37\u0f39\u0f3e\u0f3f\u0f71-\u0f84\u0f86\u0f87\u0f8d-\u0f97\u0f99-\u0fbc\u0fc6\u102b-\u103e\u1040-\u1049\u1056-\u1059\u105e-\u1060\u1062-\u1064\u1067-\u106d\u1071-\u1074\u1082-\u108d\u108f-\u109d\u135d-\u135f\u1369-\u1371\u1712-\u1715\u1732-\u1734\u1752\u1753\u1772\u1773\u17b4-\u17d3\u17dd\u17e0-\u17e9\u180b-\u180d\u180f-\u1819\u18a9\u1920-\u192b\u1930-\u193b\u1946-\u194f\u19d0-\u19da\u1a17-\u1a1b\u1a55-\u1a5e\u1a60-\u1a7c\u1a7f-\u1a89\u1a90-\u1a99\u1ab0-\u1abd\u1abf-\u1ace\u1b00-\u1b04\u1b34-\u1b44\u1b50-\u1b59\u1b6b-\u1b73\u1b80-\u1b82\u1ba1-\u1bad\u1bb0-\u1bb9\u1be6-\u1bf3\u1c24-\u1c37\u1c40-\u1c49\u1c50-\u1c59\u1cd0-\u1cd2\u1cd4-\u1ce8\u1ced\u1cf4\u1cf7-\u1cf9\u1dc0-\u1dff\u203f\u2040\u2054\u20d0-\u20dc\u20e1\u20e5-\u20f0\u2cef-\u2cf1\u2d7f\u2de0-\u2dff\u302a-\u302f\u3099\u309a\ua620-\ua629\ua66f\ua674-\ua67d\ua69e\ua69f\ua6f0\ua6f1\ua802\ua806\ua80b\ua823-\ua827\ua82c\ua880\ua881\ua8b4-\ua8c5\ua8d0-\ua8d9\ua8e0-\ua8f1\ua8ff-\ua909\ua926-\ua92d\ua947-\ua953\ua980-\ua983\ua9b3-\ua9c0\ua9d0-\ua9d9\ua9e5\ua9f0-\ua9f9\uaa29-\uaa36\uaa43\uaa4c\uaa4d\uaa50-\uaa59\uaa7b-\uaa7d\uaab0\uaab2-\uaab4\uaab7\uaab8\uaabe\uaabf\uaac1\uaaeb-\uaaef\uaaf5\uaaf6\uabe3-\uabea\uabec\uabed\uabf0-\uabf9\ufb1e\ufe00-\ufe0f\ufe20-\ufe2f\ufe33\ufe34\ufe4d-\ufe4f\uff10-\uff19\uff3f";
  const nonASCIIidentifierStart = new RegExp("[" + nonASCIIidentifierStartChars + "]");
  const nonASCIIidentifier = new RegExp("[" + nonASCIIidentifierStartChars + nonASCIIidentifierChars + "]");
  nonASCIIidentifierStartChars = nonASCIIidentifierChars = null;
  const astralIdentifierStartCodes = [0, 11, 2, 25, 2, 18, 2, 1, 2, 14, 3, 13, 35, 122, 70, 52, 268, 28, 4, 48, 48, 31, 14, 29, 6, 37, 11, 29, 3, 35, 5, 7, 2, 4, 43, 157, 19, 35, 5, 35, 5, 39, 9, 51, 13, 10, 2, 14, 2, 6, 2, 1, 2, 10, 2, 14, 2, 6, 2, 1, 68, 310, 10, 21, 11, 7, 25, 5, 2, 41, 2, 8, 70, 5, 3, 0, 2, 43, 2, 1, 4, 0, 3, 22, 11, 22, 10, 30, 66, 18, 2, 1, 11, 21, 11, 25, 71, 55, 7, 1, 65, 0, 16, 3, 2, 2, 2, 28, 43, 28, 4, 28, 36, 7, 2, 27, 28, 53, 11, 21, 11, 18, 14, 17, 111, 72, 56, 50, 14, 50, 14, 35, 349, 41, 7, 1, 79, 28, 11, 0, 9, 21, 43, 17, 47, 20, 28, 22, 13, 52, 58, 1, 3, 0, 14, 44, 33, 24, 27, 35, 30, 0, 3, 0, 9, 34, 4, 0, 13, 47, 15, 3, 22, 0, 2, 0, 36, 17, 2, 24, 85, 6, 2, 0, 2, 3, 2, 14, 2, 9, 8, 46, 39, 7, 3, 1, 3, 21, 2, 6, 2, 1, 2, 4, 4, 0, 19, 0, 13, 4, 159, 52, 19, 3, 21, 2, 31, 47, 21, 1, 2, 0, 185, 46, 42, 3, 37, 47, 21, 0, 60, 42, 14, 0, 72, 26, 38, 6, 186, 43, 117, 63, 32, 7, 3, 0, 3, 7, 2, 1, 2, 23, 16, 0, 2, 0, 95, 7, 3, 38, 17, 0, 2, 0, 29, 0, 11, 39, 8, 0, 22, 0, 12, 45, 20, 0, 19, 72, 264, 8, 2, 36, 18, 0, 50, 29, 113, 6, 2, 1, 2, 37, 22, 0, 26, 5, 2, 1, 2, 31, 15, 0, 328, 18, 190, 0, 80, 921, 103, 110, 18, 195, 2637, 96, 16, 1070, 4050, 582, 8634, 568, 8, 30, 18, 78, 18, 29, 19, 47, 17, 3, 32, 20, 6, 18, 689, 63, 129, 74, 6, 0, 67, 12, 65, 1, 2, 0, 29, 6135, 9, 1237, 43, 8, 8936, 3, 2, 6, 2, 1, 2, 290, 46, 2, 18, 3, 9, 395, 2309, 106, 6, 12, 4, 8, 8, 9, 5991, 84, 2, 70, 2, 1, 3, 0, 3, 1, 3, 3, 2, 11, 2, 0, 2, 6, 2, 64, 2, 3, 3, 7, 2, 6, 2, 27, 2, 3, 2, 4, 2, 0, 4, 6, 2, 339, 3, 24, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 30, 2, 24, 2, 7, 1845, 30, 482, 44, 11, 6, 17, 0, 322, 29, 19, 43, 1269, 6, 2, 3, 2, 1, 2, 14, 2, 196, 60, 67, 8, 0, 1205, 3, 2, 26, 2, 1, 2, 0, 3, 0, 2, 9, 2, 3, 2, 0, 2, 0, 7, 0, 5, 0, 2, 0, 2, 0, 2, 2, 2, 1, 2, 0, 3, 0, 2, 0, 2, 0, 2, 0, 2, 0, 2, 1, 2, 0, 3, 3, 2, 6, 2, 3, 2, 3, 2, 0, 2, 9, 2, 16, 6, 2, 2, 4, 2, 16, 4421, 42719, 33, 4152, 8, 221, 3, 5761, 15, 7472, 3104, 541, 1507, 4938];
  const astralIdentifierCodes = [509, 0, 227, 0, 150, 4, 294, 9, 1368, 2, 2, 1, 6, 3, 41, 2, 5, 0, 166, 1, 574, 3, 9, 9, 370, 1, 154, 10, 50, 3, 123, 2, 54, 14, 32, 10, 3, 1, 11, 3, 46, 10, 8, 0, 46, 9, 7, 2, 37, 13, 2, 9, 6, 1, 45, 0, 13, 2, 49, 13, 9, 3, 2, 11, 83, 11, 7, 0, 161, 11, 6, 9, 7, 3, 56, 1, 2, 6, 3, 1, 3, 2, 10, 0, 11, 1, 3, 6, 4, 4, 193, 17, 10, 9, 5, 0, 82, 19, 13, 9, 214, 6, 3, 8, 28, 1, 83, 16, 16, 9, 82, 12, 9, 9, 84, 14, 5, 9, 243, 14, 166, 9, 71, 5, 2, 1, 3, 3, 2, 0, 2, 1, 13, 9, 120, 6, 3, 6, 4, 0, 29, 9, 41, 6, 2, 3, 9, 0, 10, 10, 47, 15, 406, 7, 2, 7, 17, 9, 57, 21, 2, 13, 123, 5, 4, 0, 2, 1, 2, 6, 2, 0, 9, 9, 49, 4, 2, 1, 2, 4, 9, 9, 330, 3, 19306, 9, 87, 9, 39, 4, 60, 6, 26, 9, 1014, 0, 2, 54, 8, 3, 82, 0, 12, 1, 19628, 1, 4706, 45, 3, 22, 543, 4, 4, 5, 9, 7, 3, 6, 31, 3, 149, 2, 1418, 49, 513, 54, 5, 49, 9, 0, 15, 0, 23, 4, 2, 14, 1361, 6, 2, 16, 3, 6, 2, 1, 2, 4, 262, 6, 10, 9, 357, 0, 62, 13, 1495, 6, 110, 6, 6, 9, 4759, 9, 787719, 239];
  
  function isInAstralSet(code, set) {
    let pos = 0x10000;
  
    for (let i = 0, length = set.length; i < length; i += 2) {
      pos += set[i];
      if (pos > code) return false;
      pos += set[i + 1];
      if (pos >= code) return true;
    }
  
    return false;
  }
  
  function isIdentifierStart(code) {
    if (code < 65) return code === 36;
    if (code <= 90) return true;
    if (code < 97) return code === 95;
    if (code <= 122) return true;
  
    if (code <= 0xffff) {
      return code >= 0xaa && nonASCIIidentifierStart.test(String.fromCharCode(code));
    }
  
    return isInAstralSet(code, astralIdentifierStartCodes);
  }
  
  function isIdentifierChar(code) {
    if (code < 48) return code === 36;
    if (code < 58) return true;
    if (code < 65) return false;
    if (code <= 90) return true;
    if (code < 97) return code === 95;
    if (code <= 122) return true;
  
    if (code <= 0xffff) {
      return code >= 0xaa && nonASCIIidentifier.test(String.fromCharCode(code));
    }
  
    return isInAstralSet(code, astralIdentifierStartCodes) || isInAstralSet(code, astralIdentifierCodes);
  }
  
  function isIdentifierName(name) {
    let isFirst = true;
  
    for (let i = 0; i < name.length; i++) {
      let cp = name.charCodeAt(i);
  
      if ((cp & 0xfc00) === 0xd800 && i + 1 < name.length) {
        const trail = name.charCodeAt(++i);
  
        if ((trail & 0xfc00) === 0xdc00) {
          cp = 0x10000 + ((cp & 0x3ff) << 10) + (trail & 0x3ff);
        }
      }
  
      if (isFirst) {
        isFirst = false;
  
        if (!isIdentifierStart(cp)) {
          return false;
        }
      } else if (!isIdentifierChar(cp)) {
        return false;
      }
    }
  
    return !isFirst;
  }
  },{}],28:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "isIdentifierName", {
    enumerable: true,
    get: function () {
      return _identifier.isIdentifierName;
    }
  });
  Object.defineProperty(exports, "isIdentifierChar", {
    enumerable: true,
    get: function () {
      return _identifier.isIdentifierChar;
    }
  });
  Object.defineProperty(exports, "isIdentifierStart", {
    enumerable: true,
    get: function () {
      return _identifier.isIdentifierStart;
    }
  });
  Object.defineProperty(exports, "isReservedWord", {
    enumerable: true,
    get: function () {
      return _keyword.isReservedWord;
    }
  });
  Object.defineProperty(exports, "isStrictBindOnlyReservedWord", {
    enumerable: true,
    get: function () {
      return _keyword.isStrictBindOnlyReservedWord;
    }
  });
  Object.defineProperty(exports, "isStrictBindReservedWord", {
    enumerable: true,
    get: function () {
      return _keyword.isStrictBindReservedWord;
    }
  });
  Object.defineProperty(exports, "isStrictReservedWord", {
    enumerable: true,
    get: function () {
      return _keyword.isStrictReservedWord;
    }
  });
  Object.defineProperty(exports, "isKeyword", {
    enumerable: true,
    get: function () {
      return _keyword.isKeyword;
    }
  });
  
  var _identifier = require("./identifier");
  
  var _keyword = require("./keyword");
  },{"./identifier":27,"./keyword":29}],29:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.isReservedWord = isReservedWord;
  exports.isStrictReservedWord = isStrictReservedWord;
  exports.isStrictBindOnlyReservedWord = isStrictBindOnlyReservedWord;
  exports.isStrictBindReservedWord = isStrictBindReservedWord;
  exports.isKeyword = isKeyword;
  const reservedWords = {
    keyword: ["break", "case", "catch", "continue", "debugger", "default", "do", "else", "finally", "for", "function", "if", "return", "switch", "throw", "try", "var", "const", "while", "with", "new", "this", "super", "class", "extends", "export", "import", "null", "true", "false", "in", "instanceof", "typeof", "void", "delete"],
    strict: ["implements", "interface", "let", "package", "private", "protected", "public", "static", "yield"],
    strictBind: ["eval", "arguments"]
  };
  const keywords = new Set(reservedWords.keyword);
  const reservedWordsStrictSet = new Set(reservedWords.strict);
  const reservedWordsStrictBindSet = new Set(reservedWords.strictBind);
  
  function isReservedWord(word, inModule) {
    return inModule && word === "await" || word === "enum";
  }
  
  function isStrictReservedWord(word, inModule) {
    return isReservedWord(word, inModule) || reservedWordsStrictSet.has(word);
  }
  
  function isStrictBindOnlyReservedWord(word) {
    return reservedWordsStrictBindSet.has(word);
  }
  
  function isStrictBindReservedWord(word, inModule) {
    return isStrictReservedWord(word, inModule) || isStrictBindOnlyReservedWord(word);
  }
  
  function isKeyword(word) {
    return keywords.has(word);
  }
  },{}],30:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = assertNode;
  
  var _isNode = require("../validators/isNode");
  
  function assertNode(node) {
    if (!(0, _isNode.default)(node)) {
      var _node$type;
  
      const type = (_node$type = node == null ? void 0 : node.type) != null ? _node$type : JSON.stringify(node);
      throw new TypeError(`Not a valid node of type "${type}"`);
    }
  }
  },{"../validators/isNode":96}],31:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.assertArrayExpression = assertArrayExpression;
  exports.assertAssignmentExpression = assertAssignmentExpression;
  exports.assertBinaryExpression = assertBinaryExpression;
  exports.assertInterpreterDirective = assertInterpreterDirective;
  exports.assertDirective = assertDirective;
  exports.assertDirectiveLiteral = assertDirectiveLiteral;
  exports.assertBlockStatement = assertBlockStatement;
  exports.assertBreakStatement = assertBreakStatement;
  exports.assertCallExpression = assertCallExpression;
  exports.assertCatchClause = assertCatchClause;
  exports.assertConditionalExpression = assertConditionalExpression;
  exports.assertContinueStatement = assertContinueStatement;
  exports.assertDebuggerStatement = assertDebuggerStatement;
  exports.assertDoWhileStatement = assertDoWhileStatement;
  exports.assertEmptyStatement = assertEmptyStatement;
  exports.assertExpressionStatement = assertExpressionStatement;
  exports.assertFile = assertFile;
  exports.assertForInStatement = assertForInStatement;
  exports.assertForStatement = assertForStatement;
  exports.assertFunctionDeclaration = assertFunctionDeclaration;
  exports.assertFunctionExpression = assertFunctionExpression;
  exports.assertIdentifier = assertIdentifier;
  exports.assertIfStatement = assertIfStatement;
  exports.assertLabeledStatement = assertLabeledStatement;
  exports.assertStringLiteral = assertStringLiteral;
  exports.assertNumericLiteral = assertNumericLiteral;
  exports.assertNullLiteral = assertNullLiteral;
  exports.assertBooleanLiteral = assertBooleanLiteral;
  exports.assertRegExpLiteral = assertRegExpLiteral;
  exports.assertLogicalExpression = assertLogicalExpression;
  exports.assertMemberExpression = assertMemberExpression;
  exports.assertNewExpression = assertNewExpression;
  exports.assertProgram = assertProgram;
  exports.assertObjectExpression = assertObjectExpression;
  exports.assertObjectMethod = assertObjectMethod;
  exports.assertObjectProperty = assertObjectProperty;
  exports.assertRestElement = assertRestElement;
  exports.assertReturnStatement = assertReturnStatement;
  exports.assertSequenceExpression = assertSequenceExpression;
  exports.assertParenthesizedExpression = assertParenthesizedExpression;
  exports.assertSwitchCase = assertSwitchCase;
  exports.assertSwitchStatement = assertSwitchStatement;
  exports.assertThisExpression = assertThisExpression;
  exports.assertThrowStatement = assertThrowStatement;
  exports.assertTryStatement = assertTryStatement;
  exports.assertUnaryExpression = assertUnaryExpression;
  exports.assertUpdateExpression = assertUpdateExpression;
  exports.assertVariableDeclaration = assertVariableDeclaration;
  exports.assertVariableDeclarator = assertVariableDeclarator;
  exports.assertWhileStatement = assertWhileStatement;
  exports.assertWithStatement = assertWithStatement;
  exports.assertAssignmentPattern = assertAssignmentPattern;
  exports.assertArrayPattern = assertArrayPattern;
  exports.assertArrowFunctionExpression = assertArrowFunctionExpression;
  exports.assertClassBody = assertClassBody;
  exports.assertClassExpression = assertClassExpression;
  exports.assertClassDeclaration = assertClassDeclaration;
  exports.assertExportAllDeclaration = assertExportAllDeclaration;
  exports.assertExportDefaultDeclaration = assertExportDefaultDeclaration;
  exports.assertExportNamedDeclaration = assertExportNamedDeclaration;
  exports.assertExportSpecifier = assertExportSpecifier;
  exports.assertForOfStatement = assertForOfStatement;
  exports.assertImportDeclaration = assertImportDeclaration;
  exports.assertImportDefaultSpecifier = assertImportDefaultSpecifier;
  exports.assertImportNamespaceSpecifier = assertImportNamespaceSpecifier;
  exports.assertImportSpecifier = assertImportSpecifier;
  exports.assertMetaProperty = assertMetaProperty;
  exports.assertClassMethod = assertClassMethod;
  exports.assertObjectPattern = assertObjectPattern;
  exports.assertSpreadElement = assertSpreadElement;
  exports.assertSuper = assertSuper;
  exports.assertTaggedTemplateExpression = assertTaggedTemplateExpression;
  exports.assertTemplateElement = assertTemplateElement;
  exports.assertTemplateLiteral = assertTemplateLiteral;
  exports.assertYieldExpression = assertYieldExpression;
  exports.assertAwaitExpression = assertAwaitExpression;
  exports.assertImport = assertImport;
  exports.assertBigIntLiteral = assertBigIntLiteral;
  exports.assertExportNamespaceSpecifier = assertExportNamespaceSpecifier;
  exports.assertOptionalMemberExpression = assertOptionalMemberExpression;
  exports.assertOptionalCallExpression = assertOptionalCallExpression;
  exports.assertClassProperty = assertClassProperty;
  exports.assertClassPrivateProperty = assertClassPrivateProperty;
  exports.assertClassPrivateMethod = assertClassPrivateMethod;
  exports.assertPrivateName = assertPrivateName;
  exports.assertAnyTypeAnnotation = assertAnyTypeAnnotation;
  exports.assertArrayTypeAnnotation = assertArrayTypeAnnotation;
  exports.assertBooleanTypeAnnotation = assertBooleanTypeAnnotation;
  exports.assertBooleanLiteralTypeAnnotation = assertBooleanLiteralTypeAnnotation;
  exports.assertNullLiteralTypeAnnotation = assertNullLiteralTypeAnnotation;
  exports.assertClassImplements = assertClassImplements;
  exports.assertDeclareClass = assertDeclareClass;
  exports.assertDeclareFunction = assertDeclareFunction;
  exports.assertDeclareInterface = assertDeclareInterface;
  exports.assertDeclareModule = assertDeclareModule;
  exports.assertDeclareModuleExports = assertDeclareModuleExports;
  exports.assertDeclareTypeAlias = assertDeclareTypeAlias;
  exports.assertDeclareOpaqueType = assertDeclareOpaqueType;
  exports.assertDeclareVariable = assertDeclareVariable;
  exports.assertDeclareExportDeclaration = assertDeclareExportDeclaration;
  exports.assertDeclareExportAllDeclaration = assertDeclareExportAllDeclaration;
  exports.assertDeclaredPredicate = assertDeclaredPredicate;
  exports.assertExistsTypeAnnotation = assertExistsTypeAnnotation;
  exports.assertFunctionTypeAnnotation = assertFunctionTypeAnnotation;
  exports.assertFunctionTypeParam = assertFunctionTypeParam;
  exports.assertGenericTypeAnnotation = assertGenericTypeAnnotation;
  exports.assertInferredPredicate = assertInferredPredicate;
  exports.assertInterfaceExtends = assertInterfaceExtends;
  exports.assertInterfaceDeclaration = assertInterfaceDeclaration;
  exports.assertInterfaceTypeAnnotation = assertInterfaceTypeAnnotation;
  exports.assertIntersectionTypeAnnotation = assertIntersectionTypeAnnotation;
  exports.assertMixedTypeAnnotation = assertMixedTypeAnnotation;
  exports.assertEmptyTypeAnnotation = assertEmptyTypeAnnotation;
  exports.assertNullableTypeAnnotation = assertNullableTypeAnnotation;
  exports.assertNumberLiteralTypeAnnotation = assertNumberLiteralTypeAnnotation;
  exports.assertNumberTypeAnnotation = assertNumberTypeAnnotation;
  exports.assertObjectTypeAnnotation = assertObjectTypeAnnotation;
  exports.assertObjectTypeInternalSlot = assertObjectTypeInternalSlot;
  exports.assertObjectTypeCallProperty = assertObjectTypeCallProperty;
  exports.assertObjectTypeIndexer = assertObjectTypeIndexer;
  exports.assertObjectTypeProperty = assertObjectTypeProperty;
  exports.assertObjectTypeSpreadProperty = assertObjectTypeSpreadProperty;
  exports.assertOpaqueType = assertOpaqueType;
  exports.assertQualifiedTypeIdentifier = assertQualifiedTypeIdentifier;
  exports.assertStringLiteralTypeAnnotation = assertStringLiteralTypeAnnotation;
  exports.assertStringTypeAnnotation = assertStringTypeAnnotation;
  exports.assertSymbolTypeAnnotation = assertSymbolTypeAnnotation;
  exports.assertThisTypeAnnotation = assertThisTypeAnnotation;
  exports.assertTupleTypeAnnotation = assertTupleTypeAnnotation;
  exports.assertTypeofTypeAnnotation = assertTypeofTypeAnnotation;
  exports.assertTypeAlias = assertTypeAlias;
  exports.assertTypeAnnotation = assertTypeAnnotation;
  exports.assertTypeCastExpression = assertTypeCastExpression;
  exports.assertTypeParameter = assertTypeParameter;
  exports.assertTypeParameterDeclaration = assertTypeParameterDeclaration;
  exports.assertTypeParameterInstantiation = assertTypeParameterInstantiation;
  exports.assertUnionTypeAnnotation = assertUnionTypeAnnotation;
  exports.assertVariance = assertVariance;
  exports.assertVoidTypeAnnotation = assertVoidTypeAnnotation;
  exports.assertEnumDeclaration = assertEnumDeclaration;
  exports.assertEnumBooleanBody = assertEnumBooleanBody;
  exports.assertEnumNumberBody = assertEnumNumberBody;
  exports.assertEnumStringBody = assertEnumStringBody;
  exports.assertEnumSymbolBody = assertEnumSymbolBody;
  exports.assertEnumBooleanMember = assertEnumBooleanMember;
  exports.assertEnumNumberMember = assertEnumNumberMember;
  exports.assertEnumStringMember = assertEnumStringMember;
  exports.assertEnumDefaultedMember = assertEnumDefaultedMember;
  exports.assertIndexedAccessType = assertIndexedAccessType;
  exports.assertOptionalIndexedAccessType = assertOptionalIndexedAccessType;
  exports.assertJSXAttribute = assertJSXAttribute;
  exports.assertJSXClosingElement = assertJSXClosingElement;
  exports.assertJSXElement = assertJSXElement;
  exports.assertJSXEmptyExpression = assertJSXEmptyExpression;
  exports.assertJSXExpressionContainer = assertJSXExpressionContainer;
  exports.assertJSXSpreadChild = assertJSXSpreadChild;
  exports.assertJSXIdentifier = assertJSXIdentifier;
  exports.assertJSXMemberExpression = assertJSXMemberExpression;
  exports.assertJSXNamespacedName = assertJSXNamespacedName;
  exports.assertJSXOpeningElement = assertJSXOpeningElement;
  exports.assertJSXSpreadAttribute = assertJSXSpreadAttribute;
  exports.assertJSXText = assertJSXText;
  exports.assertJSXFragment = assertJSXFragment;
  exports.assertJSXOpeningFragment = assertJSXOpeningFragment;
  exports.assertJSXClosingFragment = assertJSXClosingFragment;
  exports.assertNoop = assertNoop;
  exports.assertPlaceholder = assertPlaceholder;
  exports.assertV8IntrinsicIdentifier = assertV8IntrinsicIdentifier;
  exports.assertArgumentPlaceholder = assertArgumentPlaceholder;
  exports.assertBindExpression = assertBindExpression;
  exports.assertImportAttribute = assertImportAttribute;
  exports.assertDecorator = assertDecorator;
  exports.assertDoExpression = assertDoExpression;
  exports.assertExportDefaultSpecifier = assertExportDefaultSpecifier;
  exports.assertRecordExpression = assertRecordExpression;
  exports.assertTupleExpression = assertTupleExpression;
  exports.assertDecimalLiteral = assertDecimalLiteral;
  exports.assertStaticBlock = assertStaticBlock;
  exports.assertModuleExpression = assertModuleExpression;
  exports.assertTopicReference = assertTopicReference;
  exports.assertPipelineTopicExpression = assertPipelineTopicExpression;
  exports.assertPipelineBareFunction = assertPipelineBareFunction;
  exports.assertPipelinePrimaryTopicReference = assertPipelinePrimaryTopicReference;
  exports.assertTSParameterProperty = assertTSParameterProperty;
  exports.assertTSDeclareFunction = assertTSDeclareFunction;
  exports.assertTSDeclareMethod = assertTSDeclareMethod;
  exports.assertTSQualifiedName = assertTSQualifiedName;
  exports.assertTSCallSignatureDeclaration = assertTSCallSignatureDeclaration;
  exports.assertTSConstructSignatureDeclaration = assertTSConstructSignatureDeclaration;
  exports.assertTSPropertySignature = assertTSPropertySignature;
  exports.assertTSMethodSignature = assertTSMethodSignature;
  exports.assertTSIndexSignature = assertTSIndexSignature;
  exports.assertTSAnyKeyword = assertTSAnyKeyword;
  exports.assertTSBooleanKeyword = assertTSBooleanKeyword;
  exports.assertTSBigIntKeyword = assertTSBigIntKeyword;
  exports.assertTSIntrinsicKeyword = assertTSIntrinsicKeyword;
  exports.assertTSNeverKeyword = assertTSNeverKeyword;
  exports.assertTSNullKeyword = assertTSNullKeyword;
  exports.assertTSNumberKeyword = assertTSNumberKeyword;
  exports.assertTSObjectKeyword = assertTSObjectKeyword;
  exports.assertTSStringKeyword = assertTSStringKeyword;
  exports.assertTSSymbolKeyword = assertTSSymbolKeyword;
  exports.assertTSUndefinedKeyword = assertTSUndefinedKeyword;
  exports.assertTSUnknownKeyword = assertTSUnknownKeyword;
  exports.assertTSVoidKeyword = assertTSVoidKeyword;
  exports.assertTSThisType = assertTSThisType;
  exports.assertTSFunctionType = assertTSFunctionType;
  exports.assertTSConstructorType = assertTSConstructorType;
  exports.assertTSTypeReference = assertTSTypeReference;
  exports.assertTSTypePredicate = assertTSTypePredicate;
  exports.assertTSTypeQuery = assertTSTypeQuery;
  exports.assertTSTypeLiteral = assertTSTypeLiteral;
  exports.assertTSArrayType = assertTSArrayType;
  exports.assertTSTupleType = assertTSTupleType;
  exports.assertTSOptionalType = assertTSOptionalType;
  exports.assertTSRestType = assertTSRestType;
  exports.assertTSNamedTupleMember = assertTSNamedTupleMember;
  exports.assertTSUnionType = assertTSUnionType;
  exports.assertTSIntersectionType = assertTSIntersectionType;
  exports.assertTSConditionalType = assertTSConditionalType;
  exports.assertTSInferType = assertTSInferType;
  exports.assertTSParenthesizedType = assertTSParenthesizedType;
  exports.assertTSTypeOperator = assertTSTypeOperator;
  exports.assertTSIndexedAccessType = assertTSIndexedAccessType;
  exports.assertTSMappedType = assertTSMappedType;
  exports.assertTSLiteralType = assertTSLiteralType;
  exports.assertTSExpressionWithTypeArguments = assertTSExpressionWithTypeArguments;
  exports.assertTSInterfaceDeclaration = assertTSInterfaceDeclaration;
  exports.assertTSInterfaceBody = assertTSInterfaceBody;
  exports.assertTSTypeAliasDeclaration = assertTSTypeAliasDeclaration;
  exports.assertTSAsExpression = assertTSAsExpression;
  exports.assertTSTypeAssertion = assertTSTypeAssertion;
  exports.assertTSEnumDeclaration = assertTSEnumDeclaration;
  exports.assertTSEnumMember = assertTSEnumMember;
  exports.assertTSModuleDeclaration = assertTSModuleDeclaration;
  exports.assertTSModuleBlock = assertTSModuleBlock;
  exports.assertTSImportType = assertTSImportType;
  exports.assertTSImportEqualsDeclaration = assertTSImportEqualsDeclaration;
  exports.assertTSExternalModuleReference = assertTSExternalModuleReference;
  exports.assertTSNonNullExpression = assertTSNonNullExpression;
  exports.assertTSExportAssignment = assertTSExportAssignment;
  exports.assertTSNamespaceExportDeclaration = assertTSNamespaceExportDeclaration;
  exports.assertTSTypeAnnotation = assertTSTypeAnnotation;
  exports.assertTSTypeParameterInstantiation = assertTSTypeParameterInstantiation;
  exports.assertTSTypeParameterDeclaration = assertTSTypeParameterDeclaration;
  exports.assertTSTypeParameter = assertTSTypeParameter;
  exports.assertExpression = assertExpression;
  exports.assertBinary = assertBinary;
  exports.assertScopable = assertScopable;
  exports.assertBlockParent = assertBlockParent;
  exports.assertBlock = assertBlock;
  exports.assertStatement = assertStatement;
  exports.assertTerminatorless = assertTerminatorless;
  exports.assertCompletionStatement = assertCompletionStatement;
  exports.assertConditional = assertConditional;
  exports.assertLoop = assertLoop;
  exports.assertWhile = assertWhile;
  exports.assertExpressionWrapper = assertExpressionWrapper;
  exports.assertFor = assertFor;
  exports.assertForXStatement = assertForXStatement;
  exports.assertFunction = assertFunction;
  exports.assertFunctionParent = assertFunctionParent;
  exports.assertPureish = assertPureish;
  exports.assertDeclaration = assertDeclaration;
  exports.assertPatternLike = assertPatternLike;
  exports.assertLVal = assertLVal;
  exports.assertTSEntityName = assertTSEntityName;
  exports.assertLiteral = assertLiteral;
  exports.assertImmutable = assertImmutable;
  exports.assertUserWhitespacable = assertUserWhitespacable;
  exports.assertMethod = assertMethod;
  exports.assertObjectMember = assertObjectMember;
  exports.assertProperty = assertProperty;
  exports.assertUnaryLike = assertUnaryLike;
  exports.assertPattern = assertPattern;
  exports.assertClass = assertClass;
  exports.assertModuleDeclaration = assertModuleDeclaration;
  exports.assertExportDeclaration = assertExportDeclaration;
  exports.assertModuleSpecifier = assertModuleSpecifier;
  exports.assertPrivate = assertPrivate;
  exports.assertFlow = assertFlow;
  exports.assertFlowType = assertFlowType;
  exports.assertFlowBaseAnnotation = assertFlowBaseAnnotation;
  exports.assertFlowDeclaration = assertFlowDeclaration;
  exports.assertFlowPredicate = assertFlowPredicate;
  exports.assertEnumBody = assertEnumBody;
  exports.assertEnumMember = assertEnumMember;
  exports.assertJSX = assertJSX;
  exports.assertTSTypeElement = assertTSTypeElement;
  exports.assertTSType = assertTSType;
  exports.assertTSBaseType = assertTSBaseType;
  exports.assertNumberLiteral = assertNumberLiteral;
  exports.assertRegexLiteral = assertRegexLiteral;
  exports.assertRestProperty = assertRestProperty;
  exports.assertSpreadProperty = assertSpreadProperty;
  
  var _is = require("../../validators/is");
  
  function assert(type, node, opts) {
    if (!(0, _is.default)(type, node, opts)) {
      throw new Error(`Expected type "${type}" with option ${JSON.stringify(opts)}, ` + `but instead got "${node.type}".`);
    }
  }
  
  function assertArrayExpression(node, opts) {
    assert("ArrayExpression", node, opts);
  }
  
  function assertAssignmentExpression(node, opts) {
    assert("AssignmentExpression", node, opts);
  }
  
  function assertBinaryExpression(node, opts) {
    assert("BinaryExpression", node, opts);
  }
  
  function assertInterpreterDirective(node, opts) {
    assert("InterpreterDirective", node, opts);
  }
  
  function assertDirective(node, opts) {
    assert("Directive", node, opts);
  }
  
  function assertDirectiveLiteral(node, opts) {
    assert("DirectiveLiteral", node, opts);
  }
  
  function assertBlockStatement(node, opts) {
    assert("BlockStatement", node, opts);
  }
  
  function assertBreakStatement(node, opts) {
    assert("BreakStatement", node, opts);
  }
  
  function assertCallExpression(node, opts) {
    assert("CallExpression", node, opts);
  }
  
  function assertCatchClause(node, opts) {
    assert("CatchClause", node, opts);
  }
  
  function assertConditionalExpression(node, opts) {
    assert("ConditionalExpression", node, opts);
  }
  
  function assertContinueStatement(node, opts) {
    assert("ContinueStatement", node, opts);
  }
  
  function assertDebuggerStatement(node, opts) {
    assert("DebuggerStatement", node, opts);
  }
  
  function assertDoWhileStatement(node, opts) {
    assert("DoWhileStatement", node, opts);
  }
  
  function assertEmptyStatement(node, opts) {
    assert("EmptyStatement", node, opts);
  }
  
  function assertExpressionStatement(node, opts) {
    assert("ExpressionStatement", node, opts);
  }
  
  function assertFile(node, opts) {
    assert("File", node, opts);
  }
  
  function assertForInStatement(node, opts) {
    assert("ForInStatement", node, opts);
  }
  
  function assertForStatement(node, opts) {
    assert("ForStatement", node, opts);
  }
  
  function assertFunctionDeclaration(node, opts) {
    assert("FunctionDeclaration", node, opts);
  }
  
  function assertFunctionExpression(node, opts) {
    assert("FunctionExpression", node, opts);
  }
  
  function assertIdentifier(node, opts) {
    assert("Identifier", node, opts);
  }
  
  function assertIfStatement(node, opts) {
    assert("IfStatement", node, opts);
  }
  
  function assertLabeledStatement(node, opts) {
    assert("LabeledStatement", node, opts);
  }
  
  function assertStringLiteral(node, opts) {
    assert("StringLiteral", node, opts);
  }
  
  function assertNumericLiteral(node, opts) {
    assert("NumericLiteral", node, opts);
  }
  
  function assertNullLiteral(node, opts) {
    assert("NullLiteral", node, opts);
  }
  
  function assertBooleanLiteral(node, opts) {
    assert("BooleanLiteral", node, opts);
  }
  
  function assertRegExpLiteral(node, opts) {
    assert("RegExpLiteral", node, opts);
  }
  
  function assertLogicalExpression(node, opts) {
    assert("LogicalExpression", node, opts);
  }
  
  function assertMemberExpression(node, opts) {
    assert("MemberExpression", node, opts);
  }
  
  function assertNewExpression(node, opts) {
    assert("NewExpression", node, opts);
  }
  
  function assertProgram(node, opts) {
    assert("Program", node, opts);
  }
  
  function assertObjectExpression(node, opts) {
    assert("ObjectExpression", node, opts);
  }
  
  function assertObjectMethod(node, opts) {
    assert("ObjectMethod", node, opts);
  }
  
  function assertObjectProperty(node, opts) {
    assert("ObjectProperty", node, opts);
  }
  
  function assertRestElement(node, opts) {
    assert("RestElement", node, opts);
  }
  
  function assertReturnStatement(node, opts) {
    assert("ReturnStatement", node, opts);
  }
  
  function assertSequenceExpression(node, opts) {
    assert("SequenceExpression", node, opts);
  }
  
  function assertParenthesizedExpression(node, opts) {
    assert("ParenthesizedExpression", node, opts);
  }
  
  function assertSwitchCase(node, opts) {
    assert("SwitchCase", node, opts);
  }
  
  function assertSwitchStatement(node, opts) {
    assert("SwitchStatement", node, opts);
  }
  
  function assertThisExpression(node, opts) {
    assert("ThisExpression", node, opts);
  }
  
  function assertThrowStatement(node, opts) {
    assert("ThrowStatement", node, opts);
  }
  
  function assertTryStatement(node, opts) {
    assert("TryStatement", node, opts);
  }
  
  function assertUnaryExpression(node, opts) {
    assert("UnaryExpression", node, opts);
  }
  
  function assertUpdateExpression(node, opts) {
    assert("UpdateExpression", node, opts);
  }
  
  function assertVariableDeclaration(node, opts) {
    assert("VariableDeclaration", node, opts);
  }
  
  function assertVariableDeclarator(node, opts) {
    assert("VariableDeclarator", node, opts);
  }
  
  function assertWhileStatement(node, opts) {
    assert("WhileStatement", node, opts);
  }
  
  function assertWithStatement(node, opts) {
    assert("WithStatement", node, opts);
  }
  
  function assertAssignmentPattern(node, opts) {
    assert("AssignmentPattern", node, opts);
  }
  
  function assertArrayPattern(node, opts) {
    assert("ArrayPattern", node, opts);
  }
  
  function assertArrowFunctionExpression(node, opts) {
    assert("ArrowFunctionExpression", node, opts);
  }
  
  function assertClassBody(node, opts) {
    assert("ClassBody", node, opts);
  }
  
  function assertClassExpression(node, opts) {
    assert("ClassExpression", node, opts);
  }
  
  function assertClassDeclaration(node, opts) {
    assert("ClassDeclaration", node, opts);
  }
  
  function assertExportAllDeclaration(node, opts) {
    assert("ExportAllDeclaration", node, opts);
  }
  
  function assertExportDefaultDeclaration(node, opts) {
    assert("ExportDefaultDeclaration", node, opts);
  }
  
  function assertExportNamedDeclaration(node, opts) {
    assert("ExportNamedDeclaration", node, opts);
  }
  
  function assertExportSpecifier(node, opts) {
    assert("ExportSpecifier", node, opts);
  }
  
  function assertForOfStatement(node, opts) {
    assert("ForOfStatement", node, opts);
  }
  
  function assertImportDeclaration(node, opts) {
    assert("ImportDeclaration", node, opts);
  }
  
  function assertImportDefaultSpecifier(node, opts) {
    assert("ImportDefaultSpecifier", node, opts);
  }
  
  function assertImportNamespaceSpecifier(node, opts) {
    assert("ImportNamespaceSpecifier", node, opts);
  }
  
  function assertImportSpecifier(node, opts) {
    assert("ImportSpecifier", node, opts);
  }
  
  function assertMetaProperty(node, opts) {
    assert("MetaProperty", node, opts);
  }
  
  function assertClassMethod(node, opts) {
    assert("ClassMethod", node, opts);
  }
  
  function assertObjectPattern(node, opts) {
    assert("ObjectPattern", node, opts);
  }
  
  function assertSpreadElement(node, opts) {
    assert("SpreadElement", node, opts);
  }
  
  function assertSuper(node, opts) {
    assert("Super", node, opts);
  }
  
  function assertTaggedTemplateExpression(node, opts) {
    assert("TaggedTemplateExpression", node, opts);
  }
  
  function assertTemplateElement(node, opts) {
    assert("TemplateElement", node, opts);
  }
  
  function assertTemplateLiteral(node, opts) {
    assert("TemplateLiteral", node, opts);
  }
  
  function assertYieldExpression(node, opts) {
    assert("YieldExpression", node, opts);
  }
  
  function assertAwaitExpression(node, opts) {
    assert("AwaitExpression", node, opts);
  }
  
  function assertImport(node, opts) {
    assert("Import", node, opts);
  }
  
  function assertBigIntLiteral(node, opts) {
    assert("BigIntLiteral", node, opts);
  }
  
  function assertExportNamespaceSpecifier(node, opts) {
    assert("ExportNamespaceSpecifier", node, opts);
  }
  
  function assertOptionalMemberExpression(node, opts) {
    assert("OptionalMemberExpression", node, opts);
  }
  
  function assertOptionalCallExpression(node, opts) {
    assert("OptionalCallExpression", node, opts);
  }
  
  function assertClassProperty(node, opts) {
    assert("ClassProperty", node, opts);
  }
  
  function assertClassPrivateProperty(node, opts) {
    assert("ClassPrivateProperty", node, opts);
  }
  
  function assertClassPrivateMethod(node, opts) {
    assert("ClassPrivateMethod", node, opts);
  }
  
  function assertPrivateName(node, opts) {
    assert("PrivateName", node, opts);
  }
  
  function assertAnyTypeAnnotation(node, opts) {
    assert("AnyTypeAnnotation", node, opts);
  }
  
  function assertArrayTypeAnnotation(node, opts) {
    assert("ArrayTypeAnnotation", node, opts);
  }
  
  function assertBooleanTypeAnnotation(node, opts) {
    assert("BooleanTypeAnnotation", node, opts);
  }
  
  function assertBooleanLiteralTypeAnnotation(node, opts) {
    assert("BooleanLiteralTypeAnnotation", node, opts);
  }
  
  function assertNullLiteralTypeAnnotation(node, opts) {
    assert("NullLiteralTypeAnnotation", node, opts);
  }
  
  function assertClassImplements(node, opts) {
    assert("ClassImplements", node, opts);
  }
  
  function assertDeclareClass(node, opts) {
    assert("DeclareClass", node, opts);
  }
  
  function assertDeclareFunction(node, opts) {
    assert("DeclareFunction", node, opts);
  }
  
  function assertDeclareInterface(node, opts) {
    assert("DeclareInterface", node, opts);
  }
  
  function assertDeclareModule(node, opts) {
    assert("DeclareModule", node, opts);
  }
  
  function assertDeclareModuleExports(node, opts) {
    assert("DeclareModuleExports", node, opts);
  }
  
  function assertDeclareTypeAlias(node, opts) {
    assert("DeclareTypeAlias", node, opts);
  }
  
  function assertDeclareOpaqueType(node, opts) {
    assert("DeclareOpaqueType", node, opts);
  }
  
  function assertDeclareVariable(node, opts) {
    assert("DeclareVariable", node, opts);
  }
  
  function assertDeclareExportDeclaration(node, opts) {
    assert("DeclareExportDeclaration", node, opts);
  }
  
  function assertDeclareExportAllDeclaration(node, opts) {
    assert("DeclareExportAllDeclaration", node, opts);
  }
  
  function assertDeclaredPredicate(node, opts) {
    assert("DeclaredPredicate", node, opts);
  }
  
  function assertExistsTypeAnnotation(node, opts) {
    assert("ExistsTypeAnnotation", node, opts);
  }
  
  function assertFunctionTypeAnnotation(node, opts) {
    assert("FunctionTypeAnnotation", node, opts);
  }
  
  function assertFunctionTypeParam(node, opts) {
    assert("FunctionTypeParam", node, opts);
  }
  
  function assertGenericTypeAnnotation(node, opts) {
    assert("GenericTypeAnnotation", node, opts);
  }
  
  function assertInferredPredicate(node, opts) {
    assert("InferredPredicate", node, opts);
  }
  
  function assertInterfaceExtends(node, opts) {
    assert("InterfaceExtends", node, opts);
  }
  
  function assertInterfaceDeclaration(node, opts) {
    assert("InterfaceDeclaration", node, opts);
  }
  
  function assertInterfaceTypeAnnotation(node, opts) {
    assert("InterfaceTypeAnnotation", node, opts);
  }
  
  function assertIntersectionTypeAnnotation(node, opts) {
    assert("IntersectionTypeAnnotation", node, opts);
  }
  
  function assertMixedTypeAnnotation(node, opts) {
    assert("MixedTypeAnnotation", node, opts);
  }
  
  function assertEmptyTypeAnnotation(node, opts) {
    assert("EmptyTypeAnnotation", node, opts);
  }
  
  function assertNullableTypeAnnotation(node, opts) {
    assert("NullableTypeAnnotation", node, opts);
  }
  
  function assertNumberLiteralTypeAnnotation(node, opts) {
    assert("NumberLiteralTypeAnnotation", node, opts);
  }
  
  function assertNumberTypeAnnotation(node, opts) {
    assert("NumberTypeAnnotation", node, opts);
  }
  
  function assertObjectTypeAnnotation(node, opts) {
    assert("ObjectTypeAnnotation", node, opts);
  }
  
  function assertObjectTypeInternalSlot(node, opts) {
    assert("ObjectTypeInternalSlot", node, opts);
  }
  
  function assertObjectTypeCallProperty(node, opts) {
    assert("ObjectTypeCallProperty", node, opts);
  }
  
  function assertObjectTypeIndexer(node, opts) {
    assert("ObjectTypeIndexer", node, opts);
  }
  
  function assertObjectTypeProperty(node, opts) {
    assert("ObjectTypeProperty", node, opts);
  }
  
  function assertObjectTypeSpreadProperty(node, opts) {
    assert("ObjectTypeSpreadProperty", node, opts);
  }
  
  function assertOpaqueType(node, opts) {
    assert("OpaqueType", node, opts);
  }
  
  function assertQualifiedTypeIdentifier(node, opts) {
    assert("QualifiedTypeIdentifier", node, opts);
  }
  
  function assertStringLiteralTypeAnnotation(node, opts) {
    assert("StringLiteralTypeAnnotation", node, opts);
  }
  
  function assertStringTypeAnnotation(node, opts) {
    assert("StringTypeAnnotation", node, opts);
  }
  
  function assertSymbolTypeAnnotation(node, opts) {
    assert("SymbolTypeAnnotation", node, opts);
  }
  
  function assertThisTypeAnnotation(node, opts) {
    assert("ThisTypeAnnotation", node, opts);
  }
  
  function assertTupleTypeAnnotation(node, opts) {
    assert("TupleTypeAnnotation", node, opts);
  }
  
  function assertTypeofTypeAnnotation(node, opts) {
    assert("TypeofTypeAnnotation", node, opts);
  }
  
  function assertTypeAlias(node, opts) {
    assert("TypeAlias", node, opts);
  }
  
  function assertTypeAnnotation(node, opts) {
    assert("TypeAnnotation", node, opts);
  }
  
  function assertTypeCastExpression(node, opts) {
    assert("TypeCastExpression", node, opts);
  }
  
  function assertTypeParameter(node, opts) {
    assert("TypeParameter", node, opts);
  }
  
  function assertTypeParameterDeclaration(node, opts) {
    assert("TypeParameterDeclaration", node, opts);
  }
  
  function assertTypeParameterInstantiation(node, opts) {
    assert("TypeParameterInstantiation", node, opts);
  }
  
  function assertUnionTypeAnnotation(node, opts) {
    assert("UnionTypeAnnotation", node, opts);
  }
  
  function assertVariance(node, opts) {
    assert("Variance", node, opts);
  }
  
  function assertVoidTypeAnnotation(node, opts) {
    assert("VoidTypeAnnotation", node, opts);
  }
  
  function assertEnumDeclaration(node, opts) {
    assert("EnumDeclaration", node, opts);
  }
  
  function assertEnumBooleanBody(node, opts) {
    assert("EnumBooleanBody", node, opts);
  }
  
  function assertEnumNumberBody(node, opts) {
    assert("EnumNumberBody", node, opts);
  }
  
  function assertEnumStringBody(node, opts) {
    assert("EnumStringBody", node, opts);
  }
  
  function assertEnumSymbolBody(node, opts) {
    assert("EnumSymbolBody", node, opts);
  }
  
  function assertEnumBooleanMember(node, opts) {
    assert("EnumBooleanMember", node, opts);
  }
  
  function assertEnumNumberMember(node, opts) {
    assert("EnumNumberMember", node, opts);
  }
  
  function assertEnumStringMember(node, opts) {
    assert("EnumStringMember", node, opts);
  }
  
  function assertEnumDefaultedMember(node, opts) {
    assert("EnumDefaultedMember", node, opts);
  }
  
  function assertIndexedAccessType(node, opts) {
    assert("IndexedAccessType", node, opts);
  }
  
  function assertOptionalIndexedAccessType(node, opts) {
    assert("OptionalIndexedAccessType", node, opts);
  }
  
  function assertJSXAttribute(node, opts) {
    assert("JSXAttribute", node, opts);
  }
  
  function assertJSXClosingElement(node, opts) {
    assert("JSXClosingElement", node, opts);
  }
  
  function assertJSXElement(node, opts) {
    assert("JSXElement", node, opts);
  }
  
  function assertJSXEmptyExpression(node, opts) {
    assert("JSXEmptyExpression", node, opts);
  }
  
  function assertJSXExpressionContainer(node, opts) {
    assert("JSXExpressionContainer", node, opts);
  }
  
  function assertJSXSpreadChild(node, opts) {
    assert("JSXSpreadChild", node, opts);
  }
  
  function assertJSXIdentifier(node, opts) {
    assert("JSXIdentifier", node, opts);
  }
  
  function assertJSXMemberExpression(node, opts) {
    assert("JSXMemberExpression", node, opts);
  }
  
  function assertJSXNamespacedName(node, opts) {
    assert("JSXNamespacedName", node, opts);
  }
  
  function assertJSXOpeningElement(node, opts) {
    assert("JSXOpeningElement", node, opts);
  }
  
  function assertJSXSpreadAttribute(node, opts) {
    assert("JSXSpreadAttribute", node, opts);
  }
  
  function assertJSXText(node, opts) {
    assert("JSXText", node, opts);
  }
  
  function assertJSXFragment(node, opts) {
    assert("JSXFragment", node, opts);
  }
  
  function assertJSXOpeningFragment(node, opts) {
    assert("JSXOpeningFragment", node, opts);
  }
  
  function assertJSXClosingFragment(node, opts) {
    assert("JSXClosingFragment", node, opts);
  }
  
  function assertNoop(node, opts) {
    assert("Noop", node, opts);
  }
  
  function assertPlaceholder(node, opts) {
    assert("Placeholder", node, opts);
  }
  
  function assertV8IntrinsicIdentifier(node, opts) {
    assert("V8IntrinsicIdentifier", node, opts);
  }
  
  function assertArgumentPlaceholder(node, opts) {
    assert("ArgumentPlaceholder", node, opts);
  }
  
  function assertBindExpression(node, opts) {
    assert("BindExpression", node, opts);
  }
  
  function assertImportAttribute(node, opts) {
    assert("ImportAttribute", node, opts);
  }
  
  function assertDecorator(node, opts) {
    assert("Decorator", node, opts);
  }
  
  function assertDoExpression(node, opts) {
    assert("DoExpression", node, opts);
  }
  
  function assertExportDefaultSpecifier(node, opts) {
    assert("ExportDefaultSpecifier", node, opts);
  }
  
  function assertRecordExpression(node, opts) {
    assert("RecordExpression", node, opts);
  }
  
  function assertTupleExpression(node, opts) {
    assert("TupleExpression", node, opts);
  }
  
  function assertDecimalLiteral(node, opts) {
    assert("DecimalLiteral", node, opts);
  }
  
  function assertStaticBlock(node, opts) {
    assert("StaticBlock", node, opts);
  }
  
  function assertModuleExpression(node, opts) {
    assert("ModuleExpression", node, opts);
  }
  
  function assertTopicReference(node, opts) {
    assert("TopicReference", node, opts);
  }
  
  function assertPipelineTopicExpression(node, opts) {
    assert("PipelineTopicExpression", node, opts);
  }
  
  function assertPipelineBareFunction(node, opts) {
    assert("PipelineBareFunction", node, opts);
  }
  
  function assertPipelinePrimaryTopicReference(node, opts) {
    assert("PipelinePrimaryTopicReference", node, opts);
  }
  
  function assertTSParameterProperty(node, opts) {
    assert("TSParameterProperty", node, opts);
  }
  
  function assertTSDeclareFunction(node, opts) {
    assert("TSDeclareFunction", node, opts);
  }
  
  function assertTSDeclareMethod(node, opts) {
    assert("TSDeclareMethod", node, opts);
  }
  
  function assertTSQualifiedName(node, opts) {
    assert("TSQualifiedName", node, opts);
  }
  
  function assertTSCallSignatureDeclaration(node, opts) {
    assert("TSCallSignatureDeclaration", node, opts);
  }
  
  function assertTSConstructSignatureDeclaration(node, opts) {
    assert("TSConstructSignatureDeclaration", node, opts);
  }
  
  function assertTSPropertySignature(node, opts) {
    assert("TSPropertySignature", node, opts);
  }
  
  function assertTSMethodSignature(node, opts) {
    assert("TSMethodSignature", node, opts);
  }
  
  function assertTSIndexSignature(node, opts) {
    assert("TSIndexSignature", node, opts);
  }
  
  function assertTSAnyKeyword(node, opts) {
    assert("TSAnyKeyword", node, opts);
  }
  
  function assertTSBooleanKeyword(node, opts) {
    assert("TSBooleanKeyword", node, opts);
  }
  
  function assertTSBigIntKeyword(node, opts) {
    assert("TSBigIntKeyword", node, opts);
  }
  
  function assertTSIntrinsicKeyword(node, opts) {
    assert("TSIntrinsicKeyword", node, opts);
  }
  
  function assertTSNeverKeyword(node, opts) {
    assert("TSNeverKeyword", node, opts);
  }
  
  function assertTSNullKeyword(node, opts) {
    assert("TSNullKeyword", node, opts);
  }
  
  function assertTSNumberKeyword(node, opts) {
    assert("TSNumberKeyword", node, opts);
  }
  
  function assertTSObjectKeyword(node, opts) {
    assert("TSObjectKeyword", node, opts);
  }
  
  function assertTSStringKeyword(node, opts) {
    assert("TSStringKeyword", node, opts);
  }
  
  function assertTSSymbolKeyword(node, opts) {
    assert("TSSymbolKeyword", node, opts);
  }
  
  function assertTSUndefinedKeyword(node, opts) {
    assert("TSUndefinedKeyword", node, opts);
  }
  
  function assertTSUnknownKeyword(node, opts) {
    assert("TSUnknownKeyword", node, opts);
  }
  
  function assertTSVoidKeyword(node, opts) {
    assert("TSVoidKeyword", node, opts);
  }
  
  function assertTSThisType(node, opts) {
    assert("TSThisType", node, opts);
  }
  
  function assertTSFunctionType(node, opts) {
    assert("TSFunctionType", node, opts);
  }
  
  function assertTSConstructorType(node, opts) {
    assert("TSConstructorType", node, opts);
  }
  
  function assertTSTypeReference(node, opts) {
    assert("TSTypeReference", node, opts);
  }
  
  function assertTSTypePredicate(node, opts) {
    assert("TSTypePredicate", node, opts);
  }
  
  function assertTSTypeQuery(node, opts) {
    assert("TSTypeQuery", node, opts);
  }
  
  function assertTSTypeLiteral(node, opts) {
    assert("TSTypeLiteral", node, opts);
  }
  
  function assertTSArrayType(node, opts) {
    assert("TSArrayType", node, opts);
  }
  
  function assertTSTupleType(node, opts) {
    assert("TSTupleType", node, opts);
  }
  
  function assertTSOptionalType(node, opts) {
    assert("TSOptionalType", node, opts);
  }
  
  function assertTSRestType(node, opts) {
    assert("TSRestType", node, opts);
  }
  
  function assertTSNamedTupleMember(node, opts) {
    assert("TSNamedTupleMember", node, opts);
  }
  
  function assertTSUnionType(node, opts) {
    assert("TSUnionType", node, opts);
  }
  
  function assertTSIntersectionType(node, opts) {
    assert("TSIntersectionType", node, opts);
  }
  
  function assertTSConditionalType(node, opts) {
    assert("TSConditionalType", node, opts);
  }
  
  function assertTSInferType(node, opts) {
    assert("TSInferType", node, opts);
  }
  
  function assertTSParenthesizedType(node, opts) {
    assert("TSParenthesizedType", node, opts);
  }
  
  function assertTSTypeOperator(node, opts) {
    assert("TSTypeOperator", node, opts);
  }
  
  function assertTSIndexedAccessType(node, opts) {
    assert("TSIndexedAccessType", node, opts);
  }
  
  function assertTSMappedType(node, opts) {
    assert("TSMappedType", node, opts);
  }
  
  function assertTSLiteralType(node, opts) {
    assert("TSLiteralType", node, opts);
  }
  
  function assertTSExpressionWithTypeArguments(node, opts) {
    assert("TSExpressionWithTypeArguments", node, opts);
  }
  
  function assertTSInterfaceDeclaration(node, opts) {
    assert("TSInterfaceDeclaration", node, opts);
  }
  
  function assertTSInterfaceBody(node, opts) {
    assert("TSInterfaceBody", node, opts);
  }
  
  function assertTSTypeAliasDeclaration(node, opts) {
    assert("TSTypeAliasDeclaration", node, opts);
  }
  
  function assertTSAsExpression(node, opts) {
    assert("TSAsExpression", node, opts);
  }
  
  function assertTSTypeAssertion(node, opts) {
    assert("TSTypeAssertion", node, opts);
  }
  
  function assertTSEnumDeclaration(node, opts) {
    assert("TSEnumDeclaration", node, opts);
  }
  
  function assertTSEnumMember(node, opts) {
    assert("TSEnumMember", node, opts);
  }
  
  function assertTSModuleDeclaration(node, opts) {
    assert("TSModuleDeclaration", node, opts);
  }
  
  function assertTSModuleBlock(node, opts) {
    assert("TSModuleBlock", node, opts);
  }
  
  function assertTSImportType(node, opts) {
    assert("TSImportType", node, opts);
  }
  
  function assertTSImportEqualsDeclaration(node, opts) {
    assert("TSImportEqualsDeclaration", node, opts);
  }
  
  function assertTSExternalModuleReference(node, opts) {
    assert("TSExternalModuleReference", node, opts);
  }
  
  function assertTSNonNullExpression(node, opts) {
    assert("TSNonNullExpression", node, opts);
  }
  
  function assertTSExportAssignment(node, opts) {
    assert("TSExportAssignment", node, opts);
  }
  
  function assertTSNamespaceExportDeclaration(node, opts) {
    assert("TSNamespaceExportDeclaration", node, opts);
  }
  
  function assertTSTypeAnnotation(node, opts) {
    assert("TSTypeAnnotation", node, opts);
  }
  
  function assertTSTypeParameterInstantiation(node, opts) {
    assert("TSTypeParameterInstantiation", node, opts);
  }
  
  function assertTSTypeParameterDeclaration(node, opts) {
    assert("TSTypeParameterDeclaration", node, opts);
  }
  
  function assertTSTypeParameter(node, opts) {
    assert("TSTypeParameter", node, opts);
  }
  
  function assertExpression(node, opts) {
    assert("Expression", node, opts);
  }
  
  function assertBinary(node, opts) {
    assert("Binary", node, opts);
  }
  
  function assertScopable(node, opts) {
    assert("Scopable", node, opts);
  }
  
  function assertBlockParent(node, opts) {
    assert("BlockParent", node, opts);
  }
  
  function assertBlock(node, opts) {
    assert("Block", node, opts);
  }
  
  function assertStatement(node, opts) {
    assert("Statement", node, opts);
  }
  
  function assertTerminatorless(node, opts) {
    assert("Terminatorless", node, opts);
  }
  
  function assertCompletionStatement(node, opts) {
    assert("CompletionStatement", node, opts);
  }
  
  function assertConditional(node, opts) {
    assert("Conditional", node, opts);
  }
  
  function assertLoop(node, opts) {
    assert("Loop", node, opts);
  }
  
  function assertWhile(node, opts) {
    assert("While", node, opts);
  }
  
  function assertExpressionWrapper(node, opts) {
    assert("ExpressionWrapper", node, opts);
  }
  
  function assertFor(node, opts) {
    assert("For", node, opts);
  }
  
  function assertForXStatement(node, opts) {
    assert("ForXStatement", node, opts);
  }
  
  function assertFunction(node, opts) {
    assert("Function", node, opts);
  }
  
  function assertFunctionParent(node, opts) {
    assert("FunctionParent", node, opts);
  }
  
  function assertPureish(node, opts) {
    assert("Pureish", node, opts);
  }
  
  function assertDeclaration(node, opts) {
    assert("Declaration", node, opts);
  }
  
  function assertPatternLike(node, opts) {
    assert("PatternLike", node, opts);
  }
  
  function assertLVal(node, opts) {
    assert("LVal", node, opts);
  }
  
  function assertTSEntityName(node, opts) {
    assert("TSEntityName", node, opts);
  }
  
  function assertLiteral(node, opts) {
    assert("Literal", node, opts);
  }
  
  function assertImmutable(node, opts) {
    assert("Immutable", node, opts);
  }
  
  function assertUserWhitespacable(node, opts) {
    assert("UserWhitespacable", node, opts);
  }
  
  function assertMethod(node, opts) {
    assert("Method", node, opts);
  }
  
  function assertObjectMember(node, opts) {
    assert("ObjectMember", node, opts);
  }
  
  function assertProperty(node, opts) {
    assert("Property", node, opts);
  }
  
  function assertUnaryLike(node, opts) {
    assert("UnaryLike", node, opts);
  }
  
  function assertPattern(node, opts) {
    assert("Pattern", node, opts);
  }
  
  function assertClass(node, opts) {
    assert("Class", node, opts);
  }
  
  function assertModuleDeclaration(node, opts) {
    assert("ModuleDeclaration", node, opts);
  }
  
  function assertExportDeclaration(node, opts) {
    assert("ExportDeclaration", node, opts);
  }
  
  function assertModuleSpecifier(node, opts) {
    assert("ModuleSpecifier", node, opts);
  }
  
  function assertPrivate(node, opts) {
    assert("Private", node, opts);
  }
  
  function assertFlow(node, opts) {
    assert("Flow", node, opts);
  }
  
  function assertFlowType(node, opts) {
    assert("FlowType", node, opts);
  }
  
  function assertFlowBaseAnnotation(node, opts) {
    assert("FlowBaseAnnotation", node, opts);
  }
  
  function assertFlowDeclaration(node, opts) {
    assert("FlowDeclaration", node, opts);
  }
  
  function assertFlowPredicate(node, opts) {
    assert("FlowPredicate", node, opts);
  }
  
  function assertEnumBody(node, opts) {
    assert("EnumBody", node, opts);
  }
  
  function assertEnumMember(node, opts) {
    assert("EnumMember", node, opts);
  }
  
  function assertJSX(node, opts) {
    assert("JSX", node, opts);
  }
  
  function assertTSTypeElement(node, opts) {
    assert("TSTypeElement", node, opts);
  }
  
  function assertTSType(node, opts) {
    assert("TSType", node, opts);
  }
  
  function assertTSBaseType(node, opts) {
    assert("TSBaseType", node, opts);
  }
  
  function assertNumberLiteral(node, opts) {
    console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
    assert("NumberLiteral", node, opts);
  }
  
  function assertRegexLiteral(node, opts) {
    console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
    assert("RegexLiteral", node, opts);
  }
  
  function assertRestProperty(node, opts) {
    console.trace("The node type RestProperty has been renamed to RestElement");
    assert("RestProperty", node, opts);
  }
  
  function assertSpreadProperty(node, opts) {
    console.trace("The node type SpreadProperty has been renamed to SpreadElement");
    assert("SpreadProperty", node, opts);
  }
  },{"../../validators/is":91}],32:[function(require,module,exports){
  
  },{}],33:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = builder;
  
  var _definitions = require("../definitions");
  
  var _validate = require("../validators/validate");
  
  function builder(type, ...args) {
    const keys = _definitions.BUILDER_KEYS[type];
    const countArgs = args.length;
  
    if (countArgs > keys.length) {
      throw new Error(`${type}: Too many arguments passed. Received ${countArgs} but can receive no more than ${keys.length}`);
    }
  
    const node = {
      type
    };
    let i = 0;
    keys.forEach(key => {
      const field = _definitions.NODE_FIELDS[type][key];
      let arg;
      if (i < countArgs) arg = args[i];
  
      if (arg === undefined) {
        arg = Array.isArray(field.default) ? [] : field.default;
      }
  
      node[key] = arg;
      i++;
    });
  
    for (const key of Object.keys(node)) {
      (0, _validate.default)(node, key, node[key]);
    }
  
    return node;
  }
  },{"../definitions":68,"../validators/validate":109}],34:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createFlowUnionType;
  
  var _generated = require("../generated");
  
  var _removeTypeDuplicates = require("../../modifications/flow/removeTypeDuplicates");
  
  function createFlowUnionType(types) {
    const flattened = (0, _removeTypeDuplicates.default)(types);
  
    if (flattened.length === 1) {
      return flattened[0];
    } else {
      return (0, _generated.unionTypeAnnotation)(flattened);
    }
  }
  },{"../../modifications/flow/removeTypeDuplicates":76,"../generated":36}],35:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createTypeAnnotationBasedOnTypeof;
  
  var _generated = require("../generated");
  
  function createTypeAnnotationBasedOnTypeof(type) {
    if (type === "string") {
      return (0, _generated.stringTypeAnnotation)();
    } else if (type === "number") {
      return (0, _generated.numberTypeAnnotation)();
    } else if (type === "undefined") {
      return (0, _generated.voidTypeAnnotation)();
    } else if (type === "boolean") {
      return (0, _generated.booleanTypeAnnotation)();
    } else if (type === "function") {
      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Function"));
    } else if (type === "object") {
      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Object"));
    } else if (type === "symbol") {
      return (0, _generated.genericTypeAnnotation)((0, _generated.identifier)("Symbol"));
    } else if (type === "bigint") {
      return (0, _generated.anyTypeAnnotation)();
    } else {
      throw new Error("Invalid typeof value: " + type);
    }
  }
  },{"../generated":36}],36:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.arrayExpression = arrayExpression;
  exports.assignmentExpression = assignmentExpression;
  exports.binaryExpression = binaryExpression;
  exports.interpreterDirective = interpreterDirective;
  exports.directive = directive;
  exports.directiveLiteral = directiveLiteral;
  exports.blockStatement = blockStatement;
  exports.breakStatement = breakStatement;
  exports.callExpression = callExpression;
  exports.catchClause = catchClause;
  exports.conditionalExpression = conditionalExpression;
  exports.continueStatement = continueStatement;
  exports.debuggerStatement = debuggerStatement;
  exports.doWhileStatement = doWhileStatement;
  exports.emptyStatement = emptyStatement;
  exports.expressionStatement = expressionStatement;
  exports.file = file;
  exports.forInStatement = forInStatement;
  exports.forStatement = forStatement;
  exports.functionDeclaration = functionDeclaration;
  exports.functionExpression = functionExpression;
  exports.identifier = identifier;
  exports.ifStatement = ifStatement;
  exports.labeledStatement = labeledStatement;
  exports.stringLiteral = stringLiteral;
  exports.numericLiteral = numericLiteral;
  exports.nullLiteral = nullLiteral;
  exports.booleanLiteral = booleanLiteral;
  exports.regExpLiteral = regExpLiteral;
  exports.logicalExpression = logicalExpression;
  exports.memberExpression = memberExpression;
  exports.newExpression = newExpression;
  exports.program = program;
  exports.objectExpression = objectExpression;
  exports.objectMethod = objectMethod;
  exports.objectProperty = objectProperty;
  exports.restElement = restElement;
  exports.returnStatement = returnStatement;
  exports.sequenceExpression = sequenceExpression;
  exports.parenthesizedExpression = parenthesizedExpression;
  exports.switchCase = switchCase;
  exports.switchStatement = switchStatement;
  exports.thisExpression = thisExpression;
  exports.throwStatement = throwStatement;
  exports.tryStatement = tryStatement;
  exports.unaryExpression = unaryExpression;
  exports.updateExpression = updateExpression;
  exports.variableDeclaration = variableDeclaration;
  exports.variableDeclarator = variableDeclarator;
  exports.whileStatement = whileStatement;
  exports.withStatement = withStatement;
  exports.assignmentPattern = assignmentPattern;
  exports.arrayPattern = arrayPattern;
  exports.arrowFunctionExpression = arrowFunctionExpression;
  exports.classBody = classBody;
  exports.classExpression = classExpression;
  exports.classDeclaration = classDeclaration;
  exports.exportAllDeclaration = exportAllDeclaration;
  exports.exportDefaultDeclaration = exportDefaultDeclaration;
  exports.exportNamedDeclaration = exportNamedDeclaration;
  exports.exportSpecifier = exportSpecifier;
  exports.forOfStatement = forOfStatement;
  exports.importDeclaration = importDeclaration;
  exports.importDefaultSpecifier = importDefaultSpecifier;
  exports.importNamespaceSpecifier = importNamespaceSpecifier;
  exports.importSpecifier = importSpecifier;
  exports.metaProperty = metaProperty;
  exports.classMethod = classMethod;
  exports.objectPattern = objectPattern;
  exports.spreadElement = spreadElement;
  exports.super = _super;
  exports.taggedTemplateExpression = taggedTemplateExpression;
  exports.templateElement = templateElement;
  exports.templateLiteral = templateLiteral;
  exports.yieldExpression = yieldExpression;
  exports.awaitExpression = awaitExpression;
  exports.import = _import;
  exports.bigIntLiteral = bigIntLiteral;
  exports.exportNamespaceSpecifier = exportNamespaceSpecifier;
  exports.optionalMemberExpression = optionalMemberExpression;
  exports.optionalCallExpression = optionalCallExpression;
  exports.classProperty = classProperty;
  exports.classPrivateProperty = classPrivateProperty;
  exports.classPrivateMethod = classPrivateMethod;
  exports.privateName = privateName;
  exports.anyTypeAnnotation = anyTypeAnnotation;
  exports.arrayTypeAnnotation = arrayTypeAnnotation;
  exports.booleanTypeAnnotation = booleanTypeAnnotation;
  exports.booleanLiteralTypeAnnotation = booleanLiteralTypeAnnotation;
  exports.nullLiteralTypeAnnotation = nullLiteralTypeAnnotation;
  exports.classImplements = classImplements;
  exports.declareClass = declareClass;
  exports.declareFunction = declareFunction;
  exports.declareInterface = declareInterface;
  exports.declareModule = declareModule;
  exports.declareModuleExports = declareModuleExports;
  exports.declareTypeAlias = declareTypeAlias;
  exports.declareOpaqueType = declareOpaqueType;
  exports.declareVariable = declareVariable;
  exports.declareExportDeclaration = declareExportDeclaration;
  exports.declareExportAllDeclaration = declareExportAllDeclaration;
  exports.declaredPredicate = declaredPredicate;
  exports.existsTypeAnnotation = existsTypeAnnotation;
  exports.functionTypeAnnotation = functionTypeAnnotation;
  exports.functionTypeParam = functionTypeParam;
  exports.genericTypeAnnotation = genericTypeAnnotation;
  exports.inferredPredicate = inferredPredicate;
  exports.interfaceExtends = interfaceExtends;
  exports.interfaceDeclaration = interfaceDeclaration;
  exports.interfaceTypeAnnotation = interfaceTypeAnnotation;
  exports.intersectionTypeAnnotation = intersectionTypeAnnotation;
  exports.mixedTypeAnnotation = mixedTypeAnnotation;
  exports.emptyTypeAnnotation = emptyTypeAnnotation;
  exports.nullableTypeAnnotation = nullableTypeAnnotation;
  exports.numberLiteralTypeAnnotation = numberLiteralTypeAnnotation;
  exports.numberTypeAnnotation = numberTypeAnnotation;
  exports.objectTypeAnnotation = objectTypeAnnotation;
  exports.objectTypeInternalSlot = objectTypeInternalSlot;
  exports.objectTypeCallProperty = objectTypeCallProperty;
  exports.objectTypeIndexer = objectTypeIndexer;
  exports.objectTypeProperty = objectTypeProperty;
  exports.objectTypeSpreadProperty = objectTypeSpreadProperty;
  exports.opaqueType = opaqueType;
  exports.qualifiedTypeIdentifier = qualifiedTypeIdentifier;
  exports.stringLiteralTypeAnnotation = stringLiteralTypeAnnotation;
  exports.stringTypeAnnotation = stringTypeAnnotation;
  exports.symbolTypeAnnotation = symbolTypeAnnotation;
  exports.thisTypeAnnotation = thisTypeAnnotation;
  exports.tupleTypeAnnotation = tupleTypeAnnotation;
  exports.typeofTypeAnnotation = typeofTypeAnnotation;
  exports.typeAlias = typeAlias;
  exports.typeAnnotation = typeAnnotation;
  exports.typeCastExpression = typeCastExpression;
  exports.typeParameter = typeParameter;
  exports.typeParameterDeclaration = typeParameterDeclaration;
  exports.typeParameterInstantiation = typeParameterInstantiation;
  exports.unionTypeAnnotation = unionTypeAnnotation;
  exports.variance = variance;
  exports.voidTypeAnnotation = voidTypeAnnotation;
  exports.enumDeclaration = enumDeclaration;
  exports.enumBooleanBody = enumBooleanBody;
  exports.enumNumberBody = enumNumberBody;
  exports.enumStringBody = enumStringBody;
  exports.enumSymbolBody = enumSymbolBody;
  exports.enumBooleanMember = enumBooleanMember;
  exports.enumNumberMember = enumNumberMember;
  exports.enumStringMember = enumStringMember;
  exports.enumDefaultedMember = enumDefaultedMember;
  exports.indexedAccessType = indexedAccessType;
  exports.optionalIndexedAccessType = optionalIndexedAccessType;
  exports.jSXAttribute = exports.jsxAttribute = jsxAttribute;
  exports.jSXClosingElement = exports.jsxClosingElement = jsxClosingElement;
  exports.jSXElement = exports.jsxElement = jsxElement;
  exports.jSXEmptyExpression = exports.jsxEmptyExpression = jsxEmptyExpression;
  exports.jSXExpressionContainer = exports.jsxExpressionContainer = jsxExpressionContainer;
  exports.jSXSpreadChild = exports.jsxSpreadChild = jsxSpreadChild;
  exports.jSXIdentifier = exports.jsxIdentifier = jsxIdentifier;
  exports.jSXMemberExpression = exports.jsxMemberExpression = jsxMemberExpression;
  exports.jSXNamespacedName = exports.jsxNamespacedName = jsxNamespacedName;
  exports.jSXOpeningElement = exports.jsxOpeningElement = jsxOpeningElement;
  exports.jSXSpreadAttribute = exports.jsxSpreadAttribute = jsxSpreadAttribute;
  exports.jSXText = exports.jsxText = jsxText;
  exports.jSXFragment = exports.jsxFragment = jsxFragment;
  exports.jSXOpeningFragment = exports.jsxOpeningFragment = jsxOpeningFragment;
  exports.jSXClosingFragment = exports.jsxClosingFragment = jsxClosingFragment;
  exports.noop = noop;
  exports.placeholder = placeholder;
  exports.v8IntrinsicIdentifier = v8IntrinsicIdentifier;
  exports.argumentPlaceholder = argumentPlaceholder;
  exports.bindExpression = bindExpression;
  exports.importAttribute = importAttribute;
  exports.decorator = decorator;
  exports.doExpression = doExpression;
  exports.exportDefaultSpecifier = exportDefaultSpecifier;
  exports.recordExpression = recordExpression;
  exports.tupleExpression = tupleExpression;
  exports.decimalLiteral = decimalLiteral;
  exports.staticBlock = staticBlock;
  exports.moduleExpression = moduleExpression;
  exports.topicReference = topicReference;
  exports.pipelineTopicExpression = pipelineTopicExpression;
  exports.pipelineBareFunction = pipelineBareFunction;
  exports.pipelinePrimaryTopicReference = pipelinePrimaryTopicReference;
  exports.tSParameterProperty = exports.tsParameterProperty = tsParameterProperty;
  exports.tSDeclareFunction = exports.tsDeclareFunction = tsDeclareFunction;
  exports.tSDeclareMethod = exports.tsDeclareMethod = tsDeclareMethod;
  exports.tSQualifiedName = exports.tsQualifiedName = tsQualifiedName;
  exports.tSCallSignatureDeclaration = exports.tsCallSignatureDeclaration = tsCallSignatureDeclaration;
  exports.tSConstructSignatureDeclaration = exports.tsConstructSignatureDeclaration = tsConstructSignatureDeclaration;
  exports.tSPropertySignature = exports.tsPropertySignature = tsPropertySignature;
  exports.tSMethodSignature = exports.tsMethodSignature = tsMethodSignature;
  exports.tSIndexSignature = exports.tsIndexSignature = tsIndexSignature;
  exports.tSAnyKeyword = exports.tsAnyKeyword = tsAnyKeyword;
  exports.tSBooleanKeyword = exports.tsBooleanKeyword = tsBooleanKeyword;
  exports.tSBigIntKeyword = exports.tsBigIntKeyword = tsBigIntKeyword;
  exports.tSIntrinsicKeyword = exports.tsIntrinsicKeyword = tsIntrinsicKeyword;
  exports.tSNeverKeyword = exports.tsNeverKeyword = tsNeverKeyword;
  exports.tSNullKeyword = exports.tsNullKeyword = tsNullKeyword;
  exports.tSNumberKeyword = exports.tsNumberKeyword = tsNumberKeyword;
  exports.tSObjectKeyword = exports.tsObjectKeyword = tsObjectKeyword;
  exports.tSStringKeyword = exports.tsStringKeyword = tsStringKeyword;
  exports.tSSymbolKeyword = exports.tsSymbolKeyword = tsSymbolKeyword;
  exports.tSUndefinedKeyword = exports.tsUndefinedKeyword = tsUndefinedKeyword;
  exports.tSUnknownKeyword = exports.tsUnknownKeyword = tsUnknownKeyword;
  exports.tSVoidKeyword = exports.tsVoidKeyword = tsVoidKeyword;
  exports.tSThisType = exports.tsThisType = tsThisType;
  exports.tSFunctionType = exports.tsFunctionType = tsFunctionType;
  exports.tSConstructorType = exports.tsConstructorType = tsConstructorType;
  exports.tSTypeReference = exports.tsTypeReference = tsTypeReference;
  exports.tSTypePredicate = exports.tsTypePredicate = tsTypePredicate;
  exports.tSTypeQuery = exports.tsTypeQuery = tsTypeQuery;
  exports.tSTypeLiteral = exports.tsTypeLiteral = tsTypeLiteral;
  exports.tSArrayType = exports.tsArrayType = tsArrayType;
  exports.tSTupleType = exports.tsTupleType = tsTupleType;
  exports.tSOptionalType = exports.tsOptionalType = tsOptionalType;
  exports.tSRestType = exports.tsRestType = tsRestType;
  exports.tSNamedTupleMember = exports.tsNamedTupleMember = tsNamedTupleMember;
  exports.tSUnionType = exports.tsUnionType = tsUnionType;
  exports.tSIntersectionType = exports.tsIntersectionType = tsIntersectionType;
  exports.tSConditionalType = exports.tsConditionalType = tsConditionalType;
  exports.tSInferType = exports.tsInferType = tsInferType;
  exports.tSParenthesizedType = exports.tsParenthesizedType = tsParenthesizedType;
  exports.tSTypeOperator = exports.tsTypeOperator = tsTypeOperator;
  exports.tSIndexedAccessType = exports.tsIndexedAccessType = tsIndexedAccessType;
  exports.tSMappedType = exports.tsMappedType = tsMappedType;
  exports.tSLiteralType = exports.tsLiteralType = tsLiteralType;
  exports.tSExpressionWithTypeArguments = exports.tsExpressionWithTypeArguments = tsExpressionWithTypeArguments;
  exports.tSInterfaceDeclaration = exports.tsInterfaceDeclaration = tsInterfaceDeclaration;
  exports.tSInterfaceBody = exports.tsInterfaceBody = tsInterfaceBody;
  exports.tSTypeAliasDeclaration = exports.tsTypeAliasDeclaration = tsTypeAliasDeclaration;
  exports.tSAsExpression = exports.tsAsExpression = tsAsExpression;
  exports.tSTypeAssertion = exports.tsTypeAssertion = tsTypeAssertion;
  exports.tSEnumDeclaration = exports.tsEnumDeclaration = tsEnumDeclaration;
  exports.tSEnumMember = exports.tsEnumMember = tsEnumMember;
  exports.tSModuleDeclaration = exports.tsModuleDeclaration = tsModuleDeclaration;
  exports.tSModuleBlock = exports.tsModuleBlock = tsModuleBlock;
  exports.tSImportType = exports.tsImportType = tsImportType;
  exports.tSImportEqualsDeclaration = exports.tsImportEqualsDeclaration = tsImportEqualsDeclaration;
  exports.tSExternalModuleReference = exports.tsExternalModuleReference = tsExternalModuleReference;
  exports.tSNonNullExpression = exports.tsNonNullExpression = tsNonNullExpression;
  exports.tSExportAssignment = exports.tsExportAssignment = tsExportAssignment;
  exports.tSNamespaceExportDeclaration = exports.tsNamespaceExportDeclaration = tsNamespaceExportDeclaration;
  exports.tSTypeAnnotation = exports.tsTypeAnnotation = tsTypeAnnotation;
  exports.tSTypeParameterInstantiation = exports.tsTypeParameterInstantiation = tsTypeParameterInstantiation;
  exports.tSTypeParameterDeclaration = exports.tsTypeParameterDeclaration = tsTypeParameterDeclaration;
  exports.tSTypeParameter = exports.tsTypeParameter = tsTypeParameter;
  exports.numberLiteral = NumberLiteral;
  exports.regexLiteral = RegexLiteral;
  exports.restProperty = RestProperty;
  exports.spreadProperty = SpreadProperty;
  
  var _builder = require("../builder");
  
  function arrayExpression(elements) {
    return (0, _builder.default)("ArrayExpression", ...arguments);
  }
  
  function assignmentExpression(operator, left, right) {
    return (0, _builder.default)("AssignmentExpression", ...arguments);
  }
  
  function binaryExpression(operator, left, right) {
    return (0, _builder.default)("BinaryExpression", ...arguments);
  }
  
  function interpreterDirective(value) {
    return (0, _builder.default)("InterpreterDirective", ...arguments);
  }
  
  function directive(value) {
    return (0, _builder.default)("Directive", ...arguments);
  }
  
  function directiveLiteral(value) {
    return (0, _builder.default)("DirectiveLiteral", ...arguments);
  }
  
  function blockStatement(body, directives) {
    return (0, _builder.default)("BlockStatement", ...arguments);
  }
  
  function breakStatement(label) {
    return (0, _builder.default)("BreakStatement", ...arguments);
  }
  
  function callExpression(callee, _arguments) {
    return (0, _builder.default)("CallExpression", ...arguments);
  }
  
  function catchClause(param, body) {
    return (0, _builder.default)("CatchClause", ...arguments);
  }
  
  function conditionalExpression(test, consequent, alternate) {
    return (0, _builder.default)("ConditionalExpression", ...arguments);
  }
  
  function continueStatement(label) {
    return (0, _builder.default)("ContinueStatement", ...arguments);
  }
  
  function debuggerStatement() {
    return (0, _builder.default)("DebuggerStatement", ...arguments);
  }
  
  function doWhileStatement(test, body) {
    return (0, _builder.default)("DoWhileStatement", ...arguments);
  }
  
  function emptyStatement() {
    return (0, _builder.default)("EmptyStatement", ...arguments);
  }
  
  function expressionStatement(expression) {
    return (0, _builder.default)("ExpressionStatement", ...arguments);
  }
  
  function file(program, comments, tokens) {
    return (0, _builder.default)("File", ...arguments);
  }
  
  function forInStatement(left, right, body) {
    return (0, _builder.default)("ForInStatement", ...arguments);
  }
  
  function forStatement(init, test, update, body) {
    return (0, _builder.default)("ForStatement", ...arguments);
  }
  
  function functionDeclaration(id, params, body, generator, async) {
    return (0, _builder.default)("FunctionDeclaration", ...arguments);
  }
  
  function functionExpression(id, params, body, generator, async) {
    return (0, _builder.default)("FunctionExpression", ...arguments);
  }
  
  function identifier(name) {
    return (0, _builder.default)("Identifier", ...arguments);
  }
  
  function ifStatement(test, consequent, alternate) {
    return (0, _builder.default)("IfStatement", ...arguments);
  }
  
  function labeledStatement(label, body) {
    return (0, _builder.default)("LabeledStatement", ...arguments);
  }
  
  function stringLiteral(value) {
    return (0, _builder.default)("StringLiteral", ...arguments);
  }
  
  function numericLiteral(value) {
    return (0, _builder.default)("NumericLiteral", ...arguments);
  }
  
  function nullLiteral() {
    return (0, _builder.default)("NullLiteral", ...arguments);
  }
  
  function booleanLiteral(value) {
    return (0, _builder.default)("BooleanLiteral", ...arguments);
  }
  
  function regExpLiteral(pattern, flags) {
    return (0, _builder.default)("RegExpLiteral", ...arguments);
  }
  
  function logicalExpression(operator, left, right) {
    return (0, _builder.default)("LogicalExpression", ...arguments);
  }
  
  function memberExpression(object, property, computed, optional) {
    return (0, _builder.default)("MemberExpression", ...arguments);
  }
  
  function newExpression(callee, _arguments) {
    return (0, _builder.default)("NewExpression", ...arguments);
  }
  
  function program(body, directives, sourceType, interpreter) {
    return (0, _builder.default)("Program", ...arguments);
  }
  
  function objectExpression(properties) {
    return (0, _builder.default)("ObjectExpression", ...arguments);
  }
  
  function objectMethod(kind, key, params, body, computed, generator, async) {
    return (0, _builder.default)("ObjectMethod", ...arguments);
  }
  
  function objectProperty(key, value, computed, shorthand, decorators) {
    return (0, _builder.default)("ObjectProperty", ...arguments);
  }
  
  function restElement(argument) {
    return (0, _builder.default)("RestElement", ...arguments);
  }
  
  function returnStatement(argument) {
    return (0, _builder.default)("ReturnStatement", ...arguments);
  }
  
  function sequenceExpression(expressions) {
    return (0, _builder.default)("SequenceExpression", ...arguments);
  }
  
  function parenthesizedExpression(expression) {
    return (0, _builder.default)("ParenthesizedExpression", ...arguments);
  }
  
  function switchCase(test, consequent) {
    return (0, _builder.default)("SwitchCase", ...arguments);
  }
  
  function switchStatement(discriminant, cases) {
    return (0, _builder.default)("SwitchStatement", ...arguments);
  }
  
  function thisExpression() {
    return (0, _builder.default)("ThisExpression", ...arguments);
  }
  
  function throwStatement(argument) {
    return (0, _builder.default)("ThrowStatement", ...arguments);
  }
  
  function tryStatement(block, handler, finalizer) {
    return (0, _builder.default)("TryStatement", ...arguments);
  }
  
  function unaryExpression(operator, argument, prefix) {
    return (0, _builder.default)("UnaryExpression", ...arguments);
  }
  
  function updateExpression(operator, argument, prefix) {
    return (0, _builder.default)("UpdateExpression", ...arguments);
  }
  
  function variableDeclaration(kind, declarations) {
    return (0, _builder.default)("VariableDeclaration", ...arguments);
  }
  
  function variableDeclarator(id, init) {
    return (0, _builder.default)("VariableDeclarator", ...arguments);
  }
  
  function whileStatement(test, body) {
    return (0, _builder.default)("WhileStatement", ...arguments);
  }
  
  function withStatement(object, body) {
    return (0, _builder.default)("WithStatement", ...arguments);
  }
  
  function assignmentPattern(left, right) {
    return (0, _builder.default)("AssignmentPattern", ...arguments);
  }
  
  function arrayPattern(elements) {
    return (0, _builder.default)("ArrayPattern", ...arguments);
  }
  
  function arrowFunctionExpression(params, body, async) {
    return (0, _builder.default)("ArrowFunctionExpression", ...arguments);
  }
  
  function classBody(body) {
    return (0, _builder.default)("ClassBody", ...arguments);
  }
  
  function classExpression(id, superClass, body, decorators) {
    return (0, _builder.default)("ClassExpression", ...arguments);
  }
  
  function classDeclaration(id, superClass, body, decorators) {
    return (0, _builder.default)("ClassDeclaration", ...arguments);
  }
  
  function exportAllDeclaration(source) {
    return (0, _builder.default)("ExportAllDeclaration", ...arguments);
  }
  
  function exportDefaultDeclaration(declaration) {
    return (0, _builder.default)("ExportDefaultDeclaration", ...arguments);
  }
  
  function exportNamedDeclaration(declaration, specifiers, source) {
    return (0, _builder.default)("ExportNamedDeclaration", ...arguments);
  }
  
  function exportSpecifier(local, exported) {
    return (0, _builder.default)("ExportSpecifier", ...arguments);
  }
  
  function forOfStatement(left, right, body, _await) {
    return (0, _builder.default)("ForOfStatement", ...arguments);
  }
  
  function importDeclaration(specifiers, source) {
    return (0, _builder.default)("ImportDeclaration", ...arguments);
  }
  
  function importDefaultSpecifier(local) {
    return (0, _builder.default)("ImportDefaultSpecifier", ...arguments);
  }
  
  function importNamespaceSpecifier(local) {
    return (0, _builder.default)("ImportNamespaceSpecifier", ...arguments);
  }
  
  function importSpecifier(local, imported) {
    return (0, _builder.default)("ImportSpecifier", ...arguments);
  }
  
  function metaProperty(meta, property) {
    return (0, _builder.default)("MetaProperty", ...arguments);
  }
  
  function classMethod(kind, key, params, body, computed, _static, generator, async) {
    return (0, _builder.default)("ClassMethod", ...arguments);
  }
  
  function objectPattern(properties) {
    return (0, _builder.default)("ObjectPattern", ...arguments);
  }
  
  function spreadElement(argument) {
    return (0, _builder.default)("SpreadElement", ...arguments);
  }
  
  function _super() {
    return (0, _builder.default)("Super", ...arguments);
  }
  
  function taggedTemplateExpression(tag, quasi) {
    return (0, _builder.default)("TaggedTemplateExpression", ...arguments);
  }
  
  function templateElement(value, tail) {
    return (0, _builder.default)("TemplateElement", ...arguments);
  }
  
  function templateLiteral(quasis, expressions) {
    return (0, _builder.default)("TemplateLiteral", ...arguments);
  }
  
  function yieldExpression(argument, delegate) {
    return (0, _builder.default)("YieldExpression", ...arguments);
  }
  
  function awaitExpression(argument) {
    return (0, _builder.default)("AwaitExpression", ...arguments);
  }
  
  function _import() {
    return (0, _builder.default)("Import", ...arguments);
  }
  
  function bigIntLiteral(value) {
    return (0, _builder.default)("BigIntLiteral", ...arguments);
  }
  
  function exportNamespaceSpecifier(exported) {
    return (0, _builder.default)("ExportNamespaceSpecifier", ...arguments);
  }
  
  function optionalMemberExpression(object, property, computed, optional) {
    return (0, _builder.default)("OptionalMemberExpression", ...arguments);
  }
  
  function optionalCallExpression(callee, _arguments, optional) {
    return (0, _builder.default)("OptionalCallExpression", ...arguments);
  }
  
  function classProperty(key, value, typeAnnotation, decorators, computed, _static) {
    return (0, _builder.default)("ClassProperty", ...arguments);
  }
  
  function classPrivateProperty(key, value, decorators, _static) {
    return (0, _builder.default)("ClassPrivateProperty", ...arguments);
  }
  
  function classPrivateMethod(kind, key, params, body, _static) {
    return (0, _builder.default)("ClassPrivateMethod", ...arguments);
  }
  
  function privateName(id) {
    return (0, _builder.default)("PrivateName", ...arguments);
  }
  
  function anyTypeAnnotation() {
    return (0, _builder.default)("AnyTypeAnnotation", ...arguments);
  }
  
  function arrayTypeAnnotation(elementType) {
    return (0, _builder.default)("ArrayTypeAnnotation", ...arguments);
  }
  
  function booleanTypeAnnotation() {
    return (0, _builder.default)("BooleanTypeAnnotation", ...arguments);
  }
  
  function booleanLiteralTypeAnnotation(value) {
    return (0, _builder.default)("BooleanLiteralTypeAnnotation", ...arguments);
  }
  
  function nullLiteralTypeAnnotation() {
    return (0, _builder.default)("NullLiteralTypeAnnotation", ...arguments);
  }
  
  function classImplements(id, typeParameters) {
    return (0, _builder.default)("ClassImplements", ...arguments);
  }
  
  function declareClass(id, typeParameters, _extends, body) {
    return (0, _builder.default)("DeclareClass", ...arguments);
  }
  
  function declareFunction(id) {
    return (0, _builder.default)("DeclareFunction", ...arguments);
  }
  
  function declareInterface(id, typeParameters, _extends, body) {
    return (0, _builder.default)("DeclareInterface", ...arguments);
  }
  
  function declareModule(id, body, kind) {
    return (0, _builder.default)("DeclareModule", ...arguments);
  }
  
  function declareModuleExports(typeAnnotation) {
    return (0, _builder.default)("DeclareModuleExports", ...arguments);
  }
  
  function declareTypeAlias(id, typeParameters, right) {
    return (0, _builder.default)("DeclareTypeAlias", ...arguments);
  }
  
  function declareOpaqueType(id, typeParameters, supertype) {
    return (0, _builder.default)("DeclareOpaqueType", ...arguments);
  }
  
  function declareVariable(id) {
    return (0, _builder.default)("DeclareVariable", ...arguments);
  }
  
  function declareExportDeclaration(declaration, specifiers, source) {
    return (0, _builder.default)("DeclareExportDeclaration", ...arguments);
  }
  
  function declareExportAllDeclaration(source) {
    return (0, _builder.default)("DeclareExportAllDeclaration", ...arguments);
  }
  
  function declaredPredicate(value) {
    return (0, _builder.default)("DeclaredPredicate", ...arguments);
  }
  
  function existsTypeAnnotation() {
    return (0, _builder.default)("ExistsTypeAnnotation", ...arguments);
  }
  
  function functionTypeAnnotation(typeParameters, params, rest, returnType) {
    return (0, _builder.default)("FunctionTypeAnnotation", ...arguments);
  }
  
  function functionTypeParam(name, typeAnnotation) {
    return (0, _builder.default)("FunctionTypeParam", ...arguments);
  }
  
  function genericTypeAnnotation(id, typeParameters) {
    return (0, _builder.default)("GenericTypeAnnotation", ...arguments);
  }
  
  function inferredPredicate() {
    return (0, _builder.default)("InferredPredicate", ...arguments);
  }
  
  function interfaceExtends(id, typeParameters) {
    return (0, _builder.default)("InterfaceExtends", ...arguments);
  }
  
  function interfaceDeclaration(id, typeParameters, _extends, body) {
    return (0, _builder.default)("InterfaceDeclaration", ...arguments);
  }
  
  function interfaceTypeAnnotation(_extends, body) {
    return (0, _builder.default)("InterfaceTypeAnnotation", ...arguments);
  }
  
  function intersectionTypeAnnotation(types) {
    return (0, _builder.default)("IntersectionTypeAnnotation", ...arguments);
  }
  
  function mixedTypeAnnotation() {
    return (0, _builder.default)("MixedTypeAnnotation", ...arguments);
  }
  
  function emptyTypeAnnotation() {
    return (0, _builder.default)("EmptyTypeAnnotation", ...arguments);
  }
  
  function nullableTypeAnnotation(typeAnnotation) {
    return (0, _builder.default)("NullableTypeAnnotation", ...arguments);
  }
  
  function numberLiteralTypeAnnotation(value) {
    return (0, _builder.default)("NumberLiteralTypeAnnotation", ...arguments);
  }
  
  function numberTypeAnnotation() {
    return (0, _builder.default)("NumberTypeAnnotation", ...arguments);
  }
  
  function objectTypeAnnotation(properties, indexers, callProperties, internalSlots, exact) {
    return (0, _builder.default)("ObjectTypeAnnotation", ...arguments);
  }
  
  function objectTypeInternalSlot(id, value, optional, _static, method) {
    return (0, _builder.default)("ObjectTypeInternalSlot", ...arguments);
  }
  
  function objectTypeCallProperty(value) {
    return (0, _builder.default)("ObjectTypeCallProperty", ...arguments);
  }
  
  function objectTypeIndexer(id, key, value, variance) {
    return (0, _builder.default)("ObjectTypeIndexer", ...arguments);
  }
  
  function objectTypeProperty(key, value, variance) {
    return (0, _builder.default)("ObjectTypeProperty", ...arguments);
  }
  
  function objectTypeSpreadProperty(argument) {
    return (0, _builder.default)("ObjectTypeSpreadProperty", ...arguments);
  }
  
  function opaqueType(id, typeParameters, supertype, impltype) {
    return (0, _builder.default)("OpaqueType", ...arguments);
  }
  
  function qualifiedTypeIdentifier(id, qualification) {
    return (0, _builder.default)("QualifiedTypeIdentifier", ...arguments);
  }
  
  function stringLiteralTypeAnnotation(value) {
    return (0, _builder.default)("StringLiteralTypeAnnotation", ...arguments);
  }
  
  function stringTypeAnnotation() {
    return (0, _builder.default)("StringTypeAnnotation", ...arguments);
  }
  
  function symbolTypeAnnotation() {
    return (0, _builder.default)("SymbolTypeAnnotation", ...arguments);
  }
  
  function thisTypeAnnotation() {
    return (0, _builder.default)("ThisTypeAnnotation", ...arguments);
  }
  
  function tupleTypeAnnotation(types) {
    return (0, _builder.default)("TupleTypeAnnotation", ...arguments);
  }
  
  function typeofTypeAnnotation(argument) {
    return (0, _builder.default)("TypeofTypeAnnotation", ...arguments);
  }
  
  function typeAlias(id, typeParameters, right) {
    return (0, _builder.default)("TypeAlias", ...arguments);
  }
  
  function typeAnnotation(typeAnnotation) {
    return (0, _builder.default)("TypeAnnotation", ...arguments);
  }
  
  function typeCastExpression(expression, typeAnnotation) {
    return (0, _builder.default)("TypeCastExpression", ...arguments);
  }
  
  function typeParameter(bound, _default, variance) {
    return (0, _builder.default)("TypeParameter", ...arguments);
  }
  
  function typeParameterDeclaration(params) {
    return (0, _builder.default)("TypeParameterDeclaration", ...arguments);
  }
  
  function typeParameterInstantiation(params) {
    return (0, _builder.default)("TypeParameterInstantiation", ...arguments);
  }
  
  function unionTypeAnnotation(types) {
    return (0, _builder.default)("UnionTypeAnnotation", ...arguments);
  }
  
  function variance(kind) {
    return (0, _builder.default)("Variance", ...arguments);
  }
  
  function voidTypeAnnotation() {
    return (0, _builder.default)("VoidTypeAnnotation", ...arguments);
  }
  
  function enumDeclaration(id, body) {
    return (0, _builder.default)("EnumDeclaration", ...arguments);
  }
  
  function enumBooleanBody(members) {
    return (0, _builder.default)("EnumBooleanBody", ...arguments);
  }
  
  function enumNumberBody(members) {
    return (0, _builder.default)("EnumNumberBody", ...arguments);
  }
  
  function enumStringBody(members) {
    return (0, _builder.default)("EnumStringBody", ...arguments);
  }
  
  function enumSymbolBody(members) {
    return (0, _builder.default)("EnumSymbolBody", ...arguments);
  }
  
  function enumBooleanMember(id) {
    return (0, _builder.default)("EnumBooleanMember", ...arguments);
  }
  
  function enumNumberMember(id, init) {
    return (0, _builder.default)("EnumNumberMember", ...arguments);
  }
  
  function enumStringMember(id, init) {
    return (0, _builder.default)("EnumStringMember", ...arguments);
  }
  
  function enumDefaultedMember(id) {
    return (0, _builder.default)("EnumDefaultedMember", ...arguments);
  }
  
  function indexedAccessType(objectType, indexType) {
    return (0, _builder.default)("IndexedAccessType", ...arguments);
  }
  
  function optionalIndexedAccessType(objectType, indexType) {
    return (0, _builder.default)("OptionalIndexedAccessType", ...arguments);
  }
  
  function jsxAttribute(name, value) {
    return (0, _builder.default)("JSXAttribute", ...arguments);
  }
  
  function jsxClosingElement(name) {
    return (0, _builder.default)("JSXClosingElement", ...arguments);
  }
  
  function jsxElement(openingElement, closingElement, children, selfClosing) {
    return (0, _builder.default)("JSXElement", ...arguments);
  }
  
  function jsxEmptyExpression() {
    return (0, _builder.default)("JSXEmptyExpression", ...arguments);
  }
  
  function jsxExpressionContainer(expression) {
    return (0, _builder.default)("JSXExpressionContainer", ...arguments);
  }
  
  function jsxSpreadChild(expression) {
    return (0, _builder.default)("JSXSpreadChild", ...arguments);
  }
  
  function jsxIdentifier(name) {
    return (0, _builder.default)("JSXIdentifier", ...arguments);
  }
  
  function jsxMemberExpression(object, property) {
    return (0, _builder.default)("JSXMemberExpression", ...arguments);
  }
  
  function jsxNamespacedName(namespace, name) {
    return (0, _builder.default)("JSXNamespacedName", ...arguments);
  }
  
  function jsxOpeningElement(name, attributes, selfClosing) {
    return (0, _builder.default)("JSXOpeningElement", ...arguments);
  }
  
  function jsxSpreadAttribute(argument) {
    return (0, _builder.default)("JSXSpreadAttribute", ...arguments);
  }
  
  function jsxText(value) {
    return (0, _builder.default)("JSXText", ...arguments);
  }
  
  function jsxFragment(openingFragment, closingFragment, children) {
    return (0, _builder.default)("JSXFragment", ...arguments);
  }
  
  function jsxOpeningFragment() {
    return (0, _builder.default)("JSXOpeningFragment", ...arguments);
  }
  
  function jsxClosingFragment() {
    return (0, _builder.default)("JSXClosingFragment", ...arguments);
  }
  
  function noop() {
    return (0, _builder.default)("Noop", ...arguments);
  }
  
  function placeholder(expectedNode, name) {
    return (0, _builder.default)("Placeholder", ...arguments);
  }
  
  function v8IntrinsicIdentifier(name) {
    return (0, _builder.default)("V8IntrinsicIdentifier", ...arguments);
  }
  
  function argumentPlaceholder() {
    return (0, _builder.default)("ArgumentPlaceholder", ...arguments);
  }
  
  function bindExpression(object, callee) {
    return (0, _builder.default)("BindExpression", ...arguments);
  }
  
  function importAttribute(key, value) {
    return (0, _builder.default)("ImportAttribute", ...arguments);
  }
  
  function decorator(expression) {
    return (0, _builder.default)("Decorator", ...arguments);
  }
  
  function doExpression(body, async) {
    return (0, _builder.default)("DoExpression", ...arguments);
  }
  
  function exportDefaultSpecifier(exported) {
    return (0, _builder.default)("ExportDefaultSpecifier", ...arguments);
  }
  
  function recordExpression(properties) {
    return (0, _builder.default)("RecordExpression", ...arguments);
  }
  
  function tupleExpression(elements) {
    return (0, _builder.default)("TupleExpression", ...arguments);
  }
  
  function decimalLiteral(value) {
    return (0, _builder.default)("DecimalLiteral", ...arguments);
  }
  
  function staticBlock(body) {
    return (0, _builder.default)("StaticBlock", ...arguments);
  }
  
  function moduleExpression(body) {
    return (0, _builder.default)("ModuleExpression", ...arguments);
  }
  
  function topicReference() {
    return (0, _builder.default)("TopicReference", ...arguments);
  }
  
  function pipelineTopicExpression(expression) {
    return (0, _builder.default)("PipelineTopicExpression", ...arguments);
  }
  
  function pipelineBareFunction(callee) {
    return (0, _builder.default)("PipelineBareFunction", ...arguments);
  }
  
  function pipelinePrimaryTopicReference() {
    return (0, _builder.default)("PipelinePrimaryTopicReference", ...arguments);
  }
  
  function tsParameterProperty(parameter) {
    return (0, _builder.default)("TSParameterProperty", ...arguments);
  }
  
  function tsDeclareFunction(id, typeParameters, params, returnType) {
    return (0, _builder.default)("TSDeclareFunction", ...arguments);
  }
  
  function tsDeclareMethod(decorators, key, typeParameters, params, returnType) {
    return (0, _builder.default)("TSDeclareMethod", ...arguments);
  }
  
  function tsQualifiedName(left, right) {
    return (0, _builder.default)("TSQualifiedName", ...arguments);
  }
  
  function tsCallSignatureDeclaration(typeParameters, parameters, typeAnnotation) {
    return (0, _builder.default)("TSCallSignatureDeclaration", ...arguments);
  }
  
  function tsConstructSignatureDeclaration(typeParameters, parameters, typeAnnotation) {
    return (0, _builder.default)("TSConstructSignatureDeclaration", ...arguments);
  }
  
  function tsPropertySignature(key, typeAnnotation, initializer) {
    return (0, _builder.default)("TSPropertySignature", ...arguments);
  }
  
  function tsMethodSignature(key, typeParameters, parameters, typeAnnotation) {
    return (0, _builder.default)("TSMethodSignature", ...arguments);
  }
  
  function tsIndexSignature(parameters, typeAnnotation) {
    return (0, _builder.default)("TSIndexSignature", ...arguments);
  }
  
  function tsAnyKeyword() {
    return (0, _builder.default)("TSAnyKeyword", ...arguments);
  }
  
  function tsBooleanKeyword() {
    return (0, _builder.default)("TSBooleanKeyword", ...arguments);
  }
  
  function tsBigIntKeyword() {
    return (0, _builder.default)("TSBigIntKeyword", ...arguments);
  }
  
  function tsIntrinsicKeyword() {
    return (0, _builder.default)("TSIntrinsicKeyword", ...arguments);
  }
  
  function tsNeverKeyword() {
    return (0, _builder.default)("TSNeverKeyword", ...arguments);
  }
  
  function tsNullKeyword() {
    return (0, _builder.default)("TSNullKeyword", ...arguments);
  }
  
  function tsNumberKeyword() {
    return (0, _builder.default)("TSNumberKeyword", ...arguments);
  }
  
  function tsObjectKeyword() {
    return (0, _builder.default)("TSObjectKeyword", ...arguments);
  }
  
  function tsStringKeyword() {
    return (0, _builder.default)("TSStringKeyword", ...arguments);
  }
  
  function tsSymbolKeyword() {
    return (0, _builder.default)("TSSymbolKeyword", ...arguments);
  }
  
  function tsUndefinedKeyword() {
    return (0, _builder.default)("TSUndefinedKeyword", ...arguments);
  }
  
  function tsUnknownKeyword() {
    return (0, _builder.default)("TSUnknownKeyword", ...arguments);
  }
  
  function tsVoidKeyword() {
    return (0, _builder.default)("TSVoidKeyword", ...arguments);
  }
  
  function tsThisType() {
    return (0, _builder.default)("TSThisType", ...arguments);
  }
  
  function tsFunctionType(typeParameters, parameters, typeAnnotation) {
    return (0, _builder.default)("TSFunctionType", ...arguments);
  }
  
  function tsConstructorType(typeParameters, parameters, typeAnnotation) {
    return (0, _builder.default)("TSConstructorType", ...arguments);
  }
  
  function tsTypeReference(typeName, typeParameters) {
    return (0, _builder.default)("TSTypeReference", ...arguments);
  }
  
  function tsTypePredicate(parameterName, typeAnnotation, asserts) {
    return (0, _builder.default)("TSTypePredicate", ...arguments);
  }
  
  function tsTypeQuery(exprName) {
    return (0, _builder.default)("TSTypeQuery", ...arguments);
  }
  
  function tsTypeLiteral(members) {
    return (0, _builder.default)("TSTypeLiteral", ...arguments);
  }
  
  function tsArrayType(elementType) {
    return (0, _builder.default)("TSArrayType", ...arguments);
  }
  
  function tsTupleType(elementTypes) {
    return (0, _builder.default)("TSTupleType", ...arguments);
  }
  
  function tsOptionalType(typeAnnotation) {
    return (0, _builder.default)("TSOptionalType", ...arguments);
  }
  
  function tsRestType(typeAnnotation) {
    return (0, _builder.default)("TSRestType", ...arguments);
  }
  
  function tsNamedTupleMember(label, elementType, optional) {
    return (0, _builder.default)("TSNamedTupleMember", ...arguments);
  }
  
  function tsUnionType(types) {
    return (0, _builder.default)("TSUnionType", ...arguments);
  }
  
  function tsIntersectionType(types) {
    return (0, _builder.default)("TSIntersectionType", ...arguments);
  }
  
  function tsConditionalType(checkType, extendsType, trueType, falseType) {
    return (0, _builder.default)("TSConditionalType", ...arguments);
  }
  
  function tsInferType(typeParameter) {
    return (0, _builder.default)("TSInferType", ...arguments);
  }
  
  function tsParenthesizedType(typeAnnotation) {
    return (0, _builder.default)("TSParenthesizedType", ...arguments);
  }
  
  function tsTypeOperator(typeAnnotation) {
    return (0, _builder.default)("TSTypeOperator", ...arguments);
  }
  
  function tsIndexedAccessType(objectType, indexType) {
    return (0, _builder.default)("TSIndexedAccessType", ...arguments);
  }
  
  function tsMappedType(typeParameter, typeAnnotation, nameType) {
    return (0, _builder.default)("TSMappedType", ...arguments);
  }
  
  function tsLiteralType(literal) {
    return (0, _builder.default)("TSLiteralType", ...arguments);
  }
  
  function tsExpressionWithTypeArguments(expression, typeParameters) {
    return (0, _builder.default)("TSExpressionWithTypeArguments", ...arguments);
  }
  
  function tsInterfaceDeclaration(id, typeParameters, _extends, body) {
    return (0, _builder.default)("TSInterfaceDeclaration", ...arguments);
  }
  
  function tsInterfaceBody(body) {
    return (0, _builder.default)("TSInterfaceBody", ...arguments);
  }
  
  function tsTypeAliasDeclaration(id, typeParameters, typeAnnotation) {
    return (0, _builder.default)("TSTypeAliasDeclaration", ...arguments);
  }
  
  function tsAsExpression(expression, typeAnnotation) {
    return (0, _builder.default)("TSAsExpression", ...arguments);
  }
  
  function tsTypeAssertion(typeAnnotation, expression) {
    return (0, _builder.default)("TSTypeAssertion", ...arguments);
  }
  
  function tsEnumDeclaration(id, members) {
    return (0, _builder.default)("TSEnumDeclaration", ...arguments);
  }
  
  function tsEnumMember(id, initializer) {
    return (0, _builder.default)("TSEnumMember", ...arguments);
  }
  
  function tsModuleDeclaration(id, body) {
    return (0, _builder.default)("TSModuleDeclaration", ...arguments);
  }
  
  function tsModuleBlock(body) {
    return (0, _builder.default)("TSModuleBlock", ...arguments);
  }
  
  function tsImportType(argument, qualifier, typeParameters) {
    return (0, _builder.default)("TSImportType", ...arguments);
  }
  
  function tsImportEqualsDeclaration(id, moduleReference) {
    return (0, _builder.default)("TSImportEqualsDeclaration", ...arguments);
  }
  
  function tsExternalModuleReference(expression) {
    return (0, _builder.default)("TSExternalModuleReference", ...arguments);
  }
  
  function tsNonNullExpression(expression) {
    return (0, _builder.default)("TSNonNullExpression", ...arguments);
  }
  
  function tsExportAssignment(expression) {
    return (0, _builder.default)("TSExportAssignment", ...arguments);
  }
  
  function tsNamespaceExportDeclaration(id) {
    return (0, _builder.default)("TSNamespaceExportDeclaration", ...arguments);
  }
  
  function tsTypeAnnotation(typeAnnotation) {
    return (0, _builder.default)("TSTypeAnnotation", ...arguments);
  }
  
  function tsTypeParameterInstantiation(params) {
    return (0, _builder.default)("TSTypeParameterInstantiation", ...arguments);
  }
  
  function tsTypeParameterDeclaration(params) {
    return (0, _builder.default)("TSTypeParameterDeclaration", ...arguments);
  }
  
  function tsTypeParameter(constraint, _default, name) {
    return (0, _builder.default)("TSTypeParameter", ...arguments);
  }
  
  function NumberLiteral(...args) {
    console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
    return (0, _builder.default)("NumberLiteral", ...args);
  }
  
  function RegexLiteral(...args) {
    console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
    return (0, _builder.default)("RegexLiteral", ...args);
  }
  
  function RestProperty(...args) {
    console.trace("The node type RestProperty has been renamed to RestElement");
    return (0, _builder.default)("RestProperty", ...args);
  }
  
  function SpreadProperty(...args) {
    console.trace("The node type SpreadProperty has been renamed to SpreadElement");
    return (0, _builder.default)("SpreadProperty", ...args);
  }
  },{"../builder":33}],37:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "ArrayExpression", {
    enumerable: true,
    get: function () {
      return _index.arrayExpression;
    }
  });
  Object.defineProperty(exports, "AssignmentExpression", {
    enumerable: true,
    get: function () {
      return _index.assignmentExpression;
    }
  });
  Object.defineProperty(exports, "BinaryExpression", {
    enumerable: true,
    get: function () {
      return _index.binaryExpression;
    }
  });
  Object.defineProperty(exports, "InterpreterDirective", {
    enumerable: true,
    get: function () {
      return _index.interpreterDirective;
    }
  });
  Object.defineProperty(exports, "Directive", {
    enumerable: true,
    get: function () {
      return _index.directive;
    }
  });
  Object.defineProperty(exports, "DirectiveLiteral", {
    enumerable: true,
    get: function () {
      return _index.directiveLiteral;
    }
  });
  Object.defineProperty(exports, "BlockStatement", {
    enumerable: true,
    get: function () {
      return _index.blockStatement;
    }
  });
  Object.defineProperty(exports, "BreakStatement", {
    enumerable: true,
    get: function () {
      return _index.breakStatement;
    }
  });
  Object.defineProperty(exports, "CallExpression", {
    enumerable: true,
    get: function () {
      return _index.callExpression;
    }
  });
  Object.defineProperty(exports, "CatchClause", {
    enumerable: true,
    get: function () {
      return _index.catchClause;
    }
  });
  Object.defineProperty(exports, "ConditionalExpression", {
    enumerable: true,
    get: function () {
      return _index.conditionalExpression;
    }
  });
  Object.defineProperty(exports, "ContinueStatement", {
    enumerable: true,
    get: function () {
      return _index.continueStatement;
    }
  });
  Object.defineProperty(exports, "DebuggerStatement", {
    enumerable: true,
    get: function () {
      return _index.debuggerStatement;
    }
  });
  Object.defineProperty(exports, "DoWhileStatement", {
    enumerable: true,
    get: function () {
      return _index.doWhileStatement;
    }
  });
  Object.defineProperty(exports, "EmptyStatement", {
    enumerable: true,
    get: function () {
      return _index.emptyStatement;
    }
  });
  Object.defineProperty(exports, "ExpressionStatement", {
    enumerable: true,
    get: function () {
      return _index.expressionStatement;
    }
  });
  Object.defineProperty(exports, "File", {
    enumerable: true,
    get: function () {
      return _index.file;
    }
  });
  Object.defineProperty(exports, "ForInStatement", {
    enumerable: true,
    get: function () {
      return _index.forInStatement;
    }
  });
  Object.defineProperty(exports, "ForStatement", {
    enumerable: true,
    get: function () {
      return _index.forStatement;
    }
  });
  Object.defineProperty(exports, "FunctionDeclaration", {
    enumerable: true,
    get: function () {
      return _index.functionDeclaration;
    }
  });
  Object.defineProperty(exports, "FunctionExpression", {
    enumerable: true,
    get: function () {
      return _index.functionExpression;
    }
  });
  Object.defineProperty(exports, "Identifier", {
    enumerable: true,
    get: function () {
      return _index.identifier;
    }
  });
  Object.defineProperty(exports, "IfStatement", {
    enumerable: true,
    get: function () {
      return _index.ifStatement;
    }
  });
  Object.defineProperty(exports, "LabeledStatement", {
    enumerable: true,
    get: function () {
      return _index.labeledStatement;
    }
  });
  Object.defineProperty(exports, "StringLiteral", {
    enumerable: true,
    get: function () {
      return _index.stringLiteral;
    }
  });
  Object.defineProperty(exports, "NumericLiteral", {
    enumerable: true,
    get: function () {
      return _index.numericLiteral;
    }
  });
  Object.defineProperty(exports, "NullLiteral", {
    enumerable: true,
    get: function () {
      return _index.nullLiteral;
    }
  });
  Object.defineProperty(exports, "BooleanLiteral", {
    enumerable: true,
    get: function () {
      return _index.booleanLiteral;
    }
  });
  Object.defineProperty(exports, "RegExpLiteral", {
    enumerable: true,
    get: function () {
      return _index.regExpLiteral;
    }
  });
  Object.defineProperty(exports, "LogicalExpression", {
    enumerable: true,
    get: function () {
      return _index.logicalExpression;
    }
  });
  Object.defineProperty(exports, "MemberExpression", {
    enumerable: true,
    get: function () {
      return _index.memberExpression;
    }
  });
  Object.defineProperty(exports, "NewExpression", {
    enumerable: true,
    get: function () {
      return _index.newExpression;
    }
  });
  Object.defineProperty(exports, "Program", {
    enumerable: true,
    get: function () {
      return _index.program;
    }
  });
  Object.defineProperty(exports, "ObjectExpression", {
    enumerable: true,
    get: function () {
      return _index.objectExpression;
    }
  });
  Object.defineProperty(exports, "ObjectMethod", {
    enumerable: true,
    get: function () {
      return _index.objectMethod;
    }
  });
  Object.defineProperty(exports, "ObjectProperty", {
    enumerable: true,
    get: function () {
      return _index.objectProperty;
    }
  });
  Object.defineProperty(exports, "RestElement", {
    enumerable: true,
    get: function () {
      return _index.restElement;
    }
  });
  Object.defineProperty(exports, "ReturnStatement", {
    enumerable: true,
    get: function () {
      return _index.returnStatement;
    }
  });
  Object.defineProperty(exports, "SequenceExpression", {
    enumerable: true,
    get: function () {
      return _index.sequenceExpression;
    }
  });
  Object.defineProperty(exports, "ParenthesizedExpression", {
    enumerable: true,
    get: function () {
      return _index.parenthesizedExpression;
    }
  });
  Object.defineProperty(exports, "SwitchCase", {
    enumerable: true,
    get: function () {
      return _index.switchCase;
    }
  });
  Object.defineProperty(exports, "SwitchStatement", {
    enumerable: true,
    get: function () {
      return _index.switchStatement;
    }
  });
  Object.defineProperty(exports, "ThisExpression", {
    enumerable: true,
    get: function () {
      return _index.thisExpression;
    }
  });
  Object.defineProperty(exports, "ThrowStatement", {
    enumerable: true,
    get: function () {
      return _index.throwStatement;
    }
  });
  Object.defineProperty(exports, "TryStatement", {
    enumerable: true,
    get: function () {
      return _index.tryStatement;
    }
  });
  Object.defineProperty(exports, "UnaryExpression", {
    enumerable: true,
    get: function () {
      return _index.unaryExpression;
    }
  });
  Object.defineProperty(exports, "UpdateExpression", {
    enumerable: true,
    get: function () {
      return _index.updateExpression;
    }
  });
  Object.defineProperty(exports, "VariableDeclaration", {
    enumerable: true,
    get: function () {
      return _index.variableDeclaration;
    }
  });
  Object.defineProperty(exports, "VariableDeclarator", {
    enumerable: true,
    get: function () {
      return _index.variableDeclarator;
    }
  });
  Object.defineProperty(exports, "WhileStatement", {
    enumerable: true,
    get: function () {
      return _index.whileStatement;
    }
  });
  Object.defineProperty(exports, "WithStatement", {
    enumerable: true,
    get: function () {
      return _index.withStatement;
    }
  });
  Object.defineProperty(exports, "AssignmentPattern", {
    enumerable: true,
    get: function () {
      return _index.assignmentPattern;
    }
  });
  Object.defineProperty(exports, "ArrayPattern", {
    enumerable: true,
    get: function () {
      return _index.arrayPattern;
    }
  });
  Object.defineProperty(exports, "ArrowFunctionExpression", {
    enumerable: true,
    get: function () {
      return _index.arrowFunctionExpression;
    }
  });
  Object.defineProperty(exports, "ClassBody", {
    enumerable: true,
    get: function () {
      return _index.classBody;
    }
  });
  Object.defineProperty(exports, "ClassExpression", {
    enumerable: true,
    get: function () {
      return _index.classExpression;
    }
  });
  Object.defineProperty(exports, "ClassDeclaration", {
    enumerable: true,
    get: function () {
      return _index.classDeclaration;
    }
  });
  Object.defineProperty(exports, "ExportAllDeclaration", {
    enumerable: true,
    get: function () {
      return _index.exportAllDeclaration;
    }
  });
  Object.defineProperty(exports, "ExportDefaultDeclaration", {
    enumerable: true,
    get: function () {
      return _index.exportDefaultDeclaration;
    }
  });
  Object.defineProperty(exports, "ExportNamedDeclaration", {
    enumerable: true,
    get: function () {
      return _index.exportNamedDeclaration;
    }
  });
  Object.defineProperty(exports, "ExportSpecifier", {
    enumerable: true,
    get: function () {
      return _index.exportSpecifier;
    }
  });
  Object.defineProperty(exports, "ForOfStatement", {
    enumerable: true,
    get: function () {
      return _index.forOfStatement;
    }
  });
  Object.defineProperty(exports, "ImportDeclaration", {
    enumerable: true,
    get: function () {
      return _index.importDeclaration;
    }
  });
  Object.defineProperty(exports, "ImportDefaultSpecifier", {
    enumerable: true,
    get: function () {
      return _index.importDefaultSpecifier;
    }
  });
  Object.defineProperty(exports, "ImportNamespaceSpecifier", {
    enumerable: true,
    get: function () {
      return _index.importNamespaceSpecifier;
    }
  });
  Object.defineProperty(exports, "ImportSpecifier", {
    enumerable: true,
    get: function () {
      return _index.importSpecifier;
    }
  });
  Object.defineProperty(exports, "MetaProperty", {
    enumerable: true,
    get: function () {
      return _index.metaProperty;
    }
  });
  Object.defineProperty(exports, "ClassMethod", {
    enumerable: true,
    get: function () {
      return _index.classMethod;
    }
  });
  Object.defineProperty(exports, "ObjectPattern", {
    enumerable: true,
    get: function () {
      return _index.objectPattern;
    }
  });
  Object.defineProperty(exports, "SpreadElement", {
    enumerable: true,
    get: function () {
      return _index.spreadElement;
    }
  });
  Object.defineProperty(exports, "Super", {
    enumerable: true,
    get: function () {
      return _index.super;
    }
  });
  Object.defineProperty(exports, "TaggedTemplateExpression", {
    enumerable: true,
    get: function () {
      return _index.taggedTemplateExpression;
    }
  });
  Object.defineProperty(exports, "TemplateElement", {
    enumerable: true,
    get: function () {
      return _index.templateElement;
    }
  });
  Object.defineProperty(exports, "TemplateLiteral", {
    enumerable: true,
    get: function () {
      return _index.templateLiteral;
    }
  });
  Object.defineProperty(exports, "YieldExpression", {
    enumerable: true,
    get: function () {
      return _index.yieldExpression;
    }
  });
  Object.defineProperty(exports, "AwaitExpression", {
    enumerable: true,
    get: function () {
      return _index.awaitExpression;
    }
  });
  Object.defineProperty(exports, "Import", {
    enumerable: true,
    get: function () {
      return _index.import;
    }
  });
  Object.defineProperty(exports, "BigIntLiteral", {
    enumerable: true,
    get: function () {
      return _index.bigIntLiteral;
    }
  });
  Object.defineProperty(exports, "ExportNamespaceSpecifier", {
    enumerable: true,
    get: function () {
      return _index.exportNamespaceSpecifier;
    }
  });
  Object.defineProperty(exports, "OptionalMemberExpression", {
    enumerable: true,
    get: function () {
      return _index.optionalMemberExpression;
    }
  });
  Object.defineProperty(exports, "OptionalCallExpression", {
    enumerable: true,
    get: function () {
      return _index.optionalCallExpression;
    }
  });
  Object.defineProperty(exports, "ClassProperty", {
    enumerable: true,
    get: function () {
      return _index.classProperty;
    }
  });
  Object.defineProperty(exports, "ClassPrivateProperty", {
    enumerable: true,
    get: function () {
      return _index.classPrivateProperty;
    }
  });
  Object.defineProperty(exports, "ClassPrivateMethod", {
    enumerable: true,
    get: function () {
      return _index.classPrivateMethod;
    }
  });
  Object.defineProperty(exports, "PrivateName", {
    enumerable: true,
    get: function () {
      return _index.privateName;
    }
  });
  Object.defineProperty(exports, "AnyTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.anyTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "ArrayTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.arrayTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "BooleanTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.booleanTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "BooleanLiteralTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.booleanLiteralTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "NullLiteralTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.nullLiteralTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "ClassImplements", {
    enumerable: true,
    get: function () {
      return _index.classImplements;
    }
  });
  Object.defineProperty(exports, "DeclareClass", {
    enumerable: true,
    get: function () {
      return _index.declareClass;
    }
  });
  Object.defineProperty(exports, "DeclareFunction", {
    enumerable: true,
    get: function () {
      return _index.declareFunction;
    }
  });
  Object.defineProperty(exports, "DeclareInterface", {
    enumerable: true,
    get: function () {
      return _index.declareInterface;
    }
  });
  Object.defineProperty(exports, "DeclareModule", {
    enumerable: true,
    get: function () {
      return _index.declareModule;
    }
  });
  Object.defineProperty(exports, "DeclareModuleExports", {
    enumerable: true,
    get: function () {
      return _index.declareModuleExports;
    }
  });
  Object.defineProperty(exports, "DeclareTypeAlias", {
    enumerable: true,
    get: function () {
      return _index.declareTypeAlias;
    }
  });
  Object.defineProperty(exports, "DeclareOpaqueType", {
    enumerable: true,
    get: function () {
      return _index.declareOpaqueType;
    }
  });
  Object.defineProperty(exports, "DeclareVariable", {
    enumerable: true,
    get: function () {
      return _index.declareVariable;
    }
  });
  Object.defineProperty(exports, "DeclareExportDeclaration", {
    enumerable: true,
    get: function () {
      return _index.declareExportDeclaration;
    }
  });
  Object.defineProperty(exports, "DeclareExportAllDeclaration", {
    enumerable: true,
    get: function () {
      return _index.declareExportAllDeclaration;
    }
  });
  Object.defineProperty(exports, "DeclaredPredicate", {
    enumerable: true,
    get: function () {
      return _index.declaredPredicate;
    }
  });
  Object.defineProperty(exports, "ExistsTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.existsTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "FunctionTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.functionTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "FunctionTypeParam", {
    enumerable: true,
    get: function () {
      return _index.functionTypeParam;
    }
  });
  Object.defineProperty(exports, "GenericTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.genericTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "InferredPredicate", {
    enumerable: true,
    get: function () {
      return _index.inferredPredicate;
    }
  });
  Object.defineProperty(exports, "InterfaceExtends", {
    enumerable: true,
    get: function () {
      return _index.interfaceExtends;
    }
  });
  Object.defineProperty(exports, "InterfaceDeclaration", {
    enumerable: true,
    get: function () {
      return _index.interfaceDeclaration;
    }
  });
  Object.defineProperty(exports, "InterfaceTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.interfaceTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "IntersectionTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.intersectionTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "MixedTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.mixedTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "EmptyTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.emptyTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "NullableTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.nullableTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "NumberLiteralTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.numberLiteralTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "NumberTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.numberTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "ObjectTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.objectTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "ObjectTypeInternalSlot", {
    enumerable: true,
    get: function () {
      return _index.objectTypeInternalSlot;
    }
  });
  Object.defineProperty(exports, "ObjectTypeCallProperty", {
    enumerable: true,
    get: function () {
      return _index.objectTypeCallProperty;
    }
  });
  Object.defineProperty(exports, "ObjectTypeIndexer", {
    enumerable: true,
    get: function () {
      return _index.objectTypeIndexer;
    }
  });
  Object.defineProperty(exports, "ObjectTypeProperty", {
    enumerable: true,
    get: function () {
      return _index.objectTypeProperty;
    }
  });
  Object.defineProperty(exports, "ObjectTypeSpreadProperty", {
    enumerable: true,
    get: function () {
      return _index.objectTypeSpreadProperty;
    }
  });
  Object.defineProperty(exports, "OpaqueType", {
    enumerable: true,
    get: function () {
      return _index.opaqueType;
    }
  });
  Object.defineProperty(exports, "QualifiedTypeIdentifier", {
    enumerable: true,
    get: function () {
      return _index.qualifiedTypeIdentifier;
    }
  });
  Object.defineProperty(exports, "StringLiteralTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.stringLiteralTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "StringTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.stringTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "SymbolTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.symbolTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "ThisTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.thisTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "TupleTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.tupleTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "TypeofTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.typeofTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "TypeAlias", {
    enumerable: true,
    get: function () {
      return _index.typeAlias;
    }
  });
  Object.defineProperty(exports, "TypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.typeAnnotation;
    }
  });
  Object.defineProperty(exports, "TypeCastExpression", {
    enumerable: true,
    get: function () {
      return _index.typeCastExpression;
    }
  });
  Object.defineProperty(exports, "TypeParameter", {
    enumerable: true,
    get: function () {
      return _index.typeParameter;
    }
  });
  Object.defineProperty(exports, "TypeParameterDeclaration", {
    enumerable: true,
    get: function () {
      return _index.typeParameterDeclaration;
    }
  });
  Object.defineProperty(exports, "TypeParameterInstantiation", {
    enumerable: true,
    get: function () {
      return _index.typeParameterInstantiation;
    }
  });
  Object.defineProperty(exports, "UnionTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.unionTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "Variance", {
    enumerable: true,
    get: function () {
      return _index.variance;
    }
  });
  Object.defineProperty(exports, "VoidTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.voidTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "EnumDeclaration", {
    enumerable: true,
    get: function () {
      return _index.enumDeclaration;
    }
  });
  Object.defineProperty(exports, "EnumBooleanBody", {
    enumerable: true,
    get: function () {
      return _index.enumBooleanBody;
    }
  });
  Object.defineProperty(exports, "EnumNumberBody", {
    enumerable: true,
    get: function () {
      return _index.enumNumberBody;
    }
  });
  Object.defineProperty(exports, "EnumStringBody", {
    enumerable: true,
    get: function () {
      return _index.enumStringBody;
    }
  });
  Object.defineProperty(exports, "EnumSymbolBody", {
    enumerable: true,
    get: function () {
      return _index.enumSymbolBody;
    }
  });
  Object.defineProperty(exports, "EnumBooleanMember", {
    enumerable: true,
    get: function () {
      return _index.enumBooleanMember;
    }
  });
  Object.defineProperty(exports, "EnumNumberMember", {
    enumerable: true,
    get: function () {
      return _index.enumNumberMember;
    }
  });
  Object.defineProperty(exports, "EnumStringMember", {
    enumerable: true,
    get: function () {
      return _index.enumStringMember;
    }
  });
  Object.defineProperty(exports, "EnumDefaultedMember", {
    enumerable: true,
    get: function () {
      return _index.enumDefaultedMember;
    }
  });
  Object.defineProperty(exports, "IndexedAccessType", {
    enumerable: true,
    get: function () {
      return _index.indexedAccessType;
    }
  });
  Object.defineProperty(exports, "OptionalIndexedAccessType", {
    enumerable: true,
    get: function () {
      return _index.optionalIndexedAccessType;
    }
  });
  Object.defineProperty(exports, "JSXAttribute", {
    enumerable: true,
    get: function () {
      return _index.jsxAttribute;
    }
  });
  Object.defineProperty(exports, "JSXClosingElement", {
    enumerable: true,
    get: function () {
      return _index.jsxClosingElement;
    }
  });
  Object.defineProperty(exports, "JSXElement", {
    enumerable: true,
    get: function () {
      return _index.jsxElement;
    }
  });
  Object.defineProperty(exports, "JSXEmptyExpression", {
    enumerable: true,
    get: function () {
      return _index.jsxEmptyExpression;
    }
  });
  Object.defineProperty(exports, "JSXExpressionContainer", {
    enumerable: true,
    get: function () {
      return _index.jsxExpressionContainer;
    }
  });
  Object.defineProperty(exports, "JSXSpreadChild", {
    enumerable: true,
    get: function () {
      return _index.jsxSpreadChild;
    }
  });
  Object.defineProperty(exports, "JSXIdentifier", {
    enumerable: true,
    get: function () {
      return _index.jsxIdentifier;
    }
  });
  Object.defineProperty(exports, "JSXMemberExpression", {
    enumerable: true,
    get: function () {
      return _index.jsxMemberExpression;
    }
  });
  Object.defineProperty(exports, "JSXNamespacedName", {
    enumerable: true,
    get: function () {
      return _index.jsxNamespacedName;
    }
  });
  Object.defineProperty(exports, "JSXOpeningElement", {
    enumerable: true,
    get: function () {
      return _index.jsxOpeningElement;
    }
  });
  Object.defineProperty(exports, "JSXSpreadAttribute", {
    enumerable: true,
    get: function () {
      return _index.jsxSpreadAttribute;
    }
  });
  Object.defineProperty(exports, "JSXText", {
    enumerable: true,
    get: function () {
      return _index.jsxText;
    }
  });
  Object.defineProperty(exports, "JSXFragment", {
    enumerable: true,
    get: function () {
      return _index.jsxFragment;
    }
  });
  Object.defineProperty(exports, "JSXOpeningFragment", {
    enumerable: true,
    get: function () {
      return _index.jsxOpeningFragment;
    }
  });
  Object.defineProperty(exports, "JSXClosingFragment", {
    enumerable: true,
    get: function () {
      return _index.jsxClosingFragment;
    }
  });
  Object.defineProperty(exports, "Noop", {
    enumerable: true,
    get: function () {
      return _index.noop;
    }
  });
  Object.defineProperty(exports, "Placeholder", {
    enumerable: true,
    get: function () {
      return _index.placeholder;
    }
  });
  Object.defineProperty(exports, "V8IntrinsicIdentifier", {
    enumerable: true,
    get: function () {
      return _index.v8IntrinsicIdentifier;
    }
  });
  Object.defineProperty(exports, "ArgumentPlaceholder", {
    enumerable: true,
    get: function () {
      return _index.argumentPlaceholder;
    }
  });
  Object.defineProperty(exports, "BindExpression", {
    enumerable: true,
    get: function () {
      return _index.bindExpression;
    }
  });
  Object.defineProperty(exports, "ImportAttribute", {
    enumerable: true,
    get: function () {
      return _index.importAttribute;
    }
  });
  Object.defineProperty(exports, "Decorator", {
    enumerable: true,
    get: function () {
      return _index.decorator;
    }
  });
  Object.defineProperty(exports, "DoExpression", {
    enumerable: true,
    get: function () {
      return _index.doExpression;
    }
  });
  Object.defineProperty(exports, "ExportDefaultSpecifier", {
    enumerable: true,
    get: function () {
      return _index.exportDefaultSpecifier;
    }
  });
  Object.defineProperty(exports, "RecordExpression", {
    enumerable: true,
    get: function () {
      return _index.recordExpression;
    }
  });
  Object.defineProperty(exports, "TupleExpression", {
    enumerable: true,
    get: function () {
      return _index.tupleExpression;
    }
  });
  Object.defineProperty(exports, "DecimalLiteral", {
    enumerable: true,
    get: function () {
      return _index.decimalLiteral;
    }
  });
  Object.defineProperty(exports, "StaticBlock", {
    enumerable: true,
    get: function () {
      return _index.staticBlock;
    }
  });
  Object.defineProperty(exports, "ModuleExpression", {
    enumerable: true,
    get: function () {
      return _index.moduleExpression;
    }
  });
  Object.defineProperty(exports, "TopicReference", {
    enumerable: true,
    get: function () {
      return _index.topicReference;
    }
  });
  Object.defineProperty(exports, "PipelineTopicExpression", {
    enumerable: true,
    get: function () {
      return _index.pipelineTopicExpression;
    }
  });
  Object.defineProperty(exports, "PipelineBareFunction", {
    enumerable: true,
    get: function () {
      return _index.pipelineBareFunction;
    }
  });
  Object.defineProperty(exports, "PipelinePrimaryTopicReference", {
    enumerable: true,
    get: function () {
      return _index.pipelinePrimaryTopicReference;
    }
  });
  Object.defineProperty(exports, "TSParameterProperty", {
    enumerable: true,
    get: function () {
      return _index.tsParameterProperty;
    }
  });
  Object.defineProperty(exports, "TSDeclareFunction", {
    enumerable: true,
    get: function () {
      return _index.tsDeclareFunction;
    }
  });
  Object.defineProperty(exports, "TSDeclareMethod", {
    enumerable: true,
    get: function () {
      return _index.tsDeclareMethod;
    }
  });
  Object.defineProperty(exports, "TSQualifiedName", {
    enumerable: true,
    get: function () {
      return _index.tsQualifiedName;
    }
  });
  Object.defineProperty(exports, "TSCallSignatureDeclaration", {
    enumerable: true,
    get: function () {
      return _index.tsCallSignatureDeclaration;
    }
  });
  Object.defineProperty(exports, "TSConstructSignatureDeclaration", {
    enumerable: true,
    get: function () {
      return _index.tsConstructSignatureDeclaration;
    }
  });
  Object.defineProperty(exports, "TSPropertySignature", {
    enumerable: true,
    get: function () {
      return _index.tsPropertySignature;
    }
  });
  Object.defineProperty(exports, "TSMethodSignature", {
    enumerable: true,
    get: function () {
      return _index.tsMethodSignature;
    }
  });
  Object.defineProperty(exports, "TSIndexSignature", {
    enumerable: true,
    get: function () {
      return _index.tsIndexSignature;
    }
  });
  Object.defineProperty(exports, "TSAnyKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsAnyKeyword;
    }
  });
  Object.defineProperty(exports, "TSBooleanKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsBooleanKeyword;
    }
  });
  Object.defineProperty(exports, "TSBigIntKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsBigIntKeyword;
    }
  });
  Object.defineProperty(exports, "TSIntrinsicKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsIntrinsicKeyword;
    }
  });
  Object.defineProperty(exports, "TSNeverKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsNeverKeyword;
    }
  });
  Object.defineProperty(exports, "TSNullKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsNullKeyword;
    }
  });
  Object.defineProperty(exports, "TSNumberKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsNumberKeyword;
    }
  });
  Object.defineProperty(exports, "TSObjectKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsObjectKeyword;
    }
  });
  Object.defineProperty(exports, "TSStringKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsStringKeyword;
    }
  });
  Object.defineProperty(exports, "TSSymbolKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsSymbolKeyword;
    }
  });
  Object.defineProperty(exports, "TSUndefinedKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsUndefinedKeyword;
    }
  });
  Object.defineProperty(exports, "TSUnknownKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsUnknownKeyword;
    }
  });
  Object.defineProperty(exports, "TSVoidKeyword", {
    enumerable: true,
    get: function () {
      return _index.tsVoidKeyword;
    }
  });
  Object.defineProperty(exports, "TSThisType", {
    enumerable: true,
    get: function () {
      return _index.tsThisType;
    }
  });
  Object.defineProperty(exports, "TSFunctionType", {
    enumerable: true,
    get: function () {
      return _index.tsFunctionType;
    }
  });
  Object.defineProperty(exports, "TSConstructorType", {
    enumerable: true,
    get: function () {
      return _index.tsConstructorType;
    }
  });
  Object.defineProperty(exports, "TSTypeReference", {
    enumerable: true,
    get: function () {
      return _index.tsTypeReference;
    }
  });
  Object.defineProperty(exports, "TSTypePredicate", {
    enumerable: true,
    get: function () {
      return _index.tsTypePredicate;
    }
  });
  Object.defineProperty(exports, "TSTypeQuery", {
    enumerable: true,
    get: function () {
      return _index.tsTypeQuery;
    }
  });
  Object.defineProperty(exports, "TSTypeLiteral", {
    enumerable: true,
    get: function () {
      return _index.tsTypeLiteral;
    }
  });
  Object.defineProperty(exports, "TSArrayType", {
    enumerable: true,
    get: function () {
      return _index.tsArrayType;
    }
  });
  Object.defineProperty(exports, "TSTupleType", {
    enumerable: true,
    get: function () {
      return _index.tsTupleType;
    }
  });
  Object.defineProperty(exports, "TSOptionalType", {
    enumerable: true,
    get: function () {
      return _index.tsOptionalType;
    }
  });
  Object.defineProperty(exports, "TSRestType", {
    enumerable: true,
    get: function () {
      return _index.tsRestType;
    }
  });
  Object.defineProperty(exports, "TSNamedTupleMember", {
    enumerable: true,
    get: function () {
      return _index.tsNamedTupleMember;
    }
  });
  Object.defineProperty(exports, "TSUnionType", {
    enumerable: true,
    get: function () {
      return _index.tsUnionType;
    }
  });
  Object.defineProperty(exports, "TSIntersectionType", {
    enumerable: true,
    get: function () {
      return _index.tsIntersectionType;
    }
  });
  Object.defineProperty(exports, "TSConditionalType", {
    enumerable: true,
    get: function () {
      return _index.tsConditionalType;
    }
  });
  Object.defineProperty(exports, "TSInferType", {
    enumerable: true,
    get: function () {
      return _index.tsInferType;
    }
  });
  Object.defineProperty(exports, "TSParenthesizedType", {
    enumerable: true,
    get: function () {
      return _index.tsParenthesizedType;
    }
  });
  Object.defineProperty(exports, "TSTypeOperator", {
    enumerable: true,
    get: function () {
      return _index.tsTypeOperator;
    }
  });
  Object.defineProperty(exports, "TSIndexedAccessType", {
    enumerable: true,
    get: function () {
      return _index.tsIndexedAccessType;
    }
  });
  Object.defineProperty(exports, "TSMappedType", {
    enumerable: true,
    get: function () {
      return _index.tsMappedType;
    }
  });
  Object.defineProperty(exports, "TSLiteralType", {
    enumerable: true,
    get: function () {
      return _index.tsLiteralType;
    }
  });
  Object.defineProperty(exports, "TSExpressionWithTypeArguments", {
    enumerable: true,
    get: function () {
      return _index.tsExpressionWithTypeArguments;
    }
  });
  Object.defineProperty(exports, "TSInterfaceDeclaration", {
    enumerable: true,
    get: function () {
      return _index.tsInterfaceDeclaration;
    }
  });
  Object.defineProperty(exports, "TSInterfaceBody", {
    enumerable: true,
    get: function () {
      return _index.tsInterfaceBody;
    }
  });
  Object.defineProperty(exports, "TSTypeAliasDeclaration", {
    enumerable: true,
    get: function () {
      return _index.tsTypeAliasDeclaration;
    }
  });
  Object.defineProperty(exports, "TSAsExpression", {
    enumerable: true,
    get: function () {
      return _index.tsAsExpression;
    }
  });
  Object.defineProperty(exports, "TSTypeAssertion", {
    enumerable: true,
    get: function () {
      return _index.tsTypeAssertion;
    }
  });
  Object.defineProperty(exports, "TSEnumDeclaration", {
    enumerable: true,
    get: function () {
      return _index.tsEnumDeclaration;
    }
  });
  Object.defineProperty(exports, "TSEnumMember", {
    enumerable: true,
    get: function () {
      return _index.tsEnumMember;
    }
  });
  Object.defineProperty(exports, "TSModuleDeclaration", {
    enumerable: true,
    get: function () {
      return _index.tsModuleDeclaration;
    }
  });
  Object.defineProperty(exports, "TSModuleBlock", {
    enumerable: true,
    get: function () {
      return _index.tsModuleBlock;
    }
  });
  Object.defineProperty(exports, "TSImportType", {
    enumerable: true,
    get: function () {
      return _index.tsImportType;
    }
  });
  Object.defineProperty(exports, "TSImportEqualsDeclaration", {
    enumerable: true,
    get: function () {
      return _index.tsImportEqualsDeclaration;
    }
  });
  Object.defineProperty(exports, "TSExternalModuleReference", {
    enumerable: true,
    get: function () {
      return _index.tsExternalModuleReference;
    }
  });
  Object.defineProperty(exports, "TSNonNullExpression", {
    enumerable: true,
    get: function () {
      return _index.tsNonNullExpression;
    }
  });
  Object.defineProperty(exports, "TSExportAssignment", {
    enumerable: true,
    get: function () {
      return _index.tsExportAssignment;
    }
  });
  Object.defineProperty(exports, "TSNamespaceExportDeclaration", {
    enumerable: true,
    get: function () {
      return _index.tsNamespaceExportDeclaration;
    }
  });
  Object.defineProperty(exports, "TSTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _index.tsTypeAnnotation;
    }
  });
  Object.defineProperty(exports, "TSTypeParameterInstantiation", {
    enumerable: true,
    get: function () {
      return _index.tsTypeParameterInstantiation;
    }
  });
  Object.defineProperty(exports, "TSTypeParameterDeclaration", {
    enumerable: true,
    get: function () {
      return _index.tsTypeParameterDeclaration;
    }
  });
  Object.defineProperty(exports, "TSTypeParameter", {
    enumerable: true,
    get: function () {
      return _index.tsTypeParameter;
    }
  });
  Object.defineProperty(exports, "NumberLiteral", {
    enumerable: true,
    get: function () {
      return _index.numberLiteral;
    }
  });
  Object.defineProperty(exports, "RegexLiteral", {
    enumerable: true,
    get: function () {
      return _index.regexLiteral;
    }
  });
  Object.defineProperty(exports, "RestProperty", {
    enumerable: true,
    get: function () {
      return _index.restProperty;
    }
  });
  Object.defineProperty(exports, "SpreadProperty", {
    enumerable: true,
    get: function () {
      return _index.spreadProperty;
    }
  });
  
  var _index = require("./index");
  },{"./index":36}],38:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = buildChildren;
  
  var _generated = require("../../validators/generated");
  
  var _cleanJSXElementLiteralChild = require("../../utils/react/cleanJSXElementLiteralChild");
  
  function buildChildren(node) {
    const elements = [];
  
    for (let i = 0; i < node.children.length; i++) {
      let child = node.children[i];
  
      if ((0, _generated.isJSXText)(child)) {
        (0, _cleanJSXElementLiteralChild.default)(child, elements);
        continue;
      }
  
      if ((0, _generated.isJSXExpressionContainer)(child)) child = child.expression;
      if ((0, _generated.isJSXEmptyExpression)(child)) continue;
      elements.push(child);
    }
  
    return elements;
  }
  },{"../../utils/react/cleanJSXElementLiteralChild":87,"../../validators/generated":90}],39:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = createTSUnionType;
  
  var _generated = require("../generated");
  
  var _removeTypeDuplicates = require("../../modifications/typescript/removeTypeDuplicates");
  
  function createTSUnionType(typeAnnotations) {
    const types = typeAnnotations.map(type => type.typeAnnotation);
    const flattened = (0, _removeTypeDuplicates.default)(types);
  
    if (flattened.length === 1) {
      return flattened[0];
    } else {
      return (0, _generated.tsUnionType)(flattened);
    }
  }
  },{"../../modifications/typescript/removeTypeDuplicates":81,"../generated":36}],40:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = clone;
  
  var _cloneNode = require("./cloneNode");
  
  function clone(node) {
    return (0, _cloneNode.default)(node, false);
  }
  },{"./cloneNode":43}],41:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = cloneDeep;
  
  var _cloneNode = require("./cloneNode");
  
  function cloneDeep(node) {
    return (0, _cloneNode.default)(node);
  }
  },{"./cloneNode":43}],42:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = cloneDeepWithoutLoc;
  
  var _cloneNode = require("./cloneNode");
  
  function cloneDeepWithoutLoc(node) {
    return (0, _cloneNode.default)(node, true, true);
  }
  },{"./cloneNode":43}],43:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = cloneNode;
  
  var _definitions = require("../definitions");
  
  var _generated = require("../validators/generated");
  
  const has = Function.call.bind(Object.prototype.hasOwnProperty);
  
  function cloneIfNode(obj, deep, withoutLoc) {
    if (obj && typeof obj.type === "string") {
      return cloneNode(obj, deep, withoutLoc);
    }
  
    return obj;
  }
  
  function cloneIfNodeOrArray(obj, deep, withoutLoc) {
    if (Array.isArray(obj)) {
      return obj.map(node => cloneIfNode(node, deep, withoutLoc));
    }
  
    return cloneIfNode(obj, deep, withoutLoc);
  }
  
  function cloneNode(node, deep = true, withoutLoc = false) {
    if (!node) return node;
    const {
      type
    } = node;
    const newNode = {
      type: node.type
    };
  
    if ((0, _generated.isIdentifier)(node)) {
      newNode.name = node.name;
  
      if (has(node, "optional") && typeof node.optional === "boolean") {
        newNode.optional = node.optional;
      }
  
      if (has(node, "typeAnnotation")) {
        newNode.typeAnnotation = deep ? cloneIfNodeOrArray(node.typeAnnotation, true, withoutLoc) : node.typeAnnotation;
      }
    } else if (!has(_definitions.NODE_FIELDS, type)) {
      throw new Error(`Unknown node type: "${type}"`);
    } else {
      for (const field of Object.keys(_definitions.NODE_FIELDS[type])) {
        if (has(node, field)) {
          if (deep) {
            newNode[field] = (0, _generated.isFile)(node) && field === "comments" ? maybeCloneComments(node.comments, deep, withoutLoc) : cloneIfNodeOrArray(node[field], true, withoutLoc);
          } else {
            newNode[field] = node[field];
          }
        }
      }
    }
  
    if (has(node, "loc")) {
      if (withoutLoc) {
        newNode.loc = null;
      } else {
        newNode.loc = node.loc;
      }
    }
  
    if (has(node, "leadingComments")) {
      newNode.leadingComments = maybeCloneComments(node.leadingComments, deep, withoutLoc);
    }
  
    if (has(node, "innerComments")) {
      newNode.innerComments = maybeCloneComments(node.innerComments, deep, withoutLoc);
    }
  
    if (has(node, "trailingComments")) {
      newNode.trailingComments = maybeCloneComments(node.trailingComments, deep, withoutLoc);
    }
  
    if (has(node, "extra")) {
      newNode.extra = Object.assign({}, node.extra);
    }
  
    return newNode;
  }
  
  function maybeCloneComments(comments, deep, withoutLoc) {
    if (!comments || !deep) {
      return comments;
    }
  
    return comments.map(({
      type,
      value,
      loc
    }) => {
      if (withoutLoc) {
        return {
          type,
          value,
          loc: null
        };
      }
  
      return {
        type,
        value,
        loc
      };
    });
  }
  },{"../definitions":68,"../validators/generated":90}],44:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = cloneWithoutLoc;
  
  var _cloneNode = require("./cloneNode");
  
  function cloneWithoutLoc(node) {
    return (0, _cloneNode.default)(node, false, true);
  }
  },{"./cloneNode":43}],45:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = addComment;
  
  var _addComments = require("./addComments");
  
  function addComment(node, type, content, line) {
    return (0, _addComments.default)(node, type, [{
      type: line ? "CommentLine" : "CommentBlock",
      value: content
    }]);
  }
  },{"./addComments":46}],46:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = addComments;
  
  function addComments(node, type, comments) {
    if (!comments || !node) return node;
    const key = `${type}Comments`;
  
    if (node[key]) {
      if (type === "leading") {
        node[key] = comments.concat(node[key]);
      } else {
        node[key].push(...comments);
      }
    } else {
      node[key] = comments;
    }
  
    return node;
  }
  },{}],47:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = inheritInnerComments;
  
  var _inherit = require("../utils/inherit");
  
  function inheritInnerComments(child, parent) {
    (0, _inherit.default)("innerComments", child, parent);
  }
  },{"../utils/inherit":86}],48:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = inheritLeadingComments;
  
  var _inherit = require("../utils/inherit");
  
  function inheritLeadingComments(child, parent) {
    (0, _inherit.default)("leadingComments", child, parent);
  }
  },{"../utils/inherit":86}],49:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = inheritTrailingComments;
  
  var _inherit = require("../utils/inherit");
  
  function inheritTrailingComments(child, parent) {
    (0, _inherit.default)("trailingComments", child, parent);
  }
  },{"../utils/inherit":86}],50:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = inheritsComments;
  
  var _inheritTrailingComments = require("./inheritTrailingComments");
  
  var _inheritLeadingComments = require("./inheritLeadingComments");
  
  var _inheritInnerComments = require("./inheritInnerComments");
  
  function inheritsComments(child, parent) {
    (0, _inheritTrailingComments.default)(child, parent);
    (0, _inheritLeadingComments.default)(child, parent);
    (0, _inheritInnerComments.default)(child, parent);
    return child;
  }
  },{"./inheritInnerComments":47,"./inheritLeadingComments":48,"./inheritTrailingComments":49}],51:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = removeComments;
  
  var _constants = require("../constants");
  
  function removeComments(node) {
    _constants.COMMENT_KEYS.forEach(key => {
      node[key] = null;
    });
  
    return node;
  }
  },{"../constants":53}],52:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.TSBASETYPE_TYPES = exports.TSTYPE_TYPES = exports.TSTYPEELEMENT_TYPES = exports.JSX_TYPES = exports.ENUMMEMBER_TYPES = exports.ENUMBODY_TYPES = exports.FLOWPREDICATE_TYPES = exports.FLOWDECLARATION_TYPES = exports.FLOWBASEANNOTATION_TYPES = exports.FLOWTYPE_TYPES = exports.FLOW_TYPES = exports.PRIVATE_TYPES = exports.MODULESPECIFIER_TYPES = exports.EXPORTDECLARATION_TYPES = exports.MODULEDECLARATION_TYPES = exports.CLASS_TYPES = exports.PATTERN_TYPES = exports.UNARYLIKE_TYPES = exports.PROPERTY_TYPES = exports.OBJECTMEMBER_TYPES = exports.METHOD_TYPES = exports.USERWHITESPACABLE_TYPES = exports.IMMUTABLE_TYPES = exports.LITERAL_TYPES = exports.TSENTITYNAME_TYPES = exports.LVAL_TYPES = exports.PATTERNLIKE_TYPES = exports.DECLARATION_TYPES = exports.PUREISH_TYPES = exports.FUNCTIONPARENT_TYPES = exports.FUNCTION_TYPES = exports.FORXSTATEMENT_TYPES = exports.FOR_TYPES = exports.EXPRESSIONWRAPPER_TYPES = exports.WHILE_TYPES = exports.LOOP_TYPES = exports.CONDITIONAL_TYPES = exports.COMPLETIONSTATEMENT_TYPES = exports.TERMINATORLESS_TYPES = exports.STATEMENT_TYPES = exports.BLOCK_TYPES = exports.BLOCKPARENT_TYPES = exports.SCOPABLE_TYPES = exports.BINARY_TYPES = exports.EXPRESSION_TYPES = void 0;
  
  var _definitions = require("../../definitions");
  
  const EXPRESSION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Expression"];
  exports.EXPRESSION_TYPES = EXPRESSION_TYPES;
  const BINARY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Binary"];
  exports.BINARY_TYPES = BINARY_TYPES;
  const SCOPABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Scopable"];
  exports.SCOPABLE_TYPES = SCOPABLE_TYPES;
  const BLOCKPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["BlockParent"];
  exports.BLOCKPARENT_TYPES = BLOCKPARENT_TYPES;
  const BLOCK_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Block"];
  exports.BLOCK_TYPES = BLOCK_TYPES;
  const STATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Statement"];
  exports.STATEMENT_TYPES = STATEMENT_TYPES;
  const TERMINATORLESS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Terminatorless"];
  exports.TERMINATORLESS_TYPES = TERMINATORLESS_TYPES;
  const COMPLETIONSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["CompletionStatement"];
  exports.COMPLETIONSTATEMENT_TYPES = COMPLETIONSTATEMENT_TYPES;
  const CONDITIONAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Conditional"];
  exports.CONDITIONAL_TYPES = CONDITIONAL_TYPES;
  const LOOP_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Loop"];
  exports.LOOP_TYPES = LOOP_TYPES;
  const WHILE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["While"];
  exports.WHILE_TYPES = WHILE_TYPES;
  const EXPRESSIONWRAPPER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExpressionWrapper"];
  exports.EXPRESSIONWRAPPER_TYPES = EXPRESSIONWRAPPER_TYPES;
  const FOR_TYPES = _definitions.FLIPPED_ALIAS_KEYS["For"];
  exports.FOR_TYPES = FOR_TYPES;
  const FORXSTATEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ForXStatement"];
  exports.FORXSTATEMENT_TYPES = FORXSTATEMENT_TYPES;
  const FUNCTION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Function"];
  exports.FUNCTION_TYPES = FUNCTION_TYPES;
  const FUNCTIONPARENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FunctionParent"];
  exports.FUNCTIONPARENT_TYPES = FUNCTIONPARENT_TYPES;
  const PUREISH_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pureish"];
  exports.PUREISH_TYPES = PUREISH_TYPES;
  const DECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Declaration"];
  exports.DECLARATION_TYPES = DECLARATION_TYPES;
  const PATTERNLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["PatternLike"];
  exports.PATTERNLIKE_TYPES = PATTERNLIKE_TYPES;
  const LVAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["LVal"];
  exports.LVAL_TYPES = LVAL_TYPES;
  const TSENTITYNAME_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSEntityName"];
  exports.TSENTITYNAME_TYPES = TSENTITYNAME_TYPES;
  const LITERAL_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Literal"];
  exports.LITERAL_TYPES = LITERAL_TYPES;
  const IMMUTABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Immutable"];
  exports.IMMUTABLE_TYPES = IMMUTABLE_TYPES;
  const USERWHITESPACABLE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UserWhitespacable"];
  exports.USERWHITESPACABLE_TYPES = USERWHITESPACABLE_TYPES;
  const METHOD_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Method"];
  exports.METHOD_TYPES = METHOD_TYPES;
  const OBJECTMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ObjectMember"];
  exports.OBJECTMEMBER_TYPES = OBJECTMEMBER_TYPES;
  const PROPERTY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Property"];
  exports.PROPERTY_TYPES = PROPERTY_TYPES;
  const UNARYLIKE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["UnaryLike"];
  exports.UNARYLIKE_TYPES = UNARYLIKE_TYPES;
  const PATTERN_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Pattern"];
  exports.PATTERN_TYPES = PATTERN_TYPES;
  const CLASS_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Class"];
  exports.CLASS_TYPES = CLASS_TYPES;
  const MODULEDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleDeclaration"];
  exports.MODULEDECLARATION_TYPES = MODULEDECLARATION_TYPES;
  const EXPORTDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ExportDeclaration"];
  exports.EXPORTDECLARATION_TYPES = EXPORTDECLARATION_TYPES;
  const MODULESPECIFIER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["ModuleSpecifier"];
  exports.MODULESPECIFIER_TYPES = MODULESPECIFIER_TYPES;
  const PRIVATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Private"];
  exports.PRIVATE_TYPES = PRIVATE_TYPES;
  const FLOW_TYPES = _definitions.FLIPPED_ALIAS_KEYS["Flow"];
  exports.FLOW_TYPES = FLOW_TYPES;
  const FLOWTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowType"];
  exports.FLOWTYPE_TYPES = FLOWTYPE_TYPES;
  const FLOWBASEANNOTATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowBaseAnnotation"];
  exports.FLOWBASEANNOTATION_TYPES = FLOWBASEANNOTATION_TYPES;
  const FLOWDECLARATION_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowDeclaration"];
  exports.FLOWDECLARATION_TYPES = FLOWDECLARATION_TYPES;
  const FLOWPREDICATE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["FlowPredicate"];
  exports.FLOWPREDICATE_TYPES = FLOWPREDICATE_TYPES;
  const ENUMBODY_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumBody"];
  exports.ENUMBODY_TYPES = ENUMBODY_TYPES;
  const ENUMMEMBER_TYPES = _definitions.FLIPPED_ALIAS_KEYS["EnumMember"];
  exports.ENUMMEMBER_TYPES = ENUMMEMBER_TYPES;
  const JSX_TYPES = _definitions.FLIPPED_ALIAS_KEYS["JSX"];
  exports.JSX_TYPES = JSX_TYPES;
  const TSTYPEELEMENT_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSTypeElement"];
  exports.TSTYPEELEMENT_TYPES = TSTYPEELEMENT_TYPES;
  const TSTYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSType"];
  exports.TSTYPE_TYPES = TSTYPE_TYPES;
  const TSBASETYPE_TYPES = _definitions.FLIPPED_ALIAS_KEYS["TSBaseType"];
  exports.TSBASETYPE_TYPES = TSBASETYPE_TYPES;
  },{"../../definitions":68}],53:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.NOT_LOCAL_BINDING = exports.BLOCK_SCOPED_SYMBOL = exports.INHERIT_KEYS = exports.UNARY_OPERATORS = exports.STRING_UNARY_OPERATORS = exports.NUMBER_UNARY_OPERATORS = exports.BOOLEAN_UNARY_OPERATORS = exports.ASSIGNMENT_OPERATORS = exports.BINARY_OPERATORS = exports.NUMBER_BINARY_OPERATORS = exports.BOOLEAN_BINARY_OPERATORS = exports.COMPARISON_BINARY_OPERATORS = exports.EQUALITY_BINARY_OPERATORS = exports.BOOLEAN_NUMBER_BINARY_OPERATORS = exports.UPDATE_OPERATORS = exports.LOGICAL_OPERATORS = exports.COMMENT_KEYS = exports.FOR_INIT_KEYS = exports.FLATTENABLE_KEYS = exports.STATEMENT_OR_BLOCK_KEYS = void 0;
  const STATEMENT_OR_BLOCK_KEYS = ["consequent", "body", "alternate"];
  exports.STATEMENT_OR_BLOCK_KEYS = STATEMENT_OR_BLOCK_KEYS;
  const FLATTENABLE_KEYS = ["body", "expressions"];
  exports.FLATTENABLE_KEYS = FLATTENABLE_KEYS;
  const FOR_INIT_KEYS = ["left", "init"];
  exports.FOR_INIT_KEYS = FOR_INIT_KEYS;
  const COMMENT_KEYS = ["leadingComments", "trailingComments", "innerComments"];
  exports.COMMENT_KEYS = COMMENT_KEYS;
  const LOGICAL_OPERATORS = ["||", "&&", "??"];
  exports.LOGICAL_OPERATORS = LOGICAL_OPERATORS;
  const UPDATE_OPERATORS = ["++", "--"];
  exports.UPDATE_OPERATORS = UPDATE_OPERATORS;
  const BOOLEAN_NUMBER_BINARY_OPERATORS = [">", "<", ">=", "<="];
  exports.BOOLEAN_NUMBER_BINARY_OPERATORS = BOOLEAN_NUMBER_BINARY_OPERATORS;
  const EQUALITY_BINARY_OPERATORS = ["==", "===", "!=", "!=="];
  exports.EQUALITY_BINARY_OPERATORS = EQUALITY_BINARY_OPERATORS;
  const COMPARISON_BINARY_OPERATORS = [...EQUALITY_BINARY_OPERATORS, "in", "instanceof"];
  exports.COMPARISON_BINARY_OPERATORS = COMPARISON_BINARY_OPERATORS;
  const BOOLEAN_BINARY_OPERATORS = [...COMPARISON_BINARY_OPERATORS, ...BOOLEAN_NUMBER_BINARY_OPERATORS];
  exports.BOOLEAN_BINARY_OPERATORS = BOOLEAN_BINARY_OPERATORS;
  const NUMBER_BINARY_OPERATORS = ["-", "/", "%", "*", "**", "&", "|", ">>", ">>>", "<<", "^"];
  exports.NUMBER_BINARY_OPERATORS = NUMBER_BINARY_OPERATORS;
  const BINARY_OPERATORS = ["+", ...NUMBER_BINARY_OPERATORS, ...BOOLEAN_BINARY_OPERATORS];
  exports.BINARY_OPERATORS = BINARY_OPERATORS;
  const ASSIGNMENT_OPERATORS = ["=", "+=", ...NUMBER_BINARY_OPERATORS.map(op => op + "="), ...LOGICAL_OPERATORS.map(op => op + "=")];
  exports.ASSIGNMENT_OPERATORS = ASSIGNMENT_OPERATORS;
  const BOOLEAN_UNARY_OPERATORS = ["delete", "!"];
  exports.BOOLEAN_UNARY_OPERATORS = BOOLEAN_UNARY_OPERATORS;
  const NUMBER_UNARY_OPERATORS = ["+", "-", "~"];
  exports.NUMBER_UNARY_OPERATORS = NUMBER_UNARY_OPERATORS;
  const STRING_UNARY_OPERATORS = ["typeof"];
  exports.STRING_UNARY_OPERATORS = STRING_UNARY_OPERATORS;
  const UNARY_OPERATORS = ["void", "throw", ...BOOLEAN_UNARY_OPERATORS, ...NUMBER_UNARY_OPERATORS, ...STRING_UNARY_OPERATORS];
  exports.UNARY_OPERATORS = UNARY_OPERATORS;
  const INHERIT_KEYS = {
    optional: ["typeAnnotation", "typeParameters", "returnType"],
    force: ["start", "loc", "end"]
  };
  exports.INHERIT_KEYS = INHERIT_KEYS;
  const BLOCK_SCOPED_SYMBOL = Symbol.for("var used to be block scoped");
  exports.BLOCK_SCOPED_SYMBOL = BLOCK_SCOPED_SYMBOL;
  const NOT_LOCAL_BINDING = Symbol.for("should not be considered a local binding");
  exports.NOT_LOCAL_BINDING = NOT_LOCAL_BINDING;
  },{}],54:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = ensureBlock;
  
  var _toBlock = require("./toBlock");
  
  function ensureBlock(node, key = "body") {
    return node[key] = (0, _toBlock.default)(node[key], node);
  }
  },{"./toBlock":57}],55:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = gatherSequenceExpressions;
  
  var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers");
  
  var _generated = require("../validators/generated");
  
  var _generated2 = require("../builders/generated");
  
  var _cloneNode = require("../clone/cloneNode");
  
  function gatherSequenceExpressions(nodes, scope, declars) {
    const exprs = [];
    let ensureLastUndefined = true;
  
    for (const node of nodes) {
      if (!(0, _generated.isEmptyStatement)(node)) {
        ensureLastUndefined = false;
      }
  
      if ((0, _generated.isExpression)(node)) {
        exprs.push(node);
      } else if ((0, _generated.isExpressionStatement)(node)) {
        exprs.push(node.expression);
      } else if ((0, _generated.isVariableDeclaration)(node)) {
        if (node.kind !== "var") return;
  
        for (const declar of node.declarations) {
          const bindings = (0, _getBindingIdentifiers.default)(declar);
  
          for (const key of Object.keys(bindings)) {
            declars.push({
              kind: node.kind,
              id: (0, _cloneNode.default)(bindings[key])
            });
          }
  
          if (declar.init) {
            exprs.push((0, _generated2.assignmentExpression)("=", declar.id, declar.init));
          }
        }
  
        ensureLastUndefined = true;
      } else if ((0, _generated.isIfStatement)(node)) {
        const consequent = node.consequent ? gatherSequenceExpressions([node.consequent], scope, declars) : scope.buildUndefinedNode();
        const alternate = node.alternate ? gatherSequenceExpressions([node.alternate], scope, declars) : scope.buildUndefinedNode();
        if (!consequent || !alternate) return;
        exprs.push((0, _generated2.conditionalExpression)(node.test, consequent, alternate));
      } else if ((0, _generated.isBlockStatement)(node)) {
        const body = gatherSequenceExpressions(node.body, scope, declars);
        if (!body) return;
        exprs.push(body);
      } else if ((0, _generated.isEmptyStatement)(node)) {
        if (nodes.indexOf(node) === 0) {
          ensureLastUndefined = true;
        }
      } else {
        return;
      }
    }
  
    if (ensureLastUndefined) {
      exprs.push(scope.buildUndefinedNode());
    }
  
    if (exprs.length === 1) {
      return exprs[0];
    } else {
      return (0, _generated2.sequenceExpression)(exprs);
    }
  }
  },{"../builders/generated":36,"../clone/cloneNode":43,"../retrievers/getBindingIdentifiers":82,"../validators/generated":90}],56:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = toBindingIdentifierName;
  
  var _toIdentifier = require("./toIdentifier");
  
  function toBindingIdentifierName(name) {
    name = (0, _toIdentifier.default)(name);
    if (name === "eval" || name === "arguments") name = "_" + name;
    return name;
  }
  },{"./toIdentifier":60}],57:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = toBlock;
  
  var _generated = require("../validators/generated");
  
  var _generated2 = require("../builders/generated");
  
  function toBlock(node, parent) {
    if ((0, _generated.isBlockStatement)(node)) {
      return node;
    }
  
    let blockNodes = [];
  
    if ((0, _generated.isEmptyStatement)(node)) {
      blockNodes = [];
    } else {
      if (!(0, _generated.isStatement)(node)) {
        if ((0, _generated.isFunction)(parent)) {
          node = (0, _generated2.returnStatement)(node);
        } else {
          node = (0, _generated2.expressionStatement)(node);
        }
      }
  
      blockNodes = [node];
    }
  
    return (0, _generated2.blockStatement)(blockNodes);
  }
  },{"../builders/generated":36,"../validators/generated":90}],58:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = toComputedKey;
  
  var _generated = require("../validators/generated");
  
  var _generated2 = require("../builders/generated");
  
  function toComputedKey(node, key = node.key || node.property) {
    if (!node.computed && (0, _generated.isIdentifier)(key)) key = (0, _generated2.stringLiteral)(key.name);
    return key;
  }
  },{"../builders/generated":36,"../validators/generated":90}],59:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  
  var _generated = require("../validators/generated");
  
  var _default = toExpression;
  exports.default = _default;
  
  function toExpression(node) {
    if ((0, _generated.isExpressionStatement)(node)) {
      node = node.expression;
    }
  
    if ((0, _generated.isExpression)(node)) {
      return node;
    }
  
    if ((0, _generated.isClass)(node)) {
      node.type = "ClassExpression";
    } else if ((0, _generated.isFunction)(node)) {
      node.type = "FunctionExpression";
    }
  
    if (!(0, _generated.isExpression)(node)) {
      throw new Error(`cannot turn ${node.type} to an expression`);
    }
  
    return node;
  }
  },{"../validators/generated":90}],60:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = toIdentifier;
  
  var _isValidIdentifier = require("../validators/isValidIdentifier");
  
  var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
  
  function toIdentifier(input) {
    input = input + "";
    let name = "";
  
    for (const c of input) {
      name += (0, _helperValidatorIdentifier.isIdentifierChar)(c.codePointAt(0)) ? c : "-";
    }
  
    name = name.replace(/^[-0-9]+/, "");
    name = name.replace(/[-\s]+(.)?/g, function (match, c) {
      return c ? c.toUpperCase() : "";
    });
  
    if (!(0, _isValidIdentifier.default)(name)) {
      name = `_${name}`;
    }
  
    return name || "_";
  }
  },{"../validators/isValidIdentifier":104,"@babel/helper-validator-identifier":28}],61:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = toKeyAlias;
  
  var _generated = require("../validators/generated");
  
  var _cloneNode = require("../clone/cloneNode");
  
  var _removePropertiesDeep = require("../modifications/removePropertiesDeep");
  
  function toKeyAlias(node, key = node.key) {
    let alias;
  
    if (node.kind === "method") {
      return toKeyAlias.increment() + "";
    } else if ((0, _generated.isIdentifier)(key)) {
      alias = key.name;
    } else if ((0, _generated.isStringLiteral)(key)) {
      alias = JSON.stringify(key.value);
    } else {
      alias = JSON.stringify((0, _removePropertiesDeep.default)((0, _cloneNode.default)(key)));
    }
  
    if (node.computed) {
      alias = `[${alias}]`;
    }
  
    if (node.static) {
      alias = `static:${alias}`;
    }
  
    return alias;
  }
  
  toKeyAlias.uid = 0;
  
  toKeyAlias.increment = function () {
    if (toKeyAlias.uid >= Number.MAX_SAFE_INTEGER) {
      return toKeyAlias.uid = 0;
    } else {
      return toKeyAlias.uid++;
    }
  };
  },{"../clone/cloneNode":43,"../modifications/removePropertiesDeep":80,"../validators/generated":90}],62:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = toSequenceExpression;
  
  var _gatherSequenceExpressions = require("./gatherSequenceExpressions");
  
  function toSequenceExpression(nodes, scope) {
    if (!(nodes != null && nodes.length)) return;
    const declars = [];
    const result = (0, _gatherSequenceExpressions.default)(nodes, scope, declars);
    if (!result) return;
  
    for (const declar of declars) {
      scope.push(declar);
    }
  
    return result;
  }
  },{"./gatherSequenceExpressions":55}],63:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  
  var _generated = require("../validators/generated");
  
  var _generated2 = require("../builders/generated");
  
  var _default = toStatement;
  exports.default = _default;
  
  function toStatement(node, ignore) {
    if ((0, _generated.isStatement)(node)) {
      return node;
    }
  
    let mustHaveId = false;
    let newType;
  
    if ((0, _generated.isClass)(node)) {
      mustHaveId = true;
      newType = "ClassDeclaration";
    } else if ((0, _generated.isFunction)(node)) {
      mustHaveId = true;
      newType = "FunctionDeclaration";
    } else if ((0, _generated.isAssignmentExpression)(node)) {
      return (0, _generated2.expressionStatement)(node);
    }
  
    if (mustHaveId && !node.id) {
      newType = false;
    }
  
    if (!newType) {
      if (ignore) {
        return false;
      } else {
        throw new Error(`cannot turn ${node.type} to a statement`);
      }
    }
  
    node.type = newType;
    return node;
  }
  },{"../builders/generated":36,"../validators/generated":90}],64:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  
  var _isValidIdentifier = require("../validators/isValidIdentifier");
  
  var _generated = require("../builders/generated");
  
  var _default = valueToNode;
  exports.default = _default;
  const objectToString = Function.call.bind(Object.prototype.toString);
  
  function isRegExp(value) {
    return objectToString(value) === "[object RegExp]";
  }
  
  function isPlainObject(value) {
    if (typeof value !== "object" || value === null || Object.prototype.toString.call(value) !== "[object Object]") {
      return false;
    }
  
    const proto = Object.getPrototypeOf(value);
    return proto === null || Object.getPrototypeOf(proto) === null;
  }
  
  function valueToNode(value) {
    if (value === undefined) {
      return (0, _generated.identifier)("undefined");
    }
  
    if (value === true || value === false) {
      return (0, _generated.booleanLiteral)(value);
    }
  
    if (value === null) {
      return (0, _generated.nullLiteral)();
    }
  
    if (typeof value === "string") {
      return (0, _generated.stringLiteral)(value);
    }
  
    if (typeof value === "number") {
      let result;
  
      if (Number.isFinite(value)) {
        result = (0, _generated.numericLiteral)(Math.abs(value));
      } else {
        let numerator;
  
        if (Number.isNaN(value)) {
          numerator = (0, _generated.numericLiteral)(0);
        } else {
          numerator = (0, _generated.numericLiteral)(1);
        }
  
        result = (0, _generated.binaryExpression)("/", numerator, (0, _generated.numericLiteral)(0));
      }
  
      if (value < 0 || Object.is(value, -0)) {
        result = (0, _generated.unaryExpression)("-", result);
      }
  
      return result;
    }
  
    if (isRegExp(value)) {
      const pattern = value.source;
      const flags = value.toString().match(/\/([a-z]+|)$/)[1];
      return (0, _generated.regExpLiteral)(pattern, flags);
    }
  
    if (Array.isArray(value)) {
      return (0, _generated.arrayExpression)(value.map(valueToNode));
    }
  
    if (isPlainObject(value)) {
      const props = [];
  
      for (const key of Object.keys(value)) {
        let nodeKey;
  
        if ((0, _isValidIdentifier.default)(key)) {
          nodeKey = (0, _generated.identifier)(key);
        } else {
          nodeKey = (0, _generated.stringLiteral)(key);
        }
  
        props.push((0, _generated.objectProperty)(nodeKey, valueToNode(value[key])));
      }
  
      return (0, _generated.objectExpression)(props);
    }
  
    throw new Error("don't know how to turn this value into a node");
  }
  },{"../builders/generated":36,"../validators/isValidIdentifier":104}],65:[function(require,module,exports){
  (function (process){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.classMethodOrDeclareMethodCommon = exports.classMethodOrPropertyCommon = exports.patternLikeCommon = exports.functionDeclarationCommon = exports.functionTypeAnnotationCommon = exports.functionCommon = void 0;
  
  var _is = require("../validators/is");
  
  var _isValidIdentifier = require("../validators/isValidIdentifier");
  
  var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
  
  var _constants = require("../constants");
  
  var _utils = require("./utils");
  
  (0, _utils.default)("ArrayExpression", {
    fields: {
      elements: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "Expression", "SpreadElement"))),
        default: !process.env.BABEL_TYPES_8_BREAKING ? [] : undefined
      }
    },
    visitor: ["elements"],
    aliases: ["Expression"]
  });
  (0, _utils.default)("AssignmentExpression", {
    fields: {
      operator: {
        validate: function () {
          if (!process.env.BABEL_TYPES_8_BREAKING) {
            return (0, _utils.assertValueType)("string");
          }
  
          const identifier = (0, _utils.assertOneOf)(..._constants.ASSIGNMENT_OPERATORS);
          const pattern = (0, _utils.assertOneOf)("=");
          return function (node, key, val) {
            const validator = (0, _is.default)("Pattern", node.left) ? pattern : identifier;
            validator(node, key, val);
          };
        }()
      },
      left: {
        validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern")
      },
      right: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    },
    builder: ["operator", "left", "right"],
    visitor: ["left", "right"],
    aliases: ["Expression"]
  });
  (0, _utils.default)("BinaryExpression", {
    builder: ["operator", "left", "right"],
    fields: {
      operator: {
        validate: (0, _utils.assertOneOf)(..._constants.BINARY_OPERATORS)
      },
      left: {
        validate: function () {
          const expression = (0, _utils.assertNodeType)("Expression");
          const inOp = (0, _utils.assertNodeType)("Expression", "PrivateName");
  
          const validator = function (node, key, val) {
            const validator = node.operator === "in" ? inOp : expression;
            validator(node, key, val);
          };
  
          validator.oneOfNodeTypes = ["Expression", "PrivateName"];
          return validator;
        }()
      },
      right: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    },
    visitor: ["left", "right"],
    aliases: ["Binary", "Expression"]
  });
  (0, _utils.default)("InterpreterDirective", {
    builder: ["value"],
    fields: {
      value: {
        validate: (0, _utils.assertValueType)("string")
      }
    }
  });
  (0, _utils.default)("Directive", {
    visitor: ["value"],
    fields: {
      value: {
        validate: (0, _utils.assertNodeType)("DirectiveLiteral")
      }
    }
  });
  (0, _utils.default)("DirectiveLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: (0, _utils.assertValueType)("string")
      }
    }
  });
  (0, _utils.default)("BlockStatement", {
    builder: ["body", "directives"],
    visitor: ["directives", "body"],
    fields: {
      directives: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
        default: []
      },
      body: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
      }
    },
    aliases: ["Scopable", "BlockParent", "Block", "Statement"]
  });
  (0, _utils.default)("BreakStatement", {
    visitor: ["label"],
    fields: {
      label: {
        validate: (0, _utils.assertNodeType)("Identifier"),
        optional: true
      }
    },
    aliases: ["Statement", "Terminatorless", "CompletionStatement"]
  });
  (0, _utils.default)("CallExpression", {
    visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
    builder: ["callee", "arguments"],
    aliases: ["Expression"],
    fields: Object.assign({
      callee: {
        validate: (0, _utils.assertNodeType)("Expression", "V8IntrinsicIdentifier")
      },
      arguments: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
      }
    }, !process.env.BABEL_TYPES_8_BREAKING ? {
      optional: {
        validate: (0, _utils.assertOneOf)(true, false),
        optional: true
      }
    } : {}, {
      typeArguments: {
        validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
        optional: true
      },
      typeParameters: {
        validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
        optional: true
      }
    })
  });
  (0, _utils.default)("CatchClause", {
    visitor: ["param", "body"],
    fields: {
      param: {
        validate: (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern"),
        optional: true
      },
      body: {
        validate: (0, _utils.assertNodeType)("BlockStatement")
      }
    },
    aliases: ["Scopable", "BlockParent"]
  });
  (0, _utils.default)("ConditionalExpression", {
    visitor: ["test", "consequent", "alternate"],
    fields: {
      test: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      consequent: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      alternate: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    },
    aliases: ["Expression", "Conditional"]
  });
  (0, _utils.default)("ContinueStatement", {
    visitor: ["label"],
    fields: {
      label: {
        validate: (0, _utils.assertNodeType)("Identifier"),
        optional: true
      }
    },
    aliases: ["Statement", "Terminatorless", "CompletionStatement"]
  });
  (0, _utils.default)("DebuggerStatement", {
    aliases: ["Statement"]
  });
  (0, _utils.default)("DoWhileStatement", {
    visitor: ["test", "body"],
    fields: {
      test: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      body: {
        validate: (0, _utils.assertNodeType)("Statement")
      }
    },
    aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"]
  });
  (0, _utils.default)("EmptyStatement", {
    aliases: ["Statement"]
  });
  (0, _utils.default)("ExpressionStatement", {
    visitor: ["expression"],
    fields: {
      expression: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    },
    aliases: ["Statement", "ExpressionWrapper"]
  });
  (0, _utils.default)("File", {
    builder: ["program", "comments", "tokens"],
    visitor: ["program"],
    fields: {
      program: {
        validate: (0, _utils.assertNodeType)("Program")
      },
      comments: {
        validate: !process.env.BABEL_TYPES_8_BREAKING ? Object.assign(() => {}, {
          each: {
            oneOfNodeTypes: ["CommentBlock", "CommentLine"]
          }
        }) : (0, _utils.assertEach)((0, _utils.assertNodeType)("CommentBlock", "CommentLine")),
        optional: true
      },
      tokens: {
        validate: (0, _utils.assertEach)(Object.assign(() => {}, {
          type: "any"
        })),
        optional: true
      }
    }
  });
  (0, _utils.default)("ForInStatement", {
    visitor: ["left", "right", "body"],
    aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
    fields: {
      left: {
        validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("VariableDeclaration", "LVal") : (0, _utils.assertNodeType)("VariableDeclaration", "Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern")
      },
      right: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      body: {
        validate: (0, _utils.assertNodeType)("Statement")
      }
    }
  });
  (0, _utils.default)("ForStatement", {
    visitor: ["init", "test", "update", "body"],
    aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop"],
    fields: {
      init: {
        validate: (0, _utils.assertNodeType)("VariableDeclaration", "Expression"),
        optional: true
      },
      test: {
        validate: (0, _utils.assertNodeType)("Expression"),
        optional: true
      },
      update: {
        validate: (0, _utils.assertNodeType)("Expression"),
        optional: true
      },
      body: {
        validate: (0, _utils.assertNodeType)("Statement")
      }
    }
  });
  const functionCommon = {
    params: {
      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement")))
    },
    generator: {
      default: false
    },
    async: {
      default: false
    }
  };
  exports.functionCommon = functionCommon;
  const functionTypeAnnotationCommon = {
    returnType: {
      validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
      optional: true
    },
    typeParameters: {
      validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
      optional: true
    }
  };
  exports.functionTypeAnnotationCommon = functionTypeAnnotationCommon;
  const functionDeclarationCommon = Object.assign({}, functionCommon, {
    declare: {
      validate: (0, _utils.assertValueType)("boolean"),
      optional: true
    },
    id: {
      validate: (0, _utils.assertNodeType)("Identifier"),
      optional: true
    }
  });
  exports.functionDeclarationCommon = functionDeclarationCommon;
  (0, _utils.default)("FunctionDeclaration", {
    builder: ["id", "params", "body", "generator", "async"],
    visitor: ["id", "params", "body", "returnType", "typeParameters"],
    fields: Object.assign({}, functionDeclarationCommon, functionTypeAnnotationCommon, {
      body: {
        validate: (0, _utils.assertNodeType)("BlockStatement")
      }
    }),
    aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Statement", "Pureish", "Declaration"],
    validate: function () {
      if (!process.env.BABEL_TYPES_8_BREAKING) return () => {};
      const identifier = (0, _utils.assertNodeType)("Identifier");
      return function (parent, key, node) {
        if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
          identifier(node, "id", node.id);
        }
      };
    }()
  });
  (0, _utils.default)("FunctionExpression", {
    inherits: "FunctionDeclaration",
    aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
    fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
      id: {
        validate: (0, _utils.assertNodeType)("Identifier"),
        optional: true
      },
      body: {
        validate: (0, _utils.assertNodeType)("BlockStatement")
      }
    })
  });
  const patternLikeCommon = {
    typeAnnotation: {
      validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
      optional: true
    },
    decorators: {
      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator")))
    }
  };
  exports.patternLikeCommon = patternLikeCommon;
  (0, _utils.default)("Identifier", {
    builder: ["name"],
    visitor: ["typeAnnotation", "decorators"],
    aliases: ["Expression", "PatternLike", "LVal", "TSEntityName"],
    fields: Object.assign({}, patternLikeCommon, {
      name: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
          if (!process.env.BABEL_TYPES_8_BREAKING) return;
  
          if (!(0, _isValidIdentifier.default)(val, false)) {
            throw new TypeError(`"${val}" is not a valid identifier name`);
          }
        }, {
          type: "string"
        }))
      },
      optional: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      }
    }),
  
    validate(parent, key, node) {
      if (!process.env.BABEL_TYPES_8_BREAKING) return;
      const match = /\.(\w+)$/.exec(key);
      if (!match) return;
      const [, parentKey] = match;
      const nonComp = {
        computed: false
      };
  
      if (parentKey === "property") {
        if ((0, _is.default)("MemberExpression", parent, nonComp)) return;
        if ((0, _is.default)("OptionalMemberExpression", parent, nonComp)) return;
      } else if (parentKey === "key") {
        if ((0, _is.default)("Property", parent, nonComp)) return;
        if ((0, _is.default)("Method", parent, nonComp)) return;
      } else if (parentKey === "exported") {
        if ((0, _is.default)("ExportSpecifier", parent)) return;
      } else if (parentKey === "imported") {
        if ((0, _is.default)("ImportSpecifier", parent, {
          imported: node
        })) return;
      } else if (parentKey === "meta") {
        if ((0, _is.default)("MetaProperty", parent, {
          meta: node
        })) return;
      }
  
      if (((0, _helperValidatorIdentifier.isKeyword)(node.name) || (0, _helperValidatorIdentifier.isReservedWord)(node.name, false)) && node.name !== "this") {
        throw new TypeError(`"${node.name}" is not a valid identifier`);
      }
    }
  
  });
  (0, _utils.default)("IfStatement", {
    visitor: ["test", "consequent", "alternate"],
    aliases: ["Statement", "Conditional"],
    fields: {
      test: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      consequent: {
        validate: (0, _utils.assertNodeType)("Statement")
      },
      alternate: {
        optional: true,
        validate: (0, _utils.assertNodeType)("Statement")
      }
    }
  });
  (0, _utils.default)("LabeledStatement", {
    visitor: ["label", "body"],
    aliases: ["Statement"],
    fields: {
      label: {
        validate: (0, _utils.assertNodeType)("Identifier")
      },
      body: {
        validate: (0, _utils.assertNodeType)("Statement")
      }
    }
  });
  (0, _utils.default)("StringLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: (0, _utils.assertValueType)("string")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  });
  (0, _utils.default)("NumericLiteral", {
    builder: ["value"],
    deprecatedAlias: "NumberLiteral",
    fields: {
      value: {
        validate: (0, _utils.assertValueType)("number")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  });
  (0, _utils.default)("NullLiteral", {
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  });
  (0, _utils.default)("BooleanLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: (0, _utils.assertValueType)("boolean")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  });
  (0, _utils.default)("RegExpLiteral", {
    builder: ["pattern", "flags"],
    deprecatedAlias: "RegexLiteral",
    aliases: ["Expression", "Pureish", "Literal"],
    fields: {
      pattern: {
        validate: (0, _utils.assertValueType)("string")
      },
      flags: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), Object.assign(function (node, key, val) {
          if (!process.env.BABEL_TYPES_8_BREAKING) return;
          const invalid = /[^gimsuy]/.exec(val);
  
          if (invalid) {
            throw new TypeError(`"${invalid[0]}" is not a valid RegExp flag`);
          }
        }, {
          type: "string"
        })),
        default: ""
      }
    }
  });
  (0, _utils.default)("LogicalExpression", {
    builder: ["operator", "left", "right"],
    visitor: ["left", "right"],
    aliases: ["Binary", "Expression"],
    fields: {
      operator: {
        validate: (0, _utils.assertOneOf)(..._constants.LOGICAL_OPERATORS)
      },
      left: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      right: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    }
  });
  (0, _utils.default)("MemberExpression", {
    builder: ["object", "property", "computed", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["optional"] : [])],
    visitor: ["object", "property"],
    aliases: ["Expression", "LVal"],
    fields: Object.assign({
      object: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      property: {
        validate: function () {
          const normal = (0, _utils.assertNodeType)("Identifier", "PrivateName");
          const computed = (0, _utils.assertNodeType)("Expression");
  
          const validator = function (node, key, val) {
            const validator = node.computed ? computed : normal;
            validator(node, key, val);
          };
  
          validator.oneOfNodeTypes = ["Expression", "Identifier", "PrivateName"];
          return validator;
        }()
      },
      computed: {
        default: false
      }
    }, !process.env.BABEL_TYPES_8_BREAKING ? {
      optional: {
        validate: (0, _utils.assertOneOf)(true, false),
        optional: true
      }
    } : {})
  });
  (0, _utils.default)("NewExpression", {
    inherits: "CallExpression"
  });
  (0, _utils.default)("Program", {
    visitor: ["directives", "body"],
    builder: ["body", "directives", "sourceType", "interpreter"],
    fields: {
      sourceFile: {
        validate: (0, _utils.assertValueType)("string")
      },
      sourceType: {
        validate: (0, _utils.assertOneOf)("script", "module"),
        default: "script"
      },
      interpreter: {
        validate: (0, _utils.assertNodeType)("InterpreterDirective"),
        default: null,
        optional: true
      },
      directives: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Directive"))),
        default: []
      },
      body: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
      }
    },
    aliases: ["Scopable", "BlockParent", "Block"]
  });
  (0, _utils.default)("ObjectExpression", {
    visitor: ["properties"],
    aliases: ["Expression"],
    fields: {
      properties: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectMethod", "ObjectProperty", "SpreadElement")))
      }
    }
  });
  (0, _utils.default)("ObjectMethod", {
    builder: ["kind", "key", "params", "body", "computed", "generator", "async"],
    fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
      kind: Object.assign({
        validate: (0, _utils.assertOneOf)("method", "get", "set")
      }, !process.env.BABEL_TYPES_8_BREAKING ? {
        default: "method"
      } : {}),
      computed: {
        default: false
      },
      key: {
        validate: function () {
          const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
          const computed = (0, _utils.assertNodeType)("Expression");
  
          const validator = function (node, key, val) {
            const validator = node.computed ? computed : normal;
            validator(node, key, val);
          };
  
          validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"];
          return validator;
        }()
      },
      decorators: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
        optional: true
      },
      body: {
        validate: (0, _utils.assertNodeType)("BlockStatement")
      }
    }),
    visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
    aliases: ["UserWhitespacable", "Function", "Scopable", "BlockParent", "FunctionParent", "Method", "ObjectMember"]
  });
  (0, _utils.default)("ObjectProperty", {
    builder: ["key", "value", "computed", "shorthand", ...(!process.env.BABEL_TYPES_8_BREAKING ? ["decorators"] : [])],
    fields: {
      computed: {
        default: false
      },
      key: {
        validate: function () {
          const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
          const computed = (0, _utils.assertNodeType)("Expression");
  
          const validator = function (node, key, val) {
            const validator = node.computed ? computed : normal;
            validator(node, key, val);
          };
  
          validator.oneOfNodeTypes = ["Expression", "Identifier", "StringLiteral", "NumericLiteral"];
          return validator;
        }()
      },
      value: {
        validate: (0, _utils.assertNodeType)("Expression", "PatternLike")
      },
      shorthand: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
          if (!process.env.BABEL_TYPES_8_BREAKING) return;
  
          if (val && node.computed) {
            throw new TypeError("Property shorthand of ObjectProperty cannot be true if computed is true");
          }
        }, {
          type: "boolean"
        }), function (node, key, val) {
          if (!process.env.BABEL_TYPES_8_BREAKING) return;
  
          if (val && !(0, _is.default)("Identifier", node.key)) {
            throw new TypeError("Property shorthand of ObjectProperty cannot be true if key is not an Identifier");
          }
        }),
        default: false
      },
      decorators: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
        optional: true
      }
    },
    visitor: ["key", "value", "decorators"],
    aliases: ["UserWhitespacable", "Property", "ObjectMember"],
    validate: function () {
      const pattern = (0, _utils.assertNodeType)("Identifier", "Pattern");
      const expression = (0, _utils.assertNodeType)("Expression");
      return function (parent, key, node) {
        if (!process.env.BABEL_TYPES_8_BREAKING) return;
        const validator = (0, _is.default)("ObjectPattern", parent) ? pattern : expression;
        validator(node, "value", node.value);
      };
    }()
  });
  (0, _utils.default)("RestElement", {
    visitor: ["argument", "typeAnnotation"],
    builder: ["argument"],
    aliases: ["LVal", "PatternLike"],
    deprecatedAlias: "RestProperty",
    fields: Object.assign({}, patternLikeCommon, {
      argument: {
        validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("LVal") : (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern", "MemberExpression")
      },
      optional: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      }
    }),
  
    validate(parent, key) {
      if (!process.env.BABEL_TYPES_8_BREAKING) return;
      const match = /(\w+)\[(\d+)\]/.exec(key);
      if (!match) throw new Error("Internal Babel error: malformed key.");
      const [, listKey, index] = match;
  
      if (parent[listKey].length > index + 1) {
        throw new TypeError(`RestElement must be last element of ${listKey}`);
      }
    }
  
  });
  (0, _utils.default)("ReturnStatement", {
    visitor: ["argument"],
    aliases: ["Statement", "Terminatorless", "CompletionStatement"],
    fields: {
      argument: {
        validate: (0, _utils.assertNodeType)("Expression"),
        optional: true
      }
    }
  });
  (0, _utils.default)("SequenceExpression", {
    visitor: ["expressions"],
    fields: {
      expressions: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression")))
      }
    },
    aliases: ["Expression"]
  });
  (0, _utils.default)("ParenthesizedExpression", {
    visitor: ["expression"],
    aliases: ["Expression", "ExpressionWrapper"],
    fields: {
      expression: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    }
  });
  (0, _utils.default)("SwitchCase", {
    visitor: ["test", "consequent"],
    fields: {
      test: {
        validate: (0, _utils.assertNodeType)("Expression"),
        optional: true
      },
      consequent: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
      }
    }
  });
  (0, _utils.default)("SwitchStatement", {
    visitor: ["discriminant", "cases"],
    aliases: ["Statement", "BlockParent", "Scopable"],
    fields: {
      discriminant: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      cases: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("SwitchCase")))
      }
    }
  });
  (0, _utils.default)("ThisExpression", {
    aliases: ["Expression"]
  });
  (0, _utils.default)("ThrowStatement", {
    visitor: ["argument"],
    aliases: ["Statement", "Terminatorless", "CompletionStatement"],
    fields: {
      argument: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    }
  });
  (0, _utils.default)("TryStatement", {
    visitor: ["block", "handler", "finalizer"],
    aliases: ["Statement"],
    fields: {
      block: {
        validate: (0, _utils.chain)((0, _utils.assertNodeType)("BlockStatement"), Object.assign(function (node) {
          if (!process.env.BABEL_TYPES_8_BREAKING) return;
  
          if (!node.handler && !node.finalizer) {
            throw new TypeError("TryStatement expects either a handler or finalizer, or both");
          }
        }, {
          oneOfNodeTypes: ["BlockStatement"]
        }))
      },
      handler: {
        optional: true,
        validate: (0, _utils.assertNodeType)("CatchClause")
      },
      finalizer: {
        optional: true,
        validate: (0, _utils.assertNodeType)("BlockStatement")
      }
    }
  });
  (0, _utils.default)("UnaryExpression", {
    builder: ["operator", "argument", "prefix"],
    fields: {
      prefix: {
        default: true
      },
      argument: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      operator: {
        validate: (0, _utils.assertOneOf)(..._constants.UNARY_OPERATORS)
      }
    },
    visitor: ["argument"],
    aliases: ["UnaryLike", "Expression"]
  });
  (0, _utils.default)("UpdateExpression", {
    builder: ["operator", "argument", "prefix"],
    fields: {
      prefix: {
        default: false
      },
      argument: {
        validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertNodeType)("Expression") : (0, _utils.assertNodeType)("Identifier", "MemberExpression")
      },
      operator: {
        validate: (0, _utils.assertOneOf)(..._constants.UPDATE_OPERATORS)
      }
    },
    visitor: ["argument"],
    aliases: ["Expression"]
  });
  (0, _utils.default)("VariableDeclaration", {
    builder: ["kind", "declarations"],
    visitor: ["declarations"],
    aliases: ["Statement", "Declaration"],
    fields: {
      declare: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      kind: {
        validate: (0, _utils.assertOneOf)("var", "let", "const")
      },
      declarations: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("VariableDeclarator")))
      }
    },
  
    validate(parent, key, node) {
      if (!process.env.BABEL_TYPES_8_BREAKING) return;
      if (!(0, _is.default)("ForXStatement", parent, {
        left: node
      })) return;
  
      if (node.declarations.length !== 1) {
        throw new TypeError(`Exactly one VariableDeclarator is required in the VariableDeclaration of a ${parent.type}`);
      }
    }
  
  });
  (0, _utils.default)("VariableDeclarator", {
    visitor: ["id", "init"],
    fields: {
      id: {
        validate: function () {
          if (!process.env.BABEL_TYPES_8_BREAKING) {
            return (0, _utils.assertNodeType)("LVal");
          }
  
          const normal = (0, _utils.assertNodeType)("Identifier", "ArrayPattern", "ObjectPattern");
          const without = (0, _utils.assertNodeType)("Identifier");
          return function (node, key, val) {
            const validator = node.init ? normal : without;
            validator(node, key, val);
          };
        }()
      },
      definite: {
        optional: true,
        validate: (0, _utils.assertValueType)("boolean")
      },
      init: {
        optional: true,
        validate: (0, _utils.assertNodeType)("Expression")
      }
    }
  });
  (0, _utils.default)("WhileStatement", {
    visitor: ["test", "body"],
    aliases: ["Statement", "BlockParent", "Loop", "While", "Scopable"],
    fields: {
      test: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      body: {
        validate: (0, _utils.assertNodeType)("Statement")
      }
    }
  });
  (0, _utils.default)("WithStatement", {
    visitor: ["object", "body"],
    aliases: ["Statement"],
    fields: {
      object: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      body: {
        validate: (0, _utils.assertNodeType)("Statement")
      }
    }
  });
  (0, _utils.default)("AssignmentPattern", {
    visitor: ["left", "right", "decorators"],
    builder: ["left", "right"],
    aliases: ["Pattern", "PatternLike", "LVal"],
    fields: Object.assign({}, patternLikeCommon, {
      left: {
        validate: (0, _utils.assertNodeType)("Identifier", "ObjectPattern", "ArrayPattern", "MemberExpression")
      },
      right: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      decorators: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
        optional: true
      }
    })
  });
  (0, _utils.default)("ArrayPattern", {
    visitor: ["elements", "typeAnnotation"],
    builder: ["elements"],
    aliases: ["Pattern", "PatternLike", "LVal"],
    fields: Object.assign({}, patternLikeCommon, {
      elements: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeOrValueType)("null", "PatternLike")))
      },
      decorators: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
        optional: true
      },
      optional: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      }
    })
  });
  (0, _utils.default)("ArrowFunctionExpression", {
    builder: ["params", "body", "async"],
    visitor: ["params", "body", "returnType", "typeParameters"],
    aliases: ["Scopable", "Function", "BlockParent", "FunctionParent", "Expression", "Pureish"],
    fields: Object.assign({}, functionCommon, functionTypeAnnotationCommon, {
      expression: {
        validate: (0, _utils.assertValueType)("boolean")
      },
      body: {
        validate: (0, _utils.assertNodeType)("BlockStatement", "Expression")
      }
    })
  });
  (0, _utils.default)("ClassBody", {
    visitor: ["body"],
    fields: {
      body: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ClassMethod", "ClassPrivateMethod", "ClassProperty", "ClassPrivateProperty", "TSDeclareMethod", "TSIndexSignature")))
      }
    }
  });
  (0, _utils.default)("ClassExpression", {
    builder: ["id", "superClass", "body", "decorators"],
    visitor: ["id", "body", "superClass", "mixins", "typeParameters", "superTypeParameters", "implements", "decorators"],
    aliases: ["Scopable", "Class", "Expression"],
    fields: {
      id: {
        validate: (0, _utils.assertNodeType)("Identifier"),
        optional: true
      },
      typeParameters: {
        validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
        optional: true
      },
      body: {
        validate: (0, _utils.assertNodeType)("ClassBody")
      },
      superClass: {
        optional: true,
        validate: (0, _utils.assertNodeType)("Expression")
      },
      superTypeParameters: {
        validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
        optional: true
      },
      implements: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
        optional: true
      },
      decorators: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
        optional: true
      },
      mixins: {
        validate: (0, _utils.assertNodeType)("InterfaceExtends"),
        optional: true
      }
    }
  });
  (0, _utils.default)("ClassDeclaration", {
    inherits: "ClassExpression",
    aliases: ["Scopable", "Class", "Statement", "Declaration"],
    fields: {
      id: {
        validate: (0, _utils.assertNodeType)("Identifier")
      },
      typeParameters: {
        validate: (0, _utils.assertNodeType)("TypeParameterDeclaration", "TSTypeParameterDeclaration", "Noop"),
        optional: true
      },
      body: {
        validate: (0, _utils.assertNodeType)("ClassBody")
      },
      superClass: {
        optional: true,
        validate: (0, _utils.assertNodeType)("Expression")
      },
      superTypeParameters: {
        validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
        optional: true
      },
      implements: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSExpressionWithTypeArguments", "ClassImplements"))),
        optional: true
      },
      decorators: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
        optional: true
      },
      mixins: {
        validate: (0, _utils.assertNodeType)("InterfaceExtends"),
        optional: true
      },
      declare: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      abstract: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      }
    },
    validate: function () {
      const identifier = (0, _utils.assertNodeType)("Identifier");
      return function (parent, key, node) {
        if (!process.env.BABEL_TYPES_8_BREAKING) return;
  
        if (!(0, _is.default)("ExportDefaultDeclaration", parent)) {
          identifier(node, "id", node.id);
        }
      };
    }()
  });
  (0, _utils.default)("ExportAllDeclaration", {
    visitor: ["source"],
    aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
    fields: {
      source: {
        validate: (0, _utils.assertNodeType)("StringLiteral")
      },
      exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value")),
      assertions: {
        optional: true,
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
      }
    }
  });
  (0, _utils.default)("ExportDefaultDeclaration", {
    visitor: ["declaration"],
    aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
    fields: {
      declaration: {
        validate: (0, _utils.assertNodeType)("FunctionDeclaration", "TSDeclareFunction", "ClassDeclaration", "Expression")
      },
      exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("value"))
    }
  });
  (0, _utils.default)("ExportNamedDeclaration", {
    visitor: ["declaration", "specifiers", "source"],
    aliases: ["Statement", "Declaration", "ModuleDeclaration", "ExportDeclaration"],
    fields: {
      declaration: {
        optional: true,
        validate: (0, _utils.chain)((0, _utils.assertNodeType)("Declaration"), Object.assign(function (node, key, val) {
          if (!process.env.BABEL_TYPES_8_BREAKING) return;
  
          if (val && node.specifiers.length) {
            throw new TypeError("Only declaration or specifiers is allowed on ExportNamedDeclaration");
          }
        }, {
          oneOfNodeTypes: ["Declaration"]
        }), function (node, key, val) {
          if (!process.env.BABEL_TYPES_8_BREAKING) return;
  
          if (val && node.source) {
            throw new TypeError("Cannot export a declaration from a source");
          }
        })
      },
      assertions: {
        optional: true,
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
      },
      specifiers: {
        default: [],
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)(function () {
          const sourced = (0, _utils.assertNodeType)("ExportSpecifier", "ExportDefaultSpecifier", "ExportNamespaceSpecifier");
          const sourceless = (0, _utils.assertNodeType)("ExportSpecifier");
          if (!process.env.BABEL_TYPES_8_BREAKING) return sourced;
          return function (node, key, val) {
            const validator = node.source ? sourced : sourceless;
            validator(node, key, val);
          };
        }()))
      },
      source: {
        validate: (0, _utils.assertNodeType)("StringLiteral"),
        optional: true
      },
      exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
    }
  });
  (0, _utils.default)("ExportSpecifier", {
    visitor: ["local", "exported"],
    aliases: ["ModuleSpecifier"],
    fields: {
      local: {
        validate: (0, _utils.assertNodeType)("Identifier")
      },
      exported: {
        validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
      }
    }
  });
  (0, _utils.default)("ForOfStatement", {
    visitor: ["left", "right", "body"],
    builder: ["left", "right", "body", "await"],
    aliases: ["Scopable", "Statement", "For", "BlockParent", "Loop", "ForXStatement"],
    fields: {
      left: {
        validate: function () {
          if (!process.env.BABEL_TYPES_8_BREAKING) {
            return (0, _utils.assertNodeType)("VariableDeclaration", "LVal");
          }
  
          const declaration = (0, _utils.assertNodeType)("VariableDeclaration");
          const lval = (0, _utils.assertNodeType)("Identifier", "MemberExpression", "ArrayPattern", "ObjectPattern");
          return function (node, key, val) {
            if ((0, _is.default)("VariableDeclaration", val)) {
              declaration(node, key, val);
            } else {
              lval(node, key, val);
            }
          };
        }()
      },
      right: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      body: {
        validate: (0, _utils.assertNodeType)("Statement")
      },
      await: {
        default: false
      }
    }
  });
  (0, _utils.default)("ImportDeclaration", {
    visitor: ["specifiers", "source"],
    aliases: ["Statement", "Declaration", "ModuleDeclaration"],
    fields: {
      assertions: {
        optional: true,
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportAttribute")))
      },
      specifiers: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ImportSpecifier", "ImportDefaultSpecifier", "ImportNamespaceSpecifier")))
      },
      source: {
        validate: (0, _utils.assertNodeType)("StringLiteral")
      },
      importKind: {
        validate: (0, _utils.assertOneOf)("type", "typeof", "value"),
        optional: true
      }
    }
  });
  (0, _utils.default)("ImportDefaultSpecifier", {
    visitor: ["local"],
    aliases: ["ModuleSpecifier"],
    fields: {
      local: {
        validate: (0, _utils.assertNodeType)("Identifier")
      }
    }
  });
  (0, _utils.default)("ImportNamespaceSpecifier", {
    visitor: ["local"],
    aliases: ["ModuleSpecifier"],
    fields: {
      local: {
        validate: (0, _utils.assertNodeType)("Identifier")
      }
    }
  });
  (0, _utils.default)("ImportSpecifier", {
    visitor: ["local", "imported"],
    aliases: ["ModuleSpecifier"],
    fields: {
      local: {
        validate: (0, _utils.assertNodeType)("Identifier")
      },
      imported: {
        validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
      },
      importKind: {
        validate: (0, _utils.assertOneOf)("type", "typeof"),
        optional: true
      }
    }
  });
  (0, _utils.default)("MetaProperty", {
    visitor: ["meta", "property"],
    aliases: ["Expression"],
    fields: {
      meta: {
        validate: (0, _utils.chain)((0, _utils.assertNodeType)("Identifier"), Object.assign(function (node, key, val) {
          if (!process.env.BABEL_TYPES_8_BREAKING) return;
          let property;
  
          switch (val.name) {
            case "function":
              property = "sent";
              break;
  
            case "new":
              property = "target";
              break;
  
            case "import":
              property = "meta";
              break;
          }
  
          if (!(0, _is.default)("Identifier", node.property, {
            name: property
          })) {
            throw new TypeError("Unrecognised MetaProperty");
          }
        }, {
          oneOfNodeTypes: ["Identifier"]
        }))
      },
      property: {
        validate: (0, _utils.assertNodeType)("Identifier")
      }
    }
  });
  const classMethodOrPropertyCommon = {
    abstract: {
      validate: (0, _utils.assertValueType)("boolean"),
      optional: true
    },
    accessibility: {
      validate: (0, _utils.assertOneOf)("public", "private", "protected"),
      optional: true
    },
    static: {
      default: false
    },
    override: {
      default: false
    },
    computed: {
      default: false
    },
    optional: {
      validate: (0, _utils.assertValueType)("boolean"),
      optional: true
    },
    key: {
      validate: (0, _utils.chain)(function () {
        const normal = (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral");
        const computed = (0, _utils.assertNodeType)("Expression");
        return function (node, key, val) {
          const validator = node.computed ? computed : normal;
          validator(node, key, val);
        };
      }(), (0, _utils.assertNodeType)("Identifier", "StringLiteral", "NumericLiteral", "Expression"))
    }
  };
  exports.classMethodOrPropertyCommon = classMethodOrPropertyCommon;
  const classMethodOrDeclareMethodCommon = Object.assign({}, functionCommon, classMethodOrPropertyCommon, {
    params: {
      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Identifier", "Pattern", "RestElement", "TSParameterProperty")))
    },
    kind: {
      validate: (0, _utils.assertOneOf)("get", "set", "method", "constructor"),
      default: "method"
    },
    access: {
      validate: (0, _utils.chain)((0, _utils.assertValueType)("string"), (0, _utils.assertOneOf)("public", "private", "protected")),
      optional: true
    },
    decorators: {
      validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
      optional: true
    }
  });
  exports.classMethodOrDeclareMethodCommon = classMethodOrDeclareMethodCommon;
  (0, _utils.default)("ClassMethod", {
    aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method"],
    builder: ["kind", "key", "params", "body", "computed", "static", "generator", "async"],
    visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
    fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, {
      body: {
        validate: (0, _utils.assertNodeType)("BlockStatement")
      }
    })
  });
  (0, _utils.default)("ObjectPattern", {
    visitor: ["properties", "typeAnnotation", "decorators"],
    builder: ["properties"],
    aliases: ["Pattern", "PatternLike", "LVal"],
    fields: Object.assign({}, patternLikeCommon, {
      properties: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("RestElement", "ObjectProperty")))
      }
    })
  });
  (0, _utils.default)("SpreadElement", {
    visitor: ["argument"],
    aliases: ["UnaryLike"],
    deprecatedAlias: "SpreadProperty",
    fields: {
      argument: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    }
  });
  (0, _utils.default)("Super", {
    aliases: ["Expression"]
  });
  (0, _utils.default)("TaggedTemplateExpression", {
    visitor: ["tag", "quasi", "typeParameters"],
    builder: ["tag", "quasi"],
    aliases: ["Expression"],
    fields: {
      tag: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      quasi: {
        validate: (0, _utils.assertNodeType)("TemplateLiteral")
      },
      typeParameters: {
        validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
        optional: true
      }
    }
  });
  (0, _utils.default)("TemplateElement", {
    builder: ["value", "tail"],
    fields: {
      value: {
        validate: (0, _utils.assertShape)({
          raw: {
            validate: (0, _utils.assertValueType)("string")
          },
          cooked: {
            validate: (0, _utils.assertValueType)("string"),
            optional: true
          }
        })
      },
      tail: {
        default: false
      }
    }
  });
  (0, _utils.default)("TemplateLiteral", {
    visitor: ["quasis", "expressions"],
    aliases: ["Expression", "Literal"],
    fields: {
      quasis: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TemplateElement")))
      },
      expressions: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "TSType")), function (node, key, val) {
          if (node.quasis.length !== val.length + 1) {
            throw new TypeError(`Number of ${node.type} quasis should be exactly one more than the number of expressions.\nExpected ${val.length + 1} quasis but got ${node.quasis.length}`);
          }
        })
      }
    }
  });
  (0, _utils.default)("YieldExpression", {
    builder: ["argument", "delegate"],
    visitor: ["argument"],
    aliases: ["Expression", "Terminatorless"],
    fields: {
      delegate: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("boolean"), Object.assign(function (node, key, val) {
          if (!process.env.BABEL_TYPES_8_BREAKING) return;
  
          if (val && !node.argument) {
            throw new TypeError("Property delegate of YieldExpression cannot be true if there is no argument");
          }
        }, {
          type: "boolean"
        })),
        default: false
      },
      argument: {
        optional: true,
        validate: (0, _utils.assertNodeType)("Expression")
      }
    }
  });
  (0, _utils.default)("AwaitExpression", {
    builder: ["argument"],
    visitor: ["argument"],
    aliases: ["Expression", "Terminatorless"],
    fields: {
      argument: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    }
  });
  (0, _utils.default)("Import", {
    aliases: ["Expression"]
  });
  (0, _utils.default)("BigIntLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: (0, _utils.assertValueType)("string")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  });
  (0, _utils.default)("ExportNamespaceSpecifier", {
    visitor: ["exported"],
    aliases: ["ModuleSpecifier"],
    fields: {
      exported: {
        validate: (0, _utils.assertNodeType)("Identifier")
      }
    }
  });
  (0, _utils.default)("OptionalMemberExpression", {
    builder: ["object", "property", "computed", "optional"],
    visitor: ["object", "property"],
    aliases: ["Expression"],
    fields: {
      object: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      property: {
        validate: function () {
          const normal = (0, _utils.assertNodeType)("Identifier");
          const computed = (0, _utils.assertNodeType)("Expression");
  
          const validator = function (node, key, val) {
            const validator = node.computed ? computed : normal;
            validator(node, key, val);
          };
  
          validator.oneOfNodeTypes = ["Expression", "Identifier"];
          return validator;
        }()
      },
      computed: {
        default: false
      },
      optional: {
        validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
      }
    }
  });
  (0, _utils.default)("OptionalCallExpression", {
    visitor: ["callee", "arguments", "typeParameters", "typeArguments"],
    builder: ["callee", "arguments", "optional"],
    aliases: ["Expression"],
    fields: {
      callee: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      arguments: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement", "JSXNamespacedName", "ArgumentPlaceholder")))
      },
      optional: {
        validate: !process.env.BABEL_TYPES_8_BREAKING ? (0, _utils.assertValueType)("boolean") : (0, _utils.chain)((0, _utils.assertValueType)("boolean"), (0, _utils.assertOptionalChainStart)())
      },
      typeArguments: {
        validate: (0, _utils.assertNodeType)("TypeParameterInstantiation"),
        optional: true
      },
      typeParameters: {
        validate: (0, _utils.assertNodeType)("TSTypeParameterInstantiation"),
        optional: true
      }
    }
  });
  (0, _utils.default)("ClassProperty", {
    visitor: ["key", "value", "typeAnnotation", "decorators"],
    builder: ["key", "value", "typeAnnotation", "decorators", "computed", "static"],
    aliases: ["Property"],
    fields: Object.assign({}, classMethodOrPropertyCommon, {
      value: {
        validate: (0, _utils.assertNodeType)("Expression"),
        optional: true
      },
      definite: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      typeAnnotation: {
        validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
        optional: true
      },
      decorators: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
        optional: true
      },
      readonly: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      declare: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      variance: {
        validate: (0, _utils.assertNodeType)("Variance"),
        optional: true
      }
    })
  });
  (0, _utils.default)("ClassPrivateProperty", {
    visitor: ["key", "value", "decorators", "typeAnnotation"],
    builder: ["key", "value", "decorators", "static"],
    aliases: ["Property", "Private"],
    fields: {
      key: {
        validate: (0, _utils.assertNodeType)("PrivateName")
      },
      value: {
        validate: (0, _utils.assertNodeType)("Expression"),
        optional: true
      },
      typeAnnotation: {
        validate: (0, _utils.assertNodeType)("TypeAnnotation", "TSTypeAnnotation", "Noop"),
        optional: true
      },
      decorators: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
        optional: true
      },
      readonly: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      definite: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      variance: {
        validate: (0, _utils.assertNodeType)("Variance"),
        optional: true
      }
    }
  });
  (0, _utils.default)("ClassPrivateMethod", {
    builder: ["kind", "key", "params", "body", "static"],
    visitor: ["key", "params", "body", "decorators", "returnType", "typeParameters"],
    aliases: ["Function", "Scopable", "BlockParent", "FunctionParent", "Method", "Private"],
    fields: Object.assign({}, classMethodOrDeclareMethodCommon, functionTypeAnnotationCommon, {
      key: {
        validate: (0, _utils.assertNodeType)("PrivateName")
      },
      body: {
        validate: (0, _utils.assertNodeType)("BlockStatement")
      }
    })
  });
  (0, _utils.default)("PrivateName", {
    visitor: ["id"],
    aliases: ["Private"],
    fields: {
      id: {
        validate: (0, _utils.assertNodeType)("Identifier")
      }
    }
  });
  }).call(this,require('_process'))
  },{"../constants":53,"../validators/is":91,"../validators/isValidIdentifier":104,"./utils":73,"@babel/helper-validator-identifier":28,"_process":115}],66:[function(require,module,exports){
  (function (process){
  "use strict";
  
  var _utils = require("./utils");
  
  (0, _utils.default)("ArgumentPlaceholder", {});
  (0, _utils.default)("BindExpression", {
    visitor: ["object", "callee"],
    aliases: ["Expression"],
    fields: !process.env.BABEL_TYPES_8_BREAKING ? {
      object: {
        validate: Object.assign(() => {}, {
          oneOfNodeTypes: ["Expression"]
        })
      },
      callee: {
        validate: Object.assign(() => {}, {
          oneOfNodeTypes: ["Expression"]
        })
      }
    } : {
      object: {
        validate: (0, _utils.assertNodeType)("Expression")
      },
      callee: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    }
  });
  (0, _utils.default)("ImportAttribute", {
    visitor: ["key", "value"],
    fields: {
      key: {
        validate: (0, _utils.assertNodeType)("Identifier", "StringLiteral")
      },
      value: {
        validate: (0, _utils.assertNodeType)("StringLiteral")
      }
    }
  });
  (0, _utils.default)("Decorator", {
    visitor: ["expression"],
    fields: {
      expression: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    }
  });
  (0, _utils.default)("DoExpression", {
    visitor: ["body"],
    builder: ["body", "async"],
    aliases: ["Expression"],
    fields: {
      body: {
        validate: (0, _utils.assertNodeType)("BlockStatement")
      },
      async: {
        validate: (0, _utils.assertValueType)("boolean"),
        default: false
      }
    }
  });
  (0, _utils.default)("ExportDefaultSpecifier", {
    visitor: ["exported"],
    aliases: ["ModuleSpecifier"],
    fields: {
      exported: {
        validate: (0, _utils.assertNodeType)("Identifier")
      }
    }
  });
  (0, _utils.default)("RecordExpression", {
    visitor: ["properties"],
    aliases: ["Expression"],
    fields: {
      properties: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("ObjectProperty", "SpreadElement")))
      }
    }
  });
  (0, _utils.default)("TupleExpression", {
    fields: {
      elements: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Expression", "SpreadElement"))),
        default: []
      }
    },
    visitor: ["elements"],
    aliases: ["Expression"]
  });
  (0, _utils.default)("DecimalLiteral", {
    builder: ["value"],
    fields: {
      value: {
        validate: (0, _utils.assertValueType)("string")
      }
    },
    aliases: ["Expression", "Pureish", "Literal", "Immutable"]
  });
  (0, _utils.default)("StaticBlock", {
    visitor: ["body"],
    fields: {
      body: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Statement")))
      }
    },
    aliases: ["Scopable", "BlockParent"]
  });
  (0, _utils.default)("ModuleExpression", {
    visitor: ["body"],
    fields: {
      body: {
        validate: (0, _utils.assertNodeType)("Program")
      }
    },
    aliases: ["Expression"]
  });
  (0, _utils.default)("TopicReference", {
    aliases: ["Expression"]
  });
  (0, _utils.default)("PipelineTopicExpression", {
    builder: ["expression"],
    visitor: ["expression"],
    fields: {
      expression: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    },
    aliases: ["Expression"]
  });
  (0, _utils.default)("PipelineBareFunction", {
    builder: ["callee"],
    visitor: ["callee"],
    fields: {
      callee: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    },
    aliases: ["Expression"]
  });
  (0, _utils.default)("PipelinePrimaryTopicReference", {
    aliases: ["Expression"]
  });
  }).call(this,require('_process'))
  },{"./utils":73,"_process":115}],67:[function(require,module,exports){
  "use strict";
  
  var _utils = require("./utils");
  
  const defineInterfaceishType = (name, typeParameterType = "TypeParameterDeclaration") => {
    (0, _utils.default)(name, {
      builder: ["id", "typeParameters", "extends", "body"],
      visitor: ["id", "typeParameters", "extends", "mixins", "implements", "body"],
      aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
      fields: {
        id: (0, _utils.validateType)("Identifier"),
        typeParameters: (0, _utils.validateOptionalType)(typeParameterType),
        extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
        mixins: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
        implements: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ClassImplements")),
        body: (0, _utils.validateType)("ObjectTypeAnnotation")
      }
    });
  };
  
  (0, _utils.default)("AnyTypeAnnotation", {
    aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
  });
  (0, _utils.default)("ArrayTypeAnnotation", {
    visitor: ["elementType"],
    aliases: ["Flow", "FlowType"],
    fields: {
      elementType: (0, _utils.validateType)("FlowType")
    }
  });
  (0, _utils.default)("BooleanTypeAnnotation", {
    aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
  });
  (0, _utils.default)("BooleanLiteralTypeAnnotation", {
    builder: ["value"],
    aliases: ["Flow", "FlowType"],
    fields: {
      value: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
    }
  });
  (0, _utils.default)("NullLiteralTypeAnnotation", {
    aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
  });
  (0, _utils.default)("ClassImplements", {
    visitor: ["id", "typeParameters"],
    aliases: ["Flow"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
    }
  });
  defineInterfaceishType("DeclareClass");
  (0, _utils.default)("DeclareFunction", {
    visitor: ["id"],
    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      predicate: (0, _utils.validateOptionalType)("DeclaredPredicate")
    }
  });
  defineInterfaceishType("DeclareInterface");
  (0, _utils.default)("DeclareModule", {
    builder: ["id", "body", "kind"],
    visitor: ["id", "body"],
    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
      body: (0, _utils.validateType)("BlockStatement"),
      kind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("CommonJS", "ES"))
    }
  });
  (0, _utils.default)("DeclareModuleExports", {
    visitor: ["typeAnnotation"],
    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
    fields: {
      typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
    }
  });
  (0, _utils.default)("DeclareTypeAlias", {
    visitor: ["id", "typeParameters", "right"],
    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
      right: (0, _utils.validateType)("FlowType")
    }
  });
  (0, _utils.default)("DeclareOpaqueType", {
    visitor: ["id", "typeParameters", "supertype"],
    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
      supertype: (0, _utils.validateOptionalType)("FlowType"),
      impltype: (0, _utils.validateOptionalType)("FlowType")
    }
  });
  (0, _utils.default)("DeclareVariable", {
    visitor: ["id"],
    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: (0, _utils.validateType)("Identifier")
    }
  });
  (0, _utils.default)("DeclareExportDeclaration", {
    visitor: ["declaration", "specifiers", "source"],
    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
    fields: {
      declaration: (0, _utils.validateOptionalType)("Flow"),
      specifiers: (0, _utils.validateOptional)((0, _utils.arrayOfType)(["ExportSpecifier", "ExportNamespaceSpecifier"])),
      source: (0, _utils.validateOptionalType)("StringLiteral"),
      default: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
    }
  });
  (0, _utils.default)("DeclareExportAllDeclaration", {
    visitor: ["source"],
    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
    fields: {
      source: (0, _utils.validateType)("StringLiteral"),
      exportKind: (0, _utils.validateOptional)((0, _utils.assertOneOf)("type", "value"))
    }
  });
  (0, _utils.default)("DeclaredPredicate", {
    visitor: ["value"],
    aliases: ["Flow", "FlowPredicate"],
    fields: {
      value: (0, _utils.validateType)("Flow")
    }
  });
  (0, _utils.default)("ExistsTypeAnnotation", {
    aliases: ["Flow", "FlowType"]
  });
  (0, _utils.default)("FunctionTypeAnnotation", {
    visitor: ["typeParameters", "params", "rest", "returnType"],
    aliases: ["Flow", "FlowType"],
    fields: {
      typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
      params: (0, _utils.validate)((0, _utils.arrayOfType)("FunctionTypeParam")),
      rest: (0, _utils.validateOptionalType)("FunctionTypeParam"),
      this: (0, _utils.validateOptionalType)("FunctionTypeParam"),
      returnType: (0, _utils.validateType)("FlowType")
    }
  });
  (0, _utils.default)("FunctionTypeParam", {
    visitor: ["name", "typeAnnotation"],
    aliases: ["Flow"],
    fields: {
      name: (0, _utils.validateOptionalType)("Identifier"),
      typeAnnotation: (0, _utils.validateType)("FlowType"),
      optional: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
    }
  });
  (0, _utils.default)("GenericTypeAnnotation", {
    visitor: ["id", "typeParameters"],
    aliases: ["Flow", "FlowType"],
    fields: {
      id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
      typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
    }
  });
  (0, _utils.default)("InferredPredicate", {
    aliases: ["Flow", "FlowPredicate"]
  });
  (0, _utils.default)("InterfaceExtends", {
    visitor: ["id", "typeParameters"],
    aliases: ["Flow"],
    fields: {
      id: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"]),
      typeParameters: (0, _utils.validateOptionalType)("TypeParameterInstantiation")
    }
  });
  defineInterfaceishType("InterfaceDeclaration");
  (0, _utils.default)("InterfaceTypeAnnotation", {
    visitor: ["extends", "body"],
    aliases: ["Flow", "FlowType"],
    fields: {
      extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("InterfaceExtends")),
      body: (0, _utils.validateType)("ObjectTypeAnnotation")
    }
  });
  (0, _utils.default)("IntersectionTypeAnnotation", {
    visitor: ["types"],
    aliases: ["Flow", "FlowType"],
    fields: {
      types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
    }
  });
  (0, _utils.default)("MixedTypeAnnotation", {
    aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
  });
  (0, _utils.default)("EmptyTypeAnnotation", {
    aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
  });
  (0, _utils.default)("NullableTypeAnnotation", {
    visitor: ["typeAnnotation"],
    aliases: ["Flow", "FlowType"],
    fields: {
      typeAnnotation: (0, _utils.validateType)("FlowType")
    }
  });
  (0, _utils.default)("NumberLiteralTypeAnnotation", {
    builder: ["value"],
    aliases: ["Flow", "FlowType"],
    fields: {
      value: (0, _utils.validate)((0, _utils.assertValueType)("number"))
    }
  });
  (0, _utils.default)("NumberTypeAnnotation", {
    aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
  });
  (0, _utils.default)("ObjectTypeAnnotation", {
    visitor: ["properties", "indexers", "callProperties", "internalSlots"],
    aliases: ["Flow", "FlowType"],
    builder: ["properties", "indexers", "callProperties", "internalSlots", "exact"],
    fields: {
      properties: (0, _utils.validate)((0, _utils.arrayOfType)(["ObjectTypeProperty", "ObjectTypeSpreadProperty"])),
      indexers: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeIndexer")),
      callProperties: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeCallProperty")),
      internalSlots: (0, _utils.validateOptional)((0, _utils.arrayOfType)("ObjectTypeInternalSlot")),
      exact: {
        validate: (0, _utils.assertValueType)("boolean"),
        default: false
      },
      inexact: (0, _utils.validateOptional)((0, _utils.assertValueType)("boolean"))
    }
  });
  (0, _utils.default)("ObjectTypeInternalSlot", {
    visitor: ["id", "value", "optional", "static", "method"],
    aliases: ["Flow", "UserWhitespacable"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      value: (0, _utils.validateType)("FlowType"),
      optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
      static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
      method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
    }
  });
  (0, _utils.default)("ObjectTypeCallProperty", {
    visitor: ["value"],
    aliases: ["Flow", "UserWhitespacable"],
    fields: {
      value: (0, _utils.validateType)("FlowType"),
      static: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
    }
  });
  (0, _utils.default)("ObjectTypeIndexer", {
    visitor: ["id", "key", "value", "variance"],
    aliases: ["Flow", "UserWhitespacable"],
    fields: {
      id: (0, _utils.validateOptionalType)("Identifier"),
      key: (0, _utils.validateType)("FlowType"),
      value: (0, _utils.validateType)("FlowType"),
      static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
      variance: (0, _utils.validateOptionalType)("Variance")
    }
  });
  (0, _utils.default)("ObjectTypeProperty", {
    visitor: ["key", "value", "variance"],
    aliases: ["Flow", "UserWhitespacable"],
    fields: {
      key: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
      value: (0, _utils.validateType)("FlowType"),
      kind: (0, _utils.validate)((0, _utils.assertOneOf)("init", "get", "set")),
      static: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
      proto: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
      optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
      variance: (0, _utils.validateOptionalType)("Variance"),
      method: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
    }
  });
  (0, _utils.default)("ObjectTypeSpreadProperty", {
    visitor: ["argument"],
    aliases: ["Flow", "UserWhitespacable"],
    fields: {
      argument: (0, _utils.validateType)("FlowType")
    }
  });
  (0, _utils.default)("OpaqueType", {
    visitor: ["id", "typeParameters", "supertype", "impltype"],
    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
      supertype: (0, _utils.validateOptionalType)("FlowType"),
      impltype: (0, _utils.validateType)("FlowType")
    }
  });
  (0, _utils.default)("QualifiedTypeIdentifier", {
    visitor: ["id", "qualification"],
    aliases: ["Flow"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      qualification: (0, _utils.validateType)(["Identifier", "QualifiedTypeIdentifier"])
    }
  });
  (0, _utils.default)("StringLiteralTypeAnnotation", {
    builder: ["value"],
    aliases: ["Flow", "FlowType"],
    fields: {
      value: (0, _utils.validate)((0, _utils.assertValueType)("string"))
    }
  });
  (0, _utils.default)("StringTypeAnnotation", {
    aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
  });
  (0, _utils.default)("SymbolTypeAnnotation", {
    aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
  });
  (0, _utils.default)("ThisTypeAnnotation", {
    aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
  });
  (0, _utils.default)("TupleTypeAnnotation", {
    visitor: ["types"],
    aliases: ["Flow", "FlowType"],
    fields: {
      types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
    }
  });
  (0, _utils.default)("TypeofTypeAnnotation", {
    visitor: ["argument"],
    aliases: ["Flow", "FlowType"],
    fields: {
      argument: (0, _utils.validateType)("FlowType")
    }
  });
  (0, _utils.default)("TypeAlias", {
    visitor: ["id", "typeParameters", "right"],
    aliases: ["Flow", "FlowDeclaration", "Statement", "Declaration"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      typeParameters: (0, _utils.validateOptionalType)("TypeParameterDeclaration"),
      right: (0, _utils.validateType)("FlowType")
    }
  });
  (0, _utils.default)("TypeAnnotation", {
    aliases: ["Flow"],
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: (0, _utils.validateType)("FlowType")
    }
  });
  (0, _utils.default)("TypeCastExpression", {
    visitor: ["expression", "typeAnnotation"],
    aliases: ["Flow", "ExpressionWrapper", "Expression"],
    fields: {
      expression: (0, _utils.validateType)("Expression"),
      typeAnnotation: (0, _utils.validateType)("TypeAnnotation")
    }
  });
  (0, _utils.default)("TypeParameter", {
    aliases: ["Flow"],
    visitor: ["bound", "default", "variance"],
    fields: {
      name: (0, _utils.validate)((0, _utils.assertValueType)("string")),
      bound: (0, _utils.validateOptionalType)("TypeAnnotation"),
      default: (0, _utils.validateOptionalType)("FlowType"),
      variance: (0, _utils.validateOptionalType)("Variance")
    }
  });
  (0, _utils.default)("TypeParameterDeclaration", {
    aliases: ["Flow"],
    visitor: ["params"],
    fields: {
      params: (0, _utils.validate)((0, _utils.arrayOfType)("TypeParameter"))
    }
  });
  (0, _utils.default)("TypeParameterInstantiation", {
    aliases: ["Flow"],
    visitor: ["params"],
    fields: {
      params: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
    }
  });
  (0, _utils.default)("UnionTypeAnnotation", {
    visitor: ["types"],
    aliases: ["Flow", "FlowType"],
    fields: {
      types: (0, _utils.validate)((0, _utils.arrayOfType)("FlowType"))
    }
  });
  (0, _utils.default)("Variance", {
    aliases: ["Flow"],
    builder: ["kind"],
    fields: {
      kind: (0, _utils.validate)((0, _utils.assertOneOf)("minus", "plus"))
    }
  });
  (0, _utils.default)("VoidTypeAnnotation", {
    aliases: ["Flow", "FlowType", "FlowBaseAnnotation"]
  });
  (0, _utils.default)("EnumDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "body"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      body: (0, _utils.validateType)(["EnumBooleanBody", "EnumNumberBody", "EnumStringBody", "EnumSymbolBody"])
    }
  });
  (0, _utils.default)("EnumBooleanBody", {
    aliases: ["EnumBody"],
    visitor: ["members"],
    fields: {
      explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
      members: (0, _utils.validateArrayOfType)("EnumBooleanMember"),
      hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
    }
  });
  (0, _utils.default)("EnumNumberBody", {
    aliases: ["EnumBody"],
    visitor: ["members"],
    fields: {
      explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
      members: (0, _utils.validateArrayOfType)("EnumNumberMember"),
      hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
    }
  });
  (0, _utils.default)("EnumStringBody", {
    aliases: ["EnumBody"],
    visitor: ["members"],
    fields: {
      explicitType: (0, _utils.validate)((0, _utils.assertValueType)("boolean")),
      members: (0, _utils.validateArrayOfType)(["EnumStringMember", "EnumDefaultedMember"]),
      hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
    }
  });
  (0, _utils.default)("EnumSymbolBody", {
    aliases: ["EnumBody"],
    visitor: ["members"],
    fields: {
      members: (0, _utils.validateArrayOfType)("EnumDefaultedMember"),
      hasUnknownMembers: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
    }
  });
  (0, _utils.default)("EnumBooleanMember", {
    aliases: ["EnumMember"],
    visitor: ["id"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      init: (0, _utils.validateType)("BooleanLiteral")
    }
  });
  (0, _utils.default)("EnumNumberMember", {
    aliases: ["EnumMember"],
    visitor: ["id", "init"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      init: (0, _utils.validateType)("NumericLiteral")
    }
  });
  (0, _utils.default)("EnumStringMember", {
    aliases: ["EnumMember"],
    visitor: ["id", "init"],
    fields: {
      id: (0, _utils.validateType)("Identifier"),
      init: (0, _utils.validateType)("StringLiteral")
    }
  });
  (0, _utils.default)("EnumDefaultedMember", {
    aliases: ["EnumMember"],
    visitor: ["id"],
    fields: {
      id: (0, _utils.validateType)("Identifier")
    }
  });
  (0, _utils.default)("IndexedAccessType", {
    visitor: ["objectType", "indexType"],
    aliases: ["Flow", "FlowType"],
    fields: {
      objectType: (0, _utils.validateType)("FlowType"),
      indexType: (0, _utils.validateType)("FlowType")
    }
  });
  (0, _utils.default)("OptionalIndexedAccessType", {
    visitor: ["objectType", "indexType"],
    aliases: ["Flow", "FlowType"],
    fields: {
      objectType: (0, _utils.validateType)("FlowType"),
      indexType: (0, _utils.validateType)("FlowType"),
      optional: (0, _utils.validate)((0, _utils.assertValueType)("boolean"))
    }
  });
  },{"./utils":73}],68:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  Object.defineProperty(exports, "VISITOR_KEYS", {
    enumerable: true,
    get: function () {
      return _utils.VISITOR_KEYS;
    }
  });
  Object.defineProperty(exports, "ALIAS_KEYS", {
    enumerable: true,
    get: function () {
      return _utils.ALIAS_KEYS;
    }
  });
  Object.defineProperty(exports, "FLIPPED_ALIAS_KEYS", {
    enumerable: true,
    get: function () {
      return _utils.FLIPPED_ALIAS_KEYS;
    }
  });
  Object.defineProperty(exports, "NODE_FIELDS", {
    enumerable: true,
    get: function () {
      return _utils.NODE_FIELDS;
    }
  });
  Object.defineProperty(exports, "BUILDER_KEYS", {
    enumerable: true,
    get: function () {
      return _utils.BUILDER_KEYS;
    }
  });
  Object.defineProperty(exports, "DEPRECATED_KEYS", {
    enumerable: true,
    get: function () {
      return _utils.DEPRECATED_KEYS;
    }
  });
  Object.defineProperty(exports, "NODE_PARENT_VALIDATIONS", {
    enumerable: true,
    get: function () {
      return _utils.NODE_PARENT_VALIDATIONS;
    }
  });
  Object.defineProperty(exports, "PLACEHOLDERS", {
    enumerable: true,
    get: function () {
      return _placeholders.PLACEHOLDERS;
    }
  });
  Object.defineProperty(exports, "PLACEHOLDERS_ALIAS", {
    enumerable: true,
    get: function () {
      return _placeholders.PLACEHOLDERS_ALIAS;
    }
  });
  Object.defineProperty(exports, "PLACEHOLDERS_FLIPPED_ALIAS", {
    enumerable: true,
    get: function () {
      return _placeholders.PLACEHOLDERS_FLIPPED_ALIAS;
    }
  });
  exports.TYPES = void 0;
  
  var _toFastProperties = require("to-fast-properties");
  
  require("./core");
  
  require("./flow");
  
  require("./jsx");
  
  require("./misc");
  
  require("./experimental");
  
  require("./typescript");
  
  var _utils = require("./utils");
  
  var _placeholders = require("./placeholders");
  
  _toFastProperties(_utils.VISITOR_KEYS);
  
  _toFastProperties(_utils.ALIAS_KEYS);
  
  _toFastProperties(_utils.FLIPPED_ALIAS_KEYS);
  
  _toFastProperties(_utils.NODE_FIELDS);
  
  _toFastProperties(_utils.BUILDER_KEYS);
  
  _toFastProperties(_utils.DEPRECATED_KEYS);
  
  _toFastProperties(_placeholders.PLACEHOLDERS_ALIAS);
  
  _toFastProperties(_placeholders.PLACEHOLDERS_FLIPPED_ALIAS);
  
  const TYPES = Object.keys(_utils.VISITOR_KEYS).concat(Object.keys(_utils.FLIPPED_ALIAS_KEYS)).concat(Object.keys(_utils.DEPRECATED_KEYS));
  exports.TYPES = TYPES;
  },{"./core":65,"./experimental":66,"./flow":67,"./jsx":69,"./misc":70,"./placeholders":71,"./typescript":72,"./utils":73,"to-fast-properties":119}],69:[function(require,module,exports){
  "use strict";
  
  var _utils = require("./utils");
  
  (0, _utils.default)("JSXAttribute", {
    visitor: ["name", "value"],
    aliases: ["JSX", "Immutable"],
    fields: {
      name: {
        validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXNamespacedName")
      },
      value: {
        optional: true,
        validate: (0, _utils.assertNodeType)("JSXElement", "JSXFragment", "StringLiteral", "JSXExpressionContainer")
      }
    }
  });
  (0, _utils.default)("JSXClosingElement", {
    visitor: ["name"],
    aliases: ["JSX", "Immutable"],
    fields: {
      name: {
        validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
      }
    }
  });
  (0, _utils.default)("JSXElement", {
    builder: ["openingElement", "closingElement", "children", "selfClosing"],
    visitor: ["openingElement", "children", "closingElement"],
    aliases: ["JSX", "Immutable", "Expression"],
    fields: {
      openingElement: {
        validate: (0, _utils.assertNodeType)("JSXOpeningElement")
      },
      closingElement: {
        optional: true,
        validate: (0, _utils.assertNodeType)("JSXClosingElement")
      },
      children: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
      },
      selfClosing: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      }
    }
  });
  (0, _utils.default)("JSXEmptyExpression", {
    aliases: ["JSX"]
  });
  (0, _utils.default)("JSXExpressionContainer", {
    visitor: ["expression"],
    aliases: ["JSX", "Immutable"],
    fields: {
      expression: {
        validate: (0, _utils.assertNodeType)("Expression", "JSXEmptyExpression")
      }
    }
  });
  (0, _utils.default)("JSXSpreadChild", {
    visitor: ["expression"],
    aliases: ["JSX", "Immutable"],
    fields: {
      expression: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    }
  });
  (0, _utils.default)("JSXIdentifier", {
    builder: ["name"],
    aliases: ["JSX"],
    fields: {
      name: {
        validate: (0, _utils.assertValueType)("string")
      }
    }
  });
  (0, _utils.default)("JSXMemberExpression", {
    visitor: ["object", "property"],
    aliases: ["JSX"],
    fields: {
      object: {
        validate: (0, _utils.assertNodeType)("JSXMemberExpression", "JSXIdentifier")
      },
      property: {
        validate: (0, _utils.assertNodeType)("JSXIdentifier")
      }
    }
  });
  (0, _utils.default)("JSXNamespacedName", {
    visitor: ["namespace", "name"],
    aliases: ["JSX"],
    fields: {
      namespace: {
        validate: (0, _utils.assertNodeType)("JSXIdentifier")
      },
      name: {
        validate: (0, _utils.assertNodeType)("JSXIdentifier")
      }
    }
  });
  (0, _utils.default)("JSXOpeningElement", {
    builder: ["name", "attributes", "selfClosing"],
    visitor: ["name", "attributes"],
    aliases: ["JSX", "Immutable"],
    fields: {
      name: {
        validate: (0, _utils.assertNodeType)("JSXIdentifier", "JSXMemberExpression", "JSXNamespacedName")
      },
      selfClosing: {
        default: false
      },
      attributes: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXAttribute", "JSXSpreadAttribute")))
      },
      typeParameters: {
        validate: (0, _utils.assertNodeType)("TypeParameterInstantiation", "TSTypeParameterInstantiation"),
        optional: true
      }
    }
  });
  (0, _utils.default)("JSXSpreadAttribute", {
    visitor: ["argument"],
    aliases: ["JSX"],
    fields: {
      argument: {
        validate: (0, _utils.assertNodeType)("Expression")
      }
    }
  });
  (0, _utils.default)("JSXText", {
    aliases: ["JSX", "Immutable"],
    builder: ["value"],
    fields: {
      value: {
        validate: (0, _utils.assertValueType)("string")
      }
    }
  });
  (0, _utils.default)("JSXFragment", {
    builder: ["openingFragment", "closingFragment", "children"],
    visitor: ["openingFragment", "children", "closingFragment"],
    aliases: ["JSX", "Immutable", "Expression"],
    fields: {
      openingFragment: {
        validate: (0, _utils.assertNodeType)("JSXOpeningFragment")
      },
      closingFragment: {
        validate: (0, _utils.assertNodeType)("JSXClosingFragment")
      },
      children: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("JSXText", "JSXExpressionContainer", "JSXSpreadChild", "JSXElement", "JSXFragment")))
      }
    }
  });
  (0, _utils.default)("JSXOpeningFragment", {
    aliases: ["JSX", "Immutable"]
  });
  (0, _utils.default)("JSXClosingFragment", {
    aliases: ["JSX", "Immutable"]
  });
  },{"./utils":73}],70:[function(require,module,exports){
  "use strict";
  
  var _utils = require("./utils");
  
  var _placeholders = require("./placeholders");
  
  {
    (0, _utils.default)("Noop", {
      visitor: []
    });
  }
  (0, _utils.default)("Placeholder", {
    visitor: [],
    builder: ["expectedNode", "name"],
    fields: {
      name: {
        validate: (0, _utils.assertNodeType)("Identifier")
      },
      expectedNode: {
        validate: (0, _utils.assertOneOf)(..._placeholders.PLACEHOLDERS)
      }
    }
  });
  (0, _utils.default)("V8IntrinsicIdentifier", {
    builder: ["name"],
    fields: {
      name: {
        validate: (0, _utils.assertValueType)("string")
      }
    }
  });
  },{"./placeholders":71,"./utils":73}],71:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.PLACEHOLDERS_FLIPPED_ALIAS = exports.PLACEHOLDERS_ALIAS = exports.PLACEHOLDERS = void 0;
  
  var _utils = require("./utils");
  
  const PLACEHOLDERS = ["Identifier", "StringLiteral", "Expression", "Statement", "Declaration", "BlockStatement", "ClassBody", "Pattern"];
  exports.PLACEHOLDERS = PLACEHOLDERS;
  const PLACEHOLDERS_ALIAS = {
    Declaration: ["Statement"],
    Pattern: ["PatternLike", "LVal"]
  };
  exports.PLACEHOLDERS_ALIAS = PLACEHOLDERS_ALIAS;
  
  for (const type of PLACEHOLDERS) {
    const alias = _utils.ALIAS_KEYS[type];
    if (alias != null && alias.length) PLACEHOLDERS_ALIAS[type] = alias;
  }
  
  const PLACEHOLDERS_FLIPPED_ALIAS = {};
  exports.PLACEHOLDERS_FLIPPED_ALIAS = PLACEHOLDERS_FLIPPED_ALIAS;
  Object.keys(PLACEHOLDERS_ALIAS).forEach(type => {
    PLACEHOLDERS_ALIAS[type].forEach(alias => {
      if (!Object.hasOwnProperty.call(PLACEHOLDERS_FLIPPED_ALIAS, alias)) {
        PLACEHOLDERS_FLIPPED_ALIAS[alias] = [];
      }
  
      PLACEHOLDERS_FLIPPED_ALIAS[alias].push(type);
    });
  });
  },{"./utils":73}],72:[function(require,module,exports){
  "use strict";
  
  var _utils = require("./utils");
  
  var _core = require("./core");
  
  var _is = require("../validators/is");
  
  const bool = (0, _utils.assertValueType)("boolean");
  const tSFunctionTypeAnnotationCommon = {
    returnType: {
      validate: (0, _utils.assertNodeType)("TSTypeAnnotation", "Noop"),
      optional: true
    },
    typeParameters: {
      validate: (0, _utils.assertNodeType)("TSTypeParameterDeclaration", "Noop"),
      optional: true
    }
  };
  (0, _utils.default)("TSParameterProperty", {
    aliases: ["LVal"],
    visitor: ["parameter"],
    fields: {
      accessibility: {
        validate: (0, _utils.assertOneOf)("public", "private", "protected"),
        optional: true
      },
      readonly: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      parameter: {
        validate: (0, _utils.assertNodeType)("Identifier", "AssignmentPattern")
      },
      override: {
        validate: (0, _utils.assertValueType)("boolean"),
        optional: true
      },
      decorators: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("Decorator"))),
        optional: true
      }
    }
  });
  (0, _utils.default)("TSDeclareFunction", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "typeParameters", "params", "returnType"],
    fields: Object.assign({}, _core.functionDeclarationCommon, tSFunctionTypeAnnotationCommon)
  });
  (0, _utils.default)("TSDeclareMethod", {
    visitor: ["decorators", "key", "typeParameters", "params", "returnType"],
    fields: Object.assign({}, _core.classMethodOrDeclareMethodCommon, tSFunctionTypeAnnotationCommon)
  });
  (0, _utils.default)("TSQualifiedName", {
    aliases: ["TSEntityName"],
    visitor: ["left", "right"],
    fields: {
      left: (0, _utils.validateType)("TSEntityName"),
      right: (0, _utils.validateType)("Identifier")
    }
  });
  const signatureDeclarationCommon = {
    typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
    parameters: (0, _utils.validateArrayOfType)(["Identifier", "RestElement"]),
    typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
  };
  const callConstructSignatureDeclaration = {
    aliases: ["TSTypeElement"],
    visitor: ["typeParameters", "parameters", "typeAnnotation"],
    fields: signatureDeclarationCommon
  };
  (0, _utils.default)("TSCallSignatureDeclaration", callConstructSignatureDeclaration);
  (0, _utils.default)("TSConstructSignatureDeclaration", callConstructSignatureDeclaration);
  const namedTypeElementCommon = {
    key: (0, _utils.validateType)("Expression"),
    computed: (0, _utils.validate)(bool),
    optional: (0, _utils.validateOptional)(bool)
  };
  (0, _utils.default)("TSPropertySignature", {
    aliases: ["TSTypeElement"],
    visitor: ["key", "typeAnnotation", "initializer"],
    fields: Object.assign({}, namedTypeElementCommon, {
      readonly: (0, _utils.validateOptional)(bool),
      typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
      initializer: (0, _utils.validateOptionalType)("Expression"),
      kind: {
        validate: (0, _utils.assertOneOf)("get", "set")
      }
    })
  });
  (0, _utils.default)("TSMethodSignature", {
    aliases: ["TSTypeElement"],
    visitor: ["key", "typeParameters", "parameters", "typeAnnotation"],
    fields: Object.assign({}, signatureDeclarationCommon, namedTypeElementCommon, {
      kind: {
        validate: (0, _utils.assertOneOf)("method", "get", "set")
      }
    })
  });
  (0, _utils.default)("TSIndexSignature", {
    aliases: ["TSTypeElement"],
    visitor: ["parameters", "typeAnnotation"],
    fields: {
      readonly: (0, _utils.validateOptional)(bool),
      static: (0, _utils.validateOptional)(bool),
      parameters: (0, _utils.validateArrayOfType)("Identifier"),
      typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation")
    }
  });
  const tsKeywordTypes = ["TSAnyKeyword", "TSBooleanKeyword", "TSBigIntKeyword", "TSIntrinsicKeyword", "TSNeverKeyword", "TSNullKeyword", "TSNumberKeyword", "TSObjectKeyword", "TSStringKeyword", "TSSymbolKeyword", "TSUndefinedKeyword", "TSUnknownKeyword", "TSVoidKeyword"];
  
  for (const type of tsKeywordTypes) {
    (0, _utils.default)(type, {
      aliases: ["TSType", "TSBaseType"],
      visitor: [],
      fields: {}
    });
  }
  
  (0, _utils.default)("TSThisType", {
    aliases: ["TSType", "TSBaseType"],
    visitor: [],
    fields: {}
  });
  const fnOrCtrBase = {
    aliases: ["TSType"],
    visitor: ["typeParameters", "parameters", "typeAnnotation"]
  };
  (0, _utils.default)("TSFunctionType", Object.assign({}, fnOrCtrBase, {
    fields: signatureDeclarationCommon
  }));
  (0, _utils.default)("TSConstructorType", Object.assign({}, fnOrCtrBase, {
    fields: Object.assign({}, signatureDeclarationCommon, {
      abstract: (0, _utils.validateOptional)(bool)
    })
  }));
  (0, _utils.default)("TSTypeReference", {
    aliases: ["TSType"],
    visitor: ["typeName", "typeParameters"],
    fields: {
      typeName: (0, _utils.validateType)("TSEntityName"),
      typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
    }
  });
  (0, _utils.default)("TSTypePredicate", {
    aliases: ["TSType"],
    visitor: ["parameterName", "typeAnnotation"],
    builder: ["parameterName", "typeAnnotation", "asserts"],
    fields: {
      parameterName: (0, _utils.validateType)(["Identifier", "TSThisType"]),
      typeAnnotation: (0, _utils.validateOptionalType)("TSTypeAnnotation"),
      asserts: (0, _utils.validateOptional)(bool)
    }
  });
  (0, _utils.default)("TSTypeQuery", {
    aliases: ["TSType"],
    visitor: ["exprName"],
    fields: {
      exprName: (0, _utils.validateType)(["TSEntityName", "TSImportType"])
    }
  });
  (0, _utils.default)("TSTypeLiteral", {
    aliases: ["TSType"],
    visitor: ["members"],
    fields: {
      members: (0, _utils.validateArrayOfType)("TSTypeElement")
    }
  });
  (0, _utils.default)("TSArrayType", {
    aliases: ["TSType"],
    visitor: ["elementType"],
    fields: {
      elementType: (0, _utils.validateType)("TSType")
    }
  });
  (0, _utils.default)("TSTupleType", {
    aliases: ["TSType"],
    visitor: ["elementTypes"],
    fields: {
      elementTypes: (0, _utils.validateArrayOfType)(["TSType", "TSNamedTupleMember"])
    }
  });
  (0, _utils.default)("TSOptionalType", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: (0, _utils.validateType)("TSType")
    }
  });
  (0, _utils.default)("TSRestType", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: (0, _utils.validateType)("TSType")
    }
  });
  (0, _utils.default)("TSNamedTupleMember", {
    visitor: ["label", "elementType"],
    builder: ["label", "elementType", "optional"],
    fields: {
      label: (0, _utils.validateType)("Identifier"),
      optional: {
        validate: bool,
        default: false
      },
      elementType: (0, _utils.validateType)("TSType")
    }
  });
  const unionOrIntersection = {
    aliases: ["TSType"],
    visitor: ["types"],
    fields: {
      types: (0, _utils.validateArrayOfType)("TSType")
    }
  };
  (0, _utils.default)("TSUnionType", unionOrIntersection);
  (0, _utils.default)("TSIntersectionType", unionOrIntersection);
  (0, _utils.default)("TSConditionalType", {
    aliases: ["TSType"],
    visitor: ["checkType", "extendsType", "trueType", "falseType"],
    fields: {
      checkType: (0, _utils.validateType)("TSType"),
      extendsType: (0, _utils.validateType)("TSType"),
      trueType: (0, _utils.validateType)("TSType"),
      falseType: (0, _utils.validateType)("TSType")
    }
  });
  (0, _utils.default)("TSInferType", {
    aliases: ["TSType"],
    visitor: ["typeParameter"],
    fields: {
      typeParameter: (0, _utils.validateType)("TSTypeParameter")
    }
  });
  (0, _utils.default)("TSParenthesizedType", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: (0, _utils.validateType)("TSType")
    }
  });
  (0, _utils.default)("TSTypeOperator", {
    aliases: ["TSType"],
    visitor: ["typeAnnotation"],
    fields: {
      operator: (0, _utils.validate)((0, _utils.assertValueType)("string")),
      typeAnnotation: (0, _utils.validateType)("TSType")
    }
  });
  (0, _utils.default)("TSIndexedAccessType", {
    aliases: ["TSType"],
    visitor: ["objectType", "indexType"],
    fields: {
      objectType: (0, _utils.validateType)("TSType"),
      indexType: (0, _utils.validateType)("TSType")
    }
  });
  (0, _utils.default)("TSMappedType", {
    aliases: ["TSType"],
    visitor: ["typeParameter", "typeAnnotation", "nameType"],
    fields: {
      readonly: (0, _utils.validateOptional)(bool),
      typeParameter: (0, _utils.validateType)("TSTypeParameter"),
      optional: (0, _utils.validateOptional)(bool),
      typeAnnotation: (0, _utils.validateOptionalType)("TSType"),
      nameType: (0, _utils.validateOptionalType)("TSType")
    }
  });
  (0, _utils.default)("TSLiteralType", {
    aliases: ["TSType", "TSBaseType"],
    visitor: ["literal"],
    fields: {
      literal: {
        validate: function () {
          const unaryExpression = (0, _utils.assertNodeType)("NumericLiteral", "BigIntLiteral");
          const unaryOperator = (0, _utils.assertOneOf)("-");
          const literal = (0, _utils.assertNodeType)("NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral");
  
          function validator(parent, key, node) {
            if ((0, _is.default)("UnaryExpression", node)) {
              unaryOperator(node, "operator", node.operator);
              unaryExpression(node, "argument", node.argument);
            } else {
              literal(parent, key, node);
            }
          }
  
          validator.oneOfNodeTypes = ["NumericLiteral", "StringLiteral", "BooleanLiteral", "BigIntLiteral", "UnaryExpression"];
          return validator;
        }()
      }
    }
  });
  (0, _utils.default)("TSExpressionWithTypeArguments", {
    aliases: ["TSType"],
    visitor: ["expression", "typeParameters"],
    fields: {
      expression: (0, _utils.validateType)("TSEntityName"),
      typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
    }
  });
  (0, _utils.default)("TSInterfaceDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "typeParameters", "extends", "body"],
    fields: {
      declare: (0, _utils.validateOptional)(bool),
      id: (0, _utils.validateType)("Identifier"),
      typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
      extends: (0, _utils.validateOptional)((0, _utils.arrayOfType)("TSExpressionWithTypeArguments")),
      body: (0, _utils.validateType)("TSInterfaceBody")
    }
  });
  (0, _utils.default)("TSInterfaceBody", {
    visitor: ["body"],
    fields: {
      body: (0, _utils.validateArrayOfType)("TSTypeElement")
    }
  });
  (0, _utils.default)("TSTypeAliasDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "typeParameters", "typeAnnotation"],
    fields: {
      declare: (0, _utils.validateOptional)(bool),
      id: (0, _utils.validateType)("Identifier"),
      typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterDeclaration"),
      typeAnnotation: (0, _utils.validateType)("TSType")
    }
  });
  (0, _utils.default)("TSAsExpression", {
    aliases: ["Expression"],
    visitor: ["expression", "typeAnnotation"],
    fields: {
      expression: (0, _utils.validateType)("Expression"),
      typeAnnotation: (0, _utils.validateType)("TSType")
    }
  });
  (0, _utils.default)("TSTypeAssertion", {
    aliases: ["Expression"],
    visitor: ["typeAnnotation", "expression"],
    fields: {
      typeAnnotation: (0, _utils.validateType)("TSType"),
      expression: (0, _utils.validateType)("Expression")
    }
  });
  (0, _utils.default)("TSEnumDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "members"],
    fields: {
      declare: (0, _utils.validateOptional)(bool),
      const: (0, _utils.validateOptional)(bool),
      id: (0, _utils.validateType)("Identifier"),
      members: (0, _utils.validateArrayOfType)("TSEnumMember"),
      initializer: (0, _utils.validateOptionalType)("Expression")
    }
  });
  (0, _utils.default)("TSEnumMember", {
    visitor: ["id", "initializer"],
    fields: {
      id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
      initializer: (0, _utils.validateOptionalType)("Expression")
    }
  });
  (0, _utils.default)("TSModuleDeclaration", {
    aliases: ["Statement", "Declaration"],
    visitor: ["id", "body"],
    fields: {
      declare: (0, _utils.validateOptional)(bool),
      global: (0, _utils.validateOptional)(bool),
      id: (0, _utils.validateType)(["Identifier", "StringLiteral"]),
      body: (0, _utils.validateType)(["TSModuleBlock", "TSModuleDeclaration"])
    }
  });
  (0, _utils.default)("TSModuleBlock", {
    aliases: ["Scopable", "Block", "BlockParent"],
    visitor: ["body"],
    fields: {
      body: (0, _utils.validateArrayOfType)("Statement")
    }
  });
  (0, _utils.default)("TSImportType", {
    aliases: ["TSType"],
    visitor: ["argument", "qualifier", "typeParameters"],
    fields: {
      argument: (0, _utils.validateType)("StringLiteral"),
      qualifier: (0, _utils.validateOptionalType)("TSEntityName"),
      typeParameters: (0, _utils.validateOptionalType)("TSTypeParameterInstantiation")
    }
  });
  (0, _utils.default)("TSImportEqualsDeclaration", {
    aliases: ["Statement"],
    visitor: ["id", "moduleReference"],
    fields: {
      isExport: (0, _utils.validate)(bool),
      id: (0, _utils.validateType)("Identifier"),
      moduleReference: (0, _utils.validateType)(["TSEntityName", "TSExternalModuleReference"]),
      importKind: {
        validate: (0, _utils.assertOneOf)("type", "value"),
        optional: true
      }
    }
  });
  (0, _utils.default)("TSExternalModuleReference", {
    visitor: ["expression"],
    fields: {
      expression: (0, _utils.validateType)("StringLiteral")
    }
  });
  (0, _utils.default)("TSNonNullExpression", {
    aliases: ["Expression"],
    visitor: ["expression"],
    fields: {
      expression: (0, _utils.validateType)("Expression")
    }
  });
  (0, _utils.default)("TSExportAssignment", {
    aliases: ["Statement"],
    visitor: ["expression"],
    fields: {
      expression: (0, _utils.validateType)("Expression")
    }
  });
  (0, _utils.default)("TSNamespaceExportDeclaration", {
    aliases: ["Statement"],
    visitor: ["id"],
    fields: {
      id: (0, _utils.validateType)("Identifier")
    }
  });
  (0, _utils.default)("TSTypeAnnotation", {
    visitor: ["typeAnnotation"],
    fields: {
      typeAnnotation: {
        validate: (0, _utils.assertNodeType)("TSType")
      }
    }
  });
  (0, _utils.default)("TSTypeParameterInstantiation", {
    visitor: ["params"],
    fields: {
      params: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSType")))
      }
    }
  });
  (0, _utils.default)("TSTypeParameterDeclaration", {
    visitor: ["params"],
    fields: {
      params: {
        validate: (0, _utils.chain)((0, _utils.assertValueType)("array"), (0, _utils.assertEach)((0, _utils.assertNodeType)("TSTypeParameter")))
      }
    }
  });
  (0, _utils.default)("TSTypeParameter", {
    builder: ["constraint", "default", "name"],
    visitor: ["constraint", "default"],
    fields: {
      name: {
        validate: (0, _utils.assertValueType)("string")
      },
      constraint: {
        validate: (0, _utils.assertNodeType)("TSType"),
        optional: true
      },
      default: {
        validate: (0, _utils.assertNodeType)("TSType"),
        optional: true
      }
    }
  });
  },{"../validators/is":91,"./core":65,"./utils":73}],73:[function(require,module,exports){
  (function (process){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.validate = validate;
  exports.typeIs = typeIs;
  exports.validateType = validateType;
  exports.validateOptional = validateOptional;
  exports.validateOptionalType = validateOptionalType;
  exports.arrayOf = arrayOf;
  exports.arrayOfType = arrayOfType;
  exports.validateArrayOfType = validateArrayOfType;
  exports.assertEach = assertEach;
  exports.assertOneOf = assertOneOf;
  exports.assertNodeType = assertNodeType;
  exports.assertNodeOrValueType = assertNodeOrValueType;
  exports.assertValueType = assertValueType;
  exports.assertShape = assertShape;
  exports.assertOptionalChainStart = assertOptionalChainStart;
  exports.chain = chain;
  exports.default = defineType;
  exports.NODE_PARENT_VALIDATIONS = exports.DEPRECATED_KEYS = exports.BUILDER_KEYS = exports.NODE_FIELDS = exports.FLIPPED_ALIAS_KEYS = exports.ALIAS_KEYS = exports.VISITOR_KEYS = void 0;
  
  var _is = require("../validators/is");
  
  var _validate = require("../validators/validate");
  
  const VISITOR_KEYS = {};
  exports.VISITOR_KEYS = VISITOR_KEYS;
  const ALIAS_KEYS = {};
  exports.ALIAS_KEYS = ALIAS_KEYS;
  const FLIPPED_ALIAS_KEYS = {};
  exports.FLIPPED_ALIAS_KEYS = FLIPPED_ALIAS_KEYS;
  const NODE_FIELDS = {};
  exports.NODE_FIELDS = NODE_FIELDS;
  const BUILDER_KEYS = {};
  exports.BUILDER_KEYS = BUILDER_KEYS;
  const DEPRECATED_KEYS = {};
  exports.DEPRECATED_KEYS = DEPRECATED_KEYS;
  const NODE_PARENT_VALIDATIONS = {};
  exports.NODE_PARENT_VALIDATIONS = NODE_PARENT_VALIDATIONS;
  
  function getType(val) {
    if (Array.isArray(val)) {
      return "array";
    } else if (val === null) {
      return "null";
    } else {
      return typeof val;
    }
  }
  
  function validate(validate) {
    return {
      validate
    };
  }
  
  function typeIs(typeName) {
    return typeof typeName === "string" ? assertNodeType(typeName) : assertNodeType(...typeName);
  }
  
  function validateType(typeName) {
    return validate(typeIs(typeName));
  }
  
  function validateOptional(validate) {
    return {
      validate,
      optional: true
    };
  }
  
  function validateOptionalType(typeName) {
    return {
      validate: typeIs(typeName),
      optional: true
    };
  }
  
  function arrayOf(elementType) {
    return chain(assertValueType("array"), assertEach(elementType));
  }
  
  function arrayOfType(typeName) {
    return arrayOf(typeIs(typeName));
  }
  
  function validateArrayOfType(typeName) {
    return validate(arrayOfType(typeName));
  }
  
  function assertEach(callback) {
    function validator(node, key, val) {
      if (!Array.isArray(val)) return;
  
      for (let i = 0; i < val.length; i++) {
        const subkey = `${key}[${i}]`;
        const v = val[i];
        callback(node, subkey, v);
        if (process.env.BABEL_TYPES_8_BREAKING) (0, _validate.validateChild)(node, subkey, v);
      }
    }
  
    validator.each = callback;
    return validator;
  }
  
  function assertOneOf(...values) {
    function validate(node, key, val) {
      if (values.indexOf(val) < 0) {
        throw new TypeError(`Property ${key} expected value to be one of ${JSON.stringify(values)} but got ${JSON.stringify(val)}`);
      }
    }
  
    validate.oneOf = values;
    return validate;
  }
  
  function assertNodeType(...types) {
    function validate(node, key, val) {
      for (const type of types) {
        if ((0, _is.default)(type, val)) {
          (0, _validate.validateChild)(node, key, val);
          return;
        }
      }
  
      throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
    }
  
    validate.oneOfNodeTypes = types;
    return validate;
  }
  
  function assertNodeOrValueType(...types) {
    function validate(node, key, val) {
      for (const type of types) {
        if (getType(val) === type || (0, _is.default)(type, val)) {
          (0, _validate.validateChild)(node, key, val);
          return;
        }
      }
  
      throw new TypeError(`Property ${key} of ${node.type} expected node to be of a type ${JSON.stringify(types)} but instead got ${JSON.stringify(val == null ? void 0 : val.type)}`);
    }
  
    validate.oneOfNodeOrValueTypes = types;
    return validate;
  }
  
  function assertValueType(type) {
    function validate(node, key, val) {
      const valid = getType(val) === type;
  
      if (!valid) {
        throw new TypeError(`Property ${key} expected type of ${type} but got ${getType(val)}`);
      }
    }
  
    validate.type = type;
    return validate;
  }
  
  function assertShape(shape) {
    function validate(node, key, val) {
      const errors = [];
  
      for (const property of Object.keys(shape)) {
        try {
          (0, _validate.validateField)(node, property, val[property], shape[property]);
        } catch (error) {
          if (error instanceof TypeError) {
            errors.push(error.message);
            continue;
          }
  
          throw error;
        }
      }
  
      if (errors.length) {
        throw new TypeError(`Property ${key} of ${node.type} expected to have the following:\n${errors.join("\n")}`);
      }
    }
  
    validate.shapeOf = shape;
    return validate;
  }
  
  function assertOptionalChainStart() {
    function validate(node) {
      var _current;
  
      let current = node;
  
      while (node) {
        const {
          type
        } = current;
  
        if (type === "OptionalCallExpression") {
          if (current.optional) return;
          current = current.callee;
          continue;
        }
  
        if (type === "OptionalMemberExpression") {
          if (current.optional) return;
          current = current.object;
          continue;
        }
  
        break;
      }
  
      throw new TypeError(`Non-optional ${node.type} must chain from an optional OptionalMemberExpression or OptionalCallExpression. Found chain from ${(_current = current) == null ? void 0 : _current.type}`);
    }
  
    return validate;
  }
  
  function chain(...fns) {
    function validate(...args) {
      for (const fn of fns) {
        fn(...args);
      }
    }
  
    validate.chainOf = fns;
  
    if (fns.length >= 2 && "type" in fns[0] && fns[0].type === "array" && !("each" in fns[1])) {
      throw new Error(`An assertValueType("array") validator can only be followed by an assertEach(...) validator.`);
    }
  
    return validate;
  }
  
  const validTypeOpts = ["aliases", "builder", "deprecatedAlias", "fields", "inherits", "visitor", "validate"];
  const validFieldKeys = ["default", "optional", "validate"];
  
  function defineType(type, opts = {}) {
    const inherits = opts.inherits && store[opts.inherits] || {};
    let fields = opts.fields;
  
    if (!fields) {
      fields = {};
  
      if (inherits.fields) {
        const keys = Object.getOwnPropertyNames(inherits.fields);
  
        for (const key of keys) {
          const field = inherits.fields[key];
          const def = field.default;
  
          if (Array.isArray(def) ? def.length > 0 : def && typeof def === "object") {
            throw new Error("field defaults can only be primitives or empty arrays currently");
          }
  
          fields[key] = {
            default: Array.isArray(def) ? [] : def,
            optional: field.optional,
            validate: field.validate
          };
        }
      }
    }
  
    const visitor = opts.visitor || inherits.visitor || [];
    const aliases = opts.aliases || inherits.aliases || [];
    const builder = opts.builder || inherits.builder || opts.visitor || [];
  
    for (const k of Object.keys(opts)) {
      if (validTypeOpts.indexOf(k) === -1) {
        throw new Error(`Unknown type option "${k}" on ${type}`);
      }
    }
  
    if (opts.deprecatedAlias) {
      DEPRECATED_KEYS[opts.deprecatedAlias] = type;
    }
  
    for (const key of visitor.concat(builder)) {
      fields[key] = fields[key] || {};
    }
  
    for (const key of Object.keys(fields)) {
      const field = fields[key];
  
      if (field.default !== undefined && builder.indexOf(key) === -1) {
        field.optional = true;
      }
  
      if (field.default === undefined) {
        field.default = null;
      } else if (!field.validate && field.default != null) {
        field.validate = assertValueType(getType(field.default));
      }
  
      for (const k of Object.keys(field)) {
        if (validFieldKeys.indexOf(k) === -1) {
          throw new Error(`Unknown field key "${k}" on ${type}.${key}`);
        }
      }
    }
  
    VISITOR_KEYS[type] = opts.visitor = visitor;
    BUILDER_KEYS[type] = opts.builder = builder;
    NODE_FIELDS[type] = opts.fields = fields;
    ALIAS_KEYS[type] = opts.aliases = aliases;
    aliases.forEach(alias => {
      FLIPPED_ALIAS_KEYS[alias] = FLIPPED_ALIAS_KEYS[alias] || [];
      FLIPPED_ALIAS_KEYS[alias].push(type);
    });
  
    if (opts.validate) {
      NODE_PARENT_VALIDATIONS[type] = opts.validate;
    }
  
    store[type] = opts;
  }
  
  const store = {};
  }).call(this,require('_process'))
  },{"../validators/is":91,"../validators/validate":109,"_process":115}],74:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  var _exportNames = {
    react: true,
    assertNode: true,
    createTypeAnnotationBasedOnTypeof: true,
    createUnionTypeAnnotation: true,
    createFlowUnionType: true,
    createTSUnionType: true,
    cloneNode: true,
    clone: true,
    cloneDeep: true,
    cloneDeepWithoutLoc: true,
    cloneWithoutLoc: true,
    addComment: true,
    addComments: true,
    inheritInnerComments: true,
    inheritLeadingComments: true,
    inheritsComments: true,
    inheritTrailingComments: true,
    removeComments: true,
    ensureBlock: true,
    toBindingIdentifierName: true,
    toBlock: true,
    toComputedKey: true,
    toExpression: true,
    toIdentifier: true,
    toKeyAlias: true,
    toSequenceExpression: true,
    toStatement: true,
    valueToNode: true,
    appendToMemberExpression: true,
    inherits: true,
    prependToMemberExpression: true,
    removeProperties: true,
    removePropertiesDeep: true,
    removeTypeDuplicates: true,
    getBindingIdentifiers: true,
    getOuterBindingIdentifiers: true,
    traverse: true,
    traverseFast: true,
    shallowEqual: true,
    is: true,
    isBinding: true,
    isBlockScoped: true,
    isImmutable: true,
    isLet: true,
    isNode: true,
    isNodesEquivalent: true,
    isPlaceholderType: true,
    isReferenced: true,
    isScope: true,
    isSpecifierDefault: true,
    isType: true,
    isValidES3Identifier: true,
    isValidIdentifier: true,
    isVar: true,
    matchesPattern: true,
    validate: true,
    buildMatchMemberExpression: true
  };
  Object.defineProperty(exports, "assertNode", {
    enumerable: true,
    get: function () {
      return _assertNode.default;
    }
  });
  Object.defineProperty(exports, "createTypeAnnotationBasedOnTypeof", {
    enumerable: true,
    get: function () {
      return _createTypeAnnotationBasedOnTypeof.default;
    }
  });
  Object.defineProperty(exports, "createUnionTypeAnnotation", {
    enumerable: true,
    get: function () {
      return _createFlowUnionType.default;
    }
  });
  Object.defineProperty(exports, "createFlowUnionType", {
    enumerable: true,
    get: function () {
      return _createFlowUnionType.default;
    }
  });
  Object.defineProperty(exports, "createTSUnionType", {
    enumerable: true,
    get: function () {
      return _createTSUnionType.default;
    }
  });
  Object.defineProperty(exports, "cloneNode", {
    enumerable: true,
    get: function () {
      return _cloneNode.default;
    }
  });
  Object.defineProperty(exports, "clone", {
    enumerable: true,
    get: function () {
      return _clone.default;
    }
  });
  Object.defineProperty(exports, "cloneDeep", {
    enumerable: true,
    get: function () {
      return _cloneDeep.default;
    }
  });
  Object.defineProperty(exports, "cloneDeepWithoutLoc", {
    enumerable: true,
    get: function () {
      return _cloneDeepWithoutLoc.default;
    }
  });
  Object.defineProperty(exports, "cloneWithoutLoc", {
    enumerable: true,
    get: function () {
      return _cloneWithoutLoc.default;
    }
  });
  Object.defineProperty(exports, "addComment", {
    enumerable: true,
    get: function () {
      return _addComment.default;
    }
  });
  Object.defineProperty(exports, "addComments", {
    enumerable: true,
    get: function () {
      return _addComments.default;
    }
  });
  Object.defineProperty(exports, "inheritInnerComments", {
    enumerable: true,
    get: function () {
      return _inheritInnerComments.default;
    }
  });
  Object.defineProperty(exports, "inheritLeadingComments", {
    enumerable: true,
    get: function () {
      return _inheritLeadingComments.default;
    }
  });
  Object.defineProperty(exports, "inheritsComments", {
    enumerable: true,
    get: function () {
      return _inheritsComments.default;
    }
  });
  Object.defineProperty(exports, "inheritTrailingComments", {
    enumerable: true,
    get: function () {
      return _inheritTrailingComments.default;
    }
  });
  Object.defineProperty(exports, "removeComments", {
    enumerable: true,
    get: function () {
      return _removeComments.default;
    }
  });
  Object.defineProperty(exports, "ensureBlock", {
    enumerable: true,
    get: function () {
      return _ensureBlock.default;
    }
  });
  Object.defineProperty(exports, "toBindingIdentifierName", {
    enumerable: true,
    get: function () {
      return _toBindingIdentifierName.default;
    }
  });
  Object.defineProperty(exports, "toBlock", {
    enumerable: true,
    get: function () {
      return _toBlock.default;
    }
  });
  Object.defineProperty(exports, "toComputedKey", {
    enumerable: true,
    get: function () {
      return _toComputedKey.default;
    }
  });
  Object.defineProperty(exports, "toExpression", {
    enumerable: true,
    get: function () {
      return _toExpression.default;
    }
  });
  Object.defineProperty(exports, "toIdentifier", {
    enumerable: true,
    get: function () {
      return _toIdentifier.default;
    }
  });
  Object.defineProperty(exports, "toKeyAlias", {
    enumerable: true,
    get: function () {
      return _toKeyAlias.default;
    }
  });
  Object.defineProperty(exports, "toSequenceExpression", {
    enumerable: true,
    get: function () {
      return _toSequenceExpression.default;
    }
  });
  Object.defineProperty(exports, "toStatement", {
    enumerable: true,
    get: function () {
      return _toStatement.default;
    }
  });
  Object.defineProperty(exports, "valueToNode", {
    enumerable: true,
    get: function () {
      return _valueToNode.default;
    }
  });
  Object.defineProperty(exports, "appendToMemberExpression", {
    enumerable: true,
    get: function () {
      return _appendToMemberExpression.default;
    }
  });
  Object.defineProperty(exports, "inherits", {
    enumerable: true,
    get: function () {
      return _inherits.default;
    }
  });
  Object.defineProperty(exports, "prependToMemberExpression", {
    enumerable: true,
    get: function () {
      return _prependToMemberExpression.default;
    }
  });
  Object.defineProperty(exports, "removeProperties", {
    enumerable: true,
    get: function () {
      return _removeProperties.default;
    }
  });
  Object.defineProperty(exports, "removePropertiesDeep", {
    enumerable: true,
    get: function () {
      return _removePropertiesDeep.default;
    }
  });
  Object.defineProperty(exports, "removeTypeDuplicates", {
    enumerable: true,
    get: function () {
      return _removeTypeDuplicates.default;
    }
  });
  Object.defineProperty(exports, "getBindingIdentifiers", {
    enumerable: true,
    get: function () {
      return _getBindingIdentifiers.default;
    }
  });
  Object.defineProperty(exports, "getOuterBindingIdentifiers", {
    enumerable: true,
    get: function () {
      return _getOuterBindingIdentifiers.default;
    }
  });
  Object.defineProperty(exports, "traverse", {
    enumerable: true,
    get: function () {
      return _traverse.default;
    }
  });
  Object.defineProperty(exports, "traverseFast", {
    enumerable: true,
    get: function () {
      return _traverseFast.default;
    }
  });
  Object.defineProperty(exports, "shallowEqual", {
    enumerable: true,
    get: function () {
      return _shallowEqual.default;
    }
  });
  Object.defineProperty(exports, "is", {
    enumerable: true,
    get: function () {
      return _is.default;
    }
  });
  Object.defineProperty(exports, "isBinding", {
    enumerable: true,
    get: function () {
      return _isBinding.default;
    }
  });
  Object.defineProperty(exports, "isBlockScoped", {
    enumerable: true,
    get: function () {
      return _isBlockScoped.default;
    }
  });
  Object.defineProperty(exports, "isImmutable", {
    enumerable: true,
    get: function () {
      return _isImmutable.default;
    }
  });
  Object.defineProperty(exports, "isLet", {
    enumerable: true,
    get: function () {
      return _isLet.default;
    }
  });
  Object.defineProperty(exports, "isNode", {
    enumerable: true,
    get: function () {
      return _isNode.default;
    }
  });
  Object.defineProperty(exports, "isNodesEquivalent", {
    enumerable: true,
    get: function () {
      return _isNodesEquivalent.default;
    }
  });
  Object.defineProperty(exports, "isPlaceholderType", {
    enumerable: true,
    get: function () {
      return _isPlaceholderType.default;
    }
  });
  Object.defineProperty(exports, "isReferenced", {
    enumerable: true,
    get: function () {
      return _isReferenced.default;
    }
  });
  Object.defineProperty(exports, "isScope", {
    enumerable: true,
    get: function () {
      return _isScope.default;
    }
  });
  Object.defineProperty(exports, "isSpecifierDefault", {
    enumerable: true,
    get: function () {
      return _isSpecifierDefault.default;
    }
  });
  Object.defineProperty(exports, "isType", {
    enumerable: true,
    get: function () {
      return _isType.default;
    }
  });
  Object.defineProperty(exports, "isValidES3Identifier", {
    enumerable: true,
    get: function () {
      return _isValidES3Identifier.default;
    }
  });
  Object.defineProperty(exports, "isValidIdentifier", {
    enumerable: true,
    get: function () {
      return _isValidIdentifier.default;
    }
  });
  Object.defineProperty(exports, "isVar", {
    enumerable: true,
    get: function () {
      return _isVar.default;
    }
  });
  Object.defineProperty(exports, "matchesPattern", {
    enumerable: true,
    get: function () {
      return _matchesPattern.default;
    }
  });
  Object.defineProperty(exports, "validate", {
    enumerable: true,
    get: function () {
      return _validate.default;
    }
  });
  Object.defineProperty(exports, "buildMatchMemberExpression", {
    enumerable: true,
    get: function () {
      return _buildMatchMemberExpression.default;
    }
  });
  exports.react = void 0;
  
  var _isReactComponent = require("./validators/react/isReactComponent");
  
  var _isCompatTag = require("./validators/react/isCompatTag");
  
  var _buildChildren = require("./builders/react/buildChildren");
  
  var _assertNode = require("./asserts/assertNode");
  
  var _generated = require("./asserts/generated");
  
  Object.keys(_generated).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    if (key in exports && exports[key] === _generated[key]) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function () {
        return _generated[key];
      }
    });
  });
  
  var _createTypeAnnotationBasedOnTypeof = require("./builders/flow/createTypeAnnotationBasedOnTypeof");
  
  var _createFlowUnionType = require("./builders/flow/createFlowUnionType");
  
  var _createTSUnionType = require("./builders/typescript/createTSUnionType");
  
  var _generated2 = require("./builders/generated");
  
  Object.keys(_generated2).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    if (key in exports && exports[key] === _generated2[key]) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function () {
        return _generated2[key];
      }
    });
  });
  
  var _uppercase = require("./builders/generated/uppercase");
  
  Object.keys(_uppercase).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    if (key in exports && exports[key] === _uppercase[key]) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function () {
        return _uppercase[key];
      }
    });
  });
  
  var _cloneNode = require("./clone/cloneNode");
  
  var _clone = require("./clone/clone");
  
  var _cloneDeep = require("./clone/cloneDeep");
  
  var _cloneDeepWithoutLoc = require("./clone/cloneDeepWithoutLoc");
  
  var _cloneWithoutLoc = require("./clone/cloneWithoutLoc");
  
  var _addComment = require("./comments/addComment");
  
  var _addComments = require("./comments/addComments");
  
  var _inheritInnerComments = require("./comments/inheritInnerComments");
  
  var _inheritLeadingComments = require("./comments/inheritLeadingComments");
  
  var _inheritsComments = require("./comments/inheritsComments");
  
  var _inheritTrailingComments = require("./comments/inheritTrailingComments");
  
  var _removeComments = require("./comments/removeComments");
  
  var _generated3 = require("./constants/generated");
  
  Object.keys(_generated3).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    if (key in exports && exports[key] === _generated3[key]) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function () {
        return _generated3[key];
      }
    });
  });
  
  var _constants = require("./constants");
  
  Object.keys(_constants).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    if (key in exports && exports[key] === _constants[key]) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function () {
        return _constants[key];
      }
    });
  });
  
  var _ensureBlock = require("./converters/ensureBlock");
  
  var _toBindingIdentifierName = require("./converters/toBindingIdentifierName");
  
  var _toBlock = require("./converters/toBlock");
  
  var _toComputedKey = require("./converters/toComputedKey");
  
  var _toExpression = require("./converters/toExpression");
  
  var _toIdentifier = require("./converters/toIdentifier");
  
  var _toKeyAlias = require("./converters/toKeyAlias");
  
  var _toSequenceExpression = require("./converters/toSequenceExpression");
  
  var _toStatement = require("./converters/toStatement");
  
  var _valueToNode = require("./converters/valueToNode");
  
  var _definitions = require("./definitions");
  
  Object.keys(_definitions).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    if (key in exports && exports[key] === _definitions[key]) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function () {
        return _definitions[key];
      }
    });
  });
  
  var _appendToMemberExpression = require("./modifications/appendToMemberExpression");
  
  var _inherits = require("./modifications/inherits");
  
  var _prependToMemberExpression = require("./modifications/prependToMemberExpression");
  
  var _removeProperties = require("./modifications/removeProperties");
  
  var _removePropertiesDeep = require("./modifications/removePropertiesDeep");
  
  var _removeTypeDuplicates = require("./modifications/flow/removeTypeDuplicates");
  
  var _getBindingIdentifiers = require("./retrievers/getBindingIdentifiers");
  
  var _getOuterBindingIdentifiers = require("./retrievers/getOuterBindingIdentifiers");
  
  var _traverse = require("./traverse/traverse");
  
  Object.keys(_traverse).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    if (key in exports && exports[key] === _traverse[key]) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function () {
        return _traverse[key];
      }
    });
  });
  
  var _traverseFast = require("./traverse/traverseFast");
  
  var _shallowEqual = require("./utils/shallowEqual");
  
  var _is = require("./validators/is");
  
  var _isBinding = require("./validators/isBinding");
  
  var _isBlockScoped = require("./validators/isBlockScoped");
  
  var _isImmutable = require("./validators/isImmutable");
  
  var _isLet = require("./validators/isLet");
  
  var _isNode = require("./validators/isNode");
  
  var _isNodesEquivalent = require("./validators/isNodesEquivalent");
  
  var _isPlaceholderType = require("./validators/isPlaceholderType");
  
  var _isReferenced = require("./validators/isReferenced");
  
  var _isScope = require("./validators/isScope");
  
  var _isSpecifierDefault = require("./validators/isSpecifierDefault");
  
  var _isType = require("./validators/isType");
  
  var _isValidES3Identifier = require("./validators/isValidES3Identifier");
  
  var _isValidIdentifier = require("./validators/isValidIdentifier");
  
  var _isVar = require("./validators/isVar");
  
  var _matchesPattern = require("./validators/matchesPattern");
  
  var _validate = require("./validators/validate");
  
  var _buildMatchMemberExpression = require("./validators/buildMatchMemberExpression");
  
  var _generated4 = require("./validators/generated");
  
  Object.keys(_generated4).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    if (key in exports && exports[key] === _generated4[key]) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function () {
        return _generated4[key];
      }
    });
  });
  
  var _generated5 = require("./ast-types/generated");
  
  Object.keys(_generated5).forEach(function (key) {
    if (key === "default" || key === "__esModule") return;
    if (Object.prototype.hasOwnProperty.call(_exportNames, key)) return;
    if (key in exports && exports[key] === _generated5[key]) return;
    Object.defineProperty(exports, key, {
      enumerable: true,
      get: function () {
        return _generated5[key];
      }
    });
  });
  const react = {
    isReactComponent: _isReactComponent.default,
    isCompatTag: _isCompatTag.default,
    buildChildren: _buildChildren.default
  };
  exports.react = react;
  },{"./asserts/assertNode":30,"./asserts/generated":31,"./ast-types/generated":32,"./builders/flow/createFlowUnionType":34,"./builders/flow/createTypeAnnotationBasedOnTypeof":35,"./builders/generated":36,"./builders/generated/uppercase":37,"./builders/react/buildChildren":38,"./builders/typescript/createTSUnionType":39,"./clone/clone":40,"./clone/cloneDeep":41,"./clone/cloneDeepWithoutLoc":42,"./clone/cloneNode":43,"./clone/cloneWithoutLoc":44,"./comments/addComment":45,"./comments/addComments":46,"./comments/inheritInnerComments":47,"./comments/inheritLeadingComments":48,"./comments/inheritTrailingComments":49,"./comments/inheritsComments":50,"./comments/removeComments":51,"./constants":53,"./constants/generated":52,"./converters/ensureBlock":54,"./converters/toBindingIdentifierName":56,"./converters/toBlock":57,"./converters/toComputedKey":58,"./converters/toExpression":59,"./converters/toIdentifier":60,"./converters/toKeyAlias":61,"./converters/toSequenceExpression":62,"./converters/toStatement":63,"./converters/valueToNode":64,"./definitions":68,"./modifications/appendToMemberExpression":75,"./modifications/flow/removeTypeDuplicates":76,"./modifications/inherits":77,"./modifications/prependToMemberExpression":78,"./modifications/removeProperties":79,"./modifications/removePropertiesDeep":80,"./retrievers/getBindingIdentifiers":82,"./retrievers/getOuterBindingIdentifiers":83,"./traverse/traverse":84,"./traverse/traverseFast":85,"./utils/shallowEqual":88,"./validators/buildMatchMemberExpression":89,"./validators/generated":90,"./validators/is":91,"./validators/isBinding":92,"./validators/isBlockScoped":93,"./validators/isImmutable":94,"./validators/isLet":95,"./validators/isNode":96,"./validators/isNodesEquivalent":97,"./validators/isPlaceholderType":98,"./validators/isReferenced":99,"./validators/isScope":100,"./validators/isSpecifierDefault":101,"./validators/isType":102,"./validators/isValidES3Identifier":103,"./validators/isValidIdentifier":104,"./validators/isVar":105,"./validators/matchesPattern":106,"./validators/react/isCompatTag":107,"./validators/react/isReactComponent":108,"./validators/validate":109}],75:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = appendToMemberExpression;
  
  var _generated = require("../builders/generated");
  
  function appendToMemberExpression(member, append, computed = false) {
    member.object = (0, _generated.memberExpression)(member.object, member.property, member.computed);
    member.property = append;
    member.computed = !!computed;
    return member;
  }
  },{"../builders/generated":36}],76:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = removeTypeDuplicates;
  
  var _generated = require("../../validators/generated");
  
  function getQualifiedName(node) {
    return (0, _generated.isIdentifier)(node) ? node.name : `${node.id.name}.${getQualifiedName(node.qualification)}`;
  }
  
  function removeTypeDuplicates(nodes) {
    const generics = {};
    const bases = {};
    const typeGroups = new Set();
    const types = [];
  
    for (let i = 0; i < nodes.length; i++) {
      const node = nodes[i];
      if (!node) continue;
  
      if (types.indexOf(node) >= 0) {
        continue;
      }
  
      if ((0, _generated.isAnyTypeAnnotation)(node)) {
        return [node];
      }
  
      if ((0, _generated.isFlowBaseAnnotation)(node)) {
        bases[node.type] = node;
        continue;
      }
  
      if ((0, _generated.isUnionTypeAnnotation)(node)) {
        if (!typeGroups.has(node.types)) {
          nodes = nodes.concat(node.types);
          typeGroups.add(node.types);
        }
  
        continue;
      }
  
      if ((0, _generated.isGenericTypeAnnotation)(node)) {
        const name = getQualifiedName(node.id);
  
        if (generics[name]) {
          let existing = generics[name];
  
          if (existing.typeParameters) {
            if (node.typeParameters) {
              existing.typeParameters.params = removeTypeDuplicates(existing.typeParameters.params.concat(node.typeParameters.params));
            }
          } else {
            existing = node.typeParameters;
          }
        } else {
          generics[name] = node;
        }
  
        continue;
      }
  
      types.push(node);
    }
  
    for (const type of Object.keys(bases)) {
      types.push(bases[type]);
    }
  
    for (const name of Object.keys(generics)) {
      types.push(generics[name]);
    }
  
    return types;
  }
  },{"../../validators/generated":90}],77:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = inherits;
  
  var _constants = require("../constants");
  
  var _inheritsComments = require("../comments/inheritsComments");
  
  function inherits(child, parent) {
    if (!child || !parent) return child;
  
    for (const key of _constants.INHERIT_KEYS.optional) {
      if (child[key] == null) {
        child[key] = parent[key];
      }
    }
  
    for (const key of Object.keys(parent)) {
      if (key[0] === "_" && key !== "__clone") child[key] = parent[key];
    }
  
    for (const key of _constants.INHERIT_KEYS.force) {
      child[key] = parent[key];
    }
  
    (0, _inheritsComments.default)(child, parent);
    return child;
  }
  },{"../comments/inheritsComments":50,"../constants":53}],78:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = prependToMemberExpression;
  
  var _generated = require("../builders/generated");
  
  function prependToMemberExpression(member, prepend) {
    member.object = (0, _generated.memberExpression)(prepend, member.object);
    return member;
  }
  },{"../builders/generated":36}],79:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = removeProperties;
  
  var _constants = require("../constants");
  
  const CLEAR_KEYS = ["tokens", "start", "end", "loc", "raw", "rawValue"];
  
  const CLEAR_KEYS_PLUS_COMMENTS = _constants.COMMENT_KEYS.concat(["comments"]).concat(CLEAR_KEYS);
  
  function removeProperties(node, opts = {}) {
    const map = opts.preserveComments ? CLEAR_KEYS : CLEAR_KEYS_PLUS_COMMENTS;
  
    for (const key of map) {
      if (node[key] != null) node[key] = undefined;
    }
  
    for (const key of Object.keys(node)) {
      if (key[0] === "_" && node[key] != null) node[key] = undefined;
    }
  
    const symbols = Object.getOwnPropertySymbols(node);
  
    for (const sym of symbols) {
      node[sym] = null;
    }
  }
  },{"../constants":53}],80:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = removePropertiesDeep;
  
  var _traverseFast = require("../traverse/traverseFast");
  
  var _removeProperties = require("./removeProperties");
  
  function removePropertiesDeep(tree, opts) {
    (0, _traverseFast.default)(tree, _removeProperties.default, opts);
    return tree;
  }
  },{"../traverse/traverseFast":85,"./removeProperties":79}],81:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = removeTypeDuplicates;
  
  var _generated = require("../../validators/generated");
  
  function removeTypeDuplicates(nodes) {
    const generics = {};
    const bases = {};
    const typeGroups = new Set();
    const types = [];
  
    for (let i = 0; i < nodes.length; i++) {
      const node = nodes[i];
      if (!node) continue;
  
      if (types.indexOf(node) >= 0) {
        continue;
      }
  
      if ((0, _generated.isTSAnyKeyword)(node)) {
        return [node];
      }
  
      if ((0, _generated.isTSBaseType)(node)) {
        bases[node.type] = node;
        continue;
      }
  
      if ((0, _generated.isTSUnionType)(node)) {
        if (!typeGroups.has(node.types)) {
          nodes.push(...node.types);
          typeGroups.add(node.types);
        }
  
        continue;
      }
  
      types.push(node);
    }
  
    for (const type of Object.keys(bases)) {
      types.push(bases[type]);
    }
  
    for (const name of Object.keys(generics)) {
      types.push(generics[name]);
    }
  
    return types;
  }
  },{"../../validators/generated":90}],82:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = getBindingIdentifiers;
  
  var _generated = require("../validators/generated");
  
  function getBindingIdentifiers(node, duplicates, outerOnly) {
    let search = [].concat(node);
    const ids = Object.create(null);
  
    while (search.length) {
      const id = search.shift();
      if (!id) continue;
      const keys = getBindingIdentifiers.keys[id.type];
  
      if ((0, _generated.isIdentifier)(id)) {
        if (duplicates) {
          const _ids = ids[id.name] = ids[id.name] || [];
  
          _ids.push(id);
        } else {
          ids[id.name] = id;
        }
  
        continue;
      }
  
      if ((0, _generated.isExportDeclaration)(id) && !(0, _generated.isExportAllDeclaration)(id)) {
        if ((0, _generated.isDeclaration)(id.declaration)) {
          search.push(id.declaration);
        }
  
        continue;
      }
  
      if (outerOnly) {
        if ((0, _generated.isFunctionDeclaration)(id)) {
          search.push(id.id);
          continue;
        }
  
        if ((0, _generated.isFunctionExpression)(id)) {
          continue;
        }
      }
  
      if (keys) {
        for (let i = 0; i < keys.length; i++) {
          const key = keys[i];
  
          if (id[key]) {
            search = search.concat(id[key]);
          }
        }
      }
    }
  
    return ids;
  }
  
  getBindingIdentifiers.keys = {
    DeclareClass: ["id"],
    DeclareFunction: ["id"],
    DeclareModule: ["id"],
    DeclareVariable: ["id"],
    DeclareInterface: ["id"],
    DeclareTypeAlias: ["id"],
    DeclareOpaqueType: ["id"],
    InterfaceDeclaration: ["id"],
    TypeAlias: ["id"],
    OpaqueType: ["id"],
    CatchClause: ["param"],
    LabeledStatement: ["label"],
    UnaryExpression: ["argument"],
    AssignmentExpression: ["left"],
    ImportSpecifier: ["local"],
    ImportNamespaceSpecifier: ["local"],
    ImportDefaultSpecifier: ["local"],
    ImportDeclaration: ["specifiers"],
    ExportSpecifier: ["exported"],
    ExportNamespaceSpecifier: ["exported"],
    ExportDefaultSpecifier: ["exported"],
    FunctionDeclaration: ["id", "params"],
    FunctionExpression: ["id", "params"],
    ArrowFunctionExpression: ["params"],
    ObjectMethod: ["params"],
    ClassMethod: ["params"],
    ClassPrivateMethod: ["params"],
    ForInStatement: ["left"],
    ForOfStatement: ["left"],
    ClassDeclaration: ["id"],
    ClassExpression: ["id"],
    RestElement: ["argument"],
    UpdateExpression: ["argument"],
    ObjectProperty: ["value"],
    AssignmentPattern: ["left"],
    ArrayPattern: ["elements"],
    ObjectPattern: ["properties"],
    VariableDeclaration: ["declarations"],
    VariableDeclarator: ["id"]
  };
  },{"../validators/generated":90}],83:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  
  var _getBindingIdentifiers = require("./getBindingIdentifiers");
  
  var _default = getOuterBindingIdentifiers;
  exports.default = _default;
  
  function getOuterBindingIdentifiers(node, duplicates) {
    return (0, _getBindingIdentifiers.default)(node, duplicates, true);
  }
  },{"./getBindingIdentifiers":82}],84:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = traverse;
  
  var _definitions = require("../definitions");
  
  function traverse(node, handlers, state) {
    if (typeof handlers === "function") {
      handlers = {
        enter: handlers
      };
    }
  
    const {
      enter,
      exit
    } = handlers;
    traverseSimpleImpl(node, enter, exit, state, []);
  }
  
  function traverseSimpleImpl(node, enter, exit, state, ancestors) {
    const keys = _definitions.VISITOR_KEYS[node.type];
    if (!keys) return;
    if (enter) enter(node, ancestors, state);
  
    for (const key of keys) {
      const subNode = node[key];
  
      if (Array.isArray(subNode)) {
        for (let i = 0; i < subNode.length; i++) {
          const child = subNode[i];
          if (!child) continue;
          ancestors.push({
            node,
            key,
            index: i
          });
          traverseSimpleImpl(child, enter, exit, state, ancestors);
          ancestors.pop();
        }
      } else if (subNode) {
        ancestors.push({
          node,
          key
        });
        traverseSimpleImpl(subNode, enter, exit, state, ancestors);
        ancestors.pop();
      }
    }
  
    if (exit) exit(node, ancestors, state);
  }
  },{"../definitions":68}],85:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = traverseFast;
  
  var _definitions = require("../definitions");
  
  function traverseFast(node, enter, opts) {
    if (!node) return;
    const keys = _definitions.VISITOR_KEYS[node.type];
    if (!keys) return;
    opts = opts || {};
    enter(node, opts);
  
    for (const key of keys) {
      const subNode = node[key];
  
      if (Array.isArray(subNode)) {
        for (const node of subNode) {
          traverseFast(node, enter, opts);
        }
      } else {
        traverseFast(subNode, enter, opts);
      }
    }
  }
  },{"../definitions":68}],86:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = inherit;
  
  function inherit(key, child, parent) {
    if (child && parent) {
      child[key] = Array.from(new Set([].concat(child[key], parent[key]).filter(Boolean)));
    }
  }
  },{}],87:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = cleanJSXElementLiteralChild;
  
  var _generated = require("../../builders/generated");
  
  function cleanJSXElementLiteralChild(child, args) {
    const lines = child.value.split(/\r\n|\n|\r/);
    let lastNonEmptyLine = 0;
  
    for (let i = 0; i < lines.length; i++) {
      if (lines[i].match(/[^ \t]/)) {
        lastNonEmptyLine = i;
      }
    }
  
    let str = "";
  
    for (let i = 0; i < lines.length; i++) {
      const line = lines[i];
      const isFirstLine = i === 0;
      const isLastLine = i === lines.length - 1;
      const isLastNonEmptyLine = i === lastNonEmptyLine;
      let trimmedLine = line.replace(/\t/g, " ");
  
      if (!isFirstLine) {
        trimmedLine = trimmedLine.replace(/^[ ]+/, "");
      }
  
      if (!isLastLine) {
        trimmedLine = trimmedLine.replace(/[ ]+$/, "");
      }
  
      if (trimmedLine) {
        if (!isLastNonEmptyLine) {
          trimmedLine += " ";
        }
  
        str += trimmedLine;
      }
    }
  
    if (str) args.push((0, _generated.stringLiteral)(str));
  }
  },{"../../builders/generated":36}],88:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = shallowEqual;
  
  function shallowEqual(actual, expected) {
    const keys = Object.keys(expected);
  
    for (const key of keys) {
      if (actual[key] !== expected[key]) {
        return false;
      }
    }
  
    return true;
  }
  },{}],89:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = buildMatchMemberExpression;
  
  var _matchesPattern = require("./matchesPattern");
  
  function buildMatchMemberExpression(match, allowPartial) {
    const parts = match.split(".");
    return member => (0, _matchesPattern.default)(member, parts, allowPartial);
  }
  },{"./matchesPattern":106}],90:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.isArrayExpression = isArrayExpression;
  exports.isAssignmentExpression = isAssignmentExpression;
  exports.isBinaryExpression = isBinaryExpression;
  exports.isInterpreterDirective = isInterpreterDirective;
  exports.isDirective = isDirective;
  exports.isDirectiveLiteral = isDirectiveLiteral;
  exports.isBlockStatement = isBlockStatement;
  exports.isBreakStatement = isBreakStatement;
  exports.isCallExpression = isCallExpression;
  exports.isCatchClause = isCatchClause;
  exports.isConditionalExpression = isConditionalExpression;
  exports.isContinueStatement = isContinueStatement;
  exports.isDebuggerStatement = isDebuggerStatement;
  exports.isDoWhileStatement = isDoWhileStatement;
  exports.isEmptyStatement = isEmptyStatement;
  exports.isExpressionStatement = isExpressionStatement;
  exports.isFile = isFile;
  exports.isForInStatement = isForInStatement;
  exports.isForStatement = isForStatement;
  exports.isFunctionDeclaration = isFunctionDeclaration;
  exports.isFunctionExpression = isFunctionExpression;
  exports.isIdentifier = isIdentifier;
  exports.isIfStatement = isIfStatement;
  exports.isLabeledStatement = isLabeledStatement;
  exports.isStringLiteral = isStringLiteral;
  exports.isNumericLiteral = isNumericLiteral;
  exports.isNullLiteral = isNullLiteral;
  exports.isBooleanLiteral = isBooleanLiteral;
  exports.isRegExpLiteral = isRegExpLiteral;
  exports.isLogicalExpression = isLogicalExpression;
  exports.isMemberExpression = isMemberExpression;
  exports.isNewExpression = isNewExpression;
  exports.isProgram = isProgram;
  exports.isObjectExpression = isObjectExpression;
  exports.isObjectMethod = isObjectMethod;
  exports.isObjectProperty = isObjectProperty;
  exports.isRestElement = isRestElement;
  exports.isReturnStatement = isReturnStatement;
  exports.isSequenceExpression = isSequenceExpression;
  exports.isParenthesizedExpression = isParenthesizedExpression;
  exports.isSwitchCase = isSwitchCase;
  exports.isSwitchStatement = isSwitchStatement;
  exports.isThisExpression = isThisExpression;
  exports.isThrowStatement = isThrowStatement;
  exports.isTryStatement = isTryStatement;
  exports.isUnaryExpression = isUnaryExpression;
  exports.isUpdateExpression = isUpdateExpression;
  exports.isVariableDeclaration = isVariableDeclaration;
  exports.isVariableDeclarator = isVariableDeclarator;
  exports.isWhileStatement = isWhileStatement;
  exports.isWithStatement = isWithStatement;
  exports.isAssignmentPattern = isAssignmentPattern;
  exports.isArrayPattern = isArrayPattern;
  exports.isArrowFunctionExpression = isArrowFunctionExpression;
  exports.isClassBody = isClassBody;
  exports.isClassExpression = isClassExpression;
  exports.isClassDeclaration = isClassDeclaration;
  exports.isExportAllDeclaration = isExportAllDeclaration;
  exports.isExportDefaultDeclaration = isExportDefaultDeclaration;
  exports.isExportNamedDeclaration = isExportNamedDeclaration;
  exports.isExportSpecifier = isExportSpecifier;
  exports.isForOfStatement = isForOfStatement;
  exports.isImportDeclaration = isImportDeclaration;
  exports.isImportDefaultSpecifier = isImportDefaultSpecifier;
  exports.isImportNamespaceSpecifier = isImportNamespaceSpecifier;
  exports.isImportSpecifier = isImportSpecifier;
  exports.isMetaProperty = isMetaProperty;
  exports.isClassMethod = isClassMethod;
  exports.isObjectPattern = isObjectPattern;
  exports.isSpreadElement = isSpreadElement;
  exports.isSuper = isSuper;
  exports.isTaggedTemplateExpression = isTaggedTemplateExpression;
  exports.isTemplateElement = isTemplateElement;
  exports.isTemplateLiteral = isTemplateLiteral;
  exports.isYieldExpression = isYieldExpression;
  exports.isAwaitExpression = isAwaitExpression;
  exports.isImport = isImport;
  exports.isBigIntLiteral = isBigIntLiteral;
  exports.isExportNamespaceSpecifier = isExportNamespaceSpecifier;
  exports.isOptionalMemberExpression = isOptionalMemberExpression;
  exports.isOptionalCallExpression = isOptionalCallExpression;
  exports.isClassProperty = isClassProperty;
  exports.isClassPrivateProperty = isClassPrivateProperty;
  exports.isClassPrivateMethod = isClassPrivateMethod;
  exports.isPrivateName = isPrivateName;
  exports.isAnyTypeAnnotation = isAnyTypeAnnotation;
  exports.isArrayTypeAnnotation = isArrayTypeAnnotation;
  exports.isBooleanTypeAnnotation = isBooleanTypeAnnotation;
  exports.isBooleanLiteralTypeAnnotation = isBooleanLiteralTypeAnnotation;
  exports.isNullLiteralTypeAnnotation = isNullLiteralTypeAnnotation;
  exports.isClassImplements = isClassImplements;
  exports.isDeclareClass = isDeclareClass;
  exports.isDeclareFunction = isDeclareFunction;
  exports.isDeclareInterface = isDeclareInterface;
  exports.isDeclareModule = isDeclareModule;
  exports.isDeclareModuleExports = isDeclareModuleExports;
  exports.isDeclareTypeAlias = isDeclareTypeAlias;
  exports.isDeclareOpaqueType = isDeclareOpaqueType;
  exports.isDeclareVariable = isDeclareVariable;
  exports.isDeclareExportDeclaration = isDeclareExportDeclaration;
  exports.isDeclareExportAllDeclaration = isDeclareExportAllDeclaration;
  exports.isDeclaredPredicate = isDeclaredPredicate;
  exports.isExistsTypeAnnotation = isExistsTypeAnnotation;
  exports.isFunctionTypeAnnotation = isFunctionTypeAnnotation;
  exports.isFunctionTypeParam = isFunctionTypeParam;
  exports.isGenericTypeAnnotation = isGenericTypeAnnotation;
  exports.isInferredPredicate = isInferredPredicate;
  exports.isInterfaceExtends = isInterfaceExtends;
  exports.isInterfaceDeclaration = isInterfaceDeclaration;
  exports.isInterfaceTypeAnnotation = isInterfaceTypeAnnotation;
  exports.isIntersectionTypeAnnotation = isIntersectionTypeAnnotation;
  exports.isMixedTypeAnnotation = isMixedTypeAnnotation;
  exports.isEmptyTypeAnnotation = isEmptyTypeAnnotation;
  exports.isNullableTypeAnnotation = isNullableTypeAnnotation;
  exports.isNumberLiteralTypeAnnotation = isNumberLiteralTypeAnnotation;
  exports.isNumberTypeAnnotation = isNumberTypeAnnotation;
  exports.isObjectTypeAnnotation = isObjectTypeAnnotation;
  exports.isObjectTypeInternalSlot = isObjectTypeInternalSlot;
  exports.isObjectTypeCallProperty = isObjectTypeCallProperty;
  exports.isObjectTypeIndexer = isObjectTypeIndexer;
  exports.isObjectTypeProperty = isObjectTypeProperty;
  exports.isObjectTypeSpreadProperty = isObjectTypeSpreadProperty;
  exports.isOpaqueType = isOpaqueType;
  exports.isQualifiedTypeIdentifier = isQualifiedTypeIdentifier;
  exports.isStringLiteralTypeAnnotation = isStringLiteralTypeAnnotation;
  exports.isStringTypeAnnotation = isStringTypeAnnotation;
  exports.isSymbolTypeAnnotation = isSymbolTypeAnnotation;
  exports.isThisTypeAnnotation = isThisTypeAnnotation;
  exports.isTupleTypeAnnotation = isTupleTypeAnnotation;
  exports.isTypeofTypeAnnotation = isTypeofTypeAnnotation;
  exports.isTypeAlias = isTypeAlias;
  exports.isTypeAnnotation = isTypeAnnotation;
  exports.isTypeCastExpression = isTypeCastExpression;
  exports.isTypeParameter = isTypeParameter;
  exports.isTypeParameterDeclaration = isTypeParameterDeclaration;
  exports.isTypeParameterInstantiation = isTypeParameterInstantiation;
  exports.isUnionTypeAnnotation = isUnionTypeAnnotation;
  exports.isVariance = isVariance;
  exports.isVoidTypeAnnotation = isVoidTypeAnnotation;
  exports.isEnumDeclaration = isEnumDeclaration;
  exports.isEnumBooleanBody = isEnumBooleanBody;
  exports.isEnumNumberBody = isEnumNumberBody;
  exports.isEnumStringBody = isEnumStringBody;
  exports.isEnumSymbolBody = isEnumSymbolBody;
  exports.isEnumBooleanMember = isEnumBooleanMember;
  exports.isEnumNumberMember = isEnumNumberMember;
  exports.isEnumStringMember = isEnumStringMember;
  exports.isEnumDefaultedMember = isEnumDefaultedMember;
  exports.isIndexedAccessType = isIndexedAccessType;
  exports.isOptionalIndexedAccessType = isOptionalIndexedAccessType;
  exports.isJSXAttribute = isJSXAttribute;
  exports.isJSXClosingElement = isJSXClosingElement;
  exports.isJSXElement = isJSXElement;
  exports.isJSXEmptyExpression = isJSXEmptyExpression;
  exports.isJSXExpressionContainer = isJSXExpressionContainer;
  exports.isJSXSpreadChild = isJSXSpreadChild;
  exports.isJSXIdentifier = isJSXIdentifier;
  exports.isJSXMemberExpression = isJSXMemberExpression;
  exports.isJSXNamespacedName = isJSXNamespacedName;
  exports.isJSXOpeningElement = isJSXOpeningElement;
  exports.isJSXSpreadAttribute = isJSXSpreadAttribute;
  exports.isJSXText = isJSXText;
  exports.isJSXFragment = isJSXFragment;
  exports.isJSXOpeningFragment = isJSXOpeningFragment;
  exports.isJSXClosingFragment = isJSXClosingFragment;
  exports.isNoop = isNoop;
  exports.isPlaceholder = isPlaceholder;
  exports.isV8IntrinsicIdentifier = isV8IntrinsicIdentifier;
  exports.isArgumentPlaceholder = isArgumentPlaceholder;
  exports.isBindExpression = isBindExpression;
  exports.isImportAttribute = isImportAttribute;
  exports.isDecorator = isDecorator;
  exports.isDoExpression = isDoExpression;
  exports.isExportDefaultSpecifier = isExportDefaultSpecifier;
  exports.isRecordExpression = isRecordExpression;
  exports.isTupleExpression = isTupleExpression;
  exports.isDecimalLiteral = isDecimalLiteral;
  exports.isStaticBlock = isStaticBlock;
  exports.isModuleExpression = isModuleExpression;
  exports.isTopicReference = isTopicReference;
  exports.isPipelineTopicExpression = isPipelineTopicExpression;
  exports.isPipelineBareFunction = isPipelineBareFunction;
  exports.isPipelinePrimaryTopicReference = isPipelinePrimaryTopicReference;
  exports.isTSParameterProperty = isTSParameterProperty;
  exports.isTSDeclareFunction = isTSDeclareFunction;
  exports.isTSDeclareMethod = isTSDeclareMethod;
  exports.isTSQualifiedName = isTSQualifiedName;
  exports.isTSCallSignatureDeclaration = isTSCallSignatureDeclaration;
  exports.isTSConstructSignatureDeclaration = isTSConstructSignatureDeclaration;
  exports.isTSPropertySignature = isTSPropertySignature;
  exports.isTSMethodSignature = isTSMethodSignature;
  exports.isTSIndexSignature = isTSIndexSignature;
  exports.isTSAnyKeyword = isTSAnyKeyword;
  exports.isTSBooleanKeyword = isTSBooleanKeyword;
  exports.isTSBigIntKeyword = isTSBigIntKeyword;
  exports.isTSIntrinsicKeyword = isTSIntrinsicKeyword;
  exports.isTSNeverKeyword = isTSNeverKeyword;
  exports.isTSNullKeyword = isTSNullKeyword;
  exports.isTSNumberKeyword = isTSNumberKeyword;
  exports.isTSObjectKeyword = isTSObjectKeyword;
  exports.isTSStringKeyword = isTSStringKeyword;
  exports.isTSSymbolKeyword = isTSSymbolKeyword;
  exports.isTSUndefinedKeyword = isTSUndefinedKeyword;
  exports.isTSUnknownKeyword = isTSUnknownKeyword;
  exports.isTSVoidKeyword = isTSVoidKeyword;
  exports.isTSThisType = isTSThisType;
  exports.isTSFunctionType = isTSFunctionType;
  exports.isTSConstructorType = isTSConstructorType;
  exports.isTSTypeReference = isTSTypeReference;
  exports.isTSTypePredicate = isTSTypePredicate;
  exports.isTSTypeQuery = isTSTypeQuery;
  exports.isTSTypeLiteral = isTSTypeLiteral;
  exports.isTSArrayType = isTSArrayType;
  exports.isTSTupleType = isTSTupleType;
  exports.isTSOptionalType = isTSOptionalType;
  exports.isTSRestType = isTSRestType;
  exports.isTSNamedTupleMember = isTSNamedTupleMember;
  exports.isTSUnionType = isTSUnionType;
  exports.isTSIntersectionType = isTSIntersectionType;
  exports.isTSConditionalType = isTSConditionalType;
  exports.isTSInferType = isTSInferType;
  exports.isTSParenthesizedType = isTSParenthesizedType;
  exports.isTSTypeOperator = isTSTypeOperator;
  exports.isTSIndexedAccessType = isTSIndexedAccessType;
  exports.isTSMappedType = isTSMappedType;
  exports.isTSLiteralType = isTSLiteralType;
  exports.isTSExpressionWithTypeArguments = isTSExpressionWithTypeArguments;
  exports.isTSInterfaceDeclaration = isTSInterfaceDeclaration;
  exports.isTSInterfaceBody = isTSInterfaceBody;
  exports.isTSTypeAliasDeclaration = isTSTypeAliasDeclaration;
  exports.isTSAsExpression = isTSAsExpression;
  exports.isTSTypeAssertion = isTSTypeAssertion;
  exports.isTSEnumDeclaration = isTSEnumDeclaration;
  exports.isTSEnumMember = isTSEnumMember;
  exports.isTSModuleDeclaration = isTSModuleDeclaration;
  exports.isTSModuleBlock = isTSModuleBlock;
  exports.isTSImportType = isTSImportType;
  exports.isTSImportEqualsDeclaration = isTSImportEqualsDeclaration;
  exports.isTSExternalModuleReference = isTSExternalModuleReference;
  exports.isTSNonNullExpression = isTSNonNullExpression;
  exports.isTSExportAssignment = isTSExportAssignment;
  exports.isTSNamespaceExportDeclaration = isTSNamespaceExportDeclaration;
  exports.isTSTypeAnnotation = isTSTypeAnnotation;
  exports.isTSTypeParameterInstantiation = isTSTypeParameterInstantiation;
  exports.isTSTypeParameterDeclaration = isTSTypeParameterDeclaration;
  exports.isTSTypeParameter = isTSTypeParameter;
  exports.isExpression = isExpression;
  exports.isBinary = isBinary;
  exports.isScopable = isScopable;
  exports.isBlockParent = isBlockParent;
  exports.isBlock = isBlock;
  exports.isStatement = isStatement;
  exports.isTerminatorless = isTerminatorless;
  exports.isCompletionStatement = isCompletionStatement;
  exports.isConditional = isConditional;
  exports.isLoop = isLoop;
  exports.isWhile = isWhile;
  exports.isExpressionWrapper = isExpressionWrapper;
  exports.isFor = isFor;
  exports.isForXStatement = isForXStatement;
  exports.isFunction = isFunction;
  exports.isFunctionParent = isFunctionParent;
  exports.isPureish = isPureish;
  exports.isDeclaration = isDeclaration;
  exports.isPatternLike = isPatternLike;
  exports.isLVal = isLVal;
  exports.isTSEntityName = isTSEntityName;
  exports.isLiteral = isLiteral;
  exports.isImmutable = isImmutable;
  exports.isUserWhitespacable = isUserWhitespacable;
  exports.isMethod = isMethod;
  exports.isObjectMember = isObjectMember;
  exports.isProperty = isProperty;
  exports.isUnaryLike = isUnaryLike;
  exports.isPattern = isPattern;
  exports.isClass = isClass;
  exports.isModuleDeclaration = isModuleDeclaration;
  exports.isExportDeclaration = isExportDeclaration;
  exports.isModuleSpecifier = isModuleSpecifier;
  exports.isPrivate = isPrivate;
  exports.isFlow = isFlow;
  exports.isFlowType = isFlowType;
  exports.isFlowBaseAnnotation = isFlowBaseAnnotation;
  exports.isFlowDeclaration = isFlowDeclaration;
  exports.isFlowPredicate = isFlowPredicate;
  exports.isEnumBody = isEnumBody;
  exports.isEnumMember = isEnumMember;
  exports.isJSX = isJSX;
  exports.isTSTypeElement = isTSTypeElement;
  exports.isTSType = isTSType;
  exports.isTSBaseType = isTSBaseType;
  exports.isNumberLiteral = isNumberLiteral;
  exports.isRegexLiteral = isRegexLiteral;
  exports.isRestProperty = isRestProperty;
  exports.isSpreadProperty = isSpreadProperty;
  
  var _shallowEqual = require("../../utils/shallowEqual");
  
  function isArrayExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ArrayExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isAssignmentExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "AssignmentExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBinaryExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BinaryExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isInterpreterDirective(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "InterpreterDirective") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDirective(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Directive") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDirectiveLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DirectiveLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBlockStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BlockStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBreakStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BreakStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isCallExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "CallExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isCatchClause(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "CatchClause") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isConditionalExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ConditionalExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isContinueStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ContinueStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDebuggerStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DebuggerStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDoWhileStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DoWhileStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEmptyStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EmptyStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExpressionStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExpressionStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFile(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "File") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isForInStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ForInStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isForStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ForStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunctionDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FunctionDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunctionExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FunctionExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isIdentifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Identifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isIfStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "IfStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isLabeledStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "LabeledStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isStringLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "StringLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNumericLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NumericLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNullLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NullLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBooleanLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BooleanLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isRegExpLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "RegExpLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isLogicalExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "LogicalExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isMemberExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "MemberExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNewExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NewExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isProgram(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Program") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectMethod(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectMethod") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isRestElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "RestElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isReturnStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ReturnStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSequenceExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SequenceExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isParenthesizedExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ParenthesizedExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSwitchCase(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SwitchCase") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSwitchStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SwitchStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isThisExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ThisExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isThrowStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ThrowStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTryStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TryStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isUnaryExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "UnaryExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isUpdateExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "UpdateExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isVariableDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "VariableDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isVariableDeclarator(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "VariableDeclarator") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isWhileStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "WhileStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isWithStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "WithStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isAssignmentPattern(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "AssignmentPattern") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isArrayPattern(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ArrayPattern") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isArrowFunctionExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ArrowFunctionExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportAllDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportAllDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportDefaultDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportDefaultDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportNamedDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportNamedDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isForOfStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ForOfStatement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImportDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ImportDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImportDefaultSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ImportDefaultSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImportNamespaceSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ImportNamespaceSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImportSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ImportSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isMetaProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "MetaProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassMethod(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassMethod") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectPattern(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectPattern") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSpreadElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SpreadElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSuper(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Super") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTaggedTemplateExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TaggedTemplateExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTemplateElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TemplateElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTemplateLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TemplateLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isYieldExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "YieldExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isAwaitExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "AwaitExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImport(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Import") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBigIntLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BigIntLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportNamespaceSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportNamespaceSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isOptionalMemberExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "OptionalMemberExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isOptionalCallExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "OptionalCallExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassPrivateProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassPrivateProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassPrivateMethod(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassPrivateMethod") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPrivateName(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "PrivateName") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isAnyTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "AnyTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isArrayTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ArrayTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBooleanTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BooleanTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBooleanLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BooleanLiteralTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNullLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NullLiteralTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClassImplements(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ClassImplements") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareClass(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareClass") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareFunction(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareFunction") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareInterface(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareInterface") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareModule(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareModule") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareModuleExports(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareModuleExports") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareTypeAlias(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareTypeAlias") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareOpaqueType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareOpaqueType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareVariable(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareVariable") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareExportDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareExportDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclareExportAllDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclareExportAllDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclaredPredicate(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DeclaredPredicate") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExistsTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExistsTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunctionTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FunctionTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunctionTypeParam(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "FunctionTypeParam") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isGenericTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "GenericTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isInferredPredicate(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "InferredPredicate") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isInterfaceExtends(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "InterfaceExtends") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isInterfaceDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "InterfaceDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isInterfaceTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "InterfaceTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isIntersectionTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "IntersectionTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isMixedTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "MixedTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEmptyTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EmptyTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNullableTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NullableTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNumberLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NumberLiteralTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNumberTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NumberTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeInternalSlot(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeInternalSlot") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeCallProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeCallProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeIndexer(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeIndexer") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectTypeSpreadProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ObjectTypeSpreadProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isOpaqueType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "OpaqueType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isQualifiedTypeIdentifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "QualifiedTypeIdentifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isStringLiteralTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "StringLiteralTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isStringTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "StringTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSymbolTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SymbolTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isThisTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ThisTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTupleTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TupleTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeofTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeofTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeAlias(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeAlias") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeCastExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeCastExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeParameter(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeParameter") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeParameterDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeParameterDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTypeParameterInstantiation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TypeParameterInstantiation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isUnionTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "UnionTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isVariance(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Variance") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isVoidTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "VoidTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumBooleanBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumBooleanBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumNumberBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumNumberBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumStringBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumStringBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumSymbolBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumSymbolBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumBooleanMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumBooleanMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumNumberMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumNumberMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumStringMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumStringMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumDefaultedMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "EnumDefaultedMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isIndexedAccessType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "IndexedAccessType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isOptionalIndexedAccessType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "OptionalIndexedAccessType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXAttribute(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXAttribute") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXClosingElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXClosingElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXEmptyExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXEmptyExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXExpressionContainer(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXExpressionContainer") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXSpreadChild(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXSpreadChild") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXIdentifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXIdentifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXMemberExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXMemberExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXNamespacedName(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXNamespacedName") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXOpeningElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXOpeningElement") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXSpreadAttribute(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXSpreadAttribute") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXText(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXText") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXFragment(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXFragment") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXOpeningFragment(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXOpeningFragment") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSXClosingFragment(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "JSXClosingFragment") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNoop(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Noop") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPlaceholder(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Placeholder") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isV8IntrinsicIdentifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "V8IntrinsicIdentifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isArgumentPlaceholder(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ArgumentPlaceholder") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBindExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "BindExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImportAttribute(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ImportAttribute") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDecorator(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "Decorator") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDoExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DoExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportDefaultSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ExportDefaultSpecifier") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isRecordExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "RecordExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTupleExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TupleExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDecimalLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "DecimalLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isStaticBlock(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "StaticBlock") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isModuleExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "ModuleExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTopicReference(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TopicReference") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPipelineTopicExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "PipelineTopicExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPipelineBareFunction(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "PipelineBareFunction") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPipelinePrimaryTopicReference(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "PipelinePrimaryTopicReference") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSParameterProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSParameterProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSDeclareFunction(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSDeclareFunction") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSDeclareMethod(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSDeclareMethod") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSQualifiedName(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSQualifiedName") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSCallSignatureDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSCallSignatureDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSConstructSignatureDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSConstructSignatureDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSPropertySignature(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSPropertySignature") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSMethodSignature(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSMethodSignature") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSIndexSignature(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSIndexSignature") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSAnyKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSAnyKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSBooleanKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSBooleanKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSBigIntKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSBigIntKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSIntrinsicKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSIntrinsicKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNeverKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNeverKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNullKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNullKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNumberKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNumberKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSObjectKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSObjectKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSStringKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSStringKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSSymbolKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSSymbolKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSUndefinedKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSUndefinedKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSUnknownKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSUnknownKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSVoidKeyword(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSVoidKeyword") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSThisType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSThisType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSFunctionType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSFunctionType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSConstructorType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSConstructorType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeReference(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeReference") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypePredicate(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypePredicate") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeQuery(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeQuery") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSArrayType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSArrayType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTupleType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTupleType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSOptionalType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSOptionalType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSRestType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSRestType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNamedTupleMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNamedTupleMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSUnionType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSUnionType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSIntersectionType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSIntersectionType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSConditionalType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSConditionalType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSInferType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSInferType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSParenthesizedType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSParenthesizedType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeOperator(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeOperator") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSIndexedAccessType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSIndexedAccessType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSMappedType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSMappedType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSLiteralType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSLiteralType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSExpressionWithTypeArguments(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSExpressionWithTypeArguments") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSInterfaceDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSInterfaceDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSInterfaceBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSInterfaceBody") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeAliasDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeAliasDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSAsExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSAsExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeAssertion(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeAssertion") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSEnumDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSEnumDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSEnumMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSEnumMember") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSModuleDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSModuleDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSModuleBlock(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSModuleBlock") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSImportType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSImportType") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSImportEqualsDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSImportEqualsDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSExternalModuleReference(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSExternalModuleReference") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNonNullExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNonNullExpression") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSExportAssignment(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSExportAssignment") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSNamespaceExportDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSNamespaceExportDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeAnnotation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeParameterInstantiation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeParameterInstantiation") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeParameterDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeParameterDeclaration") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeParameter(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "TSTypeParameter") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExpression(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ArrayExpression" === nodeType || "AssignmentExpression" === nodeType || "BinaryExpression" === nodeType || "CallExpression" === nodeType || "ConditionalExpression" === nodeType || "FunctionExpression" === nodeType || "Identifier" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "LogicalExpression" === nodeType || "MemberExpression" === nodeType || "NewExpression" === nodeType || "ObjectExpression" === nodeType || "SequenceExpression" === nodeType || "ParenthesizedExpression" === nodeType || "ThisExpression" === nodeType || "UnaryExpression" === nodeType || "UpdateExpression" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "MetaProperty" === nodeType || "Super" === nodeType || "TaggedTemplateExpression" === nodeType || "TemplateLiteral" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType || "Import" === nodeType || "BigIntLiteral" === nodeType || "OptionalMemberExpression" === nodeType || "OptionalCallExpression" === nodeType || "TypeCastExpression" === nodeType || "JSXElement" === nodeType || "JSXFragment" === nodeType || "BindExpression" === nodeType || "DoExpression" === nodeType || "RecordExpression" === nodeType || "TupleExpression" === nodeType || "DecimalLiteral" === nodeType || "ModuleExpression" === nodeType || "TopicReference" === nodeType || "PipelineTopicExpression" === nodeType || "PipelineBareFunction" === nodeType || "PipelinePrimaryTopicReference" === nodeType || "TSAsExpression" === nodeType || "TSTypeAssertion" === nodeType || "TSNonNullExpression" === nodeType || nodeType === "Placeholder" && ("Expression" === node.expectedNode || "Identifier" === node.expectedNode || "StringLiteral" === node.expectedNode)) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBinary(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("BinaryExpression" === nodeType || "LogicalExpression" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isScopable(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassExpression" === nodeType || "ClassDeclaration" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "StaticBlock" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBlockParent(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("BlockStatement" === nodeType || "CatchClause" === nodeType || "DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "Program" === nodeType || "ObjectMethod" === nodeType || "SwitchStatement" === nodeType || "WhileStatement" === nodeType || "ArrowFunctionExpression" === nodeType || "ForOfStatement" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType || "StaticBlock" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isBlock(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("BlockStatement" === nodeType || "Program" === nodeType || "TSModuleBlock" === nodeType || nodeType === "Placeholder" && "BlockStatement" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("BlockStatement" === nodeType || "BreakStatement" === nodeType || "ContinueStatement" === nodeType || "DebuggerStatement" === nodeType || "DoWhileStatement" === nodeType || "EmptyStatement" === nodeType || "ExpressionStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "FunctionDeclaration" === nodeType || "IfStatement" === nodeType || "LabeledStatement" === nodeType || "ReturnStatement" === nodeType || "SwitchStatement" === nodeType || "ThrowStatement" === nodeType || "TryStatement" === nodeType || "VariableDeclaration" === nodeType || "WhileStatement" === nodeType || "WithStatement" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ForOfStatement" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "EnumDeclaration" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || "TSImportEqualsDeclaration" === nodeType || "TSExportAssignment" === nodeType || "TSNamespaceExportDeclaration" === nodeType || nodeType === "Placeholder" && ("Statement" === node.expectedNode || "Declaration" === node.expectedNode || "BlockStatement" === node.expectedNode)) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTerminatorless(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType || "YieldExpression" === nodeType || "AwaitExpression" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isCompletionStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("BreakStatement" === nodeType || "ContinueStatement" === nodeType || "ReturnStatement" === nodeType || "ThrowStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isConditional(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ConditionalExpression" === nodeType || "IfStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isLoop(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("DoWhileStatement" === nodeType || "ForInStatement" === nodeType || "ForStatement" === nodeType || "WhileStatement" === nodeType || "ForOfStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isWhile(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("DoWhileStatement" === nodeType || "WhileStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExpressionWrapper(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ExpressionStatement" === nodeType || "ParenthesizedExpression" === nodeType || "TypeCastExpression" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFor(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ForInStatement" === nodeType || "ForStatement" === nodeType || "ForOfStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isForXStatement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ForInStatement" === nodeType || "ForOfStatement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunction(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFunctionParent(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "ObjectMethod" === nodeType || "ArrowFunctionExpression" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPureish(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("FunctionDeclaration" === nodeType || "FunctionExpression" === nodeType || "StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "ArrowFunctionExpression" === nodeType || "BigIntLiteral" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("FunctionDeclaration" === nodeType || "VariableDeclaration" === nodeType || "ClassDeclaration" === nodeType || "ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType || "EnumDeclaration" === nodeType || "TSDeclareFunction" === nodeType || "TSInterfaceDeclaration" === nodeType || "TSTypeAliasDeclaration" === nodeType || "TSEnumDeclaration" === nodeType || "TSModuleDeclaration" === nodeType || nodeType === "Placeholder" && "Declaration" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPatternLike(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("Identifier" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || nodeType === "Placeholder" && ("Pattern" === node.expectedNode || "Identifier" === node.expectedNode)) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isLVal(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("Identifier" === nodeType || "MemberExpression" === nodeType || "RestElement" === nodeType || "AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || "TSParameterProperty" === nodeType || nodeType === "Placeholder" && ("Pattern" === node.expectedNode || "Identifier" === node.expectedNode)) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSEntityName(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("Identifier" === nodeType || "TSQualifiedName" === nodeType || nodeType === "Placeholder" && "Identifier" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isLiteral(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "RegExpLiteral" === nodeType || "TemplateLiteral" === nodeType || "BigIntLiteral" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isImmutable(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("StringLiteral" === nodeType || "NumericLiteral" === nodeType || "NullLiteral" === nodeType || "BooleanLiteral" === nodeType || "BigIntLiteral" === nodeType || "JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXOpeningElement" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType || "DecimalLiteral" === nodeType || nodeType === "Placeholder" && "StringLiteral" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isUserWhitespacable(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ObjectMethod" === nodeType || "ObjectProperty" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isMethod(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ObjectMethod" === nodeType || "ClassMethod" === nodeType || "ClassPrivateMethod" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isObjectMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ObjectMethod" === nodeType || "ObjectProperty" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isProperty(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ObjectProperty" === nodeType || "ClassProperty" === nodeType || "ClassPrivateProperty" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isUnaryLike(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("UnaryExpression" === nodeType || "SpreadElement" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPattern(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("AssignmentPattern" === nodeType || "ArrayPattern" === nodeType || "ObjectPattern" === nodeType || nodeType === "Placeholder" && "Pattern" === node.expectedNode) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isClass(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ClassExpression" === nodeType || "ClassDeclaration" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isModuleDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType || "ImportDeclaration" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isExportDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ExportAllDeclaration" === nodeType || "ExportDefaultDeclaration" === nodeType || "ExportNamedDeclaration" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isModuleSpecifier(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ExportSpecifier" === nodeType || "ImportDefaultSpecifier" === nodeType || "ImportNamespaceSpecifier" === nodeType || "ImportSpecifier" === nodeType || "ExportNamespaceSpecifier" === nodeType || "ExportDefaultSpecifier" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isPrivate(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("ClassPrivateProperty" === nodeType || "ClassPrivateMethod" === nodeType || "PrivateName" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFlow(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ClassImplements" === nodeType || "DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "DeclaredPredicate" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "FunctionTypeParam" === nodeType || "GenericTypeAnnotation" === nodeType || "InferredPredicate" === nodeType || "InterfaceExtends" === nodeType || "InterfaceDeclaration" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "ObjectTypeInternalSlot" === nodeType || "ObjectTypeCallProperty" === nodeType || "ObjectTypeIndexer" === nodeType || "ObjectTypeProperty" === nodeType || "ObjectTypeSpreadProperty" === nodeType || "OpaqueType" === nodeType || "QualifiedTypeIdentifier" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "TypeAlias" === nodeType || "TypeAnnotation" === nodeType || "TypeCastExpression" === nodeType || "TypeParameter" === nodeType || "TypeParameterDeclaration" === nodeType || "TypeParameterInstantiation" === nodeType || "UnionTypeAnnotation" === nodeType || "Variance" === nodeType || "VoidTypeAnnotation" === nodeType || "IndexedAccessType" === nodeType || "OptionalIndexedAccessType" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFlowType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("AnyTypeAnnotation" === nodeType || "ArrayTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "BooleanLiteralTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "ExistsTypeAnnotation" === nodeType || "FunctionTypeAnnotation" === nodeType || "GenericTypeAnnotation" === nodeType || "InterfaceTypeAnnotation" === nodeType || "IntersectionTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NullableTypeAnnotation" === nodeType || "NumberLiteralTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "ObjectTypeAnnotation" === nodeType || "StringLiteralTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "TupleTypeAnnotation" === nodeType || "TypeofTypeAnnotation" === nodeType || "UnionTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType || "IndexedAccessType" === nodeType || "OptionalIndexedAccessType" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFlowBaseAnnotation(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("AnyTypeAnnotation" === nodeType || "BooleanTypeAnnotation" === nodeType || "NullLiteralTypeAnnotation" === nodeType || "MixedTypeAnnotation" === nodeType || "EmptyTypeAnnotation" === nodeType || "NumberTypeAnnotation" === nodeType || "StringTypeAnnotation" === nodeType || "SymbolTypeAnnotation" === nodeType || "ThisTypeAnnotation" === nodeType || "VoidTypeAnnotation" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFlowDeclaration(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("DeclareClass" === nodeType || "DeclareFunction" === nodeType || "DeclareInterface" === nodeType || "DeclareModule" === nodeType || "DeclareModuleExports" === nodeType || "DeclareTypeAlias" === nodeType || "DeclareOpaqueType" === nodeType || "DeclareVariable" === nodeType || "DeclareExportDeclaration" === nodeType || "DeclareExportAllDeclaration" === nodeType || "InterfaceDeclaration" === nodeType || "OpaqueType" === nodeType || "TypeAlias" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isFlowPredicate(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("DeclaredPredicate" === nodeType || "InferredPredicate" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumBody(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("EnumBooleanBody" === nodeType || "EnumNumberBody" === nodeType || "EnumStringBody" === nodeType || "EnumSymbolBody" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isEnumMember(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("EnumBooleanMember" === nodeType || "EnumNumberMember" === nodeType || "EnumStringMember" === nodeType || "EnumDefaultedMember" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isJSX(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("JSXAttribute" === nodeType || "JSXClosingElement" === nodeType || "JSXElement" === nodeType || "JSXEmptyExpression" === nodeType || "JSXExpressionContainer" === nodeType || "JSXSpreadChild" === nodeType || "JSXIdentifier" === nodeType || "JSXMemberExpression" === nodeType || "JSXNamespacedName" === nodeType || "JSXOpeningElement" === nodeType || "JSXSpreadAttribute" === nodeType || "JSXText" === nodeType || "JSXFragment" === nodeType || "JSXOpeningFragment" === nodeType || "JSXClosingFragment" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSTypeElement(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("TSCallSignatureDeclaration" === nodeType || "TSConstructSignatureDeclaration" === nodeType || "TSPropertySignature" === nodeType || "TSMethodSignature" === nodeType || "TSIndexSignature" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSIntrinsicKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSFunctionType" === nodeType || "TSConstructorType" === nodeType || "TSTypeReference" === nodeType || "TSTypePredicate" === nodeType || "TSTypeQuery" === nodeType || "TSTypeLiteral" === nodeType || "TSArrayType" === nodeType || "TSTupleType" === nodeType || "TSOptionalType" === nodeType || "TSRestType" === nodeType || "TSUnionType" === nodeType || "TSIntersectionType" === nodeType || "TSConditionalType" === nodeType || "TSInferType" === nodeType || "TSParenthesizedType" === nodeType || "TSTypeOperator" === nodeType || "TSIndexedAccessType" === nodeType || "TSMappedType" === nodeType || "TSLiteralType" === nodeType || "TSExpressionWithTypeArguments" === nodeType || "TSImportType" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isTSBaseType(node, opts) {
    if (!node) return false;
    const nodeType = node.type;
  
    if ("TSAnyKeyword" === nodeType || "TSBooleanKeyword" === nodeType || "TSBigIntKeyword" === nodeType || "TSIntrinsicKeyword" === nodeType || "TSNeverKeyword" === nodeType || "TSNullKeyword" === nodeType || "TSNumberKeyword" === nodeType || "TSObjectKeyword" === nodeType || "TSStringKeyword" === nodeType || "TSSymbolKeyword" === nodeType || "TSUndefinedKeyword" === nodeType || "TSUnknownKeyword" === nodeType || "TSVoidKeyword" === nodeType || "TSThisType" === nodeType || "TSLiteralType" === nodeType) {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isNumberLiteral(node, opts) {
    console.trace("The node type NumberLiteral has been renamed to NumericLiteral");
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "NumberLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isRegexLiteral(node, opts) {
    console.trace("The node type RegexLiteral has been renamed to RegExpLiteral");
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "RegexLiteral") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isRestProperty(node, opts) {
    console.trace("The node type RestProperty has been renamed to RestElement");
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "RestProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  
  function isSpreadProperty(node, opts) {
    console.trace("The node type SpreadProperty has been renamed to SpreadElement");
    if (!node) return false;
    const nodeType = node.type;
  
    if (nodeType === "SpreadProperty") {
      if (typeof opts === "undefined") {
        return true;
      } else {
        return (0, _shallowEqual.default)(node, opts);
      }
    }
  
    return false;
  }
  },{"../../utils/shallowEqual":88}],91:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = is;
  
  var _shallowEqual = require("../utils/shallowEqual");
  
  var _isType = require("./isType");
  
  var _isPlaceholderType = require("./isPlaceholderType");
  
  var _definitions = require("../definitions");
  
  function is(type, node, opts) {
    if (!node) return false;
    const matches = (0, _isType.default)(node.type, type);
  
    if (!matches) {
      if (!opts && node.type === "Placeholder" && type in _definitions.FLIPPED_ALIAS_KEYS) {
        return (0, _isPlaceholderType.default)(node.expectedNode, type);
      }
  
      return false;
    }
  
    if (typeof opts === "undefined") {
      return true;
    } else {
      return (0, _shallowEqual.default)(node, opts);
    }
  }
  },{"../definitions":68,"../utils/shallowEqual":88,"./isPlaceholderType":98,"./isType":102}],92:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isBinding;
  
  var _getBindingIdentifiers = require("../retrievers/getBindingIdentifiers");
  
  function isBinding(node, parent, grandparent) {
    if (grandparent && node.type === "Identifier" && parent.type === "ObjectProperty" && grandparent.type === "ObjectExpression") {
      return false;
    }
  
    const keys = _getBindingIdentifiers.default.keys[parent.type];
  
    if (keys) {
      for (let i = 0; i < keys.length; i++) {
        const key = keys[i];
        const val = parent[key];
  
        if (Array.isArray(val)) {
          if (val.indexOf(node) >= 0) return true;
        } else {
          if (val === node) return true;
        }
      }
    }
  
    return false;
  }
  },{"../retrievers/getBindingIdentifiers":82}],93:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isBlockScoped;
  
  var _generated = require("./generated");
  
  var _isLet = require("./isLet");
  
  function isBlockScoped(node) {
    return (0, _generated.isFunctionDeclaration)(node) || (0, _generated.isClassDeclaration)(node) || (0, _isLet.default)(node);
  }
  },{"./generated":90,"./isLet":95}],94:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isImmutable;
  
  var _isType = require("./isType");
  
  var _generated = require("./generated");
  
  function isImmutable(node) {
    if ((0, _isType.default)(node.type, "Immutable")) return true;
  
    if ((0, _generated.isIdentifier)(node)) {
      if (node.name === "undefined") {
        return true;
      } else {
        return false;
      }
    }
  
    return false;
  }
  },{"./generated":90,"./isType":102}],95:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isLet;
  
  var _generated = require("./generated");
  
  var _constants = require("../constants");
  
  function isLet(node) {
    return (0, _generated.isVariableDeclaration)(node) && (node.kind !== "var" || node[_constants.BLOCK_SCOPED_SYMBOL]);
  }
  },{"../constants":53,"./generated":90}],96:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isNode;
  
  var _definitions = require("../definitions");
  
  function isNode(node) {
    return !!(node && _definitions.VISITOR_KEYS[node.type]);
  }
  },{"../definitions":68}],97:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isNodesEquivalent;
  
  var _definitions = require("../definitions");
  
  function isNodesEquivalent(a, b) {
    if (typeof a !== "object" || typeof b !== "object" || a == null || b == null) {
      return a === b;
    }
  
    if (a.type !== b.type) {
      return false;
    }
  
    const fields = Object.keys(_definitions.NODE_FIELDS[a.type] || a.type);
    const visitorKeys = _definitions.VISITOR_KEYS[a.type];
  
    for (const field of fields) {
      if (typeof a[field] !== typeof b[field]) {
        return false;
      }
  
      if (a[field] == null && b[field] == null) {
        continue;
      } else if (a[field] == null || b[field] == null) {
        return false;
      }
  
      if (Array.isArray(a[field])) {
        if (!Array.isArray(b[field])) {
          return false;
        }
  
        if (a[field].length !== b[field].length) {
          return false;
        }
  
        for (let i = 0; i < a[field].length; i++) {
          if (!isNodesEquivalent(a[field][i], b[field][i])) {
            return false;
          }
        }
  
        continue;
      }
  
      if (typeof a[field] === "object" && !(visitorKeys != null && visitorKeys.includes(field))) {
        for (const key of Object.keys(a[field])) {
          if (a[field][key] !== b[field][key]) {
            return false;
          }
        }
  
        continue;
      }
  
      if (!isNodesEquivalent(a[field], b[field])) {
        return false;
      }
    }
  
    return true;
  }
  },{"../definitions":68}],98:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isPlaceholderType;
  
  var _definitions = require("../definitions");
  
  function isPlaceholderType(placeholderType, targetType) {
    if (placeholderType === targetType) return true;
    const aliases = _definitions.PLACEHOLDERS_ALIAS[placeholderType];
  
    if (aliases) {
      for (const alias of aliases) {
        if (targetType === alias) return true;
      }
    }
  
    return false;
  }
  },{"../definitions":68}],99:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isReferenced;
  
  function isReferenced(node, parent, grandparent) {
    switch (parent.type) {
      case "MemberExpression":
      case "OptionalMemberExpression":
        if (parent.property === node) {
          return !!parent.computed;
        }
  
        return parent.object === node;
  
      case "JSXMemberExpression":
        return parent.object === node;
  
      case "VariableDeclarator":
        return parent.init === node;
  
      case "ArrowFunctionExpression":
        return parent.body === node;
  
      case "PrivateName":
        return false;
  
      case "ClassMethod":
      case "ClassPrivateMethod":
      case "ObjectMethod":
        if (parent.key === node) {
          return !!parent.computed;
        }
  
        return false;
  
      case "ObjectProperty":
        if (parent.key === node) {
          return !!parent.computed;
        }
  
        return !grandparent || grandparent.type !== "ObjectPattern";
  
      case "ClassProperty":
        if (parent.key === node) {
          return !!parent.computed;
        }
  
        return true;
  
      case "ClassPrivateProperty":
        return parent.key !== node;
  
      case "ClassDeclaration":
      case "ClassExpression":
        return parent.superClass === node;
  
      case "AssignmentExpression":
        return parent.right === node;
  
      case "AssignmentPattern":
        return parent.right === node;
  
      case "LabeledStatement":
        return false;
  
      case "CatchClause":
        return false;
  
      case "RestElement":
        return false;
  
      case "BreakStatement":
      case "ContinueStatement":
        return false;
  
      case "FunctionDeclaration":
      case "FunctionExpression":
        return false;
  
      case "ExportNamespaceSpecifier":
      case "ExportDefaultSpecifier":
        return false;
  
      case "ExportSpecifier":
        if (grandparent != null && grandparent.source) {
          return false;
        }
  
        return parent.local === node;
  
      case "ImportDefaultSpecifier":
      case "ImportNamespaceSpecifier":
      case "ImportSpecifier":
        return false;
  
      case "ImportAttribute":
        return false;
  
      case "JSXAttribute":
        return false;
  
      case "ObjectPattern":
      case "ArrayPattern":
        return false;
  
      case "MetaProperty":
        return false;
  
      case "ObjectTypeProperty":
        return parent.key !== node;
  
      case "TSEnumMember":
        return parent.id !== node;
  
      case "TSPropertySignature":
        if (parent.key === node) {
          return !!parent.computed;
        }
  
        return true;
    }
  
    return true;
  }
  },{}],100:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isScope;
  
  var _generated = require("./generated");
  
  function isScope(node, parent) {
    if ((0, _generated.isBlockStatement)(node) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) {
      return false;
    }
  
    if ((0, _generated.isPattern)(node) && ((0, _generated.isFunction)(parent) || (0, _generated.isCatchClause)(parent))) {
      return true;
    }
  
    return (0, _generated.isScopable)(node);
  }
  },{"./generated":90}],101:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isSpecifierDefault;
  
  var _generated = require("./generated");
  
  function isSpecifierDefault(specifier) {
    return (0, _generated.isImportDefaultSpecifier)(specifier) || (0, _generated.isIdentifier)(specifier.imported || specifier.exported, {
      name: "default"
    });
  }
  },{"./generated":90}],102:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isType;
  
  var _definitions = require("../definitions");
  
  function isType(nodeType, targetType) {
    if (nodeType === targetType) return true;
    if (_definitions.ALIAS_KEYS[targetType]) return false;
    const aliases = _definitions.FLIPPED_ALIAS_KEYS[targetType];
  
    if (aliases) {
      if (aliases[0] === nodeType) return true;
  
      for (const alias of aliases) {
        if (nodeType === alias) return true;
      }
    }
  
    return false;
  }
  },{"../definitions":68}],103:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isValidES3Identifier;
  
  var _isValidIdentifier = require("./isValidIdentifier");
  
  const RESERVED_WORDS_ES3_ONLY = new Set(["abstract", "boolean", "byte", "char", "double", "enum", "final", "float", "goto", "implements", "int", "interface", "long", "native", "package", "private", "protected", "public", "short", "static", "synchronized", "throws", "transient", "volatile"]);
  
  function isValidES3Identifier(name) {
    return (0, _isValidIdentifier.default)(name) && !RESERVED_WORDS_ES3_ONLY.has(name);
  }
  },{"./isValidIdentifier":104}],104:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isValidIdentifier;
  
  var _helperValidatorIdentifier = require("@babel/helper-validator-identifier");
  
  function isValidIdentifier(name, reserved = true) {
    if (typeof name !== "string") return false;
  
    if (reserved) {
      if ((0, _helperValidatorIdentifier.isKeyword)(name) || (0, _helperValidatorIdentifier.isStrictReservedWord)(name, true)) {
        return false;
      }
    }
  
    return (0, _helperValidatorIdentifier.isIdentifierName)(name);
  }
  },{"@babel/helper-validator-identifier":28}],105:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isVar;
  
  var _generated = require("./generated");
  
  var _constants = require("../constants");
  
  function isVar(node) {
    return (0, _generated.isVariableDeclaration)(node, {
      kind: "var"
    }) && !node[_constants.BLOCK_SCOPED_SYMBOL];
  }
  },{"../constants":53,"./generated":90}],106:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = matchesPattern;
  
  var _generated = require("./generated");
  
  function matchesPattern(member, match, allowPartial) {
    if (!(0, _generated.isMemberExpression)(member)) return false;
    const parts = Array.isArray(match) ? match : match.split(".");
    const nodes = [];
    let node;
  
    for (node = member; (0, _generated.isMemberExpression)(node); node = node.object) {
      nodes.push(node.property);
    }
  
    nodes.push(node);
    if (nodes.length < parts.length) return false;
    if (!allowPartial && nodes.length > parts.length) return false;
  
    for (let i = 0, j = nodes.length - 1; i < parts.length; i++, j--) {
      const node = nodes[j];
      let value;
  
      if ((0, _generated.isIdentifier)(node)) {
        value = node.name;
      } else if ((0, _generated.isStringLiteral)(node)) {
        value = node.value;
      } else if ((0, _generated.isThisExpression)(node)) {
        value = "this";
      } else {
        return false;
      }
  
      if (parts[i] !== value) return false;
    }
  
    return true;
  }
  },{"./generated":90}],107:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = isCompatTag;
  
  function isCompatTag(tagName) {
    return !!tagName && /^[a-z]/.test(tagName);
  }
  },{}],108:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = void 0;
  
  var _buildMatchMemberExpression = require("../buildMatchMemberExpression");
  
  const isReactComponent = (0, _buildMatchMemberExpression.default)("React.Component");
  var _default = isReactComponent;
  exports.default = _default;
  },{"../buildMatchMemberExpression":89}],109:[function(require,module,exports){
  "use strict";
  
  Object.defineProperty(exports, "__esModule", {
    value: true
  });
  exports.default = validate;
  exports.validateField = validateField;
  exports.validateChild = validateChild;
  
  var _definitions = require("../definitions");
  
  function validate(node, key, val) {
    if (!node) return;
    const fields = _definitions.NODE_FIELDS[node.type];
    if (!fields) return;
    const field = fields[key];
    validateField(node, key, val, field);
    validateChild(node, key, val);
  }
  
  function validateField(node, key, val, field) {
    if (!(field != null && field.validate)) return;
    if (field.optional && val == null) return;
    field.validate(node, key, val);
  }
  
  function validateChild(node, key, val) {
    if (val == null) return;
    const validate = _definitions.NODE_PARENT_VALIDATIONS[val.type];
    if (!validate) return;
    validate(node, key, val);
  }
  },{"../definitions":68}],110:[function(require,module,exports){
  'use strict'
  
  exports.byteLength = byteLength
  exports.toByteArray = toByteArray
  exports.fromByteArray = fromByteArray
  
  var lookup = []
  var revLookup = []
  var Arr = typeof Uint8Array !== 'undefined' ? Uint8Array : Array
  
  var code = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/'
  for (var i = 0, len = code.length; i < len; ++i) {
    lookup[i] = code[i]
    revLookup[code.charCodeAt(i)] = i
  }
  
  // Support decoding URL-safe base64 strings, as Node.js does.
  // See: https://en.wikipedia.org/wiki/Base64#URL_applications
  revLookup['-'.charCodeAt(0)] = 62
  revLookup['_'.charCodeAt(0)] = 63
  
  function getLens (b64) {
    var len = b64.length
  
    if (len % 4 > 0) {
      throw new Error('Invalid string. Length must be a multiple of 4')
    }
  
    // Trim off extra bytes after placeholder bytes are found
    // See: https://github.com/beatgammit/base64-js/issues/42
    var validLen = b64.indexOf('=')
    if (validLen === -1) validLen = len
  
    var placeHoldersLen = validLen === len
      ? 0
      : 4 - (validLen % 4)
  
    return [validLen, placeHoldersLen]
  }
  
  // base64 is 4/3 + up to two characters of the original data
  function byteLength (b64) {
    var lens = getLens(b64)
    var validLen = lens[0]
    var placeHoldersLen = lens[1]
    return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
  }
  
  function _byteLength (b64, validLen, placeHoldersLen) {
    return ((validLen + placeHoldersLen) * 3 / 4) - placeHoldersLen
  }
  
  function toByteArray (b64) {
    var tmp
    var lens = getLens(b64)
    var validLen = lens[0]
    var placeHoldersLen = lens[1]
  
    var arr = new Arr(_byteLength(b64, validLen, placeHoldersLen))
  
    var curByte = 0
  
    // if there are placeholders, only get up to the last complete 4 chars
    var len = placeHoldersLen > 0
      ? validLen - 4
      : validLen
  
    var i
    for (i = 0; i < len; i += 4) {
      tmp =
        (revLookup[b64.charCodeAt(i)] << 18) |
        (revLookup[b64.charCodeAt(i + 1)] << 12) |
        (revLookup[b64.charCodeAt(i + 2)] << 6) |
        revLookup[b64.charCodeAt(i + 3)]
      arr[curByte++] = (tmp >> 16) & 0xFF
      arr[curByte++] = (tmp >> 8) & 0xFF
      arr[curByte++] = tmp & 0xFF
    }
  
    if (placeHoldersLen === 2) {
      tmp =
        (revLookup[b64.charCodeAt(i)] << 2) |
        (revLookup[b64.charCodeAt(i + 1)] >> 4)
      arr[curByte++] = tmp & 0xFF
    }
  
    if (placeHoldersLen === 1) {
      tmp =
        (revLookup[b64.charCodeAt(i)] << 10) |
        (revLookup[b64.charCodeAt(i + 1)] << 4) |
        (revLookup[b64.charCodeAt(i + 2)] >> 2)
      arr[curByte++] = (tmp >> 8) & 0xFF
      arr[curByte++] = tmp & 0xFF
    }
  
    return arr
  }
  
  function tripletToBase64 (num) {
    return lookup[num >> 18 & 0x3F] +
      lookup[num >> 12 & 0x3F] +
      lookup[num >> 6 & 0x3F] +
      lookup[num & 0x3F]
  }
  
  function encodeChunk (uint8, start, end) {
    var tmp
    var output = []
    for (var i = start; i < end; i += 3) {
      tmp =
        ((uint8[i] << 16) & 0xFF0000) +
        ((uint8[i + 1] << 8) & 0xFF00) +
        (uint8[i + 2] & 0xFF)
      output.push(tripletToBase64(tmp))
    }
    return output.join('')
  }
  
  function fromByteArray (uint8) {
    var tmp
    var len = uint8.length
    var extraBytes = len % 3 // if we have 1 byte left, pad 2 bytes
    var parts = []
    var maxChunkLength = 16383 // must be multiple of 3
  
    // go through the array every three bytes, we'll deal with trailing stuff later
    for (var i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
      parts.push(encodeChunk(
        uint8, i, (i + maxChunkLength) > len2 ? len2 : (i + maxChunkLength)
      ))
    }
  
    // pad the end with zeros, but make sure to not forget the extra bytes
    if (extraBytes === 1) {
      tmp = uint8[len - 1]
      parts.push(
        lookup[tmp >> 2] +
        lookup[(tmp << 4) & 0x3F] +
        '=='
      )
    } else if (extraBytes === 2) {
      tmp = (uint8[len - 2] << 8) + uint8[len - 1]
      parts.push(
        lookup[tmp >> 10] +
        lookup[(tmp >> 4) & 0x3F] +
        lookup[(tmp << 2) & 0x3F] +
        '='
      )
    }
  
    return parts.join('')
  }
  
  },{}],111:[function(require,module,exports){
  (function (Buffer){
  /*!
   * The buffer module from node.js, for the browser.
   *
   * @author   Feross Aboukhadijeh <https://feross.org>
   * @license  MIT
   */
  /* eslint-disable no-proto */
  
  'use strict'
  
  var base64 = require('base64-js')
  var ieee754 = require('ieee754')
  
  exports.Buffer = Buffer
  exports.SlowBuffer = SlowBuffer
  exports.INSPECT_MAX_BYTES = 50
  
  var K_MAX_LENGTH = 0x7fffffff
  exports.kMaxLength = K_MAX_LENGTH
  
  /**
   * If `Buffer.TYPED_ARRAY_SUPPORT`:
   *   === true    Use Uint8Array implementation (fastest)
   *   === false   Print warning and recommend using `buffer` v4.x which has an Object
   *               implementation (most compatible, even IE6)
   *
   * Browsers that support typed arrays are IE 10+, Firefox 4+, Chrome 7+, Safari 5.1+,
   * Opera 11.6+, iOS 4.2+.
   *
   * We report that the browser does not support typed arrays if the are not subclassable
   * using __proto__. Firefox 4-29 lacks support for adding new properties to `Uint8Array`
   * (See: https://bugzilla.mozilla.org/show_bug.cgi?id=695438). IE 10 lacks support
   * for __proto__ and has a buggy typed array implementation.
   */
  Buffer.TYPED_ARRAY_SUPPORT = typedArraySupport()
  
  if (!Buffer.TYPED_ARRAY_SUPPORT && typeof console !== 'undefined' &&
      typeof console.error === 'function') {
    console.error(
      'This browser lacks typed array (Uint8Array) support which is required by ' +
      '`buffer` v5.x. Use `buffer` v4.x if you require old browser support.'
    )
  }
  
  function typedArraySupport () {
    // Can typed array instances can be augmented?
    try {
      var arr = new Uint8Array(1)
      arr.__proto__ = { __proto__: Uint8Array.prototype, foo: function () { return 42 } }
      return arr.foo() === 42
    } catch (e) {
      return false
    }
  }
  
  Object.defineProperty(Buffer.prototype, 'parent', {
    enumerable: true,
    get: function () {
      if (!Buffer.isBuffer(this)) return undefined
      return this.buffer
    }
  })
  
  Object.defineProperty(Buffer.prototype, 'offset', {
    enumerable: true,
    get: function () {
      if (!Buffer.isBuffer(this)) return undefined
      return this.byteOffset
    }
  })
  
  function createBuffer (length) {
    if (length > K_MAX_LENGTH) {
      throw new RangeError('The value "' + length + '" is invalid for option "size"')
    }
    // Return an augmented `Uint8Array` instance
    var buf = new Uint8Array(length)
    buf.__proto__ = Buffer.prototype
    return buf
  }
  
  /**
   * The Buffer constructor returns instances of `Uint8Array` that have their
   * prototype changed to `Buffer.prototype`. Furthermore, `Buffer` is a subclass of
   * `Uint8Array`, so the returned instances will have all the node `Buffer` methods
   * and the `Uint8Array` methods. Square bracket notation works as expected -- it
   * returns a single octet.
   *
   * The `Uint8Array` prototype remains unmodified.
   */
  
  function Buffer (arg, encodingOrOffset, length) {
    // Common case.
    if (typeof arg === 'number') {
      if (typeof encodingOrOffset === 'string') {
        throw new TypeError(
          'The "string" argument must be of type string. Received type number'
        )
      }
      return allocUnsafe(arg)
    }
    return from(arg, encodingOrOffset, length)
  }
  
  // Fix subarray() in ES2016. See: https://github.com/feross/buffer/pull/97
  if (typeof Symbol !== 'undefined' && Symbol.species != null &&
      Buffer[Symbol.species] === Buffer) {
    Object.defineProperty(Buffer, Symbol.species, {
      value: null,
      configurable: true,
      enumerable: false,
      writable: false
    })
  }
  
  Buffer.poolSize = 8192 // not used by this implementation
  
  function from (value, encodingOrOffset, length) {
    if (typeof value === 'string') {
      return fromString(value, encodingOrOffset)
    }
  
    if (ArrayBuffer.isView(value)) {
      return fromArrayLike(value)
    }
  
    if (value == null) {
      throw TypeError(
        'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
        'or Array-like Object. Received type ' + (typeof value)
      )
    }
  
    if (isInstance(value, ArrayBuffer) ||
        (value && isInstance(value.buffer, ArrayBuffer))) {
      return fromArrayBuffer(value, encodingOrOffset, length)
    }
  
    if (typeof value === 'number') {
      throw new TypeError(
        'The "value" argument must not be of type number. Received type number'
      )
    }
  
    var valueOf = value.valueOf && value.valueOf()
    if (valueOf != null && valueOf !== value) {
      return Buffer.from(valueOf, encodingOrOffset, length)
    }
  
    var b = fromObject(value)
    if (b) return b
  
    if (typeof Symbol !== 'undefined' && Symbol.toPrimitive != null &&
        typeof value[Symbol.toPrimitive] === 'function') {
      return Buffer.from(
        value[Symbol.toPrimitive]('string'), encodingOrOffset, length
      )
    }
  
    throw new TypeError(
      'The first argument must be one of type string, Buffer, ArrayBuffer, Array, ' +
      'or Array-like Object. Received type ' + (typeof value)
    )
  }
  
  /**
   * Functionally equivalent to Buffer(arg, encoding) but throws a TypeError
   * if value is a number.
   * Buffer.from(str[, encoding])
   * Buffer.from(array)
   * Buffer.from(buffer)
   * Buffer.from(arrayBuffer[, byteOffset[, length]])
   **/
  Buffer.from = function (value, encodingOrOffset, length) {
    return from(value, encodingOrOffset, length)
  }
  
  // Note: Change prototype *after* Buffer.from is defined to workaround Chrome bug:
  // https://github.com/feross/buffer/pull/148
  Buffer.prototype.__proto__ = Uint8Array.prototype
  Buffer.__proto__ = Uint8Array
  
  function assertSize (size) {
    if (typeof size !== 'number') {
      throw new TypeError('"size" argument must be of type number')
    } else if (size < 0) {
      throw new RangeError('The value "' + size + '" is invalid for option "size"')
    }
  }
  
  function alloc (size, fill, encoding) {
    assertSize(size)
    if (size <= 0) {
      return createBuffer(size)
    }
    if (fill !== undefined) {
      // Only pay attention to encoding if it's a string. This
      // prevents accidentally sending in a number that would
      // be interpretted as a start offset.
      return typeof encoding === 'string'
        ? createBuffer(size).fill(fill, encoding)
        : createBuffer(size).fill(fill)
    }
    return createBuffer(size)
  }
  
  /**
   * Creates a new filled Buffer instance.
   * alloc(size[, fill[, encoding]])
   **/
  Buffer.alloc = function (size, fill, encoding) {
    return alloc(size, fill, encoding)
  }
  
  function allocUnsafe (size) {
    assertSize(size)
    return createBuffer(size < 0 ? 0 : checked(size) | 0)
  }
  
  /**
   * Equivalent to Buffer(num), by default creates a non-zero-filled Buffer instance.
   * */
  Buffer.allocUnsafe = function (size) {
    return allocUnsafe(size)
  }
  /**
   * Equivalent to SlowBuffer(num), by default creates a non-zero-filled Buffer instance.
   */
  Buffer.allocUnsafeSlow = function (size) {
    return allocUnsafe(size)
  }
  
  function fromString (string, encoding) {
    if (typeof encoding !== 'string' || encoding === '') {
      encoding = 'utf8'
    }
  
    if (!Buffer.isEncoding(encoding)) {
      throw new TypeError('Unknown encoding: ' + encoding)
    }
  
    var length = byteLength(string, encoding) | 0
    var buf = createBuffer(length)
  
    var actual = buf.write(string, encoding)
  
    if (actual !== length) {
      // Writing a hex string, for example, that contains invalid characters will
      // cause everything after the first invalid character to be ignored. (e.g.
      // 'abxxcd' will be treated as 'ab')
      buf = buf.slice(0, actual)
    }
  
    return buf
  }
  
  function fromArrayLike (array) {
    var length = array.length < 0 ? 0 : checked(array.length) | 0
    var buf = createBuffer(length)
    for (var i = 0; i < length; i += 1) {
      buf[i] = array[i] & 255
    }
    return buf
  }
  
  function fromArrayBuffer (array, byteOffset, length) {
    if (byteOffset < 0 || array.byteLength < byteOffset) {
      throw new RangeError('"offset" is outside of buffer bounds')
    }
  
    if (array.byteLength < byteOffset + (length || 0)) {
      throw new RangeError('"length" is outside of buffer bounds')
    }
  
    var buf
    if (byteOffset === undefined && length === undefined) {
      buf = new Uint8Array(array)
    } else if (length === undefined) {
      buf = new Uint8Array(array, byteOffset)
    } else {
      buf = new Uint8Array(array, byteOffset, length)
    }
  
    // Return an augmented `Uint8Array` instance
    buf.__proto__ = Buffer.prototype
    return buf
  }
  
  function fromObject (obj) {
    if (Buffer.isBuffer(obj)) {
      var len = checked(obj.length) | 0
      var buf = createBuffer(len)
  
      if (buf.length === 0) {
        return buf
      }
  
      obj.copy(buf, 0, 0, len)
      return buf
    }
  
    if (obj.length !== undefined) {
      if (typeof obj.length !== 'number' || numberIsNaN(obj.length)) {
        return createBuffer(0)
      }
      return fromArrayLike(obj)
    }
  
    if (obj.type === 'Buffer' && Array.isArray(obj.data)) {
      return fromArrayLike(obj.data)
    }
  }
  
  function checked (length) {
    // Note: cannot use `length < K_MAX_LENGTH` here because that fails when
    // length is NaN (which is otherwise coerced to zero.)
    if (length >= K_MAX_LENGTH) {
      throw new RangeError('Attempt to allocate Buffer larger than maximum ' +
                           'size: 0x' + K_MAX_LENGTH.toString(16) + ' bytes')
    }
    return length | 0
  }
  
  function SlowBuffer (length) {
    if (+length != length) { // eslint-disable-line eqeqeq
      length = 0
    }
    return Buffer.alloc(+length)
  }
  
  Buffer.isBuffer = function isBuffer (b) {
    return b != null && b._isBuffer === true &&
      b !== Buffer.prototype // so Buffer.isBuffer(Buffer.prototype) will be false
  }
  
  Buffer.compare = function compare (a, b) {
    if (isInstance(a, Uint8Array)) a = Buffer.from(a, a.offset, a.byteLength)
    if (isInstance(b, Uint8Array)) b = Buffer.from(b, b.offset, b.byteLength)
    if (!Buffer.isBuffer(a) || !Buffer.isBuffer(b)) {
      throw new TypeError(
        'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array'
      )
    }
  
    if (a === b) return 0
  
    var x = a.length
    var y = b.length
  
    for (var i = 0, len = Math.min(x, y); i < len; ++i) {
      if (a[i] !== b[i]) {
        x = a[i]
        y = b[i]
        break
      }
    }
  
    if (x < y) return -1
    if (y < x) return 1
    return 0
  }
  
  Buffer.isEncoding = function isEncoding (encoding) {
    switch (String(encoding).toLowerCase()) {
      case 'hex':
      case 'utf8':
      case 'utf-8':
      case 'ascii':
      case 'latin1':
      case 'binary':
      case 'base64':
      case 'ucs2':
      case 'ucs-2':
      case 'utf16le':
      case 'utf-16le':
        return true
      default:
        return false
    }
  }
  
  Buffer.concat = function concat (list, length) {
    if (!Array.isArray(list)) {
      throw new TypeError('"list" argument must be an Array of Buffers')
    }
  
    if (list.length === 0) {
      return Buffer.alloc(0)
    }
  
    var i
    if (length === undefined) {
      length = 0
      for (i = 0; i < list.length; ++i) {
        length += list[i].length
      }
    }
  
    var buffer = Buffer.allocUnsafe(length)
    var pos = 0
    for (i = 0; i < list.length; ++i) {
      var buf = list[i]
      if (isInstance(buf, Uint8Array)) {
        buf = Buffer.from(buf)
      }
      if (!Buffer.isBuffer(buf)) {
        throw new TypeError('"list" argument must be an Array of Buffers')
      }
      buf.copy(buffer, pos)
      pos += buf.length
    }
    return buffer
  }
  
  function byteLength (string, encoding) {
    if (Buffer.isBuffer(string)) {
      return string.length
    }
    if (ArrayBuffer.isView(string) || isInstance(string, ArrayBuffer)) {
      return string.byteLength
    }
    if (typeof string !== 'string') {
      throw new TypeError(
        'The "string" argument must be one of type string, Buffer, or ArrayBuffer. ' +
        'Received type ' + typeof string
      )
    }
  
    var len = string.length
    var mustMatch = (arguments.length > 2 && arguments[2] === true)
    if (!mustMatch && len === 0) return 0
  
    // Use a for loop to avoid recursion
    var loweredCase = false
    for (;;) {
      switch (encoding) {
        case 'ascii':
        case 'latin1':
        case 'binary':
          return len
        case 'utf8':
        case 'utf-8':
          return utf8ToBytes(string).length
        case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return len * 2
        case 'hex':
          return len >>> 1
        case 'base64':
          return base64ToBytes(string).length
        default:
          if (loweredCase) {
            return mustMatch ? -1 : utf8ToBytes(string).length // assume utf8
          }
          encoding = ('' + encoding).toLowerCase()
          loweredCase = true
      }
    }
  }
  Buffer.byteLength = byteLength
  
  function slowToString (encoding, start, end) {
    var loweredCase = false
  
    // No need to verify that "this.length <= MAX_UINT32" since it's a read-only
    // property of a typed array.
  
    // This behaves neither like String nor Uint8Array in that we set start/end
    // to their upper/lower bounds if the value passed is out of range.
    // undefined is handled specially as per ECMA-262 6th Edition,
    // Section 13.3.3.7 Runtime Semantics: KeyedBindingInitialization.
    if (start === undefined || start < 0) {
      start = 0
    }
    // Return early if start > this.length. Done here to prevent potential uint32
    // coercion fail below.
    if (start > this.length) {
      return ''
    }
  
    if (end === undefined || end > this.length) {
      end = this.length
    }
  
    if (end <= 0) {
      return ''
    }
  
    // Force coersion to uint32. This will also coerce falsey/NaN values to 0.
    end >>>= 0
    start >>>= 0
  
    if (end <= start) {
      return ''
    }
  
    if (!encoding) encoding = 'utf8'
  
    while (true) {
      switch (encoding) {
        case 'hex':
          return hexSlice(this, start, end)
  
        case 'utf8':
        case 'utf-8':
          return utf8Slice(this, start, end)
  
        case 'ascii':
          return asciiSlice(this, start, end)
  
        case 'latin1':
        case 'binary':
          return latin1Slice(this, start, end)
  
        case 'base64':
          return base64Slice(this, start, end)
  
        case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return utf16leSlice(this, start, end)
  
        default:
          if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
          encoding = (encoding + '').toLowerCase()
          loweredCase = true
      }
    }
  }
  
  // This property is used by `Buffer.isBuffer` (and the `is-buffer` npm package)
  // to detect a Buffer instance. It's not possible to use `instanceof Buffer`
  // reliably in a browserify context because there could be multiple different
  // copies of the 'buffer' package in use. This method works even for Buffer
  // instances that were created from another copy of the `buffer` package.
  // See: https://github.com/feross/buffer/issues/154
  Buffer.prototype._isBuffer = true
  
  function swap (b, n, m) {
    var i = b[n]
    b[n] = b[m]
    b[m] = i
  }
  
  Buffer.prototype.swap16 = function swap16 () {
    var len = this.length
    if (len % 2 !== 0) {
      throw new RangeError('Buffer size must be a multiple of 16-bits')
    }
    for (var i = 0; i < len; i += 2) {
      swap(this, i, i + 1)
    }
    return this
  }
  
  Buffer.prototype.swap32 = function swap32 () {
    var len = this.length
    if (len % 4 !== 0) {
      throw new RangeError('Buffer size must be a multiple of 32-bits')
    }
    for (var i = 0; i < len; i += 4) {
      swap(this, i, i + 3)
      swap(this, i + 1, i + 2)
    }
    return this
  }
  
  Buffer.prototype.swap64 = function swap64 () {
    var len = this.length
    if (len % 8 !== 0) {
      throw new RangeError('Buffer size must be a multiple of 64-bits')
    }
    for (var i = 0; i < len; i += 8) {
      swap(this, i, i + 7)
      swap(this, i + 1, i + 6)
      swap(this, i + 2, i + 5)
      swap(this, i + 3, i + 4)
    }
    return this
  }
  
  Buffer.prototype.toString = function toString () {
    var length = this.length
    if (length === 0) return ''
    if (arguments.length === 0) return utf8Slice(this, 0, length)
    return slowToString.apply(this, arguments)
  }
  
  Buffer.prototype.toLocaleString = Buffer.prototype.toString
  
  Buffer.prototype.equals = function equals (b) {
    if (!Buffer.isBuffer(b)) throw new TypeError('Argument must be a Buffer')
    if (this === b) return true
    return Buffer.compare(this, b) === 0
  }
  
  Buffer.prototype.inspect = function inspect () {
    var str = ''
    var max = exports.INSPECT_MAX_BYTES
    str = this.toString('hex', 0, max).replace(/(.{2})/g, '$1 ').trim()
    if (this.length > max) str += ' ... '
    return '<Buffer ' + str + '>'
  }
  
  Buffer.prototype.compare = function compare (target, start, end, thisStart, thisEnd) {
    if (isInstance(target, Uint8Array)) {
      target = Buffer.from(target, target.offset, target.byteLength)
    }
    if (!Buffer.isBuffer(target)) {
      throw new TypeError(
        'The "target" argument must be one of type Buffer or Uint8Array. ' +
        'Received type ' + (typeof target)
      )
    }
  
    if (start === undefined) {
      start = 0
    }
    if (end === undefined) {
      end = target ? target.length : 0
    }
    if (thisStart === undefined) {
      thisStart = 0
    }
    if (thisEnd === undefined) {
      thisEnd = this.length
    }
  
    if (start < 0 || end > target.length || thisStart < 0 || thisEnd > this.length) {
      throw new RangeError('out of range index')
    }
  
    if (thisStart >= thisEnd && start >= end) {
      return 0
    }
    if (thisStart >= thisEnd) {
      return -1
    }
    if (start >= end) {
      return 1
    }
  
    start >>>= 0
    end >>>= 0
    thisStart >>>= 0
    thisEnd >>>= 0
  
    if (this === target) return 0
  
    var x = thisEnd - thisStart
    var y = end - start
    var len = Math.min(x, y)
  
    var thisCopy = this.slice(thisStart, thisEnd)
    var targetCopy = target.slice(start, end)
  
    for (var i = 0; i < len; ++i) {
      if (thisCopy[i] !== targetCopy[i]) {
        x = thisCopy[i]
        y = targetCopy[i]
        break
      }
    }
  
    if (x < y) return -1
    if (y < x) return 1
    return 0
  }
  
  // Finds either the first index of `val` in `buffer` at offset >= `byteOffset`,
  // OR the last index of `val` in `buffer` at offset <= `byteOffset`.
  //
  // Arguments:
  // - buffer - a Buffer to search
  // - val - a string, Buffer, or number
  // - byteOffset - an index into `buffer`; will be clamped to an int32
  // - encoding - an optional encoding, relevant is val is a string
  // - dir - true for indexOf, false for lastIndexOf
  function bidirectionalIndexOf (buffer, val, byteOffset, encoding, dir) {
    // Empty buffer means no match
    if (buffer.length === 0) return -1
  
    // Normalize byteOffset
    if (typeof byteOffset === 'string') {
      encoding = byteOffset
      byteOffset = 0
    } else if (byteOffset > 0x7fffffff) {
      byteOffset = 0x7fffffff
    } else if (byteOffset < -0x80000000) {
      byteOffset = -0x80000000
    }
    byteOffset = +byteOffset // Coerce to Number.
    if (numberIsNaN(byteOffset)) {
      // byteOffset: it it's undefined, null, NaN, "foo", etc, search whole buffer
      byteOffset = dir ? 0 : (buffer.length - 1)
    }
  
    // Normalize byteOffset: negative offsets start from the end of the buffer
    if (byteOffset < 0) byteOffset = buffer.length + byteOffset
    if (byteOffset >= buffer.length) {
      if (dir) return -1
      else byteOffset = buffer.length - 1
    } else if (byteOffset < 0) {
      if (dir) byteOffset = 0
      else return -1
    }
  
    // Normalize val
    if (typeof val === 'string') {
      val = Buffer.from(val, encoding)
    }
  
    // Finally, search either indexOf (if dir is true) or lastIndexOf
    if (Buffer.isBuffer(val)) {
      // Special case: looking for empty string/buffer always fails
      if (val.length === 0) {
        return -1
      }
      return arrayIndexOf(buffer, val, byteOffset, encoding, dir)
    } else if (typeof val === 'number') {
      val = val & 0xFF // Search for a byte value [0-255]
      if (typeof Uint8Array.prototype.indexOf === 'function') {
        if (dir) {
          return Uint8Array.prototype.indexOf.call(buffer, val, byteOffset)
        } else {
          return Uint8Array.prototype.lastIndexOf.call(buffer, val, byteOffset)
        }
      }
      return arrayIndexOf(buffer, [ val ], byteOffset, encoding, dir)
    }
  
    throw new TypeError('val must be string, number or Buffer')
  }
  
  function arrayIndexOf (arr, val, byteOffset, encoding, dir) {
    var indexSize = 1
    var arrLength = arr.length
    var valLength = val.length
  
    if (encoding !== undefined) {
      encoding = String(encoding).toLowerCase()
      if (encoding === 'ucs2' || encoding === 'ucs-2' ||
          encoding === 'utf16le' || encoding === 'utf-16le') {
        if (arr.length < 2 || val.length < 2) {
          return -1
        }
        indexSize = 2
        arrLength /= 2
        valLength /= 2
        byteOffset /= 2
      }
    }
  
    function read (buf, i) {
      if (indexSize === 1) {
        return buf[i]
      } else {
        return buf.readUInt16BE(i * indexSize)
      }
    }
  
    var i
    if (dir) {
      var foundIndex = -1
      for (i = byteOffset; i < arrLength; i++) {
        if (read(arr, i) === read(val, foundIndex === -1 ? 0 : i - foundIndex)) {
          if (foundIndex === -1) foundIndex = i
          if (i - foundIndex + 1 === valLength) return foundIndex * indexSize
        } else {
          if (foundIndex !== -1) i -= i - foundIndex
          foundIndex = -1
        }
      }
    } else {
      if (byteOffset + valLength > arrLength) byteOffset = arrLength - valLength
      for (i = byteOffset; i >= 0; i--) {
        var found = true
        for (var j = 0; j < valLength; j++) {
          if (read(arr, i + j) !== read(val, j)) {
            found = false
            break
          }
        }
        if (found) return i
      }
    }
  
    return -1
  }
  
  Buffer.prototype.includes = function includes (val, byteOffset, encoding) {
    return this.indexOf(val, byteOffset, encoding) !== -1
  }
  
  Buffer.prototype.indexOf = function indexOf (val, byteOffset, encoding) {
    return bidirectionalIndexOf(this, val, byteOffset, encoding, true)
  }
  
  Buffer.prototype.lastIndexOf = function lastIndexOf (val, byteOffset, encoding) {
    return bidirectionalIndexOf(this, val, byteOffset, encoding, false)
  }
  
  function hexWrite (buf, string, offset, length) {
    offset = Number(offset) || 0
    var remaining = buf.length - offset
    if (!length) {
      length = remaining
    } else {
      length = Number(length)
      if (length > remaining) {
        length = remaining
      }
    }
  
    var strLen = string.length
  
    if (length > strLen / 2) {
      length = strLen / 2
    }
    for (var i = 0; i < length; ++i) {
      var parsed = parseInt(string.substr(i * 2, 2), 16)
      if (numberIsNaN(parsed)) return i
      buf[offset + i] = parsed
    }
    return i
  }
  
  function utf8Write (buf, string, offset, length) {
    return blitBuffer(utf8ToBytes(string, buf.length - offset), buf, offset, length)
  }
  
  function asciiWrite (buf, string, offset, length) {
    return blitBuffer(asciiToBytes(string), buf, offset, length)
  }
  
  function latin1Write (buf, string, offset, length) {
    return asciiWrite(buf, string, offset, length)
  }
  
  function base64Write (buf, string, offset, length) {
    return blitBuffer(base64ToBytes(string), buf, offset, length)
  }
  
  function ucs2Write (buf, string, offset, length) {
    return blitBuffer(utf16leToBytes(string, buf.length - offset), buf, offset, length)
  }
  
  Buffer.prototype.write = function write (string, offset, length, encoding) {
    // Buffer#write(string)
    if (offset === undefined) {
      encoding = 'utf8'
      length = this.length
      offset = 0
    // Buffer#write(string, encoding)
    } else if (length === undefined && typeof offset === 'string') {
      encoding = offset
      length = this.length
      offset = 0
    // Buffer#write(string, offset[, length][, encoding])
    } else if (isFinite(offset)) {
      offset = offset >>> 0
      if (isFinite(length)) {
        length = length >>> 0
        if (encoding === undefined) encoding = 'utf8'
      } else {
        encoding = length
        length = undefined
      }
    } else {
      throw new Error(
        'Buffer.write(string, encoding, offset[, length]) is no longer supported'
      )
    }
  
    var remaining = this.length - offset
    if (length === undefined || length > remaining) length = remaining
  
    if ((string.length > 0 && (length < 0 || offset < 0)) || offset > this.length) {
      throw new RangeError('Attempt to write outside buffer bounds')
    }
  
    if (!encoding) encoding = 'utf8'
  
    var loweredCase = false
    for (;;) {
      switch (encoding) {
        case 'hex':
          return hexWrite(this, string, offset, length)
  
        case 'utf8':
        case 'utf-8':
          return utf8Write(this, string, offset, length)
  
        case 'ascii':
          return asciiWrite(this, string, offset, length)
  
        case 'latin1':
        case 'binary':
          return latin1Write(this, string, offset, length)
  
        case 'base64':
          // Warning: maxLength not taken into account in base64Write
          return base64Write(this, string, offset, length)
  
        case 'ucs2':
        case 'ucs-2':
        case 'utf16le':
        case 'utf-16le':
          return ucs2Write(this, string, offset, length)
  
        default:
          if (loweredCase) throw new TypeError('Unknown encoding: ' + encoding)
          encoding = ('' + encoding).toLowerCase()
          loweredCase = true
      }
    }
  }
  
  Buffer.prototype.toJSON = function toJSON () {
    return {
      type: 'Buffer',
      data: Array.prototype.slice.call(this._arr || this, 0)
    }
  }
  
  function base64Slice (buf, start, end) {
    if (start === 0 && end === buf.length) {
      return base64.fromByteArray(buf)
    } else {
      return base64.fromByteArray(buf.slice(start, end))
    }
  }
  
  function utf8Slice (buf, start, end) {
    end = Math.min(buf.length, end)
    var res = []
  
    var i = start
    while (i < end) {
      var firstByte = buf[i]
      var codePoint = null
      var bytesPerSequence = (firstByte > 0xEF) ? 4
        : (firstByte > 0xDF) ? 3
          : (firstByte > 0xBF) ? 2
            : 1
  
      if (i + bytesPerSequence <= end) {
        var secondByte, thirdByte, fourthByte, tempCodePoint
  
        switch (bytesPerSequence) {
          case 1:
            if (firstByte < 0x80) {
              codePoint = firstByte
            }
            break
          case 2:
            secondByte = buf[i + 1]
            if ((secondByte & 0xC0) === 0x80) {
              tempCodePoint = (firstByte & 0x1F) << 0x6 | (secondByte & 0x3F)
              if (tempCodePoint > 0x7F) {
                codePoint = tempCodePoint
              }
            }
            break
          case 3:
            secondByte = buf[i + 1]
            thirdByte = buf[i + 2]
            if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80) {
              tempCodePoint = (firstByte & 0xF) << 0xC | (secondByte & 0x3F) << 0x6 | (thirdByte & 0x3F)
              if (tempCodePoint > 0x7FF && (tempCodePoint < 0xD800 || tempCodePoint > 0xDFFF)) {
                codePoint = tempCodePoint
              }
            }
            break
          case 4:
            secondByte = buf[i + 1]
            thirdByte = buf[i + 2]
            fourthByte = buf[i + 3]
            if ((secondByte & 0xC0) === 0x80 && (thirdByte & 0xC0) === 0x80 && (fourthByte & 0xC0) === 0x80) {
              tempCodePoint = (firstByte & 0xF) << 0x12 | (secondByte & 0x3F) << 0xC | (thirdByte & 0x3F) << 0x6 | (fourthByte & 0x3F)
              if (tempCodePoint > 0xFFFF && tempCodePoint < 0x110000) {
                codePoint = tempCodePoint
              }
            }
        }
      }
  
      if (codePoint === null) {
        // we did not generate a valid codePoint so insert a
        // replacement char (U+FFFD) and advance only 1 byte
        codePoint = 0xFFFD
        bytesPerSequence = 1
      } else if (codePoint > 0xFFFF) {
        // encode to utf16 (surrogate pair dance)
        codePoint -= 0x10000
        res.push(codePoint >>> 10 & 0x3FF | 0xD800)
        codePoint = 0xDC00 | codePoint & 0x3FF
      }
  
      res.push(codePoint)
      i += bytesPerSequence
    }
  
    return decodeCodePointsArray(res)
  }
  
  // Based on http://stackoverflow.com/a/22747272/680742, the browser with
  // the lowest limit is Chrome, with 0x10000 args.
  // We go 1 magnitude less, for safety
  var MAX_ARGUMENTS_LENGTH = 0x1000
  
  function decodeCodePointsArray (codePoints) {
    var len = codePoints.length
    if (len <= MAX_ARGUMENTS_LENGTH) {
      return String.fromCharCode.apply(String, codePoints) // avoid extra slice()
    }
  
    // Decode in chunks to avoid "call stack size exceeded".
    var res = ''
    var i = 0
    while (i < len) {
      res += String.fromCharCode.apply(
        String,
        codePoints.slice(i, i += MAX_ARGUMENTS_LENGTH)
      )
    }
    return res
  }
  
  function asciiSlice (buf, start, end) {
    var ret = ''
    end = Math.min(buf.length, end)
  
    for (var i = start; i < end; ++i) {
      ret += String.fromCharCode(buf[i] & 0x7F)
    }
    return ret
  }
  
  function latin1Slice (buf, start, end) {
    var ret = ''
    end = Math.min(buf.length, end)
  
    for (var i = start; i < end; ++i) {
      ret += String.fromCharCode(buf[i])
    }
    return ret
  }
  
  function hexSlice (buf, start, end) {
    var len = buf.length
  
    if (!start || start < 0) start = 0
    if (!end || end < 0 || end > len) end = len
  
    var out = ''
    for (var i = start; i < end; ++i) {
      out += toHex(buf[i])
    }
    return out
  }
  
  function utf16leSlice (buf, start, end) {
    var bytes = buf.slice(start, end)
    var res = ''
    for (var i = 0; i < bytes.length; i += 2) {
      res += String.fromCharCode(bytes[i] + (bytes[i + 1] * 256))
    }
    return res
  }
  
  Buffer.prototype.slice = function slice (start, end) {
    var len = this.length
    start = ~~start
    end = end === undefined ? len : ~~end
  
    if (start < 0) {
      start += len
      if (start < 0) start = 0
    } else if (start > len) {
      start = len
    }
  
    if (end < 0) {
      end += len
      if (end < 0) end = 0
    } else if (end > len) {
      end = len
    }
  
    if (end < start) end = start
  
    var newBuf = this.subarray(start, end)
    // Return an augmented `Uint8Array` instance
    newBuf.__proto__ = Buffer.prototype
    return newBuf
  }
  
  /*
   * Need to make sure that buffer isn't trying to write out of bounds.
   */
  function checkOffset (offset, ext, length) {
    if ((offset % 1) !== 0 || offset < 0) throw new RangeError('offset is not uint')
    if (offset + ext > length) throw new RangeError('Trying to access beyond buffer length')
  }
  
  Buffer.prototype.readUIntLE = function readUIntLE (offset, byteLength, noAssert) {
    offset = offset >>> 0
    byteLength = byteLength >>> 0
    if (!noAssert) checkOffset(offset, byteLength, this.length)
  
    var val = this[offset]
    var mul = 1
    var i = 0
    while (++i < byteLength && (mul *= 0x100)) {
      val += this[offset + i] * mul
    }
  
    return val
  }
  
  Buffer.prototype.readUIntBE = function readUIntBE (offset, byteLength, noAssert) {
    offset = offset >>> 0
    byteLength = byteLength >>> 0
    if (!noAssert) {
      checkOffset(offset, byteLength, this.length)
    }
  
    var val = this[offset + --byteLength]
    var mul = 1
    while (byteLength > 0 && (mul *= 0x100)) {
      val += this[offset + --byteLength] * mul
    }
  
    return val
  }
  
  Buffer.prototype.readUInt8 = function readUInt8 (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 1, this.length)
    return this[offset]
  }
  
  Buffer.prototype.readUInt16LE = function readUInt16LE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 2, this.length)
    return this[offset] | (this[offset + 1] << 8)
  }
  
  Buffer.prototype.readUInt16BE = function readUInt16BE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 2, this.length)
    return (this[offset] << 8) | this[offset + 1]
  }
  
  Buffer.prototype.readUInt32LE = function readUInt32LE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 4, this.length)
  
    return ((this[offset]) |
        (this[offset + 1] << 8) |
        (this[offset + 2] << 16)) +
        (this[offset + 3] * 0x1000000)
  }
  
  Buffer.prototype.readUInt32BE = function readUInt32BE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 4, this.length)
  
    return (this[offset] * 0x1000000) +
      ((this[offset + 1] << 16) |
      (this[offset + 2] << 8) |
      this[offset + 3])
  }
  
  Buffer.prototype.readIntLE = function readIntLE (offset, byteLength, noAssert) {
    offset = offset >>> 0
    byteLength = byteLength >>> 0
    if (!noAssert) checkOffset(offset, byteLength, this.length)
  
    var val = this[offset]
    var mul = 1
    var i = 0
    while (++i < byteLength && (mul *= 0x100)) {
      val += this[offset + i] * mul
    }
    mul *= 0x80
  
    if (val >= mul) val -= Math.pow(2, 8 * byteLength)
  
    return val
  }
  
  Buffer.prototype.readIntBE = function readIntBE (offset, byteLength, noAssert) {
    offset = offset >>> 0
    byteLength = byteLength >>> 0
    if (!noAssert) checkOffset(offset, byteLength, this.length)
  
    var i = byteLength
    var mul = 1
    var val = this[offset + --i]
    while (i > 0 && (mul *= 0x100)) {
      val += this[offset + --i] * mul
    }
    mul *= 0x80
  
    if (val >= mul) val -= Math.pow(2, 8 * byteLength)
  
    return val
  }
  
  Buffer.prototype.readInt8 = function readInt8 (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 1, this.length)
    if (!(this[offset] & 0x80)) return (this[offset])
    return ((0xff - this[offset] + 1) * -1)
  }
  
  Buffer.prototype.readInt16LE = function readInt16LE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 2, this.length)
    var val = this[offset] | (this[offset + 1] << 8)
    return (val & 0x8000) ? val | 0xFFFF0000 : val
  }
  
  Buffer.prototype.readInt16BE = function readInt16BE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 2, this.length)
    var val = this[offset + 1] | (this[offset] << 8)
    return (val & 0x8000) ? val | 0xFFFF0000 : val
  }
  
  Buffer.prototype.readInt32LE = function readInt32LE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 4, this.length)
  
    return (this[offset]) |
      (this[offset + 1] << 8) |
      (this[offset + 2] << 16) |
      (this[offset + 3] << 24)
  }
  
  Buffer.prototype.readInt32BE = function readInt32BE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 4, this.length)
  
    return (this[offset] << 24) |
      (this[offset + 1] << 16) |
      (this[offset + 2] << 8) |
      (this[offset + 3])
  }
  
  Buffer.prototype.readFloatLE = function readFloatLE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 4, this.length)
    return ieee754.read(this, offset, true, 23, 4)
  }
  
  Buffer.prototype.readFloatBE = function readFloatBE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 4, this.length)
    return ieee754.read(this, offset, false, 23, 4)
  }
  
  Buffer.prototype.readDoubleLE = function readDoubleLE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 8, this.length)
    return ieee754.read(this, offset, true, 52, 8)
  }
  
  Buffer.prototype.readDoubleBE = function readDoubleBE (offset, noAssert) {
    offset = offset >>> 0
    if (!noAssert) checkOffset(offset, 8, this.length)
    return ieee754.read(this, offset, false, 52, 8)
  }
  
  function checkInt (buf, value, offset, ext, max, min) {
    if (!Buffer.isBuffer(buf)) throw new TypeError('"buffer" argument must be a Buffer instance')
    if (value > max || value < min) throw new RangeError('"value" argument is out of bounds')
    if (offset + ext > buf.length) throw new RangeError('Index out of range')
  }
  
  Buffer.prototype.writeUIntLE = function writeUIntLE (value, offset, byteLength, noAssert) {
    value = +value
    offset = offset >>> 0
    byteLength = byteLength >>> 0
    if (!noAssert) {
      var maxBytes = Math.pow(2, 8 * byteLength) - 1
      checkInt(this, value, offset, byteLength, maxBytes, 0)
    }
  
    var mul = 1
    var i = 0
    this[offset] = value & 0xFF
    while (++i < byteLength && (mul *= 0x100)) {
      this[offset + i] = (value / mul) & 0xFF
    }
  
    return offset + byteLength
  }
  
  Buffer.prototype.writeUIntBE = function writeUIntBE (value, offset, byteLength, noAssert) {
    value = +value
    offset = offset >>> 0
    byteLength = byteLength >>> 0
    if (!noAssert) {
      var maxBytes = Math.pow(2, 8 * byteLength) - 1
      checkInt(this, value, offset, byteLength, maxBytes, 0)
    }
  
    var i = byteLength - 1
    var mul = 1
    this[offset + i] = value & 0xFF
    while (--i >= 0 && (mul *= 0x100)) {
      this[offset + i] = (value / mul) & 0xFF
    }
  
    return offset + byteLength
  }
  
  Buffer.prototype.writeUInt8 = function writeUInt8 (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 1, 0xff, 0)
    this[offset] = (value & 0xff)
    return offset + 1
  }
  
  Buffer.prototype.writeUInt16LE = function writeUInt16LE (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
    return offset + 2
  }
  
  Buffer.prototype.writeUInt16BE = function writeUInt16BE (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 2, 0xffff, 0)
    this[offset] = (value >>> 8)
    this[offset + 1] = (value & 0xff)
    return offset + 2
  }
  
  Buffer.prototype.writeUInt32LE = function writeUInt32LE (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
    this[offset + 3] = (value >>> 24)
    this[offset + 2] = (value >>> 16)
    this[offset + 1] = (value >>> 8)
    this[offset] = (value & 0xff)
    return offset + 4
  }
  
  Buffer.prototype.writeUInt32BE = function writeUInt32BE (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 4, 0xffffffff, 0)
    this[offset] = (value >>> 24)
    this[offset + 1] = (value >>> 16)
    this[offset + 2] = (value >>> 8)
    this[offset + 3] = (value & 0xff)
    return offset + 4
  }
  
  Buffer.prototype.writeIntLE = function writeIntLE (value, offset, byteLength, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) {
      var limit = Math.pow(2, (8 * byteLength) - 1)
  
      checkInt(this, value, offset, byteLength, limit - 1, -limit)
    }
  
    var i = 0
    var mul = 1
    var sub = 0
    this[offset] = value & 0xFF
    while (++i < byteLength && (mul *= 0x100)) {
      if (value < 0 && sub === 0 && this[offset + i - 1] !== 0) {
        sub = 1
      }
      this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
    }
  
    return offset + byteLength
  }
  
  Buffer.prototype.writeIntBE = function writeIntBE (value, offset, byteLength, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) {
      var limit = Math.pow(2, (8 * byteLength) - 1)
  
      checkInt(this, value, offset, byteLength, limit - 1, -limit)
    }
  
    var i = byteLength - 1
    var mul = 1
    var sub = 0
    this[offset + i] = value & 0xFF
    while (--i >= 0 && (mul *= 0x100)) {
      if (value < 0 && sub === 0 && this[offset + i + 1] !== 0) {
        sub = 1
      }
      this[offset + i] = ((value / mul) >> 0) - sub & 0xFF
    }
  
    return offset + byteLength
  }
  
  Buffer.prototype.writeInt8 = function writeInt8 (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 1, 0x7f, -0x80)
    if (value < 0) value = 0xff + value + 1
    this[offset] = (value & 0xff)
    return offset + 1
  }
  
  Buffer.prototype.writeInt16LE = function writeInt16LE (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
    return offset + 2
  }
  
  Buffer.prototype.writeInt16BE = function writeInt16BE (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 2, 0x7fff, -0x8000)
    this[offset] = (value >>> 8)
    this[offset + 1] = (value & 0xff)
    return offset + 2
  }
  
  Buffer.prototype.writeInt32LE = function writeInt32LE (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
    this[offset] = (value & 0xff)
    this[offset + 1] = (value >>> 8)
    this[offset + 2] = (value >>> 16)
    this[offset + 3] = (value >>> 24)
    return offset + 4
  }
  
  Buffer.prototype.writeInt32BE = function writeInt32BE (value, offset, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) checkInt(this, value, offset, 4, 0x7fffffff, -0x80000000)
    if (value < 0) value = 0xffffffff + value + 1
    this[offset] = (value >>> 24)
    this[offset + 1] = (value >>> 16)
    this[offset + 2] = (value >>> 8)
    this[offset + 3] = (value & 0xff)
    return offset + 4
  }
  
  function checkIEEE754 (buf, value, offset, ext, max, min) {
    if (offset + ext > buf.length) throw new RangeError('Index out of range')
    if (offset < 0) throw new RangeError('Index out of range')
  }
  
  function writeFloat (buf, value, offset, littleEndian, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) {
      checkIEEE754(buf, value, offset, 4, 3.4028234663852886e+38, -3.4028234663852886e+38)
    }
    ieee754.write(buf, value, offset, littleEndian, 23, 4)
    return offset + 4
  }
  
  Buffer.prototype.writeFloatLE = function writeFloatLE (value, offset, noAssert) {
    return writeFloat(this, value, offset, true, noAssert)
  }
  
  Buffer.prototype.writeFloatBE = function writeFloatBE (value, offset, noAssert) {
    return writeFloat(this, value, offset, false, noAssert)
  }
  
  function writeDouble (buf, value, offset, littleEndian, noAssert) {
    value = +value
    offset = offset >>> 0
    if (!noAssert) {
      checkIEEE754(buf, value, offset, 8, 1.7976931348623157E+308, -1.7976931348623157E+308)
    }
    ieee754.write(buf, value, offset, littleEndian, 52, 8)
    return offset + 8
  }
  
  Buffer.prototype.writeDoubleLE = function writeDoubleLE (value, offset, noAssert) {
    return writeDouble(this, value, offset, true, noAssert)
  }
  
  Buffer.prototype.writeDoubleBE = function writeDoubleBE (value, offset, noAssert) {
    return writeDouble(this, value, offset, false, noAssert)
  }
  
  // copy(targetBuffer, targetStart=0, sourceStart=0, sourceEnd=buffer.length)
  Buffer.prototype.copy = function copy (target, targetStart, start, end) {
    if (!Buffer.isBuffer(target)) throw new TypeError('argument should be a Buffer')
    if (!start) start = 0
    if (!end && end !== 0) end = this.length
    if (targetStart >= target.length) targetStart = target.length
    if (!targetStart) targetStart = 0
    if (end > 0 && end < start) end = start
  
    // Copy 0 bytes; we're done
    if (end === start) return 0
    if (target.length === 0 || this.length === 0) return 0
  
    // Fatal error conditions
    if (targetStart < 0) {
      throw new RangeError('targetStart out of bounds')
    }
    if (start < 0 || start >= this.length) throw new RangeError('Index out of range')
    if (end < 0) throw new RangeError('sourceEnd out of bounds')
  
    // Are we oob?
    if (end > this.length) end = this.length
    if (target.length - targetStart < end - start) {
      end = target.length - targetStart + start
    }
  
    var len = end - start
  
    if (this === target && typeof Uint8Array.prototype.copyWithin === 'function') {
      // Use built-in when available, missing from IE11
      this.copyWithin(targetStart, start, end)
    } else if (this === target && start < targetStart && targetStart < end) {
      // descending copy from end
      for (var i = len - 1; i >= 0; --i) {
        target[i + targetStart] = this[i + start]
      }
    } else {
      Uint8Array.prototype.set.call(
        target,
        this.subarray(start, end),
        targetStart
      )
    }
  
    return len
  }
  
  // Usage:
  //    buffer.fill(number[, offset[, end]])
  //    buffer.fill(buffer[, offset[, end]])
  //    buffer.fill(string[, offset[, end]][, encoding])
  Buffer.prototype.fill = function fill (val, start, end, encoding) {
    // Handle string cases:
    if (typeof val === 'string') {
      if (typeof start === 'string') {
        encoding = start
        start = 0
        end = this.length
      } else if (typeof end === 'string') {
        encoding = end
        end = this.length
      }
      if (encoding !== undefined && typeof encoding !== 'string') {
        throw new TypeError('encoding must be a string')
      }
      if (typeof encoding === 'string' && !Buffer.isEncoding(encoding)) {
        throw new TypeError('Unknown encoding: ' + encoding)
      }
      if (val.length === 1) {
        var code = val.charCodeAt(0)
        if ((encoding === 'utf8' && code < 128) ||
            encoding === 'latin1') {
          // Fast path: If `val` fits into a single byte, use that numeric value.
          val = code
        }
      }
    } else if (typeof val === 'number') {
      val = val & 255
    }
  
    // Invalid ranges are not set to a default, so can range check early.
    if (start < 0 || this.length < start || this.length < end) {
      throw new RangeError('Out of range index')
    }
  
    if (end <= start) {
      return this
    }
  
    start = start >>> 0
    end = end === undefined ? this.length : end >>> 0
  
    if (!val) val = 0
  
    var i
    if (typeof val === 'number') {
      for (i = start; i < end; ++i) {
        this[i] = val
      }
    } else {
      var bytes = Buffer.isBuffer(val)
        ? val
        : Buffer.from(val, encoding)
      var len = bytes.length
      if (len === 0) {
        throw new TypeError('The value "' + val +
          '" is invalid for argument "value"')
      }
      for (i = 0; i < end - start; ++i) {
        this[i + start] = bytes[i % len]
      }
    }
  
    return this
  }
  
  // HELPER FUNCTIONS
  // ================
  
  var INVALID_BASE64_RE = /[^+/0-9A-Za-z-_]/g
  
  function base64clean (str) {
    // Node takes equal signs as end of the Base64 encoding
    str = str.split('=')[0]
    // Node strips out invalid characters like \n and \t from the string, base64-js does not
    str = str.trim().replace(INVALID_BASE64_RE, '')
    // Node converts strings with length < 2 to ''
    if (str.length < 2) return ''
    // Node allows for non-padded base64 strings (missing trailing ===), base64-js does not
    while (str.length % 4 !== 0) {
      str = str + '='
    }
    return str
  }
  
  function toHex (n) {
    if (n < 16) return '0' + n.toString(16)
    return n.toString(16)
  }
  
  function utf8ToBytes (string, units) {
    units = units || Infinity
    var codePoint
    var length = string.length
    var leadSurrogate = null
    var bytes = []
  
    for (var i = 0; i < length; ++i) {
      codePoint = string.charCodeAt(i)
  
      // is surrogate component
      if (codePoint > 0xD7FF && codePoint < 0xE000) {
        // last char was a lead
        if (!leadSurrogate) {
          // no lead yet
          if (codePoint > 0xDBFF) {
            // unexpected trail
            if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
            continue
          } else if (i + 1 === length) {
            // unpaired lead
            if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
            continue
          }
  
          // valid lead
          leadSurrogate = codePoint
  
          continue
        }
  
        // 2 leads in a row
        if (codePoint < 0xDC00) {
          if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
          leadSurrogate = codePoint
          continue
        }
  
        // valid surrogate pair
        codePoint = (leadSurrogate - 0xD800 << 10 | codePoint - 0xDC00) + 0x10000
      } else if (leadSurrogate) {
        // valid bmp char, but last char was a lead
        if ((units -= 3) > -1) bytes.push(0xEF, 0xBF, 0xBD)
      }
  
      leadSurrogate = null
  
      // encode utf8
      if (codePoint < 0x80) {
        if ((units -= 1) < 0) break
        bytes.push(codePoint)
      } else if (codePoint < 0x800) {
        if ((units -= 2) < 0) break
        bytes.push(
          codePoint >> 0x6 | 0xC0,
          codePoint & 0x3F | 0x80
        )
      } else if (codePoint < 0x10000) {
        if ((units -= 3) < 0) break
        bytes.push(
          codePoint >> 0xC | 0xE0,
          codePoint >> 0x6 & 0x3F | 0x80,
          codePoint & 0x3F | 0x80
        )
      } else if (codePoint < 0x110000) {
        if ((units -= 4) < 0) break
        bytes.push(
          codePoint >> 0x12 | 0xF0,
          codePoint >> 0xC & 0x3F | 0x80,
          codePoint >> 0x6 & 0x3F | 0x80,
          codePoint & 0x3F | 0x80
        )
      } else {
        throw new Error('Invalid code point')
      }
    }
  
    return bytes
  }
  
  function asciiToBytes (str) {
    var byteArray = []
    for (var i = 0; i < str.length; ++i) {
      // Node's code seems to be doing this and not & 0x7F..
      byteArray.push(str.charCodeAt(i) & 0xFF)
    }
    return byteArray
  }
  
  function utf16leToBytes (str, units) {
    var c, hi, lo
    var byteArray = []
    for (var i = 0; i < str.length; ++i) {
      if ((units -= 2) < 0) break
  
      c = str.charCodeAt(i)
      hi = c >> 8
      lo = c % 256
      byteArray.push(lo)
      byteArray.push(hi)
    }
  
    return byteArray
  }
  
  function base64ToBytes (str) {
    return base64.toByteArray(base64clean(str))
  }
  
  function blitBuffer (src, dst, offset, length) {
    for (var i = 0; i < length; ++i) {
      if ((i + offset >= dst.length) || (i >= src.length)) break
      dst[i + offset] = src[i]
    }
    return i
  }
  
  // ArrayBuffer or Uint8Array objects from other contexts (i.e. iframes) do not pass
  // the `instanceof` check but they should be treated as of that type.
  // See: https://github.com/feross/buffer/issues/166
  function isInstance (obj, type) {
    return obj instanceof type ||
      (obj != null && obj.constructor != null && obj.constructor.name != null &&
        obj.constructor.name === type.name)
  }
  function numberIsNaN (obj) {
    // For IE11 support
    return obj !== obj // eslint-disable-line no-self-compare
  }
  
  }).call(this,require("buffer").Buffer)
  },{"base64-js":110,"buffer":111,"ieee754":114}],112:[function(require,module,exports){
  var charenc = {
    // UTF-8 encoding
    utf8: {
      // Convert a string to a byte array
      stringToBytes: function(str) {
        return charenc.bin.stringToBytes(unescape(encodeURIComponent(str)));
      },
  
      // Convert a byte array to a string
      bytesToString: function(bytes) {
        return decodeURIComponent(escape(charenc.bin.bytesToString(bytes)));
      }
    },
  
    // Binary encoding
    bin: {
      // Convert a string to a byte array
      stringToBytes: function(str) {
        for (var bytes = [], i = 0; i < str.length; i++)
          bytes.push(str.charCodeAt(i) & 0xFF);
        return bytes;
      },
  
      // Convert a byte array to a string
      bytesToString: function(bytes) {
        for (var str = [], i = 0; i < bytes.length; i++)
          str.push(String.fromCharCode(bytes[i]));
        return str.join('');
      }
    }
  };
  
  module.exports = charenc;
  
  },{}],113:[function(require,module,exports){
  (function() {
    var base64map
        = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/',
  
    crypt = {
      // Bit-wise rotation left
      rotl: function(n, b) {
        return (n << b) | (n >>> (32 - b));
      },
  
      // Bit-wise rotation right
      rotr: function(n, b) {
        return (n << (32 - b)) | (n >>> b);
      },
  
      // Swap big-endian to little-endian and vice versa
      endian: function(n) {
        // If number given, swap endian
        if (n.constructor == Number) {
          return crypt.rotl(n, 8) & 0x00FF00FF | crypt.rotl(n, 24) & 0xFF00FF00;
        }
  
        // Else, assume array and swap all items
        for (var i = 0; i < n.length; i++)
          n[i] = crypt.endian(n[i]);
        return n;
      },
  
      // Generate an array of any length of random bytes
      randomBytes: function(n) {
        for (var bytes = []; n > 0; n--)
          bytes.push(Math.floor(Math.random() * 256));
        return bytes;
      },
  
      // Convert a byte array to big-endian 32-bit words
      bytesToWords: function(bytes) {
        for (var words = [], i = 0, b = 0; i < bytes.length; i++, b += 8)
          words[b >>> 5] |= bytes[i] << (24 - b % 32);
        return words;
      },
  
      // Convert big-endian 32-bit words to a byte array
      wordsToBytes: function(words) {
        for (var bytes = [], b = 0; b < words.length * 32; b += 8)
          bytes.push((words[b >>> 5] >>> (24 - b % 32)) & 0xFF);
        return bytes;
      },
  
      // Convert a byte array to a hex string
      bytesToHex: function(bytes) {
        for (var hex = [], i = 0; i < bytes.length; i++) {
          hex.push((bytes[i] >>> 4).toString(16));
          hex.push((bytes[i] & 0xF).toString(16));
        }
        return hex.join('');
      },
  
      // Convert a hex string to a byte array
      hexToBytes: function(hex) {
        for (var bytes = [], c = 0; c < hex.length; c += 2)
          bytes.push(parseInt(hex.substr(c, 2), 16));
        return bytes;
      },
  
      // Convert a byte array to a base-64 string
      bytesToBase64: function(bytes) {
        for (var base64 = [], i = 0; i < bytes.length; i += 3) {
          var triplet = (bytes[i] << 16) | (bytes[i + 1] << 8) | bytes[i + 2];
          for (var j = 0; j < 4; j++)
            if (i * 8 + j * 6 <= bytes.length * 8)
              base64.push(base64map.charAt((triplet >>> 6 * (3 - j)) & 0x3F));
            else
              base64.push('=');
        }
        return base64.join('');
      },
  
      // Convert a base-64 string to a byte array
      base64ToBytes: function(base64) {
        // Remove non-base-64 characters
        base64 = base64.replace(/[^A-Z0-9+\/]/ig, '');
  
        for (var bytes = [], i = 0, imod4 = 0; i < base64.length;
            imod4 = ++i % 4) {
          if (imod4 == 0) continue;
          bytes.push(((base64map.indexOf(base64.charAt(i - 1))
              & (Math.pow(2, -2 * imod4 + 8) - 1)) << (imod4 * 2))
              | (base64map.indexOf(base64.charAt(i)) >>> (6 - imod4 * 2)));
        }
        return bytes;
      }
    };
  
    module.exports = crypt;
  })();
  
  },{}],114:[function(require,module,exports){
  exports.read = function (buffer, offset, isLE, mLen, nBytes) {
    var e, m
    var eLen = (nBytes * 8) - mLen - 1
    var eMax = (1 << eLen) - 1
    var eBias = eMax >> 1
    var nBits = -7
    var i = isLE ? (nBytes - 1) : 0
    var d = isLE ? -1 : 1
    var s = buffer[offset + i]
  
    i += d
  
    e = s & ((1 << (-nBits)) - 1)
    s >>= (-nBits)
    nBits += eLen
    for (; nBits > 0; e = (e * 256) + buffer[offset + i], i += d, nBits -= 8) {}
  
    m = e & ((1 << (-nBits)) - 1)
    e >>= (-nBits)
    nBits += mLen
    for (; nBits > 0; m = (m * 256) + buffer[offset + i], i += d, nBits -= 8) {}
  
    if (e === 0) {
      e = 1 - eBias
    } else if (e === eMax) {
      return m ? NaN : ((s ? -1 : 1) * Infinity)
    } else {
      m = m + Math.pow(2, mLen)
      e = e - eBias
    }
    return (s ? -1 : 1) * m * Math.pow(2, e - mLen)
  }
  
  exports.write = function (buffer, value, offset, isLE, mLen, nBytes) {
    var e, m, c
    var eLen = (nBytes * 8) - mLen - 1
    var eMax = (1 << eLen) - 1
    var eBias = eMax >> 1
    var rt = (mLen === 23 ? Math.pow(2, -24) - Math.pow(2, -77) : 0)
    var i = isLE ? 0 : (nBytes - 1)
    var d = isLE ? 1 : -1
    var s = value < 0 || (value === 0 && 1 / value < 0) ? 1 : 0
  
    value = Math.abs(value)
  
    if (isNaN(value) || value === Infinity) {
      m = isNaN(value) ? 1 : 0
      e = eMax
    } else {
      e = Math.floor(Math.log(value) / Math.LN2)
      if (value * (c = Math.pow(2, -e)) < 1) {
        e--
        c *= 2
      }
      if (e + eBias >= 1) {
        value += rt / c
      } else {
        value += rt * Math.pow(2, 1 - eBias)
      }
      if (value * c >= 2) {
        e++
        c /= 2
      }
  
      if (e + eBias >= eMax) {
        m = 0
        e = eMax
      } else if (e + eBias >= 1) {
        m = ((value * c) - 1) * Math.pow(2, mLen)
        e = e + eBias
      } else {
        m = value * Math.pow(2, eBias - 1) * Math.pow(2, mLen)
        e = 0
      }
    }
  
    for (; mLen >= 8; buffer[offset + i] = m & 0xff, i += d, m /= 256, mLen -= 8) {}
  
    e = (e << mLen) | m
    eLen += mLen
    for (; eLen > 0; buffer[offset + i] = e & 0xff, i += d, e /= 256, eLen -= 8) {}
  
    buffer[offset + i - d] |= s * 128
  }
  
  },{}],115:[function(require,module,exports){
  // shim for using process in browser
  var process = module.exports = {};
  
  // cached from whatever global is present so that test runners that stub it
  // don't break things.  But we need to wrap it in a try catch in case it is
  // wrapped in strict mode code which doesn't define any globals.  It's inside a
  // function because try/catches deoptimize in certain engines.
  
  var cachedSetTimeout;
  var cachedClearTimeout;
  
  function defaultSetTimout() {
      throw new Error('setTimeout has not been defined');
  }
  function defaultClearTimeout () {
      throw new Error('clearTimeout has not been defined');
  }
  (function () {
      try {
          if (typeof setTimeout === 'function') {
              cachedSetTimeout = setTimeout;
          } else {
              cachedSetTimeout = defaultSetTimout;
          }
      } catch (e) {
          cachedSetTimeout = defaultSetTimout;
      }
      try {
          if (typeof clearTimeout === 'function') {
              cachedClearTimeout = clearTimeout;
          } else {
              cachedClearTimeout = defaultClearTimeout;
          }
      } catch (e) {
          cachedClearTimeout = defaultClearTimeout;
      }
  } ())
  function runTimeout(fun) {
      if (cachedSetTimeout === setTimeout) {
          //normal enviroments in sane situations
          return setTimeout(fun, 0);
      }
      // if setTimeout wasn't available but was latter defined
      if ((cachedSetTimeout === defaultSetTimout || !cachedSetTimeout) && setTimeout) {
          cachedSetTimeout = setTimeout;
          return setTimeout(fun, 0);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedSetTimeout(fun, 0);
      } catch(e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't trust the global object when called normally
              return cachedSetTimeout.call(null, fun, 0);
          } catch(e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error
              return cachedSetTimeout.call(this, fun, 0);
          }
      }
  
  
  }
  function runClearTimeout(marker) {
      if (cachedClearTimeout === clearTimeout) {
          //normal enviroments in sane situations
          return clearTimeout(marker);
      }
      // if clearTimeout wasn't available but was latter defined
      if ((cachedClearTimeout === defaultClearTimeout || !cachedClearTimeout) && clearTimeout) {
          cachedClearTimeout = clearTimeout;
          return clearTimeout(marker);
      }
      try {
          // when when somebody has screwed with setTimeout but no I.E. maddness
          return cachedClearTimeout(marker);
      } catch (e){
          try {
              // When we are in I.E. but the script has been evaled so I.E. doesn't  trust the global object when called normally
              return cachedClearTimeout.call(null, marker);
          } catch (e){
              // same as above but when it's a version of I.E. that must have the global object for 'this', hopfully our context correct otherwise it will throw a global error.
              // Some versions of I.E. have different rules for clearTimeout vs setTimeout
              return cachedClearTimeout.call(this, marker);
          }
      }
  
  
  
  }
  var queue = [];
  var draining = false;
  var currentQueue;
  var queueIndex = -1;
  
  function cleanUpNextTick() {
      if (!draining || !currentQueue) {
          return;
      }
      draining = false;
      if (currentQueue.length) {
          queue = currentQueue.concat(queue);
      } else {
          queueIndex = -1;
      }
      if (queue.length) {
          drainQueue();
      }
  }
  
  function drainQueue() {
      if (draining) {
          return;
      }
      var timeout = runTimeout(cleanUpNextTick);
      draining = true;
  
      var len = queue.length;
      while(len) {
          currentQueue = queue;
          queue = [];
          while (++queueIndex < len) {
              if (currentQueue) {
                  currentQueue[queueIndex].run();
              }
          }
          queueIndex = -1;
          len = queue.length;
      }
      currentQueue = null;
      draining = false;
      runClearTimeout(timeout);
  }
  
  process.nextTick = function (fun) {
      var args = new Array(arguments.length - 1);
      if (arguments.length > 1) {
          for (var i = 1; i < arguments.length; i++) {
              args[i - 1] = arguments[i];
          }
      }
      queue.push(new Item(fun, args));
      if (queue.length === 1 && !draining) {
          runTimeout(drainQueue);
      }
  };
  
  // v8 likes predictible objects
  function Item(fun, array) {
      this.fun = fun;
      this.array = array;
  }
  Item.prototype.run = function () {
      this.fun.apply(null, this.array);
  };
  process.title = 'browser';
  process.browser = true;
  process.env = {};
  process.argv = [];
  process.version = ''; // empty string to avoid regexp issues
  process.versions = {};
  
  function noop() {}
  
  process.on = noop;
  process.addListener = noop;
  process.once = noop;
  process.off = noop;
  process.removeListener = noop;
  process.removeAllListeners = noop;
  process.emit = noop;
  process.prependListener = noop;
  process.prependOnceListener = noop;
  
  process.listeners = function (name) { return [] }
  
  process.binding = function (name) {
      throw new Error('process.binding is not supported');
  };
  
  process.cwd = function () { return '/' };
  process.chdir = function (dir) {
      throw new Error('process.chdir is not supported');
  };
  process.umask = function() { return 0; };
  
  },{}],116:[function(require,module,exports){
  /*
   * qTip2 - Pretty powerful tooltips - v3.0.3
   * http://qtip2.com
   *
   * Copyright (c) 2016 
   * Released under the MIT licenses
   * http://jquery.org/license
   *
   * Date: Wed May 11 2016 10:31 GMT+0100+0100
   * Plugins: tips modal viewport svg imagemap ie6
   * Styles: core basic css3
   */
  /*global window: false, jQuery: false, console: false, define: false */
  
  /* Cache window, document, undefined */
  (function( window, document, undefined ) {
  
  // Uses AMD or browser globals to create a jQuery plugin.
  (function( factory ) {
  	"use strict";
  	if(typeof define === 'function' && define.amd) {
  		define(['jquery'], factory);
  	}
  	else if(jQuery && !jQuery.fn.qtip) {
  		factory(jQuery);
  	}
  }
  (function($) {
  	"use strict"; // Enable ECMAScript "strict" operation for this function. See more: http://ejohn.org/blog/ecmascript-5-strict-mode-json-and-more/
  ;// Munge the primitives - Paul Irish tip
  var TRUE = true,
  FALSE = false,
  NULL = null,
  
  // Common variables
  X = 'x', Y = 'y',
  WIDTH = 'width',
  HEIGHT = 'height',
  
  // Positioning sides
  TOP = 'top',
  LEFT = 'left',
  BOTTOM = 'bottom',
  RIGHT = 'right',
  CENTER = 'center',
  
  // Position adjustment types
  FLIP = 'flip',
  FLIPINVERT = 'flipinvert',
  SHIFT = 'shift',
  
  // Shortcut vars
  QTIP, PROTOTYPE, CORNER, CHECKS,
  PLUGINS = {},
  NAMESPACE = 'qtip',
  ATTR_HAS = 'data-hasqtip',
  ATTR_ID = 'data-qtip-id',
  WIDGET = ['ui-widget', 'ui-tooltip'],
  SELECTOR = '.'+NAMESPACE,
  INACTIVE_EVENTS = 'click dblclick mousedown mouseup mousemove mouseleave mouseenter'.split(' '),
  
  CLASS_FIXED = NAMESPACE+'-fixed',
  CLASS_DEFAULT = NAMESPACE + '-default',
  CLASS_FOCUS = NAMESPACE + '-focus',
  CLASS_HOVER = NAMESPACE + '-hover',
  CLASS_DISABLED = NAMESPACE+'-disabled',
  
  replaceSuffix = '_replacedByqTip',
  oldtitle = 'oldtitle',
  trackingBound,
  
  // Browser detection
  BROWSER = {
  	/*
  	 * IE version detection
  	 *
  	 * Adapted from: http://ajaxian.com/archives/attack-of-the-ie-conditional-comment
  	 * Credit to James Padolsey for the original implemntation!
  	 */
  	ie: (function() {
  		/* eslint-disable no-empty */
  		var v, i;
  		for (
  			v = 4, i = document.createElement('div');
  			(i.innerHTML = '<!--[if gt IE ' + v + ']><i></i><![endif]-->') && i.getElementsByTagName('i')[0];
  			v+=1
  		) {}
  		return v > 4 ? v : NaN;
  		/* eslint-enable no-empty */
  	})(),
  
  	/*
  	 * iOS version detection
  	 */
  	iOS: parseFloat(
  		('' + (/CPU.*OS ([0-9_]{1,5})|(CPU like).*AppleWebKit.*Mobile/i.exec(navigator.userAgent) || [0,''])[1])
  		.replace('undefined', '3_2').replace('_', '.').replace('_', '')
  	) || FALSE
  };
  ;function QTip(target, options, id, attr) {
  	// Elements and ID
  	this.id = id;
  	this.target = target;
  	this.tooltip = NULL;
  	this.elements = { target: target };
  
  	// Internal constructs
  	this._id = NAMESPACE + '-' + id;
  	this.timers = { img: {} };
  	this.options = options;
  	this.plugins = {};
  
  	// Cache object
  	this.cache = {
  		event: {},
  		target: $(),
  		disabled: FALSE,
  		attr: attr,
  		onTooltip: FALSE,
  		lastClass: ''
  	};
  
  	// Set the initial flags
  	this.rendered = this.destroyed = this.disabled = this.waiting =
  		this.hiddenDuringWait = this.positioning = this.triggering = FALSE;
  }
  PROTOTYPE = QTip.prototype;
  
  PROTOTYPE._when = function(deferreds) {
  	return $.when.apply($, deferreds);
  };
  
  PROTOTYPE.render = function(show) {
  	if(this.rendered || this.destroyed) { return this; } // If tooltip has already been rendered, exit
  
  	var self = this,
  		options = this.options,
  		cache = this.cache,
  		elements = this.elements,
  		text = options.content.text,
  		title = options.content.title,
  		button = options.content.button,
  		posOptions = options.position,
  		deferreds = [];
  
  	// Add ARIA attributes to target
  	$.attr(this.target[0], 'aria-describedby', this._id);
  
  	// Create public position object that tracks current position corners
  	cache.posClass = this._createPosClass(
  		(this.position = { my: posOptions.my, at: posOptions.at }).my
  	);
  
  	// Create tooltip element
  	this.tooltip = elements.tooltip = $('<div/>', {
  		'id': this._id,
  		'class': [ NAMESPACE, CLASS_DEFAULT, options.style.classes, cache.posClass ].join(' '),
  		'width': options.style.width || '',
  		'height': options.style.height || '',
  		'tracking': posOptions.target === 'mouse' && posOptions.adjust.mouse,
  
  		/* ARIA specific attributes */
  		'role': 'alert',
  		'aria-live': 'polite',
  		'aria-atomic': FALSE,
  		'aria-describedby': this._id + '-content',
  		'aria-hidden': TRUE
  	})
  	.toggleClass(CLASS_DISABLED, this.disabled)
  	.attr(ATTR_ID, this.id)
  	.data(NAMESPACE, this)
  	.appendTo(posOptions.container)
  	.append(
  		// Create content element
  		elements.content = $('<div />', {
  			'class': NAMESPACE + '-content',
  			'id': this._id + '-content',
  			'aria-atomic': TRUE
  		})
  	);
  
  	// Set rendered flag and prevent redundant reposition calls for now
  	this.rendered = -1;
  	this.positioning = TRUE;
  
  	// Create title...
  	if(title) {
  		this._createTitle();
  
  		// Update title only if its not a callback (called in toggle if so)
  		if(!$.isFunction(title)) {
  			deferreds.push( this._updateTitle(title, FALSE) );
  		}
  	}
  
  	// Create button
  	if(button) { this._createButton(); }
  
  	// Set proper rendered flag and update content if not a callback function (called in toggle)
  	if(!$.isFunction(text)) {
  		deferreds.push( this._updateContent(text, FALSE) );
  	}
  	this.rendered = TRUE;
  
  	// Setup widget classes
  	this._setWidget();
  
  	// Initialize 'render' plugins
  	$.each(PLUGINS, function(name) {
  		var instance;
  		if(this.initialize === 'render' && (instance = this(self))) {
  			self.plugins[name] = instance;
  		}
  	});
  
  	// Unassign initial events and assign proper events
  	this._unassignEvents();
  	this._assignEvents();
  
  	// When deferreds have completed
  	this._when(deferreds).then(function() {
  		// tooltiprender event
  		self._trigger('render');
  
  		// Reset flags
  		self.positioning = FALSE;
  
  		// Show tooltip if not hidden during wait period
  		if(!self.hiddenDuringWait && (options.show.ready || show)) {
  			self.toggle(TRUE, cache.event, FALSE);
  		}
  		self.hiddenDuringWait = FALSE;
  	});
  
  	// Expose API
  	QTIP.api[this.id] = this;
  
  	return this;
  };
  
  PROTOTYPE.destroy = function(immediate) {
  	// Set flag the signify destroy is taking place to plugins
  	// and ensure it only gets destroyed once!
  	if(this.destroyed) { return this.target; }
  
  	function process() {
  		if(this.destroyed) { return; }
  		this.destroyed = TRUE;
  
  		var target = this.target,
  			title = target.attr(oldtitle),
  			timer;
  
  		// Destroy tooltip if rendered
  		if(this.rendered) {
  			this.tooltip.stop(1,0).find('*').remove().end().remove();
  		}
  
  		// Destroy all plugins
  		$.each(this.plugins, function() {
  			this.destroy && this.destroy();
  		});
  
  		// Clear timers
  		for (timer in this.timers) {
  			if (this.timers.hasOwnProperty(timer)) {
  				clearTimeout(this.timers[timer]);
  			}
  		}
  
  		// Remove api object and ARIA attributes
  		target.removeData(NAMESPACE)
  			.removeAttr(ATTR_ID)
  			.removeAttr(ATTR_HAS)
  			.removeAttr('aria-describedby');
  
  		// Reset old title attribute if removed
  		if(this.options.suppress && title) {
  			target.attr('title', title).removeAttr(oldtitle);
  		}
  
  		// Remove qTip events associated with this API
  		this._unassignEvents();
  
  		// Remove ID from used id objects, and delete object references
  		// for better garbage collection and leak protection
  		this.options = this.elements = this.cache = this.timers =
  			this.plugins = this.mouse = NULL;
  
  		// Delete epoxsed API object
  		delete QTIP.api[this.id];
  	}
  
  	// If an immediate destroy is needed
  	if((immediate !== TRUE || this.triggering === 'hide') && this.rendered) {
  		this.tooltip.one('tooltiphidden', $.proxy(process, this));
  		!this.triggering && this.hide();
  	}
  
  	// If we're not in the process of hiding... process
  	else { process.call(this); }
  
  	return this.target;
  };
  ;function invalidOpt(a) {
  	return a === NULL || $.type(a) !== 'object';
  }
  
  function invalidContent(c) {
  	return !($.isFunction(c) || 
              c && c.attr || 
              c.length || 
              $.type(c) === 'object' && (c.jquery || c.then));
  }
  
  // Option object sanitizer
  function sanitizeOptions(opts) {
  	var content, text, ajax, once;
  
  	if(invalidOpt(opts)) { return FALSE; }
  
  	if(invalidOpt(opts.metadata)) {
  		opts.metadata = { type: opts.metadata };
  	}
  
  	if('content' in opts) {
  		content = opts.content;
  
  		if(invalidOpt(content) || content.jquery || content.done) {
  			text = invalidContent(content) ? FALSE : content;
  			content = opts.content = {
  				text: text
  			};
  		}
  		else { text = content.text; }
  
  		// DEPRECATED - Old content.ajax plugin functionality
  		// Converts it into the proper Deferred syntax
  		if('ajax' in content) {
  			ajax = content.ajax;
  			once = ajax && ajax.once !== FALSE;
  			delete content.ajax;
  
  			content.text = function(event, api) {
  				var loading = text || $(this).attr(api.options.content.attr) || 'Loading...',
  
  				deferred = $.ajax(
  					$.extend({}, ajax, { context: api })
  				)
  				.then(ajax.success, NULL, ajax.error)
  				.then(function(newContent) {
  					if(newContent && once) { api.set('content.text', newContent); }
  					return newContent;
  				},
  				function(xhr, status, error) {
  					if(api.destroyed || xhr.status === 0) { return; }
  					api.set('content.text', status + ': ' + error);
  				});
  
  				return !once ? (api.set('content.text', loading), deferred) : loading;
  			};
  		}
  
  		if('title' in content) {
  			if($.isPlainObject(content.title)) {
  				content.button = content.title.button;
  				content.title = content.title.text;
  			}
  
  			if(invalidContent(content.title || FALSE)) {
  				content.title = FALSE;
  			}
  		}
  	}
  
  	if('position' in opts && invalidOpt(opts.position)) {
  		opts.position = { my: opts.position, at: opts.position };
  	}
  
  	if('show' in opts && invalidOpt(opts.show)) {
  		opts.show = opts.show.jquery ? { target: opts.show } :
  			opts.show === TRUE ? { ready: TRUE } : { event: opts.show };
  	}
  
  	if('hide' in opts && invalidOpt(opts.hide)) {
  		opts.hide = opts.hide.jquery ? { target: opts.hide } : { event: opts.hide };
  	}
  
  	if('style' in opts && invalidOpt(opts.style)) {
  		opts.style = { classes: opts.style };
  	}
  
  	// Sanitize plugin options
  	$.each(PLUGINS, function() {
  		this.sanitize && this.sanitize(opts);
  	});
  
  	return opts;
  }
  
  // Setup builtin .set() option checks
  CHECKS = PROTOTYPE.checks = {
  	builtin: {
  		// Core checks
  		'^id$': function(obj, o, v, prev) {
  			var id = v === TRUE ? QTIP.nextid : v,
  				newId = NAMESPACE + '-' + id;
  
  			if(id !== FALSE && id.length > 0 && !$('#'+newId).length) {
  				this._id = newId;
  
  				if(this.rendered) {
  					this.tooltip[0].id = this._id;
  					this.elements.content[0].id = this._id + '-content';
  					this.elements.title[0].id = this._id + '-title';
  				}
  			}
  			else { obj[o] = prev; }
  		},
  		'^prerender': function(obj, o, v) {
  			v && !this.rendered && this.render(this.options.show.ready);
  		},
  
  		// Content checks
  		'^content.text$': function(obj, o, v) {
  			this._updateContent(v);
  		},
  		'^content.attr$': function(obj, o, v, prev) {
  			if(this.options.content.text === this.target.attr(prev)) {
  				this._updateContent( this.target.attr(v) );
  			}
  		},
  		'^content.title$': function(obj, o, v) {
  			// Remove title if content is null
  			if(!v) { return this._removeTitle(); }
  
  			// If title isn't already created, create it now and update
  			v && !this.elements.title && this._createTitle();
  			this._updateTitle(v);
  		},
  		'^content.button$': function(obj, o, v) {
  			this._updateButton(v);
  		},
  		'^content.title.(text|button)$': function(obj, o, v) {
  			this.set('content.'+o, v); // Backwards title.text/button compat
  		},
  
  		// Position checks
  		'^position.(my|at)$': function(obj, o, v){
  			if('string' === typeof v) {
  				this.position[o] = obj[o] = new CORNER(v, o === 'at');
  			}
  		},
  		'^position.container$': function(obj, o, v){
  			this.rendered && this.tooltip.appendTo(v);
  		},
  
  		// Show checks
  		'^show.ready$': function(obj, o, v) {
  			v && (!this.rendered && this.render(TRUE) || this.toggle(TRUE));
  		},
  
  		// Style checks
  		'^style.classes$': function(obj, o, v, p) {
  			this.rendered && this.tooltip.removeClass(p).addClass(v);
  		},
  		'^style.(width|height)': function(obj, o, v) {
  			this.rendered && this.tooltip.css(o, v);
  		},
  		'^style.widget|content.title': function() {
  			this.rendered && this._setWidget();
  		},
  		'^style.def': function(obj, o, v) {
  			this.rendered && this.tooltip.toggleClass(CLASS_DEFAULT, !!v);
  		},
  
  		// Events check
  		'^events.(render|show|move|hide|focus|blur)$': function(obj, o, v) {
  			this.rendered && this.tooltip[($.isFunction(v) ? '' : 'un') + 'bind']('tooltip'+o, v);
  		},
  
  		// Properties which require event reassignment
  		'^(show|hide|position).(event|target|fixed|inactive|leave|distance|viewport|adjust)': function() {
  			if(!this.rendered) { return; }
  
  			// Set tracking flag
  			var posOptions = this.options.position;
  			this.tooltip.attr('tracking', posOptions.target === 'mouse' && posOptions.adjust.mouse);
  
  			// Reassign events
  			this._unassignEvents();
  			this._assignEvents();
  		}
  	}
  };
  
  // Dot notation converter
  function convertNotation(options, notation) {
  	var i = 0, obj, option = options,
  
  	// Split notation into array
  	levels = notation.split('.');
  
  	// Loop through
  	while(option = option[ levels[i++] ]) {
  		if(i < levels.length) { obj = option; }
  	}
  
  	return [obj || options, levels.pop()];
  }
  
  PROTOTYPE.get = function(notation) {
  	if(this.destroyed) { return this; }
  
  	var o = convertNotation(this.options, notation.toLowerCase()),
  		result = o[0][ o[1] ];
  
  	return result.precedance ? result.string() : result;
  };
  
  function setCallback(notation, args) {
  	var category, rule, match;
  
  	for(category in this.checks) {
  		if (!this.checks.hasOwnProperty(category)) { continue; }
  
  		for(rule in this.checks[category]) {
  			if (!this.checks[category].hasOwnProperty(rule)) { continue; }
  
  			if(match = (new RegExp(rule, 'i')).exec(notation)) {
  				args.push(match);
  
  				if(category === 'builtin' || this.plugins[category]) {
  					this.checks[category][rule].apply(
  						this.plugins[category] || this, args
  					);
  				}
  			}
  		}
  	}
  }
  
  var rmove = /^position\.(my|at|adjust|target|container|viewport)|style|content|show\.ready/i,
  	rrender = /^prerender|show\.ready/i;
  
  PROTOTYPE.set = function(option, value) {
  	if(this.destroyed) { return this; }
  
  	var rendered = this.rendered,
  		reposition = FALSE,
  		options = this.options,
  		name;
  
  	// Convert singular option/value pair into object form
  	if('string' === typeof option) {
  		name = option; option = {}; option[name] = value;
  	}
  	else { option = $.extend({}, option); }
  
  	// Set all of the defined options to their new values
  	$.each(option, function(notation, val) {
  		if(rendered && rrender.test(notation)) {
  			delete option[notation]; return;
  		}
  
  		// Set new obj value
  		var obj = convertNotation(options, notation.toLowerCase()), previous;
  		previous = obj[0][ obj[1] ];
  		obj[0][ obj[1] ] = val && val.nodeType ? $(val) : val;
  
  		// Also check if we need to reposition
  		reposition = rmove.test(notation) || reposition;
  
  		// Set the new params for the callback
  		option[notation] = [obj[0], obj[1], val, previous];
  	});
  
  	// Re-sanitize options
  	sanitizeOptions(options);
  
  	/*
  	 * Execute any valid callbacks for the set options
  	 * Also set positioning flag so we don't get loads of redundant repositioning calls.
  	 */
  	this.positioning = TRUE;
  	$.each(option, $.proxy(setCallback, this));
  	this.positioning = FALSE;
  
  	// Update position if needed
  	if(this.rendered && this.tooltip[0].offsetWidth > 0 && reposition) {
  		this.reposition( options.position.target === 'mouse' ? NULL : this.cache.event );
  	}
  
  	return this;
  };
  ;PROTOTYPE._update = function(content, element) {
  	var self = this,
  		cache = this.cache;
  
  	// Make sure tooltip is rendered and content is defined. If not return
  	if(!this.rendered || !content) { return FALSE; }
  
  	// Use function to parse content
  	if($.isFunction(content)) {
  		content = content.call(this.elements.target, cache.event, this) || '';
  	}
  
  	// Handle deferred content
  	if($.isFunction(content.then)) {
  		cache.waiting = TRUE;
  		return content.then(function(c) {
  			cache.waiting = FALSE;
  			return self._update(c, element);
  		}, NULL, function(e) {
  			return self._update(e, element);
  		});
  	}
  
  	// If content is null... return false
  	if(content === FALSE || !content && content !== '') { return FALSE; }
  
  	// Append new content if its a DOM array and show it if hidden
  	if(content.jquery && content.length > 0) {
  		element.empty().append(
  			content.css({ display: 'block', visibility: 'visible' })
  		);
  	}
  
  	// Content is a regular string, insert the new content
  	else { element.html(content); }
  
  	// Wait for content to be loaded, and reposition
  	return this._waitForContent(element).then(function(images) {
  		if(self.rendered && self.tooltip[0].offsetWidth > 0) {
  			self.reposition(cache.event, !images.length);
  		}
  	});
  };
  
  PROTOTYPE._waitForContent = function(element) {
  	var cache = this.cache;
  
  	// Set flag
  	cache.waiting = TRUE;
  
  	// If imagesLoaded is included, ensure images have loaded and return promise
  	return ( $.fn.imagesLoaded ? element.imagesLoaded() : new $.Deferred().resolve([]) )
  		.done(function() { cache.waiting = FALSE; })
  		.promise();
  };
  
  PROTOTYPE._updateContent = function(content, reposition) {
  	this._update(content, this.elements.content, reposition);
  };
  
  PROTOTYPE._updateTitle = function(content, reposition) {
  	if(this._update(content, this.elements.title, reposition) === FALSE) {
  		this._removeTitle(FALSE);
  	}
  };
  
  PROTOTYPE._createTitle = function()
  {
  	var elements = this.elements,
  		id = this._id+'-title';
  
  	// Destroy previous title element, if present
  	if(elements.titlebar) { this._removeTitle(); }
  
  	// Create title bar and title elements
  	elements.titlebar = $('<div />', {
  		'class': NAMESPACE + '-titlebar ' + (this.options.style.widget ? createWidgetClass('header') : '')
  	})
  	.append(
  		elements.title = $('<div />', {
  			'id': id,
  			'class': NAMESPACE + '-title',
  			'aria-atomic': TRUE
  		})
  	)
  	.insertBefore(elements.content)
  
  	// Button-specific events
  	.delegate('.qtip-close', 'mousedown keydown mouseup keyup mouseout', function(event) {
  		$(this).toggleClass('ui-state-active ui-state-focus', event.type.substr(-4) === 'down');
  	})
  	.delegate('.qtip-close', 'mouseover mouseout', function(event){
  		$(this).toggleClass('ui-state-hover', event.type === 'mouseover');
  	});
  
  	// Create button if enabled
  	if(this.options.content.button) { this._createButton(); }
  };
  
  PROTOTYPE._removeTitle = function(reposition)
  {
  	var elements = this.elements;
  
  	if(elements.title) {
  		elements.titlebar.remove();
  		elements.titlebar = elements.title = elements.button = NULL;
  
  		// Reposition if enabled
  		if(reposition !== FALSE) { this.reposition(); }
  	}
  };
  ;PROTOTYPE._createPosClass = function(my) {
  	return NAMESPACE + '-pos-' + (my || this.options.position.my).abbrev();
  };
  
  PROTOTYPE.reposition = function(event, effect) {
  	if(!this.rendered || this.positioning || this.destroyed) { return this; }
  
  	// Set positioning flag
  	this.positioning = TRUE;
  
  	var cache = this.cache,
  		tooltip = this.tooltip,
  		posOptions = this.options.position,
  		target = posOptions.target,
  		my = posOptions.my,
  		at = posOptions.at,
  		viewport = posOptions.viewport,
  		container = posOptions.container,
  		adjust = posOptions.adjust,
  		method = adjust.method.split(' '),
  		tooltipWidth = tooltip.outerWidth(FALSE),
  		tooltipHeight = tooltip.outerHeight(FALSE),
  		targetWidth = 0,
  		targetHeight = 0,
  		type = tooltip.css('position'),
  		position = { left: 0, top: 0 },
  		visible = tooltip[0].offsetWidth > 0,
  		isScroll = event && event.type === 'scroll',
  		win = $(window),
  		doc = container[0].ownerDocument,
  		mouse = this.mouse,
  		pluginCalculations, offset, adjusted, newClass;
  
  	// Check if absolute position was passed
  	if($.isArray(target) && target.length === 2) {
  		// Force left top and set position
  		at = { x: LEFT, y: TOP };
  		position = { left: target[0], top: target[1] };
  	}
  
  	// Check if mouse was the target
  	else if(target === 'mouse') {
  		// Force left top to allow flipping
  		at = { x: LEFT, y: TOP };
  
  		// Use the mouse origin that caused the show event, if distance hiding is enabled
  		if((!adjust.mouse || this.options.hide.distance) && cache.origin && cache.origin.pageX) {
  			event =  cache.origin;
  		}
  
  		// Use cached event for resize/scroll events
  		else if(!event || event && (event.type === 'resize' || event.type === 'scroll')) {
  			event = cache.event;
  		}
  
  		// Otherwise, use the cached mouse coordinates if available
  		else if(mouse && mouse.pageX) {
  			event = mouse;
  		}
  
  		// Calculate body and container offset and take them into account below
  		if(type !== 'static') { position = container.offset(); }
  		if(doc.body.offsetWidth !== (window.innerWidth || doc.documentElement.clientWidth)) {
  			offset = $(document.body).offset();
  		}
  
  		// Use event coordinates for position
  		position = {
  			left: event.pageX - position.left + (offset && offset.left || 0),
  			top: event.pageY - position.top + (offset && offset.top || 0)
  		};
  
  		// Scroll events are a pain, some browsers
  		if(adjust.mouse && isScroll && mouse) {
  			position.left -= (mouse.scrollX || 0) - win.scrollLeft();
  			position.top -= (mouse.scrollY || 0) - win.scrollTop();
  		}
  	}
  
  	// Target wasn't mouse or absolute...
  	else {
  		// Check if event targetting is being used
  		if(target === 'event') {
  			if(event && event.target && event.type !== 'scroll' && event.type !== 'resize') {
  				cache.target = $(event.target);
  			}
  			else if(!event.target) {
  				cache.target = this.elements.target;
  			}
  		}
  		else if(target !== 'event'){
  			cache.target = $(target.jquery ? target : this.elements.target);
  		}
  		target = cache.target;
  
  		// Parse the target into a jQuery object and make sure there's an element present
  		target = $(target).eq(0);
  		if(target.length === 0) { return this; }
  
  		// Check if window or document is the target
  		else if(target[0] === document || target[0] === window) {
  			targetWidth = BROWSER.iOS ? window.innerWidth : target.width();
  			targetHeight = BROWSER.iOS ? window.innerHeight : target.height();
  
  			if(target[0] === window) {
  				position = {
  					top: (viewport || target).scrollTop(),
  					left: (viewport || target).scrollLeft()
  				};
  			}
  		}
  
  		// Check if the target is an <AREA> element
  		else if(PLUGINS.imagemap && target.is('area')) {
  			pluginCalculations = PLUGINS.imagemap(this, target, at, PLUGINS.viewport ? method : FALSE);
  		}
  
  		// Check if the target is an SVG element
  		else if(PLUGINS.svg && target && target[0].ownerSVGElement) {
  			pluginCalculations = PLUGINS.svg(this, target, at, PLUGINS.viewport ? method : FALSE);
  		}
  
  		// Otherwise use regular jQuery methods
  		else {
  			targetWidth = target.outerWidth(FALSE);
  			targetHeight = target.outerHeight(FALSE);
  			position = target.offset();
  		}
  
  		// Parse returned plugin values into proper variables
  		if(pluginCalculations) {
  			targetWidth = pluginCalculations.width;
  			targetHeight = pluginCalculations.height;
  			offset = pluginCalculations.offset;
  			position = pluginCalculations.position;
  		}
  
  		// Adjust position to take into account offset parents
  		position = this.reposition.offset(target, position, container);
  
  		// Adjust for position.fixed tooltips (and also iOS scroll bug in v3.2-4.0 & v4.3-4.3.2)
  		if(BROWSER.iOS > 3.1 && BROWSER.iOS < 4.1 ||
  			BROWSER.iOS >= 4.3 && BROWSER.iOS < 4.33 ||
  			!BROWSER.iOS && type === 'fixed'
  		){
  			position.left -= win.scrollLeft();
  			position.top -= win.scrollTop();
  		}
  
  		// Adjust position relative to target
  		if(!pluginCalculations || pluginCalculations && pluginCalculations.adjustable !== FALSE) {
  			position.left += at.x === RIGHT ? targetWidth : at.x === CENTER ? targetWidth / 2 : 0;
  			position.top += at.y === BOTTOM ? targetHeight : at.y === CENTER ? targetHeight / 2 : 0;
  		}
  	}
  
  	// Adjust position relative to tooltip
  	position.left += adjust.x + (my.x === RIGHT ? -tooltipWidth : my.x === CENTER ? -tooltipWidth / 2 : 0);
  	position.top += adjust.y + (my.y === BOTTOM ? -tooltipHeight : my.y === CENTER ? -tooltipHeight / 2 : 0);
  
  	// Use viewport adjustment plugin if enabled
  	if(PLUGINS.viewport) {
  		adjusted = position.adjusted = PLUGINS.viewport(
  			this, position, posOptions, targetWidth, targetHeight, tooltipWidth, tooltipHeight
  		);
  
  		// Apply offsets supplied by positioning plugin (if used)
  		if(offset && adjusted.left) { position.left += offset.left; }
  		if(offset && adjusted.top) {  position.top += offset.top; }
  
  		// Apply any new 'my' position
  		if(adjusted.my) { this.position.my = adjusted.my; }
  	}
  
  	// Viewport adjustment is disabled, set values to zero
  	else { position.adjusted = { left: 0, top: 0 }; }
  
  	// Set tooltip position class if it's changed
  	if(cache.posClass !== (newClass = this._createPosClass(this.position.my))) {
  		cache.posClass = newClass;
  		tooltip.removeClass(cache.posClass).addClass(newClass);
  	}
  
  	// tooltipmove event
  	if(!this._trigger('move', [position, viewport.elem || viewport], event)) { return this; }
  	delete position.adjusted;
  
  	// If effect is disabled, target it mouse, no animation is defined or positioning gives NaN out, set CSS directly
  	if(effect === FALSE || !visible || isNaN(position.left) || isNaN(position.top) || target === 'mouse' || !$.isFunction(posOptions.effect)) {
  		tooltip.css(position);
  	}
  
  	// Use custom function if provided
  	else if($.isFunction(posOptions.effect)) {
  		posOptions.effect.call(tooltip, this, $.extend({}, position));
  		tooltip.queue(function(next) {
  			// Reset attributes to avoid cross-browser rendering bugs
  			$(this).css({ opacity: '', height: '' });
  			if(BROWSER.ie) { this.style.removeAttribute('filter'); }
  
  			next();
  		});
  	}
  
  	// Set positioning flag
  	this.positioning = FALSE;
  
  	return this;
  };
  
  // Custom (more correct for qTip!) offset calculator
  PROTOTYPE.reposition.offset = function(elem, pos, container) {
  	if(!container[0]) { return pos; }
  
  	var ownerDocument = $(elem[0].ownerDocument),
  		quirks = !!BROWSER.ie && document.compatMode !== 'CSS1Compat',
  		parent = container[0],
  		scrolled, position, parentOffset, overflow;
  
  	function scroll(e, i) {
  		pos.left += i * e.scrollLeft();
  		pos.top += i * e.scrollTop();
  	}
  
  	// Compensate for non-static containers offset
  	do {
  		if((position = $.css(parent, 'position')) !== 'static') {
  			if(position === 'fixed') {
  				parentOffset = parent.getBoundingClientRect();
  				scroll(ownerDocument, -1);
  			}
  			else {
  				parentOffset = $(parent).position();
  				parentOffset.left += parseFloat($.css(parent, 'borderLeftWidth')) || 0;
  				parentOffset.top += parseFloat($.css(parent, 'borderTopWidth')) || 0;
  			}
  
  			pos.left -= parentOffset.left + (parseFloat($.css(parent, 'marginLeft')) || 0);
  			pos.top -= parentOffset.top + (parseFloat($.css(parent, 'marginTop')) || 0);
  
  			// If this is the first parent element with an overflow of "scroll" or "auto", store it
  			if(!scrolled && (overflow = $.css(parent, 'overflow')) !== 'hidden' && overflow !== 'visible') { scrolled = $(parent); }
  		}
  	}
  	while(parent = parent.offsetParent);
  
  	// Compensate for containers scroll if it also has an offsetParent (or in IE quirks mode)
  	if(scrolled && (scrolled[0] !== ownerDocument[0] || quirks)) {
  		scroll(scrolled, 1);
  	}
  
  	return pos;
  };
  
  // Corner class
  var C = (CORNER = PROTOTYPE.reposition.Corner = function(corner, forceY) {
  	corner = ('' + corner).replace(/([A-Z])/, ' $1').replace(/middle/gi, CENTER).toLowerCase();
  	this.x = (corner.match(/left|right/i) || corner.match(/center/) || ['inherit'])[0].toLowerCase();
  	this.y = (corner.match(/top|bottom|center/i) || ['inherit'])[0].toLowerCase();
  	this.forceY = !!forceY;
  
  	var f = corner.charAt(0);
  	this.precedance = f === 't' || f === 'b' ? Y : X;
  }).prototype;
  
  C.invert = function(z, center) {
  	this[z] = this[z] === LEFT ? RIGHT : this[z] === RIGHT ? LEFT : center || this[z];
  };
  
  C.string = function(join) {
  	var x = this.x, y = this.y;
  
  	var result = x !== y ?
  		x === 'center' || y !== 'center' && (this.precedance === Y || this.forceY) ? 
  			[y,x] : 
  			[x,y] :
  		[x];
  
  	return join !== false ? result.join(' ') : result;
  };
  
  C.abbrev = function() {
  	var result = this.string(false);
  	return result[0].charAt(0) + (result[1] && result[1].charAt(0) || '');
  };
  
  C.clone = function() {
  	return new CORNER( this.string(), this.forceY );
  };
  
  ;
  PROTOTYPE.toggle = function(state, event) {
  	var cache = this.cache,
  		options = this.options,
  		tooltip = this.tooltip;
  
  	// Try to prevent flickering when tooltip overlaps show element
  	if(event) {
  		if((/over|enter/).test(event.type) && cache.event && (/out|leave/).test(cache.event.type) &&
  			options.show.target.add(event.target).length === options.show.target.length &&
  			tooltip.has(event.relatedTarget).length) {
  			return this;
  		}
  
  		// Cache event
  		cache.event = $.event.fix(event);
  	}
  
  	// If we're currently waiting and we've just hidden... stop it
  	this.waiting && !state && (this.hiddenDuringWait = TRUE);
  
  	// Render the tooltip if showing and it isn't already
  	if(!this.rendered) { return state ? this.render(1) : this; }
  	else if(this.destroyed || this.disabled) { return this; }
  
  	var type = state ? 'show' : 'hide',
  		opts = this.options[type],
  		posOptions = this.options.position,
  		contentOptions = this.options.content,
  		width = this.tooltip.css('width'),
  		visible = this.tooltip.is(':visible'),
  		animate = state || opts.target.length === 1,
  		sameTarget = !event || opts.target.length < 2 || cache.target[0] === event.target,
  		identicalState, allow, after;
  
  	// Detect state if valid one isn't provided
  	if((typeof state).search('boolean|number')) { state = !visible; }
  
  	// Check if the tooltip is in an identical state to the new would-be state
  	identicalState = !tooltip.is(':animated') && visible === state && sameTarget;
  
  	// Fire tooltip(show/hide) event and check if destroyed
  	allow = !identicalState ? !!this._trigger(type, [90]) : NULL;
  
  	// Check to make sure the tooltip wasn't destroyed in the callback
  	if(this.destroyed) { return this; }
  
  	// If the user didn't stop the method prematurely and we're showing the tooltip, focus it
  	if(allow !== FALSE && state) { this.focus(event); }
  
  	// If the state hasn't changed or the user stopped it, return early
  	if(!allow || identicalState) { return this; }
  
  	// Set ARIA hidden attribute
  	$.attr(tooltip[0], 'aria-hidden', !!!state);
  
  	// Execute state specific properties
  	if(state) {
  		// Store show origin coordinates
  		this.mouse && (cache.origin = $.event.fix(this.mouse));
  
  		// Update tooltip content & title if it's a dynamic function
  		if($.isFunction(contentOptions.text)) { this._updateContent(contentOptions.text, FALSE); }
  		if($.isFunction(contentOptions.title)) { this._updateTitle(contentOptions.title, FALSE); }
  
  		// Cache mousemove events for positioning purposes (if not already tracking)
  		if(!trackingBound && posOptions.target === 'mouse' && posOptions.adjust.mouse) {
  			$(document).bind('mousemove.'+NAMESPACE, this._storeMouse);
  			trackingBound = TRUE;
  		}
  
  		// Update the tooltip position (set width first to prevent viewport/max-width issues)
  		if(!width) { tooltip.css('width', tooltip.outerWidth(FALSE)); }
  		this.reposition(event, arguments[2]);
  		if(!width) { tooltip.css('width', ''); }
  
  		// Hide other tooltips if tooltip is solo
  		if(!!opts.solo) {
  			(typeof opts.solo === 'string' ? $(opts.solo) : $(SELECTOR, opts.solo))
  				.not(tooltip).not(opts.target).qtip('hide', new $.Event('tooltipsolo'));
  		}
  	}
  	else {
  		// Clear show timer if we're hiding
  		clearTimeout(this.timers.show);
  
  		// Remove cached origin on hide
  		delete cache.origin;
  
  		// Remove mouse tracking event if not needed (all tracking qTips are hidden)
  		if(trackingBound && !$(SELECTOR+'[tracking="true"]:visible', opts.solo).not(tooltip).length) {
  			$(document).unbind('mousemove.'+NAMESPACE);
  			trackingBound = FALSE;
  		}
  
  		// Blur the tooltip
  		this.blur(event);
  	}
  
  	// Define post-animation, state specific properties
  	after = $.proxy(function() {
  		if(state) {
  			// Prevent antialias from disappearing in IE by removing filter
  			if(BROWSER.ie) { tooltip[0].style.removeAttribute('filter'); }
  
  			// Remove overflow setting to prevent tip bugs
  			tooltip.css('overflow', '');
  
  			// Autofocus elements if enabled
  			if('string' === typeof opts.autofocus) {
  				$(this.options.show.autofocus, tooltip).focus();
  			}
  
  			// If set, hide tooltip when inactive for delay period
  			this.options.show.target.trigger('qtip-'+this.id+'-inactive');
  		}
  		else {
  			// Reset CSS states
  			tooltip.css({
  				display: '',
  				visibility: '',
  				opacity: '',
  				left: '',
  				top: ''
  			});
  		}
  
  		// tooltipvisible/tooltiphidden events
  		this._trigger(state ? 'visible' : 'hidden');
  	}, this);
  
  	// If no effect type is supplied, use a simple toggle
  	if(opts.effect === FALSE || animate === FALSE) {
  		tooltip[ type ]();
  		after();
  	}
  
  	// Use custom function if provided
  	else if($.isFunction(opts.effect)) {
  		tooltip.stop(1, 1);
  		opts.effect.call(tooltip, this);
  		tooltip.queue('fx', function(n) {
  			after(); n();
  		});
  	}
  
  	// Use basic fade function by default
  	else { tooltip.fadeTo(90, state ? 1 : 0, after); }
  
  	// If inactive hide method is set, active it
  	if(state) { opts.target.trigger('qtip-'+this.id+'-inactive'); }
  
  	return this;
  };
  
  PROTOTYPE.show = function(event) { return this.toggle(TRUE, event); };
  
  PROTOTYPE.hide = function(event) { return this.toggle(FALSE, event); };
  ;PROTOTYPE.focus = function(event) {
  	if(!this.rendered || this.destroyed) { return this; }
  
  	var qtips = $(SELECTOR),
  		tooltip = this.tooltip,
  		curIndex = parseInt(tooltip[0].style.zIndex, 10),
  		newIndex = QTIP.zindex + qtips.length;
  
  	// Only update the z-index if it has changed and tooltip is not already focused
  	if(!tooltip.hasClass(CLASS_FOCUS)) {
  		// tooltipfocus event
  		if(this._trigger('focus', [newIndex], event)) {
  			// Only update z-index's if they've changed
  			if(curIndex !== newIndex) {
  				// Reduce our z-index's and keep them properly ordered
  				qtips.each(function() {
  					if(this.style.zIndex > curIndex) {
  						this.style.zIndex = this.style.zIndex - 1;
  					}
  				});
  
  				// Fire blur event for focused tooltip
  				qtips.filter('.' + CLASS_FOCUS).qtip('blur', event);
  			}
  
  			// Set the new z-index
  			tooltip.addClass(CLASS_FOCUS)[0].style.zIndex = newIndex;
  		}
  	}
  
  	return this;
  };
  
  PROTOTYPE.blur = function(event) {
  	if(!this.rendered || this.destroyed) { return this; }
  
  	// Set focused status to FALSE
  	this.tooltip.removeClass(CLASS_FOCUS);
  
  	// tooltipblur event
  	this._trigger('blur', [ this.tooltip.css('zIndex') ], event);
  
  	return this;
  };
  ;PROTOTYPE.disable = function(state) {
  	if(this.destroyed) { return this; }
  
  	// If 'toggle' is passed, toggle the current state
  	if(state === 'toggle') {
  		state = !(this.rendered ? this.tooltip.hasClass(CLASS_DISABLED) : this.disabled);
  	}
  
  	// Disable if no state passed
  	else if('boolean' !== typeof state) {
  		state = TRUE;
  	}
  
  	if(this.rendered) {
  		this.tooltip.toggleClass(CLASS_DISABLED, state)
  			.attr('aria-disabled', state);
  	}
  
  	this.disabled = !!state;
  
  	return this;
  };
  
  PROTOTYPE.enable = function() { return this.disable(FALSE); };
  ;PROTOTYPE._createButton = function()
  {
  	var self = this,
  		elements = this.elements,
  		tooltip = elements.tooltip,
  		button = this.options.content.button,
  		isString = typeof button === 'string',
  		close = isString ? button : 'Close tooltip';
  
  	if(elements.button) { elements.button.remove(); }
  
  	// Use custom button if one was supplied by user, else use default
  	if(button.jquery) {
  		elements.button = button;
  	}
  	else {
  		elements.button = $('<a />', {
  			'class': 'qtip-close ' + (this.options.style.widget ? '' : NAMESPACE+'-icon'),
  			'title': close,
  			'aria-label': close
  		})
  		.prepend(
  			$('<span />', {
  				'class': 'ui-icon ui-icon-close',
  				'html': '&times;'
  			})
  		);
  	}
  
  	// Create button and setup attributes
  	elements.button.appendTo(elements.titlebar || tooltip)
  		.attr('role', 'button')
  		.click(function(event) {
  			if(!tooltip.hasClass(CLASS_DISABLED)) { self.hide(event); }
  			return FALSE;
  		});
  };
  
  PROTOTYPE._updateButton = function(button)
  {
  	// Make sure tooltip is rendered and if not, return
  	if(!this.rendered) { return FALSE; }
  
  	var elem = this.elements.button;
  	if(button) { this._createButton(); }
  	else { elem.remove(); }
  };
  ;// Widget class creator
  function createWidgetClass(cls) {
  	return WIDGET.concat('').join(cls ? '-'+cls+' ' : ' ');
  }
  
  // Widget class setter method
  PROTOTYPE._setWidget = function()
  {
  	var on = this.options.style.widget,
  		elements = this.elements,
  		tooltip = elements.tooltip,
  		disabled = tooltip.hasClass(CLASS_DISABLED);
  
  	tooltip.removeClass(CLASS_DISABLED);
  	CLASS_DISABLED = on ? 'ui-state-disabled' : 'qtip-disabled';
  	tooltip.toggleClass(CLASS_DISABLED, disabled);
  
  	tooltip.toggleClass('ui-helper-reset '+createWidgetClass(), on).toggleClass(CLASS_DEFAULT, this.options.style.def && !on);
  
  	if(elements.content) {
  		elements.content.toggleClass( createWidgetClass('content'), on);
  	}
  	if(elements.titlebar) {
  		elements.titlebar.toggleClass( createWidgetClass('header'), on);
  	}
  	if(elements.button) {
  		elements.button.toggleClass(NAMESPACE+'-icon', !on);
  	}
  };
  ;function delay(callback, duration) {
  	// If tooltip has displayed, start hide timer
  	if(duration > 0) {
  		return setTimeout(
  			$.proxy(callback, this), duration
  		);
  	}
  	else{ callback.call(this); }
  }
  
  function showMethod(event) {
  	if(this.tooltip.hasClass(CLASS_DISABLED)) { return; }
  
  	// Clear hide timers
  	clearTimeout(this.timers.show);
  	clearTimeout(this.timers.hide);
  
  	// Start show timer
  	this.timers.show = delay.call(this,
  		function() { this.toggle(TRUE, event); },
  		this.options.show.delay
  	);
  }
  
  function hideMethod(event) {
  	if(this.tooltip.hasClass(CLASS_DISABLED) || this.destroyed) { return; }
  
  	// Check if new target was actually the tooltip element
  	var relatedTarget = $(event.relatedTarget),
  		ontoTooltip = relatedTarget.closest(SELECTOR)[0] === this.tooltip[0],
  		ontoTarget = relatedTarget[0] === this.options.show.target[0];
  
  	// Clear timers and stop animation queue
  	clearTimeout(this.timers.show);
  	clearTimeout(this.timers.hide);
  
  	// Prevent hiding if tooltip is fixed and event target is the tooltip.
  	// Or if mouse positioning is enabled and cursor momentarily overlaps
  	if(this !== relatedTarget[0] &&
  		(this.options.position.target === 'mouse' && ontoTooltip) ||
  		this.options.hide.fixed && (
  			(/mouse(out|leave|move)/).test(event.type) && (ontoTooltip || ontoTarget))
  		)
  	{
  		/* eslint-disable no-empty */
  		try {
  			event.preventDefault();
  			event.stopImmediatePropagation();
  		} catch(e) {}
  		/* eslint-enable no-empty */
  
  		return;
  	}
  
  	// If tooltip has displayed, start hide timer
  	this.timers.hide = delay.call(this,
  		function() { this.toggle(FALSE, event); },
  		this.options.hide.delay,
  		this
  	);
  }
  
  function inactiveMethod(event) {
  	if(this.tooltip.hasClass(CLASS_DISABLED) || !this.options.hide.inactive) { return; }
  
  	// Clear timer
  	clearTimeout(this.timers.inactive);
  
  	this.timers.inactive = delay.call(this,
  		function(){ this.hide(event); },
  		this.options.hide.inactive
  	);
  }
  
  function repositionMethod(event) {
  	if(this.rendered && this.tooltip[0].offsetWidth > 0) { this.reposition(event); }
  }
  
  // Store mouse coordinates
  PROTOTYPE._storeMouse = function(event) {
  	(this.mouse = $.event.fix(event)).type = 'mousemove';
  	return this;
  };
  
  // Bind events
  PROTOTYPE._bind = function(targets, events, method, suffix, context) {
  	if(!targets || !method || !events.length) { return; }
  	var ns = '.' + this._id + (suffix ? '-'+suffix : '');
  	$(targets).bind(
  		(events.split ? events : events.join(ns + ' ')) + ns,
  		$.proxy(method, context || this)
  	);
  	return this;
  };
  PROTOTYPE._unbind = function(targets, suffix) {
  	targets && $(targets).unbind('.' + this._id + (suffix ? '-'+suffix : ''));
  	return this;
  };
  
  // Global delegation helper
  function delegate(selector, events, method) {
  	$(document.body).delegate(selector,
  		(events.split ? events : events.join('.'+NAMESPACE + ' ')) + '.'+NAMESPACE,
  		function() {
  			var api = QTIP.api[ $.attr(this, ATTR_ID) ];
  			api && !api.disabled && method.apply(api, arguments);
  		}
  	);
  }
  // Event trigger
  PROTOTYPE._trigger = function(type, args, event) {
  	var callback = new $.Event('tooltip'+type);
  	callback.originalEvent = event && $.extend({}, event) || this.cache.event || NULL;
  
  	this.triggering = type;
  	this.tooltip.trigger(callback, [this].concat(args || []));
  	this.triggering = FALSE;
  
  	return !callback.isDefaultPrevented();
  };
  
  PROTOTYPE._bindEvents = function(showEvents, hideEvents, showTargets, hideTargets, showCallback, hideCallback) {
  	// Get tasrgets that lye within both
  	var similarTargets = showTargets.filter( hideTargets ).add( hideTargets.filter(showTargets) ),
  		toggleEvents = [];
  
  	// If hide and show targets are the same...
  	if(similarTargets.length) {
  
  		// Filter identical show/hide events
  		$.each(hideEvents, function(i, type) {
  			var showIndex = $.inArray(type, showEvents);
  
  			// Both events are identical, remove from both hide and show events
  			// and append to toggleEvents
  			showIndex > -1 && toggleEvents.push( showEvents.splice( showIndex, 1 )[0] );
  		});
  
  		// Toggle events are special case of identical show/hide events, which happen in sequence
  		if(toggleEvents.length) {
  			// Bind toggle events to the similar targets
  			this._bind(similarTargets, toggleEvents, function(event) {
  				var state = this.rendered ? this.tooltip[0].offsetWidth > 0 : false;
  				(state ? hideCallback : showCallback).call(this, event);
  			});
  
  			// Remove the similar targets from the regular show/hide bindings
  			showTargets = showTargets.not(similarTargets);
  			hideTargets = hideTargets.not(similarTargets);
  		}
  	}
  
  	// Apply show/hide/toggle events
  	this._bind(showTargets, showEvents, showCallback);
  	this._bind(hideTargets, hideEvents, hideCallback);
  };
  
  PROTOTYPE._assignInitialEvents = function(event) {
  	var options = this.options,
  		showTarget = options.show.target,
  		hideTarget = options.hide.target,
  		showEvents = options.show.event ? $.trim('' + options.show.event).split(' ') : [],
  		hideEvents = options.hide.event ? $.trim('' + options.hide.event).split(' ') : [];
  
  	// Catch remove/removeqtip events on target element to destroy redundant tooltips
  	this._bind(this.elements.target, ['remove', 'removeqtip'], function() {
  		this.destroy(true);
  	}, 'destroy');
  
  	/*
  	 * Make sure hoverIntent functions properly by using mouseleave as a hide event if
  	 * mouseenter/mouseout is used for show.event, even if it isn't in the users options.
  	 */
  	if(/mouse(over|enter)/i.test(options.show.event) && !/mouse(out|leave)/i.test(options.hide.event)) {
  		hideEvents.push('mouseleave');
  	}
  
  	/*
  	 * Also make sure initial mouse targetting works correctly by caching mousemove coords
  	 * on show targets before the tooltip has rendered. Also set onTarget when triggered to
  	 * keep mouse tracking working.
  	 */
  	this._bind(showTarget, 'mousemove', function(moveEvent) {
  		this._storeMouse(moveEvent);
  		this.cache.onTarget = TRUE;
  	});
  
  	// Define hoverIntent function
  	function hoverIntent(hoverEvent) {
  		// Only continue if tooltip isn't disabled
  		if(this.disabled || this.destroyed) { return FALSE; }
  
  		// Cache the event data
  		this.cache.event = hoverEvent && $.event.fix(hoverEvent);
  		this.cache.target = hoverEvent && $(hoverEvent.target);
  
  		// Start the event sequence
  		clearTimeout(this.timers.show);
  		this.timers.show = delay.call(this,
  			function() { this.render(typeof hoverEvent === 'object' || options.show.ready); },
  			options.prerender ? 0 : options.show.delay
  		);
  	}
  
  	// Filter and bind events
  	this._bindEvents(showEvents, hideEvents, showTarget, hideTarget, hoverIntent, function() {
  		if(!this.timers) { return FALSE; }
  		clearTimeout(this.timers.show);
  	});
  
  	// Prerendering is enabled, create tooltip now
  	if(options.show.ready || options.prerender) { hoverIntent.call(this, event); }
  };
  
  // Event assignment method
  PROTOTYPE._assignEvents = function() {
  	var self = this,
  		options = this.options,
  		posOptions = options.position,
  
  		tooltip = this.tooltip,
  		showTarget = options.show.target,
  		hideTarget = options.hide.target,
  		containerTarget = posOptions.container,
  		viewportTarget = posOptions.viewport,
  		documentTarget = $(document),
  		windowTarget = $(window),
  
  		showEvents = options.show.event ? $.trim('' + options.show.event).split(' ') : [],
  		hideEvents = options.hide.event ? $.trim('' + options.hide.event).split(' ') : [];
  
  
  	// Assign passed event callbacks
  	$.each(options.events, function(name, callback) {
  		self._bind(tooltip, name === 'toggle' ? ['tooltipshow','tooltiphide'] : ['tooltip'+name], callback, null, tooltip);
  	});
  
  	// Hide tooltips when leaving current window/frame (but not select/option elements)
  	if(/mouse(out|leave)/i.test(options.hide.event) && options.hide.leave === 'window') {
  		this._bind(documentTarget, ['mouseout', 'blur'], function(event) {
  			if(!/select|option/.test(event.target.nodeName) && !event.relatedTarget) {
  				this.hide(event);
  			}
  		});
  	}
  
  	// Enable hide.fixed by adding appropriate class
  	if(options.hide.fixed) {
  		hideTarget = hideTarget.add( tooltip.addClass(CLASS_FIXED) );
  	}
  
  	/*
  	 * Make sure hoverIntent functions properly by using mouseleave to clear show timer if
  	 * mouseenter/mouseout is used for show.event, even if it isn't in the users options.
  	 */
  	else if(/mouse(over|enter)/i.test(options.show.event)) {
  		this._bind(hideTarget, 'mouseleave', function() {
  			clearTimeout(this.timers.show);
  		});
  	}
  
  	// Hide tooltip on document mousedown if unfocus events are enabled
  	if(('' + options.hide.event).indexOf('unfocus') > -1) {
  		this._bind(containerTarget.closest('html'), ['mousedown', 'touchstart'], function(event) {
  			var elem = $(event.target),
  				enabled = this.rendered && !this.tooltip.hasClass(CLASS_DISABLED) && this.tooltip[0].offsetWidth > 0,
  				isAncestor = elem.parents(SELECTOR).filter(this.tooltip[0]).length > 0;
  
  			if(elem[0] !== this.target[0] && elem[0] !== this.tooltip[0] && !isAncestor &&
  				!this.target.has(elem[0]).length && enabled
  			) {
  				this.hide(event);
  			}
  		});
  	}
  
  	// Check if the tooltip hides when inactive
  	if('number' === typeof options.hide.inactive) {
  		// Bind inactive method to show target(s) as a custom event
  		this._bind(showTarget, 'qtip-'+this.id+'-inactive', inactiveMethod, 'inactive');
  
  		// Define events which reset the 'inactive' event handler
  		this._bind(hideTarget.add(tooltip), QTIP.inactiveEvents, inactiveMethod);
  	}
  
  	// Filter and bind events
  	this._bindEvents(showEvents, hideEvents, showTarget, hideTarget, showMethod, hideMethod);
  
  	// Mouse movement bindings
  	this._bind(showTarget.add(tooltip), 'mousemove', function(event) {
  		// Check if the tooltip hides when mouse is moved a certain distance
  		if('number' === typeof options.hide.distance) {
  			var origin = this.cache.origin || {},
  				limit = this.options.hide.distance,
  				abs = Math.abs;
  
  			// Check if the movement has gone beyond the limit, and hide it if so
  			if(abs(event.pageX - origin.pageX) >= limit || abs(event.pageY - origin.pageY) >= limit) {
  				this.hide(event);
  			}
  		}
  
  		// Cache mousemove coords on show targets
  		this._storeMouse(event);
  	});
  
  	// Mouse positioning events
  	if(posOptions.target === 'mouse') {
  		// If mouse adjustment is on...
  		if(posOptions.adjust.mouse) {
  			// Apply a mouseleave event so we don't get problems with overlapping
  			if(options.hide.event) {
  				// Track if we're on the target or not
  				this._bind(showTarget, ['mouseenter', 'mouseleave'], function(event) {
  					if(!this.cache) {return FALSE; }
  					this.cache.onTarget = event.type === 'mouseenter';
  				});
  			}
  
  			// Update tooltip position on mousemove
  			this._bind(documentTarget, 'mousemove', function(event) {
  				// Update the tooltip position only if the tooltip is visible and adjustment is enabled
  				if(this.rendered && this.cache.onTarget && !this.tooltip.hasClass(CLASS_DISABLED) && this.tooltip[0].offsetWidth > 0) {
  					this.reposition(event);
  				}
  			});
  		}
  	}
  
  	// Adjust positions of the tooltip on window resize if enabled
  	if(posOptions.adjust.resize || viewportTarget.length) {
  		this._bind( $.event.special.resize ? viewportTarget : windowTarget, 'resize', repositionMethod );
  	}
  
  	// Adjust tooltip position on scroll of the window or viewport element if present
  	if(posOptions.adjust.scroll) {
  		this._bind( windowTarget.add(posOptions.container), 'scroll', repositionMethod );
  	}
  };
  
  // Un-assignment method
  PROTOTYPE._unassignEvents = function() {
  	var options = this.options,
  		showTargets = options.show.target,
  		hideTargets = options.hide.target,
  		targets = $.grep([
  			this.elements.target[0],
  			this.rendered && this.tooltip[0],
  			options.position.container[0],
  			options.position.viewport[0],
  			options.position.container.closest('html')[0], // unfocus
  			window,
  			document
  		], function(i) {
  			return typeof i === 'object';
  		});
  
  	// Add show and hide targets if they're valid
  	if(showTargets && showTargets.toArray) {
  		targets = targets.concat(showTargets.toArray());
  	}
  	if(hideTargets && hideTargets.toArray) {
  		targets = targets.concat(hideTargets.toArray());
  	}
  
  	// Unbind the events
  	this._unbind(targets)
  		._unbind(targets, 'destroy')
  		._unbind(targets, 'inactive');
  };
  
  // Apply common event handlers using delegate (avoids excessive .bind calls!)
  $(function() {
  	delegate(SELECTOR, ['mouseenter', 'mouseleave'], function(event) {
  		var state = event.type === 'mouseenter',
  			tooltip = $(event.currentTarget),
  			target = $(event.relatedTarget || event.target),
  			options = this.options;
  
  		// On mouseenter...
  		if(state) {
  			// Focus the tooltip on mouseenter (z-index stacking)
  			this.focus(event);
  
  			// Clear hide timer on tooltip hover to prevent it from closing
  			tooltip.hasClass(CLASS_FIXED) && !tooltip.hasClass(CLASS_DISABLED) && clearTimeout(this.timers.hide);
  		}
  
  		// On mouseleave...
  		else {
  			// When mouse tracking is enabled, hide when we leave the tooltip and not onto the show target (if a hide event is set)
  			if(options.position.target === 'mouse' && options.position.adjust.mouse &&
  				options.hide.event && options.show.target && !target.closest(options.show.target[0]).length) {
  				this.hide(event);
  			}
  		}
  
  		// Add hover class
  		tooltip.toggleClass(CLASS_HOVER, state);
  	});
  
  	// Define events which reset the 'inactive' event handler
  	delegate('['+ATTR_ID+']', INACTIVE_EVENTS, inactiveMethod);
  });
  ;// Initialization method
  function init(elem, id, opts) {
  	var obj, posOptions, attr, config, title,
  
  	// Setup element references
  	docBody = $(document.body),
  
  	// Use document body instead of document element if needed
  	newTarget = elem[0] === document ? docBody : elem,
  
  	// Grab metadata from element if plugin is present
  	metadata = elem.metadata ? elem.metadata(opts.metadata) : NULL,
  
  	// If metadata type if HTML5, grab 'name' from the object instead, or use the regular data object otherwise
  	metadata5 = opts.metadata.type === 'html5' && metadata ? metadata[opts.metadata.name] : NULL,
  
  	// Grab data from metadata.name (or data-qtipopts as fallback) using .data() method,
  	html5 = elem.data(opts.metadata.name || 'qtipopts');
  
  	// If we don't get an object returned attempt to parse it manualyl without parseJSON
  	/* eslint-disable no-empty */
  	try { html5 = typeof html5 === 'string' ? $.parseJSON(html5) : html5; }
  	catch(e) {}
  	/* eslint-enable no-empty */
  
  	// Merge in and sanitize metadata
  	config = $.extend(TRUE, {}, QTIP.defaults, opts,
  		typeof html5 === 'object' ? sanitizeOptions(html5) : NULL,
  		sanitizeOptions(metadata5 || metadata));
  
  	// Re-grab our positioning options now we've merged our metadata and set id to passed value
  	posOptions = config.position;
  	config.id = id;
  
  	// Setup missing content if none is detected
  	if('boolean' === typeof config.content.text) {
  		attr = elem.attr(config.content.attr);
  
  		// Grab from supplied attribute if available
  		if(config.content.attr !== FALSE && attr) { config.content.text = attr; }
  
  		// No valid content was found, abort render
  		else { return FALSE; }
  	}
  
  	// Setup target options
  	if(!posOptions.container.length) { posOptions.container = docBody; }
  	if(posOptions.target === FALSE) { posOptions.target = newTarget; }
  	if(config.show.target === FALSE) { config.show.target = newTarget; }
  	if(config.show.solo === TRUE) { config.show.solo = posOptions.container.closest('body'); }
  	if(config.hide.target === FALSE) { config.hide.target = newTarget; }
  	if(config.position.viewport === TRUE) { config.position.viewport = posOptions.container; }
  
  	// Ensure we only use a single container
  	posOptions.container = posOptions.container.eq(0);
  
  	// Convert position corner values into x and y strings
  	posOptions.at = new CORNER(posOptions.at, TRUE);
  	posOptions.my = new CORNER(posOptions.my);
  
  	// Destroy previous tooltip if overwrite is enabled, or skip element if not
  	if(elem.data(NAMESPACE)) {
  		if(config.overwrite) {
  			elem.qtip('destroy', true);
  		}
  		else if(config.overwrite === FALSE) {
  			return FALSE;
  		}
  	}
  
  	// Add has-qtip attribute
  	elem.attr(ATTR_HAS, id);
  
  	// Remove title attribute and store it if present
  	if(config.suppress && (title = elem.attr('title'))) {
  		// Final attr call fixes event delegatiom and IE default tooltip showing problem
  		elem.removeAttr('title').attr(oldtitle, title).attr('title', '');
  	}
  
  	// Initialize the tooltip and add API reference
  	obj = new QTip(elem, config, id, !!attr);
  	elem.data(NAMESPACE, obj);
  
  	return obj;
  }
  
  // jQuery $.fn extension method
  QTIP = $.fn.qtip = function(options, notation, newValue)
  {
  	var command = ('' + options).toLowerCase(), // Parse command
  		returned = NULL,
  		args = $.makeArray(arguments).slice(1),
  		event = args[args.length - 1],
  		opts = this[0] ? $.data(this[0], NAMESPACE) : NULL;
  
  	// Check for API request
  	if(!arguments.length && opts || command === 'api') {
  		return opts;
  	}
  
  	// Execute API command if present
  	else if('string' === typeof options) {
  		this.each(function() {
  			var api = $.data(this, NAMESPACE);
  			if(!api) { return TRUE; }
  
  			// Cache the event if possible
  			if(event && event.timeStamp) { api.cache.event = event; }
  
  			// Check for specific API commands
  			if(notation && (command === 'option' || command === 'options')) {
  				if(newValue !== undefined || $.isPlainObject(notation)) {
  					api.set(notation, newValue);
  				}
  				else {
  					returned = api.get(notation);
  					return FALSE;
  				}
  			}
  
  			// Execute API command
  			else if(api[command]) {
  				api[command].apply(api, args);
  			}
  		});
  
  		return returned !== NULL ? returned : this;
  	}
  
  	// No API commands. validate provided options and setup qTips
  	else if('object' === typeof options || !arguments.length) {
  		// Sanitize options first
  		opts = sanitizeOptions($.extend(TRUE, {}, options));
  
  		return this.each(function(i) {
  			var api, id;
  
  			// Find next available ID, or use custom ID if provided
  			id = $.isArray(opts.id) ? opts.id[i] : opts.id;
  			id = !id || id === FALSE || id.length < 1 || QTIP.api[id] ? QTIP.nextid++ : id;
  
  			// Initialize the qTip and re-grab newly sanitized options
  			api = init($(this), id, opts);
  			if(api === FALSE) { return TRUE; }
  			else { QTIP.api[id] = api; }
  
  			// Initialize plugins
  			$.each(PLUGINS, function() {
  				if(this.initialize === 'initialize') { this(api); }
  			});
  
  			// Assign initial pre-render events
  			api._assignInitialEvents(event);
  		});
  	}
  };
  
  // Expose class
  $.qtip = QTip;
  
  // Populated in render method
  QTIP.api = {};
  ;$.each({
  	/* Allow other plugins to successfully retrieve the title of an element with a qTip applied */
  	attr: function(attr, val) {
  		if(this.length) {
  			var self = this[0],
  				title = 'title',
  				api = $.data(self, 'qtip');
  
  			if(attr === title && api && api.options && 'object' === typeof api && 'object' === typeof api.options && api.options.suppress) {
  				if(arguments.length < 2) {
  					return $.attr(self, oldtitle);
  				}
  
  				// If qTip is rendered and title was originally used as content, update it
  				if(api && api.options.content.attr === title && api.cache.attr) {
  					api.set('content.text', val);
  				}
  
  				// Use the regular attr method to set, then cache the result
  				return this.attr(oldtitle, val);
  			}
  		}
  
  		return $.fn['attr'+replaceSuffix].apply(this, arguments);
  	},
  
  	/* Allow clone to correctly retrieve cached title attributes */
  	clone: function(keepData) {
  		// Clone our element using the real clone method
  		var elems = $.fn['clone'+replaceSuffix].apply(this, arguments);
  
  		// Grab all elements with an oldtitle set, and change it to regular title attribute, if keepData is false
  		if(!keepData) {
  			elems.filter('['+oldtitle+']').attr('title', function() {
  				return $.attr(this, oldtitle);
  			})
  			.removeAttr(oldtitle);
  		}
  
  		return elems;
  	}
  }, function(name, func) {
  	if(!func || $.fn[name+replaceSuffix]) { return TRUE; }
  
  	var old = $.fn[name+replaceSuffix] = $.fn[name];
  	$.fn[name] = function() {
  		return func.apply(this, arguments) || old.apply(this, arguments);
  	};
  });
  
  /* Fire off 'removeqtip' handler in $.cleanData if jQuery UI not present (it already does similar).
   * This snippet is taken directly from jQuery UI source code found here:
   *     http://code.jquery.com/ui/jquery-ui-git.js
   */
  if(!$.ui) {
  	$['cleanData'+replaceSuffix] = $.cleanData;
  	$.cleanData = function( elems ) {
  		for(var i = 0, elem; (elem = $( elems[i] )).length; i++) {
  			if(elem.attr(ATTR_HAS)) {
  				/* eslint-disable no-empty */
  				try { elem.triggerHandler('removeqtip'); }
  				catch( e ) {}
  				/* eslint-enable no-empty */
  			}
  		}
  		$['cleanData'+replaceSuffix].apply(this, arguments);
  	};
  }
  ;// qTip version
  QTIP.version = '3.0.3';
  
  // Base ID for all qTips
  QTIP.nextid = 0;
  
  // Inactive events array
  QTIP.inactiveEvents = INACTIVE_EVENTS;
  
  // Base z-index for all qTips
  QTIP.zindex = 15000;
  
  // Define configuration defaults
  QTIP.defaults = {
  	prerender: FALSE,
  	id: FALSE,
  	overwrite: TRUE,
  	suppress: TRUE,
  	content: {
  		text: TRUE,
  		attr: 'title',
  		title: FALSE,
  		button: FALSE
  	},
  	position: {
  		my: 'top left',
  		at: 'bottom right',
  		target: FALSE,
  		container: FALSE,
  		viewport: FALSE,
  		adjust: {
  			x: 0, y: 0,
  			mouse: TRUE,
  			scroll: TRUE,
  			resize: TRUE,
  			method: 'flipinvert flipinvert'
  		},
  		effect: function(api, pos) {
  			$(this).animate(pos, {
  				duration: 200,
  				queue: FALSE
  			});
  		}
  	},
  	show: {
  		target: FALSE,
  		event: 'mouseenter',
  		effect: TRUE,
  		delay: 90,
  		solo: FALSE,
  		ready: FALSE,
  		autofocus: FALSE
  	},
  	hide: {
  		target: FALSE,
  		event: 'mouseleave',
  		effect: TRUE,
  		delay: 0,
  		fixed: FALSE,
  		inactive: FALSE,
  		leave: 'window',
  		distance: FALSE
  	},
  	style: {
  		classes: '',
  		widget: FALSE,
  		width: FALSE,
  		height: FALSE,
  		def: TRUE
  	},
  	events: {
  		render: NULL,
  		move: NULL,
  		show: NULL,
  		hide: NULL,
  		toggle: NULL,
  		visible: NULL,
  		hidden: NULL,
  		focus: NULL,
  		blur: NULL
  	}
  };
  ;var TIP,
  createVML,
  SCALE,
  PIXEL_RATIO,
  BACKING_STORE_RATIO,
  
  // Common CSS strings
  MARGIN = 'margin',
  BORDER = 'border',
  COLOR = 'color',
  BG_COLOR = 'background-color',
  TRANSPARENT = 'transparent',
  IMPORTANT = ' !important',
  
  // Check if the browser supports <canvas/> elements
  HASCANVAS = !!document.createElement('canvas').getContext,
  
  // Invalid colour values used in parseColours()
  INVALID = /rgba?\(0, 0, 0(, 0)?\)|transparent|#123456/i;
  
  // Camel-case method, taken from jQuery source
  // http://code.jquery.com/jquery-1.8.0.js
  function camel(s) { return s.charAt(0).toUpperCase() + s.slice(1); }
  
  /*
   * Modified from Modernizr's testPropsAll()
   * http://modernizr.com/downloads/modernizr-latest.js
   */
  var cssProps = {}, cssPrefixes = ['Webkit', 'O', 'Moz', 'ms'];
  function vendorCss(elem, prop) {
  	var ucProp = prop.charAt(0).toUpperCase() + prop.slice(1),
  		props = (prop + ' ' + cssPrefixes.join(ucProp + ' ') + ucProp).split(' '),
  		cur, val, i = 0;
  
  	// If the property has already been mapped...
  	if(cssProps[prop]) { return elem.css(cssProps[prop]); }
  
  	while(cur = props[i++]) {
  		if((val = elem.css(cur)) !== undefined) {
  			cssProps[prop] = cur;
  			return val;
  		}
  	}
  }
  
  // Parse a given elements CSS property into an int
  function intCss(elem, prop) {
  	return Math.ceil(parseFloat(vendorCss(elem, prop)));
  }
  
  
  // VML creation (for IE only)
  if(!HASCANVAS) {
  	createVML = function(tag, props, style) {
  		return '<qtipvml:'+tag+' xmlns="urn:schemas-microsoft.com:vml" class="qtip-vml" '+(props||'')+
  			' style="behavior: url(#default#VML); '+(style||'')+ '" />';
  	};
  }
  
  // Canvas only definitions
  else {
  	PIXEL_RATIO = window.devicePixelRatio || 1;
  	BACKING_STORE_RATIO = (function() {
  		var context = document.createElement('canvas').getContext('2d');
  		return context.backingStorePixelRatio || context.webkitBackingStorePixelRatio || context.mozBackingStorePixelRatio ||
  				context.msBackingStorePixelRatio || context.oBackingStorePixelRatio || 1;
  	})();
  	SCALE = PIXEL_RATIO / BACKING_STORE_RATIO;
  }
  
  
  function Tip(qtip, options) {
  	this._ns = 'tip';
  	this.options = options;
  	this.offset = options.offset;
  	this.size = [ options.width, options.height ];
  
  	// Initialize
  	this.qtip = qtip;
  	this.init(qtip);
  }
  
  $.extend(Tip.prototype, {
  	init: function(qtip) {
  		var context, tip;
  
  		// Create tip element and prepend to the tooltip
  		tip = this.element = qtip.elements.tip = $('<div />', { 'class': NAMESPACE+'-tip' }).prependTo(qtip.tooltip);
  
  		// Create tip drawing element(s)
  		if(HASCANVAS) {
  			// save() as soon as we create the canvas element so FF2 doesn't bork on our first restore()!
  			context = $('<canvas />').appendTo(this.element)[0].getContext('2d');
  
  			// Setup constant parameters
  			context.lineJoin = 'miter';
  			context.miterLimit = 100000;
  			context.save();
  		}
  		else {
  			context = createVML('shape', 'coordorigin="0,0"', 'position:absolute;');
  			this.element.html(context + context);
  
  			// Prevent mousing down on the tip since it causes problems with .live() handling in IE due to VML
  			qtip._bind( $('*', tip).add(tip), ['click', 'mousedown'], function(event) { event.stopPropagation(); }, this._ns);
  		}
  
  		// Bind update events
  		qtip._bind(qtip.tooltip, 'tooltipmove', this.reposition, this._ns, this);
  
  		// Create it
  		this.create();
  	},
  
  	_swapDimensions: function() {
  		this.size[0] = this.options.height;
  		this.size[1] = this.options.width;
  	},
  	_resetDimensions: function() {
  		this.size[0] = this.options.width;
  		this.size[1] = this.options.height;
  	},
  
  	_useTitle: function(corner) {
  		var titlebar = this.qtip.elements.titlebar;
  		return titlebar && (
  			corner.y === TOP || corner.y === CENTER && this.element.position().top + this.size[1] / 2 + this.options.offset < titlebar.outerHeight(TRUE)
  		);
  	},
  
  	_parseCorner: function(corner) {
  		var my = this.qtip.options.position.my;
  
  		// Detect corner and mimic properties
  		if(corner === FALSE || my === FALSE) {
  			corner = FALSE;
  		}
  		else if(corner === TRUE) {
  			corner = new CORNER( my.string() );
  		}
  		else if(!corner.string) {
  			corner = new CORNER(corner);
  			corner.fixed = TRUE;
  		}
  
  		return corner;
  	},
  
  	_parseWidth: function(corner, side, use) {
  		var elements = this.qtip.elements,
  			prop = BORDER + camel(side) + 'Width';
  
  		return (use ? intCss(use, prop) : 
  			intCss(elements.content, prop) ||
  			intCss(this._useTitle(corner) && elements.titlebar || elements.content, prop) ||
  			intCss(elements.tooltip, prop)
  		) || 0;
  	},
  
  	_parseRadius: function(corner) {
  		var elements = this.qtip.elements,
  			prop = BORDER + camel(corner.y) + camel(corner.x) + 'Radius';
  
  		return BROWSER.ie < 9 ? 0 :
  			intCss(this._useTitle(corner) && elements.titlebar || elements.content, prop) ||
  			intCss(elements.tooltip, prop) || 0;
  	},
  
  	_invalidColour: function(elem, prop, compare) {
  		var val = elem.css(prop);
  		return !val || compare && val === elem.css(compare) || INVALID.test(val) ? FALSE : val;
  	},
  
  	_parseColours: function(corner) {
  		var elements = this.qtip.elements,
  			tip = this.element.css('cssText', ''),
  			borderSide = BORDER + camel(corner[ corner.precedance ]) + camel(COLOR),
  			colorElem = this._useTitle(corner) && elements.titlebar || elements.content,
  			css = this._invalidColour, color = [];
  
  		// Attempt to detect the background colour from various elements, left-to-right precedance
  		color[0] = css(tip, BG_COLOR) || css(colorElem, BG_COLOR) || css(elements.content, BG_COLOR) ||
  			css(elements.tooltip, BG_COLOR) || tip.css(BG_COLOR);
  
  		// Attempt to detect the correct border side colour from various elements, left-to-right precedance
  		color[1] = css(tip, borderSide, COLOR) || css(colorElem, borderSide, COLOR) ||
  			css(elements.content, borderSide, COLOR) || css(elements.tooltip, borderSide, COLOR) || elements.tooltip.css(borderSide);
  
  		// Reset background and border colours
  		$('*', tip).add(tip).css('cssText', BG_COLOR+':'+TRANSPARENT+IMPORTANT+';'+BORDER+':0'+IMPORTANT+';');
  
  		return color;
  	},
  
  	_calculateSize: function(corner) {
  		var y = corner.precedance === Y,
  			width = this.options.width,
  			height = this.options.height,
  			isCenter = corner.abbrev() === 'c',
  			base = (y ? width: height) * (isCenter ? 0.5 : 1),
  			pow = Math.pow,
  			round = Math.round,
  			bigHyp, ratio, result,
  
  		smallHyp = Math.sqrt( pow(base, 2) + pow(height, 2) ),
  		hyp = [
  			this.border / base * smallHyp,
  			this.border / height * smallHyp
  		];
  
  		hyp[2] = Math.sqrt( pow(hyp[0], 2) - pow(this.border, 2) );
  		hyp[3] = Math.sqrt( pow(hyp[1], 2) - pow(this.border, 2) );
  
  		bigHyp = smallHyp + hyp[2] + hyp[3] + (isCenter ? 0 : hyp[0]);
  		ratio = bigHyp / smallHyp;
  
  		result = [ round(ratio * width), round(ratio * height) ];
  		return y ? result : result.reverse();
  	},
  
  	// Tip coordinates calculator
  	_calculateTip: function(corner, size, scale) {
  		scale = scale || 1;
  		size = size || this.size;
  
  		var width = size[0] * scale,
  			height = size[1] * scale,
  			width2 = Math.ceil(width / 2), height2 = Math.ceil(height / 2),
  
  		// Define tip coordinates in terms of height and width values
  		tips = {
  			br:	[0,0,		width,height,	width,0],
  			bl:	[0,0,		width,0,		0,height],
  			tr:	[0,height,	width,0,		width,height],
  			tl:	[0,0,		0,height,		width,height],
  			tc:	[0,height,	width2,0,		width,height],
  			bc:	[0,0,		width,0,		width2,height],
  			rc:	[0,0,		width,height2,	0,height],
  			lc:	[width,0,	width,height,	0,height2]
  		};
  
  		// Set common side shapes
  		tips.lt = tips.br; tips.rt = tips.bl;
  		tips.lb = tips.tr; tips.rb = tips.tl;
  
  		return tips[ corner.abbrev() ];
  	},
  
  	// Tip coordinates drawer (canvas)
  	_drawCoords: function(context, coords) {
  		context.beginPath();
  		context.moveTo(coords[0], coords[1]);
  		context.lineTo(coords[2], coords[3]);
  		context.lineTo(coords[4], coords[5]);
  		context.closePath();
  	},
  
  	create: function() {
  		// Determine tip corner
  		var c = this.corner = (HASCANVAS || BROWSER.ie) && this._parseCorner(this.options.corner);
  
  		// If we have a tip corner...
  		this.enabled = !!this.corner && this.corner.abbrev() !== 'c';
  		if(this.enabled) {
  			// Cache it
  			this.qtip.cache.corner = c.clone();
  
  			// Create it
  			this.update();
  		}
  
  		// Toggle tip element
  		this.element.toggle(this.enabled);
  
  		return this.corner;
  	},
  
  	update: function(corner, position) {
  		if(!this.enabled) { return this; }
  
  		var elements = this.qtip.elements,
  			tip = this.element,
  			inner = tip.children(),
  			options = this.options,
  			curSize = this.size,
  			mimic = options.mimic,
  			round = Math.round,
  			color, precedance, context,
  			coords, bigCoords, translate, newSize, border;
  
  		// Re-determine tip if not already set
  		if(!corner) { corner = this.qtip.cache.corner || this.corner; }
  
  		// Use corner property if we detect an invalid mimic value
  		if(mimic === FALSE) { mimic = corner; }
  
  		// Otherwise inherit mimic properties from the corner object as necessary
  		else {
  			mimic = new CORNER(mimic);
  			mimic.precedance = corner.precedance;
  
  			if(mimic.x === 'inherit') { mimic.x = corner.x; }
  			else if(mimic.y === 'inherit') { mimic.y = corner.y; }
  			else if(mimic.x === mimic.y) {
  				mimic[ corner.precedance ] = corner[ corner.precedance ];
  			}
  		}
  		precedance = mimic.precedance;
  
  		// Ensure the tip width.height are relative to the tip position
  		if(corner.precedance === X) { this._swapDimensions(); }
  		else { this._resetDimensions(); }
  
  		// Update our colours
  		color = this.color = this._parseColours(corner);
  
  		// Detect border width, taking into account colours
  		if(color[1] !== TRANSPARENT) {
  			// Grab border width
  			border = this.border = this._parseWidth(corner, corner[corner.precedance]);
  
  			// If border width isn't zero, use border color as fill if it's not invalid (1.0 style tips)
  			if(options.border && border < 1 && !INVALID.test(color[1])) { color[0] = color[1]; }
  
  			// Set border width (use detected border width if options.border is true)
  			this.border = border = options.border !== TRUE ? options.border : border;
  		}
  
  		// Border colour was invalid, set border to zero
  		else { this.border = border = 0; }
  
  		// Determine tip size
  		newSize = this.size = this._calculateSize(corner);
  		tip.css({
  			width: newSize[0],
  			height: newSize[1],
  			lineHeight: newSize[1]+'px'
  		});
  
  		// Calculate tip translation
  		if(corner.precedance === Y) {
  			translate = [
  				round(mimic.x === LEFT ? border : mimic.x === RIGHT ? newSize[0] - curSize[0] - border : (newSize[0] - curSize[0]) / 2),
  				round(mimic.y === TOP ? newSize[1] - curSize[1] : 0)
  			];
  		}
  		else {
  			translate = [
  				round(mimic.x === LEFT ? newSize[0] - curSize[0] : 0),
  				round(mimic.y === TOP ? border : mimic.y === BOTTOM ? newSize[1] - curSize[1] - border : (newSize[1] - curSize[1]) / 2)
  			];
  		}
  
  		// Canvas drawing implementation
  		if(HASCANVAS) {
  			// Grab canvas context and clear/save it
  			context = inner[0].getContext('2d');
  			context.restore(); context.save();
  			context.clearRect(0,0,6000,6000);
  
  			// Calculate coordinates
  			coords = this._calculateTip(mimic, curSize, SCALE);
  			bigCoords = this._calculateTip(mimic, this.size, SCALE);
  
  			// Set the canvas size using calculated size
  			inner.attr(WIDTH, newSize[0] * SCALE).attr(HEIGHT, newSize[1] * SCALE);
  			inner.css(WIDTH, newSize[0]).css(HEIGHT, newSize[1]);
  
  			// Draw the outer-stroke tip
  			this._drawCoords(context, bigCoords);
  			context.fillStyle = color[1];
  			context.fill();
  
  			// Draw the actual tip
  			context.translate(translate[0] * SCALE, translate[1] * SCALE);
  			this._drawCoords(context, coords);
  			context.fillStyle = color[0];
  			context.fill();
  		}
  
  		// VML (IE Proprietary implementation)
  		else {
  			// Calculate coordinates
  			coords = this._calculateTip(mimic);
  
  			// Setup coordinates string
  			coords = 'm' + coords[0] + ',' + coords[1] + ' l' + coords[2] +
  				',' + coords[3] + ' ' + coords[4] + ',' + coords[5] + ' xe';
  
  			// Setup VML-specific offset for pixel-perfection
  			translate[2] = border && /^(r|b)/i.test(corner.string()) ?
  				BROWSER.ie === 8 ? 2 : 1 : 0;
  
  			// Set initial CSS
  			inner.css({
  				coordsize: newSize[0]+border + ' ' + newSize[1]+border,
  				antialias: ''+(mimic.string().indexOf(CENTER) > -1),
  				left: translate[0] - translate[2] * Number(precedance === X),
  				top: translate[1] - translate[2] * Number(precedance === Y),
  				width: newSize[0] + border,
  				height: newSize[1] + border
  			})
  			.each(function(i) {
  				var $this = $(this);
  
  				// Set shape specific attributes
  				$this[ $this.prop ? 'prop' : 'attr' ]({
  					coordsize: newSize[0]+border + ' ' + newSize[1]+border,
  					path: coords,
  					fillcolor: color[0],
  					filled: !!i,
  					stroked: !i
  				})
  				.toggle(!!(border || i));
  
  				// Check if border is enabled and add stroke element
  				!i && $this.html( createVML(
  					'stroke', 'weight="'+border*2+'px" color="'+color[1]+'" miterlimit="1000" joinstyle="miter"'
  				) );
  			});
  		}
  
  		// Opera bug #357 - Incorrect tip position
  		// https://github.com/Craga89/qTip2/issues/367
  		window.opera && setTimeout(function() {
  			elements.tip.css({
  				display: 'inline-block',
  				visibility: 'visible'
  			});
  		}, 1);
  
  		// Position if needed
  		if(position !== FALSE) { this.calculate(corner, newSize); }
  	},
  
  	calculate: function(corner, size) {
  		if(!this.enabled) { return FALSE; }
  
  		var self = this,
  			elements = this.qtip.elements,
  			tip = this.element,
  			userOffset = this.options.offset,
  			position = {},
  			precedance, corners;
  
  		// Inherit corner if not provided
  		corner = corner || this.corner;
  		precedance = corner.precedance;
  
  		// Determine which tip dimension to use for adjustment
  		size = size || this._calculateSize(corner);
  
  		// Setup corners and offset array
  		corners = [ corner.x, corner.y ];
  		if(precedance === X) { corners.reverse(); }
  
  		// Calculate tip position
  		$.each(corners, function(i, side) {
  			var b, bc, br;
  
  			if(side === CENTER) {
  				b = precedance === Y ? LEFT : TOP;
  				position[ b ] = '50%';
  				position[MARGIN+'-' + b] = -Math.round(size[ precedance === Y ? 0 : 1 ] / 2) + userOffset;
  			}
  			else {
  				b = self._parseWidth(corner, side, elements.tooltip);
  				bc = self._parseWidth(corner, side, elements.content);
  				br = self._parseRadius(corner);
  
  				position[ side ] = Math.max(-self.border, i ? bc : userOffset + (br > b ? br : -b));
  			}
  		});
  
  		// Adjust for tip size
  		position[ corner[precedance] ] -= size[ precedance === X ? 0 : 1 ];
  
  		// Set and return new position
  		tip.css({ margin: '', top: '', bottom: '', left: '', right: '' }).css(position);
  		return position;
  	},
  
  	reposition: function(event, api, pos) {
  		if(!this.enabled) { return; }
  
  		var cache = api.cache,
  			newCorner = this.corner.clone(),
  			adjust = pos.adjusted,
  			method = api.options.position.adjust.method.split(' '),
  			horizontal = method[0],
  			vertical = method[1] || method[0],
  			shift = { left: FALSE, top: FALSE, x: 0, y: 0 },
  			offset, css = {}, props;
  
  		function shiftflip(direction, precedance, popposite, side, opposite) {
  			// Horizontal - Shift or flip method
  			if(direction === SHIFT && newCorner.precedance === precedance && adjust[side] && newCorner[popposite] !== CENTER) {
  				newCorner.precedance = newCorner.precedance === X ? Y : X;
  			}
  			else if(direction !== SHIFT && adjust[side]){
  				newCorner[precedance] = newCorner[precedance] === CENTER ?
  					adjust[side] > 0 ? side : opposite :
  					newCorner[precedance] === side ? opposite : side;
  			}
  		}
  
  		function shiftonly(xy, side, opposite) {
  			if(newCorner[xy] === CENTER) {
  				css[MARGIN+'-'+side] = shift[xy] = offset[MARGIN+'-'+side] - adjust[side];
  			}
  			else {
  				props = offset[opposite] !== undefined ?
  					[ adjust[side], -offset[side] ] : [ -adjust[side], offset[side] ];
  
  				if( (shift[xy] = Math.max(props[0], props[1])) > props[0] ) {
  					pos[side] -= adjust[side];
  					shift[side] = FALSE;
  				}
  
  				css[ offset[opposite] !== undefined ? opposite : side ] = shift[xy];
  			}
  		}
  
  		// If our tip position isn't fixed e.g. doesn't adjust with viewport...
  		if(this.corner.fixed !== TRUE) {
  			// Perform shift/flip adjustments
  			shiftflip(horizontal, X, Y, LEFT, RIGHT);
  			shiftflip(vertical, Y, X, TOP, BOTTOM);
  
  			// Update and redraw the tip if needed (check cached details of last drawn tip)
  			if(newCorner.string() !== cache.corner.string() || cache.cornerTop !== adjust.top || cache.cornerLeft !== adjust.left) {
  				this.update(newCorner, FALSE);
  			}
  		}
  
  		// Setup tip offset properties
  		offset = this.calculate(newCorner);
  
  		// Readjust offset object to make it left/top
  		if(offset.right !== undefined) { offset.left = -offset.right; }
  		if(offset.bottom !== undefined) { offset.top = -offset.bottom; }
  		offset.user = this.offset;
  
  		// Perform shift adjustments
  		shift.left = horizontal === SHIFT && !!adjust.left;
  		if(shift.left) {
  			shiftonly(X, LEFT, RIGHT);
  		}
  		shift.top = vertical === SHIFT && !!adjust.top;
  		if(shift.top) {
  			shiftonly(Y, TOP, BOTTOM);
  		}
  
  		/*
  		* If the tip is adjusted in both dimensions, or in a
  		* direction that would cause it to be anywhere but the
  		* outer border, hide it!
  		*/
  		this.element.css(css).toggle(
  			!(shift.x && shift.y || newCorner.x === CENTER && shift.y || newCorner.y === CENTER && shift.x)
  		);
  
  		// Adjust position to accomodate tip dimensions
  		pos.left -= offset.left.charAt ? offset.user :
  			horizontal !== SHIFT || shift.top || !shift.left && !shift.top ? offset.left + this.border : 0;
  		pos.top -= offset.top.charAt ? offset.user :
  			vertical !== SHIFT || shift.left || !shift.left && !shift.top ? offset.top + this.border : 0;
  
  		// Cache details
  		cache.cornerLeft = adjust.left; cache.cornerTop = adjust.top;
  		cache.corner = newCorner.clone();
  	},
  
  	destroy: function() {
  		// Unbind events
  		this.qtip._unbind(this.qtip.tooltip, this._ns);
  
  		// Remove the tip element(s)
  		if(this.qtip.elements.tip) {
  			this.qtip.elements.tip.find('*')
  				.remove().end().remove();
  		}
  	}
  });
  
  TIP = PLUGINS.tip = function(api) {
  	return new Tip(api, api.options.style.tip);
  };
  
  // Initialize tip on render
  TIP.initialize = 'render';
  
  // Setup plugin sanitization options
  TIP.sanitize = function(options) {
  	if(options.style && 'tip' in options.style) {
  		var opts = options.style.tip;
  		if(typeof opts !== 'object') { opts = options.style.tip = { corner: opts }; }
  		if(!(/string|boolean/i).test(typeof opts.corner)) { opts.corner = TRUE; }
  	}
  };
  
  // Add new option checks for the plugin
  CHECKS.tip = {
  	'^position.my|style.tip.(corner|mimic|border)$': function() {
  		// Make sure a tip can be drawn
  		this.create();
  
  		// Reposition the tooltip
  		this.qtip.reposition();
  	},
  	'^style.tip.(height|width)$': function(obj) {
  		// Re-set dimensions and redraw the tip
  		this.size = [ obj.width, obj.height ];
  		this.update();
  
  		// Reposition the tooltip
  		this.qtip.reposition();
  	},
  	'^content.title|style.(classes|widget)$': function() {
  		this.update();
  	}
  };
  
  // Extend original qTip defaults
  $.extend(TRUE, QTIP.defaults, {
  	style: {
  		tip: {
  			corner: TRUE,
  			mimic: FALSE,
  			width: 6,
  			height: 6,
  			border: TRUE,
  			offset: 0
  		}
  	}
  });
  ;var MODAL, OVERLAY,
  	MODALCLASS = 'qtip-modal',
  	MODALSELECTOR = '.'+MODALCLASS;
  
  OVERLAY = function()
  {
  	var self = this,
  		focusableElems = {},
  		current,
  		prevState,
  		elem;
  
  	// Modified code from jQuery UI 1.10.0 source
  	// http://code.jquery.com/ui/1.10.0/jquery-ui.js
  	function focusable(element) {
  		// Use the defined focusable checker when possible
  		if($.expr[':'].focusable) { return $.expr[':'].focusable; }
  
  		var isTabIndexNotNaN = !isNaN($.attr(element, 'tabindex')),
  			nodeName = element.nodeName && element.nodeName.toLowerCase(),
  			map, mapName, img;
  
  		if('area' === nodeName) {
  			map = element.parentNode;
  			mapName = map.name;
  			if(!element.href || !mapName || map.nodeName.toLowerCase() !== 'map') {
  				return false;
  			}
  			img = $('img[usemap=#' + mapName + ']')[0];
  			return !!img && img.is(':visible');
  		}
  
  		return /input|select|textarea|button|object/.test( nodeName ) ?
  			!element.disabled :
  			'a' === nodeName ?
  				element.href || isTabIndexNotNaN :
  				isTabIndexNotNaN
  		;
  	}
  
  	// Focus inputs using cached focusable elements (see update())
  	function focusInputs(blurElems) {
  		// Blurring body element in IE causes window.open windows to unfocus!
  		if(focusableElems.length < 1 && blurElems.length) { blurElems.not('body').blur(); }
  
  		// Focus the inputs
  		else { focusableElems.first().focus(); }
  	}
  
  	// Steal focus from elements outside tooltip
  	function stealFocus(event) {
  		if(!elem.is(':visible')) { return; }
  
  		var target = $(event.target),
  			tooltip = current.tooltip,
  			container = target.closest(SELECTOR),
  			targetOnTop;
  
  		// Determine if input container target is above this
  		targetOnTop = container.length < 1 ? FALSE :
  			parseInt(container[0].style.zIndex, 10) > parseInt(tooltip[0].style.zIndex, 10);
  
  		// If we're showing a modal, but focus has landed on an input below
  		// this modal, divert focus to the first visible input in this modal
  		// or if we can't find one... the tooltip itself
  		if(!targetOnTop && target.closest(SELECTOR)[0] !== tooltip[0]) {
  			focusInputs(target);
  		}
  	}
  
  	$.extend(self, {
  		init: function() {
  			// Create document overlay
  			elem = self.elem = $('<div />', {
  				id: 'qtip-overlay',
  				html: '<div></div>',
  				mousedown: function() { return FALSE; }
  			})
  			.hide();
  
  			// Make sure we can't focus anything outside the tooltip
  			$(document.body).bind('focusin'+MODALSELECTOR, stealFocus);
  
  			// Apply keyboard "Escape key" close handler
  			$(document).bind('keydown'+MODALSELECTOR, function(event) {
  				if(current && current.options.show.modal.escape && event.keyCode === 27) {
  					current.hide(event);
  				}
  			});
  
  			// Apply click handler for blur option
  			elem.bind('click'+MODALSELECTOR, function(event) {
  				if(current && current.options.show.modal.blur) {
  					current.hide(event);
  				}
  			});
  
  			return self;
  		},
  
  		update: function(api) {
  			// Update current API reference
  			current = api;
  
  			// Update focusable elements if enabled
  			if(api.options.show.modal.stealfocus !== FALSE) {
  				focusableElems = api.tooltip.find('*').filter(function() {
  					return focusable(this);
  				});
  			}
  			else { focusableElems = []; }
  		},
  
  		toggle: function(api, state, duration) {
  			var tooltip = api.tooltip,
  				options = api.options.show.modal,
  				effect = options.effect,
  				type = state ? 'show': 'hide',
  				visible = elem.is(':visible'),
  				visibleModals = $(MODALSELECTOR).filter(':visible:not(:animated)').not(tooltip);
  
  			// Set active tooltip API reference
  			self.update(api);
  
  			// If the modal can steal the focus...
  			// Blur the current item and focus anything in the modal we an
  			if(state && options.stealfocus !== FALSE) {
  				focusInputs( $(':focus') );
  			}
  
  			// Toggle backdrop cursor style on show
  			elem.toggleClass('blurs', options.blur);
  
  			// Append to body on show
  			if(state) {
  				elem.appendTo(document.body);
  			}
  
  			// Prevent modal from conflicting with show.solo, and don't hide backdrop is other modals are visible
  			if(elem.is(':animated') && visible === state && prevState !== FALSE || !state && visibleModals.length) {
  				return self;
  			}
  
  			// Stop all animations
  			elem.stop(TRUE, FALSE);
  
  			// Use custom function if provided
  			if($.isFunction(effect)) {
  				effect.call(elem, state);
  			}
  
  			// If no effect type is supplied, use a simple toggle
  			else if(effect === FALSE) {
  				elem[ type ]();
  			}
  
  			// Use basic fade function
  			else {
  				elem.fadeTo( parseInt(duration, 10) || 90, state ? 1 : 0, function() {
  					if(!state) { elem.hide(); }
  				});
  			}
  
  			// Reset position and detach from body on hide
  			if(!state) {
  				elem.queue(function(next) {
  					elem.css({ left: '', top: '' });
  					if(!$(MODALSELECTOR).length) { elem.detach(); }
  					next();
  				});
  			}
  
  			// Cache the state
  			prevState = state;
  
  			// If the tooltip is destroyed, set reference to null
  			if(current.destroyed) { current = NULL; }
  
  			return self;
  		}
  	});
  
  	self.init();
  };
  OVERLAY = new OVERLAY();
  
  function Modal(api, options) {
  	this.options = options;
  	this._ns = '-modal';
  
  	this.qtip = api;
  	this.init(api);
  }
  
  $.extend(Modal.prototype, {
  	init: function(qtip) {
  		var tooltip = qtip.tooltip;
  
  		// If modal is disabled... return
  		if(!this.options.on) { return this; }
  
  		// Set overlay reference
  		qtip.elements.overlay = OVERLAY.elem;
  
  		// Add unique attribute so we can grab modal tooltips easily via a SELECTOR, and set z-index
  		tooltip.addClass(MODALCLASS).css('z-index', QTIP.modal_zindex + $(MODALSELECTOR).length);
  
  		// Apply our show/hide/focus modal events
  		qtip._bind(tooltip, ['tooltipshow', 'tooltiphide'], function(event, api, duration) {
  			var oEvent = event.originalEvent;
  
  			// Make sure mouseout doesn't trigger a hide when showing the modal and mousing onto backdrop
  			if(event.target === tooltip[0]) {
  				if(oEvent && event.type === 'tooltiphide' && /mouse(leave|enter)/.test(oEvent.type) && $(oEvent.relatedTarget).closest(OVERLAY.elem[0]).length) {
  					/* eslint-disable no-empty */
  					try { event.preventDefault(); }
  					catch(e) {}
  					/* eslint-enable no-empty */
  				}
  				else if(!oEvent || oEvent && oEvent.type !== 'tooltipsolo') {
  					this.toggle(event, event.type === 'tooltipshow', duration);
  				}
  			}
  		}, this._ns, this);
  
  		// Adjust modal z-index on tooltip focus
  		qtip._bind(tooltip, 'tooltipfocus', function(event, api) {
  			// If focus was cancelled before it reached us, don't do anything
  			if(event.isDefaultPrevented() || event.target !== tooltip[0]) { return; }
  
  			var qtips = $(MODALSELECTOR),
  
  			// Keep the modal's lower than other, regular qtips
  			newIndex = QTIP.modal_zindex + qtips.length,
  			curIndex = parseInt(tooltip[0].style.zIndex, 10);
  
  			// Set overlay z-index
  			OVERLAY.elem[0].style.zIndex = newIndex - 1;
  
  			// Reduce modal z-index's and keep them properly ordered
  			qtips.each(function() {
  				if(this.style.zIndex > curIndex) {
  					this.style.zIndex -= 1;
  				}
  			});
  
  			// Fire blur event for focused tooltip
  			qtips.filter('.' + CLASS_FOCUS).qtip('blur', event.originalEvent);
  
  			// Set the new z-index
  			tooltip.addClass(CLASS_FOCUS)[0].style.zIndex = newIndex;
  
  			// Set current
  			OVERLAY.update(api);
  
  			// Prevent default handling
  			/* eslint-disable no-empty */
  			try { event.preventDefault(); }
  			catch(e) {}
  			/* eslint-enable no-empty */
  		}, this._ns, this);
  
  		// Focus any other visible modals when this one hides
  		qtip._bind(tooltip, 'tooltiphide', function(event) {
  			if(event.target === tooltip[0]) {
  				$(MODALSELECTOR).filter(':visible').not(tooltip).last().qtip('focus', event);
  			}
  		}, this._ns, this);
  	},
  
  	toggle: function(event, state, duration) {
  		// Make sure default event hasn't been prevented
  		if(event && event.isDefaultPrevented()) { return this; }
  
  		// Toggle it
  		OVERLAY.toggle(this.qtip, !!state, duration);
  	},
  
  	destroy: function() {
  		// Remove modal class
  		this.qtip.tooltip.removeClass(MODALCLASS);
  
  		// Remove bound events
  		this.qtip._unbind(this.qtip.tooltip, this._ns);
  
  		// Delete element reference
  		OVERLAY.toggle(this.qtip, FALSE);
  		delete this.qtip.elements.overlay;
  	}
  });
  
  
  MODAL = PLUGINS.modal = function(api) {
  	return new Modal(api, api.options.show.modal);
  };
  
  // Setup sanitiztion rules
  MODAL.sanitize = function(opts) {
  	if(opts.show) {
  		if(typeof opts.show.modal !== 'object') { opts.show.modal = { on: !!opts.show.modal }; }
  		else if(typeof opts.show.modal.on === 'undefined') { opts.show.modal.on = TRUE; }
  	}
  };
  
  // Base z-index for all modal tooltips (use qTip core z-index as a base)
  /* eslint-disable camelcase */
  QTIP.modal_zindex = QTIP.zindex - 200;
  /* eslint-enable camelcase */
  
  // Plugin needs to be initialized on render
  MODAL.initialize = 'render';
  
  // Setup option set checks
  CHECKS.modal = {
  	'^show.modal.(on|blur)$': function() {
  		// Initialise
  		this.destroy();
  		this.init();
  
  		// Show the modal if not visible already and tooltip is visible
  		this.qtip.elems.overlay.toggle(
  			this.qtip.tooltip[0].offsetWidth > 0
  		);
  	}
  };
  
  // Extend original api defaults
  $.extend(TRUE, QTIP.defaults, {
  	show: {
  		modal: {
  			on: FALSE,
  			effect: TRUE,
  			blur: TRUE,
  			stealfocus: TRUE,
  			escape: TRUE
  		}
  	}
  });
  ;PLUGINS.viewport = function(api, position, posOptions, targetWidth, targetHeight, elemWidth, elemHeight)
  {
  	var target = posOptions.target,
  		tooltip = api.elements.tooltip,
  		my = posOptions.my,
  		at = posOptions.at,
  		adjust = posOptions.adjust,
  		method = adjust.method.split(' '),
  		methodX = method[0],
  		methodY = method[1] || method[0],
  		viewport = posOptions.viewport,
  		container = posOptions.container,
  		adjusted = { left: 0, top: 0 },
  		fixed, newMy, containerOffset, containerStatic,
  		viewportWidth, viewportHeight, viewportScroll, viewportOffset;
  
  	// If viewport is not a jQuery element, or it's the window/document, or no adjustment method is used... return
  	if(!viewport.jquery || target[0] === window || target[0] === document.body || adjust.method === 'none') {
  		return adjusted;
  	}
  
  	// Cach container details
  	containerOffset = container.offset() || adjusted;
  	containerStatic = container.css('position') === 'static';
  
  	// Cache our viewport details
  	fixed = tooltip.css('position') === 'fixed';
  	viewportWidth = viewport[0] === window ? viewport.width() : viewport.outerWidth(FALSE);
  	viewportHeight = viewport[0] === window ? viewport.height() : viewport.outerHeight(FALSE);
  	viewportScroll = { left: fixed ? 0 : viewport.scrollLeft(), top: fixed ? 0 : viewport.scrollTop() };
  	viewportOffset = viewport.offset() || adjusted;
  
  	// Generic calculation method
  	function calculate(side, otherSide, type, adjustment, side1, side2, lengthName, targetLength, elemLength) {
  		var initialPos = position[side1],
  			mySide = my[side],
  			atSide = at[side],
  			isShift = type === SHIFT,
  			myLength = mySide === side1 ? elemLength : mySide === side2 ? -elemLength : -elemLength / 2,
  			atLength = atSide === side1 ? targetLength : atSide === side2 ? -targetLength : -targetLength / 2,
  			sideOffset = viewportScroll[side1] + viewportOffset[side1] - (containerStatic ? 0 : containerOffset[side1]),
  			overflow1 = sideOffset - initialPos,
  			overflow2 = initialPos + elemLength - (lengthName === WIDTH ? viewportWidth : viewportHeight) - sideOffset,
  			offset = myLength - (my.precedance === side || mySide === my[otherSide] ? atLength : 0) - (atSide === CENTER ? targetLength / 2 : 0);
  
  		// shift
  		if(isShift) {
  			offset = (mySide === side1 ? 1 : -1) * myLength;
  
  			// Adjust position but keep it within viewport dimensions
  			position[side1] += overflow1 > 0 ? overflow1 : overflow2 > 0 ? -overflow2 : 0;
  			position[side1] = Math.max(
  				-containerOffset[side1] + viewportOffset[side1],
  				initialPos - offset,
  				Math.min(
  					Math.max(
  						-containerOffset[side1] + viewportOffset[side1] + (lengthName === WIDTH ? viewportWidth : viewportHeight),
  						initialPos + offset
  					),
  					position[side1],
  
  					// Make sure we don't adjust complete off the element when using 'center'
  					mySide === 'center' ? initialPos - myLength : 1E9
  				)
  			);
  
  		}
  
  		// flip/flipinvert
  		else {
  			// Update adjustment amount depending on if using flipinvert or flip
  			adjustment *= type === FLIPINVERT ? 2 : 0;
  
  			// Check for overflow on the left/top
  			if(overflow1 > 0 && (mySide !== side1 || overflow2 > 0)) {
  				position[side1] -= offset + adjustment;
  				newMy.invert(side, side1);
  			}
  
  			// Check for overflow on the bottom/right
  			else if(overflow2 > 0 && (mySide !== side2 || overflow1 > 0)  ) {
  				position[side1] -= (mySide === CENTER ? -offset : offset) + adjustment;
  				newMy.invert(side, side2);
  			}
  
  			// Make sure we haven't made things worse with the adjustment and reset if so
  			if(position[side1] < viewportScroll[side1] && -position[side1] > overflow2) {
  				position[side1] = initialPos; newMy = my.clone();
  			}
  		}
  
  		return position[side1] - initialPos;
  	}
  
  	// Set newMy if using flip or flipinvert methods
  	if(methodX !== 'shift' || methodY !== 'shift') { newMy = my.clone(); }
  
  	// Adjust position based onviewport and adjustment options
  	adjusted = {
  		left: methodX !== 'none' ? calculate( X, Y, methodX, adjust.x, LEFT, RIGHT, WIDTH, targetWidth, elemWidth ) : 0,
  		top: methodY !== 'none' ? calculate( Y, X, methodY, adjust.y, TOP, BOTTOM, HEIGHT, targetHeight, elemHeight ) : 0,
  		my: newMy
  	};
  
  	return adjusted;
  };
  ;PLUGINS.polys = {
  	// POLY area coordinate calculator
  	//	Special thanks to Ed Cradock for helping out with this.
  	//	Uses a binary search algorithm to find suitable coordinates.
  	polygon: function(baseCoords, corner) {
  		var result = {
  			width: 0, height: 0,
  			position: {
  				top: 1e10, right: 0,
  				bottom: 0, left: 1e10
  			},
  			adjustable: FALSE
  		},
  		i = 0, next,
  		coords = [],
  		compareX = 1, compareY = 1,
  		realX = 0, realY = 0,
  		newWidth, newHeight;
  
  		// First pass, sanitize coords and determine outer edges
  		i = baseCoords.length; 
  		while(i--) {
  			next = [ parseInt(baseCoords[--i], 10), parseInt(baseCoords[i+1], 10) ];
  
  			if(next[0] > result.position.right){ result.position.right = next[0]; }
  			if(next[0] < result.position.left){ result.position.left = next[0]; }
  			if(next[1] > result.position.bottom){ result.position.bottom = next[1]; }
  			if(next[1] < result.position.top){ result.position.top = next[1]; }
  
  			coords.push(next);
  		}
  
  		// Calculate height and width from outer edges
  		newWidth = result.width = Math.abs(result.position.right - result.position.left);
  		newHeight = result.height = Math.abs(result.position.bottom - result.position.top);
  
  		// If it's the center corner...
  		if(corner.abbrev() === 'c') {
  			result.position = {
  				left: result.position.left + result.width / 2,
  				top: result.position.top + result.height / 2
  			};
  		}
  		else {
  			// Second pass, use a binary search algorithm to locate most suitable coordinate
  			while(newWidth > 0 && newHeight > 0 && compareX > 0 && compareY > 0)
  			{
  				newWidth = Math.floor(newWidth / 2);
  				newHeight = Math.floor(newHeight / 2);
  
  				if(corner.x === LEFT){ compareX = newWidth; }
  				else if(corner.x === RIGHT){ compareX = result.width - newWidth; }
  				else{ compareX += Math.floor(newWidth / 2); }
  
  				if(corner.y === TOP){ compareY = newHeight; }
  				else if(corner.y === BOTTOM){ compareY = result.height - newHeight; }
  				else{ compareY += Math.floor(newHeight / 2); }
  
  				i = coords.length;
  				while(i--)
  				{
  					if(coords.length < 2){ break; }
  
  					realX = coords[i][0] - result.position.left;
  					realY = coords[i][1] - result.position.top;
  
  					if(
  						corner.x === LEFT && realX >= compareX ||
  						corner.x === RIGHT && realX <= compareX ||
  						corner.x === CENTER && (realX < compareX || realX > result.width - compareX) ||
  						corner.y === TOP && realY >= compareY ||
  						corner.y === BOTTOM && realY <= compareY ||
  						corner.y === CENTER && (realY < compareY || realY > result.height - compareY)) {
  						coords.splice(i, 1);
  					}
  				}
  			}
  			result.position = { left: coords[0][0], top: coords[0][1] };
  		}
  
  		return result;
  	},
  
  	rect: function(ax, ay, bx, by) {
  		return {
  			width: Math.abs(bx - ax),
  			height: Math.abs(by - ay),
  			position: {
  				left: Math.min(ax, bx),
  				top: Math.min(ay, by)
  			}
  		};
  	},
  
  	_angles: {
  		tc: 3 / 2, tr: 7 / 4, tl: 5 / 4,
  		bc: 1 / 2, br: 1 / 4, bl: 3 / 4,
  		rc: 2, lc: 1, c: 0
  	},
  	ellipse: function(cx, cy, rx, ry, corner) {
  		var c = PLUGINS.polys._angles[ corner.abbrev() ],
  			rxc = c === 0 ? 0 : rx * Math.cos( c * Math.PI ),
  			rys = ry * Math.sin( c * Math.PI );
  
  		return {
  			width: rx * 2 - Math.abs(rxc),
  			height: ry * 2 - Math.abs(rys),
  			position: {
  				left: cx + rxc,
  				top: cy + rys
  			},
  			adjustable: FALSE
  		};
  	},
  	circle: function(cx, cy, r, corner) {
  		return PLUGINS.polys.ellipse(cx, cy, r, r, corner);
  	}
  };
  ;PLUGINS.svg = function(api, svg, corner)
  {
  	var elem = svg[0],
  		root = $(elem.ownerSVGElement),
  		ownerDocument = elem.ownerDocument,
  		strokeWidth2 = (parseInt(svg.css('stroke-width'), 10) || 0) / 2,
  		frameOffset, mtx, transformed,
  		len, next, i, points,
  		result, position;
  
  	// Ascend the parentNode chain until we find an element with getBBox()
  	while(!elem.getBBox) { elem = elem.parentNode; }
  	if(!elem.getBBox || !elem.parentNode) { return FALSE; }
  
  	// Determine which shape calculation to use
  	switch(elem.nodeName) {
  		case 'ellipse':
  		case 'circle':
  			result = PLUGINS.polys.ellipse(
  				elem.cx.baseVal.value,
  				elem.cy.baseVal.value,
  				(elem.rx || elem.r).baseVal.value + strokeWidth2,
  				(elem.ry || elem.r).baseVal.value + strokeWidth2,
  				corner
  			);
  		break;
  
  		case 'line':
  		case 'polygon':
  		case 'polyline':
  			// Determine points object (line has none, so mimic using array)
  			points = elem.points || [
  				{ x: elem.x1.baseVal.value, y: elem.y1.baseVal.value },
  				{ x: elem.x2.baseVal.value, y: elem.y2.baseVal.value }
  			];
  
  			for(result = [], i = -1, len = points.numberOfItems || points.length; ++i < len;) {
  				next = points.getItem ? points.getItem(i) : points[i];
  				result.push.apply(result, [next.x, next.y]);
  			}
  
  			result = PLUGINS.polys.polygon(result, corner);
  		break;
  
  		// Unknown shape or rectangle? Use bounding box
  		default:
  			result = elem.getBBox();
  			result = {
  				width: result.width,
  				height: result.height,
  				position: {
  					left: result.x,
  					top: result.y
  				}
  			};
  		break;
  	}
  
  	// Shortcut assignments
  	position = result.position;
  	root = root[0];
  
  	// Convert position into a pixel value
  	if(root.createSVGPoint) {
  		mtx = elem.getScreenCTM();
  		points = root.createSVGPoint();
  
  		points.x = position.left;
  		points.y = position.top;
  		transformed = points.matrixTransform( mtx );
  		position.left = transformed.x;
  		position.top = transformed.y;
  	}
  
  	// Check the element is not in a child document, and if so, adjust for frame elements offset
  	if(ownerDocument !== document && api.position.target !== 'mouse') {
  		frameOffset = $((ownerDocument.defaultView || ownerDocument.parentWindow).frameElement).offset();
  		if(frameOffset) {
  			position.left += frameOffset.left;
  			position.top += frameOffset.top;
  		}
  	}
  
  	// Adjust by scroll offset of owner document
  	ownerDocument = $(ownerDocument);
  	position.left += ownerDocument.scrollLeft();
  	position.top += ownerDocument.scrollTop();
  
  	return result;
  };
  ;PLUGINS.imagemap = function(api, area, corner)
  {
  	if(!area.jquery) { area = $(area); }
  
  	var shape = (area.attr('shape') || 'rect').toLowerCase().replace('poly', 'polygon'),
  		image = $('img[usemap="#'+area.parent('map').attr('name')+'"]'),
  		coordsString = $.trim(area.attr('coords')),
  		coordsArray = coordsString.replace(/,$/, '').split(','),
  		imageOffset, coords, i, result, len;
  
  	// If we can't find the image using the map...
  	if(!image.length) { return FALSE; }
  
  	// Pass coordinates string if polygon
  	if(shape === 'polygon') {
  		result = PLUGINS.polys.polygon(coordsArray, corner);
  	}
  
  	// Otherwise parse the coordinates and pass them as arguments
  	else if(PLUGINS.polys[shape]) {
  		for(i = -1, len = coordsArray.length, coords = []; ++i < len;) {
  			coords.push( parseInt(coordsArray[i], 10) );
  		}
  
  		result = PLUGINS.polys[shape].apply(
  			this, coords.concat(corner)
  		);
  	}
  
  	// If no shapre calculation method was found, return false
  	else { return FALSE; }
  
  	// Make sure we account for padding and borders on the image
  	imageOffset = image.offset();
  	imageOffset.left += Math.ceil((image.outerWidth(FALSE) - image.width()) / 2);
  	imageOffset.top += Math.ceil((image.outerHeight(FALSE) - image.height()) / 2);
  
  	// Add image position to offset coordinates
  	result.position.left += imageOffset.left;
  	result.position.top += imageOffset.top;
  
  	return result;
  };
  ;var IE6,
  
  /*
   * BGIFrame adaption (http://plugins.jquery.com/project/bgiframe)
   * Special thanks to Brandon Aaron
   */
  BGIFRAME = '<iframe class="qtip-bgiframe" frameborder="0" tabindex="-1" src="javascript:\'\';" ' +
  	' style="display:block; position:absolute; z-index:-1; filter:alpha(opacity=0); ' +
  		'-ms-filter:"progid:DXImageTransform.Microsoft.Alpha(Opacity=0)";"></iframe>';
  
  function Ie6(api) {
  	this._ns = 'ie6';
  
  	this.qtip = api;
  	this.init(api);
  }
  
  $.extend(Ie6.prototype, {
  	_scroll : function() {
  		var overlay = this.qtip.elements.overlay;
  		overlay && (overlay[0].style.top = $(window).scrollTop() + 'px');
  	},
  
  	init: function(qtip) {
  		var tooltip = qtip.tooltip;
  
  		// Create the BGIFrame element if needed
  		if($('select, object').length < 1) {
  			this.bgiframe = qtip.elements.bgiframe = $(BGIFRAME).appendTo(tooltip);
  
  			// Update BGIFrame on tooltip move
  			qtip._bind(tooltip, 'tooltipmove', this.adjustBGIFrame, this._ns, this);
  		}
  
  		// redraw() container for width/height calculations
  		this.redrawContainer = $('<div/>', { id: NAMESPACE+'-rcontainer' })
  			.appendTo(document.body);
  
  		// Fixup modal plugin if present too
  		if( qtip.elements.overlay && qtip.elements.overlay.addClass('qtipmodal-ie6fix') ) {
  			qtip._bind(window, ['scroll', 'resize'], this._scroll, this._ns, this);
  			qtip._bind(tooltip, ['tooltipshow'], this._scroll, this._ns, this);
  		}
  
  		// Set dimensions
  		this.redraw();
  	},
  
  	adjustBGIFrame: function() {
  		var tooltip = this.qtip.tooltip,
  			dimensions = {
  				height: tooltip.outerHeight(FALSE),
  				width: tooltip.outerWidth(FALSE)
  			},
  			plugin = this.qtip.plugins.tip,
  			tip = this.qtip.elements.tip,
  			tipAdjust, offset;
  
  		// Adjust border offset
  		offset = parseInt(tooltip.css('borderLeftWidth'), 10) || 0;
  		offset = { left: -offset, top: -offset };
  
  		// Adjust for tips plugin
  		if(plugin && tip) {
  			tipAdjust = plugin.corner.precedance === 'x' ? [WIDTH, LEFT] : [HEIGHT, TOP];
  			offset[ tipAdjust[1] ] -= tip[ tipAdjust[0] ]();
  		}
  
  		// Update bgiframe
  		this.bgiframe.css(offset).css(dimensions);
  	},
  
  	// Max/min width simulator function
  	redraw: function() {
  		if(this.qtip.rendered < 1 || this.drawing) { return this; }
  
  		var tooltip = this.qtip.tooltip,
  			style = this.qtip.options.style,
  			container = this.qtip.options.position.container,
  			perc, width, max, min;
  
  		// Set drawing flag
  		this.qtip.drawing = 1;
  
  		// If tooltip has a set height/width, just set it... like a boss!
  		if(style.height) { tooltip.css(HEIGHT, style.height); }
  		if(style.width) { tooltip.css(WIDTH, style.width); }
  
  		// Simulate max/min width if not set width present...
  		else {
  			// Reset width and add fluid class
  			tooltip.css(WIDTH, '').appendTo(this.redrawContainer);
  
  			// Grab our tooltip width (add 1 if odd so we don't get wrapping problems.. huzzah!)
  			width = tooltip.width();
  			if(width % 2 < 1) { width += 1; }
  
  			// Grab our max/min properties
  			max = tooltip.css('maxWidth') || '';
  			min = tooltip.css('minWidth') || '';
  
  			// Parse into proper pixel values
  			perc = (max + min).indexOf('%') > -1 ? container.width() / 100 : 0;
  			max = (max.indexOf('%') > -1 ? perc : 1 * parseInt(max, 10)) || width;
  			min = (min.indexOf('%') > -1 ? perc : 1 * parseInt(min, 10)) || 0;
  
  			// Determine new dimension size based on max/min/current values
  			width = max + min ? Math.min(Math.max(width, min), max) : width;
  
  			// Set the newly calculated width and remvoe fluid class
  			tooltip.css(WIDTH, Math.round(width)).appendTo(container);
  		}
  
  		// Set drawing flag
  		this.drawing = 0;
  
  		return this;
  	},
  
  	destroy: function() {
  		// Remove iframe
  		this.bgiframe && this.bgiframe.remove();
  
  		// Remove bound events
  		this.qtip._unbind([window, this.qtip.tooltip], this._ns);
  	}
  });
  
  IE6 = PLUGINS.ie6 = function(api) {
  	// Proceed only if the browser is IE6
  	return BROWSER.ie === 6 ? new Ie6(api) : FALSE;
  };
  
  IE6.initialize = 'render';
  
  CHECKS.ie6 = {
  	'^content|style$': function() {
  		this.redraw();
  	}
  };
  ;}));
  }( window, document ));
  
  },{}],117:[function(require,module,exports){
  /*!
  * screenfull
  * v5.1.0 - 2020-12-24
  * (c) Sindre Sorhus; MIT License
  */
  (function () {
  	'use strict';
  
  	var document = typeof window !== 'undefined' && typeof window.document !== 'undefined' ? window.document : {};
  	var isCommonjs = typeof module !== 'undefined' && module.exports;
  
  	var fn = (function () {
  		var val;
  
  		var fnMap = [
  			[
  				'requestFullscreen',
  				'exitFullscreen',
  				'fullscreenElement',
  				'fullscreenEnabled',
  				'fullscreenchange',
  				'fullscreenerror'
  			],
  			// New WebKit
  			[
  				'webkitRequestFullscreen',
  				'webkitExitFullscreen',
  				'webkitFullscreenElement',
  				'webkitFullscreenEnabled',
  				'webkitfullscreenchange',
  				'webkitfullscreenerror'
  
  			],
  			// Old WebKit
  			[
  				'webkitRequestFullScreen',
  				'webkitCancelFullScreen',
  				'webkitCurrentFullScreenElement',
  				'webkitCancelFullScreen',
  				'webkitfullscreenchange',
  				'webkitfullscreenerror'
  
  			],
  			[
  				'mozRequestFullScreen',
  				'mozCancelFullScreen',
  				'mozFullScreenElement',
  				'mozFullScreenEnabled',
  				'mozfullscreenchange',
  				'mozfullscreenerror'
  			],
  			[
  				'msRequestFullscreen',
  				'msExitFullscreen',
  				'msFullscreenElement',
  				'msFullscreenEnabled',
  				'MSFullscreenChange',
  				'MSFullscreenError'
  			]
  		];
  
  		var i = 0;
  		var l = fnMap.length;
  		var ret = {};
  
  		for (; i < l; i++) {
  			val = fnMap[i];
  			if (val && val[1] in document) {
  				for (i = 0; i < val.length; i++) {
  					ret[fnMap[0][i]] = val[i];
  				}
  				return ret;
  			}
  		}
  
  		return false;
  	})();
  
  	var eventNameMap = {
  		change: fn.fullscreenchange,
  		error: fn.fullscreenerror
  	};
  
  	var screenfull = {
  		request: function (element, options) {
  			return new Promise(function (resolve, reject) {
  				var onFullScreenEntered = function () {
  					this.off('change', onFullScreenEntered);
  					resolve();
  				}.bind(this);
  
  				this.on('change', onFullScreenEntered);
  
  				element = element || document.documentElement;
  
  				var returnPromise = element[fn.requestFullscreen](options);
  
  				if (returnPromise instanceof Promise) {
  					returnPromise.then(onFullScreenEntered).catch(reject);
  				}
  			}.bind(this));
  		},
  		exit: function () {
  			return new Promise(function (resolve, reject) {
  				if (!this.isFullscreen) {
  					resolve();
  					return;
  				}
  
  				var onFullScreenExit = function () {
  					this.off('change', onFullScreenExit);
  					resolve();
  				}.bind(this);
  
  				this.on('change', onFullScreenExit);
  
  				var returnPromise = document[fn.exitFullscreen]();
  
  				if (returnPromise instanceof Promise) {
  					returnPromise.then(onFullScreenExit).catch(reject);
  				}
  			}.bind(this));
  		},
  		toggle: function (element, options) {
  			return this.isFullscreen ? this.exit() : this.request(element, options);
  		},
  		onchange: function (callback) {
  			this.on('change', callback);
  		},
  		onerror: function (callback) {
  			this.on('error', callback);
  		},
  		on: function (event, callback) {
  			var eventName = eventNameMap[event];
  			if (eventName) {
  				document.addEventListener(eventName, callback, false);
  			}
  		},
  		off: function (event, callback) {
  			var eventName = eventNameMap[event];
  			if (eventName) {
  				document.removeEventListener(eventName, callback, false);
  			}
  		},
  		raw: fn
  	};
  
  	if (!fn) {
  		if (isCommonjs) {
  			module.exports = {isEnabled: false};
  		} else {
  			window.screenfull = {isEnabled: false};
  		}
  
  		return;
  	}
  
  	Object.defineProperties(screenfull, {
  		isFullscreen: {
  			get: function () {
  				return Boolean(document[fn.fullscreenElement]);
  			}
  		},
  		element: {
  			enumerable: true,
  			get: function () {
  				return document[fn.fullscreenElement];
  			}
  		},
  		isEnabled: {
  			enumerable: true,
  			get: function () {
  				// Coerce to boolean in case of old WebKit
  				return Boolean(document[fn.fullscreenEnabled]);
  			}
  		}
  	});
  
  	if (isCommonjs) {
  		module.exports = screenfull;
  	} else {
  		window.screenfull = screenfull;
  	}
  })();
  
  },{}],118:[function(require,module,exports){
  (function (Buffer){
  (function() {
    var crypt = require('crypt'),
        utf8 = require('charenc').utf8,
        bin = require('charenc').bin,
  
    // The core
    sha1 = function (message) {
      // Convert to byte array
      if (message.constructor == String)
        message = utf8.stringToBytes(message);
      else if (typeof Buffer !== 'undefined' && typeof Buffer.isBuffer == 'function' && Buffer.isBuffer(message))
        message = Array.prototype.slice.call(message, 0);
      else if (!Array.isArray(message))
        message = message.toString();
  
      // otherwise assume byte array
  
      var m  = crypt.bytesToWords(message),
          l  = message.length * 8,
          w  = [],
          H0 =  1732584193,
          H1 = -271733879,
          H2 = -1732584194,
          H3 =  271733878,
          H4 = -1009589776;
  
      // Padding
      m[l >> 5] |= 0x80 << (24 - l % 32);
      m[((l + 64 >>> 9) << 4) + 15] = l;
  
      for (var i = 0; i < m.length; i += 16) {
        var a = H0,
            b = H1,
            c = H2,
            d = H3,
            e = H4;
  
        for (var j = 0; j < 80; j++) {
  
          if (j < 16)
            w[j] = m[i + j];
          else {
            var n = w[j - 3] ^ w[j - 8] ^ w[j - 14] ^ w[j - 16];
            w[j] = (n << 1) | (n >>> 31);
          }
  
          var t = ((H0 << 5) | (H0 >>> 27)) + H4 + (w[j] >>> 0) + (
                  j < 20 ? (H1 & H2 | ~H1 & H3) + 1518500249 :
                  j < 40 ? (H1 ^ H2 ^ H3) + 1859775393 :
                  j < 60 ? (H1 & H2 | H1 & H3 | H2 & H3) - 1894007588 :
                           (H1 ^ H2 ^ H3) - 899497514);
  
          H4 = H3;
          H3 = H2;
          H2 = (H1 << 30) | (H1 >>> 2);
          H1 = H0;
          H0 = t;
        }
  
        H0 += a;
        H1 += b;
        H2 += c;
        H3 += d;
        H4 += e;
      }
  
      return [H0, H1, H2, H3, H4];
    },
  
    // Public API
    api = function (message, options) {
      var digestbytes = crypt.wordsToBytes(sha1(message));
      return options && options.asBytes ? digestbytes :
          options && options.asString ? bin.bytesToString(digestbytes) :
          crypt.bytesToHex(digestbytes);
    };
  
    api._blocksize = 16;
    api._digestsize = 20;
  
    module.exports = api;
  })();
  
  }).call(this,require("buffer").Buffer)
  },{"buffer":111,"charenc":112,"crypt":113}],119:[function(require,module,exports){
  'use strict';
  
  let fastProto = null;
  
  // Creates an object with permanently fast properties in V8. See Toon Verwaest's
  // post https://medium.com/@tverwaes/setting-up-prototypes-in-v8-ec9c9491dfe2#5f62
  // for more details. Use %HasFastProperties(object) and the Node.js flag
  // --allow-natives-syntax to check whether an object has fast properties.
  function FastObject(o) {
  	// A prototype object will have "fast properties" enabled once it is checked
  	// against the inline property cache of a function, e.g. fastProto.property:
  	// https://github.com/v8/v8/blob/6.0.122/test/mjsunit/fast-prototype.js#L48-L63
  	if (fastProto !== null && typeof fastProto.property) {
  		const result = fastProto;
  		fastProto = FastObject.prototype = null;
  		return result;
  	}
  	fastProto = FastObject.prototype = o == null ? Object.create(null) : o;
  	return new FastObject;
  }
  
  // Initialize the inline property cache of FastObject
  FastObject();
  
  module.exports = function toFastproperties(o) {
  	return FastObject(o);
  };
  
  },{}]},{},[15]);
  