/*! For license information please see admin-content.js.LICENSE.txt */
(() => {
    function _typeof(o) {
        return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function(o) {
            return typeof o;
        } : function(o) {
            return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o;
        }, _typeof(o);
    }
    function _regeneratorRuntime() {
        "use strict";
        _regeneratorRuntime = function() {
            return e;
        };
        var t, e = {}, r = Object.prototype, n = r.hasOwnProperty, o = Object.defineProperty || function(t, e, r) {
            t[e] = r.value;
        }, i = "function" == typeof Symbol ? Symbol : {}, a = i.iterator || "@@iterator", c = i.asyncIterator || "@@asyncIterator", u = i.toStringTag || "@@toStringTag";
        function define(t, e, r) {
            return Object.defineProperty(t, e, {
                value: r,
                enumerable: !0,
                configurable: !0,
                writable: !0
            }), t[e];
        }
        try {
            define({}, "");
        } catch (t) {
            define = function(t, e, r) {
                return t[e] = r;
            };
        }
        function wrap(t, e, r, n) {
            var i = e && e.prototype instanceof Generator ? e : Generator, a = Object.create(i.prototype), c = new Context(n || []);
            return o(a, "_invoke", {
                value: makeInvokeMethod(t, r, c)
            }), a;
        }
        function tryCatch(t, e, r) {
            try {
                return {
                    type: "normal",
                    arg: t.call(e, r)
                };
            } catch (t) {
                return {
                    type: "throw",
                    arg: t
                };
            }
        }
        e.wrap = wrap;
        var h = "suspendedStart", l = "suspendedYield", f = "executing", s = "completed", y = {};
        function Generator() {}
        function GeneratorFunction() {}
        function GeneratorFunctionPrototype() {}
        var p = {};
        define(p, a, (function() {
            return this;
        }));
        var d = Object.getPrototypeOf, v = d && d(d(values([])));
        v && v !== r && n.call(v, a) && (p = v);
        var g = GeneratorFunctionPrototype.prototype = Generator.prototype = Object.create(p);
        function defineIteratorMethods(t) {
            [ "next", "throw", "return" ].forEach((function(e) {
                define(t, e, (function(t) {
                    return this._invoke(e, t);
                }));
            }));
        }
        function AsyncIterator(t, e) {
            function invoke(r, o, i, a) {
                var c = tryCatch(t[r], t, o);
                if ("throw" !== c.type) {
                    var u = c.arg, h = u.value;
                    return h && "object" == _typeof(h) && n.call(h, "__await") ? e.resolve(h.__await).then((function(t) {
                        invoke("next", t, i, a);
                    }), (function(t) {
                        invoke("throw", t, i, a);
                    })) : e.resolve(h).then((function(t) {
                        u.value = t, i(u);
                    }), (function(t) {
                        return invoke("throw", t, i, a);
                    }));
                }
                a(c.arg);
            }
            var r;
            o(this, "_invoke", {
                value: function(t, n) {
                    function callInvokeWithMethodAndArg() {
                        return new e((function(e, r) {
                            invoke(t, n, e, r);
                        }));
                    }
                    return r = r ? r.then(callInvokeWithMethodAndArg, callInvokeWithMethodAndArg) : callInvokeWithMethodAndArg();
                }
            });
        }
        function makeInvokeMethod(e, r, n) {
            var o = h;
            return function(i, a) {
                if (o === f) throw Error("Generator is already running");
                if (o === s) {
                    if ("throw" === i) throw a;
                    return {
                        value: t,
                        done: !0
                    };
                }
                for (n.method = i, n.arg = a; ;) {
                    var c = n.delegate;
                    if (c) {
                        var u = maybeInvokeDelegate(c, n);
                        if (u) {
                            if (u === y) continue;
                            return u;
                        }
                    }
                    if ("next" === n.method) n.sent = n._sent = n.arg; else if ("throw" === n.method) {
                        if (o === h) throw o = s, n.arg;
                        n.dispatchException(n.arg);
                    } else "return" === n.method && n.abrupt("return", n.arg);
                    o = f;
                    var p = tryCatch(e, r, n);
                    if ("normal" === p.type) {
                        if (o = n.done ? s : l, p.arg === y) continue;
                        return {
                            value: p.arg,
                            done: n.done
                        };
                    }
                    "throw" === p.type && (o = s, n.method = "throw", n.arg = p.arg);
                }
            };
        }
        function maybeInvokeDelegate(e, r) {
            var n = r.method, o = e.iterator[n];
            if (o === t) return r.delegate = null, "throw" === n && e.iterator.return && (r.method = "return", 
            r.arg = t, maybeInvokeDelegate(e, r), "throw" === r.method) || "return" !== n && (r.method = "throw", 
            r.arg = new TypeError("The iterator does not provide a '" + n + "' method")), y;
            var i = tryCatch(o, e.iterator, r.arg);
            if ("throw" === i.type) return r.method = "throw", r.arg = i.arg, r.delegate = null, 
            y;
            var a = i.arg;
            return a ? a.done ? (r[e.resultName] = a.value, r.next = e.nextLoc, "return" !== r.method && (r.method = "next", 
            r.arg = t), r.delegate = null, y) : a : (r.method = "throw", r.arg = new TypeError("iterator result is not an object"), 
            r.delegate = null, y);
        }
        function pushTryEntry(t) {
            var e = {
                tryLoc: t[0]
            };
            1 in t && (e.catchLoc = t[1]), 2 in t && (e.finallyLoc = t[2], e.afterLoc = t[3]), 
            this.tryEntries.push(e);
        }
        function resetTryEntry(t) {
            var e = t.completion || {};
            e.type = "normal", delete e.arg, t.completion = e;
        }
        function Context(t) {
            this.tryEntries = [ {
                tryLoc: "root"
            } ], t.forEach(pushTryEntry, this), this.reset(!0);
        }
        function values(e) {
            if (e || "" === e) {
                var r = e[a];
                if (r) return r.call(e);
                if ("function" == typeof e.next) return e;
                if (!isNaN(e.length)) {
                    var o = -1, i = function next() {
                        for (;++o < e.length; ) if (n.call(e, o)) return next.value = e[o], next.done = !1, 
                        next;
                        return next.value = t, next.done = !0, next;
                    };
                    return i.next = i;
                }
            }
            throw new TypeError(_typeof(e) + " is not iterable");
        }
        return GeneratorFunction.prototype = GeneratorFunctionPrototype, o(g, "constructor", {
            value: GeneratorFunctionPrototype,
            configurable: !0
        }), o(GeneratorFunctionPrototype, "constructor", {
            value: GeneratorFunction,
            configurable: !0
        }), GeneratorFunction.displayName = define(GeneratorFunctionPrototype, u, "GeneratorFunction"), 
        e.isGeneratorFunction = function(t) {
            var e = "function" == typeof t && t.constructor;
            return !!e && (e === GeneratorFunction || "GeneratorFunction" === (e.displayName || e.name));
        }, e.mark = function(t) {
            return Object.setPrototypeOf ? Object.setPrototypeOf(t, GeneratorFunctionPrototype) : (t.__proto__ = GeneratorFunctionPrototype, 
            define(t, u, "GeneratorFunction")), t.prototype = Object.create(g), t;
        }, e.awrap = function(t) {
            return {
                __await: t
            };
        }, defineIteratorMethods(AsyncIterator.prototype), define(AsyncIterator.prototype, c, (function() {
            return this;
        })), e.AsyncIterator = AsyncIterator, e.async = function(t, r, n, o, i) {
            void 0 === i && (i = Promise);
            var a = new AsyncIterator(wrap(t, r, n, o), i);
            return e.isGeneratorFunction(r) ? a : a.next().then((function(t) {
                return t.done ? t.value : a.next();
            }));
        }, defineIteratorMethods(g), define(g, u, "Generator"), define(g, a, (function() {
            return this;
        })), define(g, "toString", (function() {
            return "[object Generator]";
        })), e.keys = function(t) {
            var e = Object(t), r = [];
            for (var n in e) r.push(n);
            return r.reverse(), function next() {
                for (;r.length; ) {
                    var t = r.pop();
                    if (t in e) return next.value = t, next.done = !1, next;
                }
                return next.done = !0, next;
            };
        }, e.values = values, Context.prototype = {
            constructor: Context,
            reset: function(e) {
                if (this.prev = 0, this.next = 0, this.sent = this._sent = t, this.done = !1, this.delegate = null, 
                this.method = "next", this.arg = t, this.tryEntries.forEach(resetTryEntry), !e) for (var r in this) "t" === r.charAt(0) && n.call(this, r) && !isNaN(+r.slice(1)) && (this[r] = t);
            },
            stop: function() {
                this.done = !0;
                var t = this.tryEntries[0].completion;
                if ("throw" === t.type) throw t.arg;
                return this.rval;
            },
            dispatchException: function(e) {
                if (this.done) throw e;
                var r = this;
                function handle(n, o) {
                    return a.type = "throw", a.arg = e, r.next = n, o && (r.method = "next", r.arg = t), 
                    !!o;
                }
                for (var o = this.tryEntries.length - 1; o >= 0; --o) {
                    var i = this.tryEntries[o], a = i.completion;
                    if ("root" === i.tryLoc) return handle("end");
                    if (i.tryLoc <= this.prev) {
                        var c = n.call(i, "catchLoc"), u = n.call(i, "finallyLoc");
                        if (c && u) {
                            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
                            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
                        } else if (c) {
                            if (this.prev < i.catchLoc) return handle(i.catchLoc, !0);
                        } else {
                            if (!u) throw Error("try statement without catch or finally");
                            if (this.prev < i.finallyLoc) return handle(i.finallyLoc);
                        }
                    }
                }
            },
            abrupt: function(t, e) {
                for (var r = this.tryEntries.length - 1; r >= 0; --r) {
                    var o = this.tryEntries[r];
                    if (o.tryLoc <= this.prev && n.call(o, "finallyLoc") && this.prev < o.finallyLoc) {
                        var i = o;
                        break;
                    }
                }
                i && ("break" === t || "continue" === t) && i.tryLoc <= e && e <= i.finallyLoc && (i = null);
                var a = i ? i.completion : {};
                return a.type = t, a.arg = e, i ? (this.method = "next", this.next = i.finallyLoc, 
                y) : this.complete(a);
            },
            complete: function(t, e) {
                if ("throw" === t.type) throw t.arg;
                return "break" === t.type || "continue" === t.type ? this.next = t.arg : "return" === t.type ? (this.rval = this.arg = t.arg, 
                this.method = "return", this.next = "end") : "normal" === t.type && e && (this.next = e), 
                y;
            },
            finish: function(t) {
                for (var e = this.tryEntries.length - 1; e >= 0; --e) {
                    var r = this.tryEntries[e];
                    if (r.finallyLoc === t) return this.complete(r.completion, r.afterLoc), resetTryEntry(r), 
                    y;
                }
            },
            catch: function(t) {
                for (var e = this.tryEntries.length - 1; e >= 0; --e) {
                    var r = this.tryEntries[e];
                    if (r.tryLoc === t) {
                        var n = r.completion;
                        if ("throw" === n.type) {
                            var o = n.arg;
                            resetTryEntry(r);
                        }
                        return o;
                    }
                }
                throw Error("illegal catch attempt");
            },
            delegateYield: function(e, r, n) {
                return this.delegate = {
                    iterator: values(e),
                    resultName: r,
                    nextLoc: n
                }, "next" === this.method && (this.arg = t), y;
            }
        }, e;
    }
    function _slicedToArray(r, e) {
        return function(r) {
            if (Array.isArray(r)) return r;
        }(r) || function(r, l) {
            var t = null == r ? null : "undefined" != typeof Symbol && r[Symbol.iterator] || r["@@iterator"];
            if (null != t) {
                var e, n, i, u, a = [], f = !0, o = !1;
                try {
                    if (i = (t = t.call(r)).next, 0 === l) {
                        if (Object(t) !== t) return;
                        f = !1;
                    } else for (;!(f = (e = i.call(t)).done) && (a.push(e.value), a.length !== l); f = !0) ;
                } catch (r) {
                    o = !0, n = r;
                } finally {
                    try {
                        if (!f && null != t.return && (u = t.return(), Object(u) !== u)) return;
                    } finally {
                        if (o) throw n;
                    }
                }
                return a;
            }
        }(r, e) || function(r, a) {
            if (r) {
                if ("string" == typeof r) return _arrayLikeToArray(r, a);
                var t = {}.toString.call(r).slice(8, -1);
                return "Object" === t && r.constructor && (t = r.constructor.name), "Map" === t || "Set" === t ? Array.from(r) : "Arguments" === t || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(t) ? _arrayLikeToArray(r, a) : void 0;
            }
        }(r, e) || function() {
            throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
        }();
    }
    function _arrayLikeToArray(r, a) {
        (null == a || a > r.length) && (a = r.length);
        for (var e = 0, n = Array(a); e < a; e++) n[e] = r[e];
        return n;
    }
    function asyncGeneratorStep(n, t, e, r, o, a, c) {
        try {
            var i = n[a](c), u = i.value;
        } catch (n) {
            return void e(n);
        }
        i.done ? t(u) : Promise.resolve(u).then(r, o);
    }
    function _asyncToGenerator(n) {
        return function() {
            var t = this, e = arguments;
            return new Promise((function(r, o) {
                var a = n.apply(t, e);
                function _next(n) {
                    asyncGeneratorStep(a, r, o, _next, _throw, "next", n);
                }
                function _throw(n) {
                    asyncGeneratorStep(a, r, o, _next, _throw, "throw", n);
                }
                _next(void 0);
            }));
        };
    }
    var _storeItems = function() {
        var _ref = _asyncToGenerator(_regeneratorRuntime().mark((function _callee(items) {
            var nonce, idx, _window, ajaxurl, data, _i, _Object$entries, _Object$entries$_i, key, value, prog, _args = arguments;
            return _regeneratorRuntime().wrap((function(_context) {
                for (;;) switch (_context.prev = _context.next) {
                  case 0:
                    if (nonce = _args.length > 1 && void 0 !== _args[1] ? _args[1] : null, idx = _args.length > 2 && void 0 !== _args[2] ? _args[2] : 0, 
                    items.length) {
                        _context.next = 4;
                        break;
                    }
                    return _context.abrupt("return", !0);

                  case 4:
                    for (nonce || (nonce = ag_content_params.nonce), _window = window, ajaxurl = _window.ajaxurl, 
                    (data = new FormData).append("action", "age_gate_store_terms"), data.append("idx", idx), 
                    data.append("nonce", nonce), _i = 0, _Object$entries = Object.entries(items[0]); _i < _Object$entries.length; _i++) _Object$entries$_i = _slicedToArray(_Object$entries[_i], 2), 
                    key = _Object$entries$_i[0], value = _Object$entries$_i[1], data.append("ag_settings[".concat(key, "]"), value);
                    return _context.prev = 12, _context.next = 15, fetch(ajaxurl, {
                        method: "POST",
                        body: data
                    });

                  case 15:
                    return _context.next = 17, _context.sent.json();

                  case 17:
                    _context.sent, _context.next = 23;
                    break;

                  case 20:
                    return _context.prev = 20, _context.t0 = _context.catch(12), _context.abrupt("return", !1);

                  case 23:
                    return items.shift(), (prog = document.querySelector(".age-gate-progress")) && (prog.value = idx + 1), 
                    _context.abrupt("return", _storeItems(items, nonce, idx + 1));

                  case 27:
                  case "end":
                    return _context.stop();
                }
            }), _callee, null, [ [ 12, 20 ] ]);
        })));
        return function(_x) {
            return _ref.apply(this, arguments);
        };
    }();
    window.addEventListener("DOMContentLoaded", (function() {
        var contentForm = document.querySelector('[data-form="content"]');
        contentForm && contentForm.addEventListener("submit", function() {
            var _ref2 = _asyncToGenerator(_regeneratorRuntime().mark((function _callee2(e) {
                var fields, all, backup, progress, wrapper, overlay, _ag_content_params, save_error;
                return _regeneratorRuntime().wrap((function(_context2) {
                    for (;;) switch (_context2.prev = _context2.next) {
                      case 0:
                        return e.preventDefault(), fields = Array.from(document.querySelectorAll('[name="ag_settings[terms][]"]')), 
                        all = [], backup = [], fields.forEach((function(field) {
                            var object = JSON.parse(field.value);
                            backup.push(field.value);
                            var values = Object.values(object), portion = {}, _final = [], counter = 0;
                            for (var key in object) 0 !== counter && counter % 50 == 0 && (_final.push(portion), 
                            portion = {}), portion[key] = values[counter], counter++;
                            _final.push(portion), field.value = "", all = all.concat(_final);
                        })), progress = document.createElement("progress"), (wrapper = document.createElement("div")).className = "age-gate-overlay", 
                        progress.className = "age-gate-progress", wrapper.append(progress), document.body.appendChild(wrapper), 
                        progress.max = all.length, progress.value = 0, _context2.next = 15, _storeItems(all);

                      case 15:
                        if (!1 !== _context2.sent) {
                            _context2.next = 24;
                            break;
                        }
                        return backup.forEach((function(d, i) {
                            return fields[i].value = d;
                        })), (overlay = document.querySelector(".age-gate-overlay")) && overlay.parentNode.removeChild(overlay), 
                        _ag_content_params = ag_content_params, save_error = _ag_content_params.save_error, 
                        document.querySelector(".wrap h2").insertAdjacentHTML("afterend", '<div class="notice notice-error"><p><strong>'.concat(save_error, "</strong></p></div>")), 
                        window.scrollTo({
                            top: 0,
                            left: 0,
                            behavior: "smooth"
                        }), _context2.abrupt("return");

                      case 24:
                        contentForm.submit();

                      case 25:
                      case "end":
                        return _context2.stop();
                    }
                }), _callee2);
            })));
            return function(_x2) {
                return _ref2.apply(this, arguments);
            };
        }());
    }));
})();