Greasy Fork

// ==UserScript==
// @name                'Doublesplit - 999999 in 1
// @name:ru             'Doublesplit - 999999 в 1
// @name:uk             'Doublesplit - 999999 в 1
// @name:ja             'デルタ - 999999 イン 1
// @name:es             'Doublesplit - 999999 en 1
// @name:zh-CN          'Doublesplit - 999999 合 1
// @name:de             'Doublesplit - 999999 in 1
// @name:ar             'دلتا - 999999 في 1
// @description         Doublesplit - Agario extension, with zoom, minimap, helpers, adblocker
// @description:es      Doublesplit - extensión para Agario con zoom, minimapa, ayudas y bloqueador de anuncios
// @description:ru      Doublesplit — расширение для Agario с зумом, миникартой, помощниками и блокировщиком рекламы
// @description:zh-CN   Doublesplit - agario 的扩展，带有缩放、小地图、辅助功能和广告拦截器
// @description:uk      Doublesplit — розширення для Agario із зумом, мінікартою, помічниками та блокувальником реклами
// @description:tr      Doublesplit - Agario için yakınlaştırma, mini harita, yardımcılar ve reklam engelleyici uzantısı
// @description:de      Doublesplit – Erweiterung für Agario mit Zoom, Minikarte, Helfern und Werbeblocker
// @description:ja      Doublesplit - Agario のズーム、ミニマップ、ヘルパー、広告ブロッカー付き拡張機能
// @description:pl      Doublesplit - rozszerzenie do Agario z powiększeniem, minimapą, pomocnikami i blokadą reklam
// @description:fr      Doublesplit - extension pour Agario avec zoom, mini-carte, assistants et bloqueur de publicité
// @description:ar      دلتا - إضافة لـ Agario مع مانع إعلانات
// @version             8.0.4
// @namespace           doublesplit.agar
// @author              neo
// @icon                https://deltav4.gitlab.io/favicon.ico
// @match               *://*.agar.io/
// @run-at              document-start
// @grant               GM.xmlHttpRequest
// @grant               GM.registerMenuCommand
// @grant               window.close
// @grant               unsafeWindow
// @license             MPL-2.0
// @antifeature         ads
// @source              https://github.com/doublesplit/lite-ext/
// @supportURL          https://discord.gg/HHmyKW6
// @require             https://cdnjs.cloudflare.com/ajax/libs/preact/10.21.0/preact.umd.min.js
// @require             https://cdnjs.cloudflare.com/ajax/libs/preact/10.21.0/hooks.umd.min.js
// @require             https://cdnjs.cloudflare.com/ajax/libs/preact/10.21.0/compat.umd.min.js
// ==/UserScript==
 
/*
  GREASYFORK VERSION
 
  en: If this user script does not start, write me a discord
  ru: Если данное расширение не запускается, напишите мне в дискорд
  https://discord.gg/HHmyKW6
 
*/
 
(function (window) {
/******/ // runtime can't be in strict mode because a global variable is assign and maybe created.
/******/ var __webpack_modules__ = ({
 
/***/ 32:
/***/ ((module) => {
 
"use strict";
module.exports = preact;
 
/***/ }),
 
/***/ 56:
/***/ ((module, __unused_webpack_exports, __webpack_require__) => {
 
"use strict";
 
 
/* istanbul ignore next  */
function setAttributesWithoutAttributes(styleElement) {
  var nonce =  true ? __webpack_require__.nc : 0;
  if (nonce) {
    styleElement.setAttribute("nonce", nonce);
  }
}
module.exports = setAttributesWithoutAttributes;
 
/***/ }),
 
/***/ 72:
/***/ ((module) => {
 
"use strict";
 
 
var stylesInDOM = [];
function getIndexByIdentifier(identifier) {
  var result = -1;
  for (var i = 0; i < stylesInDOM.length; i++) {
    if (stylesInDOM[i].identifier === identifier) {
      result = i;
      break;
    }
  }
  return result;
}
function modulesToDom(list, options) {
  var idCountMap = {};
  var identifiers = [];
  for (var i = 0; i < list.length; i++) {
    var item = list[i];
    var id = options.base ? item[0] + options.base : item[0];
    var count = idCountMap[id] || 0;
    var identifier = "".concat(id, " ").concat(count);
    idCountMap[id] = count + 1;
    var indexByIdentifier = getIndexByIdentifier(identifier);
    var obj = {
      css: item[1],
      media: item[2],
      sourceMap: item[3],
      supports: item[4],
      layer: item[5]
    };
    if (indexByIdentifier !== -1) {
      stylesInDOM[indexByIdentifier].references++;
      stylesInDOM[indexByIdentifier].updater(obj);
    } else {
      var updater = addElementStyle(obj, options);
      options.byIndex = i;
      stylesInDOM.splice(i, 0, {
        identifier: identifier,
        updater: updater,
        references: 1
      });
    }
    identifiers.push(identifier);
  }
  return identifiers;
}
function addElementStyle(obj, options) {
  var api = options.domAPI(options);
  api.update(obj);
  var updater = function updater(newObj) {
    if (newObj) {
      if (newObj.css === obj.css && newObj.media === obj.media && newObj.sourceMap === obj.sourceMap && newObj.supports === obj.supports && newObj.layer === obj.layer) {
        return;
      }
      api.update(obj = newObj);
    } else {
      api.remove();
    }
  };
  return updater;
}
module.exports = function (list, options) {
  options = options || {};
  list = list || [];
  var lastIdentifiers = modulesToDom(list, options);
  return function update(newList) {
    newList = newList || [];
    for (var i = 0; i < lastIdentifiers.length; i++) {
      var identifier = lastIdentifiers[i];
      var index = getIndexByIdentifier(identifier);
      stylesInDOM[index].references--;
    }
    var newLastIdentifiers = modulesToDom(newList, options);
    for (var _i = 0; _i < lastIdentifiers.length; _i++) {
      var _identifier = lastIdentifiers[_i];
      var _index = getIndexByIdentifier(_identifier);
      if (stylesInDOM[_index].references === 0) {
        stylesInDOM[_index].updater();
        stylesInDOM.splice(_index, 1);
      }
    }
    lastIdentifiers = newLastIdentifiers;
  };
};
 
/***/ }),
 
/***/ 102:
/***/ ((module) => {
 
"use strict";
 
 
/*
  MIT License http://www.opensource.org/licenses/mit-license.php
  Author Tobias Koppers @sokra
*/
module.exports = function (cssWithMappingToString) {
  var list = [];
 
  // return the list of modules as css string
  list.toString = function toString() {
    return this.map(function (item) {
      var content = "";
      var needLayer = typeof item[5] !== "undefined";
      if (item[4]) {
        content += "@supports (".concat(item[4], ") {");
      }
      if (item[2]) {
        content += "@media ".concat(item[2], " {");
      }
      if (needLayer) {
        content += "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {");
      }
      content += cssWithMappingToString(item);
      if (needLayer) {
        content += "}";
      }
      if (item[2]) {
        content += "}";
      }
      if (item[4]) {
        content += "}";
      }
      return content;
    }).join("");
  };
 
  // import a list of modules into the list
  list.i = function i(modules, media, dedupe, supports, layer) {
    if (typeof modules === "string") {
      modules = [[null, modules, undefined]];
    }
    var alreadyImportedModules = {};
    if (dedupe) {
      for (var k = 0; k < this.length; k++) {
        var id = this[k][0];
        if (id != null) {
          alreadyImportedModules[id] = true;
        }
      }
    }
    for (var _k = 0; _k < modules.length; _k++) {
      var item = [].concat(modules[_k]);
      if (dedupe && alreadyImportedModules[item[0]]) {
        continue;
      }
      if (typeof layer !== "undefined") {
        if (typeof item[5] === "undefined") {
          item[5] = layer;
        } else {
          item[1] = "@layer".concat(item[5].length > 0 ? " ".concat(item[5]) : "", " {").concat(item[1], "}");
          item[5] = layer;
        }
      }
      if (media) {
        if (!item[2]) {
          item[2] = media;
        } else {
          item[1] = "@media ".concat(item[2], " {").concat(item[1], "}");
          item[2] = media;
        }
      }
      if (supports) {
        if (!item[4]) {
          item[4] = "".concat(supports);
        } else {
          item[1] = "@supports (".concat(item[4], ") {").concat(item[1], "}");
          item[4] = supports;
        }
      }
      list.push(item);
    }
  };
  return list;
};
 
/***/ }),
 
/***/ 113:
/***/ ((module) => {
 
"use strict";
 
 
/* istanbul ignore next  */
function styleTagTransform(css, styleElement) {
  if (styleElement.styleSheet) {
    styleElement.styleSheet.cssText = css;
  } else {
    while (styleElement.firstChild) {
      styleElement.removeChild(styleElement.firstChild);
    }
    styleElement.appendChild(document.createTextNode(css));
  }
}
module.exports = styleTagTransform;
 
/***/ }),
 
/***/ 390:
/***/ ((module, __webpack_exports__, __webpack_require__) => {
 
"use strict";
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Minimap: () => (/* binding */ Minimap)
/* harmony export */ });
/* harmony import */ var preact_hooks__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(632);
/* harmony import */ var preact_hooks__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(preact_hooks__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _settings__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(701);
/* harmony import */ var _Contexts__WEBPACK_IMPORTED_MODULE_2__ = __webpack_require__(413);
/* harmony import */ var preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__ = __webpack_require__(557);
/* module decorator */ module = __webpack_require__.hmd(module);
 
 
 
 
function Minimap() {
  const app = (0,preact_hooks__WEBPACK_IMPORTED_MODULE_0__.useContext)(_Contexts__WEBPACK_IMPORTED_MODULE_2__.AppContext);
  const [minimapEnabled, setMinimapEnabled] = (0,preact_hooks__WEBPACK_IMPORTED_MODULE_0__.useState)(_settings__WEBPACK_IMPORTED_MODULE_1__.settings.raw.Minimap);
  const $canvas = (0,preact_hooks__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  const $sectors = (0,preact_hooks__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  const $minimap = (0,preact_hooks__WEBPACK_IMPORTED_MODULE_0__.useRef)(null);
  (0,preact_hooks__WEBPACK_IMPORTED_MODULE_0__.useLayoutEffect)(() => {
    const ctx = $canvas.current.getContext('2d');
    const sectors = $sectors.current.querySelectorAll('.sector');
    let sectorIndex = -1;
    let rafId;
    function render() {
      const sectorId = app.world.drawMinimap(ctx, $canvas.current);
      setSector(sectorId);
      rafId = requestAnimationFrame(render);
    }
    function setSector(index) {
      if (index === sectorIndex || index < 0) return;
      index = Math.min(index, sectors.length - 1);
      sectorIndex !== -1 && sectors[sectorIndex].classList.remove('active');
      sectors[index].classList.add('active');
      sectorIndex = index;
    }
    if (minimapEnabled) rafId = requestAnimationFrame(render);
    $minimap.current.style.display = minimapEnabled ? '' : 'none';
    const minimapListener = _settings__WEBPACK_IMPORTED_MODULE_1__.settings.on('Minimap', value => {
      setMinimapEnabled(value);
    });
    return () => {
      _settings__WEBPACK_IMPORTED_MODULE_1__.settings.removeListener('Minimap', minimapListener);
      cancelAnimationFrame(rafId);
    };
  }, [minimapEnabled]);
  return (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", {
    ref: $minimap,
    id: "ds-minimap",
    style: {
      zIndex: 1000
    },
    children: [(0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsxs)("div", {
      class: "background",
      ref: $sectors,
      children: [(0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "A1"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "A2"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "A3"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "A4"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "A5"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "B1"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "B2"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "B3"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "B4"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "B5"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "C1"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "C2"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "C3"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "C4"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "C5"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "D1"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "D2"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "D3"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "D4"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "D5"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "E1"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "E2"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "E3"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "E4"
      }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("div", {
        class: "sector",
        children: "E5"
      })]
    }), (0,preact_jsx_runtime__WEBPACK_IMPORTED_MODULE_3__.jsx)("canvas", {
      id: "minimap",
      width: "200",
      height: "200",
      ref: $canvas
    })]
  });
}
if ('hot' in module) {
  // @ts-ignore
  module['hot'].accept();
}
 
/***/ }),
 
/***/ 397:
/***/ ((module, __webpack_exports__, __webpack_require__) => {
 
"use strict";
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(653);
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(102);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
// Imports
 
 
var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
// Module
___CSS_LOADER_EXPORT___.push([module.id, `/*! tailwindcss v4.1.4 | MIT License | https://tailwindcss.com */
@layer properties;
@layer theme, base, components, utilities;
@layer theme {
  :root, :host {
    --font-sans: ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji",
      "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji";
    --font-mono: ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono",
      "Courier New", monospace;
    --spacing: 0.25rem;
    --default-font-family: var(--font-sans);
    --default-mono-font-family: var(--font-mono);
  }
}
@layer base {
  *,
  ::after,
  ::before,
  ::backdrop,
  ::file-selector-button {
    box-sizing: border-box;
    margin: 0;
    padding: 0;
    border: 0 solid;
  }
  html,
  :host {
    line-height: 1.5;
    -webkit-text-size-adjust: 100%;
    -moz-tab-size: 4;
      -o-tab-size: 4;
         tab-size: 4;
    font-family: var(--default-font-family, ui-sans-serif, system-ui, sans-serif, "Apple Color Emoji", "Segoe UI Emoji", "Segoe UI Symbol", "Noto Color Emoji");
    font-feature-settings: var(--default-font-feature-settings, normal);
    font-variation-settings: var(--default-font-variation-settings, normal);
    -webkit-tap-highlight-color: transparent;
  }
  hr {
    height: 0;
    color: inherit;
    border-top-width: 1px;
  }
  abbr:where([title]) {
    -webkit-text-decoration: underline dotted;
    text-decoration: underline dotted;
  }
  h1,
  h2,
  h3,
  h4,
  h5,
  h6 {
    font-size: inherit;
    font-weight: inherit;
  }
  a {
    color: inherit;
    -webkit-text-decoration: inherit;
    text-decoration: inherit;
  }
  b,
  strong {
    font-weight: bolder;
  }
  code,
  kbd,
  samp,
  pre {
    font-family: var(--default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, "Liberation Mono", "Courier New", monospace);
    font-feature-settings: var(--default-mono-font-feature-settings, normal);
    font-variation-settings: var(--default-mono-font-variation-settings, normal);
    font-size: 1em;
  }
  small {
    font-size: 80%;
  }
  sub,
  sup {
    font-size: 75%;
    line-height: 0;
    position: relative;
    vertical-align: baseline;
  }
  sub {
    bottom: -0.25em;
  }
  sup {
    top: -0.5em;
  }
  table {
    text-indent: 0;
    border-color: inherit;
    border-collapse: collapse;
  }
  :-moz-focusring {
    outline: auto;
  }
  progress {
    vertical-align: baseline;
  }
  summary {
    display: list-item;
  }
  ol,
  ul,
  menu {
    list-style: none;
  }
  img,
  svg,
  video,
  canvas,
  audio,
  iframe,
  embed,
  object {
    display: block;
    vertical-align: middle;
  }
  img,
  video {
    max-width: 100%;
    height: auto;
  }
  button,
  input,
  select,
  optgroup,
  textarea,
  ::file-selector-button {
    font: inherit;
    font-feature-settings: inherit;
    font-variation-settings: inherit;
    letter-spacing: inherit;
    color: inherit;
    border-radius: 0;
    background-color: transparent;
    opacity: 1;
  }
  :where(select:is([multiple], [size])) optgroup {
    font-weight: bolder;
  }
  :where(select:is([multiple], [size])) optgroup option {
    padding-inline-start: 20px;
  }
  ::file-selector-button {
    margin-inline-end: 4px;
  }
  ::-moz-placeholder {
    opacity: 1;
  }
  ::placeholder {
    opacity: 1;
  }
  @supports (not (-webkit-appearance: -apple-pay-button))  or
    (contain-intrinsic-size: 1px) {
    ::-moz-placeholder {
      color: currentcolor;
      @supports (color: color-mix(in lab, red, red)) {
        color: color-mix(in oklab, currentcolor 50%, transparent);
      }
    }
    ::placeholder {
      color: currentcolor;
      @supports (color: color-mix(in lab, red, red)) {
        color: color-mix(in oklab, currentcolor 50%, transparent);
      }
    }
  }
  textarea {
    resize: vertical;
  }
  ::-webkit-search-decoration {
    -webkit-appearance: none;
  }
  ::-webkit-date-and-time-value {
    min-height: 1lh;
    text-align: inherit;
  }
  ::-webkit-datetime-edit {
    display: inline-flex;
  }
  ::-webkit-datetime-edit-fields-wrapper {
    padding: 0;
  }
  ::-webkit-datetime-edit,
  ::-webkit-datetime-edit-year-field,
  ::-webkit-datetime-edit-month-field,
  ::-webkit-datetime-edit-day-field,
  ::-webkit-datetime-edit-hour-field,
  ::-webkit-datetime-edit-minute-field,
  ::-webkit-datetime-edit-second-field,
  ::-webkit-datetime-edit-millisecond-field,
  ::-webkit-datetime-edit-meridiem-field {
    padding-block: 0;
  }
  :-moz-ui-invalid {
    box-shadow: none;
  }
  button,
  input:where([type="button"], [type="reset"], [type="submit"]),
  ::file-selector-button {
    -webkit-appearance: button;
       -moz-appearance: button;
            appearance: button;
  }
  ::-webkit-inner-spin-button,
  ::-webkit-outer-spin-button {
    height: auto;
  }
  [hidden]:where(:not([hidden="until-found"])) {
    display: none !important;
  }
}
@layer utilities {
  .absolute {
    position: absolute !important;
  }
  .relative {
    position: relative !important;
  }
  .static {
    position: static !important;
  }
  .mx-2 {
    margin-inline: calc(var(--spacing) * 2) !important;
  }
  .contents {
    display: contents !important;
  }
  .flex {
    display: flex !important;
  }
  .grid {
    display: grid !important;
  }
  .inline {
    display: inline !important;
  }
  .w-4 {
    width: calc(var(--spacing) * 4) !important;
  }
  .w-full {
    width: 100% !important;
  }
  .grow {
    flex-grow: 1 !important;
  }
  .transform {
    transform: var(--tw-rotate-x,) var(--tw-rotate-y,) var(--tw-rotate-z,) var(--tw-skew-x,) var(--tw-skew-y,) !important;
  }
  .resize {
    resize: both !important;
  }
  .flex-row {
    flex-direction: row !important;
  }
  .gap-2 {
    gap: calc(var(--spacing) * 2) !important;
  }
  .p-1 {
    padding: calc(var(--spacing) * 1) !important;
  }
  .text-left {
    text-align: left !important;
  }
}
*,
::after,
::before,
::backdrop,
::file-selector-button {
  box-sizing: border-box;
  margin: 0;
  padding: 0;
  border: 0 solid;
}
html,
:host {
  line-height: 1.5;
  -webkit-text-size-adjust: 100%;
  -moz-tab-size: 4;
    -o-tab-size: 4;
       tab-size: 4;
  font-family: var(--default-font-family, ui-sans-serif, system-ui, sans-serif, 'Apple Color Emoji', 'Segoe UI Emoji', 'Segoe UI Symbol', 'Noto Color Emoji');
  font-feature-settings: var(--default-font-feature-settings, normal);
  font-variation-settings: var(--default-font-variation-settings, normal);
  -webkit-tap-highlight-color: transparent;
}
hr {
  height: 0;
  color: inherit;
  border-top-width: 1px;
}
abbr:where([title]) {
  -webkit-text-decoration: underline dotted;
  text-decoration: underline dotted;
}
h1,
h2,
h3,
h4,
h5,
h6 {
  font-size: inherit;
  font-weight: inherit;
}
a {
  color: inherit;
  -webkit-text-decoration: inherit;
  text-decoration: inherit;
}
b,
strong {
  font-weight: bolder;
}
code,
kbd,
samp,
pre {
  font-family: var(--default-mono-font-family, ui-monospace, SFMono-Regular, Menlo, Monaco, Consolas, 'Liberation Mono', 'Courier New', monospace);
  font-feature-settings: var(--default-mono-font-feature-settings, normal);
  font-variation-settings: var(--default-mono-font-variation-settings, normal);
  font-size: 1em;
}
small {
  font-size: 80%;
}
sub,
sup {
  font-size: 75%;
  line-height: 0;
  position: relative;
  vertical-align: baseline;
}
sub {
  bottom: -0.25em;
}
sup {
  top: -0.5em;
}
table {
  text-indent: 0;
  border-color: inherit;
  border-collapse: collapse;
}
:-moz-focusring {
  outline: auto;
}
progress {
  vertical-align: baseline;
}
summary {
  display: list-item;
}
ol,
ul,
menu {
  list-style: none;
}
img,
svg,
video,
canvas,
audio,
iframe,
embed,
object {
  display: block;
  vertical-align: middle;
}
img,
video {
  max-width: 100%;
  height: auto;
}
button,
input,
select,
optgroup,
textarea,
::file-selector-button {
  font: inherit;
  font-feature-settings: inherit;
  font-variation-settings: inherit;
  letter-spacing: inherit;
  color: inherit;
  border-radius: 0;
  background-color: transparent;
  opacity: 1;
}
:where(select:is([multiple], [size])) optgroup {
  font-weight: bolder;
}
:where(select:is([multiple], [size])) optgroup option {
  padding-inline-start: 20px;
}
::file-selector-button {
  margin-inline-end: 4px;
}
::-moz-placeholder {
  opacity: 1;
}
::placeholder {
  opacity: 1;
}
@supports (not (-webkit-appearance: -apple-pay-button))  or
  (contain-intrinsic-size: 1px) {
  ::-moz-placeholder {
    color: currentcolor;
    @supports (color: color-mix(in lab, red, red)) {
      color: color-mix(in oklab, currentcolor 50%, transparent);
    }
  }
  ::placeholder {
    color: currentcolor;
    @supports (color: color-mix(in lab, red, red)) {
      color: color-mix(in oklab, currentcolor 50%, transparent);
    }
  }
}
textarea {
  resize: vertical;
}
::-webkit-search-decoration {
  -webkit-appearance: none;
}
::-webkit-date-and-time-value {
  min-height: 1lh;
  text-align: inherit;
}
::-webkit-datetime-edit {
  display: inline-flex;
}
::-webkit-datetime-edit-fields-wrapper {
  padding: 0;
}
::-webkit-datetime-edit,
::-webkit-datetime-edit-year-field,
::-webkit-datetime-edit-month-field,
::-webkit-datetime-edit-day-field,
::-webkit-datetime-edit-hour-field,
::-webkit-datetime-edit-minute-field,
::-webkit-datetime-edit-second-field,
::-webkit-datetime-edit-millisecond-field,
::-webkit-datetime-edit-meridiem-field {
  padding-block: 0;
}
:-moz-ui-invalid {
  box-shadow: none;
}
button,
input:where([type='button'], [type='reset'], [type='submit']),
::file-selector-button {
  -webkit-appearance: button;
     -moz-appearance: button;
          appearance: button;
}
::-webkit-inner-spin-button,
::-webkit-outer-spin-button {
  height: auto;
}
[hidden]:where(:not([hidden='until-found'])) {
  display: none !important;
}
:root {
  --bottom-banner-height: 0px !important;
}
#title {
  margin-top: 0 !important;
}
#mainui-play {
  height: 595px !important;
}
#mainPanel {
  display: flex;
  flex-direction: column;
  height: 100%;
}
#socialLoginContainer {
  position: initial !important;
}
#instructions {
  position: initial !important;
  display: none !important;
  overflow: hidden !important;
  flex-direction: column !important;
  margin: 0 !important;
}
.play-container {
  display: flex;
  height: 100%;
  padding: 0 !important;
}
#play {
  top: initial !important;
}
#nick {
  position: initial !important;
  left: initial !important;
  top: initial !important;
  float: initial !important;
}
#skinButton {
  position: relative !important;
  display: block;
  left: initial !important;
  width: 46px;
  height: 46px;
}
#playnick {
  position: initial !important;
  display: flex;
  flex-direction: row;
  flex-wrap: wrap;
  justify-content: center;
  align-items: center;
}
#socialLoginContainer {
  top: initial !important;
  margin: 4px 20px 0px 20px !important;
}
.guest {
  display: flex;
  flex-direction: column;
  align-items: center;
}
.menu-addon {
  gap: 4px;
  display: flex;
  flex-direction: column;
  align-items: center;
}
.menu-button {
  color: #fff;
  background-color: #54c800;
  border-color: #54c800;
  height: 34px;
  font-size: 20px;
  line-height: 1.5;
  padding: 0 0.5rem;
}
.menu-button:hover {
  filter: brightness(0.7) contrast(1);
}
.input-addon {
  width: 100%;
  height: 28px;
}
.circle.green {
  position: absolute !important;
}
#settingsButton {
  left: 5px;
  position: absolute !important;
}
.circle {
  display: flex;
  justify-content: center;
}
.agario-panel {
  margin: 0 auto;
}
.tosBox {
  display: none !important;
}
@property --tw-rotate-x {
  syntax: "*";
  inherits: false;
}
@property --tw-rotate-y {
  syntax: "*";
  inherits: false;
}
@property --tw-rotate-z {
  syntax: "*";
  inherits: false;
}
@property --tw-skew-x {
  syntax: "*";
  inherits: false;
}
@property --tw-skew-y {
  syntax: "*";
  inherits: false;
}
@layer properties {
  @supports ((-webkit-hyphens: none) and (not (margin-trim: inline))) or ((-moz-orient: inline) and (not (color:rgb(from red r g b)))) {
    *, ::before, ::after, ::backdrop {
      --tw-rotate-x: initial;
      --tw-rotate-y: initial;
      --tw-rotate-z: initial;
      --tw-skew-x: initial;
      --tw-skew-y: initial;
    }
  }
}
`, ""]);
// Exports
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___);
 
 
/***/ }),
 
/***/ 413:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
"use strict";
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   AppContext: () => (/* binding */ AppContext)
/* harmony export */ });
/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(32);
/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(preact__WEBPACK_IMPORTED_MODULE_0__);
 
const AppContext = (0,preact__WEBPACK_IMPORTED_MODULE_0__.createContext)(null);
 
/***/ }),
 
/***/ 540:
/***/ ((module) => {
 
"use strict";
 
 
/* istanbul ignore next  */
function insertStyleElement(options) {
  var element = document.createElement("style");
  options.setAttributes(element, options.attributes);
  options.insert(element, options.options);
  return element;
}
module.exports = insertStyleElement;
 
/***/ }),
 
/***/ 557:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
"use strict";
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   Fragment: () => (/* reexport safe */ preact__WEBPACK_IMPORTED_MODULE_0__.Fragment),
/* harmony export */   jsx: () => (/* binding */ u),
/* harmony export */   jsxs: () => (/* binding */ u)
/* harmony export */ });
/* unused harmony exports jsxAttr, jsxDEV, jsxEscape, jsxTemplate */
/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(32);
/* harmony import */ var preact__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(preact__WEBPACK_IMPORTED_MODULE_0__);
 
 
var t = /["&<]/;
function n(r) {
  if (0 === r.length || !1 === t.test(r)) return r;
  for (var e = 0, n = 0, o = "", f = ""; n < r.length; n++) {
    switch (r.charCodeAt(n)) {
      case 34:
        f = "&quot;";
        break;
      case 38:
        f = "&amp;";
        break;
      case 60:
        f = "&lt;";
        break;
      default:
        continue;
    }
    n !== e && (o += r.slice(e, n)), o += f, e = n + 1;
  }
  return n !== e && (o += r.slice(e, n)), o;
}
var o = /acit|ex(?:s|g|n|p|$)|rph|grid|ows|mnc|ntw|ine[ch]|zoo|^ord|itera/i,
  f = 0,
  i = Array.isArray;
function u(e, t, n, o, i, u) {
  t || (t = {});
  var a,
    c,
    p = t;
  if ("ref" in p) for (c in p = {}, t) "ref" == c ? a = t[c] : p[c] = t[c];
  var l = {
    type: e,
    props: p,
    key: n,
    ref: a,
    __k: null,
    __: null,
    __b: 0,
    __e: null,
    __c: null,
    constructor: void 0,
    __v: --f,
    __i: -1,
    __u: 0,
    __source: i,
    __self: u
  };
  if ("function" == typeof e && (a = e.defaultProps)) for (c in a) void 0 === p[c] && (p[c] = a[c]);
  return preact__WEBPACK_IMPORTED_MODULE_0__.options.vnode && preact__WEBPACK_IMPORTED_MODULE_0__.options.vnode(l), l;
}
function a(r) {
  var t = u(e, {
    tpl: r,
    exprs: [].slice.call(arguments, 1)
  });
  return t.key = t.__v, t;
}
var c = {},
  p = /[A-Z]/g;
function l(e, t) {
  if (r.attr) {
    var f = r.attr(e, t);
    if ("string" == typeof f) return f;
  }
  if ("ref" === e || "key" === e) return "";
  if ("style" === e && "object" == typeof t) {
    var i = "";
    for (var u in t) {
      var a = t[u];
      if (null != a && "" !== a) {
        var l = "-" == u[0] ? u : c[u] || (c[u] = u.replace(p, "-$&").toLowerCase()),
          s = ";";
        "number" != typeof a || l.startsWith("--") || o.test(l) || (s = "px;"), i = i + l + ":" + a + s;
      }
    }
    return e + '="' + i + '"';
  }
  return null == t || !1 === t || "function" == typeof t || "object" == typeof t ? "" : !0 === t ? e : e + '="' + n(t) + '"';
}
function s(r) {
  if (null == r || "boolean" == typeof r || "function" == typeof r) return null;
  if ("object" == typeof r) {
    if (void 0 === r.constructor) return r;
    if (i(r)) {
      for (var e = 0; e < r.length; e++) r[e] = s(r[e]);
      return r;
    }
  }
  return n("" + r);
}
 
 
/***/ }),
 
/***/ 632:
/***/ ((module) => {
 
"use strict";
module.exports = preactHooks;
 
/***/ }),
 
/***/ 653:
/***/ ((module) => {
 
"use strict";
 
 
module.exports = function (i) {
  return i[1];
};
 
/***/ }),
 
/***/ 659:
/***/ ((module) => {
 
"use strict";
 
 
var memo = {};
 
/* istanbul ignore next  */
function getTarget(target) {
  if (typeof memo[target] === "undefined") {
    var styleTarget = document.querySelector(target);
 
    // Special case to return head of iframe instead of iframe itself
    if (window.HTMLIFrameElement && styleTarget instanceof window.HTMLIFrameElement) {
      try {
        // This will throw an exception if access to iframe is blocked
        // due to cross-origin restrictions
        styleTarget = styleTarget.contentDocument.head;
      } catch (e) {
        // istanbul ignore next
        styleTarget = null;
      }
    }
    memo[target] = styleTarget;
  }
  return memo[target];
}
 
/* istanbul ignore next  */
function insertBySelector(insert, style) {
  var target = getTarget(insert);
  if (!target) {
    throw new Error("Couldn't find a style target. This probably means that the value for the 'insert' parameter is invalid.");
  }
  target.appendChild(style);
}
module.exports = insertBySelector;
 
/***/ }),
 
/***/ 701:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
"use strict";
 
// EXPORTS
__webpack_require__.d(__webpack_exports__, {
  settings: () => (/* binding */ settings)
});
 
// EXTERNAL MODULE: ./Shared/src/utils/Eventify.ts
var Eventify = __webpack_require__(714);
;// ./dev/src/Settngs.ts
 
// eslint-disable-next-line @typescript-eslint/no-explicit-any
class BasicSetting {
  constructor({
    path = 'DEFAULT',
    name = ''
  }) {
    this.exportable = true;
    this.type = 'NONE';
    this._value = null;
    this.default = null;
    this.path = path;
    this.name = name;
  }
  get value() {
    return this._value;
  }
  set value(data) {
    this._value = data;
  }
  setter(data) {
    this.value = data;
  }
  get export() {
    return this.value;
  }
}
class Settings extends Eventify.Eventify {
  constructor(descriptions) {
    super();
    this.raw = descriptions;
    const self = this;
    this.proxy = new Proxy(this.raw, {
      set: (target, prop, newValue) => {
        const previous = target[prop].value;
        self.emit('before*', prop, newValue); // before set
        target[prop].setter(newValue);
        try {
          newValue !== previous && self.emit.call(this, prop, newValue, previous); // on set
          newValue !== previous && self.emit('*', prop, newValue, previous); // on any
        } catch (message) {
          console.error(message);
        }
        return true;
      },
      get(target, prop) {
        return target[prop].value;
      }
    });
  }
  import(object) {
    if (!object) return;
    for (const option in this.raw) {
      if (this.raw.hasOwnProperty(option) && object.hasOwnProperty(option)) {
        this.proxy[option] = object[option];
      }
    }
  }
  export() {
    const export_data = {};
    for (const option in this.raw) {
      export_data[option] = this.raw[option].export;
    }
    return export_data;
  }
  restore() {
    for (const opt in this.raw) {
      const option = opt;
      if (this.raw.hasOwnProperty(option)) {
        this.proxy[option] = this.raw[option].default;
      }
    }
  }
}
;// ./dev/src/utils/microColor.ts
var _a;
class MicroColor {
  constructor(red = 255, green = 255, blue = 255, alpha = 255) {
    this.r = red;
    this.g = green;
    this.b = blue;
    this.a = alpha;
    this.vector = new Float32Array(4);
    this.bytes = new Uint8Array(4);
    this.dataview = new DataView(this.bytes.buffer);
    this.string = '#000000';
    this.int = 0;
    this.inta = 0;
    this.updVector();
    this.updString();
    this.updInt();
  }
  updVector() {
    this.vector[0] = this.r / 255;
    this.vector[1] = this.g / 255;
    this.vector[2] = this.b / 255;
    this.vector[3] = this.a / 255;
    this.bytes[0] = this.r;
    this.bytes[1] = this.g;
    this.bytes[2] = this.b;
    this.bytes[3] = this.a;
    this.float = this.dataview.getFloat32(0, true);
    this.u32 = this.r | this.g << 8 | this.b << 16 | this.a << 24;
    // for (let i = 0; i < 4; i++) {
    //     this.u32 |= this.bytes[i] << (8 * i);
    // }
  }
  updString() {
    this.string = this.toRgb(true);
  }
  updInt() {
    this.int = this.getInt();
    this.inta = this.getInta();
  }
  cloneFrom(t) {
    this.r = t.r;
    this.g = t.g;
    this.b = t.b;
    this.a = t.a;
    this.updVector();
    this.updString();
    return this;
  }
  fromHSL(h, s, l, a = 255) {
    s /= 100;
    l /= 100;
    const c = (1 - Math.abs(2 * l - 1)) * s;
    const x = c * (1 - Math.abs(h / 60 % 2 - 1));
    const m = l - c / 2;
    let r = 0;
    let g = 0;
    let b = 0;
    if (0 <= h && h < 60) {
      r = c, g = x, b = 0;
    } else if (60 <= h && h < 120) {
      r = x, g = c, b = 0;
    } else if (120 <= h && h < 180) {
      r = 0, g = c, b = x;
    } else if (180 <= h && h < 240) {
      r = 0, g = x, b = c;
    } else if (240 <= h && h < 300) {
      r = x, g = 0, b = c;
    } else if (300 <= h && h < 360) {
      r = c, g = 0, b = x;
    }
    // Having obtained RGB, convert channels to hex
    this.r = Math.round((r + m) * 255);
    this.g = Math.round((g + m) * 255);
    this.b = Math.round((b + m) * 255);
    this.a = a;
    return this;
  }
  fromRGB(r, g, b, a = 255) {
    this.r = r;
    this.g = g;
    this.b = b;
    this.a = a;
    this.updVector();
    this.updString();
    return this;
  }
  // fromINTA(int: number, alpha = 255) {
  //     const a = (int >> 24) & alpha;
  //     return this.fromINT(color);
  // }
  fromINT(int, reorder) {
    this.a = (4278190080 & int) >>> 24;
    this.r = (16711680 & int) >>> 16;
    this.g = (65280 & int) >>> 8;
    this.b = (255 & int) >>> 0;
    if (reorder) Object.assign(this, {
      r: this.a,
      g: this.r,
      b: this.g,
      a: this.b
    });
    this.updVector();
    this.updString();
    return this;
  }
  fromHex(hex) {
    const len = hex.length;
    if (!hex || len !== 7 && len !== 9) return this;
    let i = hex.length === 9 ? 32 : 24;
    const n = parseInt(hex.slice(1), 16);
    const r = n >> (i -= 8) & 255;
    const g = n >> (i -= 8) & 255;
    const b = n >> (i -= 8) & 255;
    const a = i ? n >> i - 8 & 255 : 255;
    return this.fromRGB(r, g, b, a);
  }
  get getNormalFromSecure() {
    return _a.rgbToInt(Math.ceil(this.r / 0.9), Math.ceil(this.g / 0.9), Math.ceil(this.b / 0.9));
  }
  toRgb(useAlpha) {
    return useAlpha ? `rgba(${this.r}, ${this.g}, ${this.b}, ${this.a / 255})` : `rgb(${this.r}, ${this.g}, ${this.b})`;
  }
  getHEXA() {
    let r = this.r.toString(16);
    let g = this.g.toString(16);
    let b = this.b.toString(16);
    let a = this.a.toString(16);
    if (r.length == 1) r = '0' + r;
    if (g.length == 1) g = '0' + g;
    if (b.length == 1) b = '0' + b;
    if (a.length == 1) a = '0' + a;
    return '#' + r + g + b + a;
  }
  getFloat() {
    const bits = this.a << 24 | this.b << 16 | this.g << 8 | this.r;
    return _a.pack(bits & 0xfeffffff);
  }
  getHEX() {
    return '#' + (16777216 | this.getInt()).toString(16).substring(1);
  }
  getInt() {
    return this.r << 16 | this.g << 8 | this.b;
  }
  getIntaShader(alpha) {
    return this.r | this.g << 8 | this.b << 16 | (alpha < 0 ? this.a : alpha) << 24;
  }
  getIntShader() {
    return this.r | this.g << 8 | this.b << 16;
  }
  getInta() {
    return this.a << 24 | this.r << 16 | this.g << 8 | this.b;
  }
  getSecureHex() {
    return _a.colorIntToHex(_a.rgbToInt(~~(this.r * 0.9), ~~(this.g * 0.9), ~~(this.b * 0.9)));
  }
  static rgbToInt(r, g, b) {
    return r << 16 | g << 8 | b;
  }
  static colorIntToHex(int) {
    let s = int.toString(16);
    for (; s.length < 6;) {
      s = '0' + s;
    }
    return '#' + s;
  }
  static inta2shader(int) {
    const a = (0xff000000 & int) >>> 24;
    const r = (0xff0000 & int) >>> 16;
    const g = (0xff00 & int) >>> 8;
    const b = (0xff & int) >>> 0;
    return r | g << 8 | b << 16 | a << 24;
  }
  toHEX8() {
    return `#${(16777216 | this.getInt()).toString(16).substring(1)}${this.a.toString(16).padStart(2, '0')}`;
  }
  static pack(i) {
    _a.int32[0] = i;
    return _a.float32[0];
  }
  static unpack(f) {
    _a.float32[0] = f;
    return _a.int32[0];
  }
  static darkenColor(color, percent) {
    const num = typeof color == 'string' ? parseInt(color, 16) : color,
      amt = Math.round(2.55 * percent),
      R = (num >> 16) + amt,
      B = (num >> 8 & 0x00ff) + amt,
      G = (num & 0x0000ff) + amt;
    return 255 << 24 | R << 16 | G << 8 | B;
  }
  static brighten(int, amount = 10) {
    const a = (4278190080 & int) >>> 24;
    let r = (16711680 & int) >>> 16;
    let g = (65280 & int) >>> 8;
    let b = (255 & int) >>> 0;
    r = Math.max(0, Math.min(255, r - Math.round(255 * -(amount / 100))));
    g = Math.max(0, Math.min(255, g - Math.round(255 * -(amount / 100))));
    b = Math.max(0, Math.min(255, b - Math.round(255 * -(amount / 100))));
    return a << 24 | r << 16 | g << 8 | b;
  }
  static multiplyAlpha(int, alpha) {
    return ((int >>> 24) * alpha & 0xff) << 24 | int & 0x00ffffff;
  }
}
_a = MicroColor;
(() => {
  _a.int8 = new Int8Array(4);
  _a.int32 = new Int32Array(_a.int8.buffer, 0, 1);
  _a.float32 = new Float32Array(_a.int8.buffer, 0, 1);
})();
MicroColor.temp = new _a();
MicroColor.isValidHex = hex => /^#([A-Fa-f0-9]{3,4}){1,2}$/.test(hex);
MicroColor.getChunksFromString = (st, chunkSize) => st.match(new RegExp(`.{${chunkSize}}`, 'g'));
MicroColor.convertHexUnitTo256 = hexStr => parseInt(hexStr.repeat(2 / hexStr.length), 16);
MicroColor.getAlphafloat = (a, alpha) => {
  if (typeof a !== 'undefined') {
    return a / 255;
  }
  if (typeof alpha != 'number' || alpha < 0 || alpha > 1) {
    return 1;
  }
  return alpha;
};
MicroColor.hexToRGBA = hex => {
  if (!_a.isValidHex(hex)) {
    throw new Error('Invalid HEX');
  }
  const chunkSize = Math.floor((hex.length - 1) / 3);
  const hexArr = _a.getChunksFromString(hex.slice(1), chunkSize);
  return hexArr.map(_a.convertHexUnitTo256);
};
/* harmony default export */ const microColor = (MicroColor);
;// ./dev/src/utils/microColorUtils.ts
let canvas;
let ctx;
function parseColorToInta(input) {
  if (!canvas) {
    canvas = document.createElement('canvas');
    canvas.width = canvas.height = 1;
    ctx = canvas.getContext('2d');
  }
  if (!ctx) return 0;
  ctx.clearRect(0, 0, 1, 1);
  try {
    ctx.fillStyle = input;
  } catch (_a) {
    return 0;
  }
  ctx.fillRect(0, 0, 1, 1);
  const [r, g, b, a] = ctx.getImageData(0, 0, 1, 1).data;
  return a << 24 | r << 16 | g << 8 | b;
}
;// ./dev/src/Settings.entities.ts
 
 
 
class Color extends BasicSetting {
  constructor({
    value = '#FF00FFFF',
    useAlpha = false,
    useCss = false,
    path
  }) {
    super({
      path
    });
    this.microcolor = new microColor();
    this.string = '#FFFFFF'; // hex or rgba
    this.type = 'COL';
    this.value = 0;
    // this.hexa = '#FF00FF66' // 8-Digit hex
    // this.vector = new Float32Array(4)
    // this.rgba = new Uint8Array(4)
    this.alpha = useAlpha;
    this.default = value;
    this.useCss = useCss;
    this.setter(value);
  }
  get export() {
    return this.microcolor.toHEX8();
  }
  toJSON() {
    return this.export;
  }
  setter(string_or_number) {
    let inta = 0;
    if (typeof string_or_number === 'string') {
      if (string_or_number[0] == '#' && (string_or_number.length == 7 || string_or_number.length == 9)) {
        inta = microColor.temp.fromHex(string_or_number).getInta();
      } else {
        inta = parseColorToInta(string_or_number);
      }
    } else {
      inta = string_or_number;
    }
    this.microcolor.fromINT(inta);
    this.value = inta;
    this.string = this.alpha ? this.microcolor.fromINT(inta).toRgb(this.alpha) : this.microcolor.fromINT(inta).getHEX();
  }
}
class Select extends BasicSetting {
  constructor({
    name,
    options = {},
    value,
    path
  }) {
    super({
      name,
      path
    });
    this.type = 'SEL';
    this.options = options;
    this.value = value;
    this.default = value;
    this.setter(value);
  }
  get export() {
    return this.value;
  }
  toJSON() {
    return this.export;
  }
  setter(data) {
    let isError = true;
    for (const [, value] of Object.entries(this.options)) {
      if (value === data) {
        isError = false;
      }
    }
    if (isError) {
      console.error('Select: Invalid value ', data, ', fallback to default', this, this.default);
      this.value = this.default;
      return;
    }
    this.value = data;
  }
}
class Slider extends BasicSetting {
  constructor({
    name,
    min,
    max,
    step,
    value,
    useCss = false,
    dim = '',
    unit = '',
    path
  }) {
    var _a;
    super({
      name,
      path
    });
    this.type = 'SLD';
    this.min = min;
    this.max = max;
    this.step = step;
    this.value = value;
    this.default = value;
    this.useCss = useCss;
    this.dim = dim;
    this.unit = unit;
    this.precision = ((_a = step.toString().split('.')[1]) === null || _a === void 0 ? void 0 : _a.length) || 0;
    this.setter(value);
  }
  get export() {
    return this.value;
  }
  toJSON() {
    return this.export;
  }
  setter(data) {
    if (typeof data !== 'number' || typeof data == 'undefined') data = this.default;
    this.value = data;
  }
}
class Option extends BasicSetting {
  constructor({
    name,
    value,
    path
  }) {
    super({
      name,
      path
    });
    this.type = 'OPT';
    this.value = value;
    this.default = value;
    this.setter(value);
  }
  get export() {
    return this.value;
  }
  toJSON() {
    return this.export;
  }
  setter(data) {
    this.value = data;
  }
}
class Input extends BasicSetting {
  constructor({
    name,
    value,
    csshook = s => s,
    path,
    useCss = false,
    options = {}
  }) {
    super({
      name,
      path
    });
    this.type = 'INP';
    this.value = value;
    this.default = value;
    this.csshook = csshook;
    this.useCss = useCss;
    this.options = options;
    this.setter(value);
  }
  get export() {
    return this.value;
  }
  toJSON() {
    return this.export;
  }
  setter(data) {
    if (typeof data !== 'string' || typeof data == 'undefined') data = this.default;
    this.value = String(data);
  }
  cssValue() {
    return this.csshook ? this.csshook(this.value) : this.value;
  }
}
;// ./dev/src/settings.ts
 
 
var Group1;
(function (Group1) {
  Group1["s_game"] = "gameplayGroup";
})(Group1 || (Group1 = {}));
const settingsDescriptions = {
  Minimap: new Option({
    path: Group1.s_game,
    value: true
  }),
  AutoRespawn: new Option({
    path: Group1.s_game,
    value: false
  }),
  AcidMode: new Option({
    path: Group1.s_game,
    value: false
  }),
  LeaderboardTitle: new Input({
    path: Group1.s_game,
    value: 'Doublesplit',
    options: {
      Leaderboard: 'Leaderboard'
    }
  }),
  MapBorder: new Option({
    path: Group1.s_game,
    value: true
  }),
  MapSectors: new Option({
    path: Group1.s_game,
    value: true
  }),
  MapSectorLabels: new Option({
    path: Group1.s_game,
    value: true
  }),
  AutoCollectCoins: new Option({
    path: Group1.s_game,
    value: true
  })
  // label: new Color({ path: Group1.s_game, value: 0x1affa3ff }),
  // miniblob: new Color({ path: Group1.s_game, value: 0x0000ffff }),
  // transparent_cells: new Slider({ path: Group1.s_game, value: 1, min: 0.1, max: 1, step: 0.1 })
};
const settings = new Settings(settingsDescriptions);
Object.assign(window, {
  settings
});
 
/***/ }),
 
/***/ 714:
/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
"use strict";
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   EventObject: () => (/* binding */ EventObject),
/* harmony export */   Eventify: () => (/* binding */ Eventify),
/* harmony export */   deferrify: () => (/* binding */ deferrify)
/* harmony export */ });
/* unused harmony exports EventMixin, eventify, Promised, sleep */
// https://stackoverflow.com/questions/50071115/typescript-promise-rejection-type
//https://github.com/microsoft/TypeScript/issues/24122
function EventMixin(Base) {
  class EventifyBase extends Base {
    constructor() {
      super(...arguments);
      /* Stores events */
      this.events = {};
      /* Stores delegated events */
      // ev: Array<[EventifyBase, EventName<EventMap>, LISTENER]> = [];
      this.ev = [];
      this.blockRemovingListeners = false;
    }
    on(...rest) {
      if (rest.length < 2) throw new Error('Eventify.on() need at least 2 arguments');
      const length = rest.length;
      const listener = rest[length - 1];
      for (let i = 0; length - 1 > i; i++) {
        const event = rest[i];
        if (typeof this.events[event] !== 'object') {
          this.events[event] = [];
        }
        this.events[event].push(listener);
      }
      return listener;
    }
    removeListener(event, listener) {
      if (typeof this.events[event] === 'object') {
        const idx = this.events[event].indexOf(listener);
        if (idx > -1) {
          this.events[event].splice(idx, 1);
        }
        if (this.events[event].length === 0) {
          delete this.events[event];
        }
      }
    }
    emit(event, ...rest) {
      // this.blockRemovingListeners = true;
      if (typeof this.events[event] === 'object') {
        const listeners = this.events[event].slice();
        for (const listener of listeners) {
          listener.apply(this, rest);
        }
      }
      // this.blockRemovingListeners = false;
    }
    once(event, listener) {
      const once_listener = (...args) => {
        this.removeListener(event, once_listener);
        listener.apply(this, args);
      };
      this.on(event, once_listener);
      return once_listener;
    }
    waitTimeout(event, timeout, abortController) {
      const ret = this.waitfor(event, (_, rejector) => {
        const timeoutId = setTimeout(() => {
          const error = new Error(`Waiting "${event.toString()}" Timeout`);
          error.cause = 'timeout';
          rejector(error);
        }, timeout);
        if (abortController) {
          function abort() {
            clearTimeout(timeoutId);
            const error = new Error(`Waiting "${event.toString()}" Aborted`);
            error.cause = 'aborted';
            rejector(error);
          }
          if (abortController.signal.aborted) {
            abort();
          } else {
            abortController.signal.addEventListener('abort', abort, {
              once: true
            });
          }
        }
        return () => {
          clearTimeout(timeoutId);
        };
      });
      return ret;
    }
    waitfor(event, reject_callback) {
      return new Promise((_resolve, _reject) => {
        let destroyCallbackCalled = false;
        const removeListener = () => {
          this.removeListener(event, resolver);
          this.removeListener(event, rejector);
          if (destroyCallbackCalled) return;
          destroyCallbackCalled = true;
          destroyRejectCallback();
        };
        function resolver(v) {
          _resolve(v);
          removeListener();
        }
        function rejector(e) {
          _reject(e);
          removeListener();
        }
        // @ts-ignore
        const destroyRejectCallback = reject_callback(resolver, rejector);
        // eslint-disable-next-line @typescript-eslint/no-explicit-any
        const self = this;
        self.listenSelf(event, resolver);
        self.listenSelf(event, rejector);
      });
    }
    delegateTo(target, ...rest) {
      if (arguments.length < 3) throw new Error('Eventify.delegateTo() need at least 3 arguments');
      const length = rest.length,
        listener = rest[length - 1];
      for (let i = 0; length - 1 > i; i++) {
        const event = rest[i];
        if (typeof target.events[event] !== 'object') {
          target.events[event] = [];
        }
        const _target = target;
        target.ev.push({
          delegated: this,
          event: event,
          listener: listener
        });
        this.on(event, listener);
      }
      return listener;
    }
    listenTo(target, ...rest) {
      return target.delegateTo(this, ...rest);
    }
    listenSelf(...rest) {
      return this.listenTo(this, ...rest);
    }
    /**
     * Removes delegated events
     */
    unlisten() {
      const before = this.ev.slice();
      for (let i = 0; before.length > i; i++) {
        const target = before[i].delegated;
        const eventName = before[i].event;
        const listener = before[i].listener;
        target.removeListener(eventName, listener);
        const idx = this.ev.indexOf(before[i]);
        if (idx > -1) this.ev.splice(idx, 1);
      }
      if (this.ev.length > 0) {
        console.error('We have error in unlisten()', before, this.ev);
      }
    }
  }
  return EventifyBase;
}
class Eventify extends EventMixin(class {}) {}
 
/* LIB : EVENTIFY ANY OBJECT */
const props = ['on', 'removeListener', 'emit', 'once', 'listenTo', 'delegateTo', 'listenSelf', 'unlisten', 'ev', 'events', 'waitfor', 'waitTimeout'];
const eventify = function (object) {
  const EVENTIFY = new Eventify();
  props.forEach(key => {
    Object.defineProperty(object, key, {
      value: EVENTIFY[key],
      enumerable: false,
      writable: false
    });
  });
  return object;
};
function EventObject(object) {
  // = instead extends
  const _Eventify = eventify(object);
  const eventObject = new Proxy(object, {
    set(target, prop, val) {
      const prev = object[prop];
      const curr = val;
      // @ts-ignore
      _Eventify.emit('before*', prop, val);
      //@ts-ignore
      object[prop] = val;
      try {
        // @ts-ignore
        _Eventify.emit(prop, val, prev);
        if (prev !== curr) {
          // @ts-ignore
          _Eventify.emit('change:*', prop, val); // @ts-ignore
          _Eventify.emit('change:' + String(prop), val, prev);
        }
        // @ts-ignore
        _Eventify.emit('*', prop, val, prev);
      } catch (message) {
        console.error(message);
      }
      return true;
    }
  });
  Object.defineProperty(eventObject, 'raw', {
    get() {
      return object;
    }
  });
  return eventObject;
  // return eventObject as EventObjectReturnType<OBJ>;
}
function deferrify(params) {
  let resolve = null;
  let reject = null;
  const promise = new Promise((resolveFunc, rejectFunc) => {
    var _a;
    resolve = resolveFunc;
    reject = rejectFunc;
    if ((params === null || params === void 0 ? void 0 : params.signal) instanceof Promise) {
      params.signal.catch(reject);
    } else if ((_a = params === null || params === void 0 ? void 0 : params.signal) === null || _a === void 0 ? void 0 : _a.aborted) {
      reject();
    }
  });
  return {
    promise,
    resolve,
    reject
  };
}
class Promised extends Promise {
  constructor(executor) {
    super((resolve, reject) => {
      this.resolve = resolve;
      this.reject = reject;
      // @ts-ignore
      if (executor !== undefined) executor(resolve, reject);
    });
  }
}
const sleep = delay => function chainDelay(args) {
  return new Promise(res => {
    setTimeout(() => res(args), delay);
  });
};
 
/***/ }),
 
/***/ 767:
/***/ ((module, __webpack_exports__, __webpack_require__) => {
 
"use strict";
/* harmony export */ __webpack_require__.d(__webpack_exports__, {
/* harmony export */   "default": () => (__WEBPACK_DEFAULT_EXPORT__)
/* harmony export */ });
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(653);
/* harmony import */ var _node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0__);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(102);
/* harmony import */ var _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(_node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1__);
// Imports
 
 
var ___CSS_LOADER_EXPORT___ = _node_modules_css_loader_dist_runtime_api_js__WEBPACK_IMPORTED_MODULE_1___default()((_node_modules_css_loader_dist_runtime_noSourceMaps_js__WEBPACK_IMPORTED_MODULE_0___default()));
// Module
___CSS_LOADER_EXPORT___.push([module.id, `#minimap {
    position: absolute;
    top: 0;
    left: 0;
    width: 100%;
    height: 100%;
    pointer-events: none;
}
#ds-minimap {
    position: fixed;
    bottom: 15px;
    right: 15px;
    width: 200px;
    height: 200px;
    border: 2px solid rgba(255, 255, 255, 0.3);
    border-radius: 10px;
    overflow: hidden;
    background-color: rgba(20, 20, 20, 0.75);
    box-shadow: 0 4px 10px rgba(0, 0, 0, 0.5);
}
#ds-minimap .background {
    display: grid;
    grid-template-columns: repeat(5, 1fr);
    grid-template-rows: repeat(5, 1fr);
    width: 100%;
    height: 100%;
}
#ds-minimap .sector {
    display: flex;
    justify-content: center;
    align-items: center;
    color: #ddd;
    font-size: 12px;
    border: 1px solid rgba(255, 255, 255, 0.2);
    transition:
        background-color 0.3s ease,
        transform 0.2s ease;
}
#ds-minimap .sector.active {
    background-color: rgba(0, 191, 255, 0.3);
    border: 1px solid #00bfff;
}
`, ""]);
// Exports
/* harmony default export */ const __WEBPACK_DEFAULT_EXPORT__ = (___CSS_LOADER_EXPORT___);
 
 
/***/ }),
 
/***/ 825:
/***/ ((module) => {
 
"use strict";
 
 
/* istanbul ignore next  */
function apply(styleElement, options, obj) {
  var css = "";
  if (obj.supports) {
    css += "@supports (".concat(obj.supports, ") {");
  }
  if (obj.media) {
    css += "@media ".concat(obj.media, " {");
  }
  var needLayer = typeof obj.layer !== "undefined";
  if (needLayer) {
    css += "@layer".concat(obj.layer.length > 0 ? " ".concat(obj.layer) : "", " {");
  }
  css += obj.css;
  if (needLayer) {
    css += "}";
  }
  if (obj.media) {
    css += "}";
  }
  if (obj.supports) {
    css += "}";
  }
  var sourceMap = obj.sourceMap;
  if (sourceMap && typeof btoa !== "undefined") {
    css += "\n/*# sourceMappingURL=data:application/json;base64,".concat(btoa(unescape(encodeURIComponent(JSON.stringify(sourceMap)))), " */");
  }
 
  // For old IE
  /* istanbul ignore if  */
  options.styleTagTransform(css, styleElement, options.options);
}
function removeStyleElement(styleElement) {
  // istanbul ignore if
  if (styleElement.parentNode === null) {
    return false;
  }
  styleElement.parentNode.removeChild(styleElement);
}
 
/* istanbul ignore next  */
function domAPI(options) {
  if (typeof document === "undefined") {
    return {
      update: function update() {},
      remove: function remove() {}
    };
  }
  var styleElement = options.insertStyleElement(options);
  return {
    update: function update(obj) {
      apply(styleElement, options, obj);
    },
    remove: function remove() {
      removeStyleElement(styleElement);
    }
  };
}
module.exports = domAPI;
 
/***/ })
 
/******/ });
/************************************************************************/
/******/ // 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] = {
/******/ 		id: moduleId,
/******/ 		loaded: false,
/******/ 		exports: {}
/******/ 	};
/******/ 
/******/ 	// Execute the module function
/******/ 	__webpack_modules__[moduleId](module, module.exports, __webpack_require__);
/******/ 
/******/ 	// Flag the module as loaded
/******/ 	module.loaded = true;
/******/ 
/******/ 	// Return the exports of the module
/******/ 	return module.exports;
/******/ }
/******/ 
/************************************************************************/
/******/ /* webpack/runtime/compat get default export */
/******/ (() => {
/******/ 	// getDefaultExport function for compatibility with non-harmony modules
/******/ 	__webpack_require__.n = (module) => {
/******/ 		var getter = module && module.__esModule ?
/******/ 			() => (module['default']) :
/******/ 			() => (module);
/******/ 		__webpack_require__.d(getter, { a: getter });
/******/ 		return getter;
/******/ 	};
/******/ })();
/******/ 
/******/ /* webpack/runtime/define property getters */
/******/ (() => {
/******/ 	// define getter functions for harmony exports
/******/ 	__webpack_require__.d = (exports, definition) => {
/******/ 		for(var key in definition) {
/******/ 			if(__webpack_require__.o(definition, key) && !__webpack_require__.o(exports, key)) {
/******/ 				Object.defineProperty(exports, key, { enumerable: true, get: definition[key] });
/******/ 			}
/******/ 		}
/******/ 	};
/******/ })();
/******/ 
/******/ /* webpack/runtime/harmony module decorator */
/******/ (() => {
/******/ 	__webpack_require__.hmd = (module) => {
/******/ 		module = Object.create(module);
/******/ 		if (!module.children) module.children = [];
/******/ 		Object.defineProperty(module, 'exports', {
/******/ 			enumerable: true,
/******/ 			set: () => {
/******/ 				throw new Error('ES Modules may not assign module.exports or exports.*, Use ESM export syntax, instead: ' + module.id);
/******/ 			}
/******/ 		});
/******/ 		return module;
/******/ 	};
/******/ })();
/******/ 
/******/ /* webpack/runtime/hasOwnProperty shorthand */
/******/ (() => {
/******/ 	__webpack_require__.o = (obj, prop) => (Object.prototype.hasOwnProperty.call(obj, prop))
/******/ })();
/******/ 
/******/ /* webpack/runtime/nonce */
/******/ (() => {
/******/ 	__webpack_require__.nc = undefined;
/******/ })();
/******/ 
/************************************************************************/
var __webpack_exports__ = {};
// This entry needs to be wrapped in an IIFE because it needs to be in strict mode.
(() => {
"use strict";
 
// EXTERNAL MODULE: ./Shared/src/utils/Eventify.ts
var Eventify = __webpack_require__(714);
;// ./dev/src/utils/utils.ts
/**
 * Finds all nodes in the given tree structure that match the specified condition.
 */
function find_node(where = window['agarApp'].home, cond) {
  const results = [];
  const find_static = (where = window['agarApp'].home, cond) => {
    function each_children(child, depth) {
      depth += 1;
      child.forEach(ch => {
        if (cond(ch, depth)) results.push(ch);
        ch.children && each_children(ch.children, depth);
      });
    }
    each_children(where, -1);
    return results;
  };
  function each_children(child, depth) {
    var _a, _b, _c, _d, _e, _f, _g;
    depth += 1;
    if (cond(child, depth)) results.push(child);
    child._staticTrees && find_static(child._staticTrees, cond);
    // console.log(depth, 'TAG:', child, child.$vnode?.tag)
    (_a = child.$children) === null || _a === void 0 ? void 0 : _a.forEach(ch => {
      each_children(ch, depth);
    });
    (_b = child.children) === null || _b === void 0 ? void 0 : _b.forEach(ch => {
      each_children(ch, depth);
    });
    (_d = (_c = child._vnode) === null || _c === void 0 ? void 0 : _c.children) === null || _d === void 0 ? void 0 : _d.forEach(ch => {
      each_children(ch, depth);
    });
    (_g = (_f = (_e = child._vnode) === null || _e === void 0 ? void 0 : _e.componentOptions) === null || _f === void 0 ? void 0 : _f.children) === null || _g === void 0 ? void 0 : _g.forEach(ch => {
      each_children(ch, depth);
    });
  }
  each_children(where, -1);
  return results;
}
/**
@example
overrideMethod(ctx, 'drawImage', (originalMethod, args) => {
    return originalMethod.apply(ctx, args);
})
 */
function overrideMethod(obj, methodName, getMethod) {
  const originalMethod = obj[methodName];
  obj[methodName] = function () {
    return getMethod(originalMethod, arguments);
  };
}
function overridePrototype(obj, methodName, getMethod) {
  const originalMethod = obj[methodName];
  return obj[methodName] = getMethod(originalMethod);
}
const updateCssString = (() => {
  const records = {};
  return (name, css) => {
    if (!records[name]) {
      const style = document.createElement('style');
      style.setAttribute('data-css-name', name);
      document.head.appendChild(style);
      records[name] = style;
    }
    records[name].textContent = css;
  };
})();
function setCssVariable(_line, name, value, dimension) {
  const root = document.body;
  if (dimension) value += dimension;
  if (value === 0) {
    value = 'none';
  }
  root.style.setProperty(`--${name}`, String(value));
}
function camelCaseToWords(s) {
  const result = s.replace(/([A-Z])/g, ' $1');
  return result.charAt(0).toUpperCase() + result.slice(1);
}
;// ./dev/src/agario-patches.ts
 
function exposeHxClasses() {
  let $hxClasses;
  const targetProperty = 'ApplicationMain';
  return new Promise(resolve => {
    Object.defineProperty(Object.prototype, targetProperty, {
      set: function (value) {
        delete Object.prototype[targetProperty];
        this.ApplicationMain = value;
        $hxClasses = value;
        Object.assign(window, {
          $hxClasses: this
        });
        resolve(this);
      },
      get: function () {
        return $hxClasses;
      },
      configurable: true,
      enumerable: false
    });
  });
}
function coreInitPatch() {
  overrideMethod(window['core'], 'setFpsCap', originalMethod => {
    return originalMethod(-1);
  });
}
function coreUiPatch() {
  const title = document.querySelector('#title');
  title.innerHTML = 'Doublesplit';
  title.style.fontSize = '2.5em';
}
function coreAdsPatch() {
  var _a, _b, _c, _d, _e;
  // Ads delete
  (_a = find_node(undefined, child => {
    var _a;
    return (_a = child.$vnode) === null || _a === void 0 ? void 0 : _a.tag.includes('-ads');
  })[0]) === null || _a === void 0 ? void 0 : _a.$destroy();
  (_b = find_node(undefined, child => {
    var _a;
    return (_a = child.$vnode) === null || _a === void 0 ? void 0 : _a.tag.includes('-promo');
  })[0]) === null || _b === void 0 ? void 0 : _b.$destroy();
  find_node(undefined, child => {
    var _a, _b;
    return (_b = (_a = child.elm) === null || _a === void 0 ? void 0 : _a.id) === null || _b === void 0 ? void 0 : _b.includes('agar-io');
  }).forEach(child => {
    var _a;
    (_a = child.elm.parentElement) === null || _a === void 0 ? void 0 : _a.removeChild(child.elm);
  });
  find_node(undefined, child => child.playVideoAd).forEach(elem => {
    elem.getVideoTimestamp = () => Date.now();
  });
  {
    const vnode = (_c = find_node(undefined, child => Object.getPrototypeOf(child).hasOwnProperty('hasBottomAd'))) === null || _c === void 0 ? void 0 : _c[0];
    if (vnode) {
      Object.defineProperties(vnode, {
        fastEntry: {
          get: () => true
        }
      });
    }
  }
  // Youtube, FB buttons
  {
    const vnode = find_node(undefined, child => {
      var _a;
      if (((_a = child === null || child === void 0 ? void 0 : child.elm) === null || _a === void 0 ? void 0 : _a.id) == 'socialButtons') return true;
    })[0];
    if (vnode) {
      vnode.elm.parentElement.removeChild(vnode.elm);
    }
  }
  // Skin floating badge
  {
    const bubble = find_node(undefined, child => {
      var _a, _b;
      return (_b = (_a = child.data) === null || _a === void 0 ? void 0 : _a.staticClass) === null || _b === void 0 ? void 0 : _b.includes('bubble');
    })[0];
    (_d = bubble === null || bubble === void 0 ? void 0 : bubble.elm) === null || _d === void 0 ? void 0 : _d.parentElement.removeChild(bubble === null || bubble === void 0 ? void 0 : bubble.elm);
  }
  {
    const vnode = (_e = find_node(undefined, child => Object.getPrototypeOf(child).hasOwnProperty('hasBottomAd'))) === null || _e === void 0 ? void 0 : _e[0];
    if (vnode) {
      ['hasBottomAd', 'hasSideAds'].map(prop => {
        vnode._computedWatchers[prop]['getter'] = () => false;
      });
      Object.defineProperties(vnode, {
        hasBottomAd: {
          get: () => false
        },
        // hasSideAds: {get:()=> false},
        // hasTopAd: {get:()=> false},
        // showSideBanners: {get:()=> false},
        // showBottomBanners: {get:()=> false},
        fastEntry: {
          get: () => true
        }
      });
    }
  }
  document.documentElement.style.setProperty(`--bottom-banner-height`, '0px');
  let agarapp = window['agarApp'];
  Object.defineProperty(window, 'agarApp', {
    get() {
      return agarapp;
    },
    set(value) {
      agarapp = value;
      onAgarApp();
    }
  });
  function onAgarApp() {
    var _a, _b, _c;
    var _d;
    (_a = (_d = window['agarApp']).ads) !== null && _a !== void 0 ? _a : _d.ads = {};
    Object.assign(window['agarApp'].ads, {
      requestAds() {},
      requestAd() {},
      refreshAd() {},
      destroyAd() {},
      adSlots() {},
      enableTargetedAds() {},
      disableTargetedAds() {},
      isTargeted() {},
      supersonicAds: {
        BrandConnectReadyEvent() {},
        BrandConnectDoneEvent() {},
        BrandConnectOpenEvent() {},
        BrandConnectCloseEvent() {},
        BrandConnectCompletedEvent() {},
        hasEngagement() {
          return false;
        }
      }
    });
    if ((_b = window['agarApp']) === null || _b === void 0 ? void 0 : _b.main) ['sendEndSession', 'initDataDog', 'sendAnalyticsInitEvent', 'onGoliathReady', 'onGoliathUnload', 'initAnalytics', 'initGuestAnalytics', 'sendAnalyticsInitEvent', 'initBrowserId'].forEach(prop => {
      window['agarApp'].main[prop] = () => {};
    });
    if ((_c = window['agarApp']) === null || _c === void 0 ? void 0 : _c.MCSDK) ['sendMatchEvent'].forEach(prop => window['agarApp'].MCSDK[prop] = () => {});
  }
  try {
    onAgarApp();
  } catch (e) {}
}
function fixNoServers() {
  let AgarioEndpoints = null;
  class HookXMLHttpRequest extends window.XMLHttpRequest {
    constructor() {
      super();
    }
    open(method, _url, async, username, password) {
      const url = new URL(_url, location.href);
      if (url.pathname.endsWith('/info')) {
        this.addEventListener('load', () => {
          const regions = JSON.parse(this.responseText);
          AgarioEndpoints = regions;
        });
      }
      if (url.pathname.endsWith('/findServerWithFriends')) {
        console.log('Hooked XMLHttpRequest:', method, url);
        this.addEventListener('load', e => {
          const endpoints = JSON.parse(this.responseText);
          if (endpoints.status == 'no_servers') {
            const escapeIndex = (index, count) => (index % count + count) % count;
            const otherRegions = Object.keys(AgarioEndpoints.regions);
            const targetRegion = window['MC'].getRegion();
            const regionIndex = otherRegions.indexOf(targetRegion);
            const tryRegion = escapeIndex(regionIndex + 1, otherRegions.length);
            console.log('Trying region:', otherRegions[tryRegion]);
            setTimeout(() => {
              window['MC'].setRegion(otherRegions[tryRegion], true);
            }, 0);
          }
          if (false) {}
        });
      }
      super.open(method, url, async, username, password);
    }
  }
  window.XMLHttpRequest = HookXMLHttpRequest;
}
// EXTERNAL MODULE: ./dev/src/settings.ts + 4 modules
var settings = __webpack_require__(701);
// EXTERNAL MODULE: external "preact"
var external_preact_ = __webpack_require__(32);
// EXTERNAL MODULE: ./dev/src/ui/Contexts.ts
var Contexts = __webpack_require__(413);
// EXTERNAL MODULE: external "preactHooks"
var external_preactHooks_ = __webpack_require__(632);
;// ./dev/src/utils/minmax.ts
function vh(v) {
  const h = window.innerHeight;
  return v * h / 100;
}
function vw(v) {
  const w = window.innerWidth;
  return v * w / 100;
}
function vmin(v) {
  return Math.min(vh(v), vw(v));
}
function vmax(v) {
  return Math.max(vh(v), vw(v));
}
function gcd(a = window.innerWidth, b = window.innerHeight) {
  return b == 0 ? a : gcd(b, a % b);
}
;// ./dev/src/ui/componetns/hooks.tsx
 
 
 
const scaling = (0,Eventify.EventObject)({
  uiScale: 1
});
function calcScale() {
  const gc = gcd();
  let sizeOfMap = 1;
  const {
    w,
    h
  } = {
    w: 4,
    h: 3
  };
  if (gc * window.innerWidth / (gc * window.innerHeight) > w / h) {
    sizeOfMap = vh(27) / 200;
  } else {
    sizeOfMap = h * vw(27) / w / 200;
  }
  scaling.uiScale = Math.min(1, sizeOfMap);
}
window.addEventListener('resize', calcScale);
calcScale();
function useEventify(effect, deps) {
  const eventify = (0,external_preactHooks_.useMemo)(() => new Eventify.Eventify(), []);
  (0,external_preactHooks_.useEffect)(() => {
    const destroy = effect(eventify);
    return () => {
      if (destroy) destroy();
      eventify.unlisten();
    };
  }, deps);
}
// EXTERNAL MODULE: ./node_modules/preact/jsx-runtime/dist/jsxRuntime.module.js
var jsxRuntime_module = __webpack_require__(557);
;// ./dev/src/ui/componetns/Inputs.tsx
 
 
 
 
function keepValue(a) {
  const e = a;
  if (e.keyCode === 27) {
    e.target.blur();
    e.preventDefault();
  }
}
function UiOption({
  target,
  name
}) {
  const [value, updateValue] = (0,external_preactHooks_.useState)(target.raw[name].value);
  // @ts-ignore
  useEventify(e => e.listenTo(target, name, () => updateValue(target.raw[name].value))(), [name]);
  return (0,jsxRuntime_module.jsx)(UiOptionMarkup
  // @ts-ignore
  , {
    name: camelCaseToWords(target.raw[name].name || name),
    value: value,
    onValue: value => {
      updateValue(value);
      target.proxy[name] = value;
    }
  });
}
function UiOptionMarkup({
  name,
  value,
  onValue
}) {
  return (0,jsxRuntime_module.jsxs)("label", {
    className: "flex flex-row p-1 text-left gap-2",
    children: [(0,jsxRuntime_module.jsx)("div", {
      className: "grow",
      children: name
    }), (0,jsxRuntime_module.jsx)("div", {
      className: "",
      children: (0,jsxRuntime_module.jsxs)("label", {
        className: "switch",
        children: [(0,jsxRuntime_module.jsx)("input", {
          name: Math.random().toString(),
          className: "",
          onChange: e => onValue(e.target['checked']),
          checked: value,
          defaultChecked: value,
          type: "checkbox"
        }), (0,jsxRuntime_module.jsx)("div", {
          className: "slider round",
          "data-on": 'ui_on',
          "data-off": 'ui_off'
        })]
      })
    })]
  });
}
function UiSlider({
  target,
  name
}) {
  const helperRef = (0,external_preactHooks_.useRef)();
  const unit = target.raw[name].unit || '';
  function updateValue(value) {
    helperRef.current.innerText = String(value.toFixed(target.raw[name].precision)) + unit;
  }
  useEventify(e => {
    // @ts-ignore
    e.listenTo(target, name, () => updateValue(target.raw[name].value))();
    return () => e.unlisten();
  }, [name]);
  return (0,jsxRuntime_module.jsx)(SliderRender
  // @ts-ignore
  , {
    name: camelCaseToWords(name),
    value: target.raw[name].value,
    data: target.raw[name],
    onValue: value => {
      target.proxy[name] = value;
      updateValue(value);
    },
    helperRef: helperRef
  });
}
function SliderRender({
  name,
  value,
  data,
  onValue,
  helperRef
}) {
  const rangeRef = (0,external_preactHooks_.useRef)();
  return (0,jsxRuntime_module.jsxs)("label", {
    class: "flex p-1 text-left gap-2",
    children: [(0,jsxRuntime_module.jsx)("div", {
      class: "grow",
      children: name
    }), (0,jsxRuntime_module.jsx)("div", {
      ref: helperRef,
      class: "helper"
    }), (0,jsxRuntime_module.jsx)("div", {
      class: "text-left",
      children: (0,jsxRuntime_module.jsx)("input", {
        name: Math.random().toString(),
        ref: rangeRef,
        class: "",
        type: "range",
        onInput: e => onValue(Number(e.target['value'])),
        min: data.min,
        max: data.max,
        step: data.step,
        value: value,
        defaultValue: value.toString()
      })
    })]
  });
}
function UiSelectbox({
  target,
  name
}) {
  const [value, updateValue] = (0,external_preactHooks_.useState)(target.raw[name].value);
  useEventify(e => {
    const handleStatusChange = () => updateValue(target.raw[name].value);
    // @ts-ignore
    e.listenTo(target, name, handleStatusChange);
    handleStatusChange();
    return () => e.unlisten();
  }, [name]);
  return (0,jsxRuntime_module.jsx)(SelectboxRender, {
    name: camelCaseToWords(name.toString()),
    value: value,
    data: target.raw[name].options,
    onValue: value => {
      // updateValue(value)
      target.proxy[name] = value;
    }
  });
}
function SelectboxRender({
  name,
  value,
  data,
  onValue
}) {
  return (0,jsxRuntime_module.jsxs)("div", {
    className: "flex p-1 text-left gap-2",
    children: [(0,jsxRuntime_module.jsx)("div", {
      className: "grow",
      children: name
    }), (0,jsxRuntime_module.jsx)("div", {
      className: "",
      children: (0,jsxRuntime_module.jsx)("select", {
        name: Math.random().toString(),
        className: "selectbox",
        value: value,
        onChange: e => onValue(isNaN(e.target.value) ? e.target.value : Number(e.target.value)),
        children: Object.entries(data).map(([name, value]) => (0,jsxRuntime_module.jsx)("option", {
          value: value,
          children: camelCaseToWords(name)
        }))
      })
    })]
  });
}
function UiInputbox({
  target,
  name
}) {
  var _a;
  function onValue(value) {
    // const { target, name } = this.props;
    target.proxy[name] = value;
  }
  const [value, updateValue] = (0,external_preactHooks_.useState)(target.raw[name].value);
  useEventify(e => {
    const handleStatusChange = () => updateValue(target.raw[name].value);
    // @ts-ignore
    e.listenTo(target, name, handleStatusChange);
    handleStatusChange();
    return () => e.unlisten();
  }, [name]);
  const display_name = camelCaseToWords(name);
  return (0,jsxRuntime_module.jsxs)("div", {
    class: "flex p-1 text-left gap-2",
    children: [(0,jsxRuntime_module.jsx)("div", {
      class: "grow",
      children: display_name
    }), (0,jsxRuntime_module.jsxs)("div", {
      class: "flex grow",
      style: {
        width: '30%'
      },
      children: [(0,jsxRuntime_module.jsx)("input", {
        name: Math.random().toString(),
        class: "input",
        type: "search",
        inputMode: "text",
        autocomplete: "off",
        style: "width: 100%;",
        placeholder: name.toString(),
        onKeyDown: keepValue,
        onInput: e => onValue(e.target['value']),
        value: value,
        defaultValue: value
      }),  true ? (0,jsxRuntime_module.jsxs)("select", {
        name: 'select-' + Math.random(),
        class: "w-4",
        onChange: _e => {
          const e = _e;
          e.target.value != undefined && onValue(e.target.value);
          e.target.value = '';
          e.target.blur();
        },
        style: "",
        children: [(0,jsxRuntime_module.jsx)("option", {
          value: ""
        }), typeof target.raw[name].default !== 'undefined' && (0,jsxRuntime_module.jsx)("option", {
          value: target.raw[name].default,
          children: "Default"
        }), (_a = Object.entries(target.raw[name].options)) === null || _a === void 0 ? void 0 : _a.map(([key, val]) => (0,jsxRuntime_module.jsx)("option", {
          value: val,
          children: key
        }))]
      }) : 0]
    })]
  });
}
;// ./dev/src/ui/SettingsList.tsx
 
 
function SettingsList({
  array,
  target
}) {
  // @ts-ignore
  const result = array.map(([optName, setting]) => {
    const type = setting.type;
    // @ts-ignore
    if (type == 'OPT') return (0,jsxRuntime_module.jsx)(UiOption, {
      target: target,
      name: optName
    });
    // @ts-ignore
    if (type == 'SLD') return (0,jsxRuntime_module.jsx)(UiSlider, {
      target: target,
      name: optName
    });
    // @ts-ignore
    if (type == 'SEL') return (0,jsxRuntime_module.jsx)(UiSelectbox, {
      target: target,
      name: optName
    });
    // @ts-ignore
    if (type == 'INP') return (0,jsxRuntime_module.jsx)(UiInputbox, {
      target: target,
      name: optName
    });
    // @ts-ignore
    if (type == 'COL') return (0,jsxRuntime_module.jsx)(UiColorbox, {
      target: target,
      name: optName
    });
  });
  return result;
}
;// ./dev/src/ui/Menu.tsx
 
 
 
 
 
 
function MenuButtons() {
  const app = (0,external_preactHooks_.useContext)(Contexts.AppContext);
  const inputRef = (0,external_preactHooks_.useRef)();
  useEventify(e => {
    e.listenTo(app.state, 'ws', () => {
      inputRef.current.value = app.state.ws;
    })();
  }, []);
  return (0,jsxRuntime_module.jsxs)("div", {
    class: 'menu-addon',
    style: {
      marginTop: '4px',
      display: 'flex',
      flexDirection: 'column',
      alignItems: 'center'
    },
    children: [(0,jsxRuntime_module.jsx)("button", {
      style: {
        width: '242px'
      },
      type: "submit",
      class: "btn menu-button ",
      onClick: () => app.spetate(),
      children: "Spectate"
    }), (0,jsxRuntime_module.jsxs)("div", {
      style: {
        display: 'flex',
        gap: '4px',
        paddingTop: '4px'
      },
      children: [(0,jsxRuntime_module.jsx)("input", {
        class: "input-addon",
        placeholder: "server",
        ref: inputRef
      }), (0,jsxRuntime_module.jsx)("button", {
        type: "submit",
        class: "btn menu-button",
        onClick: () => app.connect(inputRef.current.value),
        children: "Connect"
      })]
    })]
  });
}
const Menu = () => {
  return (0,jsxRuntime_module.jsx)("div", {
    style: {
      overflowY: 'scroll'
    },
    onWheel: e => e.stopPropagation(),
    children: (0,jsxRuntime_module.jsx)("div", {
      className: "mx-2",
      children: (0,jsxRuntime_module.jsx)(SettingsList, {
        array: Object.entries(settings.settings.raw),
        target: settings.settings
      })
    })
  });
};
// EXTERNAL MODULE: ./dev/src/ui/Minimap.tsx
var Minimap = __webpack_require__(390);
;// ./dev/src/ui/componetns/preact-portal.tsx
 
 
class Portal extends external_preact_.Component {
  constructor() {
    super(...arguments);
    this.isMounted = false;
  }
  componentDidUpdate(props) {
    for (const i in props) {
      if (props[i] !== this.props[i]) {
        return setTimeout(() => this.renderLayer());
      }
    }
  }
  componentDidMount() {
    this.isMounted = true;
    this.renderLayer = this.renderLayer.bind(this);
    this.renderLayer();
  }
  componentWillUnmount() {
    this.renderLayer(false);
    this.isMounted = false;
    if (this.remote && this.remote.parentNode) this.remote.parentNode.removeChild(this.remote);
  }
  findNode(node) {
    return typeof node === 'string' ? document.querySelector(node) : node;
  }
  renderLayer(show = true) {
    if (!this.isMounted) return;
    // clean up old node if moving bases:
    if (this.props.into !== this.intoPointer) {
      this.intoPointer = this.props.into;
      if (this.into && this.remote) {
        // @ts-ignore
        this.remote = (0,external_preact_.render)((0,jsxRuntime_module.jsx)(PortalProxy, {}), createRootFragment(this.into, this.remote));
      }
      this.into = this.findNode(this.props.into);
    }
    // @ts-ignore
    this.remote = (0,external_preact_.render)((0,jsxRuntime_module.jsx)(PortalProxy, {
      context: this.$state,
      children: show && this.props.children ? [this.props.children] : null
    }), createRootFragment(this.into, this.remote));
  }
  render() {
    return null;
  }
}
class PortalProxy extends external_preact_.Component {
  getChildContext() {
    return this.props.context;
  }
  render({
    children
  } = this.props) {
    return children && children[0] || null;
  }
}
/**
 * A Preact 11+ implementation of the `replaceNode` parameter from Preact 10.
 *
 * This creates a "Persistent Fragment" (a fake DOM element) containing one or more
 * DOM nodes, which can then be passed as the `parent` argument to Preact's `render()` method.
 */
function createRootFragment(parent, replaceNode) {
  if (replaceNode) {
    replaceNode = Array.isArray(replaceNode) ? replaceNode : [replaceNode];
  } else {
    replaceNode = [parent];
    parent = parent.parentNode;
  }
  const s = replaceNode[replaceNode.length - 1].nextSibling;
  const rootFragment = {
    nodeType: 1,
    parentNode: parent,
    firstChild: replaceNode[0],
    childNodes: replaceNode,
    insertBefore: (c, r) => {
      parent.insertBefore(c, r || s);
      return c;
    },
    appendChild: c => {
      parent.insertBefore(c, s);
      return c;
    },
    removeChild: function (c) {
      parent.removeChild(c);
      return c;
    }
  };
  parent.__k = rootFragment;
  return rootFragment;
}
;// ./dev/src/ui/index.tsx
 
 
 
 
 
// import './style.scss' with { type: 'cssfile' };
 
function initLiteui(app) {
  // import('./style.scss', { type: 'cssfile' }).then((module) => {});
  const liteui = document.createElement('div');
  liteui.style = 'display:flex; flex-direction:column; overflow:hidden;';
  document.getElementById('instructions').insertAdjacentElement('afterend', liteui);
  (0,external_preact_.render)((0,jsxRuntime_module.jsx)(jsxRuntime_module.Fragment, {
    children: (0,jsxRuntime_module.jsx)(Portal, {
      into: liteui,
      children: (0,jsxRuntime_module.jsx)(jsxRuntime_module.Fragment, {
        children: (0,jsxRuntime_module.jsxs)("div", {
          "data-portal": true,
          className: "w-full",
          style: "overflow: hidden;display: flex;height: 100%;flex-direction: column;",
          children: [(0,jsxRuntime_module.jsx)(Contexts.AppContext.Provider, {
            value: app,
            children: (0,jsxRuntime_module.jsx)(MenuButtons, {})
          }), (0,jsxRuntime_module.jsx)(Contexts.AppContext.Provider, {
            value: app,
            children: (0,jsxRuntime_module.jsx)(Menu, {})
          })]
        })
      })
    })
  }), document.body);
  const minimapElem = document.createElement('div');
  (0,external_preact_.render)((0,jsxRuntime_module.jsx)(Contexts.AppContext.Provider, {
    value: app,
    children: (0,jsxRuntime_module.jsx)(Minimap.Minimap, {})
  }), minimapElem);
  document.body.insertAdjacentElement('afterbegin', minimapElem);
  const observer = new window.MutationObserver(mtRecs => {
    for (const mtRec of mtRecs) {
      const elem = mtRec.target;
      if (elem.style.display !== 'none') {
        elem.style.display = 'flex';
        elem.style.display = 'flex-direction:column';
      }
    }
  });
  observer.observe(window.document.querySelector('#mainPanel'), {
    attributeFilter: ['style']
  });
}
;// ./dev/src/utils/env.ts
function makeGLobal(name, value) {
  window[name] = value;
  return value;
}
;// ./dev/src/utils/Sampler.ts
class Sampler {
  constructor() {
    this.samplerIndex = 0;
    this.sampler = new Float32Array(30).fill(0);
    this.averagePerSecond = 0;
    this.renderedFrames = 0;
    this.average = 0;
    this.now = 0;
  }
  step() {
    const now = Date.now();
    const elapsed = now - this.now;
    this.now = now;
    const delta = elapsed / 1000;
    const perSecond = 1 / delta;
    let average = 0;
    let howmuchSamples = 0;
    this.sampler[this.samplerIndex] = Math.round(perSecond);
    this.samplerIndex = (this.samplerIndex + 1) % this.sampler.length;
    for (let i = 0; i < Math.min(this.sampler.length, this.renderedFrames); i++) {
      average += this.sampler[i];
      howmuchSamples++;
    }
    average = Math.round(average / howmuchSamples);
    this.average = average;
    if (this.renderedFrames <= this.sampler.length) this.renderedFrames++;
  }
}
;// ./dev/src/utils/storage.ts
var __classPrivateFieldGet = undefined && undefined.__classPrivateFieldGet || function (receiver, state, kind, f) {
  if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
  if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
  return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
};
var _Storage_namespace;
class Storage {
  constructor() {
    _Storage_namespace.set(this, 'ds_');
  }
  set(key, object, namespace = __classPrivateFieldGet(this, _Storage_namespace, "f"), middleware = d => d) {
    localStorage.setItem(namespace + key, middleware(JSON.stringify(object)));
  }
  get(key, namespace = __classPrivateFieldGet(this, _Storage_namespace, "f"), middleware = d => d) {
    let obj = {};
    const rawData = localStorage.getItem(namespace + key);
    if (typeof rawData === 'string') {
      try {
        obj = JSON.parse(middleware(rawData));
      } catch (e) {
        console.error(e);
      }
    }
    return obj;
  }
  clear(key, namespace = __classPrivateFieldGet(this, _Storage_namespace, "f")) {
    return localStorage.removeItem(namespace + key);
  }
}
_Storage_namespace = new WeakMap();
const storage = new Storage();
;// ./dev/src/utils/wasmPatcher.ts
function applyPatch(u8, operations, anyFail) {
  let result = u8;
  for (const {
    pattern,
    payload,
    type
  } of operations) {
    const index = findPattern(result, pattern);
    if (index === -1) {
      console.warn(`Pattern not found: ${pattern.map(b => b.toString(16)).join(' ')}`);
      anyFail();
      continue;
    }
    let patchIndex = index;
    if (type === 'insertAfter') patchIndex = index + pattern.length;else if (type === 'insertBefore') patchIndex = index;else if (type === 'replaceAfter') {
      patchIndex = index + pattern.length;
      const sliceBefore = result.slice(0, patchIndex);
      const sliceAfter = result.slice(patchIndex + payload.length);
      result = concatUint8Arrays([sliceBefore, new Uint8Array(payload), sliceAfter]);
      continue;
    } else if (type === 'replaceBefore') {
      patchIndex = index - payload.length;
      if (patchIndex < 0) throw new Error('replaceBefore would underflow the buffer');
      const sliceBefore = result.slice(0, patchIndex);
      const sliceAfter = result.slice(index);
      result = concatUint8Arrays([sliceBefore, new Uint8Array(payload), sliceAfter]);
      continue;
    }
    // Default insert
    const sliceBefore = result.slice(0, patchIndex);
    const sliceAfter = result.slice(patchIndex);
    result = concatUint8Arrays([sliceBefore, new Uint8Array(payload), sliceAfter]);
  }
  return result;
}
function findPattern(buffer, pattern) {
  for (let i = 0; i <= buffer.length - pattern.length; i++) {
    let match = true;
    for (let j = 0; j < pattern.length; j++) {
      if (buffer[i + j] !== pattern[j]) {
        match = false;
        break;
      }
    }
    if (match) return i;
  }
  return -1;
}
function concatUint8Arrays(arrays) {
  const totalLength = arrays.reduce((sum, arr) => sum + arr.length, 0);
  const result = new Uint8Array(totalLength);
  let offset = 0;
  for (const arr of arrays) {
    result.set(arr, offset);
    offset += arr.length;
  }
  return result;
}
;// ./dev/src/World.ts
 
class World extends Eventify.Eventify {
  get isAgar() {
    var _a;
    return (_a = this.ws) === null || _a === void 0 ? void 0 : _a.url.includes('minic');
  }
  constructor(app) {
    super();
    this.xorBuffer = (buffer, key) => {
      const dataView = new DataView(buffer);
      for (let i = 0; i < dataView.byteLength; i++) {
        dataView.setUint8(i, dataView.getUint8(i) ^ key >>> i % 4 * 8 & 255);
      }
      return buffer;
    };
    this.overWriteWS = _target => {
      const target = _target;
      this.ws = target;
      target._onopen = target.onopen;
      target._onmessage = target.onmessage;
      target.onopen = e => {
        this.reset();
        target._onopen(e);
      };
      target.onmessage = message => {
        target._onmessage(message);
        let offset = 0;
        let msg = message.data;
        if (this.decryptionKey) msg = this.xorBuffer(msg, this.decryptionKey ^ 31122);
        const view = new DataView(msg);
        const opcode = view.getUint8(offset++);
        switch (opcode) {
          case 17:
            const playerX = view.getFloat32(offset, true);
            offset += 4;
            const playerY = view.getFloat32(offset, true);
            offset += 4;
            this.targetX = this.receiveX(playerX);
            this.targetY = this.receiveY(playerY);
            break;
          case 32:
            this.myCellIds.push(view.getUint32(offset, true));
            break;
          case 69:
            this.ghostCells(view, offset);
            break;
          case 241:
            this.decryptionKey = view.getUint32(offset, true);
            break;
          case 255:
            this.handleMessages(this.uncompressMessage(new Uint8Array(view.buffer.slice(5)), new Uint8Array(view.getUint32(offset, true))));
            break;
          default:
            this.handleMessages(new Uint8Array(msg));
        }
      };
    };
    this.websocketHooked = false;
    this.reset();
    this.app = app;
  }
  reset() {
    this.minimap = [];
    this.offsetX = 0;
    this.offsetY = 0;
    this.borderX = 0;
    this.borderY = 0;
    this.targetX = 0;
    this.targetY = 0;
    this.myCellIds = [];
    this.decryptionKey = 0;
    this.mapOffsetFixed = false;
    this.mapShiftX = 0;
    this.mapShiftY = 0;
    this.mapOffsetX = 0;
    this.mapOffsetY = 0;
    this.mapMinX = 0;
    this.mapMinY = 0;
    this.mapMaxX = 0;
    this.mapMaxY = 0;
    this.mapMidX = 0;
    this.mapMidY = 0;
    this.mapSizeH = 0;
    this.mapSizeV = 0;
    this.mapShrinkW = 1;
    this.mapShrinkH = 1;
    this.viewX = 0;
    this.viewY = 0;
    this.mirrorV = false;
    this.mirrorH = false;
  }
  uncompressMessage(input, output) {
    for (let i = 0, j = 0; i < input.length;) {
      const byte = input[i++];
      let literalsLength = byte >> 4;
      if (literalsLength > 0) {
        let length = literalsLength + 240;
        while (length === 255) {
          length = input[i++];
          literalsLength += length;
        }
        const end = i + literalsLength;
        while (i < end) output[j++] = input[i++];
        if (i === input.length) return output;
      }
      const offset = input[i++] | input[i++] << 8;
      if (offset === 0 || offset > j) return -(i - 2);
      let matchLength = byte & 15;
      let length = matchLength + 240;
      while (length === 255) {
        length = input[i++];
        matchLength += length;
      }
      let pos = j - offset;
      const end = j + matchLength + 4;
      while (j < end) output[j++] = output[pos++];
    }
    return output;
  }
  handleMessages(message) {
    let offset = 0;
    const view = new DataView(message.buffer);
    const opcode = view.getUint8(offset++);
    switch (opcode) {
      case 16:
        {
          const eatRecordLength = view.getUint16(offset, true);
          offset += 2;
          for (let i = 0; i < eatRecordLength; i++) offset += 8;
          while (true) {
            const id = view.getUint32(offset, true);
            offset += 4;
            if (id === 0) break;
            const targetX = this.receiveX(view.getInt32(offset, true));
            offset += 4;
            const targetY = this.receiveY(view.getInt32(offset, true));
            offset += 4;
            offset += 2;
            const flags = view.getUint8(offset++);
            const extendedFlags = flags & 128 ? view.getUint8(offset++) : 0;
            if (flags & 2) offset += 3;
            if (flags & 4) while (view.getInt8(offset++) !== 0) {
              /* intentionally left empty */
            }
            if (flags & 8) while (view.getInt8(offset++) !== 0) {
              /* intentionally left empty */
            }
            if (extendedFlags & 4) offset += 4;
            if (this.myCellIds.indexOf(id) !== -1) {
              this.targetX = targetX;
              this.targetY = targetY;
            }
          }
          const removeLength = view.getUint16(offset, true);
          offset += 2;
          for (let i = 0; i < removeLength; i++) {
            const removedID = view.getUint32(offset, true);
            offset += 4;
            if (this.myCellIds.includes(removedID)) this.myCellIds = this.myCellIds.filter(id => id != removedID);
          }
        }
        break;
      case 64:
        const minx = view.getFloat64(offset, true);
        offset += 8;
        const miny = view.getFloat64(offset, true);
        offset += 8;
        const maxx = view.getFloat64(offset, true);
        offset += 8;
        const maxy = view.getFloat64(offset, true);
        if (!this.mapOffsetFixed) {
          this.offsetX = (minx + maxx) / 2;
          this.offsetY = (miny + maxy) / 2;
          this.borderX = maxx - minx;
          this.borderY = maxy - miny;
          this.setMapOffset(minx, miny, maxx, maxy);
          this.mapOffsetFixed = true;
        }
        break;
    }
  }
  setMapOffset(left, top, right, bottom) {
    const isAgar = this.ws.url.includes('minic');
    if (right - left > 14000 && bottom - top > 14000 || !isAgar) {
      if (this.mapOffsetFixed) return;
      if (isAgar) {
        const side = 14142;
        this.mapShrinkW = side / (right - left);
        this.mapShrinkH = side / (bottom - top);
        left = this.shrinkX(left);
        top = this.shrinkY(top);
        right = this.shrinkX(right);
        bottom = this.shrinkY(bottom);
      }
      this.mapShiftY = 0;
      this.mapShiftX = 0;
      const prX = -(right - left) * 0.5;
      const prY = -(bottom - top) * 0.5;
      const diffX = prX - left;
      const diffY = prY - top;
      this.mapShiftX = -diffX;
      this.mapShiftY = -diffY;
      left = this.shiftX(left);
      top = this.shiftY(top);
      right = this.shiftX(right);
      bottom = this.shiftY(bottom);
      this.mapOffsetX = (right - left) * 0.5 - right;
      this.mapOffsetY = (bottom - top) * 0.5 - bottom;
      this.mapMinX = left;
      this.mapMinY = top;
      this.mapMaxX = right;
      this.mapMaxY = bottom;
      this.mapMidX = (this.mapMaxX + this.mapMinX) * 0.5;
      this.mapMidY = (this.mapMaxY + this.mapMinY) * 0.5;
      this.mapSizeH = this.mapMaxX - this.mapMinX;
      this.mapSizeV = this.mapMaxY - this.mapMinY;
      if (!this.mapOffsetFixed) {
        this.viewX = (right + left) * 0.5;
        this.viewY = (bottom + top) * 0.5;
      }
      this.mapOffsetFixed = true;
    } else {}
  }
  ghostCells(view, offset) {
    this.minimap = [];
    let x = 0,
      y = 0,
      mass = 0;
    const length = view.getUint16(offset, true);
    offset += 2;
    for (let i = 0; i < length; i++) {
      x = this.receiveX(view.getInt32(offset, true));
      offset += 4;
      y = this.receiveY(view.getInt32(offset, true));
      offset += 4;
      mass = view.getUint32(offset, true);
      offset += 5;
      this.minimap.push({
        x: x,
        y: y,
        size: ~~Math.sqrt(100 * mass),
        mass: mass
      });
    }
  }
  unshrinkX(x) {
    return x / this.mapShrinkW;
  }
  unshrinkY(y) {
    return y / this.mapShrinkH;
  }
  shrinkX(x) {
    return x * this.mapShrinkW;
  }
  shrinkY(y) {
    return y * this.mapShrinkH;
  }
  unshiftX(x) {
    return x - -this.mapShiftX;
  }
  unshiftY(y) {
    return y - -this.mapShiftY;
  }
  shiftX(x) {
    return x - this.mapShiftX;
  }
  shiftY(y) {
    return y - this.mapShiftY;
  }
  invflipX(x) {
    return this.mirrorH ? x : this.mapMaxX - (x - this.mapMinX);
  }
  invflipY(y) {
    return this.mirrorV ? y : this.mapMaxY - (y - this.mapMinY);
  }
  flipX(x) {
    return !this.mirrorH ? x : this.mapMaxX - (x - this.mapMinX);
  }
  flipY(y) {
    return !this.mirrorV ? y : this.mapMaxY - (y - this.mapMinY);
  }
  receiveX(x) {
    x = this.shrinkX(x);
    x = this.shiftX(x);
    x = this.flipX(x);
    return x;
  }
  receiveY(y) {
    y = this.shrinkY(y);
    y = this.shiftY(y);
    y = this.flipY(y);
    return y;
  }
  serverX(x) {
    x = this.flipX(x);
    x = this.unshiftX(x);
    x = this.unshrinkX(x);
    return x;
  }
  serverY(y) {
    y = this.flipY(y);
    y = this.unshiftY(y);
    y = this.unshrinkY(y);
    return y;
  }
  drawMinimap(ctx, canvas, clear = true) {
    function safe(number) {
      return number == 0 ? 1 : number;
    }
    if (clear) ctx.clearRect(0, 0, canvas.width, canvas.height);
    this.minimap.forEach(cell => {
      const x = safe(cell.x + this.borderX / 2) / this.borderX * canvas.width;
      const y = safe(cell.y + this.borderY / 2) / this.borderY * canvas.height;
      const size = cell.size / this.borderX * canvas.width + 1;
      ctx.fillStyle = '#ffd700';
      ctx.beginPath();
      ctx.arc(x, y, size, 0, Math.PI * 2);
      ctx.fill();
    });
    const playerX = safe(this.targetX + this.borderX / 2) / this.borderX * canvas.width;
    const playerY = safe(this.targetY + this.borderY / 2) / this.borderY * canvas.height;
    ctx.fillStyle = '#00bfff';
    ctx.beginPath();
    ctx.arc(playerX, playerY, 5, 0, Math.PI * 2);
    ctx.fill();
    const sectorSizeX = canvas.width / 5;
    const sectorSizeY = canvas.height / 5;
    const sectorCol = Math.floor(playerX / sectorSizeX);
    const sectorRow = Math.floor(playerY / sectorSizeY);
    const activeSectorIndex = sectorRow * 5 + sectorCol;
    return Number.isFinite(activeSectorIndex) ? activeSectorIndex : -1;
  }
  initialize() {
    if (this.websocketHooked) return console.error('Error: WebSocket already hooked');
    this.websocketHooked = true;
    // eslint-disable-next-line @typescript-eslint/no-this-alias
    const self = this;
    class WS extends window.WebSocket {
      constructor(url, protocols) {
        const errorStack = new Error().stack;
        const isAgar = /wasm:\/\/|wasm-function|WebAssembly.instantiate/.test(errorStack);
        const isAgarServer = url.includes('minic');
        if (isAgar && !isAgarServer) {
          // window['core'].disableIntegrityChecks(true);
        }
        if (isAgar) self.emit('beforeConnect', url, isAgarServer);
        super(url, protocols);
        if (isAgar) Promise.resolve().then(() => self.overWriteWS(this));
      }
    }
    WS.injectedOnce = false;
    window.WebSocket = WS;
  }
}
;// ./dev/src/App.ts
var __awaiter = undefined && undefined.__awaiter || function (thisArg, _arguments, P, generator) {
  function adopt(value) {
    return value instanceof P ? value : new P(function (resolve) {
      resolve(value);
    });
  }
  return new (P || (P = Promise))(function (resolve, reject) {
    function fulfilled(value) {
      try {
        step(generator.next(value));
      } catch (e) {
        reject(e);
      }
    }
    function rejected(value) {
      try {
        step(generator["throw"](value));
      } catch (e) {
        reject(e);
      }
    }
    function step(result) {
      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
    }
    step((generator = generator.apply(thisArg, _arguments || [])).next());
  });
};
 
 
 
 
 
 
 
 
 
 
class App {
  display_vue() {
    return find_node(window['agarApp'].home, (child, depth) => {
      var _a;
      console.log(child, (_a = child === null || child === void 0 ? void 0 : child.$vnode) === null || _a === void 0 ? void 0 : _a.tag);
      return true;
    });
  }
  constructor() {
    this.sampler = new Sampler();
    this.performance_now = 0; // for speedhack
    this.timer_mp = 1; // time multiplier
    this.waitForSpawn = false; // respawn ways
    this.sector = 5;
    this.stopmovement = false;
    /*** camera zoom ****/
    this.scale = 1;
    /** target cursor world */
    this.mouse = {
      x: 0,
      y: 0
    };
    /** cursor on canvas display */
    this.mouseDisplay = {
      x: 0,
      y: 0
    };
    /** world camera position */
    this.camera = {
      x: 0,
      y: 0
    };
    this.state = (0,Eventify.EventObject)({
      play: false,
      pause: false,
      ws: '',
      isLoggedIn: false
    });
    this.memory = (0,Eventify.EventObject)({
      skinUrl: ''
    });
    /** vue ui */
    this.mainui = null;
    /** exposed emscripten module */
    this.emsc = null;
    /** exposed $hxClasses */
    this.hx = null;
    this.observerPatcher = e => {
      const randomKey = 'app_' + Math.random().toString(36).slice(2, 10);
      window[randomKey] = this;
      const app = 'window.' + randomKey;
      const replacements = {
        registerSkin: [[/("\s?registerSkin\s?"\s?:\s?function\s?\(\s?(.+?)\s?,\s?(.+?)\s?,\s?(.+?)\s?,\s?(.+?)\s?,\s?(.+?)\s?\)\s?\{\s?)/i, `$1${app}.onRegisterSkin($2,$3,$4,$5,$6);`]],
        onConnect: [[/(;..?\s?\.\s?onopen\s?=\s?function\s?\(\s?\)\s?\{\s?)/i, `$1${app}.onConnect(this.url, this);`]],
        mobileData: [[/(\s?if\s?\(\s?window\s?\[\s?"\s?MC\s?"\s?]\s?&&\s?window\s?\[\s?"\s?MC\s?"\s?]\s?\[\s?"\s?onMobileData\s?"\s?]\s?\)\s?window\s?\[\s?"\s?MC\s?"\s?]\s?\[\s?"\s?onMobileData\s?"\s?]\s?\(\s?(.+?)\s?\))/i, `$2=${app}.onPacket($2);$1`]],
        'Emscripten hook': [[/(\w+)\W+instantiateWasm/, `(${app}.onEmscripten($1)), $&`]],
        'Mouse hook': [[/("\s?setTarget\s?"\s?:\s?function\s?\(\s?(.+?)\s?,\s?(.+?)\s?\)\s?\{\s?)/i, `$1 var [$2, $3] = ${app}.syncMouse($2, $3);`]],
        'Player Zoom': [[/("\s?playerZoom\s?"\s?:\s?function\s?\(\s?(.+?)\s?\)\s?\{\s?)/i, `$1$2=${app}.onPlayerZoom($2);`]],
        'WebSocket onclose': [[/(;..?\s?\.\s?onclose\s?=\s?function\s?\(\s?\)\s?\{\s?)/i, `$1${app}.onDisconnect(this);`]],
        'WebSocket onerror': [[/(;..?\s?\.\s?onerror\s?=\s?function\s?\(\s?\)\s?\{\s?)/i, `$1${app}.onDisconnect(this);`]],
        'Binary Patch': [[/(instantiate\(\s?)([^,]+)/, `$1${app}.patchWasm($2)`]],
        something: [[/([a-z]{6}\s?[a-z|A-Z]{16}\s?\(\s?([a-z]{6})\s?,\s?[a-z|A-Z]{10}\s?,\s?[a-z|A-Z]{7}\s?,\s?[a-zA-Z]{8}\s?\)\s?\{\s?)/i, '$1$2=true;']]
      };
      for (const [name, array] of Object.entries(replacements)) {
        let current = 0;
        for (const [regexp, replacer] of array) {
          if (regexp.test(e)) {
            e = e.replace(regexp, replacer);
            current++;
          } else {
            console.log(`[Not Found - ${current}]: `, name);
          }
        }
      }
      return e;
    };
    this.calls = [];
    this.world = new World(this);
    this.world.on('beforeConnect', this.beforeConnect.bind(this));
    const storageName = 'lite_settings';
    settings.settings.import(Object.assign(Object.assign({}, settings.settings.export()), storage.get(storageName)));
    settings.settings.on('*', _ => {
      storage.set(storageName, settings.settings.export());
    });
    Object.assign(this.memory, storage.get('memory'));
    this.memory.on('*', () => {
      console.log('nick', this.memory);
      storage.set('memory', this.memory);
    });
    // this.memory.on('skinUrl', () => {
    //     // @ts-ignore
    //     if (this.memory.skinUrl)
    //         try {
    //             window['core'].registerSkin(
    //                 document.getElementById('nick').value,
    //                 null,
    //                 this.memory.skinUrl,
    //                 2,
    //                 null
    //             );
    //         } catch (e) {}
    // })();
    exposeHxClasses().then(hx => {
      this.hx = hx;
    });
    this.initObserver().then(() => {
      this.world.initialize();
      this.waitCore().then(() => {
        this.handleCoreInit();
      });
    });
    overrideMethod(window.console, 'log', function (o, args) {
      var _a, _b;
      if ((_b = (_a = args[0]).startsWith) === null || _b === void 0 ? void 0 : _b.call(_a, '       ,,,,,')) return window.console.log = o;
      return o.apply(this, args);
    });
  }
  loadAndPatchCore(url, resolve) {
    return __awaiter(this, void 0, void 0, function* () {
      try {
        const request = new XMLHttpRequest();
        request.open('GET', url, false);
        request.onload = () => {
          const patchedText = this.observerPatcher(request.responseText);
          const blob = new Blob([patchedText], {
            type: 'text/javascript'
          });
          const blobURL = URL.createObjectURL(blob);
          const script = document.createElement('script');
          script.id = 'agario.core.js';
          script.src = blobURL;
          script.onload = () => {
            URL.revokeObjectURL(blobURL);
            resolve();
          };
          document.body.appendChild(script);
        };
        request.send();
      } catch (error) {
        console.error('[ERROR] Failed to load and patch core:', error);
      }
    });
  }
  initObserver() {
    const deferred = (0,Eventify.deferrify)();
    const observer = new window.MutationObserver(mtRecs => {
      var _a;
      for (const mtRec of mtRecs) {
        for (let i = 0; i < mtRec.addedNodes.length; i++) {
          const elem = mtRec.addedNodes[i];
          const [t] = elem.src && elem.src.match(/agario\.core\.js.+/i) || [];
          if (t) {
            observer.disconnect();
            elem.remove();
            (_a = elem.parentNode) === null || _a === void 0 ? void 0 : _a.removeChild(elem);
            this.loadAndPatchCore(t, deferred.resolve);
          }
        }
      }
    });
    observer.observe(document, {
      childList: true,
      subtree: true
    });
    return deferred.promise;
  }
  patchWasm(u) {
    let anyFail = false;
    const patchedUint8Array = applyPatch(new Uint8Array(u), [{
      pattern: [0x45, 0x0d, 0x00, 0x20, 0x02, 0x10, 0x0f, 0x20, 0x01, 0x20, 0x02, 0x10, 0x1e, 0x21, 0x01],
      payload: [0x20, 0x00, 0x28, 0x02, 0x1c, 0x45, 0x04, 0x40, 0x0f, 0x0b],
      type: 'insertAfter'
    }, {
      pattern: [0x81, 0x03, 0x84, 0x03, 0x10, 0x87, 0x03, 0x86, 0x03, 0x85, 0x03, 0x0a],
      payload: [203],
      type: 'replaceAfter'
    }, {
      pattern: [0x00, 0x20, 0x00, 0x20, 0x04, 0x37, 0x03, 0x08, 0x20, 0x03, 0x41, 0x10, 0x6a, 0x24, 0x00, 0x0b],
      payload: [138],
      type: 'replaceAfter'
    }, {
      pattern: [0x01, 0x2d, 0x00, 0x07, 0x20, 0x02, 0x41, 0x1b, 0x6c, 0x41, 0x01, 0x6a, 0x73, 0x3a, 0x00, 0x07, 0x20, 0x1f, 0xbf, 0x44, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00],
      payload: [0, 0],
      type: 'replaceAfter'
    }], () => anyFail = true);
    if (anyFail) return u;
    return patchedUint8Array.buffer;
  }
  waitCore() {
    return __awaiter(this, void 0, void 0, function* () {
      const deferred = (0,Eventify.deferrify)();
      addEventListener('core_init_complete', () => {
        var _a;
        if (!window['core']) {
          // backup event
          if ((_a = window['MC']) === null || _a === void 0 ? void 0 : _a['onAgarioCoreLoaded']) {
            const old_loaded = window['MC']['onAgarioCoreLoaded'];
            window['MC']['onAgarioCoreLoaded'] = function () {
              deferred.resolve();
              window['MC']['onAgarioCoreLoaded'] = old_loaded;
              return old_loaded.apply(this, arguments);
            };
            return;
          }
          // deadline mode
          Object.defineProperty(window, 'core', {
            get: () => window['_core'],
            set: value => (window['_core'] = value, deferred.resolve())
          });
          return;
        }
        deferred.resolve();
      });
      addEventListener('event_regions_update', () => __awaiter(this, void 0, void 0, function* () {}));
      // let rafRequest: any = null;
      // function watchVue() {
      //     rafRequest = requestAnimationFrame(() => {
      //         if (window['agarApp']) cancelAnimationFrame(rafRequest);
      //         coreAdsPatch();
      //     });
      // }
      // watchVue();
      // Object.defineProperty(window, 'mcReady', {
      //     get: () => () => {},
      //     set: () => {}
      // });
      return deferred.promise;
    });
  }
  handleCoreInit() {
    coreInitPatch();
    coreAdsPatch();
    fixNoServers();
    coreUiPatch();
    this.init();
    this.onCoreInit();
    initLiteui(this);
  }
  modifyScore(sourceString) {
    if (!this.state.play) sourceString = '';
    return `${sourceString}`;
  }
  init() {
    const modifyScore = this.modifyScore.bind(this);
    const onPlayerSpawn = this.onPlayerSpawn.bind(this);
    const onPlayerDeath = this.onPlayerDeath.bind(this);
    // timelord.activate();
    // this.performance_now = window.performance['_now']();
    // const updateRealTime = (realTime_ms: number) => {
    //     const dt = realTime_ms - this.performance_now;
    //     timelord.stepTime(dt * (settings.proxy.AnimationDelay / 100), dt * this.timer_mp);
    //     this.performance_now = realTime_ms;
    //     window['_requestAnimationFrame'](updateRealTime);
    // };
    // updateRealTime(this.performance_now);
    overridePrototype(CanvasRenderingContext2D.prototype, 'fillText', o => {
      return function () {
        if (arguments[0].includes('Scor')) {
          arguments[0] = modifyScore(arguments[0]);
        } else if (arguments[0].startsWith('Leaderboard')) {
          arguments[0] = settings.settings.proxy.LeaderboardTitle;
        }
        return o.apply(this, arguments);
      };
    });
    overridePrototype(CanvasRenderingContext2D.prototype, 'measureText', o => {
      return function () {
        if (arguments[0].includes('Scor')) {
          arguments[0] = modifyScore(arguments[0]);
        }
        return o.apply(this, arguments);
      };
    });
    overrideMethod(window['MC'], 'onPlayerSpawn', function (o, args) {
      o.apply(this, args);
      onPlayerSpawn(...args);
    });
    overrideMethod(window['MC'], 'onPlayerDeath', function (o, args) {
      o.apply(this, args);
      onPlayerDeath(...args);
    });
  }
  onEmscripten(Module) {
    var _a, _b;
    this.emsc = Module;
    makeGLobal('emsc', Module);
    console.log('emsc', Module);
    this.canvas = document.getElementById('canvas');
    const ctx = this.canvas.getContext('2d');
    const world = this.world;
    function numberIsInRange(value, min, max) {
      return value >= min && value <= max;
    }
    // eslint-disable-next-line @typescript-eslint/no-this-alias
    const self = this;
    const traceCalls = ['clearRect', 'drawImage', 'fillText', 'strokeText', 'fillRect', 'strokeRect',
    // 'beginPath',
    'moveTo',
    // 'lineTo',
    // 'arc',
    'scale', 'save', 'restore', 'translate', 'transform', 'setTransform'];
    let gotScale = false;
    let callNumber = -1;
    traceCalls.forEach(method => {
      // @ts-ignore
      overrideMethod(ctx, method, function (o, args) {
        callNumber++;
        // self.calls.push(method);
        // if (callNumber === 3)  console.log('scale', ...args);
        // if (callNumber === 2) {
        //     console.log('translate', ...args);
        // }
        // if (numberIsInRange(callNumber - 1, 1, 7))  function () {}; // Off grid
        const cmd = o.apply(ctx, args);
        return cmd;
      });
    });
    overrideMethod(ctx, 'scale', function (o, args) {
      if (!gotScale) {
        gotScale = true;
        self.scale = args[0];
      }
      const cmd = o.apply(ctx, args);
      return cmd;
    });
    // if (callNumber == 9) console.log('canvas', args[0], args[1]);
    // if (callNumber == 11) console.log('cam', args[0], args[1]);
    overrideMethod(ctx, 'drawImage', function (o, args) {
      let dx = 0,
        dy = 0,
        dw = 0,
        dh = 0;
      if (args.length == 9) {
        dx = args[5];
        dy = args[6];
        dw = args[7];
        dh = args[8];
      } else if (args.length == 3) {
        dx = args[1];
        dy = args[2];
      }
      const cmd = o.apply(ctx, args);
      return cmd;
    });
    /*** Camera hook ***/
    let translateCall = -1;
    overrideMethod(ctx, 'translate', function (o, args) {
      translateCall++;
      if (translateCall == 2) {
        self.camera.x = args[0];
        self.camera.y = args[1];
        self.drawBackground(ctx, world, o);
      }
      return o.apply(ctx, args);
    });
    /*** Before render ***/
    (_a = Module['preMainLoop']) !== null && _a !== void 0 ? _a : Module['preMainLoop'] = () => {};
    overrideMethod(Module, 'preMainLoop', (o, args) => {
      this.calls = [];
      o.apply(this, args);
    });
    /*** After render ***/
    (_b = Module['postMainLoop']) !== null && _b !== void 0 ? _b : Module['postMainLoop'] = () => {};
    overrideMethod(Module, 'postMainLoop', (o, args) => {
      this.sampler.step();
      callNumber = -1;
      translateCall = -1;
      gotScale = false;
      this.drawHud(ctx);
      o.apply(this, args);
    });
  }
  onRegisterSkin() {
    // console.log('register skin', arguments);
  }
  onCoreInit() {
    settings.settings.on('AcidMode', v => {
      window['core'].setAcid(v);
    })(settings.settings.proxy.AcidMode);
    /** COINS COLLECTION */
    {
      const collectCoins = () => {
        if (this.state.isLoggedIn && settings.settings.proxy.AutoCollectCoins) {
          window['agarApp'].API.getFreeCoins();
          window['agarApp'].API.closeTopView();
        }
      };
      addEventListener('login', () => this.state.isLoggedIn = true);
      addEventListener('logout', () => this.state.isLoggedIn = false);
      addEventListener('free_coins_timer', collectCoins);
      this.state.on('isLoggedIn', collectCoins);
      settings.settings.on('AutoCollectCoins', collectCoins)();
    }
  }
  get menuShow() {
    if (!this.mainui) this.mainui = find_node(window['agarApp'].home, child => {
      var _a, _b;
      return (_b = (_a = child.$vnode) === null || _a === void 0 ? void 0 : _a.tag) === null || _b === void 0 ? void 0 : _b.toLowerCase().includes('mainui');
    })[0];
    if (!this.mainui) return false;
    return this.mainui.menuShow;
  }
  beforeConnect(url, isAgar) {}
  onConnect(url) {
    console.log('Connected', url);
    this.state.ws = url;
    //onconnect
    if (this.waitForSpawn) {
      window['MC'].playGame();
      this.waitForSpawn = false;
    }
    // window['core'].setFadeout(false);
    // window['core'].setFadeout = () => {};
    this.disableMenuBackground();
  }
  disableMenuBackground() {
    if (!this.world.isAgar) return;
    this.emsc._ac_special_on();
    window['core'].setFpsCap(-1);
    window['core'].setFadeout(false);
    requestAnimationFrame(() => {
      window['core'].setFadeout(true);
    });
    this.emsc._ac_spectate();
  }
  spetate() {
    var _a;
    (_a = find_node(undefined, child => child === null || child === void 0 ? void 0 : child.spectate)[0]) === null || _a === void 0 ? void 0 : _a.spectate();
  }
  connect(url) {
    window['core'].disableIntegrityChecks(!url.includes('minic'));
    if (window['raga'] && url.indexOf('raga') > -1) {
      window['raga'].isSwitchingGameMode = true;
      window['raga'].gameMode = 'ragaffa-16x';
    }
    window['core'].connect(url);
    // window['core'].disconnect()
    // window['MC'].reconnect(true)
  }
  respawn() {
    if (this.state.play) {
      this.connect(this.state.ws);
      this.waitForSpawn = true;
    } else {
      window['core'].setFadeout(false);
      window['core'].sendSpectate();
      window['MC'].playGame();
      setTimeout(() => {
        // MC.playGame()
        // window['agarApp'].home.$children[0].$children[0].spectate()
        // window['agarApp'].home.$children[0].$children[0].play()
        // window['agarApp'].home.$children[0].onHideMainMenu()
        // window['agarApp'].home.$children[0].onGameStart()
      }, 200);
    }
  }
  onPlayerSpawn(...args) {
    this.state.play = true;
    this.reset();
  }
  onPlayerDeath(...args) {
    find_node(undefined, child => {
      if (child.fastEntry !== undefined) return true;else return false;
    }).forEach(child => {
      !child.fastEntry && Object.defineProperty(child, 'fastEntry', {
        get: () => true,
        set: x => x
      });
    });
    window['core'].setFadeout(true);
    const setInterval = window['_setInterval'] || window.setInterval;
    const clearInterval = window['_clearInterval'] || window.clearInterval;
    const setTimeout = window['_setTimeout'] || window.setTimeout;
    const clearTimeout = window['_clearTimeout'] || window.clearTimeout;
    this.state.play = false;
    this.reset();
    if (!window['agarApp'].home.$children[0].$children[0].showMenu && settings.settings.proxy.AutoRespawn) {
      this.respawn();
      return true;
    } else {
      const prev = this.timer_mp;
      this.timer_mp = 10000;
      setTimeout(() => this.timer_mp = prev, 800);
    }
    // window.setTimeout(MC.showNickDialog, 500);
  }
  onPacket(packet) {
    return packet;
  }
  reset() {
    this.stopmovement = false;
    this.world.myCellIds = [];
  }
  dumpMem() {
    const blob = new Blob([this['emsc'].buffer]);
    const a = document.createElement('a');
    a.href = URL.createObjectURL(blob);
    a.download = 'dump.bin';
    a.click();
    URL.revokeObjectURL(a.href);
  }
  onDisconnect(obj) {
    console.log('disconnected', obj);
  }
  onPlayerZoom(zoom) {
    return zoom;
  }
  syncCamera(x, y) {
    this.camera.x = x;
    this.camera.y = y;
  }
  syncMouse(mouseDisplayX, mouseDisplayY) {
    this.mouseDisplay.x = mouseDisplayX;
    this.mouseDisplay.y = mouseDisplayY;
    this.calcMosuseWorld();
    if (this.state.pause) {
      return [this.canvas.width / 2, this.canvas.height / 2];
    }
    return [mouseDisplayX, mouseDisplayY];
  }
  calcMosuseWorld() {
    const camX = this.camera.x + this.world.offsetX;
    const camY = this.camera.y + this.world.offsetY;
    const canvasCenterX = this.canvas.width / 2;
    const canvasCenterY = this.canvas.height / 2;
    this.mouse.x = -((canvasCenterX - this.mouseDisplay.x) / this.scale + camX);
    this.mouse.y = -((canvasCenterY - this.mouseDisplay.y) / this.scale + camY);
  }
  renderLoop() {}
  drawBackground(ctx, world, translate = ctx['translate']) {
    const offsetX = this.camera.x + this.world.offsetX;
    const offsetY = this.camera.y + this.world.offsetY;
    const initialAlpha = ctx.globalAlpha;
    translate(offsetX, offsetY);
    /*** Map Border ****/
    if (settings.settings.proxy.MapBorder) {
      ctx.globalAlpha = 0.2;
      ctx.lineWidth = 20;
      ctx.fillStyle = 'green';
      ctx.strokeRect(this.world.mapMinX, this.world.mapMinY, this.world.mapSizeH, this.world.mapSizeV);
      ctx.globalAlpha = initialAlpha;
    }
    const parselw = this.world.mapSizeH / this.sector;
    const parselh = this.world.mapSizeV / this.sector;
    /*** Map Sectors ****/
    if (settings.settings.proxy.MapSectors) {
      ctx.beginPath();
      ctx.lineWidth = 10;
      ctx.strokeStyle = 'green';
      ctx.globalAlpha = 0.2;
      for (let zi = 1; zi < this.sector; zi++) {
        ctx.moveTo(this.world.mapMinX, this.world.mapMinY + parselw * zi);
        ctx.lineTo(this.world.mapMaxX, this.world.mapMinY + parselw * zi);
        ctx.moveTo(this.world.mapMinX + parselh * zi, this.world.mapMinY);
        ctx.lineTo(this.world.mapMinX + parselh * zi, this.world.mapMaxY);
      }
      ctx.stroke();
      ctx.closePath();
      ctx.globalAlpha = initialAlpha;
    }
    /*** Sector Label ****/
    if (settings.settings.proxy.MapSectorLabels) {
      ctx.textAlign = 'center';
      ctx.textBaseline = 'middle';
      ctx.font = parselw / 2.8 + 'px Segoe Print';
      ctx.globalAlpha = 0.2;
      ctx.fillStyle = 'green';
      const bucw = parselw / 2,
        buch = parselh / 2;
      for (let sat = 0; sat < this.sector; sat++) {
        const label = String.fromCharCode(65 + sat);
        for (let sut = 0; sut < this.sector; sut++) {
          ctx.fillText(label + (sut + 1), this.world.mapMinX + parselw * sut + bucw, this.world.mapMinY + parselh * sat + buch);
        }
      }
      ctx.globalAlpha = initialAlpha;
    }
    /*** C3 sign ****/
    ctx.textBaseline = 'middle';
    ctx.textAlign = 'center';
    ctx.font = '380px Segoe Print';
    ctx.globalAlpha = 0.5;
    ctx.fillStyle = '#808080';
    ctx.fillText('Doublesplit', 0, 0);
    ctx.globalAlpha = initialAlpha;
    translate(-offsetX, -offsetY);
    // ctx.fillStyle = 'rgba(0, 0, 0, 0.3)';
    // ctx.scale(1 / this.zoomvalue, 1 / this.zoomvalue);
    // ctx.fillRect(0, 0 + ctx.canvas.height / 2 - 150, 200, 100);
    // ctx.scale(this.zoomvalue, this.zoomvalue);
    return;
    /*** Mini Map ****/
    if (false) {
      const minimapWidth = 100;
      const minimapHeight = 100;
      const mapMinX = this.world.mapMinX;
      const mapMinY = this.world.mapMinY;
      const mapMaxX = this.world.mapMaxX;
      const mapMaxY = this.world.mapMaxY;
      const mapWidth = this.world.mapSizeH;
      const mapHeight = this.world.mapSizeV;
      const viewX = this.camera.x;
      const viewY = this.camera.y;
      const mw = minimapWidth / 5;
      const blurrylines = 0;
      let leftrate = (viewX - mapMinX) / mapWidth;
      let toprate = (viewY - mapMinY) / mapHeight;
      let minileft = Math.round(minimapWidth * leftrate * 100) / 100;
      let minitop = Math.round(minimapHeight * toprate * 100) / 100;
      ctx.beginPath();
      ctx.clearRect(0, 0, minimapWidth, minimapHeight);
      ctx.globalAlpha = 0.5;
      ctx.lineWidth = 0.5;
      ctx.strokeStyle = 'blue'; //settings.raw.border.string;
      ctx.strokeRect(blurrylines + mw, blurrylines + mw, minimapWidth - mw * 2, minimapHeight - mw * 2);
      ctx.strokeRect(blurrylines + mw * 2, blurrylines + mw * 2, minimapWidth - mw * 4, minimapHeight - mw * 4);
      ctx.globalAlpha = 1;
      ctx.fillStyle = 'red'; //settings.raw.miniblob.string;
      ctx.arc(minileft, minitop, 5, 0, 2 * Math.PI);
      ctx.fill();
      ctx.closePath();
      ctx.beginPath();
      ctx.fillStyle = 'red';
      leftrate = minimapWidth / mapWidth;
      toprate = minimapHeight / mapHeight;
      minileft = Math.round((mapWidth / 2 + (this.mouse.x - offsetX)) * leftrate);
      minitop = Math.round((mapHeight / 2 + (this.mouse.y - offsetY)) * toprate);
      ctx.arc(minileft, minitop, 3, 0, 2 * Math.PI);
      ctx.fill();
      ctx.closePath();
    }
  }
  drawHud(ctx) {
    ctx.fillStyle = 'rgba(0, 0, 0, 0.3)';
    ctx.fillRect(0, 0, 0, 0);
  }
}
// if ('hot' in module) {
//     // @ts-ignore
//     module['hot'].decline();
//     // @ts-ignore
//     module['hot'].dispose(() => {
//         location.reload();
//     });
// }
;// ./dev/src/dev.ts
 
function enableVueDevtools() {
  overrideMethod(window.Object, 'defineProperty', (originalMethod, args) => {
    if (args[1] === 'config') {
      const orig_getter = args[2].get;
      args[2].get = function () {
        const vueConfig = orig_getter();
        vueConfig.devtools = true;
        vueConfig.productionTip = true;
        return () => vueConfig;
      };
      window.Object.defineProperty = originalMethod;
    }
    return originalMethod.apply(window.Object, args);
  });
}
function enableFastCanvasView() {
  Object.defineProperty(window.HTMLCanvasElement.prototype, 'aaa', {
    get() {
      this.toBlob(blob => {
        const blobUrl = URL.createObjectURL(blob);
        createPopupWin(blobUrl, 'Canvas', 800, 600);
      });
      return 1;
    }
  });
}
function createPopupWin(pageURL, pageTitle, popupWinWidth, popupWinHeight) {
  const left = (screen.width - popupWinWidth) / 2;
  const top = (screen.height - popupWinHeight) / 4;
  return window.open(pageURL, pageTitle, 'resizable=yes, width=' + popupWinWidth + ', height=' + popupWinHeight + ', top=' + top + ', left=' + left);
}
// EXTERNAL MODULE: ./node_modules/style-loader/dist/runtime/injectStylesIntoStyleTag.js
var injectStylesIntoStyleTag = __webpack_require__(72);
var injectStylesIntoStyleTag_default = /*#__PURE__*/__webpack_require__.n(injectStylesIntoStyleTag);
// EXTERNAL MODULE: ./node_modules/style-loader/dist/runtime/styleDomAPI.js
var styleDomAPI = __webpack_require__(825);
var styleDomAPI_default = /*#__PURE__*/__webpack_require__.n(styleDomAPI);
// EXTERNAL MODULE: ./node_modules/style-loader/dist/runtime/insertBySelector.js
var insertBySelector = __webpack_require__(659);
var insertBySelector_default = /*#__PURE__*/__webpack_require__.n(insertBySelector);
// EXTERNAL MODULE: ./node_modules/style-loader/dist/runtime/setAttributesWithoutAttributes.js
var setAttributesWithoutAttributes = __webpack_require__(56);
var setAttributesWithoutAttributes_default = /*#__PURE__*/__webpack_require__.n(setAttributesWithoutAttributes);
// EXTERNAL MODULE: ./node_modules/style-loader/dist/runtime/insertStyleElement.js
var insertStyleElement = __webpack_require__(540);
var insertStyleElement_default = /*#__PURE__*/__webpack_require__.n(insertStyleElement);
// EXTERNAL MODULE: ./node_modules/style-loader/dist/runtime/styleTagTransform.js
var styleTagTransform = __webpack_require__(113);
var styleTagTransform_default = /*#__PURE__*/__webpack_require__.n(styleTagTransform);
// EXTERNAL MODULE: ./node_modules/css-loader/dist/cjs.js??ruleSet[1].rules[1].use[1]!./node_modules/postcss-loader/dist/cjs.js??ruleSet[1].rules[1].use[2]!./dev/src/ui/minimap.css
var minimap = __webpack_require__(767);
;// ./dev/src/ui/minimap.css
 
      
      
      
      
      
      
      
      
      
 
var options = {};
 
options.styleTagTransform = (styleTagTransform_default());
options.setAttributes = (setAttributesWithoutAttributes_default());
options.insert = insertBySelector_default().bind(null, "head");
options.domAPI = (styleDomAPI_default());
options.insertStyleElement = (insertStyleElement_default());
 
var update = injectStylesIntoStyleTag_default()(minimap["default"], options);
 
 
 
 
       /* harmony default export */ const ui_minimap = (minimap["default"] && minimap["default"].locals ? minimap["default"].locals : undefined);
 
// EXTERNAL MODULE: ./node_modules/css-loader/dist/cjs.js??ruleSet[1].rules[1].use[1]!./node_modules/postcss-loader/dist/cjs.js??ruleSet[1].rules[1].use[2]!./dev/src/ui/style.css
var style = __webpack_require__(397);
;// ./dev/src/ui/style.css
 
      
      
      
      
      
      
      
      
      
 
var style_options = {};
 
style_options.styleTagTransform = (styleTagTransform_default());
style_options.setAttributes = (setAttributesWithoutAttributes_default());
style_options.insert = insertBySelector_default().bind(null, "head");
style_options.domAPI = (styleDomAPI_default());
style_options.insertStyleElement = (insertStyleElement_default());
 
var style_update = injectStylesIntoStyleTag_default()(style["default"], style_options);
 
 
 
 
       /* harmony default export */ const ui_style = (style["default"] && style["default"].locals ? style["default"].locals : undefined);
 
;// ./dev/src/userscripting/Tampermonkey.ts
function registerMenuCommands() {
  const links = [{
    name: '\uD83D\uDF02 Adverisement: Play cell games on Delt.io',
    url: 'https://delt.io'
  }, {
    name: '\uD83D\uDDAD Contact: Delta Discord',
    url: 'https://bit.ly/3RXQXQd'
  }];
  try {
    links.forEach(link => GM.registerMenuCommand(link.name, () => window.location.href = link.url));
  } catch (e) {}
}
function registerCheckUpdates() {
  GM.registerMenuCommand(`Version: ${GM.info.script.version} - Check for updates`, checkUpdates);
}
function checkUpdates() {
  const url = GM.info.scriptUpdateURL;
  if (!url) return alert('⛔ Error:\nNo update URL found!');
  const version2int = (x = '0') => x.split('.').reduce((n, c, i, a) => n + parseInt(c) * Math.pow(100, a.length - i - 1), 0);
  const req = new Promise(r => GM.xmlHttpRequest({
    method: 'GET',
    url: url,
    onload: r
  }));
  req.then(res => {
    const matches = /\/\/\s*@version\s*(\S+)/im.exec(res.responseText);
    if (!matches) return alert('⛔ Error:\nNo version found!');
    const remoteVersion = version2int(matches[1]);
    const localVersion = version2int(GM.info.script.version);
    if (remoteVersion > localVersion) {
      const msg = `🔔 New version available: ${matches[1]}\n\nDo you want to update?`;
      if (confirm(msg)) {
        const installer = window.open(url, '_blank');
        const i = setInterval(() => {
          if (!installer.closed) return;
          clearInterval(i);
          location.reload();
        }, 100);
      }
    } else {
      alert('👍 You are using the latest version!');
    }
  }).catch(e => {
    console.error(e);
    alert('⛔ Error: Cant fetch update info!\n' + e);
  });
}
function isGM() {
  return typeof GM !== 'undefined' && GM;
}
;// ./dev/src/index.ts
 
 
 
 
 
 
 
enableVueDevtools();
enableFastCanvasView();
const app = new App();
makeGLobal('app', app);
makeGLobal('find_node', find_node);
if (isGM() && !window.GM_skipMenu) {
  registerMenuCommands();
  registerCheckUpdates();
}
})();
 
MyLibrary = __webpack_exports__;
 
})(typeof unsafeWindow !== 'undefined' ? unsafeWindow : window);