@series-inc/rundot-game-sdk 5.0.0

package/dist/rundot-game-api/index.js

@@ -0,0 +1,2088 @@
+import { SDK_VERSION, createHost, initializeStorage, initializeRoomsApi, initializeAds, initializePopups, initializeAnalytics, initializeIap, initializeLeaderboard, initializeLocalNotifications, initializePreloader, initializeTime, initializeLifecycleApi, initializeHaptics, initializeCdn, initializeFeaturesApi, initializeLoggingApi, initializeProfile, initializeSystem, initializeAvatar3d, initializeStackNavigation, initializeAi, initializeSimulation, initializeSocial } from '../chunk-RT4CMCVW.js';
+import { createProxiedObject, createProxiedMethod } from '../chunk-3GKY3LY5.js';
+
+// src/rundot-game-api/systems/asset-loader.js
+var RundotGameAssetLoader = class {
+  constructor() {
+    this.cache = /* @__PURE__ */ new Map();
+    this.blobUrls = /* @__PURE__ */ new Map();
+    this.isWebView = false;
+    this.rundotGameAPI = null;
+  }
+  // Set the RundotGameAPI reference during initialization
+  setRundotGameAPI(api2) {
+    this.rundotGameAPI = api2;
+    this.isWebView = typeof window !== "undefined" && typeof window.ReactNativeWebView !== "undefined";
+  }
+  /**
+   * Load any asset with automatic optimization
+   * @param {string} url - Asset URL
+   * @param {Object} options - Loading options
+   * @returns {Promise<string>} - URL to use (original, blob, or object URL)
+   */
+  async loadAsset(url, options = {}) {
+    const {
+      type = "auto",
+      // 'image', 'audio', 'video', 'text', 'json', 'auto'
+      cache = true,
+      // Use cache
+      timeout = 3e4,
+      isOptional = false
+      // New option to suppress error logging for optional assets
+    } = options;
+    const resolvedUrl = this.rundotGameAPI.cdn.resolveAssetUrl(url);
+    if (cache && this.cache.has(resolvedUrl)) {
+      return this.cache.get(resolvedUrl);
+    }
+    const assetType = type === "auto" ? this._detectType(resolvedUrl) : type;
+    try {
+      let resultUrl = resolvedUrl;
+      if (assetType === "text" || assetType === "json") {
+        const content = await this._fetchText(resolvedUrl, timeout);
+        this.cache.set(resolvedUrl, content);
+        return content;
+      }
+      const isMockMode = this.rundotGameAPI && this.rundotGameAPI.isMock && this.rundotGameAPI.isMock();
+      if (this.isWebView && !isMockMode && ["image", "audio", "video"].includes(assetType)) {
+        if (assetType === "video") {
+          resultUrl = await this._loadAsBlob(resolvedUrl, assetType);
+          if (cache) {
+            this.cache.set(resolvedUrl, resultUrl);
+          }
+          return resultUrl;
+        } else if (assetType === "audio") {
+          resultUrl = await this._loadAsBlob(resolvedUrl, assetType);
+        } else {
+          resultUrl = await this._loadAsBlob(resolvedUrl, assetType);
+        }
+      }
+      if (!(this.isWebView && !isMockMode && assetType === "video")) {
+        await this._verifyAsset(resultUrl, assetType);
+      }
+      if (cache) {
+        this.cache.set(resolvedUrl, resultUrl);
+      }
+      return resultUrl;
+    } catch (error) {
+      if (!isOptional) {
+        console.error(`[RundotGameAssetLoader] Failed to load ${resolvedUrl}:`, error);
+      }
+      throw error;
+    }
+  }
+  async _fetchText(url, timeout) {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), timeout);
+    try {
+      const response = await fetch(url, { signal: controller.signal });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      return await response.text();
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  async _loadAsBlob(url, type) {
+    if (this.blobUrls.has(url)) {
+      return this.blobUrls.get(url);
+    }
+    const mimeType = {
+      image: "image/*",
+      audio: "audio/*",
+      video: "video/*"
+    }[type] || "*/*";
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), 3e4);
+    try {
+      const response = await fetch(url, {
+        mode: "cors",
+        credentials: "omit",
+        headers: { Accept: mimeType },
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+      }
+      const blob = await response.blob();
+      const blobUrl = URL.createObjectURL(blob);
+      this.blobUrls.set(url, blobUrl);
+      return blobUrl;
+    } catch (error) {
+      clearTimeout(timeoutId);
+      throw error;
+    }
+  }
+  async _checkStreamingSupport(url) {
+    try {
+      const response = await fetch(url, { method: "HEAD" });
+      const acceptRanges = response.headers.get("Accept-Ranges") === "bytes";
+      const contentLength = response.headers.get("Content-Length");
+      return acceptRanges && !!contentLength;
+    } catch {
+      return false;
+    }
+  }
+  async _verifyAsset(url, type) {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        reject(new Error(`Verification timeout for ${type} asset`));
+      }, 1e4);
+      if (type === "image") {
+        const img = new Image();
+        img.onload = () => {
+          clearTimeout(timeout);
+          resolve();
+        };
+        img.onerror = (error) => {
+          clearTimeout(timeout);
+          reject(new Error("Failed to load image"));
+        };
+        img.src = url;
+      } else if (type === "audio") {
+        const audio = new Audio();
+        audio.oncanplaythrough = () => {
+          clearTimeout(timeout);
+          resolve();
+        };
+        audio.onerror = () => {
+          clearTimeout(timeout);
+          reject(new Error("Failed to load audio"));
+        };
+        audio.src = url;
+        audio.load();
+      } else if (type === "video") {
+        const video = document.createElement("video");
+        video.onloadedmetadata = () => {
+          clearTimeout(timeout);
+          video.src = "";
+          resolve();
+        };
+        video.onerror = () => {
+          clearTimeout(timeout);
+          reject(new Error("Failed to load video"));
+        };
+        video.src = url;
+      } else {
+        clearTimeout(timeout);
+        resolve();
+      }
+    });
+  }
+  _detectType(url) {
+    const ext = url.split(".").pop()?.toLowerCase();
+    if (["jpg", "jpeg", "png", "gif", "webp", "svg"].includes(ext)) return "image";
+    if (["mp3", "wav", "ogg", "m4a", "aac"].includes(ext)) return "audio";
+    if (["mp4", "webm", "mov", "m4v"].includes(ext)) return "video";
+    if (["json"].includes(ext)) return "json";
+    return "text";
+  }
+  /**
+   * Preload multiple assets in parallel
+   * @param {(string|{url: string, isOptional?: boolean})[]} urls - Array of URLs or URL objects with optional metadata
+   * @param {Object} options - Loading options
+   */
+  async preloadAssets(urls, options = {}) {
+    const { onProgress } = options;
+    let loaded = 0;
+    const total = urls.length;
+    const normalizedUrls = urls.map((item) => {
+      if (typeof item === "string") {
+        return { url: item, isOptional: false };
+      }
+      return {
+        url: item.url,
+        isOptional: item.isOptional || false
+      };
+    });
+    const results = await Promise.allSettled(
+      normalizedUrls.map(async (item) => {
+        try {
+          const result = await this.loadAsset(item.url, { ...options, isOptional: item.isOptional });
+          loaded++;
+          if (onProgress) {
+            onProgress(loaded / total, { loaded, total, current: item.url });
+          }
+          return { url: item.url, result, success: true, isOptional: item.isOptional };
+        } catch (error) {
+          loaded++;
+          if (onProgress) {
+            onProgress(loaded / total, { loaded, total, current: item.url, error });
+          }
+          return { url: item.url, error, success: false, isOptional: item.isOptional };
+        }
+      })
+    );
+    const failedRequired = results.filter(
+      (r2) => (r2.status === "rejected" || !r2.value?.success) && !r2.value?.isOptional
+    );
+    if (failedRequired.length > 0) {
+      console.warn(`[RundotGameAssetLoader] ${failedRequired.length} required assets failed to load`);
+      failedRequired.forEach((r2) => {
+        console.warn(`[RundotGameAssetLoader] Failed required asset: ${r2.value?.url}`);
+      });
+    }
+    const failedOptional = results.filter(
+      (r2) => (r2.status === "rejected" || !r2.value?.success) && r2.value?.isOptional
+    );
+    if (failedOptional.length > 0) {
+      console.info(`[RundotGameAssetLoader] ${failedOptional.length} optional assets were not found (this is OK)`);
+    }
+    return results.map((r2) => r2.value);
+  }
+  /**
+   * Clean up blob URLs to prevent memory leaks
+   */
+  cleanup() {
+    for (const blobUrl of this.blobUrls.values()) {
+      URL.revokeObjectURL(blobUrl);
+    }
+    this.blobUrls.clear();
+    this.cache.clear();
+  }
+  /**
+   * Get a cached asset URL if available
+   */
+  getCached(url) {
+    const resolvedUrl = this.rundotGameAPI.cdn.resolveAssetUrl(url);
+    return this.cache.get(resolvedUrl);
+  }
+};
+if (typeof RundotGameAPI !== "undefined") {
+  RundotGameAPI.assetLoader = new RundotGameAssetLoader();
+  RundotGameAPI.loadAsset = (url, options) => RundotGameAPI.assetLoader.loadAsset(url, options);
+  RundotGameAPI.preloadAssets = (urls, options) => RundotGameAPI.assetLoader.preloadAssets(urls, options);
+  RundotGameAPI.cleanupAssets = () => RundotGameAPI.assetLoader.cleanup();
+}
+function initializeAssetLoader(rundotGameApi, createProxiedMethod2) {
+  const assetLoader = new RundotGameAssetLoader();
+  assetLoader.setRundotGameAPI(api);
+  api._assetLoader = assetLoader;
+  api.assetLoader = assetLoader;
+  if (createProxiedMethod2) {
+    api.loadAsset = createProxiedMethod2("loadAsset", function(url, options) {
+      return assetLoader.loadAsset(url, options);
+    });
+    api.preloadAssets = createProxiedMethod2("preloadAssets", function(urls, options) {
+      return assetLoader.preloadAssets(urls, options);
+    });
+    api.cleanupAssets = createProxiedMethod2("cleanupAssets", function() {
+      return assetLoader.cleanup();
+    });
+  } else {
+    api.loadAsset = function(url, options) {
+      return assetLoader.loadAsset(url, options);
+    };
+    api.preloadAssets = function(urls, options) {
+      return assetLoader.preloadAssets(urls, options);
+    };
+    api.cleanupAssets = function() {
+      return assetLoader.cleanup();
+    };
+  }
+  if (typeof window !== "undefined" && window.RundotGameAPI) {
+    window.RundotGameAPI.loadAsset = api.loadAsset;
+    window.RundotGameAPI.preloadAssets = api.preloadAssets;
+    window.RundotGameAPI.cleanupAssets = api.cleanupAssets;
+  }
+}
+
+// src/rundot-game-api/lib/break_eternity.js
+function se(r2, n) {
+  if (!(r2 instanceof n)) throw new TypeError("Cannot call a class as a function");
+}
+function le(r2, n) {
+  for (var e = 0; e < n.length; e++) {
+    var t = n[e];
+    t.enumerable = t.enumerable || false, t.configurable = true, "value" in t && (t.writable = true), Object.defineProperty(r2, t.key, t);
+  }
+}
+function ue(r2, n, e) {
+  return n && le(r2.prototype, n), e && le(r2, e), Object.defineProperty(r2, "prototype", { writable: false }), r2;
+}
+var me = (function() {
+  function r2(n) {
+    se(this, r2), this.map = /* @__PURE__ */ new Map(), this.first = void 0, this.last = void 0, this.maxSize = n;
+  }
+  return ue(r2, [{ key: "size", get: function() {
+    return this.map.size;
+  } }, { key: "get", value: function(e) {
+    var t = this.map.get(e);
+    if (t !== void 0) return t !== this.first && (t === this.last ? (this.last = t.prev, this.last.next = void 0) : (t.prev.next = t.next, t.next.prev = t.prev), t.next = this.first, this.first.prev = t, this.first = t), t.value;
+  } }, { key: "set", value: function(e, t) {
+    if (!(this.maxSize < 1)) {
+      if (this.map.has(e)) throw new Error("Cannot update existing keys in the cache");
+      var i = new ge(e, t);
+      for (this.first === void 0 ? (this.first = i, this.last = i) : (i.next = this.first, this.first.prev = i, this.first = i), this.map.set(e, i); this.map.size > this.maxSize; ) {
+        var a = this.last;
+        this.map.delete(a.key), this.last = a.prev, this.last.next = void 0;
+      }
+    }
+  } }]), r2;
+})();
+var ge = ue(function r(n, e) {
+  se(this, r), this.next = void 0, this.prev = void 0, this.key = n, this.value = e;
+});
+var ne = 17;
+var T = 9e15;
+var ce = Math.log10(9e15);
+var $ = 1 / 9e15;
+var ve = 308;
+var ye = -324;
+var fe = 5;
+var de = 1023;
+var Ne = (function() {
+  for (var r2 = [], n = ye + 1; n <= ve; n++) r2.push(+("1e" + n));
+  var e = 323;
+  return function(t) {
+    return r2[t + e];
+  };
+})();
+var _ = [2, Math.E, 3, 4, 5, 6, 7, 8, 9, 10];
+var be = [[1, 1.0891180521811203, 1.1789767925673957, 1.2701455431742086, 1.3632090180450092, 1.4587818160364217, 1.5575237916251419, 1.6601571006859253, 1.767485818836978, 1.8804192098842727, 2], [1, 1.1121114330934079, 1.231038924931609, 1.3583836963111375, 1.4960519303993531, 1.6463542337511945, 1.8121385357018724, 1.996971324618307, 2.2053895545527546, 2.4432574483385254, Math.E], [1, 1.1187738849693603, 1.2464963939368214, 1.38527004705667, 1.5376664685821402, 1.7068895236551784, 1.897001227148399, 2.1132403089001035, 2.362480153784171, 2.6539010333870774, 3], [1, 1.1367350847096405, 1.2889510672956703, 1.4606478703324786, 1.6570295196661111, 1.8850062585672889, 2.1539465047453485, 2.476829779693097, 2.872061932789197, 3.3664204535587183, 4], [1, 1.1494592900767588, 1.319708228183931, 1.5166291280087583, 1.748171114438024, 2.0253263297298045, 2.3636668498288547, 2.7858359149579424, 3.3257226212448145, 4.035730287722532, 5], [1, 1.159225940787673, 1.343712473580932, 1.5611293155111927, 1.8221199554561318, 2.14183924486326, 2.542468319282638, 3.0574682501653316, 3.7390572020926873, 4.6719550537360774, 6], [1, 1.1670905356972596, 1.3632807444991446, 1.5979222279405536, 1.8842640123816674, 2.2416069644878687, 2.69893426559423, 3.3012632110403577, 4.121250340630164, 5.281493033448316, 7], [1, 1.1736630594087796, 1.379783782386201, 1.6292821855668218, 1.9378971836180754, 2.3289975651071977, 2.8384347394720835, 3.5232708454565906, 4.478242031114584, 5.868592169644505, 8], [1, 1.1793017514670474, 1.394054150657457, 1.65664127441059, 1.985170999970283, 2.4069682290577457, 2.9647310119960752, 3.7278665320924946, 4.814462547283592, 6.436522247411611, 9], [1, 1.1840100246247336, 1.4061375836156955, 1.6802272208863964, 2.026757028388619, 2.4770056063449646, 3.080525271755482, 3.9191964192627284, 5.135152840833187, 6.989961179534715, 10]];
+var we = [[-1, -0.9194161097107025, -0.8335625019330468, -0.7425599821143978, -0.6466611521029437, -0.5462617907227869, -0.4419033816638769, -0.3342645487554494, -0.224140440909962, -0.11241087890006762, 0], [-1, -0.90603157029014, -0.80786507256596, -0.7064666939634, -0.60294836853664, -0.49849837513117, -0.39430303318768, -0.29147201034755, -0.19097820800866, -0.09361896280296, 0], [-1, -0.9021579584316141, -0.8005762598234203, -0.6964780623319391, -0.5911906810998454, -0.486050182576545, -0.3823089430815083, -0.28106046722897615, -0.1831906535795894, -0.08935809204418144, 0], [-1, -0.8917227442365535, -0.781258746326964, -0.6705130326902455, -0.5612813129406509, -0.4551067709033134, -0.35319256652135966, -0.2563741554088552, -0.1651412821106526, -0.0796919581982668, 0], [-1, -0.8843387974366064, -0.7678744063886243, -0.6529563724510552, -0.5415870994657841, -0.4352842206588936, -0.33504449124791424, -0.24138853420685147, -0.15445285440944467, -0.07409659641336663, 0], [-1, -0.8786709358426346, -0.7577735191184886, -0.6399546189952064, -0.527284921869926, -0.4211627631006314, -0.3223479611761232, -0.23107655627789858, -0.1472057700818259, -0.07035171210706326, 0], [-1, -0.8740862815291583, -0.7497032990976209, -0.6297119746181752, -0.5161838335958787, -0.41036238255751956, -0.31277212146489963, -0.2233976621705518, -0.1418697367979619, -0.06762117662323441, 0], [-1, -0.8702632331800649, -0.7430366914122081, -0.6213373075161548, -0.5072025698095242, -0.40171437727184167, -0.30517930701410456, -0.21736343968190863, -0.137710238299109, -0.06550774483471955, 0], [-1, -0.8670016295947213, -0.7373984232432306, -0.6143173985094293, -0.49973884395492807, -0.394584953527678, -0.2989649949848695, -0.21245647317021688, -0.13434688362382652, -0.0638072667348083, 0], [-1, -0.8641642839543857, -0.732534623168535, -0.6083127477059322, -0.4934049257184696, -0.3885773075899922, -0.29376029055315767, -0.2083678561173622, -0.13155653399373268, -0.062401588652553186, 0]];
+var s = function(n) {
+  return k.fromValue_noAlloc(n);
+};
+var m = function(n, e, t) {
+  return k.fromComponents(n, e, t);
+};
+var c = function(n, e, t) {
+  return k.fromComponents_noNormalize(n, e, t);
+};
+var K = function(n, e) {
+  var t = e + 1, i = Math.ceil(Math.log10(Math.abs(n))), a = Math.round(n * Math.pow(10, t - i)) * Math.pow(10, i - t);
+  return parseFloat(a.toFixed(Math.max(t - i, 0)));
+};
+var ie = function(n) {
+  return Math.sign(n) * Math.log10(Math.abs(n));
+};
+var ke = function(n) {
+  if (!isFinite(n)) return n;
+  if (n < -50) return n === Math.trunc(n) ? Number.NEGATIVE_INFINITY : 0;
+  for (var e = 1; n < 10; ) e = e * n, ++n;
+  n -= 1;
+  var t = 0.9189385332046727;
+  t = t + (n + 0.5) * Math.log(n), t = t - n;
+  var i = n * n, a = n;
+  return t = t + 1 / (12 * a), a = a * i, t = t - 1 / (360 * a), a = a * i, t = t + 1 / (1260 * a), a = a * i, t = t - 1 / (1680 * a), a = a * i, t = t + 1 / (1188 * a), a = a * i, t = t - 691 / (360360 * a), a = a * i, t = t + 7 / (1092 * a), a = a * i, t = t - 3617 / (122400 * a), Math.exp(t) / e;
+};
+var Me = 0.36787944117144233;
+var oe = 0.5671432904097838;
+var ae = function(n) {
+  var e = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1e-10, t = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true, i, a;
+  if (!Number.isFinite(n)) return n;
+  if (t) {
+    if (n === 0) return n;
+    if (n === 1) return oe;
+    n < 10 ? i = 0 : i = Math.log(n) - Math.log(Math.log(n));
+  } else {
+    if (n === 0) return -1 / 0;
+    n <= -0.1 ? i = -2 : i = Math.log(-n) - Math.log(-Math.log(-n));
+  }
+  for (var l = 0; l < 100; ++l) {
+    if (a = (n * Math.exp(-i) + i * i) / (i + 1), Math.abs(a - i) < e * Math.abs(a)) return a;
+    i = a;
+  }
+  throw Error("Iteration failed to converge: ".concat(n.toString()));
+};
+function he(r2) {
+  var n = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1e-10, e = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : true, t, i, a, l;
+  if (!Number.isFinite(r2.mag)) return new k(r2);
+  if (e) {
+    if (r2.eq(k.dZero)) return c(0, 0, 0);
+    if (r2.eq(k.dOne)) return k.fromNumber(oe);
+    t = k.ln(r2);
+  } else {
+    if (r2.eq(k.dZero)) return new k(k.dNegInf);
+    t = k.ln(r2.neg());
+  }
+  for (var f = 0; f < 100; ++f) {
+    if (i = t.neg().exp(), a = t.sub(r2.mul(i)), l = t.sub(a.div(t.add(1).sub(t.add(2).mul(a).div(k.mul(2, t).add(2))))), k.abs(l.sub(t)).lt(k.abs(l).mul(n))) return l;
+    t = l;
+  }
+  throw Error("Iteration failed to converge: ".concat(r2.toString()));
+}
+var k = (function() {
+  function r2(n) {
+    se(this, r2), this.sign = 0, this.mag = 0, this.layer = 0, n instanceof r2 ? this.fromDecimal(n) : typeof n == "number" ? this.fromNumber(n) : typeof n == "string" && this.fromString(n);
+  }
+  return ue(r2, [{ key: "m", get: function() {
+    if (this.sign === 0) return 0;
+    if (this.layer === 0) {
+      var e = Math.floor(Math.log10(this.mag)), t;
+      return this.mag === 5e-324 ? t = 5 : t = this.mag / Ne(e), this.sign * t;
+    } else if (this.layer === 1) {
+      var i = this.mag - Math.floor(this.mag);
+      return this.sign * Math.pow(10, i);
+    } else return this.sign;
+  }, set: function(e) {
+    this.layer <= 2 ? this.fromMantissaExponent(e, this.e) : (this.sign = Math.sign(e), this.sign === 0 && (this.layer = 0, this.exponent = 0));
+  } }, { key: "e", get: function() {
+    return this.sign === 0 ? 0 : this.layer === 0 ? Math.floor(Math.log10(this.mag)) : this.layer === 1 ? Math.floor(this.mag) : this.layer === 2 ? Math.floor(Math.sign(this.mag) * Math.pow(10, Math.abs(this.mag))) : this.mag * Number.POSITIVE_INFINITY;
+  }, set: function(e) {
+    this.fromMantissaExponent(this.m, e);
+  } }, { key: "s", get: function() {
+    return this.sign;
+  }, set: function(e) {
+    e === 0 ? (this.sign = 0, this.layer = 0, this.mag = 0) : this.sign = e;
+  } }, { key: "mantissa", get: function() {
+    return this.m;
+  }, set: function(e) {
+    this.m = e;
+  } }, { key: "exponent", get: function() {
+    return this.e;
+  }, set: function(e) {
+    this.e = e;
+  } }, { key: "normalize", value: function() {
+    if (this.sign === 0 || this.mag === 0 && this.layer === 0 || this.mag === Number.NEGATIVE_INFINITY && this.layer > 0 && Number.isFinite(this.layer)) return this.sign = 0, this.mag = 0, this.layer = 0, this;
+    if (this.layer === 0 && this.mag < 0 && (this.mag = -this.mag, this.sign = -this.sign), this.mag === Number.POSITIVE_INFINITY || this.layer === Number.POSITIVE_INFINITY || this.mag === Number.NEGATIVE_INFINITY || this.layer === Number.NEGATIVE_INFINITY) return this.mag = Number.POSITIVE_INFINITY, this.layer = Number.POSITIVE_INFINITY, this;
+    if (this.layer === 0 && this.mag < $) return this.layer += 1, this.mag = Math.log10(this.mag), this;
+    var e = Math.abs(this.mag), t = Math.sign(this.mag);
+    if (e >= T) return this.layer += 1, this.mag = t * Math.log10(e), this;
+    for (; e < ce && this.layer > 0; ) this.layer -= 1, this.layer === 0 ? this.mag = Math.pow(10, this.mag) : (this.mag = t * Math.pow(10, e), e = Math.abs(this.mag), t = Math.sign(this.mag));
+    return this.layer === 0 && (this.mag < 0 ? (this.mag = -this.mag, this.sign = -this.sign) : this.mag === 0 && (this.sign = 0)), (Number.isNaN(this.sign) || Number.isNaN(this.layer) || Number.isNaN(this.mag)) && (this.sign = Number.NaN, this.layer = Number.NaN, this.mag = Number.NaN), this;
+  } }, { key: "fromComponents", value: function(e, t, i) {
+    return this.sign = e, this.layer = t, this.mag = i, this.normalize(), this;
+  } }, { key: "fromComponents_noNormalize", value: function(e, t, i) {
+    return this.sign = e, this.layer = t, this.mag = i, this;
+  } }, { key: "fromMantissaExponent", value: function(e, t) {
+    return this.layer = 1, this.sign = Math.sign(e), e = Math.abs(e), this.mag = t + Math.log10(e), this.normalize(), this;
+  } }, { key: "fromMantissaExponent_noNormalize", value: function(e, t) {
+    return this.fromMantissaExponent(e, t), this;
+  } }, { key: "fromDecimal", value: function(e) {
+    return this.sign = e.sign, this.layer = e.layer, this.mag = e.mag, this;
+  } }, { key: "fromNumber", value: function(e) {
+    return this.mag = Math.abs(e), this.sign = Math.sign(e), this.layer = 0, this.normalize(), this;
+  } }, { key: "fromString", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false, i = e, a = r2.fromStringCache.get(i);
+    if (a !== void 0) return this.fromDecimal(a);
+    e = e.replace(",", "");
+    var l = e.split("^^^");
+    if (l.length === 2) {
+      var f = parseFloat(l[0]), g = parseFloat(l[1]), h = l[1].split(";"), v = 1;
+      if (h.length === 2 && (v = parseFloat(h[1]), isFinite(v) || (v = 1)), isFinite(f) && isFinite(g)) {
+        var u = r2.pentate(f, g, v, t);
+        return this.sign = u.sign, this.layer = u.layer, this.mag = u.mag, r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), this;
+      }
+    }
+    var M = e.split("^^");
+    if (M.length === 2) {
+      var x = parseFloat(M[0]), w = parseFloat(M[1]), o = M[1].split(";"), F = 1;
+      if (o.length === 2 && (F = parseFloat(o[1]), isFinite(F) || (F = 1)), isFinite(x) && isFinite(w)) {
+        var A = r2.tetrate(x, w, F, t);
+        return this.sign = A.sign, this.layer = A.layer, this.mag = A.mag, r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), this;
+      }
+    }
+    var d = e.split("^");
+    if (d.length === 2) {
+      var S = parseFloat(d[0]), p = parseFloat(d[1]);
+      if (isFinite(S) && isFinite(p)) {
+        var q = r2.pow(S, p);
+        return this.sign = q.sign, this.layer = q.layer, this.mag = q.mag, r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), this;
+      }
+    }
+    e = e.trim().toLowerCase();
+    var I, N, y = e.split("pt");
+    if (y.length === 2) {
+      I = 10;
+      var V = false;
+      y[0][0] == "-" && (V = true, y[0] = y[0].slice(1)), N = parseFloat(y[0]), y[1] = y[1].replace("(", ""), y[1] = y[1].replace(")", "");
+      var C = parseFloat(y[1]);
+      if (isFinite(C) || (C = 1), isFinite(I) && isFinite(N)) {
+        var D = r2.tetrate(I, N, C, t);
+        return this.sign = D.sign, this.layer = D.layer, this.mag = D.mag, r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), V && (this.sign *= -1), this;
+      }
+    }
+    if (y = e.split("p"), y.length === 2) {
+      I = 10;
+      var Y = false;
+      y[0][0] == "-" && (Y = true, y[0] = y[0].slice(1)), N = parseFloat(y[0]), y[1] = y[1].replace("(", ""), y[1] = y[1].replace(")", "");
+      var L = parseFloat(y[1]);
+      if (isFinite(L) || (L = 1), isFinite(I) && isFinite(N)) {
+        var G = r2.tetrate(I, N, L, t);
+        return this.sign = G.sign, this.layer = G.layer, this.mag = G.mag, r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), Y && (this.sign *= -1), this;
+      }
+    }
+    if (y = e.split("f"), y.length === 2) {
+      I = 10;
+      var E = false;
+      y[0][0] == "-" && (E = true, y[0] = y[0].slice(1)), y[0] = y[0].replace("(", ""), y[0] = y[0].replace(")", "");
+      var X = parseFloat(y[0]);
+      if (y[1] = y[1].replace("(", ""), y[1] = y[1].replace(")", ""), N = parseFloat(y[1]), isFinite(X) || (X = 1), isFinite(I) && isFinite(N)) {
+        var Q = r2.tetrate(I, N, X, t);
+        return this.sign = Q.sign, this.layer = Q.layer, this.mag = Q.mag, r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), E && (this.sign *= -1), this;
+      }
+    }
+    var J = e.split("e"), Z = J.length - 1;
+    if (Z === 0) {
+      var re = parseFloat(e);
+      if (isFinite(re)) return this.fromNumber(re), r2.fromStringCache.size >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), this;
+    } else if (Z === 1) {
+      var W = parseFloat(e);
+      if (isFinite(W) && Math.abs(W) > 1e-307) return this.fromNumber(W), r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), this;
+    }
+    var H = e.split("e^");
+    if (H.length === 2) {
+      this.sign = 1, H[0].charAt(0) == "-" && (this.sign = -1);
+      for (var te = "", U = 0; U < H[1].length; ++U) {
+        var P = H[1].charCodeAt(U);
+        if (P >= 43 && P <= 57 || P === 101) te += H[1].charAt(U);
+        else {
+          if (this.layer = parseFloat(te), this.mag = parseFloat(H[1].substr(U + 1)), this.layer < 0 || this.layer % 1 != 0) {
+            var B = r2.tetrate(10, this.layer, this.mag, t);
+            this.sign = B.sign, this.layer = B.layer, this.mag = B.mag;
+          }
+          return this.normalize(), r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), this;
+        }
+      }
+    }
+    if (Z < 1) return this.sign = 0, this.layer = 0, this.mag = 0, r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), this;
+    var z = parseFloat(J[0]);
+    if (z === 0) return this.sign = 0, this.layer = 0, this.mag = 0, r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), this;
+    var R = parseFloat(J[J.length - 1]);
+    if (Z >= 2) {
+      var ee = parseFloat(J[J.length - 2]);
+      isFinite(ee) && (R *= Math.sign(ee), R += ie(ee));
+    }
+    if (!isFinite(z)) this.sign = J[0] === "-" ? -1 : 1, this.layer = Z, this.mag = R;
+    else if (Z === 1) this.sign = Math.sign(z), this.layer = 1, this.mag = R + Math.log10(Math.abs(z));
+    else if (this.sign = Math.sign(z), this.layer = Z, Z === 2) {
+      var j = r2.mul(m(1, 2, R), s(z));
+      return this.sign = j.sign, this.layer = j.layer, this.mag = j.mag, r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), this;
+    } else this.mag = R;
+    return this.normalize(), r2.fromStringCache.maxSize >= 1 && r2.fromStringCache.set(i, r2.fromDecimal(this)), this;
+  } }, { key: "fromValue", value: function(e) {
+    return e instanceof r2 ? this.fromDecimal(e) : typeof e == "number" ? this.fromNumber(e) : typeof e == "string" ? this.fromString(e) : (this.sign = 0, this.layer = 0, this.mag = 0, this);
+  } }, { key: "toNumber", value: function() {
+    return this.mag === Number.POSITIVE_INFINITY && this.layer === Number.POSITIVE_INFINITY && this.sign === 1 ? Number.POSITIVE_INFINITY : this.mag === Number.POSITIVE_INFINITY && this.layer === Number.POSITIVE_INFINITY && this.sign === -1 ? Number.NEGATIVE_INFINITY : Number.isFinite(this.layer) ? this.layer === 0 ? this.sign * this.mag : this.layer === 1 ? this.sign * Math.pow(10, this.mag) : this.mag > 0 ? this.sign > 0 ? Number.POSITIVE_INFINITY : Number.NEGATIVE_INFINITY : 0 : Number.NaN;
+  } }, { key: "mantissaWithDecimalPlaces", value: function(e) {
+    return isNaN(this.m) ? Number.NaN : this.m === 0 ? 0 : K(this.m, e);
+  } }, { key: "magnitudeWithDecimalPlaces", value: function(e) {
+    return isNaN(this.mag) ? Number.NaN : this.mag === 0 ? 0 : K(this.mag, e);
+  } }, { key: "toString", value: function() {
+    return isNaN(this.layer) || isNaN(this.sign) || isNaN(this.mag) ? "NaN" : this.mag === Number.POSITIVE_INFINITY || this.layer === Number.POSITIVE_INFINITY ? this.sign === 1 ? "Infinity" : "-Infinity" : this.layer === 0 ? this.mag < 1e21 && this.mag > 1e-7 || this.mag === 0 ? (this.sign * this.mag).toString() : this.m + "e" + this.e : this.layer === 1 ? this.m + "e" + this.e : this.layer <= fe ? (this.sign === -1 ? "-" : "") + "e".repeat(this.layer) + this.mag : (this.sign === -1 ? "-" : "") + "(e^" + this.layer + ")" + this.mag;
+  } }, { key: "toExponential", value: function(e) {
+    return this.layer === 0 ? (this.sign * this.mag).toExponential(e) : this.toStringWithDecimalPlaces(e);
+  } }, { key: "toFixed", value: function(e) {
+    return this.layer === 0 ? (this.sign * this.mag).toFixed(e) : this.toStringWithDecimalPlaces(e);
+  } }, { key: "toPrecision", value: function(e) {
+    return this.e <= -7 ? this.toExponential(e - 1) : e > this.e ? this.toFixed(e - this.exponent - 1) : this.toExponential(e - 1);
+  } }, { key: "valueOf", value: function() {
+    return this.toString();
+  } }, { key: "toJSON", value: function() {
+    return this.toString();
+  } }, { key: "toStringWithDecimalPlaces", value: function(e) {
+    return this.layer === 0 ? this.mag < 1e21 && this.mag > 1e-7 || this.mag === 0 ? (this.sign * this.mag).toFixed(e) : K(this.m, e) + "e" + K(this.e, e) : this.layer === 1 ? K(this.m, e) + "e" + K(this.e, e) : this.layer <= fe ? (this.sign === -1 ? "-" : "") + "e".repeat(this.layer) + K(this.mag, e) : (this.sign === -1 ? "-" : "") + "(e^" + this.layer + ")" + K(this.mag, e);
+  } }, { key: "abs", value: function() {
+    return c(this.sign === 0 ? 0 : 1, this.layer, this.mag);
+  } }, { key: "neg", value: function() {
+    return c(-this.sign, this.layer, this.mag);
+  } }, { key: "negate", value: function() {
+    return this.neg();
+  } }, { key: "negated", value: function() {
+    return this.neg();
+  } }, { key: "sgn", value: function() {
+    return this.sign;
+  } }, { key: "round", value: function() {
+    return this.mag < 0 ? c(0, 0, 0) : this.layer === 0 ? m(this.sign, 0, Math.round(this.mag)) : new r2(this);
+  } }, { key: "floor", value: function() {
+    return this.mag < 0 ? this.sign === -1 ? c(-1, 0, 1) : c(0, 0, 0) : this.sign === -1 ? this.neg().ceil().neg() : this.layer === 0 ? m(this.sign, 0, Math.floor(this.mag)) : new r2(this);
+  } }, { key: "ceil", value: function() {
+    return this.mag < 0 ? this.sign === 1 ? c(1, 0, 1) : c(0, 0, 0) : this.sign === -1 ? this.neg().floor().neg() : this.layer === 0 ? m(this.sign, 0, Math.ceil(this.mag)) : new r2(this);
+  } }, { key: "trunc", value: function() {
+    return this.mag < 0 ? c(0, 0, 0) : this.layer === 0 ? m(this.sign, 0, Math.trunc(this.mag)) : new r2(this);
+  } }, { key: "add", value: function(e) {
+    var t = s(e);
+    if (this.eq(r2.dInf) && t.eq(r2.dNegInf) || this.eq(r2.dNegInf) && t.eq(r2.dInf)) return new r2(r2.dNaN);
+    if (!Number.isFinite(this.layer)) return new r2(this);
+    if (!Number.isFinite(t.layer)) return new r2(t);
+    if (this.sign === 0) return new r2(t);
+    if (t.sign === 0) return new r2(this);
+    if (this.sign === -t.sign && this.layer === t.layer && this.mag === t.mag) return c(0, 0, 0);
+    var i, a;
+    if (this.layer >= 2 || t.layer >= 2) return this.maxabs(t);
+    if (r2.cmpabs(this, t) > 0 ? (i = new r2(this), a = new r2(t)) : (i = new r2(t), a = new r2(this)), i.layer === 0 && a.layer === 0) return r2.fromNumber(i.sign * i.mag + a.sign * a.mag);
+    var l = i.layer * Math.sign(i.mag), f = a.layer * Math.sign(a.mag);
+    if (l - f >= 2) return i;
+    if (l === 0 && f === -1) {
+      if (Math.abs(a.mag - Math.log10(i.mag)) > ne) return i;
+      var g = Math.pow(10, Math.log10(i.mag) - a.mag), h = a.sign + i.sign * g;
+      return m(Math.sign(h), 1, a.mag + Math.log10(Math.abs(h)));
+    }
+    if (l === 1 && f === 0) {
+      if (Math.abs(i.mag - Math.log10(a.mag)) > ne) return i;
+      var v = Math.pow(10, i.mag - Math.log10(a.mag)), u = a.sign + i.sign * v;
+      return m(Math.sign(u), 1, Math.log10(a.mag) + Math.log10(Math.abs(u)));
+    }
+    if (Math.abs(i.mag - a.mag) > ne) return i;
+    var M = Math.pow(10, i.mag - a.mag), x = a.sign + i.sign * M;
+    return m(Math.sign(x), 1, a.mag + Math.log10(Math.abs(x)));
+  } }, { key: "plus", value: function(e) {
+    return this.add(e);
+  } }, { key: "sub", value: function(e) {
+    return this.add(s(e).neg());
+  } }, { key: "subtract", value: function(e) {
+    return this.sub(e);
+  } }, { key: "minus", value: function(e) {
+    return this.sub(e);
+  } }, { key: "mul", value: function(e) {
+    var t = s(e);
+    if (this.eq(r2.dInf) && t.eq(r2.dNegInf) || this.eq(r2.dNegInf) && t.eq(r2.dInf)) return new r2(r2.dNegInf);
+    if (this.mag == Number.POSITIVE_INFINITY && t.eq(r2.dZero) || this.eq(r2.dZero) && this.mag == Number.POSITIVE_INFINITY) return new r2(r2.dNaN);
+    if (this.eq(r2.dNegInf) && t.eq(r2.dNegInf)) return new r2(r2.dInf);
+    if (!Number.isFinite(this.layer)) return new r2(this);
+    if (!Number.isFinite(t.layer)) return new r2(t);
+    if (this.sign === 0 || t.sign === 0) return c(0, 0, 0);
+    if (this.layer === t.layer && this.mag === -t.mag) return c(this.sign * t.sign, 0, 1);
+    var i, a;
+    if (this.layer > t.layer || this.layer == t.layer && Math.abs(this.mag) > Math.abs(t.mag) ? (i = new r2(this), a = new r2(t)) : (i = new r2(t), a = new r2(this)), i.layer === 0 && a.layer === 0) return r2.fromNumber(i.sign * a.sign * i.mag * a.mag);
+    if (i.layer >= 3 || i.layer - a.layer >= 2) return m(i.sign * a.sign, i.layer, i.mag);
+    if (i.layer === 1 && a.layer === 0) return m(i.sign * a.sign, 1, i.mag + Math.log10(a.mag));
+    if (i.layer === 1 && a.layer === 1) return m(i.sign * a.sign, 1, i.mag + a.mag);
+    if (i.layer === 2 && a.layer === 1) {
+      var l = m(Math.sign(i.mag), i.layer - 1, Math.abs(i.mag)).add(m(Math.sign(a.mag), a.layer - 1, Math.abs(a.mag)));
+      return m(i.sign * a.sign, l.layer + 1, l.sign * l.mag);
+    }
+    if (i.layer === 2 && a.layer === 2) {
+      var f = m(Math.sign(i.mag), i.layer - 1, Math.abs(i.mag)).add(m(Math.sign(a.mag), a.layer - 1, Math.abs(a.mag)));
+      return m(i.sign * a.sign, f.layer + 1, f.sign * f.mag);
+    }
+    throw Error("Bad arguments to mul: " + this + ", " + e);
+  } }, { key: "multiply", value: function(e) {
+    return this.mul(e);
+  } }, { key: "times", value: function(e) {
+    return this.mul(e);
+  } }, { key: "div", value: function(e) {
+    var t = s(e);
+    return this.mul(t.recip());
+  } }, { key: "divide", value: function(e) {
+    return this.div(e);
+  } }, { key: "divideBy", value: function(e) {
+    return this.div(e);
+  } }, { key: "dividedBy", value: function(e) {
+    return this.div(e);
+  } }, { key: "recip", value: function() {
+    return this.mag === 0 ? new r2(r2.dNaN) : this.mag === Number.POSITIVE_INFINITY ? c(0, 0, 0) : this.layer === 0 ? m(this.sign, 0, 1 / this.mag) : m(this.sign, this.layer, -this.mag);
+  } }, { key: "reciprocal", value: function() {
+    return this.recip();
+  } }, { key: "reciprocate", value: function() {
+    return this.recip();
+  } }, { key: "mod", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false, i = s(e), a = i.abs();
+    if (this.eq(r2.dZero) || a.eq(r2.dZero)) return c(0, 0, 0);
+    if (t) {
+      var l = this.abs().mod(a);
+      return this.sign == -1 != (i.sign == -1) && (l = i.abs().sub(l)), l.mul(i.sign);
+    }
+    var f = this.toNumber(), g = a.toNumber();
+    return isFinite(f) && isFinite(g) && f != 0 && g != 0 ? new r2(f % g) : this.sub(a).eq(this) ? c(0, 0, 0) : a.sub(this).eq(a) ? new r2(this) : this.sign == -1 ? this.abs().mod(a).neg() : this.sub(this.div(a).floor().mul(a));
+  } }, { key: "modulo", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    return this.mod(e, t);
+  } }, { key: "modular", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    return this.mod(e, t);
+  } }, { key: "cmp", value: function(e) {
+    var t = s(e);
+    return this.sign > t.sign ? 1 : this.sign < t.sign ? -1 : this.sign * this.cmpabs(e);
+  } }, { key: "cmpabs", value: function(e) {
+    var t = s(e), i = this.mag > 0 ? this.layer : -this.layer, a = t.mag > 0 ? t.layer : -t.layer;
+    return i > a ? 1 : i < a ? -1 : this.mag > t.mag ? 1 : this.mag < t.mag ? -1 : 0;
+  } }, { key: "compare", value: function(e) {
+    return this.cmp(e);
+  } }, { key: "isNan", value: function() {
+    return isNaN(this.sign) || isNaN(this.layer) || isNaN(this.mag);
+  } }, { key: "isFinite", value: (function(n) {
+    function e() {
+      return n.apply(this, arguments);
+    }
+    return e.toString = function() {
+      return n.toString();
+    }, e;
+  })(function() {
+    return isFinite(this.sign) && isFinite(this.layer) && isFinite(this.mag);
+  }) }, { key: "eq", value: function(e) {
+    var t = s(e);
+    return this.sign === t.sign && this.layer === t.layer && this.mag === t.mag;
+  } }, { key: "equals", value: function(e) {
+    return this.eq(e);
+  } }, { key: "neq", value: function(e) {
+    return !this.eq(e);
+  } }, { key: "notEquals", value: function(e) {
+    return this.neq(e);
+  } }, { key: "lt", value: function(e) {
+    return this.cmp(e) === -1;
+  } }, { key: "lte", value: function(e) {
+    return !this.gt(e);
+  } }, { key: "gt", value: function(e) {
+    return this.cmp(e) === 1;
+  } }, { key: "gte", value: function(e) {
+    return !this.lt(e);
+  } }, { key: "max", value: function(e) {
+    var t = s(e);
+    return this.lt(t) ? new r2(t) : new r2(this);
+  } }, { key: "min", value: function(e) {
+    var t = s(e);
+    return this.gt(t) ? new r2(t) : new r2(this);
+  } }, { key: "maxabs", value: function(e) {
+    var t = s(e);
+    return this.cmpabs(t) < 0 ? new r2(t) : new r2(this);
+  } }, { key: "minabs", value: function(e) {
+    var t = s(e);
+    return this.cmpabs(t) > 0 ? new r2(t) : new r2(this);
+  } }, { key: "clamp", value: function(e, t) {
+    return this.max(e).min(t);
+  } }, { key: "clampMin", value: function(e) {
+    return this.max(e);
+  } }, { key: "clampMax", value: function(e) {
+    return this.min(e);
+  } }, { key: "cmp_tolerance", value: function(e, t) {
+    var i = s(e);
+    return this.eq_tolerance(i, t) ? 0 : this.cmp(i);
+  } }, { key: "compare_tolerance", value: function(e, t) {
+    return this.cmp_tolerance(e, t);
+  } }, { key: "eq_tolerance", value: function(e, t) {
+    var i = s(e);
+    if (t == null && (t = 1e-7), this.sign !== i.sign || Math.abs(this.layer - i.layer) > 1) return false;
+    var a = this.mag, l = i.mag;
+    return this.layer > i.layer && (l = ie(l)), this.layer < i.layer && (a = ie(a)), Math.abs(a - l) <= t * Math.max(Math.abs(a), Math.abs(l));
+  } }, { key: "equals_tolerance", value: function(e, t) {
+    return this.eq_tolerance(e, t);
+  } }, { key: "neq_tolerance", value: function(e, t) {
+    return !this.eq_tolerance(e, t);
+  } }, { key: "notEquals_tolerance", value: function(e, t) {
+    return this.neq_tolerance(e, t);
+  } }, { key: "lt_tolerance", value: function(e, t) {
+    var i = s(e);
+    return !this.eq_tolerance(i, t) && this.lt(i);
+  } }, { key: "lte_tolerance", value: function(e, t) {
+    var i = s(e);
+    return this.eq_tolerance(i, t) || this.lt(i);
+  } }, { key: "gt_tolerance", value: function(e, t) {
+    var i = s(e);
+    return !this.eq_tolerance(i, t) && this.gt(i);
+  } }, { key: "gte_tolerance", value: function(e, t) {
+    var i = s(e);
+    return this.eq_tolerance(i, t) || this.gt(i);
+  } }, { key: "pLog10", value: function() {
+    return this.lt(r2.dZero) ? c(0, 0, 0) : this.log10();
+  } }, { key: "absLog10", value: function() {
+    return this.sign === 0 ? new r2(r2.dNaN) : this.layer > 0 ? m(Math.sign(this.mag), this.layer - 1, Math.abs(this.mag)) : m(1, 0, Math.log10(this.mag));
+  } }, { key: "log10", value: function() {
+    return this.sign <= 0 ? new r2(r2.dNaN) : this.layer > 0 ? m(Math.sign(this.mag), this.layer - 1, Math.abs(this.mag)) : m(this.sign, 0, Math.log10(this.mag));
+  } }, { key: "log", value: function(e) {
+    return e = s(e), this.sign <= 0 ? new r2(r2.dNaN) : e.sign <= 0 ? new r2(r2.dNaN) : e.sign === 1 && e.layer === 0 && e.mag === 1 ? new r2(r2.dNaN) : this.layer === 0 && e.layer === 0 ? m(this.sign, 0, Math.log(this.mag) / Math.log(e.mag)) : r2.div(this.log10(), e.log10());
+  } }, { key: "log2", value: function() {
+    return this.sign <= 0 ? new r2(r2.dNaN) : this.layer === 0 ? m(this.sign, 0, Math.log2(this.mag)) : this.layer === 1 ? m(Math.sign(this.mag), 0, Math.abs(this.mag) * 3.321928094887362) : this.layer === 2 ? m(Math.sign(this.mag), 1, Math.abs(this.mag) + 0.5213902276543247) : m(Math.sign(this.mag), this.layer - 1, Math.abs(this.mag));
+  } }, { key: "ln", value: function() {
+    return this.sign <= 0 ? new r2(r2.dNaN) : this.layer === 0 ? m(this.sign, 0, Math.log(this.mag)) : this.layer === 1 ? m(Math.sign(this.mag), 0, Math.abs(this.mag) * 2.302585092994046) : this.layer === 2 ? m(Math.sign(this.mag), 1, Math.abs(this.mag) + 0.36221568869946325) : m(Math.sign(this.mag), this.layer - 1, Math.abs(this.mag));
+  } }, { key: "logarithm", value: function(e) {
+    return this.log(e);
+  } }, { key: "pow", value: function(e) {
+    var t = s(e), i = new r2(this), a = new r2(t);
+    if (i.sign === 0) return a.eq(0) ? c(1, 0, 1) : i;
+    if (i.sign === 1 && i.layer === 0 && i.mag === 1) return i;
+    if (a.sign === 0) return c(1, 0, 1);
+    if (a.sign === 1 && a.layer === 0 && a.mag === 1) return i;
+    var l = i.absLog10().mul(a).pow10();
+    return this.sign === -1 ? Math.abs(a.toNumber() % 2) % 2 === 1 ? l.neg() : Math.abs(a.toNumber() % 2) % 2 === 0 ? l : new r2(r2.dNaN) : l;
+  } }, { key: "pow10", value: function() {
+    if (this.eq(r2.dInf)) return new r2(r2.dInf);
+    if (this.eq(r2.dNegInf)) return c(0, 0, 0);
+    if (!Number.isFinite(this.layer) || !Number.isFinite(this.mag)) return new r2(r2.dNaN);
+    var e = new r2(this);
+    if (e.layer === 0) {
+      var t = Math.pow(10, e.sign * e.mag);
+      if (Number.isFinite(t) && Math.abs(t) >= 0.1) return m(1, 0, t);
+      if (e.sign === 0) return c(1, 0, 1);
+      e = c(e.sign, e.layer + 1, Math.log10(e.mag));
+    }
+    return e.sign > 0 && e.mag >= 0 ? m(e.sign, e.layer + 1, e.mag) : e.sign < 0 && e.mag >= 0 ? m(-e.sign, e.layer + 1, -e.mag) : c(1, 0, 1);
+  } }, { key: "pow_base", value: function(e) {
+    return s(e).pow(this);
+  } }, { key: "root", value: function(e) {
+    var t = s(e);
+    return this.lt(0) && t.mod(2, true).eq(1) ? this.neg().root(t).neg() : this.pow(t.recip());
+  } }, { key: "factorial", value: function() {
+    return this.mag < 0 ? this.add(1).gamma() : this.layer === 0 ? this.add(1).gamma() : this.layer === 1 ? r2.exp(r2.mul(this, r2.ln(this).sub(1))) : r2.exp(this);
+  } }, { key: "gamma", value: function() {
+    if (this.mag < 0) return this.recip();
+    if (this.layer === 0) {
+      if (this.lt(c(1, 0, 24))) return r2.fromNumber(ke(this.sign * this.mag));
+      var e = this.mag - 1, t = 0.9189385332046727;
+      t = t + (e + 0.5) * Math.log(e), t = t - e;
+      var i = e * e, a = e, l = 12 * a, f = 1 / l, g = t + f;
+      if (g === t || (t = g, a = a * i, l = 360 * a, f = 1 / l, g = t - f, g === t)) return r2.exp(t);
+      t = g, a = a * i, l = 1260 * a;
+      var h = 1 / l;
+      return t = t + h, a = a * i, l = 1680 * a, h = 1 / l, t = t - h, r2.exp(t);
+    } else return this.layer === 1 ? r2.exp(r2.mul(this, r2.ln(this).sub(1))) : r2.exp(this);
+  } }, { key: "lngamma", value: function() {
+    return this.gamma().ln();
+  } }, { key: "exp", value: function() {
+    return this.mag < 0 ? c(1, 0, 1) : this.layer === 0 && this.mag <= 709.7 ? r2.fromNumber(Math.exp(this.sign * this.mag)) : this.layer === 0 ? m(1, 1, this.sign * Math.log10(Math.E) * this.mag) : this.layer === 1 ? m(1, 2, this.sign * (Math.log10(0.4342944819032518) + this.mag)) : m(1, this.layer + 1, this.sign * this.mag);
+  } }, { key: "sqr", value: function() {
+    return this.pow(2);
+  } }, { key: "sqrt", value: function() {
+    if (this.layer === 0) return r2.fromNumber(Math.sqrt(this.sign * this.mag));
+    if (this.layer === 1) return m(1, 2, Math.log10(this.mag) - 0.3010299956639812);
+    var e = r2.div(c(this.sign, this.layer - 1, this.mag), c(1, 0, 2));
+    return e.layer += 1, e.normalize(), e;
+  } }, { key: "cube", value: function() {
+    return this.pow(3);
+  } }, { key: "cbrt", value: function() {
+    return this.lt(0) ? this.neg().pow(1 / 3).neg() : this.pow(1 / 3);
+  } }, { key: "tetrate", value: function() {
+    var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 2, t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : c(1, 0, 1), i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    if (e === 1) return r2.pow(this, t);
+    if (e === 0) return new r2(t);
+    if (this.eq(r2.dOne)) return c(1, 0, 1);
+    if (this.eq(-1)) return r2.pow(this, t);
+    if (e === Number.POSITIVE_INFINITY) {
+      var a = this.toNumber();
+      if (a <= 1.444667861009766 && a >= 0.06598803584531254) {
+        var l = r2.ln(this).neg(), f = l.lambertw().div(l);
+        if (a < 1) return f;
+        var g = l.lambertw(false).div(l);
+        return a > 1.444667861009099 && (f = g = r2.fromNumber(Math.E)), t = s(t), t.eq(g) ? g : t.lt(g) ? f : new r2(r2.dInf);
+      } else return a > 1.444667861009766 ? new r2(r2.dInf) : new r2(r2.dNaN);
+    }
+    if (this.eq(r2.dZero)) {
+      var h = Math.abs((e + 1) % 2);
+      return h > 1 && (h = 2 - h), r2.fromNumber(h);
+    }
+    if (e < 0) return r2.iteratedlog(t, this, -e, i);
+    t = new r2(t);
+    var v = e;
+    e = Math.trunc(e);
+    var u = v - e;
+    if (this.gt(r2.dZero) && (this.lt(1) || this.lte(1.444667861009766) && t.lte(r2.ln(this).neg().lambertw(false).div(r2.ln(this).neg()))) && (v > 1e4 || !i)) {
+      var M = Math.min(1e4, e);
+      t.eq(r2.dOne) ? t = this.pow(u) : this.lt(1) ? t = t.pow(1 - u).mul(this.pow(t).pow(u)) : t = t.layeradd(u, this);
+      for (var x = 0; x < M; ++x) {
+        var w = t;
+        if (t = this.pow(t), w.eq(t)) return t;
+      }
+      return v > 1e4 && Math.ceil(v) % 2 == 1 ? this.pow(t) : t;
+    }
+    u !== 0 && (t.eq(r2.dOne) ? this.gt(10) || i ? t = this.pow(u) : (t = r2.fromNumber(r2.tetrate_critical(this.toNumber(), u)), this.lt(2) && (t = t.sub(1).mul(this.minus(1)).plus(1))) : this.eq(10) ? t = t.layeradd10(u, i) : this.lt(1) ? t = t.pow(1 - u).mul(this.pow(t).pow(u)) : t = t.layeradd(u, this, i));
+    for (var o = 0; o < e; ++o) {
+      if (t = this.pow(t), !isFinite(t.layer) || !isFinite(t.mag)) return t.normalize();
+      if (t.layer - this.layer > 3) return c(t.sign, t.layer + (e - o - 1), t.mag);
+      if (o > 1e4) return t;
+    }
+    return t;
+  } }, { key: "iteratedexp", value: function() {
+    var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 2, t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : c(1, 0, 1), i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    return this.tetrate(e, t, i);
+  } }, { key: "iteratedlog", value: function() {
+    var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 10, t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 1, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    if (t < 0) return r2.tetrate(e, -t, this, i);
+    e = s(e);
+    var a = r2.fromDecimal(this), l = t;
+    t = Math.trunc(t);
+    var f = l - t;
+    if (a.layer - e.layer > 3) {
+      var g = Math.min(t, a.layer - e.layer - 3);
+      t -= g, a.layer -= g;
+    }
+    for (var h = 0; h < t; ++h) {
+      if (a = a.log(e), !isFinite(a.layer) || !isFinite(a.mag)) return a.normalize();
+      if (h > 1e4) return a;
+    }
+    return f > 0 && f < 1 && (e.eq(10) ? a = a.layeradd10(-f, i) : a = a.layeradd(-f, e, i)), a;
+  } }, { key: "slog", value: function() {
+    for (var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 10, t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 100, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false, a = 1e-3, l = false, f = false, g = this.slog_internal(e, i).toNumber(), h = 1; h < t; ++h) {
+      var v = new r2(e).tetrate(g, r2.dOne, i), u = v.gt(this);
+      if (h > 1 && f != u && (l = true), f = u, l ? a /= 2 : a *= 2, a = Math.abs(a) * (u ? -1 : 1), g += a, a === 0) break;
+    }
+    return r2.fromNumber(g);
+  } }, { key: "slog_internal", value: function() {
+    var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 10, t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    if (e = s(e), e.lte(r2.dZero)) return new r2(r2.dNaN);
+    if (e.eq(r2.dOne)) return new r2(r2.dNaN);
+    if (e.lt(r2.dOne)) return this.eq(r2.dOne) ? c(0, 0, 0) : this.eq(r2.dZero) ? c(-1, 0, 1) : new r2(r2.dNaN);
+    if (this.mag < 0 || this.eq(r2.dZero)) return c(-1, 0, 1);
+    if (e.lt(1.444667861009766)) {
+      var i = r2.ln(e).neg(), a = i.lambertw().div(i);
+      if (this.eq(a)) return new r2(r2.dInf);
+      if (this.gt(a)) return new r2(r2.dNaN);
+    }
+    var l = 0, f = r2.fromDecimal(this);
+    if (f.layer - e.layer > 3) {
+      var g = f.layer - e.layer - 3;
+      l += g, f.layer -= g;
+    }
+    for (var h = 0; h < 100; ++h) if (f.lt(r2.dZero)) f = r2.pow(e, f), l -= 1;
+    else {
+      if (f.lte(r2.dOne)) return t ? r2.fromNumber(l + f.toNumber() - 1) : r2.fromNumber(l + r2.slog_critical(e.toNumber(), f.toNumber()));
+      l += 1, f = r2.log(f, e);
+    }
+    return r2.fromNumber(l);
+  } }, { key: "layeradd10", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    e = r2.fromValue_noAlloc(e).toNumber();
+    var i = r2.fromDecimal(this);
+    if (e >= 1) {
+      i.mag < 0 && i.layer > 0 ? (i.sign = 0, i.mag = 0, i.layer = 0) : i.sign === -1 && i.layer == 0 && (i.sign = 1, i.mag = -i.mag);
+      var a = Math.trunc(e);
+      e -= a, i.layer += a;
+    }
+    if (e <= -1) {
+      var l = Math.trunc(e);
+      if (e -= l, i.layer += l, i.layer < 0) for (var f = 0; f < 100; ++f) {
+        if (i.layer++, i.mag = Math.log10(i.mag), !isFinite(i.mag)) return i.sign === 0 && (i.sign = 1), i.layer < 0 && (i.layer = 0), i.normalize();
+        if (i.layer >= 0) break;
+      }
+    }
+    for (; i.layer < 0; ) i.layer++, i.mag = Math.log10(i.mag);
+    return i.sign === 0 && (i.sign = 1, i.mag === 0 && i.layer >= 1 && (i.layer -= 1, i.mag = 1)), i.normalize(), e !== 0 ? i.layeradd(e, 10, t) : i;
+  } }, { key: "layeradd", value: function(e, t) {
+    var i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false, a = s(t);
+    if (a.gt(1) && a.lte(1.444667861009766)) {
+      var l = r2.excess_slog(this, t, i), f = l[0].toNumber(), g = l[1], h = f + e, v = r2.ln(t).neg(), u = v.lambertw().div(v), M = v.lambertw(false).div(v), x = r2.dOne;
+      g == 1 ? x = u.mul(M).sqrt() : g == 2 && (x = M.mul(2));
+      var w = a.pow(x), o = Math.floor(h), F = h - o, A = x.pow(1 - F).mul(w.pow(F));
+      return r2.tetrate(a, o, A, i);
+    }
+    var d = this.slog(t, 100, i).toNumber(), S = d + e;
+    return S >= 0 ? r2.tetrate(t, S, r2.dOne, i) : Number.isFinite(S) ? S >= -1 ? r2.log(r2.tetrate(t, S + 1, r2.dOne, i), t) : r2.log(r2.log(r2.tetrate(t, S + 2, r2.dOne, i), t), t) : new r2(r2.dNaN);
+  } }, { key: "lambertw", value: function() {
+    var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : true;
+    return this.lt(-0.3678794411710499) ? new r2(r2.dNaN) : e ? this.abs().lt("1e-300") ? new r2(this) : this.mag < 0 ? r2.fromNumber(ae(this.toNumber())) : this.layer === 0 ? r2.fromNumber(ae(this.sign * this.mag)) : this.lt("eee15") ? he(this) : this.ln() : this.sign === 1 ? new r2(r2.dNaN) : this.layer === 0 ? r2.fromNumber(ae(this.sign * this.mag, 1e-10, false)) : this.layer == 1 ? he(this, 1e-10, false) : this.neg().recip().lambertw().neg();
+  } }, { key: "ssqrt", value: function() {
+    return this.linear_sroot(2);
+  } }, { key: "linear_sroot", value: function(e) {
+    if (e == 1) return this;
+    if (this.eq(r2.dInf)) return new r2(r2.dInf);
+    if (!this.isFinite()) return new r2(r2.dNaN);
+    if (e > 0 && e < 1) return this.root(e);
+    if (e > -2 && e < -1) return r2.fromNumber(e).add(2).pow(this.recip());
+    if (e <= 0) return new r2(r2.dNaN);
+    if (e == Number.POSITIVE_INFINITY) {
+      var t = this.toNumber();
+      return t < Math.E && t > Me ? this.pow(this.recip()) : new r2(r2.dNaN);
+    }
+    if (this.eq(1)) return c(1, 0, 1);
+    if (this.lt(0)) return new r2(r2.dNaN);
+    if (this.lte("1ee-16")) return e % 2 == 1 ? new r2(this) : new r2(r2.dNaN);
+    if (this.gt(1)) {
+      var i = r2.dTen;
+      this.gte(r2.tetrate(10, e, 1, true)) && (i = this.iteratedlog(10, e - 1, true)), e <= 1 && (i = this.root(e));
+      for (var a = r2.dZero, l = i.layer, f = i.iteratedlog(10, l, true), g = f, h = f.div(2), v = true; v; ) h = a.add(f).div(2), r2.iteratedexp(10, l, h, true).tetrate(e, 1, true).gt(this) ? f = h : a = h, h.eq(g) ? v = false : g = h;
+      return r2.iteratedexp(10, l, h, true);
+    } else {
+      for (var u = 1, M = m(1, 10, 1), x = m(1, 10, 1), w = m(1, 10, 1), o = m(1, 1, -16), F = r2.dZero, A = m(1, 10, 1), d = o.pow10().recip(), S = r2.dZero, p = d, q = d, I = Math.ceil(e) % 2 == 0, N = 0, y = m(1, 10, 1), V = false, C = r2.dZero, D = false; u < 4; ) {
+        if (u == 2) {
+          if (I) break;
+          w = m(1, 10, 1), o = M, u = 3, A = m(1, 10, 1), y = m(1, 10, 1);
+        }
+        for (V = false; o.neq(w); ) {
+          if (C = o, o.pow10().recip().tetrate(e, 1, true).eq(1) && o.pow10().recip().lt(0.4)) d = o.pow10().recip(), p = o.pow10().recip(), q = o.pow10().recip(), S = r2.dZero, N = -1, u == 3 && (y = o);
+          else if (o.pow10().recip().tetrate(e, 1, true).eq(o.pow10().recip()) && !I && o.pow10().recip().lt(0.4)) d = o.pow10().recip(), p = o.pow10().recip(), q = o.pow10().recip(), S = r2.dZero, N = 0;
+          else if (o.pow10().recip().tetrate(e, 1, true).eq(o.pow10().recip().mul(2).tetrate(e, 1, true))) d = o.pow10().recip(), p = r2.dZero, q = d.mul(2), S = d, I ? N = -1 : N = 0;
+          else {
+            for (F = o.mul(12e-17), d = o.pow10().recip(), p = o.add(F).pow10().recip(), S = d.sub(p), q = d.add(S); p.tetrate(e, 1, true).eq(d.tetrate(e, 1, true)) || q.tetrate(e, 1, true).eq(d.tetrate(e, 1, true)) || p.gte(d) || q.lte(d); ) F = F.mul(2), p = o.add(F).pow10().recip(), S = d.sub(p), q = d.add(S);
+            if ((u == 1 && q.tetrate(e, 1, true).gt(d.tetrate(e, 1, true)) && p.tetrate(e, 1, true).gt(d.tetrate(e, 1, true)) || u == 3 && q.tetrate(e, 1, true).lt(d.tetrate(e, 1, true)) && p.tetrate(e, 1, true).lt(d.tetrate(e, 1, true))) && (y = o), q.tetrate(e, 1, true).lt(d.tetrate(e, 1, true))) N = -1;
+            else if (I) N = 1;
+            else if (u == 3 && o.gt_tolerance(M, 1e-8)) N = 0;
+            else {
+              for (; p.tetrate(e, 1, true).eq_tolerance(d.tetrate(e, 1, true), 1e-8) || q.tetrate(e, 1, true).eq_tolerance(d.tetrate(e, 1, true), 1e-8) || p.gte(d) || q.lte(d); ) F = F.mul(2), p = o.add(F).pow10().recip(), S = d.sub(p), q = d.add(S);
+              q.tetrate(e, 1, true).sub(d.tetrate(e, 1, true)).lt(d.tetrate(e, 1, true).sub(p.tetrate(e, 1, true))) ? N = 0 : N = 1;
+            }
+          }
+          if (N == -1 && (D = true), u == 1 && N == 1 || u == 3 && N != 0) if (w.eq(m(1, 10, 1))) o = o.mul(2);
+          else {
+            var Y = false;
+            if (V && (N == 1 && u == 1 || N == -1 && u == 3) && (Y = true), o = o.add(w).div(2), Y) break;
+          }
+          else if (w.eq(m(1, 10, 1))) w = o, o = o.div(2);
+          else {
+            var L = false;
+            if (V && (N == 1 && u == 1 || N == -1 && u == 3) && (L = true), w = w.sub(A), o = o.sub(A), L) break;
+          }
+          if (w.sub(o).div(2).abs().gt(A.mul(1.5)) && (V = true), A = w.sub(o).div(2).abs(), o.gt("1e18") || o.eq(C)) break;
+        }
+        if (o.gt("1e18") || !D || y == m(1, 10, 1)) break;
+        u == 1 ? M = y : u == 3 && (x = y), u++;
+      }
+      w = M, o = m(1, 1, -18);
+      for (var G = o, E = r2.dZero, X = true; X; ) if (w.eq(m(1, 10, 1)) ? E = o.mul(2) : E = w.add(o).div(2), r2.pow(10, E).recip().tetrate(e, 1, true).gt(this) ? o = E : w = E, E.eq(G) ? X = false : G = E, o.gt("1e18")) return new r2(r2.dNaN);
+      if (E.eq_tolerance(M, 1e-15)) {
+        if (x.eq(m(1, 10, 1))) return new r2(r2.dNaN);
+        for (w = m(1, 10, 1), o = x, G = o, E = r2.dZero, X = true; X; ) if (w.eq(m(1, 10, 1)) ? E = o.mul(2) : E = w.add(o).div(2), r2.pow(10, E).recip().tetrate(e, 1, true).gt(this) ? o = E : w = E, E.eq(G) ? X = false : G = E, o.gt("1e18")) return new r2(r2.dNaN);
+        return E.pow10().recip();
+      } else return E.pow10().recip();
+    }
+  } }, { key: "pentate", value: function() {
+    var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 2, t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : c(1, 0, 1), i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    t = new r2(t);
+    var a = e;
+    e = Math.floor(e);
+    var l = a - e, f = r2.dZero, g = r2.dZero;
+    if (l !== 0) if (t.eq(r2.dOne)) ++e, t = r2.fromNumber(l);
+    else return this.pentate(t.penta_log(this, void 0, i).plus(a).toNumber(), 1, i);
+    if (e > 0) for (var h = 0; h < e; ) {
+      if (g = f, f = t, t = this.tetrate(t.toNumber(), r2.dOne, i), ++h, this.gt(0) && this.lte(1) && t.gt(0) && t.lte(1)) return this.tetrate(e - h, t, i);
+      if (t.eq(f) || t.eq(g) && h % 2 == e % 2 || !isFinite(t.layer) || !isFinite(t.mag)) return t.normalize();
+      if (h > 1e4) return t;
+    }
+    else for (var v = 0; v < -e; ++v) {
+      if (f = t, t = t.slog(this, void 0, i), t.eq(f) || !isFinite(t.layer) || !isFinite(t.mag)) return t.normalize();
+      if (v > 100) return t;
+    }
+    return t;
+  } }, { key: "penta_log", value: function() {
+    var e = arguments.length > 0 && arguments[0] !== void 0 ? arguments[0] : 10, t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 100, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    if (e = new r2(e), e.lte(1)) return new r2(r2.dNaN);
+    if (this.eq(1)) return c(0, 0, 0);
+    if (this.eq(r2.dInf)) return new r2(r2.dInf);
+    var a = new r2(1), l = 0, f = 1;
+    if (this.lt(-1)) {
+      if (this.lte(-2)) return new r2(r2.dNaN);
+      var g = e.tetrate(this.toNumber(), 1, i);
+      if (this.eq(g)) return new r2(r2.dNegInf);
+      if (this.gt(g)) return new r2(r2.dNaN);
+    }
+    if (this.gt(1)) {
+      for (; a.lt(this); ) if (l++, a = r2.tetrate(e, a.toNumber(), 1, i), l > 1e3) return new r2(r2.dNaN);
+    } else for (; a.gt(this); ) if (l--, a = r2.slog(a, e, i), l > 100) return new r2(r2.dNaN);
+    for (var h = 1; h < t; ++h) {
+      var v = e.pentate(l, r2.dOne, i);
+      if (v.eq(this)) break;
+      var u = v.gt(this);
+      if (f = Math.abs(f) * (u ? -1 : 1), l += f, f /= 2, f === 0) break;
+    }
+    return r2.fromNumber(l);
+  } }, { key: "linear_penta_root", value: function(e) {
+    return e == 1 ? this : e < 0 ? new r2(r2.dNaN) : this.eq(r2.dInf) ? new r2(r2.dInf) : this.isFinite() ? e > 0 && e < 1 ? this.root(e) : this.eq(1) ? c(1, 0, 1) : this.lt(0) ? new r2(r2.dNaN) : this.lt(1) ? this.linear_sroot(e) : r2.increasingInverse(function(t) {
+      return r2.pentate(t, e, 1, true);
+    })(this) : new r2(r2.dNaN);
+  } }, { key: "sin", value: function() {
+    return this.mag < 0 ? new r2(this) : this.layer === 0 ? r2.fromNumber(Math.sin(this.sign * this.mag)) : c(0, 0, 0);
+  } }, { key: "cos", value: function() {
+    return this.mag < 0 ? c(1, 0, 1) : this.layer === 0 ? r2.fromNumber(Math.cos(this.sign * this.mag)) : c(0, 0, 0);
+  } }, { key: "tan", value: function() {
+    return this.mag < 0 ? new r2(this) : this.layer === 0 ? r2.fromNumber(Math.tan(this.sign * this.mag)) : c(0, 0, 0);
+  } }, { key: "asin", value: function() {
+    return this.mag < 0 ? new r2(this) : this.layer === 0 ? r2.fromNumber(Math.asin(this.sign * this.mag)) : new r2(r2.dNaN);
+  } }, { key: "acos", value: function() {
+    return this.mag < 0 ? r2.fromNumber(Math.acos(this.toNumber())) : this.layer === 0 ? r2.fromNumber(Math.acos(this.sign * this.mag)) : new r2(r2.dNaN);
+  } }, { key: "atan", value: function() {
+    return this.mag < 0 ? new r2(this) : this.layer === 0 ? r2.fromNumber(Math.atan(this.sign * this.mag)) : r2.fromNumber(Math.atan(this.sign * (1 / 0)));
+  } }, { key: "sinh", value: function() {
+    return this.exp().sub(this.negate().exp()).div(2);
+  } }, { key: "cosh", value: function() {
+    return this.exp().add(this.negate().exp()).div(2);
+  } }, { key: "tanh", value: function() {
+    return this.sinh().div(this.cosh());
+  } }, { key: "asinh", value: function() {
+    return r2.ln(this.add(this.sqr().add(1).sqrt()));
+  } }, { key: "acosh", value: function() {
+    return r2.ln(this.add(this.sqr().sub(1).sqrt()));
+  } }, { key: "atanh", value: function() {
+    return this.abs().gte(1) ? new r2(r2.dNaN) : r2.ln(this.add(1).div(r2.fromNumber(1).sub(this))).div(2);
+  } }, { key: "ascensionPenalty", value: function(e) {
+    return e === 0 ? new r2(this) : this.root(r2.pow(10, e));
+  } }, { key: "egg", value: function() {
+    return this.add(9);
+  } }, { key: "lessThanOrEqualTo", value: function(e) {
+    return this.cmp(e) < 1;
+  } }, { key: "lessThan", value: function(e) {
+    return this.cmp(e) < 0;
+  } }, { key: "greaterThanOrEqualTo", value: function(e) {
+    return this.cmp(e) > -1;
+  } }, { key: "greaterThan", value: function(e) {
+    return this.cmp(e) > 0;
+  } }], [{ key: "fromComponents", value: function(e, t, i) {
+    return new r2().fromComponents(e, t, i);
+  } }, { key: "fromComponents_noNormalize", value: function(e, t, i) {
+    return new r2().fromComponents_noNormalize(e, t, i);
+  } }, { key: "fromMantissaExponent", value: function(e, t) {
+    return new r2().fromMantissaExponent(e, t);
+  } }, { key: "fromMantissaExponent_noNormalize", value: function(e, t) {
+    return new r2().fromMantissaExponent_noNormalize(e, t);
+  } }, { key: "fromDecimal", value: function(e) {
+    return new r2().fromDecimal(e);
+  } }, { key: "fromNumber", value: function(e) {
+    return new r2().fromNumber(e);
+  } }, { key: "fromString", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false;
+    return new r2().fromString(e, t);
+  } }, { key: "fromValue", value: function(e) {
+    return new r2().fromValue(e);
+  } }, { key: "fromValue_noAlloc", value: function(e) {
+    if (e instanceof r2) return e;
+    if (typeof e == "string") {
+      var t = r2.fromStringCache.get(e);
+      return t !== void 0 ? t : r2.fromString(e);
+    } else return typeof e == "number" ? r2.fromNumber(e) : c(0, 0, 0);
+  } }, { key: "abs", value: function(e) {
+    return s(e).abs();
+  } }, { key: "neg", value: function(e) {
+    return s(e).neg();
+  } }, { key: "negate", value: function(e) {
+    return s(e).neg();
+  } }, { key: "negated", value: function(e) {
+    return s(e).neg();
+  } }, { key: "sign", value: function(e) {
+    return s(e).sign;
+  } }, { key: "sgn", value: function(e) {
+    return s(e).sign;
+  } }, { key: "round", value: function(e) {
+    return s(e).round();
+  } }, { key: "floor", value: function(e) {
+    return s(e).floor();
+  } }, { key: "ceil", value: function(e) {
+    return s(e).ceil();
+  } }, { key: "trunc", value: function(e) {
+    return s(e).trunc();
+  } }, { key: "add", value: function(e, t) {
+    return s(e).add(t);
+  } }, { key: "plus", value: function(e, t) {
+    return s(e).add(t);
+  } }, { key: "sub", value: function(e, t) {
+    return s(e).sub(t);
+  } }, { key: "subtract", value: function(e, t) {
+    return s(e).sub(t);
+  } }, { key: "minus", value: function(e, t) {
+    return s(e).sub(t);
+  } }, { key: "mul", value: function(e, t) {
+    return s(e).mul(t);
+  } }, { key: "multiply", value: function(e, t) {
+    return s(e).mul(t);
+  } }, { key: "times", value: function(e, t) {
+    return s(e).mul(t);
+  } }, { key: "div", value: function(e, t) {
+    return s(e).div(t);
+  } }, { key: "divide", value: function(e, t) {
+    return s(e).div(t);
+  } }, { key: "recip", value: function(e) {
+    return s(e).recip();
+  } }, { key: "reciprocal", value: function(e) {
+    return s(e).recip();
+  } }, { key: "reciprocate", value: function(e) {
+    return s(e).reciprocate();
+  } }, { key: "mod", value: function(e, t) {
+    var i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    return s(e).mod(t, i);
+  } }, { key: "modulo", value: function(e, t) {
+    var i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    return s(e).modulo(t, i);
+  } }, { key: "modular", value: function(e, t) {
+    var i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    return s(e).modular(t, i);
+  } }, { key: "cmp", value: function(e, t) {
+    return s(e).cmp(t);
+  } }, { key: "cmpabs", value: function(e, t) {
+    return s(e).cmpabs(t);
+  } }, { key: "compare", value: function(e, t) {
+    return s(e).cmp(t);
+  } }, { key: "isNaN", value: (function(n) {
+    function e(t) {
+      return n.apply(this, arguments);
+    }
+    return e.toString = function() {
+      return n.toString();
+    }, e;
+  })(function(n) {
+    return n = s(n), isNaN(n.sign) || isNaN(n.layer) || isNaN(n.mag);
+  }) }, { key: "isFinite", value: (function(n) {
+    function e(t) {
+      return n.apply(this, arguments);
+    }
+    return e.toString = function() {
+      return n.toString();
+    }, e;
+  })(function(n) {
+    return n = s(n), isFinite(n.sign) && isFinite(n.layer) && isFinite(n.mag);
+  }) }, { key: "eq", value: function(e, t) {
+    return s(e).eq(t);
+  } }, { key: "equals", value: function(e, t) {
+    return s(e).eq(t);
+  } }, { key: "neq", value: function(e, t) {
+    return s(e).neq(t);
+  } }, { key: "notEquals", value: function(e, t) {
+    return s(e).notEquals(t);
+  } }, { key: "lt", value: function(e, t) {
+    return s(e).lt(t);
+  } }, { key: "lte", value: function(e, t) {
+    return s(e).lte(t);
+  } }, { key: "gt", value: function(e, t) {
+    return s(e).gt(t);
+  } }, { key: "gte", value: function(e, t) {
+    return s(e).gte(t);
+  } }, { key: "max", value: function(e, t) {
+    return s(e).max(t);
+  } }, { key: "min", value: function(e, t) {
+    return s(e).min(t);
+  } }, { key: "minabs", value: function(e, t) {
+    return s(e).minabs(t);
+  } }, { key: "maxabs", value: function(e, t) {
+    return s(e).maxabs(t);
+  } }, { key: "clamp", value: function(e, t, i) {
+    return s(e).clamp(t, i);
+  } }, { key: "clampMin", value: function(e, t) {
+    return s(e).clampMin(t);
+  } }, { key: "clampMax", value: function(e, t) {
+    return s(e).clampMax(t);
+  } }, { key: "cmp_tolerance", value: function(e, t, i) {
+    return s(e).cmp_tolerance(t, i);
+  } }, { key: "compare_tolerance", value: function(e, t, i) {
+    return s(e).cmp_tolerance(t, i);
+  } }, { key: "eq_tolerance", value: function(e, t, i) {
+    return s(e).eq_tolerance(t, i);
+  } }, { key: "equals_tolerance", value: function(e, t, i) {
+    return s(e).eq_tolerance(t, i);
+  } }, { key: "neq_tolerance", value: function(e, t, i) {
+    return s(e).neq_tolerance(t, i);
+  } }, { key: "notEquals_tolerance", value: function(e, t, i) {
+    return s(e).notEquals_tolerance(t, i);
+  } }, { key: "lt_tolerance", value: function(e, t, i) {
+    return s(e).lt_tolerance(t, i);
+  } }, { key: "lte_tolerance", value: function(e, t, i) {
+    return s(e).lte_tolerance(t, i);
+  } }, { key: "gt_tolerance", value: function(e, t, i) {
+    return s(e).gt_tolerance(t, i);
+  } }, { key: "gte_tolerance", value: function(e, t, i) {
+    return s(e).gte_tolerance(t, i);
+  } }, { key: "pLog10", value: function(e) {
+    return s(e).pLog10();
+  } }, { key: "absLog10", value: function(e) {
+    return s(e).absLog10();
+  } }, { key: "log10", value: function(e) {
+    return s(e).log10();
+  } }, { key: "log", value: function(e, t) {
+    return s(e).log(t);
+  } }, { key: "log2", value: function(e) {
+    return s(e).log2();
+  } }, { key: "ln", value: function(e) {
+    return s(e).ln();
+  } }, { key: "logarithm", value: function(e, t) {
+    return s(e).logarithm(t);
+  } }, { key: "pow", value: function(e, t) {
+    return s(e).pow(t);
+  } }, { key: "pow10", value: function(e) {
+    return s(e).pow10();
+  } }, { key: "root", value: function(e, t) {
+    return s(e).root(t);
+  } }, { key: "factorial", value: function(e, t) {
+    return s(e).factorial();
+  } }, { key: "gamma", value: function(e, t) {
+    return s(e).gamma();
+  } }, { key: "lngamma", value: function(e, t) {
+    return s(e).lngamma();
+  } }, { key: "exp", value: function(e) {
+    return s(e).exp();
+  } }, { key: "sqr", value: function(e) {
+    return s(e).sqr();
+  } }, { key: "sqrt", value: function(e) {
+    return s(e).sqrt();
+  } }, { key: "cube", value: function(e) {
+    return s(e).cube();
+  } }, { key: "cbrt", value: function(e) {
+    return s(e).cbrt();
+  } }, { key: "tetrate", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 2, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : c(1, 0, 1), a = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+    return s(e).tetrate(t, i, a);
+  } }, { key: "iteratedexp", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 2, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : c(1, 0, 1), a = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+    return s(e).iteratedexp(t, i, a);
+  } }, { key: "iteratedlog", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 10, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 1, a = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+    return s(e).iteratedlog(t, i, a);
+  } }, { key: "layeradd10", value: function(e, t) {
+    var i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    return s(e).layeradd10(t, i);
+  } }, { key: "layeradd", value: function(e, t) {
+    var i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 10, a = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+    return s(e).layeradd(t, i, a);
+  } }, { key: "slog", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 10, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    return s(e).slog(t, 100, i);
+  } }, { key: "lambertw", value: function(e, t) {
+    return s(e).lambertw(t);
+  } }, { key: "ssqrt", value: function(e) {
+    return s(e).ssqrt();
+  } }, { key: "linear_sroot", value: function(e, t) {
+    return s(e).linear_sroot(t);
+  } }, { key: "pentate", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 2, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : c(1, 0, 1), a = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : false;
+    return s(e).pentate(t, i, a);
+  } }, { key: "penta_log", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : 10, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    return s(e).penta_log(t, 100, i);
+  } }, { key: "linear_penta_root", value: function(e, t) {
+    return s(e).linear_penta_root(t);
+  } }, { key: "sin", value: function(e) {
+    return s(e).sin();
+  } }, { key: "cos", value: function(e) {
+    return s(e).cos();
+  } }, { key: "tan", value: function(e) {
+    return s(e).tan();
+  } }, { key: "asin", value: function(e) {
+    return s(e).asin();
+  } }, { key: "acos", value: function(e) {
+    return s(e).acos();
+  } }, { key: "atan", value: function(e) {
+    return s(e).atan();
+  } }, { key: "sinh", value: function(e) {
+    return s(e).sinh();
+  } }, { key: "cosh", value: function(e) {
+    return s(e).cosh();
+  } }, { key: "tanh", value: function(e) {
+    return s(e).tanh();
+  } }, { key: "asinh", value: function(e) {
+    return s(e).asinh();
+  } }, { key: "acosh", value: function(e) {
+    return s(e).acosh();
+  } }, { key: "atanh", value: function(e) {
+    return s(e).atanh();
+  } }, { key: "affordGeometricSeries", value: function(e, t, i, a) {
+    return this.affordGeometricSeries_core(s(e), s(t), s(i), a);
+  } }, { key: "sumGeometricSeries", value: function(e, t, i, a) {
+    return this.sumGeometricSeries_core(e, s(t), s(i), a);
+  } }, { key: "affordArithmeticSeries", value: function(e, t, i, a) {
+    return this.affordArithmeticSeries_core(s(e), s(t), s(i), s(a));
+  } }, { key: "sumArithmeticSeries", value: function(e, t, i, a) {
+    return this.sumArithmeticSeries_core(s(e), s(t), s(i), s(a));
+  } }, { key: "efficiencyOfPurchase", value: function(e, t, i) {
+    return this.efficiencyOfPurchase_core(s(e), s(t), s(i));
+  } }, { key: "randomDecimalForTesting", value: function(e) {
+    if (Math.random() * 20 < 1) return c(0, 0, 0);
+    var t = Math.random() > 0.5 ? 1 : -1;
+    if (Math.random() * 20 < 1) return c(t, 0, 1);
+    var i = Math.floor(Math.random() * (e + 1)), a = i === 0 ? Math.random() * 616 - 308 : Math.random() * 16;
+    Math.random() > 0.9 && (a = Math.trunc(a));
+    var l = Math.pow(10, a);
+    return Math.random() > 0.9 && (l = Math.trunc(l)), m(t, i, l);
+  } }, { key: "affordGeometricSeries_core", value: function(e, t, i, a) {
+    var l = t.mul(i.pow(a));
+    return r2.floor(e.div(l).mul(i.sub(1)).add(1).log10().div(i.log10()));
+  } }, { key: "sumGeometricSeries_core", value: function(e, t, i, a) {
+    return t.mul(i.pow(a)).mul(r2.sub(1, i.pow(e))).div(r2.sub(1, i));
+  } }, { key: "affordArithmeticSeries_core", value: function(e, t, i, a) {
+    var l = t.add(a.mul(i)), f = l.sub(i.div(2)), g = f.pow(2);
+    return f.neg().add(g.add(i.mul(e).mul(2)).sqrt()).div(i).floor();
+  } }, { key: "sumArithmeticSeries_core", value: function(e, t, i, a) {
+    var l = t.add(a.mul(i));
+    return e.div(2).mul(l.mul(2).plus(e.sub(1).mul(i)));
+  } }, { key: "efficiencyOfPurchase_core", value: function(e, t, i) {
+    return e.div(t).add(e.div(i));
+  } }, { key: "slog_critical", value: function(e, t) {
+    return e > 10 ? t - 1 : r2.critical_section(e, t, we);
+  } }, { key: "tetrate_critical", value: function(e, t) {
+    return r2.critical_section(e, t, be);
+  } }, { key: "critical_section", value: function(e, t, i) {
+    t *= 10, t < 0 && (t = 0), t > 10 && (t = 10), e < 2 && (e = 2), e > 10 && (e = 10);
+    for (var a = 0, l = 0, f = 0; f < _.length; ++f) if (_[f] == e) {
+      a = i[f][Math.floor(t)], l = i[f][Math.ceil(t)];
+      break;
+    } else if (_[f] < e && _[f + 1] > e) {
+      var g = (e - _[f]) / (_[f + 1] - _[f]);
+      a = i[f][Math.floor(t)] * (1 - g) + i[f + 1][Math.floor(t)] * g, l = i[f][Math.ceil(t)] * (1 - g) + i[f + 1][Math.ceil(t)] * g;
+      break;
+    }
+    var h = t - Math.floor(t);
+    return a <= 0 || l <= 0 ? a * (1 - h) + l * h : Math.pow(e, Math.log(a) / Math.log(e) * (1 - h) + Math.log(l) / Math.log(e) * h);
+  } }, { key: "excess_slog", value: function(e, t) {
+    var i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : false;
+    e = s(e), t = s(t);
+    var a = t;
+    if (t = t.toNumber(), t == 1 || t <= 0) return [new r2(r2.dNaN), 0];
+    if (t > 1.444667861009766) return [e.slog(t, 100, i), 0];
+    var l = r2.ln(t).neg(), f = l.lambertw().div(l), g = r2.dInf;
+    if (t > 1 && (g = l.lambertw(false).div(l)), t > 1.444667861009099 && (f = g = r2.fromNumber(Math.E)), e.lt(f)) return [e.slog(t, 100, i), 0];
+    if (e.eq(f)) return [new r2(r2.dInf), 0];
+    if (e.eq(g)) return [new r2(r2.dNegInf), 2];
+    if (e.gt(g)) {
+      var h = g.mul(2), v = a.pow(h), u = 0;
+      if (e.gte(h) && e.lt(v)) u = 0;
+      else if (e.gte(v)) {
+        var M = v;
+        for (u = 1; M.lt(e); ) if (M = a.pow(M), u = u + 1, M.layer > 3) {
+          var x = Math.floor(e.layer - M.layer + 1);
+          M = a.iteratedexp(x, M, i), u = u + x;
+        }
+        M.gt(e) && (M = M.log(t), u = u - 1);
+      } else if (e.lt(h)) {
+        var w = h;
+        for (u = 0; w.gt(e); ) w = w.log(t), u = u - 1;
+      }
+      for (var o = 0, F = 0, A = 0.5, d = h, S = r2.dZero; A > 1e-16; ) {
+        if (F = o + A, d = h.pow(1 - F).mul(v.pow(F)), S = r2.iteratedexp(t, u, d), S.eq(e)) return [new r2(u + F), 2];
+        S.lt(e) && (o += A), A /= 2;
+      }
+      return S.neq_tolerance(e, 1e-7) ? [new r2(r2.dNaN), 0] : [new r2(u + o), 2];
+    }
+    if (e.lt(g) && e.gt(f)) {
+      var p = f.mul(g).sqrt(), q = a.pow(p), I = 0;
+      if (e.lte(p) && e.gt(q)) I = 0;
+      else if (e.lte(q)) {
+        var N = q;
+        for (I = 1; N.gt(e); ) N = a.pow(N), I = I + 1;
+        N.lt(e) && (N = N.log(t), I = I - 1);
+      } else if (e.gt(p)) {
+        var y = p;
+        for (I = 0; y.lt(e); ) y = y.log(t), I = I - 1;
+      }
+      for (var V = 0, C = 0, D = 0.5, Y = p, L = r2.dZero; D > 1e-16; ) {
+        if (C = V + D, Y = p.pow(1 - C).mul(q.pow(C)), L = r2.iteratedexp(t, I, Y), L.eq(e)) return [new r2(I + C), 1];
+        L.gt(e) && (V += D), D /= 2;
+      }
+      return L.neq_tolerance(e, 1e-7) ? [new r2(r2.dNaN), 0] : [new r2(I + V), 1];
+    }
+    throw new Error("Unhandled behavior in excess_slog");
+  } }, { key: "increasingInverse", value: function(e) {
+    var t = arguments.length > 1 && arguments[1] !== void 0 ? arguments[1] : false, i = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : 120, a = arguments.length > 3 && arguments[3] !== void 0 ? arguments[3] : r2.dLayerMax.neg(), l = arguments.length > 4 && arguments[4] !== void 0 ? arguments[4] : r2.dLayerMax, f = arguments.length > 5 && arguments[5] !== void 0 ? arguments[5] : r2.dLayerMax.neg(), g = arguments.length > 6 && arguments[6] !== void 0 ? arguments[6] : r2.dLayerMax;
+    return function(h) {
+      if (h = new r2(h), a = new r2(a), l = new r2(l), f = new r2(f), g = new r2(g), h.isNan() || l.lt(a) || h.lt(f) || h.gt(g)) return new r2(r2.dNaN);
+      var v = function(b) {
+        return new r2(b);
+      }, u = true;
+      if (l.lt(0)) u = false;
+      else if (a.gt(0)) u = true;
+      else {
+        var M = e(r2.dZero);
+        if (M.eq(h)) return c(0, 0, 0);
+        u = h.gt(M), t && (u = !u);
+      }
+      var x = u, w;
+      if (u) {
+        if (l.lt($)) u = true;
+        else if (a.gt($)) u = false;
+        else {
+          var o = e(new r2($));
+          u = h.lt(o), t && (u = !u);
+        }
+        if (u) {
+          w = true;
+          var F = r2.pow(10, T).recip();
+          if (l.lt(F)) u = false;
+          else if (a.gt(F)) u = true;
+          else {
+            var A = e(new r2(F));
+            u = h.gt(A), t && (u = !u);
+          }
+          if (u) v = function(b) {
+            return r2.pow(10, b).recip();
+          };
+          else {
+            var d = r2.tetrate(10, T);
+            if (l.lt(d)) u = false;
+            else if (a.gt(d)) u = true;
+            else {
+              var S = e(new r2(d));
+              u = h.gt(S), t && (u = !u);
+            }
+            u ? v = function(b) {
+              return r2.tetrate(10, new r2(b).toNumber()).recip();
+            } : v = function(b) {
+              return new r2(b).gt(Math.log10(Number.MAX_VALUE)) ? r2.dZero : r2.tetrate(10, r2.pow(10, b).toNumber()).recip();
+            };
+          }
+        } else {
+          if (w = false, l.lt(T)) u = true;
+          else if (a.gt(T)) u = false;
+          else {
+            var p = e(new r2(T));
+            u = h.lt(p), t && (u = !u);
+          }
+          if (u) v = function(b) {
+            return new r2(b);
+          };
+          else {
+            var q = r2.pow(10, T);
+            if (l.lt(q)) u = true;
+            else if (a.gt(q)) u = false;
+            else {
+              var I = e(new r2(q));
+              u = h.lt(I), t && (u = !u);
+            }
+            if (u) v = function(b) {
+              return r2.pow(10, b);
+            };
+            else {
+              var N = r2.tetrate(10, T);
+              if (l.lt(N)) u = true;
+              else if (a.gt(N)) u = false;
+              else {
+                var y = e(new r2(N));
+                u = h.lt(y), t && (u = !u);
+              }
+              u ? v = function(b) {
+                return r2.tetrate(10, new r2(b).toNumber());
+              } : v = function(b) {
+                return new r2(b).gt(Math.log10(Number.MAX_VALUE)) ? r2.dInf : r2.tetrate(10, r2.pow(10, b).toNumber());
+              };
+            }
+          }
+        }
+      } else {
+        if (w = true, l.lt(-$)) u = false;
+        else if (a.gt(-$)) u = true;
+        else {
+          var V = e(new r2(-$));
+          u = h.gt(V), t && (u = !u);
+        }
+        if (u) {
+          var C = r2.pow(10, T).recip().neg();
+          if (l.lt(C)) u = true;
+          else if (a.gt(C)) u = false;
+          else {
+            var D = e(new r2(C));
+            u = h.lt(D), t && (u = !u);
+          }
+          if (u) v = function(b) {
+            return r2.pow(10, b).recip().neg();
+          };
+          else {
+            var Y = r2.tetrate(10, T).neg();
+            if (l.lt(Y)) u = true;
+            else if (a.gt(Y)) u = false;
+            else {
+              var L = e(new r2(Y));
+              u = h.lt(L), t && (u = !u);
+            }
+            u ? v = function(b) {
+              return r2.tetrate(10, new r2(b).toNumber()).recip().neg();
+            } : v = function(b) {
+              return new r2(b).gt(Math.log10(Number.MAX_VALUE)) ? r2.dZero : r2.tetrate(10, r2.pow(10, b).toNumber()).recip().neg();
+            };
+          }
+        } else {
+          if (w = false, l.lt(-T)) u = false;
+          else if (a.gt(-T)) u = true;
+          else {
+            var G = e(new r2(-T));
+            u = h.gt(G), t && (u = !u);
+          }
+          if (u) v = function(b) {
+            return r2.neg(b);
+          };
+          else {
+            var E = r2.pow(10, T).neg();
+            if (l.lt(E)) u = false;
+            else if (a.gt(E)) u = true;
+            else {
+              var X = e(new r2(E));
+              u = h.gt(X), t && (u = !u);
+            }
+            if (u) v = function(b) {
+              return r2.pow(10, b).neg();
+            };
+            else {
+              var Q = r2.tetrate(10, T).neg();
+              if (l.lt(Q)) u = false;
+              else if (a.gt(Q)) u = true;
+              else {
+                var J = e(new r2(Q));
+                u = h.gt(J), t && (u = !u);
+              }
+              u ? v = function(b) {
+                return r2.tetrate(10, new r2(b).toNumber()).neg();
+              } : v = function(b) {
+                return new r2(b).gt(Math.log10(Number.MAX_VALUE)) ? r2.dNegInf : r2.tetrate(10, r2.pow(10, b).toNumber()).neg();
+              };
+            }
+          }
+        }
+      }
+      for (var Z = x != w != t, re = Z ? function(O, b) {
+        return r2.gt(O, b);
+      } : function(O, b) {
+        return r2.lt(O, b);
+      }, W = 1e-3, H = false, te = false, U = 1, P = r2.dOne, B = 0, z = false, R = 1; R < i; ++R) {
+        z = false, B = U, P = v(U), P.gt(l) && (P = l, z = true), P.lt(a) && (P = a, z = true);
+        var ee = e(P);
+        if (ee.eq(h) && !z) break;
+        var j = re(ee, h);
+        if (R > 1 && te != j && (H = true), te = j, H ? W /= 2 : W *= 2, j != Z && P.eq(l) || j == Z && P.eq(a)) return new r2(r2.dNaN);
+        if (W = Math.abs(W) * (j ? -1 : 1), U += W, W === 0 || B == U) break;
+      }
+      return v(U);
+    };
+  } }]), r2;
+})();
+k.dZero = c(0, 0, 0);
+k.dOne = c(1, 0, 1);
+k.dNegOne = c(-1, 0, 1);
+k.dTwo = c(1, 0, 2);
+k.dTen = c(1, 0, 10);
+k.dNaN = c(Number.NaN, Number.NaN, Number.NaN);
+k.dInf = c(1, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+k.dNegInf = c(-1, Number.POSITIVE_INFINITY, Number.POSITIVE_INFINITY);
+k.dNumberMax = m(1, 0, Number.MAX_VALUE);
+k.dNumberMin = m(1, 0, Number.MIN_VALUE);
+k.dLayerSafeMax = m(1, Number.MAX_SAFE_INTEGER, T - 1);
+k.dLayerSafeMin = m(1, Number.MAX_SAFE_INTEGER, -8999999999999999);
+k.dLayerMax = m(1, Number.MAX_VALUE, T - 1);
+k.dLayerMin = m(1, Number.MAX_VALUE, -8999999999999999);
+k.fromStringCache = new me(de);
+s = k.fromValue_noAlloc;
+m = k.fromComponents;
+c = k.fromComponents_noNormalize;
+k.fromMantissaExponent;
+k.fromMantissaExponent_noNormalize;
+
+// src/rundot-game-api/systems/numbers.js
+function createNumbersAPI() {
+  const numbersAPI = {
+    // Type detection helper
+    isBigNumber: (value) => {
+      if (typeof value === "string" && value.startsWith("BE:")) return true;
+      if (value instanceof k) return true;
+      if (typeof value === "number" && (value > Number.MAX_SAFE_INTEGER || value < Number.MIN_SAFE_INTEGER)) return true;
+      return false;
+    },
+    // Normalize any input to Decimal (for API responses)
+    normalize: (value) => {
+      if (value instanceof k) return value;
+      if (typeof value === "string" && value.startsWith("BE:")) {
+        return new k(value.slice(3));
+      }
+      return new k(value);
+    },
+    // Common game formatters
+    format: {
+      incremental: (value) => {
+        const decimal = value instanceof k ? value : new k(value);
+        const suffixes = ["", "K", "M", "B", "T", "Qa", "Qi", "Sx", "Sp", "Oc", "No", "Dc"];
+        if (decimal.lt(1e3)) return decimal.toFixed(0);
+        const log = decimal.log10();
+        const suffixIndex = Math.floor(log / 3);
+        if (suffixIndex < suffixes.length) {
+          const divisor = k.pow(1e3, suffixIndex);
+          const value2 = decimal.div(divisor);
+          return `${value2.toFixed(2)}${suffixes[suffixIndex]}`;
+        }
+        return decimal.toExponential(2);
+      }
+    },
+    // NEW: Calculate geometric series cost with full Decimal precision
+    calculateGeometricSeriesCost: (baseCost, multiplier, currentQuantity, purchaseAmount) => {
+      try {
+        const base = new k(baseCost);
+        const r2 = new k(multiplier);
+        const q = new k(currentQuantity);
+        const n = new k(purchaseAmount);
+        if (r2.eq(1)) {
+          return base.mul(n);
+        }
+        const a = base.mul(r2.pow(q));
+        const numerator = a.mul(r2.pow(n).sub(1));
+        const denominator = r2.sub(1);
+        return numerator.div(denominator);
+      } catch (error) {
+        console.error("[RUN.gameAPI] Decimal calculation failed, falling back to regular math:", error);
+        const base = Number(baseCost);
+        const r2 = Number(multiplier);
+        if (r2 === 1) return base * purchaseAmount;
+        const a = base * Math.pow(r2, currentQuantity);
+        return a * (Math.pow(r2, purchaseAmount) - 1) / (r2 - 1);
+      }
+    },
+    // NEW: Find maximum affordable amount using Decimal precision
+    calculateMaxAffordableDecimal: (availableCash, baseCost, multiplier, currentQuantity) => {
+      try {
+        const cash = new k(availableCash);
+        const costOne = numbersAPI.calculateGeometricSeriesCost(baseCost, multiplier, currentQuantity, 1);
+        if (cash.lt(costOne)) return 0;
+        let low = 1;
+        let high = 1;
+        while (high < 1e6) {
+          const cost = numbersAPI.calculateGeometricSeriesCost(baseCost, multiplier, currentQuantity, high);
+          if (cost.gt(cash)) break;
+          low = high;
+          high *= 2;
+        }
+        while (low < high) {
+          const mid = Math.floor((low + high + 1) / 2);
+          const cost = numbersAPI.calculateGeometricSeriesCost(baseCost, multiplier, currentQuantity, mid);
+          if (cost.lte(cash)) {
+            low = mid;
+          } else {
+            high = mid - 1;
+          }
+        }
+        return low;
+      } catch (error) {
+        console.error("[RUN.gameAPI] Decimal max affordable calculation failed:", error);
+        return Math.floor(Number(availableCash) / Number(baseCost));
+      }
+    },
+    // NEW: Format Decimal value for currency display
+    formatDecimalCurrency: (decimalValue) => {
+      try {
+        if (numbersAPI.isBigNumber(decimalValue)) {
+          return `$${numbersAPI.format.incremental(decimalValue)}`;
+        }
+        return `$${numbersAPI.format.incremental(decimalValue)}`;
+      } catch (error) {
+        console.error("[RUN.gameAPI] Decimal formatting failed:", error);
+        return `$${Number(decimalValue).toLocaleString()}`;
+      }
+    }
+  };
+  return numbersAPI;
+}
+async function initializeNumbers(rundotGameApiInstance) {
+  const { createProxiedObject: createProxiedObject2, createProxiedMethod: createProxiedMethod2 } = await import('../core-6DQFSOBL.js');
+  const numbersAPI = createNumbersAPI();
+  rundotGameApiInstance.numbers = createProxiedObject2.call(
+    rundotGameApiInstance,
+    "numbers",
+    {
+      isBigNumber: numbersAPI.isBigNumber,
+      normalize: numbersAPI.normalize,
+      format: {
+        incremental: numbersAPI.format.incremental
+      },
+      // NEW: Expose geometric series calculation methods
+      calculateGeometricSeriesCost: numbersAPI.calculateGeometricSeriesCost,
+      calculateMaxAffordableDecimal: numbersAPI.calculateMaxAffordableDecimal,
+      formatDecimalCurrency: numbersAPI.formatDecimalCurrency,
+      // Expose Decimal class for direct use
+      Decimal: k
+    }
+  );
+}
+
+// src/context/index.ts
+function initializeContext(rundotGameApi, host) {
+  rundotGameApi.context = host.context || {
+    initializeAsleep: false,
+    launchParams: {},
+    shareParams: {}
+  };
+}
+
+// src/rundot-game-api/index.js
+var HapticStyle = {
+  LIGHT: "light",
+  MEDIUM: "medium",
+  HEAVY: "heavy",
+  SUCCESS: "success",
+  WARNING: "warning",
+  ERROR: "error"
+};
+var RundotGameAPI2 = class {
+  constructor() {
+    console.log(`[Run.game SDK] SDK Version: ${SDK_VERSION}`);
+    this._shared = {
+      initialized: false,
+      initPromise: null
+    };
+    this._bootstrap = {
+      apiInjected: false,
+      apiInjectionTimeout: null,
+      rundotGame: null,
+      isInsideHostedEnvironment: false,
+      _localHandlers: {},
+      // Store local handlers here
+      _pendingMessages: []
+      // Buffer messages until handlers are registered
+    };
+    const deterministicInstanceId = this._generateDeterministicInstanceId();
+    this._mock = {
+      // Essential config (matching H5ConfigProperties)
+      appId: "mock-app",
+      mode: "preview",
+      instanceId: deterministicInstanceId,
+      // Use deterministic ID instead of random
+      appUrl: "mock-app/index.html",
+      safeAreaInsets: {
+        top: 10,
+        right: 0,
+        bottom: 10,
+        left: 0
+      },
+      // NOTE: locale and languageCode are NOT part of static config
+      // They are delivered via INIT_SDK handshake and accessed via getLocale()/getLanguageCode()
+      // Complete environment info (matching buildStaticConfig)
+      environment: {
+        isDevelopment: true,
+        platform: "web",
+        platformVersion: "mock-1.0",
+        browserInfo: {
+          browser: "MockBrowser",
+          userAgent: navigator.userAgent,
+          isMobile: /Mobi|Android/i.test(navigator.userAgent),
+          isTablet: /iPad|Tablet|Pad/i.test(navigator.userAgent),
+          language: navigator.language || "en-US"
+        }
+      },
+      // Complete device info (matching buildStaticConfig)
+      device: {
+        screenSize: { width: window.innerWidth, height: window.innerHeight },
+        viewportSize: {
+          width: window.innerWidth - 20,
+          // account for safe area
+          height: window.innerHeight - 20
+        },
+        orientation: window.innerWidth > window.innerHeight ? "landscape" : "portrait",
+        pixelRatio: window.devicePixelRatio || 1,
+        fontScale: 1,
+        deviceType: window.innerWidth > 768 ? "tablet" : "phone",
+        platform: "web",
+        isWeb: true,
+        isMobile: /Mobi|Android/i.test(navigator.userAgent),
+        hapticsEnabled: false,
+        // Mock environment doesn't support haptics
+        haptics: {
+          supported: false,
+          enabled: false
+        }
+      },
+      // Context structure (matching buildStaticConfig)
+      context: {
+        postData: void 0,
+        stack: {
+          isInStack: false,
+          stackPosition: 0,
+          parentInstanceId: void 0
+        }
+      },
+      // Internal state (existing handlers and interaction data)
+      handlers: {
+        onPlay: null,
+        onPause: null,
+        onResume: null,
+        onQuit: null,
+        onHide: null,
+        onShow: null
+      },
+      // Platform overrides for testing different environments
+      platformOverrides: {
+        isMobile: true,
+        isWeb: false
+      }
+    };
+    this._detectHostedEnvironment();
+    this.config = createProxiedObject.call(this, "config", {});
+    const originalConfig = this.config;
+    this.config = new Proxy(originalConfig, {
+      get(target, prop) {
+        if (prop === "locale") {
+          throw new Error("Use RundotGameAPI.getLocale() instead.");
+        }
+        if (prop === "languageCode") {
+          throw new Error("Use RundotGameAPI.getLanguageCode() instead.");
+        }
+        if (prop === "user") {
+          throw new Error("Use RundotGameAPI.getLocale() and RundotGameAPI.getLanguageCode() instead.");
+        }
+        if (prop === "device") {
+          throw new Error("Use RundotGameAPI.system.getDevice() instead.");
+        }
+        if (prop === "environment") {
+          throw new Error("Use RundotGameAPI.system.getEnvironment() instead.");
+        }
+        if (prop === "profile") {
+          throw new Error("Use RundotGameAPI.getProfile() instead.");
+        }
+        if (prop === "rooms") {
+          throw new Error("Rooms configuration is internal. Use RundotGameAPI.rooms methods instead.");
+        }
+        if (prop === "ui") {
+          return new Proxy({}, {
+            get(uiTarget, uiProp) {
+              if (uiProp === "safeArea") {
+                throw new Error("Use RundotGameAPI.system.getSafeArea() instead.");
+              }
+              if (uiProp === "hudInsets") {
+                throw new Error("Use RundotGameAPI.system.getSafeArea() instead.");
+              }
+              if (uiProp === "controls") {
+                throw new Error("UI controls are no longer supported.");
+              }
+              throw new Error(`RundotGameAPI.config.ui.${uiProp} is not supported.`);
+            }
+          });
+        }
+        return target[prop];
+      },
+      set(target, prop, value) {
+        if (prop === "locale" || prop === "languageCode" || prop === "user" || prop === "device" || prop === "environment" || prop === "profile") {
+          throw new Error(`RundotGameAPI.config.${prop} cannot be set. Configuration is read-only.`);
+        }
+        if (prop === "ui") {
+          console.warn("[RUN.game SDK] Cannot set config.ui");
+          return true;
+        }
+        target[prop] = value;
+        return true;
+      },
+      has(target, prop) {
+        if (prop === "ui") {
+          return false;
+        }
+        return prop in target;
+      },
+      ownKeys(target) {
+        return Reflect.ownKeys(target).filter((key) => key !== "ui");
+      },
+      getOwnPropertyDescriptor(target, prop) {
+        if (prop === "ui") {
+          return void 0;
+        }
+        return Reflect.getOwnPropertyDescriptor(target, prop);
+      }
+    });
+    this._hostPromise = this._createHostAsync();
+    initializeAssetLoader(this, createProxiedMethod);
+    this.getLocale = () => {
+      if (this._localeData) {
+        return this._localeData;
+      }
+      if (typeof navigator !== "undefined" && navigator.language) {
+        return navigator.language;
+      }
+      return "en-US";
+    };
+    this.getLanguageCode = () => {
+      if (this._languageCodeData) {
+        return this._languageCodeData;
+      }
+      const locale = this.getLocale();
+      return locale.split("-")[0];
+    };
+  }
+  // Generate deterministic instance ID based on current page URL
+  _generateDeterministicInstanceId() {
+    try {
+      let url = window.location.href || "";
+      let normalizedUrl = url.replace(/^https?:\/\/[^\/]+/, "");
+      normalizedUrl = normalizedUrl.split("?")[0].split("#")[0].trim();
+      if (!normalizedUrl.startsWith("/H5/") && !normalizedUrl.startsWith("H5/")) {
+        if (!normalizedUrl.includes("/")) {
+          normalizedUrl = `/H5/${normalizedUrl}/index.html`;
+        } else if (!normalizedUrl.startsWith("/")) {
+          normalizedUrl = `/${normalizedUrl}`;
+        }
+      }
+      let hash = 0;
+      for (let i = 0; i < normalizedUrl.length; i++) {
+        const char = normalizedUrl.charCodeAt(i);
+        hash = (hash << 5) - hash + char;
+        hash = hash & hash;
+      }
+      const hashB36 = Math.abs(hash).toString(36);
+      const paddedHash = hashB36.substring(0, 8).padEnd(8, "0");
+      const deterministicId = `app-${paddedHash}`;
+      return deterministicId;
+    } catch (error) {
+      console.error(
+        "[Run.game Bootstrap] Error generating deterministic ID, falling back to random:",
+        error
+      );
+      return "app-" + Math.random().toString(36).substr(2, 8);
+    }
+  }
+  //---------------------------------------
+  // BOOTSTRAP METHODS
+  //---------------------------------------
+  _detectHostedEnvironment() {
+    const isInIframe = window.self !== window.top;
+    const hasReactNativeWebView = typeof window.ReactNativeWebView !== "undefined";
+    this._bootstrap.isInsideHostedEnvironment = isInIframe || hasReactNativeWebView;
+  }
+  //---------------------------------------
+  // HOST CREATION (async for dynamic imports)
+  //---------------------------------------
+  /**
+   * Create and initialize the Host asynchronously.
+   *
+   * This is async because createHost uses dynamic import for SandboxHost,
+   * which prevents Firebase from being bundled in production builds.
+   */
+  async _createHostAsync() {
+    const isInsideHostedEnv = this._bootstrap.isInsideHostedEnvironment;
+    const host = await createHost(this, !isInsideHostedEnv);
+    this.host = host;
+    initializeStorage(this, host);
+    initializeRoomsApi(this, host);
+    initializeAds(this, host);
+    initializePopups(this, host);
+    initializeAnalytics(this, host);
+    initializeIap(this, host);
+    initializeLeaderboard(this, host);
+    initializeLocalNotifications(this, host);
+    initializePreloader(this, host);
+    initializeTime(this, host);
+    initializeLifecycleApi(this, host);
+    initializeHaptics(this, host);
+    initializeCdn(this, host);
+    initializeFeaturesApi(this, host);
+    initializeLoggingApi(this, host);
+    const isAvatar3dDisabled = typeof window !== "undefined" && window.location.search.includes("EXPO_PUBLIC_DISABLE_3D_AVATARS=true");
+    initializeProfile(this, host);
+    initializeSystem(this, host);
+    if (!isAvatar3dDisabled) {
+      initializeAvatar3d(this, host);
+    }
+    initializeStackNavigation(this, host);
+    initializeAi(this, host);
+    initializeSimulation(this, host);
+    initializeSocial(this, host);
+    return host;
+  }
+  //---------------------------------------
+  // PUBLIC API METHODS
+  //---------------------------------------
+  /**
+   * @deprecated No longer need to call this method. This will get called on import.
+   */
+  async initializeAsync() {
+    if (this._shared.initialized) {
+      return Promise.resolve(this.host.context);
+    }
+    if (this._shared.initPromise) {
+      return this._shared.initPromise;
+    }
+    this._shared.initPromise = new Promise(async (resolve, reject) => {
+      try {
+        await this._hostPromise;
+        const result = await this.host.initialize();
+        initializeContext(this, this.host);
+        this._shared.initialized = true;
+        resolve(result);
+      } catch (err) {
+        reject(err);
+      }
+    });
+    return this._shared.initPromise;
+  }
+};
+var instance = new RundotGameAPI2();
+var rundot_game_api_default = instance;
+window.RundotGameAPI = instance;
+instance.HapticStyle = HapticStyle;
+instance.isAvailable = function() {
+  try {
+    return !!(typeof window !== "undefined" && window.RundotGameAPI) || !!this;
+  } catch {
+    return false;
+  }
+};
+try {
+  await initializeNumbers(instance);
+} catch (error) {
+  console.error("[RUN.game SDK] Failed to initialize numbers system:", error);
+}
+try {
+  console.log(`[Run.game SDK] Initializing...`);
+  await instance.initializeAsync();
+  instance.log(`Initialized RUN.game SDK version ${SDK_VERSION} successfully.`);
+  console.log(`[Run.game SDK] Initialized RUN.game SDK version ${SDK_VERSION} successfully.`);
+} catch (error) {
+  console.error("[RUN.game SDK] Failed to initialize RUN.game SDK:", error);
+}
+
+export { rundot_game_api_default as default };
+//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map