/*! elementor - v3.30.0 - 22-07-2025 */
/******/ (() => { // webpackBootstrap
/******/ 	var __webpack_modules__ = ({

/***/ "../assets/dev/js/utils/react.js":
/*!***************************************!*\
  !*** ../assets/dev/js/utils/react.js ***!
  \***************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _typeof = __webpack_require__(/*! @babel/runtime/helpers/typeof */ "../node_modules/@babel/runtime/helpers/typeof.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports["default"] = void 0;
var React = _interopRequireWildcard(__webpack_require__(/*! react */ "react"));
var ReactDOM = _interopRequireWildcard(__webpack_require__(/*! react-dom */ "react-dom"));
var _client = __webpack_require__(/*! react-dom/client */ "../node_modules/react-dom/client.js");
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
/**
 * Support conditional rendering of a React App to the DOM, based on the React version.
 * We use `createRoot` when available, but fallback to `ReactDOM.render` for older versions.
 *
 * @param { React.ReactElement } app        The app to render.
 * @param { HTMLElement }        domElement The DOM element to render the app into.
 *
 * @return {{ unmount: () => void }} The unmount function.
 */
function render(app, domElement) {
  var unmountFunction;
  try {
    var root = (0, _client.createRoot)(domElement);
    root.render(app);
    unmountFunction = function unmountFunction() {
      root.unmount();
    };
  } catch (e) {
    // eslint-disable-next-line react/no-deprecated
    ReactDOM.render(app, domElement);
    unmountFunction = function unmountFunction() {
      // eslint-disable-next-line react/no-deprecated
      ReactDOM.unmountComponentAtNode(domElement);
    };
  }
  return {
    unmount: unmountFunction
  };
}
var _default = exports["default"] = {
  render: render
};

/***/ }),

/***/ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-api.js":
/*!********************************************************************!*\
  !*** ../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-api.js ***!
  \********************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.triggerOptOut = exports.triggerOptIn = void 0;
var _regenerator = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/regenerator */ "../node_modules/@babel/runtime/regenerator/index.js"));
var _asyncToGenerator2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/asyncToGenerator */ "../node_modules/@babel/runtime/helpers/asyncToGenerator.js"));
var triggerOptIn = exports.triggerOptIn = /*#__PURE__*/function () {
  var _ref = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee() {
    return _regenerator.default.wrap(function _callee$(_context) {
      while (1) switch (_context.prev = _context.next) {
        case 0:
          return _context.abrupt("return", elementorCommon.ajax.addRequest('editor_v4_opt_in'));
        case 1:
        case "end":
          return _context.stop();
      }
    }, _callee);
  }));
  return function triggerOptIn() {
    return _ref.apply(this, arguments);
  };
}();
var triggerOptOut = exports.triggerOptOut = /*#__PURE__*/function () {
  var _ref2 = (0, _asyncToGenerator2.default)(/*#__PURE__*/_regenerator.default.mark(function _callee2() {
    return _regenerator.default.wrap(function _callee2$(_context2) {
      while (1) switch (_context2.prev = _context2.next) {
        case 0:
          return _context2.abrupt("return", elementorCommon.ajax.addRequest('editor_v4_opt_out'));
        case 1:
        case "end":
          return _context2.stop();
      }
    }, _callee2);
  }));
  return function triggerOptOut() {
    return _ref2.apply(this, arguments);
  };
}();

/***/ }),

/***/ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-content.js":
/*!************************************************************************!*\
  !*** ../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-content.js ***!
  \************************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
/* provided dependency */ var PropTypes = __webpack_require__(/*! prop-types */ "../node_modules/prop-types/index.js");


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.TextNode = exports.ContentListItem = exports.ContentList = exports.AdvantagesListItem = exports.AdvantagesList = void 0;
var _react = _interopRequireDefault(__webpack_require__(/*! react */ "react"));
var _extends2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/extends */ "../node_modules/@babel/runtime/helpers/extends.js"));
var _objectWithoutProperties2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/objectWithoutProperties */ "../node_modules/@babel/runtime/helpers/objectWithoutProperties.js"));
var _ui = __webpack_require__(/*! @elementor/ui */ "@elementor/ui");
var _icons = __webpack_require__(/*! @elementor/icons */ "@elementor/icons");
var _excluded = ["children"],
  _excluded2 = ["children"],
  _excluded3 = ["children"],
  _excluded4 = ["children"],
  _excluded5 = ["children"];
var TextNode = exports.TextNode = function TextNode(_ref) {
  var children = _ref.children,
    props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
  return /*#__PURE__*/_react.default.createElement(_ui.Typography, (0, _extends2.default)({
    color: "text.primary"
  }, props), children);
};
TextNode.propTypes = {
  children: PropTypes.node
};
var ContentList = exports.ContentList = function ContentList(_ref2) {
  var children = _ref2.children,
    props = (0, _objectWithoutProperties2.default)(_ref2, _excluded2);
  return /*#__PURE__*/_react.default.createElement(_ui.Box, (0, _extends2.default)({
    component: "ul",
    sx: {
      my: 0
    }
  }, props), children);
};
ContentList.propTypes = {
  children: PropTypes.node
};
var ContentListItem = exports.ContentListItem = function ContentListItem(_ref3) {
  var children = _ref3.children,
    props = (0, _objectWithoutProperties2.default)(_ref3, _excluded3);
  return /*#__PURE__*/_react.default.createElement(TextNode, (0, _extends2.default)({
    component: "li",
    sx: {
      listStyle: 'disc',
      marginInlineStart: 3
    }
  }, props), children);
};
ContentListItem.propTypes = {
  children: PropTypes.node
};
var AdvantagesList = exports.AdvantagesList = function AdvantagesList(_ref4) {
  var children = _ref4.children,
    props = (0, _objectWithoutProperties2.default)(_ref4, _excluded4);
  return /*#__PURE__*/_react.default.createElement(_ui.Box, (0, _extends2.default)({
    component: "ul",
    sx: {
      display: 'flex',
      flexDirection: 'column',
      gap: 0.5,
      my: 0
    }
  }, props), children);
};
AdvantagesList.propTypes = {
  children: PropTypes.node
};
var AdvantagesListItem = exports.AdvantagesListItem = function AdvantagesListItem(_ref5) {
  var children = _ref5.children,
    props = (0, _objectWithoutProperties2.default)(_ref5, _excluded5);
  return /*#__PURE__*/_react.default.createElement(TextNode, (0, _extends2.default)({
    component: "li",
    sx: {
      listStyle: 'none',
      marginInlineStart: 0,
      lineHeight: '150%',
      display: 'flex',
      alignItems: 'flex-start',
      gap: 0.5
    }
  }, props), /*#__PURE__*/_react.default.createElement(_icons.CheckIcon, {
    fontSize: "small"
  }), children);
};
AdvantagesListItem.propTypes = {
  children: PropTypes.node
};

/***/ }),

/***/ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-img-placeholders.js":
/*!*********************************************************************************!*\
  !*** ../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-img-placeholders.js ***!
  \*********************************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.ImageSquarePlaceholder = exports.ImageLandscapePlaceholder = void 0;
var _react = _interopRequireDefault(__webpack_require__(/*! react */ "react"));
var _extends2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/extends */ "../node_modules/@babel/runtime/helpers/extends.js"));
var _ui = __webpack_require__(/*! @elementor/ui */ "@elementor/ui");
var ImageLandscapePlaceholder = exports.ImageLandscapePlaceholder = function ImageLandscapePlaceholder(props) {
  return /*#__PURE__*/_react.default.createElement(_ui.SvgIcon, (0, _extends2.default)({
    viewBox: "0 0 600 260"
  }, props), /*#__PURE__*/_react.default.createElement("rect", {
    x: "0",
    y: "0",
    width: "600",
    height: "260",
    fill: "#d9d9d9"
  }));
};
var ImageSquarePlaceholder = exports.ImageSquarePlaceholder = function ImageSquarePlaceholder(props) {
  return /*#__PURE__*/_react.default.createElement(_ui.SvgIcon, (0, _extends2.default)({
    viewBox: "0 0 500 500"
  }, props), /*#__PURE__*/_react.default.createElement("rect", {
    x: "0",
    y: "0",
    width: "500",
    height: "500",
    fill: "#d9d9d9"
  }));
};

/***/ }),

/***/ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-message.js":
/*!************************************************************************!*\
  !*** ../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-message.js ***!
  \************************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
/* provided dependency */ var PropTypes = __webpack_require__(/*! prop-types */ "../node_modules/prop-types/index.js");


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.Message = void 0;
var _react = _interopRequireDefault(__webpack_require__(/*! react */ "react"));
var _ui = __webpack_require__(/*! @elementor/ui */ "@elementor/ui");
var _icons = __webpack_require__(/*! @elementor/icons */ "@elementor/icons");
var Message = exports.Message = function Message(_ref) {
  var action = _ref.action,
    children = _ref.children,
    _ref$severity = _ref.severity,
    severity = _ref$severity === void 0 ? 'message' : _ref$severity,
    onClose = _ref.onClose;
  return /*#__PURE__*/_react.default.createElement(_ui.Snackbar, {
    open: true,
    autoHideDuration: 4000,
    anchorOrigin: {
      vertical: 'bottom',
      horizontal: 'right'
    },
    onClose: onClose
  }, 'message' !== severity ? /*#__PURE__*/_react.default.createElement(_ui.Alert, {
    variant: "filled",
    severity: severity,
    onClose: onClose
  }, children) : /*#__PURE__*/_react.default.createElement(_ui.SnackbarContent, {
    message: /*#__PURE__*/_react.default.createElement(_ui.Stack, {
      direction: "row",
      gap: 1.5,
      alignItems: "center"
    }, /*#__PURE__*/_react.default.createElement(_icons.CircleCheckFilledIcon, null), children),
    action: /*#__PURE__*/_react.default.createElement(_ui.Stack, {
      direction: "row",
      spacing: 1,
      alignItems: "center"
    }, action, /*#__PURE__*/_react.default.createElement(_ui.IconButton, {
      color: "inherit",
      size: "small",
      onClick: onClose
    }, /*#__PURE__*/_react.default.createElement(_icons.XIcon, {
      fontSize: "small"
    })))
  }));
};
Message.propTypes = {
  action: PropTypes.node,
  children: PropTypes.node,
  severity: PropTypes.oneOf(['message', 'success', 'warning', 'error']),
  onClose: PropTypes.func
};

/***/ }),

/***/ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-terms.js":
/*!**********************************************************************!*\
  !*** ../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-terms.js ***!
  \**********************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
/* provided dependency */ var PropTypes = __webpack_require__(/*! prop-types */ "../node_modules/prop-types/index.js");


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
var _typeof = __webpack_require__(/*! @babel/runtime/helpers/typeof */ "../node_modules/@babel/runtime/helpers/typeof.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.Terms = void 0;
var _extends2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/extends */ "../node_modules/@babel/runtime/helpers/extends.js"));
var _slicedToArray2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/slicedToArray */ "../node_modules/@babel/runtime/helpers/slicedToArray.js"));
var _objectWithoutProperties2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/objectWithoutProperties */ "../node_modules/@babel/runtime/helpers/objectWithoutProperties.js"));
var _i18n = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
var _ui = __webpack_require__(/*! @elementor/ui */ "@elementor/ui");
var _react = _interopRequireWildcard(__webpack_require__(/*! react */ "react"));
var _optInContent = __webpack_require__(/*! ./opt-in-content */ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-content.js");
var _DialogHeaderGroup = _interopRequireDefault(__webpack_require__(/*! @elementor/ui/DialogHeaderGroup */ "@elementor/ui/DialogHeaderGroup"));
var _DialogHeader = _interopRequireDefault(__webpack_require__(/*! @elementor/ui/DialogHeader */ "@elementor/ui/DialogHeader"));
var _excluded = ["onClose", "onSubmit", "isEnrolled"];
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
var i18n = {
  header: (0, _i18n.__)('Editor V4', 'elementor'),
  chip: (0, _i18n.__)('Alpha', 'elementor'),
  checkboxText: (0, _i18n.__)('I’ve read and understood.', 'elementor'),
  optIn: {
    titleText: (0, _i18n.__)('You are about to enable Editor V4 features!', 'elementor'),
    introText: (0, _i18n.__)('By activating, you’ll get early access to the next generation of Elementor’s Editor. This is your chance to explore new capabilities and help shape the future of Elementor! ', 'elementor'),
    notesHeader: (0, _i18n.__)(' Important notes:', 'elementor'),
    notes: {
      alphaPrefix: (0, _i18n.__)('Editor V4 is currently in alpha, ', 'elementor'),
      details: [(0, _i18n.__)('and development is still in progress. Do not use it on live sites - use a staging or development environment instead.', 'elementor'), (0, _i18n.__)('When you activate Editor V4, you’ll also be activating Containers, the Top Bar, and Nested Elements. You can turn them back off by going to WP Admin > Elementor > Settings > Features.', 'elementor')]
    },
    activateButton: (0, _i18n.__)('Activate', 'elementor'),
    cancelButton: (0, _i18n.__)('Cancel', 'elementor')
  },
  optOut: {
    titleText: (0, _i18n.__)('You’re deactivating Editor V4', 'elementor'),
    introText: (0, _i18n.__)('We hope you enjoyed testing and building with these new features.', 'elementor'),
    notesHeader: (0, _i18n.__)('Keep in mind:', 'elementor'),
    notes: {
      details: [(0, _i18n.__)('By deactivating, you’ll lose all Editor V4 features, and any content you created with V4-specific features will no longer be available or appear on your site.', 'elementor'), (0, _i18n.__)('Containers, the Top Bar, and Nested Elements will stay in their current status.', 'elementor')]
    },
    activateButton: (0, _i18n.__)('Deactivate V4', 'elementor'),
    cancelButton: (0, _i18n.__)('Cancel', 'elementor')
  }
};
var Terms = exports.Terms = function Terms(_ref) {
  var onClose = _ref.onClose,
    onSubmit = _ref.onSubmit,
    isEnrolled = _ref.isEnrolled,
    props = (0, _objectWithoutProperties2.default)(_ref, _excluded);
  var _useState = (0, _react.useState)(false),
    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
    checked = _useState2[0],
    setChecked = _useState2[1];
  var handleCheckboxChange = function handleCheckboxChange() {
    setChecked(function (prev) {
      return !prev;
    });
  };
  var handleSubmit = function handleSubmit() {
    if (checked) {
      onSubmit();
    }
  };
  var currentState = isEnrolled ? 'optOut' : 'optIn';
  return /*#__PURE__*/_react.default.createElement(_ui.Dialog, (0, _extends2.default)({}, props, {
    open: true,
    onClose: onClose
  }), /*#__PURE__*/_react.default.createElement(_DialogHeader.default, null, /*#__PURE__*/_react.default.createElement(_DialogHeaderGroup.default, null, /*#__PURE__*/_react.default.createElement(_ui.DialogTitle, null, i18n.header), /*#__PURE__*/_react.default.createElement(_ui.Chip, {
    label: i18n.chip,
    color: "secondary",
    variant: "filled",
    size: "small"
  }))), /*#__PURE__*/_react.default.createElement(_ui.DialogContent, {
    dividers: true
  }, /*#__PURE__*/_react.default.createElement(_ui.Stack, {
    gap: 2.5
  }, /*#__PURE__*/_react.default.createElement(_ui.Stack, {
    gap: 1
  }, /*#__PURE__*/_react.default.createElement(_optInContent.TextNode, {
    align: "center",
    variant: "h6"
  }, i18n[currentState].titleText), /*#__PURE__*/_react.default.createElement(_optInContent.TextNode, {
    align: "center",
    variant: "body2"
  }, i18n[currentState].introText)), /*#__PURE__*/_react.default.createElement(_ui.Stack, {
    gap: 1
  }, /*#__PURE__*/_react.default.createElement(_optInContent.TextNode, {
    variant: "body2"
  }, i18n[currentState].notesHeader), /*#__PURE__*/_react.default.createElement(_optInContent.ContentList, null, /*#__PURE__*/_react.default.createElement(_optInContent.ContentListItem, {
    variant: "body2"
  }, !isEnrolled && /*#__PURE__*/_react.default.createElement(_optInContent.TextNode, {
    variant: "subtitle2",
    component: "span"
  }, i18n.optIn.notes.alphaPrefix), i18n[currentState].notes.details[0]), i18n[currentState].notes.details.slice(1).map(function (entry, index) {
    return /*#__PURE__*/_react.default.createElement(_optInContent.ContentListItem, {
      key: index,
      variant: "body2"
    }, entry);
  }))), /*#__PURE__*/_react.default.createElement(_ui.FormControlLabel, {
    control: /*#__PURE__*/_react.default.createElement(_ui.Checkbox, {
      checked: !!checked,
      onChange: handleCheckboxChange,
      color: "secondary",
      size: "small"
    }),
    label: /*#__PURE__*/_react.default.createElement(_optInContent.TextNode, {
      variant: "body2"
    }, i18n.checkboxText)
  }))), /*#__PURE__*/_react.default.createElement(_ui.DialogActions, null, /*#__PURE__*/_react.default.createElement(_ui.Button, {
    variant: "text",
    color: "secondary",
    onClick: onClose
  }, i18n[currentState].cancelButton), /*#__PURE__*/_react.default.createElement(_ui.Button, {
    disabled: !checked,
    variant: "contained",
    onClick: handleSubmit
  }, i18n[currentState].activateButton)));
};
Terms.propTypes = {
  onClose: PropTypes.func,
  onSubmit: PropTypes.func,
  isEnrolled: PropTypes.bool
};

/***/ }),

/***/ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in.js":
/*!****************************************************************!*\
  !*** ../modules/atomic-opt-in/assets/js/opt-in-page/opt-in.js ***!
  \****************************************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";
/* provided dependency */ var PropTypes = __webpack_require__(/*! prop-types */ "../node_modules/prop-types/index.js");


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
var _typeof = __webpack_require__(/*! @babel/runtime/helpers/typeof */ "../node_modules/@babel/runtime/helpers/typeof.js");
Object.defineProperty(exports, "__esModule", ({
  value: true
}));
exports.OptIn = void 0;
var _react = _interopRequireWildcard(__webpack_require__(/*! react */ "react"));
var _defineProperty2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/defineProperty */ "../node_modules/@babel/runtime/helpers/defineProperty.js"));
var _slicedToArray2 = _interopRequireDefault(__webpack_require__(/*! @babel/runtime/helpers/slicedToArray */ "../node_modules/@babel/runtime/helpers/slicedToArray.js"));
var _ui = __webpack_require__(/*! @elementor/ui */ "@elementor/ui");
var _icons = __webpack_require__(/*! @elementor/icons */ "@elementor/icons");
var _i18n = __webpack_require__(/*! @wordpress/i18n */ "@wordpress/i18n");
var _optInContent = __webpack_require__(/*! ./opt-in-content */ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-content.js");
var _optInImgPlaceholders = __webpack_require__(/*! ./opt-in-img-placeholders */ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-img-placeholders.js");
var _optInMessage = __webpack_require__(/*! ./opt-in-message */ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-message.js");
var _optInApi = __webpack_require__(/*! ./opt-in-api */ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-api.js");
var _dompurify = _interopRequireDefault(__webpack_require__(/*! dompurify */ "../node_modules/dompurify/dist/purify.cjs.js"));
var _optInTerms = __webpack_require__(/*! ./opt-in-terms */ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in-terms.js");
var _elementorSettingsEdi;
function _getRequireWildcardCache(e) { if ("function" != typeof WeakMap) return null; var r = new WeakMap(), t = new WeakMap(); return (_getRequireWildcardCache = function _getRequireWildcardCache(e) { return e ? t : r; })(e); }
function _interopRequireWildcard(e, r) { if (!r && e && e.__esModule) return e; if (null === e || "object" != _typeof(e) && "function" != typeof e) return { default: e }; var t = _getRequireWildcardCache(r); if (t && t.has(e)) return t.get(e); var n = { __proto__: null }, a = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var u in e) if ("default" !== u && {}.hasOwnProperty.call(e, u)) { var i = a ? Object.getOwnPropertyDescriptor(e, u) : null; i && (i.get || i.set) ? Object.defineProperty(n, u, i) : n[u] = e[u]; } return n.default = e, t && t.set(e, n), n; }
function ownKeys(e, r) { var t = Object.keys(e); if (Object.getOwnPropertySymbols) { var o = Object.getOwnPropertySymbols(e); r && (o = o.filter(function (r) { return Object.getOwnPropertyDescriptor(e, r).enumerable; })), t.push.apply(t, o); } return t; }
function _objectSpread(e) { for (var r = 1; r < arguments.length; r++) { var t = null != arguments[r] ? arguments[r] : {}; r % 2 ? ownKeys(Object(t), !0).forEach(function (r) { (0, _defineProperty2.default)(e, r, t[r]); }) : Object.getOwnPropertyDescriptors ? Object.defineProperties(e, Object.getOwnPropertyDescriptors(t)) : ownKeys(Object(t)).forEach(function (r) { Object.defineProperty(e, r, Object.getOwnPropertyDescriptor(t, r)); }); } return e; }
var decodeHtmlUrl = function decodeHtmlUrl(html) {
  var textarea = document.createElement('textarea');
  textarea.innerHTML = html;
  return textarea.value;
};
var OPT_IN_MSG = 'e-editor-v4-opt-in-message';
var OPT_OUT_MSG = 'e-editor-v4-opt-out-message';
var i18n = {
  title: (0, _i18n.__)('The road to Editor V4', 'elementor'),
  chip: (0, _i18n.__)('Alpha', 'elementor'),
  welcomeText: (0, _i18n.__)('Welcome to a new era of web creation with Editor V4. It’s faster, more flexible, and built with a fresh approach to structure & styling.', 'elementor'),
  advantagesHeader: (0, _i18n.__)('Here’s what’s inside the alpha version:', 'elementor'),
  advantages: [(0, _i18n.__)('Unparalleled performance - Cleaner code & a lighter CSS footprint.', 'elementor'), (0, _i18n.__)('Professional tools at your fingertips - classes and states.', 'elementor'), (0, _i18n.__)('Consistent styling experience - A unified Style tab for all elements.', 'elementor'), (0, _i18n.__)('Fully responsive design - Customize any style property per screen.', 'elementor')],
  andMore: (0, _i18n.__)('And much more!', 'elementor'),
  readMore: (0, _i18n.__)('Learn more', 'elementor'),
  warning: (0, _i18n.__)('Editor V4 is still in alpha and should not be used on live sites yet.', 'elementor'),
  feedback: (0, _i18n.__)('We’d love your feedback!', 'elementor'),
  overToGithub: (0, _i18n.__)('Head over to Github', 'elementor'),
  tellUsWhy: (0, _i18n.__)('Tell us why', 'elementor'),
  image: (0, _i18n.__)('Editor V4', 'elementor'),
  buttons: {
    tryOut: (0, _i18n.__)('Try out the new experience', 'elementor'),
    optIn: (0, _i18n.__)('Activate the new experience', 'elementor'),
    optOut: (0, _i18n.__)('Deactivate V4', 'elementor')
  },
  messages: {
    optInSuccess: (0, _i18n.__)('Welcome! You’ve got the newest version of the editor.', 'elementor'),
    optOut: (0, _i18n.__)('You’ve deactivated the new Editor. Have feedback?', 'elementor'),
    error: (0, _i18n.__)('Ouch, there was a glitch. Try activating V4 again soon.', 'elementor')
  }
};
var optInLinks = {
  feedbackUrl: 'https://go.elementor.com/wp-dash-opt-in-v4-feedback/',
  readMoreUrl: 'https://go.elementor.com/wp-dash-opt-in-v4-help-center/',
  tryOutUrl: _dompurify.default.sanitize(decodeHtmlUrl((_elementorSettingsEdi = elementorSettingsEditor4OptIn) === null || _elementorSettingsEdi === void 0 || (_elementorSettingsEdi = _elementorSettingsEdi.urls) === null || _elementorSettingsEdi === void 0 ? void 0 : _elementorSettingsEdi.start_building)) || '#'
};
var optInImages = {
  square: {
    src: 'https://assets.elementor.com/v4-promotion/v1/images/v4_opt_in_500.png',
    sx: {
      width: '100%',
      maxHeight: '507px',
      maxWidth: 'sm',
      height: 'auto',
      mx: 'auto',
      borderRadius: 2
    }
  },
  landscape: {
    src: 'https://assets.elementor.com/v4-promotion/v1/images/v4_opt_in_260.png',
    sx: {
      width: '100%',
      height: 'auto',
      maxHeight: '260px',
      mx: 'auto',
      maxWidth: 'sm',
      borderRadius: 2
    }
  }
};
var OptIn = exports.OptIn = function OptIn(_ref) {
  var _state$features;
  var state = _ref.state;
  var _useState = (0, _react.useState)(false),
    _useState2 = (0, _slicedToArray2.default)(_useState, 2),
    showTerms = _useState2[0],
    setShowTerms = _useState2[1];
  var _useState3 = (0, _react.useState)(''),
    _useState4 = (0, _slicedToArray2.default)(_useState3, 2),
    optInMessage = _useState4[0],
    setOptInMessage = _useState4[1];
  var _useState5 = (0, _react.useState)(''),
    _useState6 = (0, _slicedToArray2.default)(_useState5, 2),
    optOutMessage = _useState6[0],
    setOptOutMessage = _useState6[1];
  var _useState7 = (0, _react.useState)(''),
    _useState8 = (0, _slicedToArray2.default)(_useState7, 2),
    errorMessage = _useState8[0],
    setErrorMessage = _useState8[1];
  (0, _react.useEffect)(function () {
    var optInMsg = sessionStorage.getItem(OPT_IN_MSG);
    var optOutMsg = sessionStorage.getItem(OPT_OUT_MSG);
    if (optInMsg) {
      setTimeout(function () {
        setOptInMessage(optInMsg);
      }, 100);
      sessionStorage.removeItem(OPT_IN_MSG);
    }
    if (optOutMsg) {
      setTimeout(function () {
        setOptOutMessage(optOutMsg);
      }, 100);
      sessionStorage.removeItem(OPT_OUT_MSG);
    }
  }, []);
  var maybeOptIn = function maybeOptIn() {
    (0, _optInApi.triggerOptIn)().then(function () {
      sessionStorage.setItem(OPT_IN_MSG, i18n.messages.optInSuccess);
      window.location.reload();
    }).catch(function () {
      setErrorMessage(i18n.messages.error);
    });
  };
  var maybeOptOut = function maybeOptOut() {
    (0, _optInApi.triggerOptOut)().then(function () {
      sessionStorage.setItem(OPT_OUT_MSG, i18n.messages.optOut);
      window.location.reload();
    }).catch(function () {
      setErrorMessage(i18n.messages.error);
    });
  };
  var handlePopoverClose = function handlePopoverClose() {
    setShowTerms(false);
  };
  var isEnrolled = !!(state !== null && state !== void 0 && (_state$features = state.features) !== null && _state$features !== void 0 && _state$features.editor_v4);
  return /*#__PURE__*/_react.default.createElement(_ui.Container, {
    maxWidth: "xl",
    sx: {
      marginBlockStart: 2.5,
      display: 'flex',
      flexBasis: '100%',
      gap: 3,
      flexDirection: {
        xs: 'column-reverse',
        md: 'row'
      }
    }
  }, /*#__PURE__*/_react.default.createElement(_ui.Stack, {
    sx: {
      flex: 1,
      maxWidth: {
        md: '507px',
        sm: '600px'
      },
      gap: 2.5,
      mx: 'auto'
    }
  }, /*#__PURE__*/_react.default.createElement(_ui.Stack, {
    direction: "row",
    alignItems: "center",
    gap: 1
  }, /*#__PURE__*/_react.default.createElement(_optInContent.TextNode, {
    variant: "h4",
    width: "fit-content"
  }, i18n.title), /*#__PURE__*/_react.default.createElement(_ui.Chip, {
    size: "small",
    color: "secondary",
    variant: "filled",
    label: i18n.chip
  })), /*#__PURE__*/_react.default.createElement(_ui.Stack, {
    direction: "column",
    gap: 3
  }, /*#__PURE__*/_react.default.createElement(_ui.Box, null, /*#__PURE__*/_react.default.createElement(_optInContent.TextNode, null, i18n.welcomeText)), /*#__PURE__*/_react.default.createElement(_ui.Box, null, /*#__PURE__*/_react.default.createElement(_optInContent.TextNode, {
    variant: "subtitle1",
    sx: {
      mb: 1.5
    }
  }, i18n.advantagesHeader), /*#__PURE__*/_react.default.createElement(_optInContent.AdvantagesList, null, i18n.advantages.map(function (entry, i) {
    return /*#__PURE__*/_react.default.createElement(_optInContent.AdvantagesListItem, {
      key: i
    }, entry);
  }), /*#__PURE__*/_react.default.createElement(_optInContent.AdvantagesListItem, {
    key: i18n.advantages.length
  }, i18n.andMore, " ", /*#__PURE__*/_react.default.createElement(_ui.Link, {
    color: "text.primary",
    href: optInLinks.readMoreUrl,
    target: "_blank"
  }, i18n.readMore))))), /*#__PURE__*/_react.default.createElement(_ui.Stack, {
    direction: "row",
    alignItems: "self-start",
    gap: 0.5,
    sx: {
      mb: 2.5
    }
  }, /*#__PURE__*/_react.default.createElement(_icons.AlertTriangleIcon, {
    color: "action"
  }), /*#__PURE__*/_react.default.createElement(_ui.Box, null, /*#__PURE__*/_react.default.createElement(_optInContent.TextNode, null, i18n.warning))), /*#__PURE__*/_react.default.createElement(_ui.Stack, {
    direction: "column",
    width: "clamp(240px, max(340px, 75%), 340px)",
    maxWidth: "100%",
    gap: 2
  }, !isEnrolled ? /*#__PURE__*/_react.default.createElement(_ui.Button, {
    onClick: function onClick() {
      setShowTerms(true);
    },
    size: "large",
    color: "primary",
    variant: "contained",
    sx: {
      flexGrow: 1
    }
  }, i18n.buttons.optIn) : /*#__PURE__*/_react.default.createElement(_ui.Button, {
    onClick: function onClick() {
      return window.location.href = optInLinks.tryOutUrl;
    },
    size: "large",
    color: "primary",
    variant: "contained",
    sx: {
      flexGrow: 1
    }
  }, i18n.buttons.tryOut), /*#__PURE__*/_react.default.createElement(_ui.Button, {
    onClick: function onClick() {
      setShowTerms(true);
    },
    size: "large",
    color: "secondary",
    variant: "outlined",
    sx: {
      flexGrow: 1,
      visibility: isEnrolled ? 'visible' : 'hidden'
    }
  }, i18n.buttons.optOut)), /*#__PURE__*/_react.default.createElement(_optInContent.TextNode, null, i18n.feedback, " ", /*#__PURE__*/_react.default.createElement(_ui.Link, {
    underline: "hover",
    href: optInLinks.feedbackUrl,
    target: "_blank"
  }, i18n.overToGithub))), /*#__PURE__*/_react.default.createElement(_ui.Stack, {
    sx: {
      flex: 1,
      px: 0,
      maxWidth: {
        md: '507px',
        sm: '600px'
      },
      mx: 'auto'
    }
  }, optInImages.square.src ? /*#__PURE__*/_react.default.createElement(_ui.Image, {
    src: optInImages.square.src,
    alt: i18n.image,
    sx: _objectSpread(_objectSpread({}, optInImages.square.sx), {}, {
      display: {
        xs: 'none',
        md: 'block'
      }
    })
  }) : /*#__PURE__*/_react.default.createElement(_optInImgPlaceholders.ImageSquarePlaceholder, {
    sx: _objectSpread(_objectSpread({}, optInImages.square.sx), {}, {
      display: {
        xs: 'none',
        md: 'block'
      }
    })
  }), optInImages.landscape.src ? /*#__PURE__*/_react.default.createElement(_ui.Image, {
    src: optInImages.landscape.src,
    alt: i18n.image,
    sx: _objectSpread(_objectSpread({}, optInImages.landscape.sx), {}, {
      display: {
        xs: 'block',
        md: 'none'
      }
    })
  }) : /*#__PURE__*/_react.default.createElement(_optInImgPlaceholders.ImageLandscapePlaceholder, {
    sx: _objectSpread(_objectSpread({}, optInImages.landscape.sx), {}, {
      display: {
        xs: 'block',
        md: 'none'
      }
    })
  })), showTerms && /*#__PURE__*/_react.default.createElement(_optInTerms.Terms, {
    onClose: handlePopoverClose,
    onSubmit: isEnrolled ? maybeOptOut : maybeOptIn,
    isEnrolled: isEnrolled
  }), optInMessage && /*#__PURE__*/_react.default.createElement(_optInMessage.Message, {
    onClose: function onClose() {
      return setOptInMessage('');
    }
  }, optInMessage), optOutMessage && /*#__PURE__*/_react.default.createElement(_optInMessage.Message, {
    onClose: function onClose() {
      return setOptOutMessage('');
    },
    action: /*#__PURE__*/_react.default.createElement(_ui.Link, {
      href: optInLinks.feedbackUrl,
      target: "_blank",
      color: "inherit",
      sx: {
        cursor: 'pointer',
        textDecoration: 'none',
        pl: 3
      }
    }, i18n.tellUsWhy)
  }, optOutMessage), errorMessage && /*#__PURE__*/_react.default.createElement(_optInMessage.Message, {
    severity: "error",
    onClose: function onClose() {
      return setErrorMessage('');
    }
  }, errorMessage));
};
OptIn.propTypes = {
  state: PropTypes.shape({
    features: PropTypes.shape({
      editor_v4: PropTypes.bool
    })
  }).isRequired
};

/***/ }),

/***/ "../node_modules/dompurify/dist/purify.cjs.js":
/*!****************************************************!*\
  !*** ../node_modules/dompurify/dist/purify.cjs.js ***!
  \****************************************************/
/***/ ((module) => {

"use strict";
/*! @license DOMPurify 3.2.6 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/3.2.6/LICENSE */



const {
  entries,
  setPrototypeOf,
  isFrozen,
  getPrototypeOf,
  getOwnPropertyDescriptor
} = Object;
let {
  freeze,
  seal,
  create
} = Object; // eslint-disable-line import/no-mutable-exports
let {
  apply,
  construct
} = typeof Reflect !== 'undefined' && Reflect;
if (!freeze) {
  freeze = function freeze(x) {
    return x;
  };
}
if (!seal) {
  seal = function seal(x) {
    return x;
  };
}
if (!apply) {
  apply = function apply(fun, thisValue, args) {
    return fun.apply(thisValue, args);
  };
}
if (!construct) {
  construct = function construct(Func, args) {
    return new Func(...args);
  };
}
const arrayForEach = unapply(Array.prototype.forEach);
const arrayLastIndexOf = unapply(Array.prototype.lastIndexOf);
const arrayPop = unapply(Array.prototype.pop);
const arrayPush = unapply(Array.prototype.push);
const arraySplice = unapply(Array.prototype.splice);
const stringToLowerCase = unapply(String.prototype.toLowerCase);
const stringToString = unapply(String.prototype.toString);
const stringMatch = unapply(String.prototype.match);
const stringReplace = unapply(String.prototype.replace);
const stringIndexOf = unapply(String.prototype.indexOf);
const stringTrim = unapply(String.prototype.trim);
const objectHasOwnProperty = unapply(Object.prototype.hasOwnProperty);
const regExpTest = unapply(RegExp.prototype.test);
const typeErrorCreate = unconstruct(TypeError);
/**
 * Creates a new function that calls the given function with a specified thisArg and arguments.
 *
 * @param func - The function to be wrapped and called.
 * @returns A new function that calls the given function with a specified thisArg and arguments.
 */
function unapply(func) {
  return function (thisArg) {
    if (thisArg instanceof RegExp) {
      thisArg.lastIndex = 0;
    }
    for (var _len = arguments.length, args = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
      args[_key - 1] = arguments[_key];
    }
    return apply(func, thisArg, args);
  };
}
/**
 * Creates a new function that constructs an instance of the given constructor function with the provided arguments.
 *
 * @param func - The constructor function to be wrapped and called.
 * @returns A new function that constructs an instance of the given constructor function with the provided arguments.
 */
function unconstruct(func) {
  return function () {
    for (var _len2 = arguments.length, args = new Array(_len2), _key2 = 0; _key2 < _len2; _key2++) {
      args[_key2] = arguments[_key2];
    }
    return construct(func, args);
  };
}
/**
 * Add properties to a lookup table
 *
 * @param set - The set to which elements will be added.
 * @param array - The array containing elements to be added to the set.
 * @param transformCaseFunc - An optional function to transform the case of each element before adding to the set.
 * @returns The modified set with added elements.
 */
function addToSet(set, array) {
  let transformCaseFunc = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : stringToLowerCase;
  if (setPrototypeOf) {
    // Make 'in' and truthy checks like Boolean(set.constructor)
    // independent of any properties defined on Object.prototype.
    // Prevent prototype setters from intercepting set as a this value.
    setPrototypeOf(set, null);
  }
  let l = array.length;
  while (l--) {
    let element = array[l];
    if (typeof element === 'string') {
      const lcElement = transformCaseFunc(element);
      if (lcElement !== element) {
        // Config presets (e.g. tags.js, attrs.js) are immutable.
        if (!isFrozen(array)) {
          array[l] = lcElement;
        }
        element = lcElement;
      }
    }
    set[element] = true;
  }
  return set;
}
/**
 * Clean up an array to harden against CSPP
 *
 * @param array - The array to be cleaned.
 * @returns The cleaned version of the array
 */
function cleanArray(array) {
  for (let index = 0; index < array.length; index++) {
    const isPropertyExist = objectHasOwnProperty(array, index);
    if (!isPropertyExist) {
      array[index] = null;
    }
  }
  return array;
}
/**
 * Shallow clone an object
 *
 * @param object - The object to be cloned.
 * @returns A new object that copies the original.
 */
function clone(object) {
  const newObject = create(null);
  for (const [property, value] of entries(object)) {
    const isPropertyExist = objectHasOwnProperty(object, property);
    if (isPropertyExist) {
      if (Array.isArray(value)) {
        newObject[property] = cleanArray(value);
      } else if (value && typeof value === 'object' && value.constructor === Object) {
        newObject[property] = clone(value);
      } else {
        newObject[property] = value;
      }
    }
  }
  return newObject;
}
/**
 * This method automatically checks if the prop is function or getter and behaves accordingly.
 *
 * @param object - The object to look up the getter function in its prototype chain.
 * @param prop - The property name for which to find the getter function.
 * @returns The getter function found in the prototype chain or a fallback function.
 */
function lookupGetter(object, prop) {
  while (object !== null) {
    const desc = getOwnPropertyDescriptor(object, prop);
    if (desc) {
      if (desc.get) {
        return unapply(desc.get);
      }
      if (typeof desc.value === 'function') {
        return unapply(desc.value);
      }
    }
    object = getPrototypeOf(object);
  }
  function fallbackValue() {
    return null;
  }
  return fallbackValue;
}

const html$1 = freeze(['a', 'abbr', 'acronym', 'address', 'area', 'article', 'aside', 'audio', 'b', 'bdi', 'bdo', 'big', 'blink', 'blockquote', 'body', 'br', 'button', 'canvas', 'caption', 'center', 'cite', 'code', 'col', 'colgroup', 'content', 'data', 'datalist', 'dd', 'decorator', 'del', 'details', 'dfn', 'dialog', 'dir', 'div', 'dl', 'dt', 'element', 'em', 'fieldset', 'figcaption', 'figure', 'font', 'footer', 'form', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'head', 'header', 'hgroup', 'hr', 'html', 'i', 'img', 'input', 'ins', 'kbd', 'label', 'legend', 'li', 'main', 'map', 'mark', 'marquee', 'menu', 'menuitem', 'meter', 'nav', 'nobr', 'ol', 'optgroup', 'option', 'output', 'p', 'picture', 'pre', 'progress', 'q', 'rp', 'rt', 'ruby', 's', 'samp', 'section', 'select', 'shadow', 'small', 'source', 'spacer', 'span', 'strike', 'strong', 'style', 'sub', 'summary', 'sup', 'table', 'tbody', 'td', 'template', 'textarea', 'tfoot', 'th', 'thead', 'time', 'tr', 'track', 'tt', 'u', 'ul', 'var', 'video', 'wbr']);
const svg$1 = freeze(['svg', 'a', 'altglyph', 'altglyphdef', 'altglyphitem', 'animatecolor', 'animatemotion', 'animatetransform', 'circle', 'clippath', 'defs', 'desc', 'ellipse', 'filter', 'font', 'g', 'glyph', 'glyphref', 'hkern', 'image', 'line', 'lineargradient', 'marker', 'mask', 'metadata', 'mpath', 'path', 'pattern', 'polygon', 'polyline', 'radialgradient', 'rect', 'stop', 'style', 'switch', 'symbol', 'text', 'textpath', 'title', 'tref', 'tspan', 'view', 'vkern']);
const svgFilters = freeze(['feBlend', 'feColorMatrix', 'feComponentTransfer', 'feComposite', 'feConvolveMatrix', 'feDiffuseLighting', 'feDisplacementMap', 'feDistantLight', 'feDropShadow', 'feFlood', 'feFuncA', 'feFuncB', 'feFuncG', 'feFuncR', 'feGaussianBlur', 'feImage', 'feMerge', 'feMergeNode', 'feMorphology', 'feOffset', 'fePointLight', 'feSpecularLighting', 'feSpotLight', 'feTile', 'feTurbulence']);
// List of SVG elements that are disallowed by default.
// We still need to know them so that we can do namespace
// checks properly in case one wants to add them to
// allow-list.
const svgDisallowed = freeze(['animate', 'color-profile', 'cursor', 'discard', 'font-face', 'font-face-format', 'font-face-name', 'font-face-src', 'font-face-uri', 'foreignobject', 'hatch', 'hatchpath', 'mesh', 'meshgradient', 'meshpatch', 'meshrow', 'missing-glyph', 'script', 'set', 'solidcolor', 'unknown', 'use']);
const mathMl$1 = freeze(['math', 'menclose', 'merror', 'mfenced', 'mfrac', 'mglyph', 'mi', 'mlabeledtr', 'mmultiscripts', 'mn', 'mo', 'mover', 'mpadded', 'mphantom', 'mroot', 'mrow', 'ms', 'mspace', 'msqrt', 'mstyle', 'msub', 'msup', 'msubsup', 'mtable', 'mtd', 'mtext', 'mtr', 'munder', 'munderover', 'mprescripts']);
// Similarly to SVG, we want to know all MathML elements,
// even those that we disallow by default.
const mathMlDisallowed = freeze(['maction', 'maligngroup', 'malignmark', 'mlongdiv', 'mscarries', 'mscarry', 'msgroup', 'mstack', 'msline', 'msrow', 'semantics', 'annotation', 'annotation-xml', 'mprescripts', 'none']);
const text = freeze(['#text']);

const html = freeze(['accept', 'action', 'align', 'alt', 'autocapitalize', 'autocomplete', 'autopictureinpicture', 'autoplay', 'background', 'bgcolor', 'border', 'capture', 'cellpadding', 'cellspacing', 'checked', 'cite', 'class', 'clear', 'color', 'cols', 'colspan', 'controls', 'controlslist', 'coords', 'crossorigin', 'datetime', 'decoding', 'default', 'dir', 'disabled', 'disablepictureinpicture', 'disableremoteplayback', 'download', 'draggable', 'enctype', 'enterkeyhint', 'face', 'for', 'headers', 'height', 'hidden', 'high', 'href', 'hreflang', 'id', 'inputmode', 'integrity', 'ismap', 'kind', 'label', 'lang', 'list', 'loading', 'loop', 'low', 'max', 'maxlength', 'media', 'method', 'min', 'minlength', 'multiple', 'muted', 'name', 'nonce', 'noshade', 'novalidate', 'nowrap', 'open', 'optimum', 'pattern', 'placeholder', 'playsinline', 'popover', 'popovertarget', 'popovertargetaction', 'poster', 'preload', 'pubdate', 'radiogroup', 'readonly', 'rel', 'required', 'rev', 'reversed', 'role', 'rows', 'rowspan', 'spellcheck', 'scope', 'selected', 'shape', 'size', 'sizes', 'span', 'srclang', 'start', 'src', 'srcset', 'step', 'style', 'summary', 'tabindex', 'title', 'translate', 'type', 'usemap', 'valign', 'value', 'width', 'wrap', 'xmlns', 'slot']);
const svg = freeze(['accent-height', 'accumulate', 'additive', 'alignment-baseline', 'amplitude', 'ascent', 'attributename', 'attributetype', 'azimuth', 'basefrequency', 'baseline-shift', 'begin', 'bias', 'by', 'class', 'clip', 'clippathunits', 'clip-path', 'clip-rule', 'color', 'color-interpolation', 'color-interpolation-filters', 'color-profile', 'color-rendering', 'cx', 'cy', 'd', 'dx', 'dy', 'diffuseconstant', 'direction', 'display', 'divisor', 'dur', 'edgemode', 'elevation', 'end', 'exponent', 'fill', 'fill-opacity', 'fill-rule', 'filter', 'filterunits', 'flood-color', 'flood-opacity', 'font-family', 'font-size', 'font-size-adjust', 'font-stretch', 'font-style', 'font-variant', 'font-weight', 'fx', 'fy', 'g1', 'g2', 'glyph-name', 'glyphref', 'gradientunits', 'gradienttransform', 'height', 'href', 'id', 'image-rendering', 'in', 'in2', 'intercept', 'k', 'k1', 'k2', 'k3', 'k4', 'kerning', 'keypoints', 'keysplines', 'keytimes', 'lang', 'lengthadjust', 'letter-spacing', 'kernelmatrix', 'kernelunitlength', 'lighting-color', 'local', 'marker-end', 'marker-mid', 'marker-start', 'markerheight', 'markerunits', 'markerwidth', 'maskcontentunits', 'maskunits', 'max', 'mask', 'media', 'method', 'mode', 'min', 'name', 'numoctaves', 'offset', 'operator', 'opacity', 'order', 'orient', 'orientation', 'origin', 'overflow', 'paint-order', 'path', 'pathlength', 'patterncontentunits', 'patterntransform', 'patternunits', 'points', 'preservealpha', 'preserveaspectratio', 'primitiveunits', 'r', 'rx', 'ry', 'radius', 'refx', 'refy', 'repeatcount', 'repeatdur', 'restart', 'result', 'rotate', 'scale', 'seed', 'shape-rendering', 'slope', 'specularconstant', 'specularexponent', 'spreadmethod', 'startoffset', 'stddeviation', 'stitchtiles', 'stop-color', 'stop-opacity', 'stroke-dasharray', 'stroke-dashoffset', 'stroke-linecap', 'stroke-linejoin', 'stroke-miterlimit', 'stroke-opacity', 'stroke', 'stroke-width', 'style', 'surfacescale', 'systemlanguage', 'tabindex', 'tablevalues', 'targetx', 'targety', 'transform', 'transform-origin', 'text-anchor', 'text-decoration', 'text-rendering', 'textlength', 'type', 'u1', 'u2', 'unicode', 'values', 'viewbox', 'visibility', 'version', 'vert-adv-y', 'vert-origin-x', 'vert-origin-y', 'width', 'word-spacing', 'wrap', 'writing-mode', 'xchannelselector', 'ychannelselector', 'x', 'x1', 'x2', 'xmlns', 'y', 'y1', 'y2', 'z', 'zoomandpan']);
const mathMl = freeze(['accent', 'accentunder', 'align', 'bevelled', 'close', 'columnsalign', 'columnlines', 'columnspan', 'denomalign', 'depth', 'dir', 'display', 'displaystyle', 'encoding', 'fence', 'frame', 'height', 'href', 'id', 'largeop', 'length', 'linethickness', 'lspace', 'lquote', 'mathbackground', 'mathcolor', 'mathsize', 'mathvariant', 'maxsize', 'minsize', 'movablelimits', 'notation', 'numalign', 'open', 'rowalign', 'rowlines', 'rowspacing', 'rowspan', 'rspace', 'rquote', 'scriptlevel', 'scriptminsize', 'scriptsizemultiplier', 'selection', 'separator', 'separators', 'stretchy', 'subscriptshift', 'supscriptshift', 'symmetric', 'voffset', 'width', 'xmlns']);
const xml = freeze(['xlink:href', 'xml:id', 'xlink:title', 'xml:space', 'xmlns:xlink']);

// eslint-disable-next-line unicorn/better-regex
const MUSTACHE_EXPR = seal(/\{\{[\w\W]*|[\w\W]*\}\}/gm); // Specify template detection regex for SAFE_FOR_TEMPLATES mode
const ERB_EXPR = seal(/<%[\w\W]*|[\w\W]*%>/gm);
const TMPLIT_EXPR = seal(/\$\{[\w\W]*/gm); // eslint-disable-line unicorn/better-regex
const DATA_ATTR = seal(/^data-[\-\w.\u00B7-\uFFFF]+$/); // eslint-disable-line no-useless-escape
const ARIA_ATTR = seal(/^aria-[\-\w]+$/); // eslint-disable-line no-useless-escape
const IS_ALLOWED_URI = seal(/^(?:(?:(?:f|ht)tps?|mailto|tel|callto|sms|cid|xmpp|matrix):|[^a-z]|[a-z+.\-]+(?:[^a-z+.\-:]|$))/i // eslint-disable-line no-useless-escape
);
const IS_SCRIPT_OR_DATA = seal(/^(?:\w+script|data):/i);
const ATTR_WHITESPACE = seal(/[\u0000-\u0020\u00A0\u1680\u180E\u2000-\u2029\u205F\u3000]/g // eslint-disable-line no-control-regex
);
const DOCTYPE_NAME = seal(/^html$/i);
const CUSTOM_ELEMENT = seal(/^[a-z][.\w]*(-[.\w]+)+$/i);

var EXPRESSIONS = /*#__PURE__*/Object.freeze({
  __proto__: null,
  ARIA_ATTR: ARIA_ATTR,
  ATTR_WHITESPACE: ATTR_WHITESPACE,
  CUSTOM_ELEMENT: CUSTOM_ELEMENT,
  DATA_ATTR: DATA_ATTR,
  DOCTYPE_NAME: DOCTYPE_NAME,
  ERB_EXPR: ERB_EXPR,
  IS_ALLOWED_URI: IS_ALLOWED_URI,
  IS_SCRIPT_OR_DATA: IS_SCRIPT_OR_DATA,
  MUSTACHE_EXPR: MUSTACHE_EXPR,
  TMPLIT_EXPR: TMPLIT_EXPR
});

/* eslint-disable @typescript-eslint/indent */
// https://developer.mozilla.org/en-US/docs/Web/API/Node/nodeType
const NODE_TYPE = {
  element: 1,
  attribute: 2,
  text: 3,
  cdataSection: 4,
  entityReference: 5,
  // Deprecated
  entityNode: 6,
  // Deprecated
  progressingInstruction: 7,
  comment: 8,
  document: 9,
  documentType: 10,
  documentFragment: 11,
  notation: 12 // Deprecated
};
const getGlobal = function getGlobal() {
  return typeof window === 'undefined' ? null : window;
};
/**
 * Creates a no-op policy for internal use only.
 * Don't export this function outside this module!
 * @param trustedTypes The policy factory.
 * @param purifyHostElement The Script element used to load DOMPurify (to determine policy name suffix).
 * @return The policy created (or null, if Trusted Types
 * are not supported or creating the policy failed).
 */
const _createTrustedTypesPolicy = function _createTrustedTypesPolicy(trustedTypes, purifyHostElement) {
  if (typeof trustedTypes !== 'object' || typeof trustedTypes.createPolicy !== 'function') {
    return null;
  }
  // Allow the callers to control the unique policy name
  // by adding a data-tt-policy-suffix to the script element with the DOMPurify.
  // Policy creation with duplicate names throws in Trusted Types.
  let suffix = null;
  const ATTR_NAME = 'data-tt-policy-suffix';
  if (purifyHostElement && purifyHostElement.hasAttribute(ATTR_NAME)) {
    suffix = purifyHostElement.getAttribute(ATTR_NAME);
  }
  const policyName = 'dompurify' + (suffix ? '#' + suffix : '');
  try {
    return trustedTypes.createPolicy(policyName, {
      createHTML(html) {
        return html;
      },
      createScriptURL(scriptUrl) {
        return scriptUrl;
      }
    });
  } catch (_) {
    // Policy creation failed (most likely another DOMPurify script has
    // already run). Skip creating the policy, as this will only cause errors
    // if TT are enforced.
    console.warn('TrustedTypes policy ' + policyName + ' could not be created.');
    return null;
  }
};
const _createHooksMap = function _createHooksMap() {
  return {
    afterSanitizeAttributes: [],
    afterSanitizeElements: [],
    afterSanitizeShadowDOM: [],
    beforeSanitizeAttributes: [],
    beforeSanitizeElements: [],
    beforeSanitizeShadowDOM: [],
    uponSanitizeAttribute: [],
    uponSanitizeElement: [],
    uponSanitizeShadowNode: []
  };
};
function createDOMPurify() {
  let window = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : getGlobal();
  const DOMPurify = root => createDOMPurify(root);
  DOMPurify.version = '3.2.6';
  DOMPurify.removed = [];
  if (!window || !window.document || window.document.nodeType !== NODE_TYPE.document || !window.Element) {
    // Not running in a browser, provide a factory function
    // so that you can pass your own Window
    DOMPurify.isSupported = false;
    return DOMPurify;
  }
  let {
    document
  } = window;
  const originalDocument = document;
  const currentScript = originalDocument.currentScript;
  const {
    DocumentFragment,
    HTMLTemplateElement,
    Node,
    Element,
    NodeFilter,
    NamedNodeMap = window.NamedNodeMap || window.MozNamedAttrMap,
    HTMLFormElement,
    DOMParser,
    trustedTypes
  } = window;
  const ElementPrototype = Element.prototype;
  const cloneNode = lookupGetter(ElementPrototype, 'cloneNode');
  const remove = lookupGetter(ElementPrototype, 'remove');
  const getNextSibling = lookupGetter(ElementPrototype, 'nextSibling');
  const getChildNodes = lookupGetter(ElementPrototype, 'childNodes');
  const getParentNode = lookupGetter(ElementPrototype, 'parentNode');
  // As per issue #47, the web-components registry is inherited by a
  // new document created via createHTMLDocument. As per the spec
  // (http://w3c.github.io/webcomponents/spec/custom/#creating-and-passing-registries)
  // a new empty registry is used when creating a template contents owner
  // document, so we use that as our parent document to ensure nothing
  // is inherited.
  if (typeof HTMLTemplateElement === 'function') {
    const template = document.createElement('template');
    if (template.content && template.content.ownerDocument) {
      document = template.content.ownerDocument;
    }
  }
  let trustedTypesPolicy;
  let emptyHTML = '';
  const {
    implementation,
    createNodeIterator,
    createDocumentFragment,
    getElementsByTagName
  } = document;
  const {
    importNode
  } = originalDocument;
  let hooks = _createHooksMap();
  /**
   * Expose whether this browser supports running the full DOMPurify.
   */
  DOMPurify.isSupported = typeof entries === 'function' && typeof getParentNode === 'function' && implementation && implementation.createHTMLDocument !== undefined;
  const {
    MUSTACHE_EXPR,
    ERB_EXPR,
    TMPLIT_EXPR,
    DATA_ATTR,
    ARIA_ATTR,
    IS_SCRIPT_OR_DATA,
    ATTR_WHITESPACE,
    CUSTOM_ELEMENT
  } = EXPRESSIONS;
  let {
    IS_ALLOWED_URI: IS_ALLOWED_URI$1
  } = EXPRESSIONS;
  /**
   * We consider the elements and attributes below to be safe. Ideally
   * don't add any new ones but feel free to remove unwanted ones.
   */
  /* allowed element names */
  let ALLOWED_TAGS = null;
  const DEFAULT_ALLOWED_TAGS = addToSet({}, [...html$1, ...svg$1, ...svgFilters, ...mathMl$1, ...text]);
  /* Allowed attribute names */
  let ALLOWED_ATTR = null;
  const DEFAULT_ALLOWED_ATTR = addToSet({}, [...html, ...svg, ...mathMl, ...xml]);
  /*
   * Configure how DOMPurify should handle custom elements and their attributes as well as customized built-in elements.
   * @property {RegExp|Function|null} tagNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any custom elements)
   * @property {RegExp|Function|null} attributeNameCheck one of [null, regexPattern, predicate]. Default: `null` (disallow any attributes not on the allow list)
   * @property {boolean} allowCustomizedBuiltInElements allow custom elements derived from built-ins if they pass CUSTOM_ELEMENT_HANDLING.tagNameCheck. Default: `false`.
   */
  let CUSTOM_ELEMENT_HANDLING = Object.seal(create(null, {
    tagNameCheck: {
      writable: true,
      configurable: false,
      enumerable: true,
      value: null
    },
    attributeNameCheck: {
      writable: true,
      configurable: false,
      enumerable: true,
      value: null
    },
    allowCustomizedBuiltInElements: {
      writable: true,
      configurable: false,
      enumerable: true,
      value: false
    }
  }));
  /* Explicitly forbidden tags (overrides ALLOWED_TAGS/ADD_TAGS) */
  let FORBID_TAGS = null;
  /* Explicitly forbidden attributes (overrides ALLOWED_ATTR/ADD_ATTR) */
  let FORBID_ATTR = null;
  /* Decide if ARIA attributes are okay */
  let ALLOW_ARIA_ATTR = true;
  /* Decide if custom data attributes are okay */
  let ALLOW_DATA_ATTR = true;
  /* Decide if unknown protocols are okay */
  let ALLOW_UNKNOWN_PROTOCOLS = false;
  /* Decide if self-closing tags in attributes are allowed.
   * Usually removed due to a mXSS issue in jQuery 3.0 */
  let ALLOW_SELF_CLOSE_IN_ATTR = true;
  /* Output should be safe for common template engines.
   * This means, DOMPurify removes data attributes, mustaches and ERB
   */
  let SAFE_FOR_TEMPLATES = false;
  /* Output should be safe even for XML used within HTML and alike.
   * This means, DOMPurify removes comments when containing risky content.
   */
  let SAFE_FOR_XML = true;
  /* Decide if document with <html>... should be returned */
  let WHOLE_DOCUMENT = false;
  /* Track whether config is already set on this instance of DOMPurify. */
  let SET_CONFIG = false;
  /* Decide if all elements (e.g. style, script) must be children of
   * document.body. By default, browsers might move them to document.head */
  let FORCE_BODY = false;
  /* Decide if a DOM `HTMLBodyElement` should be returned, instead of a html
   * string (or a TrustedHTML object if Trusted Types are supported).
   * If `WHOLE_DOCUMENT` is enabled a `HTMLHtmlElement` will be returned instead
   */
  let RETURN_DOM = false;
  /* Decide if a DOM `DocumentFragment` should be returned, instead of a html
   * string  (or a TrustedHTML object if Trusted Types are supported) */
  let RETURN_DOM_FRAGMENT = false;
  /* Try to return a Trusted Type object instead of a string, return a string in
   * case Trusted Types are not supported  */
  let RETURN_TRUSTED_TYPE = false;
  /* Output should be free from DOM clobbering attacks?
   * This sanitizes markups named with colliding, clobberable built-in DOM APIs.
   */
  let SANITIZE_DOM = true;
  /* Achieve full DOM Clobbering protection by isolating the namespace of named
   * properties and JS variables, mitigating attacks that abuse the HTML/DOM spec rules.
   *
   * HTML/DOM spec rules that enable DOM Clobbering:
   *   - Named Access on Window (§7.3.3)
   *   - DOM Tree Accessors (§3.1.5)
   *   - Form Element Parent-Child Relations (§4.10.3)
   *   - Iframe srcdoc / Nested WindowProxies (§4.8.5)
   *   - HTMLCollection (§4.2.10.2)
   *
   * Namespace isolation is implemented by prefixing `id` and `name` attributes
   * with a constant string, i.e., `user-content-`
   */
  let SANITIZE_NAMED_PROPS = false;
  const SANITIZE_NAMED_PROPS_PREFIX = 'user-content-';
  /* Keep element content when removing element? */
  let KEEP_CONTENT = true;
  /* If a `Node` is passed to sanitize(), then performs sanitization in-place instead
   * of importing it into a new Document and returning a sanitized copy */
  let IN_PLACE = false;
  /* Allow usage of profiles like html, svg and mathMl */
  let USE_PROFILES = {};
  /* Tags to ignore content of when KEEP_CONTENT is true */
  let FORBID_CONTENTS = null;
  const DEFAULT_FORBID_CONTENTS = addToSet({}, ['annotation-xml', 'audio', 'colgroup', 'desc', 'foreignobject', 'head', 'iframe', 'math', 'mi', 'mn', 'mo', 'ms', 'mtext', 'noembed', 'noframes', 'noscript', 'plaintext', 'script', 'style', 'svg', 'template', 'thead', 'title', 'video', 'xmp']);
  /* Tags that are safe for data: URIs */
  let DATA_URI_TAGS = null;
  const DEFAULT_DATA_URI_TAGS = addToSet({}, ['audio', 'video', 'img', 'source', 'image', 'track']);
  /* Attributes safe for values like "javascript:" */
  let URI_SAFE_ATTRIBUTES = null;
  const DEFAULT_URI_SAFE_ATTRIBUTES = addToSet({}, ['alt', 'class', 'for', 'id', 'label', 'name', 'pattern', 'placeholder', 'role', 'summary', 'title', 'value', 'style', 'xmlns']);
  const MATHML_NAMESPACE = 'http://www.w3.org/1998/Math/MathML';
  const SVG_NAMESPACE = 'http://www.w3.org/2000/svg';
  const HTML_NAMESPACE = 'http://www.w3.org/1999/xhtml';
  /* Document namespace */
  let NAMESPACE = HTML_NAMESPACE;
  let IS_EMPTY_INPUT = false;
  /* Allowed XHTML+XML namespaces */
  let ALLOWED_NAMESPACES = null;
  const DEFAULT_ALLOWED_NAMESPACES = addToSet({}, [MATHML_NAMESPACE, SVG_NAMESPACE, HTML_NAMESPACE], stringToString);
  let MATHML_TEXT_INTEGRATION_POINTS = addToSet({}, ['mi', 'mo', 'mn', 'ms', 'mtext']);
  let HTML_INTEGRATION_POINTS = addToSet({}, ['annotation-xml']);
  // Certain elements are allowed in both SVG and HTML
  // namespace. We need to specify them explicitly
  // so that they don't get erroneously deleted from
  // HTML namespace.
  const COMMON_SVG_AND_HTML_ELEMENTS = addToSet({}, ['title', 'style', 'font', 'a', 'script']);
  /* Parsing of strict XHTML documents */
  let PARSER_MEDIA_TYPE = null;
  const SUPPORTED_PARSER_MEDIA_TYPES = ['application/xhtml+xml', 'text/html'];
  const DEFAULT_PARSER_MEDIA_TYPE = 'text/html';
  let transformCaseFunc = null;
  /* Keep a reference to config to pass to hooks */
  let CONFIG = null;
  /* Ideally, do not touch anything below this line */
  /* ______________________________________________ */
  const formElement = document.createElement('form');
  const isRegexOrFunction = function isRegexOrFunction(testValue) {
    return testValue instanceof RegExp || testValue instanceof Function;
  };
  /**
   * _parseConfig
   *
   * @param cfg optional config literal
   */
  // eslint-disable-next-line complexity
  const _parseConfig = function _parseConfig() {
    let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    if (CONFIG && CONFIG === cfg) {
      return;
    }
    /* Shield configuration object from tampering */
    if (!cfg || typeof cfg !== 'object') {
      cfg = {};
    }
    /* Shield configuration object from prototype pollution */
    cfg = clone(cfg);
    PARSER_MEDIA_TYPE =
    // eslint-disable-next-line unicorn/prefer-includes
    SUPPORTED_PARSER_MEDIA_TYPES.indexOf(cfg.PARSER_MEDIA_TYPE) === -1 ? DEFAULT_PARSER_MEDIA_TYPE : cfg.PARSER_MEDIA_TYPE;
    // HTML tags and attributes are not case-sensitive, converting to lowercase. Keeping XHTML as is.
    transformCaseFunc = PARSER_MEDIA_TYPE === 'application/xhtml+xml' ? stringToString : stringToLowerCase;
    /* Set configuration parameters */
    ALLOWED_TAGS = objectHasOwnProperty(cfg, 'ALLOWED_TAGS') ? addToSet({}, cfg.ALLOWED_TAGS, transformCaseFunc) : DEFAULT_ALLOWED_TAGS;
    ALLOWED_ATTR = objectHasOwnProperty(cfg, 'ALLOWED_ATTR') ? addToSet({}, cfg.ALLOWED_ATTR, transformCaseFunc) : DEFAULT_ALLOWED_ATTR;
    ALLOWED_NAMESPACES = objectHasOwnProperty(cfg, 'ALLOWED_NAMESPACES') ? addToSet({}, cfg.ALLOWED_NAMESPACES, stringToString) : DEFAULT_ALLOWED_NAMESPACES;
    URI_SAFE_ATTRIBUTES = objectHasOwnProperty(cfg, 'ADD_URI_SAFE_ATTR') ? addToSet(clone(DEFAULT_URI_SAFE_ATTRIBUTES), cfg.ADD_URI_SAFE_ATTR, transformCaseFunc) : DEFAULT_URI_SAFE_ATTRIBUTES;
    DATA_URI_TAGS = objectHasOwnProperty(cfg, 'ADD_DATA_URI_TAGS') ? addToSet(clone(DEFAULT_DATA_URI_TAGS), cfg.ADD_DATA_URI_TAGS, transformCaseFunc) : DEFAULT_DATA_URI_TAGS;
    FORBID_CONTENTS = objectHasOwnProperty(cfg, 'FORBID_CONTENTS') ? addToSet({}, cfg.FORBID_CONTENTS, transformCaseFunc) : DEFAULT_FORBID_CONTENTS;
    FORBID_TAGS = objectHasOwnProperty(cfg, 'FORBID_TAGS') ? addToSet({}, cfg.FORBID_TAGS, transformCaseFunc) : clone({});
    FORBID_ATTR = objectHasOwnProperty(cfg, 'FORBID_ATTR') ? addToSet({}, cfg.FORBID_ATTR, transformCaseFunc) : clone({});
    USE_PROFILES = objectHasOwnProperty(cfg, 'USE_PROFILES') ? cfg.USE_PROFILES : false;
    ALLOW_ARIA_ATTR = cfg.ALLOW_ARIA_ATTR !== false; // Default true
    ALLOW_DATA_ATTR = cfg.ALLOW_DATA_ATTR !== false; // Default true
    ALLOW_UNKNOWN_PROTOCOLS = cfg.ALLOW_UNKNOWN_PROTOCOLS || false; // Default false
    ALLOW_SELF_CLOSE_IN_ATTR = cfg.ALLOW_SELF_CLOSE_IN_ATTR !== false; // Default true
    SAFE_FOR_TEMPLATES = cfg.SAFE_FOR_TEMPLATES || false; // Default false
    SAFE_FOR_XML = cfg.SAFE_FOR_XML !== false; // Default true
    WHOLE_DOCUMENT = cfg.WHOLE_DOCUMENT || false; // Default false
    RETURN_DOM = cfg.RETURN_DOM || false; // Default false
    RETURN_DOM_FRAGMENT = cfg.RETURN_DOM_FRAGMENT || false; // Default false
    RETURN_TRUSTED_TYPE = cfg.RETURN_TRUSTED_TYPE || false; // Default false
    FORCE_BODY = cfg.FORCE_BODY || false; // Default false
    SANITIZE_DOM = cfg.SANITIZE_DOM !== false; // Default true
    SANITIZE_NAMED_PROPS = cfg.SANITIZE_NAMED_PROPS || false; // Default false
    KEEP_CONTENT = cfg.KEEP_CONTENT !== false; // Default true
    IN_PLACE = cfg.IN_PLACE || false; // Default false
    IS_ALLOWED_URI$1 = cfg.ALLOWED_URI_REGEXP || IS_ALLOWED_URI;
    NAMESPACE = cfg.NAMESPACE || HTML_NAMESPACE;
    MATHML_TEXT_INTEGRATION_POINTS = cfg.MATHML_TEXT_INTEGRATION_POINTS || MATHML_TEXT_INTEGRATION_POINTS;
    HTML_INTEGRATION_POINTS = cfg.HTML_INTEGRATION_POINTS || HTML_INTEGRATION_POINTS;
    CUSTOM_ELEMENT_HANDLING = cfg.CUSTOM_ELEMENT_HANDLING || {};
    if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck)) {
      CUSTOM_ELEMENT_HANDLING.tagNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.tagNameCheck;
    }
    if (cfg.CUSTOM_ELEMENT_HANDLING && isRegexOrFunction(cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck)) {
      CUSTOM_ELEMENT_HANDLING.attributeNameCheck = cfg.CUSTOM_ELEMENT_HANDLING.attributeNameCheck;
    }
    if (cfg.CUSTOM_ELEMENT_HANDLING && typeof cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements === 'boolean') {
      CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements = cfg.CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements;
    }
    if (SAFE_FOR_TEMPLATES) {
      ALLOW_DATA_ATTR = false;
    }
    if (RETURN_DOM_FRAGMENT) {
      RETURN_DOM = true;
    }
    /* Parse profile info */
    if (USE_PROFILES) {
      ALLOWED_TAGS = addToSet({}, text);
      ALLOWED_ATTR = [];
      if (USE_PROFILES.html === true) {
        addToSet(ALLOWED_TAGS, html$1);
        addToSet(ALLOWED_ATTR, html);
      }
      if (USE_PROFILES.svg === true) {
        addToSet(ALLOWED_TAGS, svg$1);
        addToSet(ALLOWED_ATTR, svg);
        addToSet(ALLOWED_ATTR, xml);
      }
      if (USE_PROFILES.svgFilters === true) {
        addToSet(ALLOWED_TAGS, svgFilters);
        addToSet(ALLOWED_ATTR, svg);
        addToSet(ALLOWED_ATTR, xml);
      }
      if (USE_PROFILES.mathMl === true) {
        addToSet(ALLOWED_TAGS, mathMl$1);
        addToSet(ALLOWED_ATTR, mathMl);
        addToSet(ALLOWED_ATTR, xml);
      }
    }
    /* Merge configuration parameters */
    if (cfg.ADD_TAGS) {
      if (ALLOWED_TAGS === DEFAULT_ALLOWED_TAGS) {
        ALLOWED_TAGS = clone(ALLOWED_TAGS);
      }
      addToSet(ALLOWED_TAGS, cfg.ADD_TAGS, transformCaseFunc);
    }
    if (cfg.ADD_ATTR) {
      if (ALLOWED_ATTR === DEFAULT_ALLOWED_ATTR) {
        ALLOWED_ATTR = clone(ALLOWED_ATTR);
      }
      addToSet(ALLOWED_ATTR, cfg.ADD_ATTR, transformCaseFunc);
    }
    if (cfg.ADD_URI_SAFE_ATTR) {
      addToSet(URI_SAFE_ATTRIBUTES, cfg.ADD_URI_SAFE_ATTR, transformCaseFunc);
    }
    if (cfg.FORBID_CONTENTS) {
      if (FORBID_CONTENTS === DEFAULT_FORBID_CONTENTS) {
        FORBID_CONTENTS = clone(FORBID_CONTENTS);
      }
      addToSet(FORBID_CONTENTS, cfg.FORBID_CONTENTS, transformCaseFunc);
    }
    /* Add #text in case KEEP_CONTENT is set to true */
    if (KEEP_CONTENT) {
      ALLOWED_TAGS['#text'] = true;
    }
    /* Add html, head and body to ALLOWED_TAGS in case WHOLE_DOCUMENT is true */
    if (WHOLE_DOCUMENT) {
      addToSet(ALLOWED_TAGS, ['html', 'head', 'body']);
    }
    /* Add tbody to ALLOWED_TAGS in case tables are permitted, see #286, #365 */
    if (ALLOWED_TAGS.table) {
      addToSet(ALLOWED_TAGS, ['tbody']);
      delete FORBID_TAGS.tbody;
    }
    if (cfg.TRUSTED_TYPES_POLICY) {
      if (typeof cfg.TRUSTED_TYPES_POLICY.createHTML !== 'function') {
        throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createHTML" hook.');
      }
      if (typeof cfg.TRUSTED_TYPES_POLICY.createScriptURL !== 'function') {
        throw typeErrorCreate('TRUSTED_TYPES_POLICY configuration option must provide a "createScriptURL" hook.');
      }
      // Overwrite existing TrustedTypes policy.
      trustedTypesPolicy = cfg.TRUSTED_TYPES_POLICY;
      // Sign local variables required by `sanitize`.
      emptyHTML = trustedTypesPolicy.createHTML('');
    } else {
      // Uninitialized policy, attempt to initialize the internal dompurify policy.
      if (trustedTypesPolicy === undefined) {
        trustedTypesPolicy = _createTrustedTypesPolicy(trustedTypes, currentScript);
      }
      // If creating the internal policy succeeded sign internal variables.
      if (trustedTypesPolicy !== null && typeof emptyHTML === 'string') {
        emptyHTML = trustedTypesPolicy.createHTML('');
      }
    }
    // Prevent further manipulation of configuration.
    // Not available in IE8, Safari 5, etc.
    if (freeze) {
      freeze(cfg);
    }
    CONFIG = cfg;
  };
  /* Keep track of all possible SVG and MathML tags
   * so that we can perform the namespace checks
   * correctly. */
  const ALL_SVG_TAGS = addToSet({}, [...svg$1, ...svgFilters, ...svgDisallowed]);
  const ALL_MATHML_TAGS = addToSet({}, [...mathMl$1, ...mathMlDisallowed]);
  /**
   * @param element a DOM element whose namespace is being checked
   * @returns Return false if the element has a
   *  namespace that a spec-compliant parser would never
   *  return. Return true otherwise.
   */
  const _checkValidNamespace = function _checkValidNamespace(element) {
    let parent = getParentNode(element);
    // In JSDOM, if we're inside shadow DOM, then parentNode
    // can be null. We just simulate parent in this case.
    if (!parent || !parent.tagName) {
      parent = {
        namespaceURI: NAMESPACE,
        tagName: 'template'
      };
    }
    const tagName = stringToLowerCase(element.tagName);
    const parentTagName = stringToLowerCase(parent.tagName);
    if (!ALLOWED_NAMESPACES[element.namespaceURI]) {
      return false;
    }
    if (element.namespaceURI === SVG_NAMESPACE) {
      // The only way to switch from HTML namespace to SVG
      // is via <svg>. If it happens via any other tag, then
      // it should be killed.
      if (parent.namespaceURI === HTML_NAMESPACE) {
        return tagName === 'svg';
      }
      // The only way to switch from MathML to SVG is via`
      // svg if parent is either <annotation-xml> or MathML
      // text integration points.
      if (parent.namespaceURI === MATHML_NAMESPACE) {
        return tagName === 'svg' && (parentTagName === 'annotation-xml' || MATHML_TEXT_INTEGRATION_POINTS[parentTagName]);
      }
      // We only allow elements that are defined in SVG
      // spec. All others are disallowed in SVG namespace.
      return Boolean(ALL_SVG_TAGS[tagName]);
    }
    if (element.namespaceURI === MATHML_NAMESPACE) {
      // The only way to switch from HTML namespace to MathML
      // is via <math>. If it happens via any other tag, then
      // it should be killed.
      if (parent.namespaceURI === HTML_NAMESPACE) {
        return tagName === 'math';
      }
      // The only way to switch from SVG to MathML is via
      // <math> and HTML integration points
      if (parent.namespaceURI === SVG_NAMESPACE) {
        return tagName === 'math' && HTML_INTEGRATION_POINTS[parentTagName];
      }
      // We only allow elements that are defined in MathML
      // spec. All others are disallowed in MathML namespace.
      return Boolean(ALL_MATHML_TAGS[tagName]);
    }
    if (element.namespaceURI === HTML_NAMESPACE) {
      // The only way to switch from SVG to HTML is via
      // HTML integration points, and from MathML to HTML
      // is via MathML text integration points
      if (parent.namespaceURI === SVG_NAMESPACE && !HTML_INTEGRATION_POINTS[parentTagName]) {
        return false;
      }
      if (parent.namespaceURI === MATHML_NAMESPACE && !MATHML_TEXT_INTEGRATION_POINTS[parentTagName]) {
        return false;
      }
      // We disallow tags that are specific for MathML
      // or SVG and should never appear in HTML namespace
      return !ALL_MATHML_TAGS[tagName] && (COMMON_SVG_AND_HTML_ELEMENTS[tagName] || !ALL_SVG_TAGS[tagName]);
    }
    // For XHTML and XML documents that support custom namespaces
    if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && ALLOWED_NAMESPACES[element.namespaceURI]) {
      return true;
    }
    // The code should never reach this place (this means
    // that the element somehow got namespace that is not
    // HTML, SVG, MathML or allowed via ALLOWED_NAMESPACES).
    // Return false just in case.
    return false;
  };
  /**
   * _forceRemove
   *
   * @param node a DOM node
   */
  const _forceRemove = function _forceRemove(node) {
    arrayPush(DOMPurify.removed, {
      element: node
    });
    try {
      // eslint-disable-next-line unicorn/prefer-dom-node-remove
      getParentNode(node).removeChild(node);
    } catch (_) {
      remove(node);
    }
  };
  /**
   * _removeAttribute
   *
   * @param name an Attribute name
   * @param element a DOM node
   */
  const _removeAttribute = function _removeAttribute(name, element) {
    try {
      arrayPush(DOMPurify.removed, {
        attribute: element.getAttributeNode(name),
        from: element
      });
    } catch (_) {
      arrayPush(DOMPurify.removed, {
        attribute: null,
        from: element
      });
    }
    element.removeAttribute(name);
    // We void attribute values for unremovable "is" attributes
    if (name === 'is') {
      if (RETURN_DOM || RETURN_DOM_FRAGMENT) {
        try {
          _forceRemove(element);
        } catch (_) {}
      } else {
        try {
          element.setAttribute(name, '');
        } catch (_) {}
      }
    }
  };
  /**
   * _initDocument
   *
   * @param dirty - a string of dirty markup
   * @return a DOM, filled with the dirty markup
   */
  const _initDocument = function _initDocument(dirty) {
    /* Create a HTML document */
    let doc = null;
    let leadingWhitespace = null;
    if (FORCE_BODY) {
      dirty = '<remove></remove>' + dirty;
    } else {
      /* If FORCE_BODY isn't used, leading whitespace needs to be preserved manually */
      const matches = stringMatch(dirty, /^[\r\n\t ]+/);
      leadingWhitespace = matches && matches[0];
    }
    if (PARSER_MEDIA_TYPE === 'application/xhtml+xml' && NAMESPACE === HTML_NAMESPACE) {
      // Root of XHTML doc must contain xmlns declaration (see https://www.w3.org/TR/xhtml1/normative.html#strict)
      dirty = '<html xmlns="http://www.w3.org/1999/xhtml"><head></head><body>' + dirty + '</body></html>';
    }
    const dirtyPayload = trustedTypesPolicy ? trustedTypesPolicy.createHTML(dirty) : dirty;
    /*
     * Use the DOMParser API by default, fallback later if needs be
     * DOMParser not work for svg when has multiple root element.
     */
    if (NAMESPACE === HTML_NAMESPACE) {
      try {
        doc = new DOMParser().parseFromString(dirtyPayload, PARSER_MEDIA_TYPE);
      } catch (_) {}
    }
    /* Use createHTMLDocument in case DOMParser is not available */
    if (!doc || !doc.documentElement) {
      doc = implementation.createDocument(NAMESPACE, 'template', null);
      try {
        doc.documentElement.innerHTML = IS_EMPTY_INPUT ? emptyHTML : dirtyPayload;
      } catch (_) {
        // Syntax error if dirtyPayload is invalid xml
      }
    }
    const body = doc.body || doc.documentElement;
    if (dirty && leadingWhitespace) {
      body.insertBefore(document.createTextNode(leadingWhitespace), body.childNodes[0] || null);
    }
    /* Work on whole document or just its body */
    if (NAMESPACE === HTML_NAMESPACE) {
      return getElementsByTagName.call(doc, WHOLE_DOCUMENT ? 'html' : 'body')[0];
    }
    return WHOLE_DOCUMENT ? doc.documentElement : body;
  };
  /**
   * Creates a NodeIterator object that you can use to traverse filtered lists of nodes or elements in a document.
   *
   * @param root The root element or node to start traversing on.
   * @return The created NodeIterator
   */
  const _createNodeIterator = function _createNodeIterator(root) {
    return createNodeIterator.call(root.ownerDocument || root, root,
    // eslint-disable-next-line no-bitwise
    NodeFilter.SHOW_ELEMENT | NodeFilter.SHOW_COMMENT | NodeFilter.SHOW_TEXT | NodeFilter.SHOW_PROCESSING_INSTRUCTION | NodeFilter.SHOW_CDATA_SECTION, null);
  };
  /**
   * _isClobbered
   *
   * @param element element to check for clobbering attacks
   * @return true if clobbered, false if safe
   */
  const _isClobbered = function _isClobbered(element) {
    return element instanceof HTMLFormElement && (typeof element.nodeName !== 'string' || typeof element.textContent !== 'string' || typeof element.removeChild !== 'function' || !(element.attributes instanceof NamedNodeMap) || typeof element.removeAttribute !== 'function' || typeof element.setAttribute !== 'function' || typeof element.namespaceURI !== 'string' || typeof element.insertBefore !== 'function' || typeof element.hasChildNodes !== 'function');
  };
  /**
   * Checks whether the given object is a DOM node.
   *
   * @param value object to check whether it's a DOM node
   * @return true is object is a DOM node
   */
  const _isNode = function _isNode(value) {
    return typeof Node === 'function' && value instanceof Node;
  };
  function _executeHooks(hooks, currentNode, data) {
    arrayForEach(hooks, hook => {
      hook.call(DOMPurify, currentNode, data, CONFIG);
    });
  }
  /**
   * _sanitizeElements
   *
   * @protect nodeName
   * @protect textContent
   * @protect removeChild
   * @param currentNode to check for permission to exist
   * @return true if node was killed, false if left alive
   */
  const _sanitizeElements = function _sanitizeElements(currentNode) {
    let content = null;
    /* Execute a hook if present */
    _executeHooks(hooks.beforeSanitizeElements, currentNode, null);
    /* Check if element is clobbered or can clobber */
    if (_isClobbered(currentNode)) {
      _forceRemove(currentNode);
      return true;
    }
    /* Now let's check the element's type and name */
    const tagName = transformCaseFunc(currentNode.nodeName);
    /* Execute a hook if present */
    _executeHooks(hooks.uponSanitizeElement, currentNode, {
      tagName,
      allowedTags: ALLOWED_TAGS
    });
    /* Detect mXSS attempts abusing namespace confusion */
    if (SAFE_FOR_XML && currentNode.hasChildNodes() && !_isNode(currentNode.firstElementChild) && regExpTest(/<[/\w!]/g, currentNode.innerHTML) && regExpTest(/<[/\w!]/g, currentNode.textContent)) {
      _forceRemove(currentNode);
      return true;
    }
    /* Remove any occurrence of processing instructions */
    if (currentNode.nodeType === NODE_TYPE.progressingInstruction) {
      _forceRemove(currentNode);
      return true;
    }
    /* Remove any kind of possibly harmful comments */
    if (SAFE_FOR_XML && currentNode.nodeType === NODE_TYPE.comment && regExpTest(/<[/\w]/g, currentNode.data)) {
      _forceRemove(currentNode);
      return true;
    }
    /* Remove element if anything forbids its presence */
    if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
      /* Check if we have a custom element to handle */
      if (!FORBID_TAGS[tagName] && _isBasicCustomElement(tagName)) {
        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, tagName)) {
          return false;
        }
        if (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(tagName)) {
          return false;
        }
      }
      /* Keep content except for bad-listed elements */
      if (KEEP_CONTENT && !FORBID_CONTENTS[tagName]) {
        const parentNode = getParentNode(currentNode) || currentNode.parentNode;
        const childNodes = getChildNodes(currentNode) || currentNode.childNodes;
        if (childNodes && parentNode) {
          const childCount = childNodes.length;
          for (let i = childCount - 1; i >= 0; --i) {
            const childClone = cloneNode(childNodes[i], true);
            childClone.__removalCount = (currentNode.__removalCount || 0) + 1;
            parentNode.insertBefore(childClone, getNextSibling(currentNode));
          }
        }
      }
      _forceRemove(currentNode);
      return true;
    }
    /* Check whether element has a valid namespace */
    if (currentNode instanceof Element && !_checkValidNamespace(currentNode)) {
      _forceRemove(currentNode);
      return true;
    }
    /* Make sure that older browsers don't get fallback-tag mXSS */
    if ((tagName === 'noscript' || tagName === 'noembed' || tagName === 'noframes') && regExpTest(/<\/no(script|embed|frames)/i, currentNode.innerHTML)) {
      _forceRemove(currentNode);
      return true;
    }
    /* Sanitize element content to be template-safe */
    if (SAFE_FOR_TEMPLATES && currentNode.nodeType === NODE_TYPE.text) {
      /* Get the element's text content */
      content = currentNode.textContent;
      arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
        content = stringReplace(content, expr, ' ');
      });
      if (currentNode.textContent !== content) {
        arrayPush(DOMPurify.removed, {
          element: currentNode.cloneNode()
        });
        currentNode.textContent = content;
      }
    }
    /* Execute a hook if present */
    _executeHooks(hooks.afterSanitizeElements, currentNode, null);
    return false;
  };
  /**
   * _isValidAttribute
   *
   * @param lcTag Lowercase tag name of containing element.
   * @param lcName Lowercase attribute name.
   * @param value Attribute value.
   * @return Returns true if `value` is valid, otherwise false.
   */
  // eslint-disable-next-line complexity
  const _isValidAttribute = function _isValidAttribute(lcTag, lcName, value) {
    /* Make sure attribute cannot clobber */
    if (SANITIZE_DOM && (lcName === 'id' || lcName === 'name') && (value in document || value in formElement)) {
      return false;
    }
    /* Allow valid data-* attributes: At least one character after "-"
        (https://html.spec.whatwg.org/multipage/dom.html#embedding-custom-non-visible-data-with-the-data-*-attributes)
        XML-compatible (https://html.spec.whatwg.org/multipage/infrastructure.html#xml-compatible and http://www.w3.org/TR/xml/#d0e804)
        We don't need to check the value; it's always URI safe. */
    if (ALLOW_DATA_ATTR && !FORBID_ATTR[lcName] && regExpTest(DATA_ATTR, lcName)) ; else if (ALLOW_ARIA_ATTR && regExpTest(ARIA_ATTR, lcName)) ; else if (!ALLOWED_ATTR[lcName] || FORBID_ATTR[lcName]) {
      if (
      // First condition does a very basic check if a) it's basically a valid custom element tagname AND
      // b) if the tagName passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
      // and c) if the attribute name passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.attributeNameCheck
      _isBasicCustomElement(lcTag) && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, lcTag) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(lcTag)) && (CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.attributeNameCheck, lcName) || CUSTOM_ELEMENT_HANDLING.attributeNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.attributeNameCheck(lcName)) ||
      // Alternative, second condition checks if it's an `is`-attribute, AND
      // the value passes whatever the user has configured for CUSTOM_ELEMENT_HANDLING.tagNameCheck
      lcName === 'is' && CUSTOM_ELEMENT_HANDLING.allowCustomizedBuiltInElements && (CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof RegExp && regExpTest(CUSTOM_ELEMENT_HANDLING.tagNameCheck, value) || CUSTOM_ELEMENT_HANDLING.tagNameCheck instanceof Function && CUSTOM_ELEMENT_HANDLING.tagNameCheck(value))) ; else {
        return false;
      }
      /* Check value is safe. First, is attr inert? If so, is safe */
    } else if (URI_SAFE_ATTRIBUTES[lcName]) ; else if (regExpTest(IS_ALLOWED_URI$1, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if ((lcName === 'src' || lcName === 'xlink:href' || lcName === 'href') && lcTag !== 'script' && stringIndexOf(value, 'data:') === 0 && DATA_URI_TAGS[lcTag]) ; else if (ALLOW_UNKNOWN_PROTOCOLS && !regExpTest(IS_SCRIPT_OR_DATA, stringReplace(value, ATTR_WHITESPACE, ''))) ; else if (value) {
      return false;
    } else ;
    return true;
  };
  /**
   * _isBasicCustomElement
   * checks if at least one dash is included in tagName, and it's not the first char
   * for more sophisticated checking see https://github.com/sindresorhus/validate-element-name
   *
   * @param tagName name of the tag of the node to sanitize
   * @returns Returns true if the tag name meets the basic criteria for a custom element, otherwise false.
   */
  const _isBasicCustomElement = function _isBasicCustomElement(tagName) {
    return tagName !== 'annotation-xml' && stringMatch(tagName, CUSTOM_ELEMENT);
  };
  /**
   * _sanitizeAttributes
   *
   * @protect attributes
   * @protect nodeName
   * @protect removeAttribute
   * @protect setAttribute
   *
   * @param currentNode to sanitize
   */
  const _sanitizeAttributes = function _sanitizeAttributes(currentNode) {
    /* Execute a hook if present */
    _executeHooks(hooks.beforeSanitizeAttributes, currentNode, null);
    const {
      attributes
    } = currentNode;
    /* Check if we have attributes; if not we might have a text node */
    if (!attributes || _isClobbered(currentNode)) {
      return;
    }
    const hookEvent = {
      attrName: '',
      attrValue: '',
      keepAttr: true,
      allowedAttributes: ALLOWED_ATTR,
      forceKeepAttr: undefined
    };
    let l = attributes.length;
    /* Go backwards over all attributes; safely remove bad ones */
    while (l--) {
      const attr = attributes[l];
      const {
        name,
        namespaceURI,
        value: attrValue
      } = attr;
      const lcName = transformCaseFunc(name);
      const initValue = attrValue;
      let value = name === 'value' ? initValue : stringTrim(initValue);
      /* Execute a hook if present */
      hookEvent.attrName = lcName;
      hookEvent.attrValue = value;
      hookEvent.keepAttr = true;
      hookEvent.forceKeepAttr = undefined; // Allows developers to see this is a property they can set
      _executeHooks(hooks.uponSanitizeAttribute, currentNode, hookEvent);
      value = hookEvent.attrValue;
      /* Full DOM Clobbering protection via namespace isolation,
       * Prefix id and name attributes with `user-content-`
       */
      if (SANITIZE_NAMED_PROPS && (lcName === 'id' || lcName === 'name')) {
        // Remove the attribute with this value
        _removeAttribute(name, currentNode);
        // Prefix the value and later re-create the attribute with the sanitized value
        value = SANITIZE_NAMED_PROPS_PREFIX + value;
      }
      /* Work around a security issue with comments inside attributes */
      if (SAFE_FOR_XML && regExpTest(/((--!?|])>)|<\/(style|title)/i, value)) {
        _removeAttribute(name, currentNode);
        continue;
      }
      /* Did the hooks approve of the attribute? */
      if (hookEvent.forceKeepAttr) {
        continue;
      }
      /* Did the hooks approve of the attribute? */
      if (!hookEvent.keepAttr) {
        _removeAttribute(name, currentNode);
        continue;
      }
      /* Work around a security issue in jQuery 3.0 */
      if (!ALLOW_SELF_CLOSE_IN_ATTR && regExpTest(/\/>/i, value)) {
        _removeAttribute(name, currentNode);
        continue;
      }
      /* Sanitize attribute content to be template-safe */
      if (SAFE_FOR_TEMPLATES) {
        arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
          value = stringReplace(value, expr, ' ');
        });
      }
      /* Is `value` valid for this attribute? */
      const lcTag = transformCaseFunc(currentNode.nodeName);
      if (!_isValidAttribute(lcTag, lcName, value)) {
        _removeAttribute(name, currentNode);
        continue;
      }
      /* Handle attributes that require Trusted Types */
      if (trustedTypesPolicy && typeof trustedTypes === 'object' && typeof trustedTypes.getAttributeType === 'function') {
        if (namespaceURI) ; else {
          switch (trustedTypes.getAttributeType(lcTag, lcName)) {
            case 'TrustedHTML':
              {
                value = trustedTypesPolicy.createHTML(value);
                break;
              }
            case 'TrustedScriptURL':
              {
                value = trustedTypesPolicy.createScriptURL(value);
                break;
              }
          }
        }
      }
      /* Handle invalid data-* attribute set by try-catching it */
      if (value !== initValue) {
        try {
          if (namespaceURI) {
            currentNode.setAttributeNS(namespaceURI, name, value);
          } else {
            /* Fallback to setAttribute() for browser-unrecognized namespaces e.g. "x-schema". */
            currentNode.setAttribute(name, value);
          }
          if (_isClobbered(currentNode)) {
            _forceRemove(currentNode);
          } else {
            arrayPop(DOMPurify.removed);
          }
        } catch (_) {
          _removeAttribute(name, currentNode);
        }
      }
    }
    /* Execute a hook if present */
    _executeHooks(hooks.afterSanitizeAttributes, currentNode, null);
  };
  /**
   * _sanitizeShadowDOM
   *
   * @param fragment to iterate over recursively
   */
  const _sanitizeShadowDOM = function _sanitizeShadowDOM(fragment) {
    let shadowNode = null;
    const shadowIterator = _createNodeIterator(fragment);
    /* Execute a hook if present */
    _executeHooks(hooks.beforeSanitizeShadowDOM, fragment, null);
    while (shadowNode = shadowIterator.nextNode()) {
      /* Execute a hook if present */
      _executeHooks(hooks.uponSanitizeShadowNode, shadowNode, null);
      /* Sanitize tags and elements */
      _sanitizeElements(shadowNode);
      /* Check attributes next */
      _sanitizeAttributes(shadowNode);
      /* Deep shadow DOM detected */
      if (shadowNode.content instanceof DocumentFragment) {
        _sanitizeShadowDOM(shadowNode.content);
      }
    }
    /* Execute a hook if present */
    _executeHooks(hooks.afterSanitizeShadowDOM, fragment, null);
  };
  // eslint-disable-next-line complexity
  DOMPurify.sanitize = function (dirty) {
    let cfg = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
    let body = null;
    let importedNode = null;
    let currentNode = null;
    let returnNode = null;
    /* Make sure we have a string to sanitize.
      DO NOT return early, as this will return the wrong type if
      the user has requested a DOM object rather than a string */
    IS_EMPTY_INPUT = !dirty;
    if (IS_EMPTY_INPUT) {
      dirty = '<!-->';
    }
    /* Stringify, in case dirty is an object */
    if (typeof dirty !== 'string' && !_isNode(dirty)) {
      if (typeof dirty.toString === 'function') {
        dirty = dirty.toString();
        if (typeof dirty !== 'string') {
          throw typeErrorCreate('dirty is not a string, aborting');
        }
      } else {
        throw typeErrorCreate('toString is not a function');
      }
    }
    /* Return dirty HTML if DOMPurify cannot run */
    if (!DOMPurify.isSupported) {
      return dirty;
    }
    /* Assign config vars */
    if (!SET_CONFIG) {
      _parseConfig(cfg);
    }
    /* Clean up removed elements */
    DOMPurify.removed = [];
    /* Check if dirty is correctly typed for IN_PLACE */
    if (typeof dirty === 'string') {
      IN_PLACE = false;
    }
    if (IN_PLACE) {
      /* Do some early pre-sanitization to avoid unsafe root nodes */
      if (dirty.nodeName) {
        const tagName = transformCaseFunc(dirty.nodeName);
        if (!ALLOWED_TAGS[tagName] || FORBID_TAGS[tagName]) {
          throw typeErrorCreate('root node is forbidden and cannot be sanitized in-place');
        }
      }
    } else if (dirty instanceof Node) {
      /* If dirty is a DOM element, append to an empty document to avoid
         elements being stripped by the parser */
      body = _initDocument('<!---->');
      importedNode = body.ownerDocument.importNode(dirty, true);
      if (importedNode.nodeType === NODE_TYPE.element && importedNode.nodeName === 'BODY') {
        /* Node is already a body, use as is */
        body = importedNode;
      } else if (importedNode.nodeName === 'HTML') {
        body = importedNode;
      } else {
        // eslint-disable-next-line unicorn/prefer-dom-node-append
        body.appendChild(importedNode);
      }
    } else {
      /* Exit directly if we have nothing to do */
      if (!RETURN_DOM && !SAFE_FOR_TEMPLATES && !WHOLE_DOCUMENT &&
      // eslint-disable-next-line unicorn/prefer-includes
      dirty.indexOf('<') === -1) {
        return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(dirty) : dirty;
      }
      /* Initialize the document to work on */
      body = _initDocument(dirty);
      /* Check we have a DOM node from the data */
      if (!body) {
        return RETURN_DOM ? null : RETURN_TRUSTED_TYPE ? emptyHTML : '';
      }
    }
    /* Remove first element node (ours) if FORCE_BODY is set */
    if (body && FORCE_BODY) {
      _forceRemove(body.firstChild);
    }
    /* Get node iterator */
    const nodeIterator = _createNodeIterator(IN_PLACE ? dirty : body);
    /* Now start iterating over the created document */
    while (currentNode = nodeIterator.nextNode()) {
      /* Sanitize tags and elements */
      _sanitizeElements(currentNode);
      /* Check attributes next */
      _sanitizeAttributes(currentNode);
      /* Shadow DOM detected, sanitize it */
      if (currentNode.content instanceof DocumentFragment) {
        _sanitizeShadowDOM(currentNode.content);
      }
    }
    /* If we sanitized `dirty` in-place, return it. */
    if (IN_PLACE) {
      return dirty;
    }
    /* Return sanitized string or DOM */
    if (RETURN_DOM) {
      if (RETURN_DOM_FRAGMENT) {
        returnNode = createDocumentFragment.call(body.ownerDocument);
        while (body.firstChild) {
          // eslint-disable-next-line unicorn/prefer-dom-node-append
          returnNode.appendChild(body.firstChild);
        }
      } else {
        returnNode = body;
      }
      if (ALLOWED_ATTR.shadowroot || ALLOWED_ATTR.shadowrootmode) {
        /*
          AdoptNode() is not used because internal state is not reset
          (e.g. the past names map of a HTMLFormElement), this is safe
          in theory but we would rather not risk another attack vector.
          The state that is cloned by importNode() is explicitly defined
          by the specs.
        */
        returnNode = importNode.call(originalDocument, returnNode, true);
      }
      return returnNode;
    }
    let serializedHTML = WHOLE_DOCUMENT ? body.outerHTML : body.innerHTML;
    /* Serialize doctype if allowed */
    if (WHOLE_DOCUMENT && ALLOWED_TAGS['!doctype'] && body.ownerDocument && body.ownerDocument.doctype && body.ownerDocument.doctype.name && regExpTest(DOCTYPE_NAME, body.ownerDocument.doctype.name)) {
      serializedHTML = '<!DOCTYPE ' + body.ownerDocument.doctype.name + '>\n' + serializedHTML;
    }
    /* Sanitize final string template-safe */
    if (SAFE_FOR_TEMPLATES) {
      arrayForEach([MUSTACHE_EXPR, ERB_EXPR, TMPLIT_EXPR], expr => {
        serializedHTML = stringReplace(serializedHTML, expr, ' ');
      });
    }
    return trustedTypesPolicy && RETURN_TRUSTED_TYPE ? trustedTypesPolicy.createHTML(serializedHTML) : serializedHTML;
  };
  DOMPurify.setConfig = function () {
    let cfg = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
    _parseConfig(cfg);
    SET_CONFIG = true;
  };
  DOMPurify.clearConfig = function () {
    CONFIG = null;
    SET_CONFIG = false;
  };
  DOMPurify.isValidAttribute = function (tag, attr, value) {
    /* Initialize shared config vars if necessary. */
    if (!CONFIG) {
      _parseConfig({});
    }
    const lcTag = transformCaseFunc(tag);
    const lcName = transformCaseFunc(attr);
    return _isValidAttribute(lcTag, lcName, value);
  };
  DOMPurify.addHook = function (entryPoint, hookFunction) {
    if (typeof hookFunction !== 'function') {
      return;
    }
    arrayPush(hooks[entryPoint], hookFunction);
  };
  DOMPurify.removeHook = function (entryPoint, hookFunction) {
    if (hookFunction !== undefined) {
      const index = arrayLastIndexOf(hooks[entryPoint], hookFunction);
      return index === -1 ? undefined : arraySplice(hooks[entryPoint], index, 1)[0];
    }
    return arrayPop(hooks[entryPoint]);
  };
  DOMPurify.removeHooks = function (entryPoint) {
    hooks[entryPoint] = [];
  };
  DOMPurify.removeAllHooks = function () {
    hooks = _createHooksMap();
  };
  return DOMPurify;
}
var purify = createDOMPurify();

module.exports = purify;
//# sourceMappingURL=purify.cjs.js.map


/***/ }),

/***/ "../node_modules/object-assign/index.js":
/*!**********************************************!*\
  !*** ../node_modules/object-assign/index.js ***!
  \**********************************************/
/***/ ((module) => {

"use strict";
/*
object-assign
(c) Sindre Sorhus
@license MIT
*/


/* eslint-disable no-unused-vars */
var getOwnPropertySymbols = Object.getOwnPropertySymbols;
var hasOwnProperty = Object.prototype.hasOwnProperty;
var propIsEnumerable = Object.prototype.propertyIsEnumerable;

function toObject(val) {
	if (val === null || val === undefined) {
		throw new TypeError('Object.assign cannot be called with null or undefined');
	}

	return Object(val);
}

function shouldUseNative() {
	try {
		if (!Object.assign) {
			return false;
		}

		// Detect buggy property enumeration order in older V8 versions.

		// https://bugs.chromium.org/p/v8/issues/detail?id=4118
		var test1 = new String('abc');  // eslint-disable-line no-new-wrappers
		test1[5] = 'de';
		if (Object.getOwnPropertyNames(test1)[0] === '5') {
			return false;
		}

		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
		var test2 = {};
		for (var i = 0; i < 10; i++) {
			test2['_' + String.fromCharCode(i)] = i;
		}
		var order2 = Object.getOwnPropertyNames(test2).map(function (n) {
			return test2[n];
		});
		if (order2.join('') !== '0123456789') {
			return false;
		}

		// https://bugs.chromium.org/p/v8/issues/detail?id=3056
		var test3 = {};
		'abcdefghijklmnopqrst'.split('').forEach(function (letter) {
			test3[letter] = letter;
		});
		if (Object.keys(Object.assign({}, test3)).join('') !==
				'abcdefghijklmnopqrst') {
			return false;
		}

		return true;
	} catch (err) {
		// We don't expect any of the above to throw, but better to be safe.
		return false;
	}
}

module.exports = shouldUseNative() ? Object.assign : function (target, source) {
	var from;
	var to = toObject(target);
	var symbols;

	for (var s = 1; s < arguments.length; s++) {
		from = Object(arguments[s]);

		for (var key in from) {
			if (hasOwnProperty.call(from, key)) {
				to[key] = from[key];
			}
		}

		if (getOwnPropertySymbols) {
			symbols = getOwnPropertySymbols(from);
			for (var i = 0; i < symbols.length; i++) {
				if (propIsEnumerable.call(from, symbols[i])) {
					to[symbols[i]] = from[symbols[i]];
				}
			}
		}
	}

	return to;
};


/***/ }),

/***/ "../node_modules/prop-types/checkPropTypes.js":
/*!****************************************************!*\
  !*** ../node_modules/prop-types/checkPropTypes.js ***!
  \****************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */



var printWarning = function() {};

if (true) {
  var ReactPropTypesSecret = __webpack_require__(/*! ./lib/ReactPropTypesSecret */ "../node_modules/prop-types/lib/ReactPropTypesSecret.js");
  var loggedTypeFailures = {};
  var has = __webpack_require__(/*! ./lib/has */ "../node_modules/prop-types/lib/has.js");

  printWarning = function(text) {
    var message = 'Warning: ' + text;
    if (typeof console !== 'undefined') {
      console.error(message);
    }
    try {
      // --- Welcome to debugging React ---
      // This error was thrown as a convenience so that you can use this stack
      // to find the callsite that caused this warning to fire.
      throw new Error(message);
    } catch (x) { /**/ }
  };
}

/**
 * Assert that the values match with the type specs.
 * Error messages are memorized and will only be shown once.
 *
 * @param {object} typeSpecs Map of name to a ReactPropType
 * @param {object} values Runtime values that need to be type-checked
 * @param {string} location e.g. "prop", "context", "child context"
 * @param {string} componentName Name of the component for error messages.
 * @param {?Function} getStack Returns the component stack.
 * @private
 */
function checkPropTypes(typeSpecs, values, location, componentName, getStack) {
  if (true) {
    for (var typeSpecName in typeSpecs) {
      if (has(typeSpecs, typeSpecName)) {
        var error;
        // Prop type validation may throw. In case they do, we don't want to
        // fail the render phase where it didn't fail before. So we log it.
        // After these have been cleaned up, we'll let them throw.
        try {
          // This is intentionally an invariant that gets caught. It's the same
          // behavior as without this statement except with a better message.
          if (typeof typeSpecs[typeSpecName] !== 'function') {
            var err = Error(
              (componentName || 'React class') + ': ' + location + ' type `' + typeSpecName + '` is invalid; ' +
              'it must be a function, usually from the `prop-types` package, but received `' + typeof typeSpecs[typeSpecName] + '`.' +
              'This often happens because of typos such as `PropTypes.function` instead of `PropTypes.func`.'
            );
            err.name = 'Invariant Violation';
            throw err;
          }
          error = typeSpecs[typeSpecName](values, typeSpecName, componentName, location, null, ReactPropTypesSecret);
        } catch (ex) {
          error = ex;
        }
        if (error && !(error instanceof Error)) {
          printWarning(
            (componentName || 'React class') + ': type specification of ' +
            location + ' `' + typeSpecName + '` is invalid; the type checker ' +
            'function must return `null` or an `Error` but returned a ' + typeof error + '. ' +
            'You may have forgotten to pass an argument to the type checker ' +
            'creator (arrayOf, instanceOf, objectOf, oneOf, oneOfType, and ' +
            'shape all require an argument).'
          );
        }
        if (error instanceof Error && !(error.message in loggedTypeFailures)) {
          // Only monitor this failure once because there tends to be a lot of the
          // same error.
          loggedTypeFailures[error.message] = true;

          var stack = getStack ? getStack() : '';

          printWarning(
            'Failed ' + location + ' type: ' + error.message + (stack != null ? stack : '')
          );
        }
      }
    }
  }
}

/**
 * Resets warning cache when testing.
 *
 * @private
 */
checkPropTypes.resetWarningCache = function() {
  if (true) {
    loggedTypeFailures = {};
  }
}

module.exports = checkPropTypes;


/***/ }),

/***/ "../node_modules/prop-types/factoryWithTypeCheckers.js":
/*!*************************************************************!*\
  !*** ../node_modules/prop-types/factoryWithTypeCheckers.js ***!
  \*************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */



var ReactIs = __webpack_require__(/*! react-is */ "../node_modules/prop-types/node_modules/react-is/index.js");
var assign = __webpack_require__(/*! object-assign */ "../node_modules/object-assign/index.js");

var ReactPropTypesSecret = __webpack_require__(/*! ./lib/ReactPropTypesSecret */ "../node_modules/prop-types/lib/ReactPropTypesSecret.js");
var has = __webpack_require__(/*! ./lib/has */ "../node_modules/prop-types/lib/has.js");
var checkPropTypes = __webpack_require__(/*! ./checkPropTypes */ "../node_modules/prop-types/checkPropTypes.js");

var printWarning = function() {};

if (true) {
  printWarning = function(text) {
    var message = 'Warning: ' + text;
    if (typeof console !== 'undefined') {
      console.error(message);
    }
    try {
      // --- Welcome to debugging React ---
      // This error was thrown as a convenience so that you can use this stack
      // to find the callsite that caused this warning to fire.
      throw new Error(message);
    } catch (x) {}
  };
}

function emptyFunctionThatReturnsNull() {
  return null;
}

module.exports = function(isValidElement, throwOnDirectAccess) {
  /* global Symbol */
  var ITERATOR_SYMBOL = typeof Symbol === 'function' && Symbol.iterator;
  var FAUX_ITERATOR_SYMBOL = '@@iterator'; // Before Symbol spec.

  /**
   * Returns the iterator method function contained on the iterable object.
   *
   * Be sure to invoke the function with the iterable as context:
   *
   *     var iteratorFn = getIteratorFn(myIterable);
   *     if (iteratorFn) {
   *       var iterator = iteratorFn.call(myIterable);
   *       ...
   *     }
   *
   * @param {?object} maybeIterable
   * @return {?function}
   */
  function getIteratorFn(maybeIterable) {
    var iteratorFn = maybeIterable && (ITERATOR_SYMBOL && maybeIterable[ITERATOR_SYMBOL] || maybeIterable[FAUX_ITERATOR_SYMBOL]);
    if (typeof iteratorFn === 'function') {
      return iteratorFn;
    }
  }

  /**
   * Collection of methods that allow declaration and validation of props that are
   * supplied to React components. Example usage:
   *
   *   var Props = require('ReactPropTypes');
   *   var MyArticle = React.createClass({
   *     propTypes: {
   *       // An optional string prop named "description".
   *       description: Props.string,
   *
   *       // A required enum prop named "category".
   *       category: Props.oneOf(['News','Photos']).isRequired,
   *
   *       // A prop named "dialog" that requires an instance of Dialog.
   *       dialog: Props.instanceOf(Dialog).isRequired
   *     },
   *     render: function() { ... }
   *   });
   *
   * A more formal specification of how these methods are used:
   *
   *   type := array|bool|func|object|number|string|oneOf([...])|instanceOf(...)
   *   decl := ReactPropTypes.{type}(.isRequired)?
   *
   * Each and every declaration produces a function with the same signature. This
   * allows the creation of custom validation functions. For example:
   *
   *  var MyLink = React.createClass({
   *    propTypes: {
   *      // An optional string or URI prop named "href".
   *      href: function(props, propName, componentName) {
   *        var propValue = props[propName];
   *        if (propValue != null && typeof propValue !== 'string' &&
   *            !(propValue instanceof URI)) {
   *          return new Error(
   *            'Expected a string or an URI for ' + propName + ' in ' +
   *            componentName
   *          );
   *        }
   *      }
   *    },
   *    render: function() {...}
   *  });
   *
   * @internal
   */

  var ANONYMOUS = '<<anonymous>>';

  // Important!
  // Keep this list in sync with production version in `./factoryWithThrowingShims.js`.
  var ReactPropTypes = {
    array: createPrimitiveTypeChecker('array'),
    bigint: createPrimitiveTypeChecker('bigint'),
    bool: createPrimitiveTypeChecker('boolean'),
    func: createPrimitiveTypeChecker('function'),
    number: createPrimitiveTypeChecker('number'),
    object: createPrimitiveTypeChecker('object'),
    string: createPrimitiveTypeChecker('string'),
    symbol: createPrimitiveTypeChecker('symbol'),

    any: createAnyTypeChecker(),
    arrayOf: createArrayOfTypeChecker,
    element: createElementTypeChecker(),
    elementType: createElementTypeTypeChecker(),
    instanceOf: createInstanceTypeChecker,
    node: createNodeChecker(),
    objectOf: createObjectOfTypeChecker,
    oneOf: createEnumTypeChecker,
    oneOfType: createUnionTypeChecker,
    shape: createShapeTypeChecker,
    exact: createStrictShapeTypeChecker,
  };

  /**
   * inlined Object.is polyfill to avoid requiring consumers ship their own
   * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/is
   */
  /*eslint-disable no-self-compare*/
  function is(x, y) {
    // SameValue algorithm
    if (x === y) {
      // Steps 1-5, 7-10
      // Steps 6.b-6.e: +0 != -0
      return x !== 0 || 1 / x === 1 / y;
    } else {
      // Step 6.a: NaN == NaN
      return x !== x && y !== y;
    }
  }
  /*eslint-enable no-self-compare*/

  /**
   * We use an Error-like object for backward compatibility as people may call
   * PropTypes directly and inspect their output. However, we don't use real
   * Errors anymore. We don't inspect their stack anyway, and creating them
   * is prohibitively expensive if they are created too often, such as what
   * happens in oneOfType() for any type before the one that matched.
   */
  function PropTypeError(message, data) {
    this.message = message;
    this.data = data && typeof data === 'object' ? data: {};
    this.stack = '';
  }
  // Make `instanceof Error` still work for returned errors.
  PropTypeError.prototype = Error.prototype;

  function createChainableTypeChecker(validate) {
    if (true) {
      var manualPropTypeCallCache = {};
      var manualPropTypeWarningCount = 0;
    }
    function checkType(isRequired, props, propName, componentName, location, propFullName, secret) {
      componentName = componentName || ANONYMOUS;
      propFullName = propFullName || propName;

      if (secret !== ReactPropTypesSecret) {
        if (throwOnDirectAccess) {
          // New behavior only for users of `prop-types` package
          var err = new Error(
            'Calling PropTypes validators directly is not supported by the `prop-types` package. ' +
            'Use `PropTypes.checkPropTypes()` to call them. ' +
            'Read more at http://fb.me/use-check-prop-types'
          );
          err.name = 'Invariant Violation';
          throw err;
        } else if ( true && typeof console !== 'undefined') {
          // Old behavior for people using React.PropTypes
          var cacheKey = componentName + ':' + propName;
          if (
            !manualPropTypeCallCache[cacheKey] &&
            // Avoid spamming the console because they are often not actionable except for lib authors
            manualPropTypeWarningCount < 3
          ) {
            printWarning(
              'You are manually calling a React.PropTypes validation ' +
              'function for the `' + propFullName + '` prop on `' + componentName + '`. This is deprecated ' +
              'and will throw in the standalone `prop-types` package. ' +
              'You may be seeing this warning due to a third-party PropTypes ' +
              'library. See https://fb.me/react-warning-dont-call-proptypes ' + 'for details.'
            );
            manualPropTypeCallCache[cacheKey] = true;
            manualPropTypeWarningCount++;
          }
        }
      }
      if (props[propName] == null) {
        if (isRequired) {
          if (props[propName] === null) {
            return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required ' + ('in `' + componentName + '`, but its value is `null`.'));
          }
          return new PropTypeError('The ' + location + ' `' + propFullName + '` is marked as required in ' + ('`' + componentName + '`, but its value is `undefined`.'));
        }
        return null;
      } else {
        return validate(props, propName, componentName, location, propFullName);
      }
    }

    var chainedCheckType = checkType.bind(null, false);
    chainedCheckType.isRequired = checkType.bind(null, true);

    return chainedCheckType;
  }

  function createPrimitiveTypeChecker(expectedType) {
    function validate(props, propName, componentName, location, propFullName, secret) {
      var propValue = props[propName];
      var propType = getPropType(propValue);
      if (propType !== expectedType) {
        // `propValue` being instance of, say, date/regexp, pass the 'object'
        // check, but we can offer a more precise error message here rather than
        // 'of type `object`'.
        var preciseType = getPreciseType(propValue);

        return new PropTypeError(
          'Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + preciseType + '` supplied to `' + componentName + '`, expected ') + ('`' + expectedType + '`.'),
          {expectedType: expectedType}
        );
      }
      return null;
    }
    return createChainableTypeChecker(validate);
  }

  function createAnyTypeChecker() {
    return createChainableTypeChecker(emptyFunctionThatReturnsNull);
  }

  function createArrayOfTypeChecker(typeChecker) {
    function validate(props, propName, componentName, location, propFullName) {
      if (typeof typeChecker !== 'function') {
        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside arrayOf.');
      }
      var propValue = props[propName];
      if (!Array.isArray(propValue)) {
        var propType = getPropType(propValue);
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an array.'));
      }
      for (var i = 0; i < propValue.length; i++) {
        var error = typeChecker(propValue, i, componentName, location, propFullName + '[' + i + ']', ReactPropTypesSecret);
        if (error instanceof Error) {
          return error;
        }
      }
      return null;
    }
    return createChainableTypeChecker(validate);
  }

  function createElementTypeChecker() {
    function validate(props, propName, componentName, location, propFullName) {
      var propValue = props[propName];
      if (!isValidElement(propValue)) {
        var propType = getPropType(propValue);
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement.'));
      }
      return null;
    }
    return createChainableTypeChecker(validate);
  }

  function createElementTypeTypeChecker() {
    function validate(props, propName, componentName, location, propFullName) {
      var propValue = props[propName];
      if (!ReactIs.isValidElementType(propValue)) {
        var propType = getPropType(propValue);
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected a single ReactElement type.'));
      }
      return null;
    }
    return createChainableTypeChecker(validate);
  }

  function createInstanceTypeChecker(expectedClass) {
    function validate(props, propName, componentName, location, propFullName) {
      if (!(props[propName] instanceof expectedClass)) {
        var expectedClassName = expectedClass.name || ANONYMOUS;
        var actualClassName = getClassName(props[propName]);
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + actualClassName + '` supplied to `' + componentName + '`, expected ') + ('instance of `' + expectedClassName + '`.'));
      }
      return null;
    }
    return createChainableTypeChecker(validate);
  }

  function createEnumTypeChecker(expectedValues) {
    if (!Array.isArray(expectedValues)) {
      if (true) {
        if (arguments.length > 1) {
          printWarning(
            'Invalid arguments supplied to oneOf, expected an array, got ' + arguments.length + ' arguments. ' +
            'A common mistake is to write oneOf(x, y, z) instead of oneOf([x, y, z]).'
          );
        } else {
          printWarning('Invalid argument supplied to oneOf, expected an array.');
        }
      }
      return emptyFunctionThatReturnsNull;
    }

    function validate(props, propName, componentName, location, propFullName) {
      var propValue = props[propName];
      for (var i = 0; i < expectedValues.length; i++) {
        if (is(propValue, expectedValues[i])) {
          return null;
        }
      }

      var valuesString = JSON.stringify(expectedValues, function replacer(key, value) {
        var type = getPreciseType(value);
        if (type === 'symbol') {
          return String(value);
        }
        return value;
      });
      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of value `' + String(propValue) + '` ' + ('supplied to `' + componentName + '`, expected one of ' + valuesString + '.'));
    }
    return createChainableTypeChecker(validate);
  }

  function createObjectOfTypeChecker(typeChecker) {
    function validate(props, propName, componentName, location, propFullName) {
      if (typeof typeChecker !== 'function') {
        return new PropTypeError('Property `' + propFullName + '` of component `' + componentName + '` has invalid PropType notation inside objectOf.');
      }
      var propValue = props[propName];
      var propType = getPropType(propValue);
      if (propType !== 'object') {
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type ' + ('`' + propType + '` supplied to `' + componentName + '`, expected an object.'));
      }
      for (var key in propValue) {
        if (has(propValue, key)) {
          var error = typeChecker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
          if (error instanceof Error) {
            return error;
          }
        }
      }
      return null;
    }
    return createChainableTypeChecker(validate);
  }

  function createUnionTypeChecker(arrayOfTypeCheckers) {
    if (!Array.isArray(arrayOfTypeCheckers)) {
       true ? printWarning('Invalid argument supplied to oneOfType, expected an instance of array.') : 0;
      return emptyFunctionThatReturnsNull;
    }

    for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
      var checker = arrayOfTypeCheckers[i];
      if (typeof checker !== 'function') {
        printWarning(
          'Invalid argument supplied to oneOfType. Expected an array of check functions, but ' +
          'received ' + getPostfixForTypeWarning(checker) + ' at index ' + i + '.'
        );
        return emptyFunctionThatReturnsNull;
      }
    }

    function validate(props, propName, componentName, location, propFullName) {
      var expectedTypes = [];
      for (var i = 0; i < arrayOfTypeCheckers.length; i++) {
        var checker = arrayOfTypeCheckers[i];
        var checkerResult = checker(props, propName, componentName, location, propFullName, ReactPropTypesSecret);
        if (checkerResult == null) {
          return null;
        }
        if (checkerResult.data && has(checkerResult.data, 'expectedType')) {
          expectedTypes.push(checkerResult.data.expectedType);
        }
      }
      var expectedTypesMessage = (expectedTypes.length > 0) ? ', expected one of type [' + expectedTypes.join(', ') + ']': '';
      return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`' + expectedTypesMessage + '.'));
    }
    return createChainableTypeChecker(validate);
  }

  function createNodeChecker() {
    function validate(props, propName, componentName, location, propFullName) {
      if (!isNode(props[propName])) {
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` supplied to ' + ('`' + componentName + '`, expected a ReactNode.'));
      }
      return null;
    }
    return createChainableTypeChecker(validate);
  }

  function invalidValidatorError(componentName, location, propFullName, key, type) {
    return new PropTypeError(
      (componentName || 'React class') + ': ' + location + ' type `' + propFullName + '.' + key + '` is invalid; ' +
      'it must be a function, usually from the `prop-types` package, but received `' + type + '`.'
    );
  }

  function createShapeTypeChecker(shapeTypes) {
    function validate(props, propName, componentName, location, propFullName) {
      var propValue = props[propName];
      var propType = getPropType(propValue);
      if (propType !== 'object') {
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
      }
      for (var key in shapeTypes) {
        var checker = shapeTypes[key];
        if (typeof checker !== 'function') {
          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
        }
        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
        if (error) {
          return error;
        }
      }
      return null;
    }
    return createChainableTypeChecker(validate);
  }

  function createStrictShapeTypeChecker(shapeTypes) {
    function validate(props, propName, componentName, location, propFullName) {
      var propValue = props[propName];
      var propType = getPropType(propValue);
      if (propType !== 'object') {
        return new PropTypeError('Invalid ' + location + ' `' + propFullName + '` of type `' + propType + '` ' + ('supplied to `' + componentName + '`, expected `object`.'));
      }
      // We need to check all keys in case some are required but missing from props.
      var allKeys = assign({}, props[propName], shapeTypes);
      for (var key in allKeys) {
        var checker = shapeTypes[key];
        if (has(shapeTypes, key) && typeof checker !== 'function') {
          return invalidValidatorError(componentName, location, propFullName, key, getPreciseType(checker));
        }
        if (!checker) {
          return new PropTypeError(
            'Invalid ' + location + ' `' + propFullName + '` key `' + key + '` supplied to `' + componentName + '`.' +
            '\nBad object: ' + JSON.stringify(props[propName], null, '  ') +
            '\nValid keys: ' + JSON.stringify(Object.keys(shapeTypes), null, '  ')
          );
        }
        var error = checker(propValue, key, componentName, location, propFullName + '.' + key, ReactPropTypesSecret);
        if (error) {
          return error;
        }
      }
      return null;
    }

    return createChainableTypeChecker(validate);
  }

  function isNode(propValue) {
    switch (typeof propValue) {
      case 'number':
      case 'string':
      case 'undefined':
        return true;
      case 'boolean':
        return !propValue;
      case 'object':
        if (Array.isArray(propValue)) {
          return propValue.every(isNode);
        }
        if (propValue === null || isValidElement(propValue)) {
          return true;
        }

        var iteratorFn = getIteratorFn(propValue);
        if (iteratorFn) {
          var iterator = iteratorFn.call(propValue);
          var step;
          if (iteratorFn !== propValue.entries) {
            while (!(step = iterator.next()).done) {
              if (!isNode(step.value)) {
                return false;
              }
            }
          } else {
            // Iterator will provide entry [k,v] tuples rather than values.
            while (!(step = iterator.next()).done) {
              var entry = step.value;
              if (entry) {
                if (!isNode(entry[1])) {
                  return false;
                }
              }
            }
          }
        } else {
          return false;
        }

        return true;
      default:
        return false;
    }
  }

  function isSymbol(propType, propValue) {
    // Native Symbol.
    if (propType === 'symbol') {
      return true;
    }

    // falsy value can't be a Symbol
    if (!propValue) {
      return false;
    }

    // 19.4.3.5 Symbol.prototype[@@toStringTag] === 'Symbol'
    if (propValue['@@toStringTag'] === 'Symbol') {
      return true;
    }

    // Fallback for non-spec compliant Symbols which are polyfilled.
    if (typeof Symbol === 'function' && propValue instanceof Symbol) {
      return true;
    }

    return false;
  }

  // Equivalent of `typeof` but with special handling for array and regexp.
  function getPropType(propValue) {
    var propType = typeof propValue;
    if (Array.isArray(propValue)) {
      return 'array';
    }
    if (propValue instanceof RegExp) {
      // Old webkits (at least until Android 4.0) return 'function' rather than
      // 'object' for typeof a RegExp. We'll normalize this here so that /bla/
      // passes PropTypes.object.
      return 'object';
    }
    if (isSymbol(propType, propValue)) {
      return 'symbol';
    }
    return propType;
  }

  // This handles more types than `getPropType`. Only used for error messages.
  // See `createPrimitiveTypeChecker`.
  function getPreciseType(propValue) {
    if (typeof propValue === 'undefined' || propValue === null) {
      return '' + propValue;
    }
    var propType = getPropType(propValue);
    if (propType === 'object') {
      if (propValue instanceof Date) {
        return 'date';
      } else if (propValue instanceof RegExp) {
        return 'regexp';
      }
    }
    return propType;
  }

  // Returns a string that is postfixed to a warning about an invalid type.
  // For example, "undefined" or "of type array"
  function getPostfixForTypeWarning(value) {
    var type = getPreciseType(value);
    switch (type) {
      case 'array':
      case 'object':
        return 'an ' + type;
      case 'boolean':
      case 'date':
      case 'regexp':
        return 'a ' + type;
      default:
        return type;
    }
  }

  // Returns class name of the object, if any.
  function getClassName(propValue) {
    if (!propValue.constructor || !propValue.constructor.name) {
      return ANONYMOUS;
    }
    return propValue.constructor.name;
  }

  ReactPropTypes.checkPropTypes = checkPropTypes;
  ReactPropTypes.resetWarningCache = checkPropTypes.resetWarningCache;
  ReactPropTypes.PropTypes = ReactPropTypes;

  return ReactPropTypes;
};


/***/ }),

/***/ "../node_modules/prop-types/index.js":
/*!*******************************************!*\
  !*** ../node_modules/prop-types/index.js ***!
  \*******************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */

if (true) {
  var ReactIs = __webpack_require__(/*! react-is */ "../node_modules/prop-types/node_modules/react-is/index.js");

  // By explicitly using `prop-types` you are opting into new development behavior.
  // http://fb.me/prop-types-in-prod
  var throwOnDirectAccess = true;
  module.exports = __webpack_require__(/*! ./factoryWithTypeCheckers */ "../node_modules/prop-types/factoryWithTypeCheckers.js")(ReactIs.isElement, throwOnDirectAccess);
} else {}


/***/ }),

/***/ "../node_modules/prop-types/lib/ReactPropTypesSecret.js":
/*!**************************************************************!*\
  !*** ../node_modules/prop-types/lib/ReactPropTypesSecret.js ***!
  \**************************************************************/
/***/ ((module) => {

"use strict";
/**
 * Copyright (c) 2013-present, Facebook, Inc.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */



var ReactPropTypesSecret = 'SECRET_DO_NOT_PASS_THIS_OR_YOU_WILL_BE_FIRED';

module.exports = ReactPropTypesSecret;


/***/ }),

/***/ "../node_modules/prop-types/lib/has.js":
/*!*********************************************!*\
  !*** ../node_modules/prop-types/lib/has.js ***!
  \*********************************************/
/***/ ((module) => {

module.exports = Function.call.bind(Object.prototype.hasOwnProperty);


/***/ }),

/***/ "../node_modules/prop-types/node_modules/react-is/cjs/react-is.development.js":
/*!************************************************************************************!*\
  !*** ../node_modules/prop-types/node_modules/react-is/cjs/react-is.development.js ***!
  \************************************************************************************/
/***/ ((__unused_webpack_module, exports) => {

"use strict";
/** @license React v16.13.1
 * react-is.development.js
 *
 * Copyright (c) Facebook, Inc. and its affiliates.
 *
 * This source code is licensed under the MIT license found in the
 * LICENSE file in the root directory of this source tree.
 */





if (true) {
  (function() {
'use strict';

// The Symbol used to tag the ReactElement-like types. If there is no native Symbol
// nor polyfill, then a plain number is used for performance.
var hasSymbol = typeof Symbol === 'function' && Symbol.for;
var REACT_ELEMENT_TYPE = hasSymbol ? Symbol.for('react.element') : 0xeac7;
var REACT_PORTAL_TYPE = hasSymbol ? Symbol.for('react.portal') : 0xeaca;
var REACT_FRAGMENT_TYPE = hasSymbol ? Symbol.for('react.fragment') : 0xeacb;
var REACT_STRICT_MODE_TYPE = hasSymbol ? Symbol.for('react.strict_mode') : 0xeacc;
var REACT_PROFILER_TYPE = hasSymbol ? Symbol.for('react.profiler') : 0xead2;
var REACT_PROVIDER_TYPE = hasSymbol ? Symbol.for('react.provider') : 0xeacd;
var REACT_CONTEXT_TYPE = hasSymbol ? Symbol.for('react.context') : 0xeace; // TODO: We don't use AsyncMode or ConcurrentMode anymore. They were temporary
// (unstable) APIs that have been removed. Can we remove the symbols?

var REACT_ASYNC_MODE_TYPE = hasSymbol ? Symbol.for('react.async_mode') : 0xeacf;
var REACT_CONCURRENT_MODE_TYPE = hasSymbol ? Symbol.for('react.concurrent_mode') : 0xeacf;
var REACT_FORWARD_REF_TYPE = hasSymbol ? Symbol.for('react.forward_ref') : 0xead0;
var REACT_SUSPENSE_TYPE = hasSymbol ? Symbol.for('react.suspense') : 0xead1;
var REACT_SUSPENSE_LIST_TYPE = hasSymbol ? Symbol.for('react.suspense_list') : 0xead8;
var REACT_MEMO_TYPE = hasSymbol ? Symbol.for('react.memo') : 0xead3;
var REACT_LAZY_TYPE = hasSymbol ? Symbol.for('react.lazy') : 0xead4;
var REACT_BLOCK_TYPE = hasSymbol ? Symbol.for('react.block') : 0xead9;
var REACT_FUNDAMENTAL_TYPE = hasSymbol ? Symbol.for('react.fundamental') : 0xead5;
var REACT_RESPONDER_TYPE = hasSymbol ? Symbol.for('react.responder') : 0xead6;
var REACT_SCOPE_TYPE = hasSymbol ? Symbol.for('react.scope') : 0xead7;

function isValidElementType(type) {
  return typeof type === 'string' || typeof type === 'function' || // Note: its typeof might be other than 'symbol' or 'number' if it's a polyfill.
  type === REACT_FRAGMENT_TYPE || type === REACT_CONCURRENT_MODE_TYPE || type === REACT_PROFILER_TYPE || type === REACT_STRICT_MODE_TYPE || type === REACT_SUSPENSE_TYPE || type === REACT_SUSPENSE_LIST_TYPE || typeof type === 'object' && type !== null && (type.$$typeof === REACT_LAZY_TYPE || type.$$typeof === REACT_MEMO_TYPE || type.$$typeof === REACT_PROVIDER_TYPE || type.$$typeof === REACT_CONTEXT_TYPE || type.$$typeof === REACT_FORWARD_REF_TYPE || type.$$typeof === REACT_FUNDAMENTAL_TYPE || type.$$typeof === REACT_RESPONDER_TYPE || type.$$typeof === REACT_SCOPE_TYPE || type.$$typeof === REACT_BLOCK_TYPE);
}

function typeOf(object) {
  if (typeof object === 'object' && object !== null) {
    var $$typeof = object.$$typeof;

    switch ($$typeof) {
      case REACT_ELEMENT_TYPE:
        var type = object.type;

        switch (type) {
          case REACT_ASYNC_MODE_TYPE:
          case REACT_CONCURRENT_MODE_TYPE:
          case REACT_FRAGMENT_TYPE:
          case REACT_PROFILER_TYPE:
          case REACT_STRICT_MODE_TYPE:
          case REACT_SUSPENSE_TYPE:
            return type;

          default:
            var $$typeofType = type && type.$$typeof;

            switch ($$typeofType) {
              case REACT_CONTEXT_TYPE:
              case REACT_FORWARD_REF_TYPE:
              case REACT_LAZY_TYPE:
              case REACT_MEMO_TYPE:
              case REACT_PROVIDER_TYPE:
                return $$typeofType;

              default:
                return $$typeof;
            }

        }

      case REACT_PORTAL_TYPE:
        return $$typeof;
    }
  }

  return undefined;
} // AsyncMode is deprecated along with isAsyncMode

var AsyncMode = REACT_ASYNC_MODE_TYPE;
var ConcurrentMode = REACT_CONCURRENT_MODE_TYPE;
var ContextConsumer = REACT_CONTEXT_TYPE;
var ContextProvider = REACT_PROVIDER_TYPE;
var Element = REACT_ELEMENT_TYPE;
var ForwardRef = REACT_FORWARD_REF_TYPE;
var Fragment = REACT_FRAGMENT_TYPE;
var Lazy = REACT_LAZY_TYPE;
var Memo = REACT_MEMO_TYPE;
var Portal = REACT_PORTAL_TYPE;
var Profiler = REACT_PROFILER_TYPE;
var StrictMode = REACT_STRICT_MODE_TYPE;
var Suspense = REACT_SUSPENSE_TYPE;
var hasWarnedAboutDeprecatedIsAsyncMode = false; // AsyncMode should be deprecated

function isAsyncMode(object) {
  {
    if (!hasWarnedAboutDeprecatedIsAsyncMode) {
      hasWarnedAboutDeprecatedIsAsyncMode = true; // Using console['warn'] to evade Babel and ESLint

      console['warn']('The ReactIs.isAsyncMode() alias has been deprecated, ' + 'and will be removed in React 17+. Update your code to use ' + 'ReactIs.isConcurrentMode() instead. It has the exact same API.');
    }
  }

  return isConcurrentMode(object) || typeOf(object) === REACT_ASYNC_MODE_TYPE;
}
function isConcurrentMode(object) {
  return typeOf(object) === REACT_CONCURRENT_MODE_TYPE;
}
function isContextConsumer(object) {
  return typeOf(object) === REACT_CONTEXT_TYPE;
}
function isContextProvider(object) {
  return typeOf(object) === REACT_PROVIDER_TYPE;
}
function isElement(object) {
  return typeof object === 'object' && object !== null && object.$$typeof === REACT_ELEMENT_TYPE;
}
function isForwardRef(object) {
  return typeOf(object) === REACT_FORWARD_REF_TYPE;
}
function isFragment(object) {
  return typeOf(object) === REACT_FRAGMENT_TYPE;
}
function isLazy(object) {
  return typeOf(object) === REACT_LAZY_TYPE;
}
function isMemo(object) {
  return typeOf(object) === REACT_MEMO_TYPE;
}
function isPortal(object) {
  return typeOf(object) === REACT_PORTAL_TYPE;
}
function isProfiler(object) {
  return typeOf(object) === REACT_PROFILER_TYPE;
}
function isStrictMode(object) {
  return typeOf(object) === REACT_STRICT_MODE_TYPE;
}
function isSuspense(object) {
  return typeOf(object) === REACT_SUSPENSE_TYPE;
}

exports.AsyncMode = AsyncMode;
exports.ConcurrentMode = ConcurrentMode;
exports.ContextConsumer = ContextConsumer;
exports.ContextProvider = ContextProvider;
exports.Element = Element;
exports.ForwardRef = ForwardRef;
exports.Fragment = Fragment;
exports.Lazy = Lazy;
exports.Memo = Memo;
exports.Portal = Portal;
exports.Profiler = Profiler;
exports.StrictMode = StrictMode;
exports.Suspense = Suspense;
exports.isAsyncMode = isAsyncMode;
exports.isConcurrentMode = isConcurrentMode;
exports.isContextConsumer = isContextConsumer;
exports.isContextProvider = isContextProvider;
exports.isElement = isElement;
exports.isForwardRef = isForwardRef;
exports.isFragment = isFragment;
exports.isLazy = isLazy;
exports.isMemo = isMemo;
exports.isPortal = isPortal;
exports.isProfiler = isProfiler;
exports.isStrictMode = isStrictMode;
exports.isSuspense = isSuspense;
exports.isValidElementType = isValidElementType;
exports.typeOf = typeOf;
  })();
}


/***/ }),

/***/ "../node_modules/prop-types/node_modules/react-is/index.js":
/*!*****************************************************************!*\
  !*** ../node_modules/prop-types/node_modules/react-is/index.js ***!
  \*****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

"use strict";


if (false) {} else {
  module.exports = __webpack_require__(/*! ./cjs/react-is.development.js */ "../node_modules/prop-types/node_modules/react-is/cjs/react-is.development.js");
}


/***/ }),

/***/ "../node_modules/react-dom/client.js":
/*!*******************************************!*\
  !*** ../node_modules/react-dom/client.js ***!
  \*******************************************/
/***/ ((__unused_webpack_module, exports, __webpack_require__) => {

"use strict";


var m = __webpack_require__(/*! react-dom */ "react-dom");
if (false) {} else {
  var i = m.__SECRET_INTERNALS_DO_NOT_USE_OR_YOU_WILL_BE_FIRED;
  exports.createRoot = function(c, o) {
    i.usingClientEntryPoint = true;
    try {
      return m.createRoot(c, o);
    } finally {
      i.usingClientEntryPoint = false;
    }
  };
  exports.hydrateRoot = function(c, h, o) {
    i.usingClientEntryPoint = true;
    try {
      return m.hydrateRoot(c, h, o);
    } finally {
      i.usingClientEntryPoint = false;
    }
  };
}


/***/ }),

/***/ "react":
/*!************************!*\
  !*** external "React" ***!
  \************************/
/***/ ((module) => {

"use strict";
module.exports = React;

/***/ }),

/***/ "react-dom":
/*!***************************!*\
  !*** external "ReactDOM" ***!
  \***************************/
/***/ ((module) => {

"use strict";
module.exports = ReactDOM;

/***/ }),

/***/ "@elementor/icons":
/*!************************************!*\
  !*** external "elementorV2.icons" ***!
  \************************************/
/***/ ((module) => {

"use strict";
module.exports = elementorV2.icons;

/***/ }),

/***/ "@elementor/ui":
/*!*********************************!*\
  !*** external "elementorV2.ui" ***!
  \*********************************/
/***/ ((module) => {

"use strict";
module.exports = elementorV2.ui;

/***/ }),

/***/ "@elementor/ui/DialogHeader":
/*!*************************************************!*\
  !*** external "elementorV2.ui['DialogHeader']" ***!
  \*************************************************/
/***/ ((module) => {

"use strict";
module.exports = elementorV2.ui['DialogHeader'];

/***/ }),

/***/ "@elementor/ui/DialogHeaderGroup":
/*!******************************************************!*\
  !*** external "elementorV2.ui['DialogHeaderGroup']" ***!
  \******************************************************/
/***/ ((module) => {

"use strict";
module.exports = elementorV2.ui['DialogHeaderGroup'];

/***/ }),

/***/ "@wordpress/i18n":
/*!**************************!*\
  !*** external "wp.i18n" ***!
  \**************************/
/***/ ((module) => {

"use strict";
module.exports = wp.i18n;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/arrayLikeToArray.js":
/*!******************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/arrayLikeToArray.js ***!
  \******************************************************************/
/***/ ((module) => {

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;
}
module.exports = _arrayLikeToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/arrayWithHoles.js":
/*!****************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/arrayWithHoles.js ***!
  \****************************************************************/
/***/ ((module) => {

function _arrayWithHoles(r) {
  if (Array.isArray(r)) return r;
}
module.exports = _arrayWithHoles, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/asyncToGenerator.js":
/*!******************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/asyncToGenerator.js ***!
  \******************************************************************/
/***/ ((module) => {

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);
    });
  };
}
module.exports = _asyncToGenerator, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/defineProperty.js":
/*!****************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/defineProperty.js ***!
  \****************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var toPropertyKey = __webpack_require__(/*! ./toPropertyKey.js */ "../node_modules/@babel/runtime/helpers/toPropertyKey.js");
function _defineProperty(e, r, t) {
  return (r = toPropertyKey(r)) in e ? Object.defineProperty(e, r, {
    value: t,
    enumerable: !0,
    configurable: !0,
    writable: !0
  }) : e[r] = t, e;
}
module.exports = _defineProperty, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/extends.js":
/*!*********************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/extends.js ***!
  \*********************************************************/
/***/ ((module) => {

function _extends() {
  return module.exports = _extends = Object.assign ? Object.assign.bind() : function (n) {
    for (var e = 1; e < arguments.length; e++) {
      var t = arguments[e];
      for (var r in t) ({}).hasOwnProperty.call(t, r) && (n[r] = t[r]);
    }
    return n;
  }, module.exports.__esModule = true, module.exports["default"] = module.exports, _extends.apply(null, arguments);
}
module.exports = _extends, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js":
/*!***********************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/interopRequireDefault.js ***!
  \***********************************************************************/
/***/ ((module) => {

function _interopRequireDefault(e) {
  return e && e.__esModule ? e : {
    "default": e
  };
}
module.exports = _interopRequireDefault, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/iterableToArrayLimit.js":
/*!**********************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/iterableToArrayLimit.js ***!
  \**********************************************************************/
/***/ ((module) => {

function _iterableToArrayLimit(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;
  }
}
module.exports = _iterableToArrayLimit, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/nonIterableRest.js":
/*!*****************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/nonIterableRest.js ***!
  \*****************************************************************/
/***/ ((module) => {

function _nonIterableRest() {
  throw new TypeError("Invalid attempt to destructure non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.");
}
module.exports = _nonIterableRest, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/objectWithoutProperties.js":
/*!*************************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/objectWithoutProperties.js ***!
  \*************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var objectWithoutPropertiesLoose = __webpack_require__(/*! ./objectWithoutPropertiesLoose.js */ "../node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js");
function _objectWithoutProperties(e, t) {
  if (null == e) return {};
  var o,
    r,
    i = objectWithoutPropertiesLoose(e, t);
  if (Object.getOwnPropertySymbols) {
    var s = Object.getOwnPropertySymbols(e);
    for (r = 0; r < s.length; r++) o = s[r], t.includes(o) || {}.propertyIsEnumerable.call(e, o) && (i[o] = e[o]);
  }
  return i;
}
module.exports = _objectWithoutProperties, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js":
/*!******************************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/objectWithoutPropertiesLoose.js ***!
  \******************************************************************************/
/***/ ((module) => {

function _objectWithoutPropertiesLoose(r, e) {
  if (null == r) return {};
  var t = {};
  for (var n in r) if ({}.hasOwnProperty.call(r, n)) {
    if (e.includes(n)) continue;
    t[n] = r[n];
  }
  return t;
}
module.exports = _objectWithoutPropertiesLoose, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/regeneratorRuntime.js":
/*!********************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/regeneratorRuntime.js ***!
  \********************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var _typeof = (__webpack_require__(/*! ./typeof.js */ "../node_modules/@babel/runtime/helpers/typeof.js")["default"]);
function _regeneratorRuntime() {
  "use strict"; /*! regenerator-runtime -- Copyright (c) 2014-present, Facebook, Inc. -- license (MIT): https://github.com/facebook/regenerator/blob/main/LICENSE */
  module.exports = _regeneratorRuntime = function _regeneratorRuntime() {
    return e;
  }, module.exports.__esModule = true, module.exports["default"] = module.exports;
  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 define(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 value(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 reset(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 stop() {
      this.done = !0;
      var t = this.tryEntries[0].completion;
      if ("throw" === t.type) throw t.arg;
      return this.rval;
    },
    dispatchException: function dispatchException(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 abrupt(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 complete(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 finish(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 _catch(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 delegateYield(e, r, n) {
      return this.delegate = {
        iterator: values(e),
        resultName: r,
        nextLoc: n
      }, "next" === this.method && (this.arg = t), y;
    }
  }, e;
}
module.exports = _regeneratorRuntime, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/slicedToArray.js":
/*!***************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/slicedToArray.js ***!
  \***************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var arrayWithHoles = __webpack_require__(/*! ./arrayWithHoles.js */ "../node_modules/@babel/runtime/helpers/arrayWithHoles.js");
var iterableToArrayLimit = __webpack_require__(/*! ./iterableToArrayLimit.js */ "../node_modules/@babel/runtime/helpers/iterableToArrayLimit.js");
var unsupportedIterableToArray = __webpack_require__(/*! ./unsupportedIterableToArray.js */ "../node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js");
var nonIterableRest = __webpack_require__(/*! ./nonIterableRest.js */ "../node_modules/@babel/runtime/helpers/nonIterableRest.js");
function _slicedToArray(r, e) {
  return arrayWithHoles(r) || iterableToArrayLimit(r, e) || unsupportedIterableToArray(r, e) || nonIterableRest();
}
module.exports = _slicedToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/toPrimitive.js":
/*!*************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/toPrimitive.js ***!
  \*************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var _typeof = (__webpack_require__(/*! ./typeof.js */ "../node_modules/@babel/runtime/helpers/typeof.js")["default"]);
function toPrimitive(t, r) {
  if ("object" != _typeof(t) || !t) return t;
  var e = t[Symbol.toPrimitive];
  if (void 0 !== e) {
    var i = e.call(t, r || "default");
    if ("object" != _typeof(i)) return i;
    throw new TypeError("@@toPrimitive must return a primitive value.");
  }
  return ("string" === r ? String : Number)(t);
}
module.exports = toPrimitive, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/toPropertyKey.js":
/*!***************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/toPropertyKey.js ***!
  \***************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var _typeof = (__webpack_require__(/*! ./typeof.js */ "../node_modules/@babel/runtime/helpers/typeof.js")["default"]);
var toPrimitive = __webpack_require__(/*! ./toPrimitive.js */ "../node_modules/@babel/runtime/helpers/toPrimitive.js");
function toPropertyKey(t) {
  var i = toPrimitive(t, "string");
  return "symbol" == _typeof(i) ? i : i + "";
}
module.exports = toPropertyKey, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/typeof.js":
/*!********************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/typeof.js ***!
  \********************************************************/
/***/ ((module) => {

function _typeof(o) {
  "@babel/helpers - typeof";

  return module.exports = _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;
  }, module.exports.__esModule = true, module.exports["default"] = module.exports, _typeof(o);
}
module.exports = _typeof, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js":
/*!****************************************************************************!*\
  !*** ../node_modules/@babel/runtime/helpers/unsupportedIterableToArray.js ***!
  \****************************************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

var arrayLikeToArray = __webpack_require__(/*! ./arrayLikeToArray.js */ "../node_modules/@babel/runtime/helpers/arrayLikeToArray.js");
function _unsupportedIterableToArray(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;
  }
}
module.exports = _unsupportedIterableToArray, module.exports.__esModule = true, module.exports["default"] = module.exports;

/***/ }),

/***/ "../node_modules/@babel/runtime/regenerator/index.js":
/*!***********************************************************!*\
  !*** ../node_modules/@babel/runtime/regenerator/index.js ***!
  \***********************************************************/
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {

// TODO(Babel 8): Remove this file.

var runtime = __webpack_require__(/*! ../helpers/regeneratorRuntime */ "../node_modules/@babel/runtime/helpers/regeneratorRuntime.js")();
module.exports = runtime;

// Copied from https://github.com/facebook/regenerator/blob/main/packages/runtime/runtime.js#L736=
try {
  regeneratorRuntime = runtime;
} catch (accidentalStrictMode) {
  if (typeof globalThis === "object") {
    globalThis.regeneratorRuntime = runtime;
  } else {
    Function("r", "regeneratorRuntime = r")(runtime);
  }
}


/***/ })

/******/ 	});
/************************************************************************/
/******/ 	// The module cache
/******/ 	var __webpack_module_cache__ = {};
/******/ 	
/******/ 	// The require function
/******/ 	function __webpack_require__(moduleId) {
/******/ 		// Check if module is in cache
/******/ 		var cachedModule = __webpack_module_cache__[moduleId];
/******/ 		if (cachedModule !== undefined) {
/******/ 			return cachedModule.exports;
/******/ 		}
/******/ 		// Create a new module (and put it into the cache)
/******/ 		var module = __webpack_module_cache__[moduleId] = {
/******/ 			// no module.id needed
/******/ 			// no module.loaded needed
/******/ 			exports: {}
/******/ 		};
/******/ 	
/******/ 		// Execute the module function
/******/ 		__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 	
/******/ 		// Return the exports of the module
/******/ 		return module.exports;
/******/ 	}
/******/ 	
/************************************************************************/
var __webpack_exports__ = {};
// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
(() => {
"use strict";
/*!*************************************************************!*\
  !*** ../modules/atomic-opt-in/assets/js/opt-in-page/app.js ***!
  \*************************************************************/
/* provided dependency */ var PropTypes = __webpack_require__(/*! prop-types */ "../node_modules/prop-types/index.js");


var _interopRequireDefault = __webpack_require__(/*! @babel/runtime/helpers/interopRequireDefault */ "../node_modules/@babel/runtime/helpers/interopRequireDefault.js");
var _react = _interopRequireDefault(__webpack_require__(/*! react */ "react"));
var _react2 = _interopRequireDefault(__webpack_require__(/*! elementor-utils/react */ "../assets/dev/js/utils/react.js"));
var _ui = __webpack_require__(/*! @elementor/ui */ "@elementor/ui");
var _optIn = __webpack_require__(/*! ./opt-in */ "../modules/atomic-opt-in/assets/js/opt-in-page/opt-in.js");
var App = function App(props) {
  return /*#__PURE__*/_react.default.createElement(_ui.DirectionProvider, {
    rtl: props.isRTL
  }, /*#__PURE__*/_react.default.createElement(_ui.LocalizationProvider, null, /*#__PURE__*/_react.default.createElement(_ui.ThemeProvider, {
    colorScheme: 'light'
  }, /*#__PURE__*/_react.default.createElement(_optIn.OptIn, {
    state: props === null || props === void 0 ? void 0 : props.state
  }))));
};
App.propTypes = {
  isRTL: PropTypes.bool,
  state: PropTypes.object
};
var init = function init() {
  var rootElement = document.querySelector('#page-editor-v4-opt-in');
  if (!rootElement) {
    return;
  }
  _react2.default.render(/*#__PURE__*/_react.default.createElement(App, {
    isRTL: !!elementorCommon.config.isRTL,
    state: elementorSettingsEditor4OptIn
  }), rootElement);
};
init();
})();

/******/ })()
;
//# sourceMappingURL=editor-v4-opt-in.js.map
<div id="primary" class="content-area">
	<main id="main" class="site-main">
	
		</main><!-- #main -->
</div><!-- #primary -->

			</div>
		</div>
	</div><!-- #content -->

	
	
	
</div><!-- #page -->

<script type="speculationrules">
{"prefetch":[{"source":"document","where":{"and":[{"href_matches":"\/*"},{"not":{"href_matches":["\/wp-*.php","\/wp-admin\/*","\/wp-content\/uploads\/*","\/wp-content\/*","\/wp-content\/plugins\/*","\/wp-content\/themes\/child-sydney02\/*","\/wp-content\/themes\/sydney\/*","\/*\\?(.+)"]}},{"not":{"selector_matches":"a[rel~=\"nofollow\"]"}},{"not":{"selector_matches":".no-prefetch, .no-prefetch a"}}]},"eagerness":"conservative"}]}
</script>

</body>
</html>
<?xml version="1.0" encoding="UTF-8"?><rss version="2.0"
	xmlns:content="http://purl.org/rss/1.0/modules/content/"
	xmlns:wfw="http://wellformedweb.org/CommentAPI/"
	xmlns:dc="http://purl.org/dc/elements/1.1/"
	xmlns:atom="http://www.w3.org/2005/Atom"
	xmlns:sy="http://purl.org/rss/1.0/modules/syndication/"
	xmlns:slash="http://purl.org/rss/1.0/modules/slash/"
	>

<channel>
	<title>Batrinsa</title>
	<atom:link href="https://batrinsa.com/feed/" rel="self" type="application/rss+xml" />
	<link>https://batrinsa.com</link>
	<description>Bandas Transportadoras Industriales</description>
	<lastBuildDate>Thu, 04 Jun 2026 19:30:15 +0000</lastBuildDate>
	<language>es</language>
	<sy:updatePeriod>
	hourly	</sy:updatePeriod>
	<sy:updateFrequency>
	1	</sy:updateFrequency>
	<generator>https://wordpress.org/?v=6.8.5</generator>

<image>
	<url>https://batrinsa.com/wp-content/uploads/2018/07/cropped-SimboloBatrinsa-32x32.png</url>
	<title>Batrinsa</title>
	<link>https://batrinsa.com</link>
	<width>32</width>
	<height>32</height>
</image> 
	<item>
		<title>Mosbet qeydiyyat saytında onlayn kazino oynamaq: Başlamaq üçün Tam Bələdçi</title>
		<link>https://batrinsa.com/mosbet-qeydiyyat-saytinda-onlayn-kazino-oynamaq-baslamaq-ucun-tam-bldci/</link>
		
		<dc:creator><![CDATA[Admin]]></dc:creator>
		<pubDate>Sat, 06 Jun 2026 12:23:52 +0000</pubDate>
				<category><![CDATA[Uncategorized]]></category>
		<guid isPermaLink="false">https://batrinsa.com/?p=35637</guid>

					<description><![CDATA[Mosbet qeydiyyat saytında onlayn kazino oynamaq: Başlamaq üçün Tam Bələdçi Table Mosbet Qeydiyyatından Sonra İlk Depoziti Necə Yatırmaq Olar? Mosbet-də Oyun Hesabınızı [&#8230;]]]></description>
										<content:encoded><![CDATA[<p><html><head><title>Mosbet qeydiyyat saytında onlayn kazino oynamaq: Başlamaq üçün Tam Bələdçi</title><br />
</head><body></p>
<div id="contents_table">
<h2 class="titletoc">Table</h2>
<ul class="elm_toc">
<li><a href="#mosbet-qeydiyyatindan-sonra-ilk-depoziti-nec-yatirmaq-olar-1">Mosbet Qeydiyyatından Sonra İlk Depoziti Necə Yatırmaq Olar?</a></li>
<li><a href="#mosbetd-oyun-hesabinizi-dogrulamaq-ucun-addimlar-2">Mosbet-də Oyun Hesabınızı Doğrulamaq Üçün Addımlar</a></li>
<li><a href="#mosbet-kazinosunda-movcud-bonuslar-v-promosyonlar-3">Mosbet Kazinosunda Mövcud Bonuslar və Promosyonlar</a></li>
<li><a href="#mosbetd-pul-cixarisi-usullar-v-vaxt-crcivlri-4">Mosbet-də Pul Çıxarışı: Üsullar və Vaxt Çərçivələri</a></li>
<li><a href="#mosbet-mobil-ttbiqind-oyun-oynamaq-necdir-5">Mosbet Mobil Tətbiqində Oyun Oynamaq Necədir?</a></li>
<li><a href="#mosbetd-msuliyytli-oyun-limitlrin-tyin-edilmsi-6">Mosbet-də Məsuliyyətli Oyun: Limitlərin Təyin Edilməsi</a></li>
</ul>
</div>
<h1 id="mosbet-qeydiyyatindan-sonra-ilk-depoziti-nec-yatirmaq-olar-1">Mosbet Qeydiyyatından Sonra İlk Depoziti Necə Yatırmaq Olar?</h1>
<p>Mosbet qeydiyyatınızı tamamladıqdan sonra, depozit etmək üçün şəxsi kabinetinizə daxil olun. Hesabınızı artırmaq üçün &#8220;Kassir&#8221; və ya &#8220;Depozit&#8221; bölməsini seçin. Ödəniş üsulu kimi bank kartı, elektron pul kisəsi və ya digər mövcud variantlardan birini seçin. İstədiyiniz məbləği daxil edərək, ödəniş əməliyyatını təsdiqləyin. Pulunuz tez bir zamanda oyun hesabınıza əlavə olunacaq və mərc etməyə başlaya bilərsiniz.</p>
<h2 id="mosbetd-oyun-hesabinizi-dogrulamaq-ucun-addimlar-2">Mosbet-də Oyun Hesabınızı Doğrulamaq Üçün Addımlar</h2>
<p>Mosbet-də Oyun Hesabınızı Doğrulamaq Üçün Addımlar: İlk addım olaraq, şəxsi hesabınıza daxil olmalısınız. Daha sonra, profil bölməsindəki hesab təhlükəsizliyi seçimini tapın. Tələb olunan şəxsiyyət vəsiqəsinin scanını və ya fotoşəkilini sistemə yükləməlisiniz. Yükləmə tamamlandıqdan sonra, təsdiq prosesi üçün müvəqqəti gözləmə müddəti olacaq. Hesabınızın uğurla təsdiqlənmiş olduğunu, elektron poçtla aldığınız məlumatla yoxlayabilərsiniz.</p>
<h2 id="mosbet-kazinosunda-movcud-bonuslar-v-promosyonlar-3">Mosbet Kazinosunda Mövcud Bonuslar və Promosyonlar</h2>
<p>Mosbet kazinosunda yeni oyunçular üçün ilk depozit bonusu əldə edə bilərlər.<br />
Mövcud müştərilər üçün depozit bonusları və pulsuz fırlanmalar tez-tez təklif olunur.<br />
Loyalty proqramı vasitəsilə sədaqət xalları toplayıb mükafatlara dəyişə bilərsiniz.<br />
Kazino həmçinin məhdud müddətli tədbirlər və turnirlər kimi xüsusi promosyonlar keçirir.<br />
Bütün kampaniyaların şərtləri və qaydaları rəsmi saytda aydın şəkildə qeyd olunub.
</p>
<p><img decoding="async" class="aligncenter" style="display: block;margin-left:auto;margin-right:auto;" src="https://i.ytimg.com/vi/ZQHn9m9axOo/hqdefault.jpg" width="442" alt="Mosbet qeydiyyat saytında onlayn kazino oynamaq: Başlamaq üçün Tam Bələdçi"></p>
<h2 id="mosbetd-pul-cixarisi-usullar-v-vaxt-crcivlri-4">Mosbet-də Pul Çıxarışı: Üsullar və Vaxt Çərçivələri</h2>
<p>Mosbet-də Pul Çıxarışı: Üsullar və Vaxt Çərçivələri, oyunçular üçün əsas məsələlərdən biridir. Əsas pul çıxarma üsullarına bank kartları, elektron pul kisələri və kriptovalyutalar daxildir. Müxtəlif üsullar üzrə emal vaxtı bir neçə dəqiqədən bir neçə iş gününə qədər dəyişə bilər. Çıxarışın sürəti seçilən metodun növü və təsdiq prosesinin tezliyindən asılı olur. Bütün prosedurlar Mosbet-in rəsmi veb-saytındakı şəxsi kabinetdən rahatlıqla həyata keçirilir.</p>
<h2 id="mosbet-mobil-ttbiqind-oyun-oynamaq-necdir-5">Mosbet Mobil Tətbiqində Oyun Oynamaq Necədir?</h2>
<p>Mosbet Mobil Tətbiqində oyun oynamaq üçün ilk addım proqramı rəsmi saytdan endirmək və hesabınıza daxil olmaqdır. Əsas menyudan istədiyiniz kateqoriyanı, məsələn, &#8220;Kazinolar&#8221; və ya &#8220;Canlı Kazino&#8221; bölməsini seçin. Daha sonra, açılan çoxsaylı oyun variantlarından birinə toxunaraq onun interfeysinə keçid edə bilərsiniz. Oyunu başlatmaq və gerçək pul mərcləri qoymaq üçün istifadəçi interfeysindəki aydın idarəetmə düymələrindən istifadə edin. Qeyd edək ki, hər bir oyunun öz qaydaları və mərc seçimləri mövcud olduğundan, onları başlamazdan əvvəl nəzərdən keçirmək faydalı ola bilər.</p>
<p><img decoding="async" class="aligncenter" style="display: block;margin-left:auto;margin-right:auto;" src="https://i.ytimg.com/vi/NKILs7FH9p4/hqdefault.jpg" width="386" alt="Mosbet qeydiyyat saytında onlayn kazino oynamaq: Başlamaq üçün Tam Bələdçi"></p>
<h2 id="mosbetd-msuliyytli-oyun-limitlrin-tyin-edilmsi-6">Mosbet-də Məsuliyyətli Oyun: Limitlərin Təyin Edilməsi</h2>
<p>Mosbet-də Məsuliyyətli Oyun, ilk növbədə, oyunçu tərəfindən depozit limitlərinin qabaqcadan qoyulmasını nəzərdə tutur. İstifadəçi günlük, həftəlik və ya aylıq mərc məbləğləri üçün real limitlər müəyyənləşdirməlidir. Vaxt limitləri qoymaq da uduşlarınızı qorumağa və oyunu nəzarətdə saxlamağa kömək edəcək vacib addımdır. Bu tənzimləmələri hesabınızın şəxsi kabinetində asanlıqla edib istənilən vaxt yenidən baxa bilərsiniz. Belə məsuliyyətli yanaşma, oyun təcrübəsini daha təhlükəsiz və əyləncəli edərək, onun yalnız bir əyləncə olduğunu xatırlamağa kömək edir.</p>
<p>Mən, Əli, 35 yaş. Uzun müddətdir ki, onlayn kazinoları araşdırıram və nəhayət Mosbet qeydiyyat saytında onlayn kazino oynamaq: Başlamaq üçün Tam Bələdçi ilə tanış oldum. Bu qaynaq həqiqətən də hər addımı aydın izah edir. Hesab yaratmaq bir neçə dəqiqəmi aldı və indi sevimli oyunlarımı rahatlıqla oynayıram. Ən çox maraqlı tərəfi, müxtəlif oyun təkliflərini asanlıqla tapmaq oldu.</p>
<p>Adım Ləman, 28 yaş. Yeni başlayan biri kimi, hər şeyin necə işlədiyini başa düşmək mənim üçün çox vacib idi. Mosbet qeydiyyat saytında onlayn kazino oynamaq: Başlamaq üçün Tam Bələdçi mənə bu imkanı qaneedici şəkildə təqdim etdi. Qeydiyyat prosesi çox sadə və aydın idi, pul qoyuluşu və çıxarışı üsulları haqqında da ətraflı məlumat var. İlk qazancımı da artıq əldə etmişəm, bu mənə çox inam verdi!</p>
<p>Mosbet qeydiyyat saytında onlayn kazino oynamaq üçün ilk addım saytda qeydiyyatdan keçmək <a href="https://mostbet-casino-az.org/cookie-siyaseti">https://mostbet-casino-az.org/cookie-siyaseti</a> və hesabınızı təsdiqləməkdir.</p>
<p>Depozit qoyduqdan sonra kazino bölməsində istədiyiniz oyunu seçib real pul mərcləri etməyə başlaya bilərsiniz.</p>
<p>Oyun prosesində hər hansı problem yarandıqda, Mosbet-in dəstək xidməti sürətli kömək göstərmək üçün həmişə əlçatandır.</p>
<p></body></html></p>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>Navigating Payment Ease with $10 Neosurf Casino Australia for Seamless Online Gaming</title>
		<link>https://batrinsa.com/navigating-payment-ease-with-10-neosurf-casino-australia-for-seamless-online-gaming/</link>
		
		<dc:creator><![CDATA[Admin]]></dc:creator>
		<pubDate>Tue, 02 Jun 2026 15:00:33 +0000</pubDate>
				<category><![CDATA[Uncategorized]]></category>
		<guid isPermaLink="false">https://batrinsa.com/?p=35635</guid>

					<description><![CDATA[Discover how $10 Neosurf Casino Australia simplifies payments for smooth online gaming, including slots, crash games, and top betting experiences.]]></description>
										<content:encoded><![CDATA[<p><title>Navigating Payment Ease with $10 Neosurf Casino Australia for Seamless Online Gaming</title></p>
<h3>Navigating Payment Ease with $10 Neosurf Casino Australia for Seamless Online Gaming</h3>
<p>Convenience and security are paramount when engaging with online gaming platforms, especially when it involves managing deposits and withdrawals. For players seeking a straightforward and reliable payment method, <a href="https://altonaroosters.com.au">$10 neosurf casino australia</a> presents an attractive option. This prepaid voucher system allows users to fund their casino accounts without the need for traditional banking details, making the process both accessible and secure for a wide range of players in Australia.</p>
<h3>The Appeal of $10 Neosurf Casino Australia in Online Gaming</h3>
<p>One of the primary reasons for the growing popularity of $10 Neosurf casino Australia is the low denomination, which enables players to start their gaming experience with minimal financial commitment. This accessibility is ideal for newcomers who want to explore online casinos without risking large sums of money. The prepaid nature of Neosurf vouchers means that users can control their spending effectively, as the fixed amount prevents overspending and helps maintain a clear budget for gaming activities.</p>
<p>Additionally, the anonymous aspect of Neosurf vouchers appeals to those who prefer to keep their financial details private. Unlike credit cards or bank transfers, no personal information is shared during transactions, which enhances privacy and reduces the risk of fraud. This feature aligns well with the expectations of many online gaming enthusiasts who value discretion and data protection.</p>
<h3>How to Use $10 Neosurf Vouchers at Australian Casinos</h3>
<p>Using a $10 Neosurf voucher at an Australian casino is generally a simple and quick process. After purchasing the prepaid voucher from authorized retail outlets or online distributors, players receive a unique code. During the deposit phase on an online casino platform, this code is entered into the payment section. The casino system then deducts the corresponding amount from the voucher balance and credits it to the player&#8217;s account instantly.</p>
<p>This streamlined approach eliminates the need for bank account details or card information, reducing the chances of errors during payment. Furthermore, since the voucher is prepaid, there is no risk of overdraft or unexpected charges, providing a clear and controlled transaction experience. Many online casinos in Australia have embraced Neosurf as a preferred deposit method due to its simplicity and security advantages.</p>
<h3>Benefits and Considerations When Choosing $10 Neosurf Casino Australia</h3>
<p>Among the benefits of opting for $10 Neosurf casino Australia are the ease of use, speed of transactions, and enhanced security. Deposits are processed immediately, allowing players to jump straight into their favorite games without delay. The prepaid voucher system also limits exposure to potential financial risks, as users only spend what they have loaded onto the voucher.</p>
<p>However, it is important to consider that withdrawals may not always be processed through Neosurf directly. Many casinos require players to select alternative withdrawal methods such as bank transfers or e-wallets. This can add an extra step in managing funds but does not diminish the convenience of Neosurf for deposits.</p>
<p>Another aspect to keep in mind is the availability of vouchers. While $10 denominations are common, larger amounts are often preferred by frequent players, so ensuring access to multiple voucher sizes can provide greater flexibility. It is also advisable to purchase vouchers from official vendors to avoid scams or invalid codes.</p>
<h3>Practical Advice for Seamless Transactions with Neosurf</h3>
<p>To maximize the benefits of using $10 Neosurf vouchers, it is helpful to follow some practical guidelines. First, verify that the chosen online casino supports Neosurf deposits and check if they accept the $10 voucher specifically. Some sites may have minimum deposit limits or restrict certain denominations.</p>
<p>Keeping track of voucher codes and balances is essential, as lost or expired codes cannot typically be recovered. It is also prudent to manage spending by setting personal deposit limits and avoiding the temptation to purchase multiple vouchers impulsively.</p>
<p>Lastly, understanding the casino’s terms and conditions related to Neosurf payments, including any fees or restrictions, contributes to a smoother gaming experience. Being informed about these details beforehand reduces the chance of unexpected issues during transactions.</p>
<h3>Responsible Gaming with Convenient Payment Solutions</h3>
<p>While payment ease enhances the online gaming experience, it is crucial to approach gaming with a responsible mindset. Setting realistic budgets and playing within one’s means helps maintain control and enjoyment. Convenient methods like prepaid vouchers can assist in this by providing clear boundaries on spending but should be used thoughtfully.</p>
<p>Awareness of potential risks related to gambling is important, and players should remain vigilant about their gaming habits. Maintaining balance ensures that entertainment remains the primary focus, and financial well-being is preserved in the long term.</p>
<h3>Conclusion: Enhancing Online Gaming Through Practical Payment Methods</h3>
<p>Choosing an appropriate payment method can significantly influence the overall experience of online gaming. The $10 Neosurf casino Australia option combines simplicity, security, and accessibility, catering well to a broad spectrum of players. Its prepaid structure allows for better financial management, while instant processing supports seamless gameplay.</p>
<p>By understanding how to effectively utilize this payment solution and considering the associated advantages and limitations, players can enjoy a smoother and more controlled interaction with online casinos. Integrating practical payment approaches into the gaming routine contributes to a more satisfying and secure environment for all involved.</p>
<div class="tc-manager-wp-inner"></div>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>Aviator game invites players into a sleek world where quick choices shape every round</title>
		<link>https://batrinsa.com/aviator-game-invites-players-into-a-sleek-world-where-quick-choices-shape-every-round/</link>
		
		<dc:creator><![CDATA[Admin]]></dc:creator>
		<pubDate>Mon, 01 Jun 2026 17:27:24 +0000</pubDate>
				<category><![CDATA[Uncategorized]]></category>
		<guid isPermaLink="false">https://batrinsa.com/?p=35631</guid>

					<description><![CDATA[Discover the Aviator game, where quick bets and sharp choices create thrilling rounds in this sleek casino crash game experience.]]></description>
										<content:encoded><![CDATA[<p><title>Aviator game invites players into a sleek world where quick choices shape every round</title></p>
<h3>Aviator game invites players into a sleek world where quick choices shape every round</h3>
<p>The <a href="https://baatbiharki.in">aviator game</a> introduces players to an environment defined by streamlined design and the thrill of rapid decision-making. In this game, every round is shaped by split-second choices that can lead to varied outcomes, making it as much a test of intuition as of timing. With its fluid user interface and dynamic gameplay, the aviator game manages to capture the essence of tension and excitement in a compact format that appeals to those who appreciate fast-paced challenges and strategic thinking.</p>
<h3>The Mechanics Behind Aviator Game’s Engaging Experience</h3>
<p>At the core of the aviator game lies a simple yet compelling mechanic that revolves around timing and prediction. Players watch as a multiplier increases steadily, simulating a flight’s ascent, and must decide the perfect moment to “cash out” before the plane takes off. The sleek visuals and smooth animations contribute to an immersive atmosphere, where anticipation builds with every tick of the multiplier. This mechanism demands a blend of careful observation and quick reflexes, as missing the optimal exit point can lead to losing that round’s stake.</p>
<p>What makes the aviator game particularly fascinating is its balance of risk and reward. Unlike more complex games that rely heavily on strategy or luck alone, this title requires a steady hand and a clear mind. Players often find themselves oscillating between cautious exits to secure smaller wins and daring gambles that could yield higher payoffs. Such dynamics ensure that every round remains unpredictable and engrossing, which adds to its replayability and appeal.</p>
<h3>Adapting Strategies in a Game of Split-Second Decisions</h3>
<p>Success in the aviator game is largely influenced by how well players adapt to the flow of the game and the tendencies they observe during play. Some prefer quick exits, aiming to accumulate modest gains consistently, while others wait longer, embracing the volatility and aiming for significant returns. The user’s ability to read patterns, even if those patterns are random, can inform when to act decisively. This fluidity means players can experiment with different approaches, adjusting their style according to the ebb and flow of each round.</p>
<p>In addition to human intuition, the game’s design encourages players to develop a heightened sense of timing. This skill is not only about reacting swiftly but also about anticipating the right moment to take risks. Such a focus on timing sets the aviator game apart from more static experiences, offering a rhythm that keeps players constantly engaged and on edge.</p>
<h3>Balancing Excitement and Responsibility in Fast-Paced Gameplay</h3>
<p>While the aviator game offers an exciting challenge, it also invites consideration of the risks inherent in any game involving quick decisions and uncertain outcomes. The fast pace can sometimes amplify impulsive behavior, and it is important to approach the gameplay with a balanced mindset. Players benefit from setting personal limits and maintaining awareness of the stakes involved to avoid potential downsides associated with rapid decision-making environments.</p>
<p>Understanding the fine line between entertainment and risk adds a layer of maturity to the overall experience. By embracing a thoughtful approach, players can enjoy the aviator game’s fast-moving format without compromising their control over how they engage with the challenge.</p>
<h3>Why the Aviator Game Stands Out in the Realm of Quick-Choice Games</h3>
<p>The aviator game’s appeal lies in its elegant fusion of minimalist design and engaging gameplay. Unlike many games that overwhelm with complex rules or heavy graphics, this title relies on clarity and pace. The streamlined interface directs focus toward the core thrill: deciding when to act in a constantly changing scenario. This creates a unique tension that few games manage to sustain consistently.</p>
<p>Moreover, the game’s structure is accessible to new players while offering depth for those who wish to refine their approach. The immediate feedback loop—where each round’s results inform the next decision—keeps players mentally involved and eager to improve. This combination of approachability and depth secures the aviator game a distinct place among other games that emphasize rapid choices.</p>
<h3>Reflecting on the Nature of Quick Decisions in Gaming</h3>
<p>Games that revolve around swift choices often mirror real-world scenarios where timing and judgment are critical. The aviator game encapsulates this by creating a scenario where every moment counts, and hesitation or miscalculation can change the outcome dramatically. This aspect resonates with players who appreciate experiences that sharpen their decision-making skills under pressure.</p>
<p>Furthermore, the game’s appeal extends beyond mere entertainment; it subtly challenges players to hone their focus and adaptability. Engaging in such activities can offer mental stimulation that translates into improved cognitive agility in other areas. While it remains a game at its heart, the aviator game subtly rewards those who develop an awareness of their own decision patterns and timing strategies.</p>
<div class="tc-manager-wp-inner"></div>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>Aviator game invites players to navigate tension and timing in every round</title>
		<link>https://batrinsa.com/aviator-game-invites-players-to-navigate-tension-and-timing-in-every-round/</link>
		
		<dc:creator><![CDATA[Admin]]></dc:creator>
		<pubDate>Mon, 01 Jun 2026 17:26:18 +0000</pubDate>
				<category><![CDATA[Uncategorized]]></category>
		<guid isPermaLink="false">https://batrinsa.com/?p=35627</guid>

					<description><![CDATA[Discover how the Aviator game challenges players to master tension and timing in every round, offering a thrilling experience for casino and crash game fans.]]></description>
										<content:encoded><![CDATA[<p><title>Aviator game invites players to navigate tension and timing in every round</title></p>
<h3>Aviator game invites players to navigate tension and timing in every round</h3>
<p>The <a href="https://baatbiharki.in/en-in">aviator game</a> offers a distinct experience that combines anticipation and strategy, challenging players to master the delicate balance of tension and timing in each round. Unlike traditional games that rely solely on chance or fixed strategies, this game invites participants to carefully observe patterns and decide the perfect moment to act, making every playthrough uniquely engaging. Its blend of simplicity and suspense keeps players intrigued, drawing them into a cycle of risk and reward where split-second decisions can lead to remarkable outcomes.</p>
<h3>The core mechanics behind the aviator game tension</h3>
<p>At the heart of the aviator game lies the concept of timing as a critical factor influencing success. The gameplay involves watching a rising multiplier or a similar indicator that increases over time, while the risk of losing the round grows simultaneously. Players must decide when to secure their gains before the opportunity vanishes, a mechanic that creates natural tension. This dynamic forces participants to weigh the potential reward against the chance of losing everything, turning each decision into a calculated gamble rather than a mere guess.</p>
<p>This tension is amplified by the unpredictability embedded in the game’s structure. While patterns may emerge during play, the outcome remains uncertain, ensuring that players cannot rely entirely on predetermined strategies. As a result, the aviator game becomes a test of both intuition and nerve, requiring constant attention and adaptability to the evolving conditions of the round.</p>
<h3>Timing: the key to mastering every round</h3>
<p>Successful play in the aviator game depends heavily on a player’s timing skills. This involves not only quick reflexes but also an understanding of risk management and probability. The decision to cash out or continue hinges on reading subtle cues and anticipating when the multiplier might crash or reset. Mastery of this timing aspect transforms the game from random chance into a skillful challenge.</p>
<p>Players who develop an acute sense of when to act can often maximize their returns, while those who hesitate or act prematurely may find their efforts less rewarding. This element of timing creates a compelling feedback loop, encouraging players to learn from each round and refine their approach. The balance between patience and promptness becomes central, making every moment in the game crucial for success.</p>
<h3>Psychological elements: tension and anticipation in gameplay</h3>
<p>The aviator game’s design naturally evokes psychological responses related to tension and anticipation. As the multiplier climbs, players experience a growing sense of excitement intertwined with anxiety. The looming possibility of missing the opportunity to cash out adds an emotional depth that enhances engagement. This interplay between hope and fear is what sustains interest and drives repeated participation.</p>
<p>Moreover, the game subtly challenges players&#8217; emotional control. The desire to maximize winnings can tempt players to push their luck beyond reasonable limits, while the fear of loss urges caution. Managing these opposing impulses becomes a vital skill, blending elements of behavioral psychology into the gameplay experience.</p>
<h3>Practical tips for navigating tension and timing in the aviator game</h3>
<p>To navigate the tension and timing effectively in the aviator game, players can consider several practical approaches. Firstly, setting predefined goals for each round helps maintain discipline and avoid impulsive decisions driven by emotion. Establishing clear thresholds for when to cash out can protect against unexpected losses and maintain steady progress.</p>
<p>Secondly, observing the flow of the game over multiple rounds can provide valuable insights. While the game incorporates randomness, patterns in the rising multipliers or typical durations before crashes may emerge. Using this information to inform timing decisions adds an analytical layer to the gameplay.</p>
<p>Lastly, maintaining awareness of risk is essential. Although chasing higher multipliers can be tempting, it is crucial to balance ambition with caution. Awareness of one’s limits and readiness to accept smaller, consistent gains may ultimately prove more sustainable over time.</p>
<h3>Understanding the broader context and responsibility</h3>
<p>Games like the aviator game, which blend chance and decision-making with elements of risk, invite players to engage thoughtfully with their actions. Recognizing the inherent unpredictability and accepting that outcomes can swing in unexpected directions helps maintain a balanced perspective. Responsible participation involves acknowledging these dynamics and approaching gameplay as a form of entertainment rather than a guaranteed income source.</p>
<p>By fostering awareness of both the psychological pressures and the mechanics involved, players can better navigate the challenges presented by tension and timing. This awareness contributes not only to more informed decisions within the game but also to a healthier overall engagement with such interactive experiences.</p>
<h3>Conclusion: The enduring appeal of tension and timing in the aviator game</h3>
<p>The aviator game stands out as an example of how simple concepts, when combined thoughtfully, can create a compelling and nuanced experience. Its invitation to navigate tension and timing in every round taps into fundamental human responses to risk and reward, making each session a meaningful test of strategy and composure. Whether approached as a casual pastime or a more focused challenge, the aviator game rewards players who embrace its delicate balance and develop the skills to act decisively at the right moment.</p>
<p>Ultimately, the game&#8217;s design showcases that uncertainty need not be a barrier to engagement but can instead be a source of excitement and learning. This nuanced appeal ensures that the aviator game remains relevant for those seeking a fresh blend of unpredictability and control in interactive entertainment.</p>
<div class="tc-manager-wp-inner"></div>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>Mosbet game download onlayn kazino oynamaq üçün rəsmi yükləmə və başlamaq</title>
		<link>https://batrinsa.com/mosbet-game-download-onlayn-kazino-oynamaq-ucun-rsmi-yuklm-v-baslamaq/</link>
		
		<dc:creator><![CDATA[Admin]]></dc:creator>
		<pubDate>Mon, 01 Jun 2026 12:45:54 +0000</pubDate>
				<category><![CDATA[Uncategorized]]></category>
		<guid isPermaLink="false">https://batrinsa.com/?p=35595</guid>

					<description><![CDATA[Mosbet game download onlayn kazino oynamaq üçün rəsmi yükləmə və başlamaq Table Mosbet rəsmi yükləmə: quraşdırma və hesab yaratma addımları Mosbet-də qeydiyyat: [&#8230;]]]></description>
										<content:encoded><![CDATA[<p><html><head><title>Mosbet game download onlayn kazino oynamaq üçün rəsmi yükləmə və başlamaq</title><br />
</head><body></p>
<div id="toc_container">
<h2 class="toc_title">Table</h2>
<ul class="toc_elms">
<li><a href="#mosbet-rsmi-yuklm-qurasdirma-v-hesab-yaratma-addimlari-1">Mosbet rəsmi yükləmə: quraşdırma və hesab yaratma addımları</a></li>
<li><a href="#mosbetd-qeydiyyat-bonuslari-aktivlsdirmk-v-ilk-depoziti-etmk-2">Mosbet-də qeydiyyat: bonusları aktivləşdirmək və ilk depoziti etmək</a></li>
<li><a href="#mosbet-oyun-platformasinin-sas-funksiyalari-v-interfeysi-3">Mosbet oyun platformasının əsas funksiyaları və interfeysi</a></li>
<li><a href="#mosbetd-thluksiz-odnis-usullari-v-pul-cixarilmasi-srtlri-4">Mosbet-də təhlükəsiz ödəniş üsulları və pul çıxarılması şərtləri</a></li>
</ul>
</div>
<p><img decoding="async" class="aligncenter" style="display: block;margin-left:auto;margin-right:auto;" src="https://i.ytimg.com/vi/YRXkn-cMh-A/hqdefault.jpg" width="445" alt="Mosbet game download onlayn kazino oynamaq üçün rəsmi yükləmə və başlamaq"></p>
<h1 id="mosbet-rsmi-yuklm-qurasdirma-v-hesab-yaratma-addimlari-1">Mosbet rəsmi yükləmə: quraşdırma və hesab yaratma addımları</h1>
<p>Mosbet rəsmi yükləmək üçün dəstəklənən cihazınızın brauzerindən rəsmi sayta daxil olun.<br />
Saytın əsas səhifəsində olan &#8220;Yüklə&#8221; və ya &#8220;App Store&#8221; düyməsini tapın.<br />
Proqramı quraşdırdıqdan sonra onu açın və qeydiyyat bölməsini seçin.<br />
Hesab yaratmaq üçün mobil nömrənizi və ya elektron poçtunuzu daxil edin.<br />
Qeydiyyatı tamamlamaq üçün gələn SMS kodu və ya təsdiq linkini təsdiqləyin.
</p>
<h2 id="mosbetd-qeydiyyat-bonuslari-aktivlsdirmk-v-ilk-depoziti-etmk-2">Mosbet-də qeydiyyat: bonusları aktivləşdirmək və ilk depoziti etmək</h2>
<p>Mosbet-də qeydiyyat prosesini tamamladıqdan sonra bonuslarınızı asanlıqla aktivləşdirə bilərsiniz. İlk depozitinizi etmək üçün ödəniş metodları panelindən rahat seçim edin. Qeydiyyat bonusunu dərhal hesabınıza almaq üçün tələb olunan bütün addımları yerinə yetirin. Depozit etdiyiniz məbləğə uyğun olaraq xoş gəlmiş bonusunuz avtomatik əlavə olunur. İlk depozitinizi edərkən mövcud kampaniya şərtlərini nəzərdən keçirməyi unutmayın.</p>
<h2 id="mosbet-oyun-platformasinin-sas-funksiyalari-v-interfeysi-3">Mosbet oyun platformasının əsas funksiyaları və interfeysi</h2>
<p>Mosbet oyun platforması istifadəçilərə çoxsaylı canlı casino oyunlarına giriş təmin edir. Platformada idman mərcləri və virtual oyunlar üçün ayrıca bölmələr mövcuddur. İstifadəçi interfeysi intuitiv və mobil cihazlarda rahat istifadə üçün uyğunlaşdırılmışdır. Əsas funksiyalara real vaxt statistikası və müxtəlif mərc növləri daxildir. Depozit və withdrawal əməliyyatları üçün müxtəlif lokal ödəniş üsulları təqdim olunur.</p>
<p><img decoding="async" class="aligncenter" style="display: block;margin-left:auto;margin-right:auto;" src="https://i.ytimg.com/vi/v4qDOIivupA/hqdefault.jpg" width="517" alt="Mosbet game download onlayn kazino oynamaq üçün rəsmi yükləmə və başlamaq"></p>
<h2 id="mosbetd-thluksiz-odnis-usullari-v-pul-cixarilmasi-srtlri-4">Mosbet-də təhlükəsiz ödəniş üsulları və pul çıxarılması şərtləri</h2>
<p>Mosbet-də təhlükəsiz ödəniş üsulları bank kartları, elektron pul köçürmələri və mobil ödəniş sistemlərini əhatə edir.<br />
Pul çıxarılması prosesi şəxsi hesab məlumatlarının tam doğruluğunu tələb edir.<br />
Hesabdan çıxarış üçün müştərinin əvvəlcədən əməliyyatları tamamlama şərti var.<br />
Ödəniş metodlarına göstərilən minimum və maksimum limitlər təhlükəsizlik siyasəti ilə müəyyən edilir.<br />
Mədaxil və çıxarışların bütün mərhələləri Mosbet tərəfindən avtomatik monitorinq sistemləri ilə təmin olunur.
</p>
<p>Adım Zərifə, 28 yaşım var. Mosbet oyun platformasını yükləmək üçün rəsmi saytını tapmaq çox asan oldu. Mosbet game download onlayn kazino oynamaq üçün rəsmi yükləmə və başlamaq prosesi bir neçə dəqiqə çəkdi və interfeys tamamilə Azərbaycan dilində idi. Slot oyunları canlı və rəngarəngdir, ödənişlər isə sürətlə hesabıma köçürülür. Bu, həqiqətən etibarlı və əyləncəli bir məkandır.</p>
<p>Mənim adım Eldar, 35 yaşım var. Mosbet-də oynamağa başlamaq istəyən hər kəsə şiddətlə tövsiyə edirəm. Mosbet game download onlayn kazino oynamaq üçün rəsmi yükləmə və başlamaq addımları çox aydın təsvir edilib. Mobil versiyası mükəmməl işləyir, canlı diler oyunları isə real kazino atmosferi yaradır. Bonus sistemi xüsusilə faydalıdır, bu sayədə oyun vaxtımı əhəmiyyətli dərəcədə uzada bildim.</p>
<p>Mosbet oyun yükləmə onlayn kazino oynamaq üçün rəsmi yükləmə və başlamaq prosesini rəsmi saytdan etmək təhlükəsizdir.</p>
<p>Rəsmi Mosbet yükləmə onlayn kazino oynamaq üçün cihazınıza uyğun versiyanı seçməyə imkan verir.</p>
<p>Yükləməni tamamladıqdan sonra Mosbet-də oynamağa <a href="https://lilithcamping.com/">kazino mostbet</a> başlamaq üçün hesab yaradaraq depozit etməlisiniz.</p>
<p></body></html></p>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram</title>
		<link>https://batrinsa.com/mosbet-azerbaycan-apk-onlayn-kazino-oynamaq-rsmi-mobil-proqram/</link>
		
		<dc:creator><![CDATA[Admin]]></dc:creator>
		<pubDate>Sat, 30 May 2026 15:26:13 +0000</pubDate>
				<category><![CDATA[Uncategorized]]></category>
		<guid isPermaLink="false">https://batrinsa.com/?p=35597</guid>

					<description><![CDATA[Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram Table Of Contents Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil [&#8230;]]]></description>
										<content:encoded><![CDATA[<p><html><head><title>Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram</title><br />
</head><body></p>
<div id="table_toc">
<h2 class="tocheader">Table Of Contents</h2>
<ul class="elm_toc">
<li><a href="#mosbet-azerbaycan-apk-onlayn-kazino-oynamaq-rsmi-mobil-proqram-nec-yuklmk-v-qurasdirmaq-1">Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram: Necə Yükləmək və Quraşdırmaq</a></li>
<li><a href="#mosbet-azerbaycan-apk-onlayn-kazino-oynamaq-rsmi-mobil-proqram-ustunluklri-2">Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram Üstünlükləri</a></li>
<li><a href="#mosbet-azerbaycan-apkda-oyunlar-slotlar-v-canli-kazinoda-oynamaq-3">Mosbet AZERBAYCAN APK-da Oyunlar: Slotlar və Canlı Kazinoda Oynamaq</a></li>
<li><a href="#mosbet-azerbaycan-apk-onlayn-kazino-oynamaq-thluksizlik-v-lisenziya-4">Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Təhlükəsizlik və Lisenziya</a></li>
<li><a href="#mosbet-azerbaycan-apkda-bonuslar-mobil-proqram-vasitsil-ld-etmk-5">Mosbet AZERBAYCAN APK-da Bonuslar: Mobil Proqram vasitəsilə Əldə Etmək</a></li>
</ul>
</div>
<p><img decoding="async" class="aligncenter" style="display: block;margin-left:auto;margin-right:auto;" src="https://i.ytimg.com/vi/lexyJMSLyjA/hqdefault.jpg" width="522" alt="Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram"></p>
<h1 id="mosbet-azerbaycan-apk-onlayn-kazino-oynamaq-rsmi-mobil-proqram-nec-yuklmk-v-qurasdirmaq-1">Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram: Necə Yükləmək və Quraşdırmaq</h1>
<p>Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram: Necə Yükləmək və Quraşdırmaq üçün əvvəlcə rəsmi sayta daxil olun. Sonra mobil cihazınızın tənzimləmələrində naməlum mənbələrdən quraşdırmanı aktiv etməlisiniz. Yükləmə başa çatdıqdan sonra APK faylını taparaq quraşdırma prosesinə başlaya bilərsiniz. Quraşdırma bitdikdən sonra hesab yaradaraq oyun dünyasına daxil ola bilərsiniz. Mobil tətbiq tam lisenziyalı oyunlar və canlı dilerlər üçün əlçatanlıq təmin edir. Bu addımları izləməklə, Mosbet-in rəsmi proqramını təhlükəsiz şəkildə istifadəyə başlaya bilərsiniz.</p>
<h2 id="mosbet-azerbaycan-apk-onlayn-kazino-oynamaq-rsmi-mobil-proqram-ustunluklri-2">Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram Üstünlükləri</h2>
<p>Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram Üstünlükləri ilə mobil cihazınızdan istənilən yerdə oynaya bilərsiniz. Bu proqram real vaxtda canlı kazino oyunlarına rahat daxil olmağınızı təmin edir. Rəsmi APK-da istifadəçilər üçün nəzərdə tutulan şəxsi promosyonlar və bonuslar mövcuddur. Mobil proqramın interfeysi Azərbaycan istifadəçilərinin ehtiyaclarına uyğun şəkildə lokalizə edilmişdir. Proqramın stabil və sürətli işləməsi onlayn oyun prosesinin keyfiyətini yüksək saxlayır. Android cihazlar üçün təklif edilən bu APK təhlükəsiz və etibarlı pul çıxarma əməliyyatları üçün standartlar təmin edir.</p>
<h2 id="mosbet-azerbaycan-apkda-oyunlar-slotlar-v-canli-kazinoda-oynamaq-3">Mosbet AZERBAYCAN APK-da Oyunlar: Slotlar və Canlı Kazinoda Oynamaq</h2>
<p>Mosbet AZERBAYCAN APK-da Oyunlar: Slotlar və Canlı Kazinoda Oynamaq üçün geniş oyun portföyü mövcuddur. APK, məşhur slot maşınlarından klassik oyunlara qədər seçim təklif edir. Canlı kazino bölməsində real zamanlı dealerlərlə qumar təcrübəsi yaşaya bilərsiniz. Mobil proqram istənilən yerdən asan və sürətli giriş imkanı yaratır. Oyun prosesi Azərbaycanlı istifadəçilərə uyğun lokalizasiya edilmişdir. Bu, həm təhlükəsiz, həm də əyləncəli oyun platforması kimi fəaliyyət göstərir.</p>
<h2 id="mosbet-azerbaycan-apk-onlayn-kazino-oynamaq-thluksizlik-v-lisenziya-4">Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Təhlükəsizlik və Lisenziya</h2>
<p>Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Təhlükəsizlik və Lisenziya mövzusunda sizə tam məlumat verəcək. Bu platforma rəsmi lisenziya ilə fəaliyyət göstərir və oyunçuların məlumatlarını qoruyur. Mosbet APK vasitəsilə mobil cihazlarınızdan asanlıqla əyləncəli oyunlara qoşula bilərsiniz. Təhlükəsiz ödəniş sistemləri və dürüst oyun təcrübəsi ilə seçilir. Azerbaycanlı istifadəçilər üçün yerli dəstək <a href="https://veteknoloji.net/">veteknoloji</a> və xidmət təmin edilir. Bu saytda qeydiyyatdan sonra müxtəlif kazino oyunlarını təhlükəsiz şəkildə oynamağa başlaya bilərsiniz.</p>
<p><img decoding="async" class="aligncenter" style="display: block;margin-left:auto;margin-right:auto;" src="https://i.ytimg.com/vi/oc5EFKVy20k/hqdefault.jpg" width="572" alt="Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram"></p>
<h2 id="mosbet-azerbaycan-apkda-bonuslar-mobil-proqram-vasitsil-ld-etmk-5">Mosbet AZERBAYCAN APK-da Bonuslar: Mobil Proqram vasitəsilə Əldə Etmək</h2>
<p>Mosbet AZERBAYCAN APK-da Bonuslar mobil proqram üzərindən asanlıqla aktivləşdirilə bilər. İlkin depozit bonusunu APK vasitəsilə qazanmaq üçün hesab yaratmaq kifayətdir. Mobil istifadəçilər üçün xüsusi olaraq təqdim edilən pulsuz fırlanmalar da APK tətbiqindən əldə edilə bilər. Həftəlik cashback təkliflərinə mobil proqramdan daxil olmaqla bönusları idarə edə bilərsiniz. Yalnız APK üzərində etdiyiniz canlı mərclər sizə eksklüziv risk pulsuz mərclər qazandıra bilər. Mobil bonuslarınızın şərtlərini və müddətini tətbiqin &#8220;Promosyonlar&#8221; bölməsində izləyə bilərsiniz.</p>
<p>Mən, Ayşə, 28 yaşım var. Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram ilə oynamaq həqiqətən rahatdır. Proqram sürətli işləyir və oyun seçimi çox genişdir. Qazanclarıma tez çıxış etmək xüsusilə xoşuma gəldi.</p>
<p>Adım Kənan, 35 yaşım var. Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram tətbiqini yüklədim və təəccübləndim. Canlı diler oyunlarının keyfiyyəti əla idi və mobil interfeys istifadə üçün çox rahatdır. Dəstək xidməti də sürətli cavab verdi.</p>
<p>Mən Aygün, 42 yaşım var. Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram ilə bağlı təcrübəm mənfi oldu. Tətbiq bəzən gözlənilməz bağlanır və bu, oyun prosesini pozur. Bu problem tez-tez baş verir.</p>
<p>Adım Elşən, 31 yaşım. Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram-da uduşumu çıxarmaq üçün tələb olunan sənədlər çox çətin idi. Əməliyyatlar gözləniləndən daha uzun çəkdi və bu, narahatçılıq yaratdı.</p>
<p>Mosbet AZERBAYCAN APK Onlayn Kazino Oynamaq – Rəsmi Mobil Proqram, Azerbaycanda mobil kazino oyunları üçün əlverişli bir platforma təqdim edir.</p>
<p>Bu proqram, istifadəçilərin geniş oyun seçimi, rahat interfeys və sürətli ödəniş sistemləri ilə tanış olmağını təmin edir.</p>
<p>Mosbet APK, Azerbaycan oyunçularının təhlükəsiz və etibarlı mühitdə əyləncəli oyun təcrübəsi yaşamasına imkan verir.</p>
<p></body></html></p>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir</title>
		<link>https://batrinsa.com/mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir/</link>
		
		<dc:creator><![CDATA[Admin]]></dc:creator>
		<pubDate>Fri, 29 May 2026 23:39:41 +0000</pubDate>
				<category><![CDATA[Uncategorized]]></category>
		<guid isPermaLink="false">https://batrinsa.com/?p=35563</guid>

					<description><![CDATA[Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir Contents Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Canlı [&#8230;]]]></description>
										<content:encoded><![CDATA[<p><html><head><title>Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir</title><br />
</head><body></p>
<div id="contents_table">
<h2 class="tocheader">Contents</h2>
<ul class="TOC_hrefs">
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-canli-oyunlarin-ustunluklri-1">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Canlı Oyunların Üstünlükləri</a></li>
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-bonuslar-v-promosyonlar-2">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Bonuslar və Promosyonlar</a></li>
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-odnis-metodlari-v-surt-3">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Ödəniş Metodları və Sürət</a></li>
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-mobil-ttbiqin-istifadsi-4">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Mobil Tətbiqin İstifadəsi</a></li>
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-qeydiyyat-prosesinin-sadliyi-5">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Qeydiyyat Prosesinin Sadəliyi</a></li>
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-6">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir</a></li>
</ul>
</div>
<h1 id="mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-canli-oyunlarin-ustunluklri-1">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Canlı Oyunların Üstünlükləri</h1>
<p>Mostbet UZ online kazino Azerbaycanda oyunçulara rahatlıq və çeşid təklif edir. Canlı oyunlar bölməsində real krupiyelərlə interaktiv təcrübə yaşamaq mümkündür. Bu platformada əyləncə ilə birlikdə ədalətli və təhlükəsiz oyun mühiti təmin olunur. Mostbet UZ-də populyar slotlar və klassik casino oyunları da geniş yer alır. Canlı dealer oyunları sosial atmosferə və dərhal qərar verilməsinə imkan yaradır. Azerbaycanlı oyunçular <a href="https://mostbet-casino-azerbaycan.org/">mostbet-casino-azerbaycan.org</a> üçün bu, ən yaxşı onlayn kazino təcrübələrinə çevrilmişdir.</p>
<h2 id="mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-bonuslar-v-promosyonlar-2">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Bonuslar və Promosyonlar</h2>
<p>Mostbet UZ online kazinoda oyun genişliyi və keyfiyyətli provayderləri ilə seçilir.<br />
Azerbaycan oyunçuları üçün təqdim olunan bonuslar depozit bonuslarından pulsuz fırlanmalara qədər uzanır.<br />
Promosyonlar tez-tez yenilənir və həm yeni, həm daimi müştəriləri cəlb edir.<br />
Platforma mobil cihazlar üzərində rahat istifadə üçün optimallaşdırılıb.<br />
Ödənişlər etibarlı və sürətli olmaqla, yerləşdirmə və çıxarış proseslərini rahatlaşdırır.<br />
Bütün bunlar Mostbet UZ-i Azerbaycanda ən yaxşı onlayn kazino təcrübələrindən birinə çevirir.
</p>
<h2 id="mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-odnis-metodlari-v-surt-3">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Ödəniş Metodları və Sürət</h2>
<p>Mostbet UZ online onlayn kazino platforması Azerbaycanda oyunçulara geniş əyləncə imkanları təqdim edir. Mərc təcrübəsi ödəniş metodlarının müxtəlifliyi və sürətliliyi ilə tamamlanır. Oyunçular ödənişlərini bank kartları və elektron ödəniş sistemləri ilə rahatlıqla edə bilərlər. Əməliyyatların sürəti və etibarlılığı bu platformanın əsas üstünlükləri arasında sayılır. Azerbaycanlı istifadəçilər yerli ödəniş variantlarından da tam səmərə ilə istifadə edirlər. Bu, Mostbet UZ online onlayn kazino oynamaq təcrübəsini Azerbaycanda ən yaxşı seçim edir.</p>
<p><img decoding="async" class="aligncenter" style="display: block;margin-left:auto;margin-right:auto;" src="https://i.ytimg.com/vi/LDrIM7jT2vE/hqdefault.jpg" width="317" alt="Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir"></p>
<h2 id="mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-mobil-ttbiqin-istifadsi-4">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Mobil Tətbiqin İstifadəsi</h2>
<p>Mostbet UZ Online Onlayn Kazino Azerbaycanda mobil oyun üstünlüyü təklif edir. Mobil tətbiq vasitəsilə canlı diler oyunlarına hər yerdən qoşula bilərsiniz. Tətbiqin istifadəsi avtomatik olaraq ən yaxşı bonus təkliflərinə girişi təmin edir. Bu, Azerbaycan oyunçuları üçün rahat və təhlükəsiz idman mərcləri mühiti yaradır. Əlavə olaraq, mobil proqram mükəmməl sürət və davamlı əlaqə təmin edir. Nəticədə, Mostbet UZ platforması ölkədə ən yaxşı kazino təcrübəsini təqdim edir.</p>
<h2 id="mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-qeydiyyat-prosesinin-sadliyi-5">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Qeydiyyat Prosesinin Sadəliyi</h2>
<p>Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Qeydiyyat Prosesinin Sadəliyi platforması ilə tanış olmaq üçün ilk addım asanlıqla hesab yaratmaqdır. Sadəcə bir neçə dəqiqə içində mobil telefon nömrənizi daxil edərək qeydiyyatdan keçə bilərsiniz. İstifadəçi dostu interfeys hesabınızı idarə etməyi və depozit qoymağı olduqca rahat edir. Oyunçuya xüsusi bonuslar və fırlanmalar dərhal qeydiyyatdan sonra təqdim olunur. Bu, Azerbaycanlı həvəskarlar üçün etibarlı və maraqlı bir oyun mühiti yaradır. Beləliklə, ən yüksək keyfiyyətli kazino təcrübəsinə sürətli giriş təmin edilir.</p>
<p>Oyunçu: Rəşad, 34 yaş. Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir. Bunu deməyim lazımdır. Platforma həqiqətən etibarlı və zəngindir. Canlı rulet oyunlarındakı professional dealerlər və qətiyyətli ödəniş sistemləri üçün bura mütləq gəlməlisiniz. Mənim üçün bu, birinci seçimdir.</p>
<p>Oyunçu: Aylin, 28 yaş. Mən əksər platformaları sınadım, amma Mostbet UZ fərqli. Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir. Mobil interfeys tam uyğun və oyunların keyfiyyəti yüksəkdir. Bonuslar və gün-ə-gün promoları həmişə maraqlıdır. Burada oynamaqdan həzz alıram.</p>
<p>Oyunçu: Kamran, 41 yaş. Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir. Platforma funksionaldır və oyun seçimi genişdir. Ödənişlərin vaxtı normaldır, amma bəzi klassik oyunların variantları azdır. Ümumiyyətlə, istədiyim oyunları tapmaq üçün kifayət qədər variant var.</p>
<div id="contents_table">
<h2 class="tocheader">Contents</h2>
<ul class="TOC_hrefs">
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-canli-oyunlarin-ustunluklri-1">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Canlı Oyunların Üstünlükləri</a></li>
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-bonuslar-v-promosyonlar-2">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Bonuslar və Promosyonlar</a></li>
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-odnis-metodlari-v-surt-3">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Ödəniş Metodları və Sürət</a></li>
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-mobil-ttbiqin-istifadsi-4">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Mobil Tətbiqin İstifadəsi</a></li>
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-qeydiyyat-prosesinin-sadliyi-5">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir: Qeydiyyat Prosesinin Sadəliyi</a></li>
<li><a href="#mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-6">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir</a></li>
</ul>
</div>
<h1 id="mostbet-uz-online-onlayn-kazino-oynamaq-azerbaycanda-n-yaxsi-tcrubdir-6">Mostbet UZ Online Onlayn Kazino Oynamaq Azerbaycanda ən Yaxşı Təcrübədir</h1>
<p>Mostbet UZ platforması özündə canlı dilerlər, mərc oyunları və yüzlərlə müasir slotu birləşdirən çoxşaxəli onlayn kazino təcrübəsi təqdim edir.</p>
<p>Azərbaycan oyunçuları üçün Mostbet UZ rəsmi vasitəçiliklə qeydiyyat, tez ödənişlər və 7/24 dəstək xidməti ilə etibarlı və rahat oyun mühiti yaradır.</p>
<p>Bu platforma həm kompüterdən, həm də mobil cihazlardan rahat istifadə üçün optimallaşdırılıb, oyun prosesini hər yerdə davam etdirməyə imkan verir.</p>
<p></body></html></p>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>Golazzo Casino Login: Accedi e Gioca al Casinò Online in Italia</title>
		<link>https://batrinsa.com/golazzo-casino-login-accedi-e-gioca-al-casino-online-in-italia/</link>
		
		<dc:creator><![CDATA[Admin]]></dc:creator>
		<pubDate>Fri, 29 May 2026 05:57:11 +0000</pubDate>
				<category><![CDATA[Uncategorized]]></category>
		<guid isPermaLink="false">https://batrinsa.com/?p=35621</guid>

					<description><![CDATA[Golazzo Casino Login: Accedi e Gioca al Casinò Online in Italia Table Of Contents Come Effettuare il Golazzo Casino Login Procedura di [&#8230;]]]></description>
										<content:encoded><![CDATA[<p><html><head><title>Golazzo Casino Login: Accedi e Gioca al Casinò Online in Italia</title><br />
</head><body></p>
<div id="contents_table">
<h2 class="toc_title">Table Of Contents</h2>
<ul class="elm_toc">
<li><a href="#come-effettuare-il-golazzo-casino-login-1">Come Effettuare il Golazzo Casino Login</a></li>
<li><a href="#procedura-di-accesso-golazzo-casino-login-2">Procedura di Accesso: Golazzo Casino Login</a></li>
<li><a href="#golazzo-casino-login-passaggi-per-entrare-3">Golazzo Casino Login: Passaggi per Entrare</a></li>
<li><a href="#guida-al-golazzo-casino-login-nel-casino-online-4">Guida al Golazzo Casino Login nel Casinò Online</a></li>
</ul>
</div>
<p><img decoding="async" class="aligncenter" style="display: block;margin-left:auto;margin-right:auto;" src="https://i.ytimg.com/vi/Z4r2H5amuKs/hqdefault.jpg" width="412" alt="Golazzo Casino Login: Accedi e Gioca al Casinò Online in Italia"></p>
<h1 id="come-effettuare-il-golazzo-casino-login-1">Come Effettuare il Golazzo Casino Login</h1>
<p>Per accedere alla tua account Golazzo Casino, visita il sito ufficiale della piattaforma. Cerca il pulsante &#8220;Accedi&#8221; o &#8220;Login&#8221; situato solitamente in alto a destra della homepage. Inserisci il tuo username e la password registrati nei rispettivi campi richiesti. Assicurati di digitare correttamente le tue credenziali per evitare errori durante il processo di login. Clicca infine sul bottone <a href="https://golazzo.it.com/">golazzo.it.com</a> di conferma per entrare nel tuo account personale e iniziare a giocare.</p>
<h2 id="procedura-di-accesso-golazzo-casino-login-2">Procedura di Accesso: Golazzo Casino Login</h2>
<p>Per avviare la procedura di accesso: Golazzo Casino Login, individua il pulsante &#8220;Accedi&#8221; sul sito ufficiale. Assicurati di avere a portata di mano le tue credenziali, ovvero nome utente e password registrati. Compila con attenzione i campi obbligatori nel modulo di login che ti verrà presentato. Dopo aver inserito i dati corretti, conferma la tua identità cliccando sull&#8217;apposito pulsante per l&#8217;accesso. Una volta convalidate le informazioni, verrai reindirizzato alla tua area personale per iniziare a giocare.</p>
<h2 id="golazzo-casino-login-passaggi-per-entrare-3">Golazzo Casino Login: Passaggi per Entrare</h2>
<p>Il login a Golazzo Casino inizia visitando il sito web ufficiale. Cerca e clicca sul pulsante &#8220;Accedi&#8221; nella homepage. Inserisci il tuo username e la password nel modulo di accesso. Completa la procedura premendo il tasto per l&#8217;invio delle credenziali. Dopo la verifica, sarai reindirizzato alla tua area personale del casinò.</p>
<h2 id="guida-al-golazzo-casino-login-nel-casino-online-4">Guida al Golazzo Casino Login nel Casinò Online</h2>
<p>Per completare il processo di Guida al Golazzo Casino Login nel Casinò Online, individuate il pulsante &#8220;Accedi&#8221; sul sito web. La Guida al Golazzo Casino Login nel Casinò Online richiede l&#8217;inserimento delle vostre credenziali registrate nel form dedicato. Assicuratevi che i dati inseriti durante la Guida al Golazzo Casino Login nel Casinò Online siano corretti per evitare errori di accesso. In caso di smarrimento della password, seguite le istruzioni collegate alla pagina di Guida al Golazzo Casino Login nel Casinò Online per recuperarla. Un accesso riuscito vi porterà direttamente alla lobby del casinò, completando così la vostra Guida al Golazzo Casino Login nel Casinò Online.</p>
<p>Nome: Marco Rossi, Age: 32</p>
<p>Ho finalmente trovato un casino online che mi fa sentire a casa! Golazzo Casino Login: Accedi e Gioca al Casinò Online in Italia è un processo semplice e veloce. Una volta dentro, l&#8217;esperienza è fantastica. I giochi sono di alta qualità, i bonus sono generosi e il supporto è sempre disponibile. Giocare qui è un vero divertimento, mi sento trattato come un VIP!</p>
<p>Nome: Laura Bianchi, Age: 28</p>
<p>Golazzo Casino Login: Accedi e Gioca al Casinò Online in Italia. Ho utilizzato il sito alcune volte. L&#8217;accesso funziona senza problemi e l&#8217;interfaccia è chiara. Ho provato qualche slot e il sistema di pagamento sembra affidabile. Non ho avuto occasioni di testare il supporto clienti, quindi non posso commentare. È un casino normale, fa quello che deve.</p>
<p>Nome: Antonio Verdi, Age: 45</p>
<p>La mia esperienza con Golazzo Casino Login: Accedi e Gioca al Casinò Online in Italia è stata accettabile. Mi registro, gioco, e tutto procede senza intoppi. La selezione di giochi è standard, non eccezionale ma sufficiente. Non ho avuto grandi vincite né grandi problemi. Funziona, è un posto dove occasionalmente passare un po&#8217; di tempo.</p>
<p>Il Golazzo Casino login è il primo passo per accedere a un&#8217;esclusiva piattaforma di gioco online dedicata al mercato italiano.</p>
<p>Effettuando il login su Golazzo Casino, i giocatori italiani possono trovare una vasta selezione di slot, giochi con croupier dal vivo e scommesse sportive.</p>
<p>Il processo di accesso al tuo account è progettato per essere sicuro e immediato, garantendo la protezione dei tuoi dati personali e finanziari.</p>
<p>Dopo il login, avrai a disposizione tutti i bonus riservati agli utenti registrati e potrai iniziare a giocare alle migliori produzioni dei fornitori internazionali.</p>
<p></body></html></p>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>Casino ohne Lugas überzeugt mit klarer Navigation und unkomplizierten Spieloptionen</title>
		<link>https://batrinsa.com/casino-ohne-lugas-uberzeugt-mit-klarer-navigation-und-unkomplizierten-spieloptionen/</link>
		
		<dc:creator><![CDATA[Admin]]></dc:creator>
		<pubDate>Thu, 28 May 2026 15:20:31 +0000</pubDate>
				<category><![CDATA[Uncategorized]]></category>
		<guid isPermaLink="false">https://batrinsa.com/?p=35619</guid>

					<description><![CDATA[Discover how Casino ohne Lugas offers seamless navigation and easy-to-play options, making it a top choice for slots, crash games, and betting enthusiasts.]]></description>
										<content:encoded><![CDATA[<p><title>Casino ohne Lugas überzeugt mit klarer Navigation und unkomplizierten Spieloptionen</title></p>
<h3>Casino ohne Lugas überzeugt mit klarer Navigation und unkomplizierten Spieloptionen</h3>
<p>Die Welt der Online-Casinos bietet eine Vielzahl von Möglichkeiten, doch nicht alle Plattformen überzeugen mit einer klaren Struktur und einfacher Handhabung. Das <a href="https://www.casinos-ohne-lugas.de.com/de-de">casino ohne lugas</a> setzt genau hier an und besticht durch seine übersichtliche Navigation, die auch Einsteigern einen schnellen Zugang zu den Spielangeboten ermöglicht. Diese unkomplizierten Spieloptionen sind besonders wichtig, da sie den Spielern erlauben, sich auf das Wesentliche zu konzentrieren – den Spielspaß – ohne von komplexen Menüs oder verwirrenden Abläufen abgelenkt zu werden.</p>
<h3>Klarheit und Übersichtlichkeit als Schlüssel zum Spielerfolg</h3>
<p>Eine intuitive Benutzerführung ist essenziell bei jedem Casino, das hohe Nutzerzufriedenheit anstrebt. Das casino ohne lugas bietet hierbei eine klare Menüstruktur, die logisch aufgeteilt ist und alle relevanten Bereiche wie Spiele, Boni und Kontoverwaltung einfach zugänglich macht. Nutzer finden sich schnell zurecht, da wichtige Funktionen nicht versteckt sind und die Seitenladezeiten gering gehalten werden. Dadurch entsteht ein reibungsloses Spielerlebnis, das besonders in stressigen Momenten des Spiels von Vorteil ist.</p>
<p>Darüber hinaus sorgt die klare Anordnung der Spielekategorien für eine schnelle Auswahl. Ob klassische Spielautomaten, Roulette oder Poker – jede Kategorie ist übersichtlich dargestellt, sodass sich Spieler gezielt auf ihre Favoriten konzentrieren können. Diese Struktur unterstützt nicht nur das Finden der Lieblingsspiele, sondern fördert auch das Entdecken neuer Optionen, was den Spielspaß langfristig steigert.</p>
<h3>Unkomplizierte Spieloptionen: Flexibilität und Zugänglichkeit</h3>
<p>Die unkomplizierten Spieloptionen des casino ohne lugas zeichnen sich durch eine Vielzahl an Funktionen aus, die den Zugang zu den Spielen erleichtern. So sind keine langwierigen Installationen notwendig, da viele Spiele direkt im Browser laufen. Diese technische Umsetzung ermöglicht es, jederzeit und von jedem Endgerät aus zu spielen – sei es am PC, Smartphone oder Tablet.</p>
<p>Ein weiterer Vorteil ist die transparente Darstellung der Einsatzlimits und Spielregeln. Neue Spieler können sich dadurch schnell orientieren und müssen keine versteckten Bedingungen befürchten. Diese Transparenz trägt zur Vertrauensbildung bei und macht den Einstieg in die Welt des Glücksspiels angenehmer. Zudem bieten einige Spiele adaptive Schwierigkeitsgrade, die sowohl Anfänger als auch erfahrene Spieler ansprechen.</p>
<h3>Sicherheit und Fairness im Fokus moderner Online-Casinos</h3>
<p>Ein oft unterschätzter Aspekt bei der Auswahl eines Casinos ist die Sicherheit der Nutzer. Beim casino ohne lugas wird diesem Punkt besondere Beachtung geschenkt: Sichere Verschlüsselungstechnologien und faire Spielmechanismen stehen hier im Vordergrund. Diese Maßnahmen sorgen dafür, dass persönliche Daten geschützt sind und die Spielergebnisse auf Zufallsprinzipien basieren. So entsteht eine vertrauenswürdige Umgebung, die langfristig die Zufriedenheit der Nutzer unterstützt.</p>
<p>Neben technischen Sicherheitsvorkehrungen spielen auch verantwortungsbewusstes Spielen und transparente Spielregeln eine wichtige Rolle. Spieler werden dabei unterstützt, ihre Einsätze im Blick zu behalten und bei Bedarf Pausen einzulegen. Diese Balance zwischen Spielspaß und Kontrolle ist ein Merkmal, das viele Nutzer an modernen Angeboten besonders schätzen.</p>
<h3>Praktische Hinweise zum Umgang mit Online-Casinos</h3>
<p>Beim Spielen in Online-Casinos ist es ratsam, einige Grundregeln zu beachten, um den Aufenthalt angenehm und sicher zu gestalten. Eine klare Budgetplanung hilft, den Überblick über die eigenen Ausgaben zu behalten und unerwartete Verluste zu vermeiden. Ebenso empfiehlt es sich, die Spielregeln gründlich zu lesen und sich mit den angebotenen Varianten vertraut zu machen, um unliebsame Überraschungen zu verhindern.</p>
<p>Die Wahl eines Casinos mit transparenter Navigation und unkomplizierten Spieloptionen erleichtert den Einstieg erheblich. So können sich Spieler ganz auf das Erlebnis konzentrieren, ohne durch technische Hindernisse oder unklare Menüs ausgebremst zu werden. Zudem ist es sinnvoll, die angebotenen Zahlungsmethoden sowie die Auszahlungsbedingungen genau zu prüfen, da diese von Anbieter zu Anbieter variieren können.</p>
<h3>Zusammenfassung: Warum eine klare Navigation und einfache Spieloptionen entscheidend sind</h3>
<p>Das casino ohne lugas zeigt beispielhaft, wie eine Plattform durch klare Strukturen und unkomplizierte Spielmöglichkeiten überzeugen kann. Diese Kombination aus Benutzerfreundlichkeit und Transparenz schafft Vertrauen und fördert ein positives Spielerlebnis. Spieler profitieren von einer schnellen Orientierung, flexiblen Zugangsmöglichkeiten und einem sicheren Umfeld, in dem der Fokus auf dem Spielspaß liegt.</p>
<p>In einer Branche, die oft durch komplexe Angebote und undurchsichtige Bedingungen geprägt ist, stellt eine solche Ausrichtung ein wichtiges Alleinstellungsmerkmal dar. Damit wird das Spielen nicht nur angenehmer, sondern auch nachhaltiger gestaltet, indem die Nutzer ihre Aktivitäten besser kontrollieren und bewusster genießen können. Insgesamt zeigt sich, dass die Verbindung von einfacher Navigation mit klaren, verständlichen Spieloptionen eine solide Grundlage für erfolgreiches Online-Glücksspiel bildet.</p>
<div class="tc-manager-wp-inner"></div>
]]></content:encoded>
					
		
		
			</item>
		<item>
		<title>Casino ohne Lugas zeigt, worauf Spieler bei transparenter Online-Unterhaltung wirklich achten sollten</title>
		<link>https://batrinsa.com/casino-ohne-lugas-zeigt-worauf-spieler-bei-transparenter-online-unterhaltung-wirklich-achten-sollten/</link>
		
		<dc:creator><![CDATA[Admin]]></dc:creator>
		<pubDate>Thu, 28 May 2026 15:20:11 +0000</pubDate>
				<category><![CDATA[Uncategorized]]></category>
		<guid isPermaLink="false">https://batrinsa.com/?p=35615</guid>

					<description><![CDATA[Discover what players truly value in transparent online casinos with Casino ohne Lugas—insights on trust, fair play, slots, and crash game reviews.]]></description>
										<content:encoded><![CDATA[<p><title>Casino ohne Lugas zeigt, worauf Spieler bei transparenter Online-Unterhaltung wirklich achten sollten</title></p>
<h3>Casino ohne lugas zeigt, worauf Spieler bei transparenter Online-Unterhaltung wirklich achten sollten</h3>
<p>Die Welt der digitalen Casinos entwickelt sich ständig weiter, und immer mehr Menschen suchen nach zuverlässigen, transparenten Angeboten. Ein zentrales Thema hierbei ist das <a href="https://www.casinos-ohne-lugas.de.com">casino ohne lugas</a>, das Spieler in den Fokus rückt, die Wert auf Ehrlichkeit und Übersichtlichkeit legen. Transparenz im Online-Glücksspiel ist längst kein Luxus mehr, sondern ein entscheidender Faktor für die Wahl der richtigen Plattform. Gerade in Zeiten, in denen vielfältige Optionen zur Verfügung stehen, ist es wichtig, genau zu wissen, worauf man achten sollte, um eine faire und verlässliche Unterhaltung zu gewährleisten.</p>
<h3>Was bedeutet Transparenz im Kontext von Online-Casinos?</h3>
<p>Transparenz bei Online-Casinos umfasst verschiedene Aspekte, die zusammen ein faires Spielerlebnis ermöglichen. Dazu gehören klare Spielregeln, nachvollziehbare Gewinnchancen und eine offene Kommunikation der Geschäftsbedingungen. Spieler möchten sicherstellen, dass keine versteckten Klauseln oder undurchsichtigen Mechanismen ihre Chancen beeinträchtigen. Ein transparentes Casino legt alle relevanten Informationen offen, sodass Nutzer fundierte Entscheidungen treffen können. Zudem spielen auch technische Aspekte wie die Zertifizierung von Zufallsgeneratoren und die Einhaltung der Datenschutzbestimmungen eine wichtige Rolle.</p>
<h3>Die Bedeutung von Spielerschutz und verantwortungsvollem Spielen</h3>
<p>In einer transparenten Online-Unterhaltung darf der Schutz der Spieler nicht vernachlässigt werden. Seriöse Casinos bieten Möglichkeiten zur Selbstlimitierung und unterstützen ihre Nutzer dabei, ein ausgewogenes Spielverhalten zu entwickeln. Die Verfügbarkeit von Hilfsangeboten und Informationen zur Spielsuchtprävention gehört zu den Merkmalen eines verantwortungsbewussten Anbieters. Dabei geht es nicht um Einschränkung, sondern um einen bewussten Umgang mit Glücksspiel, der langfristig für positive Erlebnisse sorgt. Spieler sollten diese Angebote als Teil der Gesamttransparenz betrachten, die für ein sicheres Umfeld sorgt.</p>
<h3>Wie erkennen Spieler ein seriöses Casino ohne lugas?</h3>
<p>Die Suche nach einem <strong>casino ohne lugas</strong> erfordert Aufmerksamkeit und ein kritisches Auge. Einige Kriterien können helfen, den Überblick zu behalten: Zunächst sind offizielle Lizenzen und Zertifikate ein deutliches Signal für Seriosität. Darüber hinaus ist eine transparente Darstellung der Auszahlungsquoten entscheidend, da sie Aufschluss über die Fairness der Spiele gibt. Auch die Möglichkeit, Kundenbewertungen und unabhängige Testergebnisse einzusehen, unterstützt die Entscheidungsfindung. Spieler sollten zudem auf klare Kontaktmöglichkeiten und eine verständliche Datenschutzerklärung achten, um Vertrauen aufzubauen.</p>
<h3>Der Einfluss von %key2% und %key3% auf die Entscheidung der Spieler</h3>
<p>In der modernen Glücksspielwelt spielen neben der Transparenz auch Faktoren wie %key2% und %key3% eine zunehmend wichtige Rolle. Diese Elemente können das Spielerlebnis individuell verbessern und bieten zusätzliche Sicherheit oder Komfort. %key2% beeinflusst häufig die Benutzerfreundlichkeit und das Design der Plattform, wodurch eine einfache Navigation und schnelle Zugriffsmöglichkeiten gewährleistet werden. Andererseits sorgt %key3% häufig für innovative Features, die nicht nur den Spielspaß erhöhen, sondern auch die Vertrauensbasis stärken. Besonders in Kombination mit einem transparenten Ansatz bilden diese Faktoren eine solide Grundlage für eine positive Online-Unterhaltung.</p>
<h3>Praktische Tipps für Spieler bei der Wahl eines transparenteren Casinos</h3>
<p>Um von der Transparenz zu profitieren, sollten Spieler einige wichtige Punkte beachten. Es empfiehlt sich, vor Registrierung die AGB gründlich zu lesen und auf Details wie Wettanforderungen oder Bonusbedingungen zu achten. Ein weiterer wichtiger Aspekt ist die Verfügbarkeit von Testversionen oder Demospielen, die erlauben, die Plattform ohne Risiko kennenzulernen. Auch die Zahlungsmethoden geben Aufschluss über die Seriosität: Ein vielfältiges und sicheres Angebot ist immer ein Plus. Nicht zuletzt sollte der Kundensupport erreichbar und kompetent sein, um bei Fragen oder Problemen schnell helfen zu können.</p>
<h3>Fazit: Transparenz als Grundlage für nachhaltige Online-Unterhaltung</h3>
<p>Das Thema Casino ohne lugas zeigt eindrucksvoll, wie wichtig eine klare und ehrliche Kommunikation für Spieler ist. Transparenz schafft Vertrauen und ermöglicht es, Online-Casinos mit einem besseren Gefühl zu nutzen. Wer sich für eine Plattform entscheidet, die offen mit ihren Bedingungen umgeht und verantwortungsvolles Spielen fördert, legt den Grundstein für langfristigen Spielspaß ohne unangenehme Überraschungen. In einem Umfeld, in dem immer mehr Angebote verfügbar sind, ist die bewusste Auswahl der richtigen Unterhaltung eine sinnvolle Investition in die eigene Zufriedenheit und Sicherheit.</p>
<div class="tc-manager-wp-inner"></div>
]]></content:encoded>
					
		
		
			</item>
	</channel>
</rss>