npm - @jiangzhx/adcli - Versions diffs - 0.1.2 → 0.1.3 - Mend

@jiangzhx/adcli 0.1.2 → 0.1.3

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (4) hide show

package/dist/cli.js CHANGED Viewed

@@ -1,16 +1,1901 @@
 #!/usr/bin/env node
 // @bun
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+function __accessProp(key) {
+  return this[key];
+}
+var __toESMCache_node;
+var __toESMCache_esm;
+var __toESM = (mod, isNodeMode, target) => {
+  var canCache = mod != null && typeof mod === "object";
+  if (canCache) {
+    var cache = isNodeMode ? __toESMCache_node ??= new WeakMap : __toESMCache_esm ??= new WeakMap;
+    var cached = cache.get(mod);
+    if (cached)
+      return cached;
+  }
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: __accessProp.bind(mod, key),
+        enumerable: true
+      });
+  if (canCache)
+    cache.set(mod, to);
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+// node_modules/.bun/bignumber.js@9.3.1/node_modules/bignumber.js/bignumber.js
+var require_bignumber = __commonJS((exports, module) => {
+  (function(globalObject) {
+    var BigNumber, isNumeric = /^-?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i, mathceil = Math.ceil, mathfloor = Math.floor, bignumberError = "[BigNumber Error] ", tooManyDigits = bignumberError + "Number primitive has more than 15 significant digits: ", BASE = 100000000000000, LOG_BASE = 14, MAX_SAFE_INTEGER = 9007199254740991, POWS_TEN = [1, 10, 100, 1000, 1e4, 1e5, 1e6, 1e7, 1e8, 1e9, 10000000000, 100000000000, 1000000000000, 10000000000000], SQRT_BASE = 1e7, MAX = 1e9;
+    function clone(configObject) {
+      var div, convertBase, parseNumeric, P = BigNumber2.prototype = { constructor: BigNumber2, toString: null, valueOf: null }, ONE = new BigNumber2(1), DECIMAL_PLACES = 20, ROUNDING_MODE = 4, TO_EXP_NEG = -7, TO_EXP_POS = 21, MIN_EXP = -1e7, MAX_EXP = 1e7, CRYPTO = false, MODULO_MODE = 1, POW_PRECISION = 0, FORMAT = {
+        prefix: "",
+        groupSize: 3,
+        secondaryGroupSize: 0,
+        groupSeparator: ",",
+        decimalSeparator: ".",
+        fractionGroupSize: 0,
+        fractionGroupSeparator: " ",
+        suffix: ""
+      }, ALPHABET = "0123456789abcdefghijklmnopqrstuvwxyz", alphabetHasNormalDecimalDigits = true;
+      function BigNumber2(v, b) {
+        var alphabet, c, caseChanged, e, i, isNum, len, str, x = this;
+        if (!(x instanceof BigNumber2))
+          return new BigNumber2(v, b);
+        if (b == null) {
+          if (v && v._isBigNumber === true) {
+            x.s = v.s;
+            if (!v.c || v.e > MAX_EXP) {
+              x.c = x.e = null;
+            } else if (v.e < MIN_EXP) {
+              x.c = [x.e = 0];
+            } else {
+              x.e = v.e;
+              x.c = v.c.slice();
+            }
+            return;
+          }
+          if ((isNum = typeof v == "number") && v * 0 == 0) {
+            x.s = 1 / v < 0 ? (v = -v, -1) : 1;
+            if (v === ~~v) {
+              for (e = 0, i = v;i >= 10; i /= 10, e++)
+                ;
+              if (e > MAX_EXP) {
+                x.c = x.e = null;
+              } else {
+                x.e = e;
+                x.c = [v];
+              }
+              return;
+            }
+            str = String(v);
+          } else {
+            if (!isNumeric.test(str = String(v)))
+              return parseNumeric(x, str, isNum);
+            x.s = str.charCodeAt(0) == 45 ? (str = str.slice(1), -1) : 1;
+          }
+          if ((e = str.indexOf(".")) > -1)
+            str = str.replace(".", "");
+          if ((i = str.search(/e/i)) > 0) {
+            if (e < 0)
+              e = i;
+            e += +str.slice(i + 1);
+            str = str.substring(0, i);
+          } else if (e < 0) {
+            e = str.length;
+          }
+        } else {
+          intCheck(b, 2, ALPHABET.length, "Base");
+          if (b == 10 && alphabetHasNormalDecimalDigits) {
+            x = new BigNumber2(v);
+            return round(x, DECIMAL_PLACES + x.e + 1, ROUNDING_MODE);
+          }
+          str = String(v);
+          if (isNum = typeof v == "number") {
+            if (v * 0 != 0)
+              return parseNumeric(x, str, isNum, b);
+            x.s = 1 / v < 0 ? (str = str.slice(1), -1) : 1;
+            if (BigNumber2.DEBUG && str.replace(/^0\.0*|\./, "").length > 15) {
+              throw Error(tooManyDigits + v);
+            }
+          } else {
+            x.s = str.charCodeAt(0) === 45 ? (str = str.slice(1), -1) : 1;
+          }
+          alphabet = ALPHABET.slice(0, b);
+          e = i = 0;
+          for (len = str.length;i < len; i++) {
+            if (alphabet.indexOf(c = str.charAt(i)) < 0) {
+              if (c == ".") {
+                if (i > e) {
+                  e = len;
+                  continue;
+                }
+              } else if (!caseChanged) {
+                if (str == str.toUpperCase() && (str = str.toLowerCase()) || str == str.toLowerCase() && (str = str.toUpperCase())) {
+                  caseChanged = true;
+                  i = -1;
+                  e = 0;
+                  continue;
+                }
+              }
+              return parseNumeric(x, String(v), isNum, b);
+            }
+          }
+          isNum = false;
+          str = convertBase(str, b, 10, x.s);
+          if ((e = str.indexOf(".")) > -1)
+            str = str.replace(".", "");
+          else
+            e = str.length;
+        }
+        for (i = 0;str.charCodeAt(i) === 48; i++)
+          ;
+        for (len = str.length;str.charCodeAt(--len) === 48; )
+          ;
+        if (str = str.slice(i, ++len)) {
+          len -= i;
+          if (isNum && BigNumber2.DEBUG && len > 15 && (v > MAX_SAFE_INTEGER || v !== mathfloor(v))) {
+            throw Error(tooManyDigits + x.s * v);
+          }
+          if ((e = e - i - 1) > MAX_EXP) {
+            x.c = x.e = null;
+          } else if (e < MIN_EXP) {
+            x.c = [x.e = 0];
+          } else {
+            x.e = e;
+            x.c = [];
+            i = (e + 1) % LOG_BASE;
+            if (e < 0)
+              i += LOG_BASE;
+            if (i < len) {
+              if (i)
+                x.c.push(+str.slice(0, i));
+              for (len -= LOG_BASE;i < len; ) {
+                x.c.push(+str.slice(i, i += LOG_BASE));
+              }
+              i = LOG_BASE - (str = str.slice(i)).length;
+            } else {
+              i -= len;
+            }
+            for (;i--; str += "0")
+              ;
+            x.c.push(+str);
+          }
+        } else {
+          x.c = [x.e = 0];
+        }
+      }
+      BigNumber2.clone = clone;
+      BigNumber2.ROUND_UP = 0;
+      BigNumber2.ROUND_DOWN = 1;
+      BigNumber2.ROUND_CEIL = 2;
+      BigNumber2.ROUND_FLOOR = 3;
+      BigNumber2.ROUND_HALF_UP = 4;
+      BigNumber2.ROUND_HALF_DOWN = 5;
+      BigNumber2.ROUND_HALF_EVEN = 6;
+      BigNumber2.ROUND_HALF_CEIL = 7;
+      BigNumber2.ROUND_HALF_FLOOR = 8;
+      BigNumber2.EUCLID = 9;
+      BigNumber2.config = BigNumber2.set = function(obj) {
+        var p, v;
+        if (obj != null) {
+          if (typeof obj == "object") {
+            if (obj.hasOwnProperty(p = "DECIMAL_PLACES")) {
+              v = obj[p];
+              intCheck(v, 0, MAX, p);
+              DECIMAL_PLACES = v;
+            }
+            if (obj.hasOwnProperty(p = "ROUNDING_MODE")) {
+              v = obj[p];
+              intCheck(v, 0, 8, p);
+              ROUNDING_MODE = v;
+            }
+            if (obj.hasOwnProperty(p = "EXPONENTIAL_AT")) {
+              v = obj[p];
+              if (v && v.pop) {
+                intCheck(v[0], -MAX, 0, p);
+                intCheck(v[1], 0, MAX, p);
+                TO_EXP_NEG = v[0];
+                TO_EXP_POS = v[1];
+              } else {
+                intCheck(v, -MAX, MAX, p);
+                TO_EXP_NEG = -(TO_EXP_POS = v < 0 ? -v : v);
+              }
+            }
+            if (obj.hasOwnProperty(p = "RANGE")) {
+              v = obj[p];
+              if (v && v.pop) {
+                intCheck(v[0], -MAX, -1, p);
+                intCheck(v[1], 1, MAX, p);
+                MIN_EXP = v[0];
+                MAX_EXP = v[1];
+              } else {
+                intCheck(v, -MAX, MAX, p);
+                if (v) {
+                  MIN_EXP = -(MAX_EXP = v < 0 ? -v : v);
+                } else {
+                  throw Error(bignumberError + p + " cannot be zero: " + v);
+                }
+              }
+            }
+            if (obj.hasOwnProperty(p = "CRYPTO")) {
+              v = obj[p];
+              if (v === !!v) {
+                if (v) {
+                  if (typeof crypto != "undefined" && crypto && (crypto.getRandomValues || crypto.randomBytes)) {
+                    CRYPTO = v;
+                  } else {
+                    CRYPTO = !v;
+                    throw Error(bignumberError + "crypto unavailable");
+                  }
+                } else {
+                  CRYPTO = v;
+                }
+              } else {
+                throw Error(bignumberError + p + " not true or false: " + v);
+              }
+            }
+            if (obj.hasOwnProperty(p = "MODULO_MODE")) {
+              v = obj[p];
+              intCheck(v, 0, 9, p);
+              MODULO_MODE = v;
+            }
+            if (obj.hasOwnProperty(p = "POW_PRECISION")) {
+              v = obj[p];
+              intCheck(v, 0, MAX, p);
+              POW_PRECISION = v;
+            }
+            if (obj.hasOwnProperty(p = "FORMAT")) {
+              v = obj[p];
+              if (typeof v == "object")
+                FORMAT = v;
+              else
+                throw Error(bignumberError + p + " not an object: " + v);
+            }
+            if (obj.hasOwnProperty(p = "ALPHABET")) {
+              v = obj[p];
+              if (typeof v == "string" && !/^.?$|[+\-.\s]|(.).*\1/.test(v)) {
+                alphabetHasNormalDecimalDigits = v.slice(0, 10) == "0123456789";
+                ALPHABET = v;
+              } else {
+                throw Error(bignumberError + p + " invalid: " + v);
+              }
+            }
+          } else {
+            throw Error(bignumberError + "Object expected: " + obj);
+          }
+        }
+        return {
+          DECIMAL_PLACES,
+          ROUNDING_MODE,
+          EXPONENTIAL_AT: [TO_EXP_NEG, TO_EXP_POS],
+          RANGE: [MIN_EXP, MAX_EXP],
+          CRYPTO,
+          MODULO_MODE,
+          POW_PRECISION,
+          FORMAT,
+          ALPHABET
+        };
+      };
+      BigNumber2.isBigNumber = function(v) {
+        if (!v || v._isBigNumber !== true)
+          return false;
+        if (!BigNumber2.DEBUG)
+          return true;
+        var i, n, c = v.c, e = v.e, s = v.s;
+        out:
+          if ({}.toString.call(c) == "[object Array]") {
+            if ((s === 1 || s === -1) && e >= -MAX && e <= MAX && e === mathfloor(e)) {
+              if (c[0] === 0) {
+                if (e === 0 && c.length === 1)
+                  return true;
+                break out;
+              }
+              i = (e + 1) % LOG_BASE;
+              if (i < 1)
+                i += LOG_BASE;
+              if (String(c[0]).length == i) {
+                for (i = 0;i < c.length; i++) {
+                  n = c[i];
+                  if (n < 0 || n >= BASE || n !== mathfloor(n))
+                    break out;
+                }
+                if (n !== 0)
+                  return true;
+              }
+            }
+          } else if (c === null && e === null && (s === null || s === 1 || s === -1)) {
+            return true;
+          }
+        throw Error(bignumberError + "Invalid BigNumber: " + v);
+      };
+      BigNumber2.maximum = BigNumber2.max = function() {
+        return maxOrMin(arguments, -1);
+      };
+      BigNumber2.minimum = BigNumber2.min = function() {
+        return maxOrMin(arguments, 1);
+      };
+      BigNumber2.random = function() {
+        var pow2_53 = 9007199254740992;
+        var random53bitInt = Math.random() * pow2_53 & 2097151 ? function() {
+          return mathfloor(Math.random() * pow2_53);
+        } : function() {
+          return (Math.random() * 1073741824 | 0) * 8388608 + (Math.random() * 8388608 | 0);
+        };
+        return function(dp) {
+          var a, b, e, k, v, i = 0, c = [], rand = new BigNumber2(ONE);
+          if (dp == null)
+            dp = DECIMAL_PLACES;
+          else
+            intCheck(dp, 0, MAX);
+          k = mathceil(dp / LOG_BASE);
+          if (CRYPTO) {
+            if (crypto.getRandomValues) {
+              a = crypto.getRandomValues(new Uint32Array(k *= 2));
+              for (;i < k; ) {
+                v = a[i] * 131072 + (a[i + 1] >>> 11);
+                if (v >= 9000000000000000) {
+                  b = crypto.getRandomValues(new Uint32Array(2));
+                  a[i] = b[0];
+                  a[i + 1] = b[1];
+                } else {
+                  c.push(v % 100000000000000);
+                  i += 2;
+                }
+              }
+              i = k / 2;
+            } else if (crypto.randomBytes) {
+              a = crypto.randomBytes(k *= 7);
+              for (;i < k; ) {
+                v = (a[i] & 31) * 281474976710656 + a[i + 1] * 1099511627776 + a[i + 2] * 4294967296 + a[i + 3] * 16777216 + (a[i + 4] << 16) + (a[i + 5] << 8) + a[i + 6];
+                if (v >= 9000000000000000) {
+                  crypto.randomBytes(7).copy(a, i);
+                } else {
+                  c.push(v % 100000000000000);
+                  i += 7;
+                }
+              }
+              i = k / 7;
+            } else {
+              CRYPTO = false;
+              throw Error(bignumberError + "crypto unavailable");
+            }
+          }
+          if (!CRYPTO) {
+            for (;i < k; ) {
+              v = random53bitInt();
+              if (v < 9000000000000000)
+                c[i++] = v % 100000000000000;
+            }
+          }
+          k = c[--i];
+          dp %= LOG_BASE;
+          if (k && dp) {
+            v = POWS_TEN[LOG_BASE - dp];
+            c[i] = mathfloor(k / v) * v;
+          }
+          for (;c[i] === 0; c.pop(), i--)
+            ;
+          if (i < 0) {
+            c = [e = 0];
+          } else {
+            for (e = -1;c[0] === 0; c.splice(0, 1), e -= LOG_BASE)
+              ;
+            for (i = 1, v = c[0];v >= 10; v /= 10, i++)
+              ;
+            if (i < LOG_BASE)
+              e -= LOG_BASE - i;
+          }
+          rand.e = e;
+          rand.c = c;
+          return rand;
+        };
+      }();
+      BigNumber2.sum = function() {
+        var i = 1, args = arguments, sum = new BigNumber2(args[0]);
+        for (;i < args.length; )
+          sum = sum.plus(args[i++]);
+        return sum;
+      };
+      convertBase = function() {
+        var decimal = "0123456789";
+        function toBaseOut(str, baseIn, baseOut, alphabet) {
+          var j, arr = [0], arrL, i = 0, len = str.length;
+          for (;i < len; ) {
+            for (arrL = arr.length;arrL--; arr[arrL] *= baseIn)
+              ;
+            arr[0] += alphabet.indexOf(str.charAt(i++));
+            for (j = 0;j < arr.length; j++) {
+              if (arr[j] > baseOut - 1) {
+                if (arr[j + 1] == null)
+                  arr[j + 1] = 0;
+                arr[j + 1] += arr[j] / baseOut | 0;
+                arr[j] %= baseOut;
+              }
+            }
+          }
+          return arr.reverse();
+        }
+        return function(str, baseIn, baseOut, sign, callerIsToString) {
+          var alphabet, d, e, k, r, x, xc, y, i = str.indexOf("."), dp = DECIMAL_PLACES, rm = ROUNDING_MODE;
+          if (i >= 0) {
+            k = POW_PRECISION;
+            POW_PRECISION = 0;
+            str = str.replace(".", "");
+            y = new BigNumber2(baseIn);
+            x = y.pow(str.length - i);
+            POW_PRECISION = k;
+            y.c = toBaseOut(toFixedPoint(coeffToString(x.c), x.e, "0"), 10, baseOut, decimal);
+            y.e = y.c.length;
+          }
+          xc = toBaseOut(str, baseIn, baseOut, callerIsToString ? (alphabet = ALPHABET, decimal) : (alphabet = decimal, ALPHABET));
+          e = k = xc.length;
+          for (;xc[--k] == 0; xc.pop())
+            ;
+          if (!xc[0])
+            return alphabet.charAt(0);
+          if (i < 0) {
+            --e;
+          } else {
+            x.c = xc;
+            x.e = e;
+            x.s = sign;
+            x = div(x, y, dp, rm, baseOut);
+            xc = x.c;
+            r = x.r;
+            e = x.e;
+          }
+          d = e + dp + 1;
+          i = xc[d];
+          k = baseOut / 2;
+          r = r || d < 0 || xc[d + 1] != null;
+          r = rm < 4 ? (i != null || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : i > k || i == k && (rm == 4 || r || rm == 6 && xc[d - 1] & 1 || rm == (x.s < 0 ? 8 : 7));
+          if (d < 1 || !xc[0]) {
+            str = r ? toFixedPoint(alphabet.charAt(1), -dp, alphabet.charAt(0)) : alphabet.charAt(0);
+          } else {
+            xc.length = d;
+            if (r) {
+              for (--baseOut;++xc[--d] > baseOut; ) {
+                xc[d] = 0;
+                if (!d) {
+                  ++e;
+                  xc = [1].concat(xc);
+                }
+              }
+            }
+            for (k = xc.length;!xc[--k]; )
+              ;
+            for (i = 0, str = "";i <= k; str += alphabet.charAt(xc[i++]))
+              ;
+            str = toFixedPoint(str, e, alphabet.charAt(0));
+          }
+          return str;
+        };
+      }();
+      div = function() {
+        function multiply(x, k, base) {
+          var m, temp, xlo, xhi, carry = 0, i = x.length, klo = k % SQRT_BASE, khi = k / SQRT_BASE | 0;
+          for (x = x.slice();i--; ) {
+            xlo = x[i] % SQRT_BASE;
+            xhi = x[i] / SQRT_BASE | 0;
+            m = khi * xlo + xhi * klo;
+            temp = klo * xlo + m % SQRT_BASE * SQRT_BASE + carry;
+            carry = (temp / base | 0) + (m / SQRT_BASE | 0) + khi * xhi;
+            x[i] = temp % base;
+          }
+          if (carry)
+            x = [carry].concat(x);
+          return x;
+        }
+        function compare2(a, b, aL, bL) {
+          var i, cmp;
+          if (aL != bL) {
+            cmp = aL > bL ? 1 : -1;
+          } else {
+            for (i = cmp = 0;i < aL; i++) {
+              if (a[i] != b[i]) {
+                cmp = a[i] > b[i] ? 1 : -1;
+                break;
+              }
+            }
+          }
+          return cmp;
+        }
+        function subtract(a, b, aL, base) {
+          var i = 0;
+          for (;aL--; ) {
+            a[aL] -= i;
+            i = a[aL] < b[aL] ? 1 : 0;
+            a[aL] = i * base + a[aL] - b[aL];
+          }
+          for (;!a[0] && a.length > 1; a.splice(0, 1))
+            ;
+        }
+        return function(x, y, dp, rm, base) {
+          var cmp, e, i, more, n, prod, prodL, q, qc, rem, remL, rem0, xi, xL, yc0, yL, yz, s = x.s == y.s ? 1 : -1, xc = x.c, yc = y.c;
+          if (!xc || !xc[0] || !yc || !yc[0]) {
+            return new BigNumber2(!x.s || !y.s || (xc ? yc && xc[0] == yc[0] : !yc) ? NaN : xc && xc[0] == 0 || !yc ? s * 0 : s / 0);
+          }
+          q = new BigNumber2(s);
+          qc = q.c = [];
+          e = x.e - y.e;
+          s = dp + e + 1;
+          if (!base) {
+            base = BASE;
+            e = bitFloor(x.e / LOG_BASE) - bitFloor(y.e / LOG_BASE);
+            s = s / LOG_BASE | 0;
+          }
+          for (i = 0;yc[i] == (xc[i] || 0); i++)
+            ;
+          if (yc[i] > (xc[i] || 0))
+            e--;
+          if (s < 0) {
+            qc.push(1);
+            more = true;
+          } else {
+            xL = xc.length;
+            yL = yc.length;
+            i = 0;
+            s += 2;
+            n = mathfloor(base / (yc[0] + 1));
+            if (n > 1) {
+              yc = multiply(yc, n, base);
+              xc = multiply(xc, n, base);
+              yL = yc.length;
+              xL = xc.length;
+            }
+            xi = yL;
+            rem = xc.slice(0, yL);
+            remL = rem.length;
+            for (;remL < yL; rem[remL++] = 0)
+              ;
+            yz = yc.slice();
+            yz = [0].concat(yz);
+            yc0 = yc[0];
+            if (yc[1] >= base / 2)
+              yc0++;
+            do {
+              n = 0;
+              cmp = compare2(yc, rem, yL, remL);
+              if (cmp < 0) {
+                rem0 = rem[0];
+                if (yL != remL)
+                  rem0 = rem0 * base + (rem[1] || 0);
+                n = mathfloor(rem0 / yc0);
+                if (n > 1) {
+                  if (n >= base)
+                    n = base - 1;
+                  prod = multiply(yc, n, base);
+                  prodL = prod.length;
+                  remL = rem.length;
+                  while (compare2(prod, rem, prodL, remL) == 1) {
+                    n--;
+                    subtract(prod, yL < prodL ? yz : yc, prodL, base);
+                    prodL = prod.length;
+                    cmp = 1;
+                  }
+                } else {
+                  if (n == 0) {
+                    cmp = n = 1;
+                  }
+                  prod = yc.slice();
+                  prodL = prod.length;
+                }
+                if (prodL < remL)
+                  prod = [0].concat(prod);
+                subtract(rem, prod, remL, base);
+                remL = rem.length;
+                if (cmp == -1) {
+                  while (compare2(yc, rem, yL, remL) < 1) {
+                    n++;
+                    subtract(rem, yL < remL ? yz : yc, remL, base);
+                    remL = rem.length;
+                  }
+                }
+              } else if (cmp === 0) {
+                n++;
+                rem = [0];
+              }
+              qc[i++] = n;
+              if (rem[0]) {
+                rem[remL++] = xc[xi] || 0;
+              } else {
+                rem = [xc[xi]];
+                remL = 1;
+              }
+            } while ((xi++ < xL || rem[0] != null) && s--);
+            more = rem[0] != null;
+            if (!qc[0])
+              qc.splice(0, 1);
+          }
+          if (base == BASE) {
+            for (i = 1, s = qc[0];s >= 10; s /= 10, i++)
+              ;
+            round(q, dp + (q.e = i + e * LOG_BASE - 1) + 1, rm, more);
+          } else {
+            q.e = e;
+            q.r = +more;
+          }
+          return q;
+        };
+      }();
+      function format(n, i, rm, id) {
+        var c0, e, ne, len, str;
+        if (rm == null)
+          rm = ROUNDING_MODE;
+        else
+          intCheck(rm, 0, 8);
+        if (!n.c)
+          return n.toString();
+        c0 = n.c[0];
+        ne = n.e;
+        if (i == null) {
+          str = coeffToString(n.c);
+          str = id == 1 || id == 2 && (ne <= TO_EXP_NEG || ne >= TO_EXP_POS) ? toExponential(str, ne) : toFixedPoint(str, ne, "0");
+        } else {
+          n = round(new BigNumber2(n), i, rm);
+          e = n.e;
+          str = coeffToString(n.c);
+          len = str.length;
+          if (id == 1 || id == 2 && (i <= e || e <= TO_EXP_NEG)) {
+            for (;len < i; str += "0", len++)
+              ;
+            str = toExponential(str, e);
+          } else {
+            i -= ne + (id === 2 && e > ne);
+            str = toFixedPoint(str, e, "0");
+            if (e + 1 > len) {
+              if (--i > 0)
+                for (str += ".";i--; str += "0")
+                  ;
+            } else {
+              i += e - len;
+              if (i > 0) {
+                if (e + 1 == len)
+                  str += ".";
+                for (;i--; str += "0")
+                  ;
+              }
+            }
+          }
+        }
+        return n.s < 0 && c0 ? "-" + str : str;
+      }
+      function maxOrMin(args, n) {
+        var k, y, i = 1, x = new BigNumber2(args[0]);
+        for (;i < args.length; i++) {
+          y = new BigNumber2(args[i]);
+          if (!y.s || (k = compare(x, y)) === n || k === 0 && x.s === n) {
+            x = y;
+          }
+        }
+        return x;
+      }
+      function normalise(n, c, e) {
+        var i = 1, j = c.length;
+        for (;!c[--j]; c.pop())
+          ;
+        for (j = c[0];j >= 10; j /= 10, i++)
+          ;
+        if ((e = i + e * LOG_BASE - 1) > MAX_EXP) {
+          n.c = n.e = null;
+        } else if (e < MIN_EXP) {
+          n.c = [n.e = 0];
+        } else {
+          n.e = e;
+          n.c = c;
+        }
+        return n;
+      }
+      parseNumeric = function() {
+        var basePrefix = /^(-?)0([xbo])(?=\w[\w.]*$)/i, dotAfter = /^([^.]+)\.$/, dotBefore = /^\.([^.]+)$/, isInfinityOrNaN = /^-?(Infinity|NaN)$/, whitespaceOrPlus = /^\s*\+(?=[\w.])|^\s+|\s+$/g;
+        return function(x, str, isNum, b) {
+          var base, s = isNum ? str : str.replace(whitespaceOrPlus, "");
+          if (isInfinityOrNaN.test(s)) {
+            x.s = isNaN(s) ? null : s < 0 ? -1 : 1;
+          } else {
+            if (!isNum) {
+              s = s.replace(basePrefix, function(m, p1, p2) {
+                base = (p2 = p2.toLowerCase()) == "x" ? 16 : p2 == "b" ? 2 : 8;
+                return !b || b == base ? p1 : m;
+              });
+              if (b) {
+                base = b;
+                s = s.replace(dotAfter, "$1").replace(dotBefore, "0.$1");
+              }
+              if (str != s)
+                return new BigNumber2(s, base);
+            }
+            if (BigNumber2.DEBUG) {
+              throw Error(bignumberError + "Not a" + (b ? " base " + b : "") + " number: " + str);
+            }
+            x.s = null;
+          }
+          x.c = x.e = null;
+        };
+      }();
+      function round(x, sd, rm, r) {
+        var d, i, j, k, n, ni, rd, xc = x.c, pows10 = POWS_TEN;
+        if (xc) {
+          out: {
+            for (d = 1, k = xc[0];k >= 10; k /= 10, d++)
+              ;
+            i = sd - d;
+            if (i < 0) {
+              i += LOG_BASE;
+              j = sd;
+              n = xc[ni = 0];
+              rd = mathfloor(n / pows10[d - j - 1] % 10);
+            } else {
+              ni = mathceil((i + 1) / LOG_BASE);
+              if (ni >= xc.length) {
+                if (r) {
+                  for (;xc.length <= ni; xc.push(0))
+                    ;
+                  n = rd = 0;
+                  d = 1;
+                  i %= LOG_BASE;
+                  j = i - LOG_BASE + 1;
+                } else {
+                  break out;
+                }
+              } else {
+                n = k = xc[ni];
+                for (d = 1;k >= 10; k /= 10, d++)
+                  ;
+                i %= LOG_BASE;
+                j = i - LOG_BASE + d;
+                rd = j < 0 ? 0 : mathfloor(n / pows10[d - j - 1] % 10);
+              }
+            }
+            r = r || sd < 0 || xc[ni + 1] != null || (j < 0 ? n : n % pows10[d - j - 1]);
+            r = rm < 4 ? (rd || r) && (rm == 0 || rm == (x.s < 0 ? 3 : 2)) : rd > 5 || rd == 5 && (rm == 4 || r || rm == 6 && (i > 0 ? j > 0 ? n / pows10[d - j] : 0 : xc[ni - 1]) % 10 & 1 || rm == (x.s < 0 ? 8 : 7));
+            if (sd < 1 || !xc[0]) {
+              xc.length = 0;
+              if (r) {
+                sd -= x.e + 1;
+                xc[0] = pows10[(LOG_BASE - sd % LOG_BASE) % LOG_BASE];
+                x.e = -sd || 0;
+              } else {
+                xc[0] = x.e = 0;
+              }
+              return x;
+            }
+            if (i == 0) {
+              xc.length = ni;
+              k = 1;
+              ni--;
+            } else {
+              xc.length = ni + 1;
+              k = pows10[LOG_BASE - i];
+              xc[ni] = j > 0 ? mathfloor(n / pows10[d - j] % pows10[j]) * k : 0;
+            }
+            if (r) {
+              for (;; ) {
+                if (ni == 0) {
+                  for (i = 1, j = xc[0];j >= 10; j /= 10, i++)
+                    ;
+                  j = xc[0] += k;
+                  for (k = 1;j >= 10; j /= 10, k++)
+                    ;
+                  if (i != k) {
+                    x.e++;
+                    if (xc[0] == BASE)
+                      xc[0] = 1;
+                  }
+                  break;
+                } else {
+                  xc[ni] += k;
+                  if (xc[ni] != BASE)
+                    break;
+                  xc[ni--] = 0;
+                  k = 1;
+                }
+              }
+            }
+            for (i = xc.length;xc[--i] === 0; xc.pop())
+              ;
+          }
+          if (x.e > MAX_EXP) {
+            x.c = x.e = null;
+          } else if (x.e < MIN_EXP) {
+            x.c = [x.e = 0];
+          }
+        }
+        return x;
+      }
+      function valueOf(n) {
+        var str, e = n.e;
+        if (e === null)
+          return n.toString();
+        str = coeffToString(n.c);
+        str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(str, e) : toFixedPoint(str, e, "0");
+        return n.s < 0 ? "-" + str : str;
+      }
+      P.absoluteValue = P.abs = function() {
+        var x = new BigNumber2(this);
+        if (x.s < 0)
+          x.s = 1;
+        return x;
+      };
+      P.comparedTo = function(y, b) {
+        return compare(this, new BigNumber2(y, b));
+      };
+      P.decimalPlaces = P.dp = function(dp, rm) {
+        var c, n, v, x = this;
+        if (dp != null) {
+          intCheck(dp, 0, MAX);
+          if (rm == null)
+            rm = ROUNDING_MODE;
+          else
+            intCheck(rm, 0, 8);
+          return round(new BigNumber2(x), dp + x.e + 1, rm);
+        }
+        if (!(c = x.c))
+          return null;
+        n = ((v = c.length - 1) - bitFloor(this.e / LOG_BASE)) * LOG_BASE;
+        if (v = c[v])
+          for (;v % 10 == 0; v /= 10, n--)
+            ;
+        if (n < 0)
+          n = 0;
+        return n;
+      };
+      P.dividedBy = P.div = function(y, b) {
+        return div(this, new BigNumber2(y, b), DECIMAL_PLACES, ROUNDING_MODE);
+      };
+      P.dividedToIntegerBy = P.idiv = function(y, b) {
+        return div(this, new BigNumber2(y, b), 0, 1);
+      };
+      P.exponentiatedBy = P.pow = function(n, m) {
+        var half, isModExp, i, k, more, nIsBig, nIsNeg, nIsOdd, y, x = this;
+        n = new BigNumber2(n);
+        if (n.c && !n.isInteger()) {
+          throw Error(bignumberError + "Exponent not an integer: " + valueOf(n));
+        }
+        if (m != null)
+          m = new BigNumber2(m);
+        nIsBig = n.e > 14;
+        if (!x.c || !x.c[0] || x.c[0] == 1 && !x.e && x.c.length == 1 || !n.c || !n.c[0]) {
+          y = new BigNumber2(Math.pow(+valueOf(x), nIsBig ? n.s * (2 - isOdd(n)) : +valueOf(n)));
+          return m ? y.mod(m) : y;
+        }
+        nIsNeg = n.s < 0;
+        if (m) {
+          if (m.c ? !m.c[0] : !m.s)
+            return new BigNumber2(NaN);
+          isModExp = !nIsNeg && x.isInteger() && m.isInteger();
+          if (isModExp)
+            x = x.mod(m);
+        } else if (n.e > 9 && (x.e > 0 || x.e < -1 || (x.e == 0 ? x.c[0] > 1 || nIsBig && x.c[1] >= 240000000 : x.c[0] < 80000000000000 || nIsBig && x.c[0] <= 99999750000000))) {
+          k = x.s < 0 && isOdd(n) ? -0 : 0;
+          if (x.e > -1)
+            k = 1 / k;
+          return new BigNumber2(nIsNeg ? 1 / k : k);
+        } else if (POW_PRECISION) {
+          k = mathceil(POW_PRECISION / LOG_BASE + 2);
+        }
+        if (nIsBig) {
+          half = new BigNumber2(0.5);
+          if (nIsNeg)
+            n.s = 1;
+          nIsOdd = isOdd(n);
+        } else {
+          i = Math.abs(+valueOf(n));
+          nIsOdd = i % 2;
+        }
+        y = new BigNumber2(ONE);
+        for (;; ) {
+          if (nIsOdd) {
+            y = y.times(x);
+            if (!y.c)
+              break;
+            if (k) {
+              if (y.c.length > k)
+                y.c.length = k;
+            } else if (isModExp) {
+              y = y.mod(m);
+            }
+          }
+          if (i) {
+            i = mathfloor(i / 2);
+            if (i === 0)
+              break;
+            nIsOdd = i % 2;
+          } else {
+            n = n.times(half);
+            round(n, n.e + 1, 1);
+            if (n.e > 14) {
+              nIsOdd = isOdd(n);
+            } else {
+              i = +valueOf(n);
+              if (i === 0)
+                break;
+              nIsOdd = i % 2;
+            }
+          }
+          x = x.times(x);
+          if (k) {
+            if (x.c && x.c.length > k)
+              x.c.length = k;
+          } else if (isModExp) {
+            x = x.mod(m);
+          }
+        }
+        if (isModExp)
+          return y;
+        if (nIsNeg)
+          y = ONE.div(y);
+        return m ? y.mod(m) : k ? round(y, POW_PRECISION, ROUNDING_MODE, more) : y;
+      };
+      P.integerValue = function(rm) {
+        var n = new BigNumber2(this);
+        if (rm == null)
+          rm = ROUNDING_MODE;
+        else
+          intCheck(rm, 0, 8);
+        return round(n, n.e + 1, rm);
+      };
+      P.isEqualTo = P.eq = function(y, b) {
+        return compare(this, new BigNumber2(y, b)) === 0;
+      };
+      P.isFinite = function() {
+        return !!this.c;
+      };
+      P.isGreaterThan = P.gt = function(y, b) {
+        return compare(this, new BigNumber2(y, b)) > 0;
+      };
+      P.isGreaterThanOrEqualTo = P.gte = function(y, b) {
+        return (b = compare(this, new BigNumber2(y, b))) === 1 || b === 0;
+      };
+      P.isInteger = function() {
+        return !!this.c && bitFloor(this.e / LOG_BASE) > this.c.length - 2;
+      };
+      P.isLessThan = P.lt = function(y, b) {
+        return compare(this, new BigNumber2(y, b)) < 0;
+      };
+      P.isLessThanOrEqualTo = P.lte = function(y, b) {
+        return (b = compare(this, new BigNumber2(y, b))) === -1 || b === 0;
+      };
+      P.isNaN = function() {
+        return !this.s;
+      };
+      P.isNegative = function() {
+        return this.s < 0;
+      };
+      P.isPositive = function() {
+        return this.s > 0;
+      };
+      P.isZero = function() {
+        return !!this.c && this.c[0] == 0;
+      };
+      P.minus = function(y, b) {
+        var i, j, t, xLTy, x = this, a = x.s;
+        y = new BigNumber2(y, b);
+        b = y.s;
+        if (!a || !b)
+          return new BigNumber2(NaN);
+        if (a != b) {
+          y.s = -b;
+          return x.plus(y);
+        }
+        var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
+        if (!xe || !ye) {
+          if (!xc || !yc)
+            return xc ? (y.s = -b, y) : new BigNumber2(yc ? x : NaN);
+          if (!xc[0] || !yc[0]) {
+            return yc[0] ? (y.s = -b, y) : new BigNumber2(xc[0] ? x : ROUNDING_MODE == 3 ? -0 : 0);
+          }
+        }
+        xe = bitFloor(xe);
+        ye = bitFloor(ye);
+        xc = xc.slice();
+        if (a = xe - ye) {
+          if (xLTy = a < 0) {
+            a = -a;
+            t = xc;
+          } else {
+            ye = xe;
+            t = yc;
+          }
+          t.reverse();
+          for (b = a;b--; t.push(0))
+            ;
+          t.reverse();
+        } else {
+          j = (xLTy = (a = xc.length) < (b = yc.length)) ? a : b;
+          for (a = b = 0;b < j; b++) {
+            if (xc[b] != yc[b]) {
+              xLTy = xc[b] < yc[b];
+              break;
+            }
+          }
+        }
+        if (xLTy) {
+          t = xc;
+          xc = yc;
+          yc = t;
+          y.s = -y.s;
+        }
+        b = (j = yc.length) - (i = xc.length);
+        if (b > 0)
+          for (;b--; xc[i++] = 0)
+            ;
+        b = BASE - 1;
+        for (;j > a; ) {
+          if (xc[--j] < yc[j]) {
+            for (i = j;i && !xc[--i]; xc[i] = b)
+              ;
+            --xc[i];
+            xc[j] += BASE;
+          }
+          xc[j] -= yc[j];
+        }
+        for (;xc[0] == 0; xc.splice(0, 1), --ye)
+          ;
+        if (!xc[0]) {
+          y.s = ROUNDING_MODE == 3 ? -1 : 1;
+          y.c = [y.e = 0];
+          return y;
+        }
+        return normalise(y, xc, ye);
+      };
+      P.modulo = P.mod = function(y, b) {
+        var q, s, x = this;
+        y = new BigNumber2(y, b);
+        if (!x.c || !y.s || y.c && !y.c[0]) {
+          return new BigNumber2(NaN);
+        } else if (!y.c || x.c && !x.c[0]) {
+          return new BigNumber2(x);
+        }
+        if (MODULO_MODE == 9) {
+          s = y.s;
+          y.s = 1;
+          q = div(x, y, 0, 3);
+          y.s = s;
+          q.s *= s;
+        } else {
+          q = div(x, y, 0, MODULO_MODE);
+        }
+        y = x.minus(q.times(y));
+        if (!y.c[0] && MODULO_MODE == 1)
+          y.s = x.s;
+        return y;
+      };
+      P.multipliedBy = P.times = function(y, b) {
+        var c, e, i, j, k, m, xcL, xlo, xhi, ycL, ylo, yhi, zc, base, sqrtBase, x = this, xc = x.c, yc = (y = new BigNumber2(y, b)).c;
+        if (!xc || !yc || !xc[0] || !yc[0]) {
+          if (!x.s || !y.s || xc && !xc[0] && !yc || yc && !yc[0] && !xc) {
+            y.c = y.e = y.s = null;
+          } else {
+            y.s *= x.s;
+            if (!xc || !yc) {
+              y.c = y.e = null;
+            } else {
+              y.c = [0];
+              y.e = 0;
+            }
+          }
+          return y;
+        }
+        e = bitFloor(x.e / LOG_BASE) + bitFloor(y.e / LOG_BASE);
+        y.s *= x.s;
+        xcL = xc.length;
+        ycL = yc.length;
+        if (xcL < ycL) {
+          zc = xc;
+          xc = yc;
+          yc = zc;
+          i = xcL;
+          xcL = ycL;
+          ycL = i;
+        }
+        for (i = xcL + ycL, zc = [];i--; zc.push(0))
+          ;
+        base = BASE;
+        sqrtBase = SQRT_BASE;
+        for (i = ycL;--i >= 0; ) {
+          c = 0;
+          ylo = yc[i] % sqrtBase;
+          yhi = yc[i] / sqrtBase | 0;
+          for (k = xcL, j = i + k;j > i; ) {
+            xlo = xc[--k] % sqrtBase;
+            xhi = xc[k] / sqrtBase | 0;
+            m = yhi * xlo + xhi * ylo;
+            xlo = ylo * xlo + m % sqrtBase * sqrtBase + zc[j] + c;
+            c = (xlo / base | 0) + (m / sqrtBase | 0) + yhi * xhi;
+            zc[j--] = xlo % base;
+          }
+          zc[j] = c;
+        }
+        if (c) {
+          ++e;
+        } else {
+          zc.splice(0, 1);
+        }
+        return normalise(y, zc, e);
+      };
+      P.negated = function() {
+        var x = new BigNumber2(this);
+        x.s = -x.s || null;
+        return x;
+      };
+      P.plus = function(y, b) {
+        var t, x = this, a = x.s;
+        y = new BigNumber2(y, b);
+        b = y.s;
+        if (!a || !b)
+          return new BigNumber2(NaN);
+        if (a != b) {
+          y.s = -b;
+          return x.minus(y);
+        }
+        var xe = x.e / LOG_BASE, ye = y.e / LOG_BASE, xc = x.c, yc = y.c;
+        if (!xe || !ye) {
+          if (!xc || !yc)
+            return new BigNumber2(a / 0);
+          if (!xc[0] || !yc[0])
+            return yc[0] ? y : new BigNumber2(xc[0] ? x : a * 0);
+        }
+        xe = bitFloor(xe);
+        ye = bitFloor(ye);
+        xc = xc.slice();
+        if (a = xe - ye) {
+          if (a > 0) {
+            ye = xe;
+            t = yc;
+          } else {
+            a = -a;
+            t = xc;
+          }
+          t.reverse();
+          for (;a--; t.push(0))
+            ;
+          t.reverse();
+        }
+        a = xc.length;
+        b = yc.length;
+        if (a - b < 0) {
+          t = yc;
+          yc = xc;
+          xc = t;
+          b = a;
+        }
+        for (a = 0;b; ) {
+          a = (xc[--b] = xc[b] + yc[b] + a) / BASE | 0;
+          xc[b] = BASE === xc[b] ? 0 : xc[b] % BASE;
+        }
+        if (a) {
+          xc = [a].concat(xc);
+          ++ye;
+        }
+        return normalise(y, xc, ye);
+      };
+      P.precision = P.sd = function(sd, rm) {
+        var c, n, v, x = this;
+        if (sd != null && sd !== !!sd) {
+          intCheck(sd, 1, MAX);
+          if (rm == null)
+            rm = ROUNDING_MODE;
+          else
+            intCheck(rm, 0, 8);
+          return round(new BigNumber2(x), sd, rm);
+        }
+        if (!(c = x.c))
+          return null;
+        v = c.length - 1;
+        n = v * LOG_BASE + 1;
+        if (v = c[v]) {
+          for (;v % 10 == 0; v /= 10, n--)
+            ;
+          for (v = c[0];v >= 10; v /= 10, n++)
+            ;
+        }
+        if (sd && x.e + 1 > n)
+          n = x.e + 1;
+        return n;
+      };
+      P.shiftedBy = function(k) {
+        intCheck(k, -MAX_SAFE_INTEGER, MAX_SAFE_INTEGER);
+        return this.times("1e" + k);
+      };
+      P.squareRoot = P.sqrt = function() {
+        var m, n, r, rep, t, x = this, c = x.c, s = x.s, e = x.e, dp = DECIMAL_PLACES + 4, half = new BigNumber2("0.5");
+        if (s !== 1 || !c || !c[0]) {
+          return new BigNumber2(!s || s < 0 && (!c || c[0]) ? NaN : c ? x : 1 / 0);
+        }
+        s = Math.sqrt(+valueOf(x));
+        if (s == 0 || s == 1 / 0) {
+          n = coeffToString(c);
+          if ((n.length + e) % 2 == 0)
+            n += "0";
+          s = Math.sqrt(+n);
+          e = bitFloor((e + 1) / 2) - (e < 0 || e % 2);
+          if (s == 1 / 0) {
+            n = "5e" + e;
+          } else {
+            n = s.toExponential();
+            n = n.slice(0, n.indexOf("e") + 1) + e;
+          }
+          r = new BigNumber2(n);
+        } else {
+          r = new BigNumber2(s + "");
+        }
+        if (r.c[0]) {
+          e = r.e;
+          s = e + dp;
+          if (s < 3)
+            s = 0;
+          for (;; ) {
+            t = r;
+            r = half.times(t.plus(div(x, t, dp, 1)));
+            if (coeffToString(t.c).slice(0, s) === (n = coeffToString(r.c)).slice(0, s)) {
+              if (r.e < e)
+                --s;
+              n = n.slice(s - 3, s + 1);
+              if (n == "9999" || !rep && n == "4999") {
+                if (!rep) {
+                  round(t, t.e + DECIMAL_PLACES + 2, 0);
+                  if (t.times(t).eq(x)) {
+                    r = t;
+                    break;
+                  }
+                }
+                dp += 4;
+                s += 4;
+                rep = 1;
+              } else {
+                if (!+n || !+n.slice(1) && n.charAt(0) == "5") {
+                  round(r, r.e + DECIMAL_PLACES + 2, 1);
+                  m = !r.times(r).eq(x);
+                }
+                break;
+              }
+            }
+          }
+        }
+        return round(r, r.e + DECIMAL_PLACES + 1, ROUNDING_MODE, m);
+      };
+      P.toExponential = function(dp, rm) {
+        if (dp != null) {
+          intCheck(dp, 0, MAX);
+          dp++;
+        }
+        return format(this, dp, rm, 1);
+      };
+      P.toFixed = function(dp, rm) {
+        if (dp != null) {
+          intCheck(dp, 0, MAX);
+          dp = dp + this.e + 1;
+        }
+        return format(this, dp, rm);
+      };
+      P.toFormat = function(dp, rm, format2) {
+        var str, x = this;
+        if (format2 == null) {
+          if (dp != null && rm && typeof rm == "object") {
+            format2 = rm;
+            rm = null;
+          } else if (dp && typeof dp == "object") {
+            format2 = dp;
+            dp = rm = null;
+          } else {
+            format2 = FORMAT;
+          }
+        } else if (typeof format2 != "object") {
+          throw Error(bignumberError + "Argument not an object: " + format2);
+        }
+        str = x.toFixed(dp, rm);
+        if (x.c) {
+          var i, arr = str.split("."), g1 = +format2.groupSize, g2 = +format2.secondaryGroupSize, groupSeparator = format2.groupSeparator || "", intPart = arr[0], fractionPart = arr[1], isNeg = x.s < 0, intDigits = isNeg ? intPart.slice(1) : intPart, len = intDigits.length;
+          if (g2) {
+            i = g1;
+            g1 = g2;
+            g2 = i;
+            len -= i;
+          }
+          if (g1 > 0 && len > 0) {
+            i = len % g1 || g1;
+            intPart = intDigits.substr(0, i);
+            for (;i < len; i += g1)
+              intPart += groupSeparator + intDigits.substr(i, g1);
+            if (g2 > 0)
+              intPart += groupSeparator + intDigits.slice(i);
+            if (isNeg)
+              intPart = "-" + intPart;
+          }
+          str = fractionPart ? intPart + (format2.decimalSeparator || "") + ((g2 = +format2.fractionGroupSize) ? fractionPart.replace(new RegExp("\\d{" + g2 + "}\\B", "g"), "$&" + (format2.fractionGroupSeparator || "")) : fractionPart) : intPart;
+        }
+        return (format2.prefix || "") + str + (format2.suffix || "");
+      };
+      P.toFraction = function(md) {
+        var d, d0, d1, d2, e, exp, n, n0, n1, q, r, s, x = this, xc = x.c;
+        if (md != null) {
+          n = new BigNumber2(md);
+          if (!n.isInteger() && (n.c || n.s !== 1) || n.lt(ONE)) {
+            throw Error(bignumberError + "Argument " + (n.isInteger() ? "out of range: " : "not an integer: ") + valueOf(n));
+          }
+        }
+        if (!xc)
+          return new BigNumber2(x);
+        d = new BigNumber2(ONE);
+        n1 = d0 = new BigNumber2(ONE);
+        d1 = n0 = new BigNumber2(ONE);
+        s = coeffToString(xc);
+        e = d.e = s.length - x.e - 1;
+        d.c[0] = POWS_TEN[(exp = e % LOG_BASE) < 0 ? LOG_BASE + exp : exp];
+        md = !md || n.comparedTo(d) > 0 ? e > 0 ? d : n1 : n;
+        exp = MAX_EXP;
+        MAX_EXP = 1 / 0;
+        n = new BigNumber2(s);
+        n0.c[0] = 0;
+        for (;; ) {
+          q = div(n, d, 0, 1);
+          d2 = d0.plus(q.times(d1));
+          if (d2.comparedTo(md) == 1)
+            break;
+          d0 = d1;
+          d1 = d2;
+          n1 = n0.plus(q.times(d2 = n1));
+          n0 = d2;
+          d = n.minus(q.times(d2 = d));
+          n = d2;
+        }
+        d2 = div(md.minus(d0), d1, 0, 1);
+        n0 = n0.plus(d2.times(n1));
+        d0 = d0.plus(d2.times(d1));
+        n0.s = n1.s = x.s;
+        e = e * 2;
+        r = div(n1, d1, e, ROUNDING_MODE).minus(x).abs().comparedTo(div(n0, d0, e, ROUNDING_MODE).minus(x).abs()) < 1 ? [n1, d1] : [n0, d0];
+        MAX_EXP = exp;
+        return r;
+      };
+      P.toNumber = function() {
+        return +valueOf(this);
+      };
+      P.toPrecision = function(sd, rm) {
+        if (sd != null)
+          intCheck(sd, 1, MAX);
+        return format(this, sd, rm, 2);
+      };
+      P.toString = function(b) {
+        var str, n = this, s = n.s, e = n.e;
+        if (e === null) {
+          if (s) {
+            str = "Infinity";
+            if (s < 0)
+              str = "-" + str;
+          } else {
+            str = "NaN";
+          }
+        } else {
+          if (b == null) {
+            str = e <= TO_EXP_NEG || e >= TO_EXP_POS ? toExponential(coeffToString(n.c), e) : toFixedPoint(coeffToString(n.c), e, "0");
+          } else if (b === 10 && alphabetHasNormalDecimalDigits) {
+            n = round(new BigNumber2(n), DECIMAL_PLACES + e + 1, ROUNDING_MODE);
+            str = toFixedPoint(coeffToString(n.c), n.e, "0");
+          } else {
+            intCheck(b, 2, ALPHABET.length, "Base");
+            str = convertBase(toFixedPoint(coeffToString(n.c), e, "0"), 10, b, s, true);
+          }
+          if (s < 0 && n.c[0])
+            str = "-" + str;
+        }
+        return str;
+      };
+      P.valueOf = P.toJSON = function() {
+        return valueOf(this);
+      };
+      P._isBigNumber = true;
+      if (configObject != null)
+        BigNumber2.set(configObject);
+      return BigNumber2;
+    }
+    function bitFloor(n) {
+      var i = n | 0;
+      return n > 0 || n === i ? i : i - 1;
+    }
+    function coeffToString(a) {
+      var s, z, i = 1, j = a.length, r = a[0] + "";
+      for (;i < j; ) {
+        s = a[i++] + "";
+        z = LOG_BASE - s.length;
+        for (;z--; s = "0" + s)
+          ;
+        r += s;
+      }
+      for (j = r.length;r.charCodeAt(--j) === 48; )
+        ;
+      return r.slice(0, j + 1 || 1);
+    }
+    function compare(x, y) {
+      var a, b, xc = x.c, yc = y.c, i = x.s, j = y.s, k = x.e, l = y.e;
+      if (!i || !j)
+        return null;
+      a = xc && !xc[0];
+      b = yc && !yc[0];
+      if (a || b)
+        return a ? b ? 0 : -j : i;
+      if (i != j)
+        return i;
+      a = i < 0;
+      b = k == l;
+      if (!xc || !yc)
+        return b ? 0 : !xc ^ a ? 1 : -1;
+      if (!b)
+        return k > l ^ a ? 1 : -1;
+      j = (k = xc.length) < (l = yc.length) ? k : l;
+      for (i = 0;i < j; i++)
+        if (xc[i] != yc[i])
+          return xc[i] > yc[i] ^ a ? 1 : -1;
+      return k == l ? 0 : k > l ^ a ? 1 : -1;
+    }
+    function intCheck(n, min, max, name) {
+      if (n < min || n > max || n !== mathfloor(n)) {
+        throw Error(bignumberError + (name || "Argument") + (typeof n == "number" ? n < min || n > max ? " out of range: " : " not an integer: " : " not a primitive number: ") + String(n));
+      }
+    }
+    function isOdd(n) {
+      var k = n.c.length - 1;
+      return bitFloor(n.e / LOG_BASE) == k && n.c[k] % 2 != 0;
+    }
+    function toExponential(str, e) {
+      return (str.length > 1 ? str.charAt(0) + "." + str.slice(1) : str) + (e < 0 ? "e" : "e+") + e;
+    }
+    function toFixedPoint(str, e, z) {
+      var len, zs;
+      if (e < 0) {
+        for (zs = z + ".";++e; zs += z)
+          ;
+        str = zs + str;
+      } else {
+        len = str.length;
+        if (++e > len) {
+          for (zs = z, e -= len;--e; zs += z)
+            ;
+          str += zs;
+        } else if (e < len) {
+          str = str.slice(0, e) + "." + str.slice(e);
+        }
+      }
+      return str;
+    }
+    BigNumber = clone();
+    BigNumber["default"] = BigNumber.BigNumber = BigNumber;
+    if (typeof define == "function" && define.amd) {
+      define(function() {
+        return BigNumber;
+      });
+    } else if (typeof module != "undefined" && module.exports) {
+      module.exports = BigNumber;
+    } else {
+      if (!globalObject) {
+        globalObject = typeof self != "undefined" && self ? self : window;
+      }
+      globalObject.BigNumber = BigNumber;
+    }
+  })(exports);
+});
+// node_modules/.bun/json-bigint@1.0.0/node_modules/json-bigint/lib/stringify.js
+var require_stringify = __commonJS((exports, module) => {
+  var BigNumber = require_bignumber();
+  var JSON2 = exports;
+  (function() {
+    function f(n) {
+      return n < 10 ? "0" + n : n;
+    }
+    var cx = /[\u0000\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, escapable = /[\\\"\x00-\x1f\x7f-\x9f\u00ad\u0600-\u0604\u070f\u17b4\u17b5\u200c-\u200f\u2028-\u202f\u2060-\u206f\ufeff\ufff0-\uffff]/g, gap, indent, meta = {
+      "\b": "\\b",
+      "\t": "\\t",
+      "\n": "\\n",
+      "\f": "\\f",
+      "\r": "\\r",
+      '"': "\\\"",
+      "\\": "\\\\"
+    }, rep;
+    function quote(string) {
+      escapable.lastIndex = 0;
+      return escapable.test(string) ? '"' + string.replace(escapable, function(a) {
+        var c = meta[a];
+        return typeof c === "string" ? c : "\\u" + ("0000" + a.charCodeAt(0).toString(16)).slice(-4);
+      }) + '"' : '"' + string + '"';
+    }
+    function str(key, holder) {
+      var i, k, v, length, mind = gap, partial, value = holder[key], isBigNumber = value != null && (value instanceof BigNumber || BigNumber.isBigNumber(value));
+      if (value && typeof value === "object" && typeof value.toJSON === "function") {
+        value = value.toJSON(key);
+      }
+      if (typeof rep === "function") {
+        value = rep.call(holder, key, value);
+      }
+      switch (typeof value) {
+        case "string":
+          if (isBigNumber) {
+            return value;
+          } else {
+            return quote(value);
+          }
+        case "number":
+          return isFinite(value) ? String(value) : "null";
+        case "boolean":
+        case "null":
+        case "bigint":
+          return String(value);
+        case "object":
+          if (!value) {
+            return "null";
+          }
+          gap += indent;
+          partial = [];
+          if (Object.prototype.toString.apply(value) === "[object Array]") {
+            length = value.length;
+            for (i = 0;i < length; i += 1) {
+              partial[i] = str(i, value) || "null";
+            }
+            v = partial.length === 0 ? "[]" : gap ? `[
+` + gap + partial.join(`,
+` + gap) + `
+` + mind + "]" : "[" + partial.join(",") + "]";
+            gap = mind;
+            return v;
+          }
+          if (rep && typeof rep === "object") {
+            length = rep.length;
+            for (i = 0;i < length; i += 1) {
+              if (typeof rep[i] === "string") {
+                k = rep[i];
+                v = str(k, value);
+                if (v) {
+                  partial.push(quote(k) + (gap ? ": " : ":") + v);
+                }
+              }
+            }
+          } else {
+            Object.keys(value).forEach(function(k2) {
+              var v2 = str(k2, value);
+              if (v2) {
+                partial.push(quote(k2) + (gap ? ": " : ":") + v2);
+              }
+            });
+          }
+          v = partial.length === 0 ? "{}" : gap ? `{
+` + gap + partial.join(`,
+` + gap) + `
+` + mind + "}" : "{" + partial.join(",") + "}";
+          gap = mind;
+          return v;
+      }
+    }
+    if (typeof JSON2.stringify !== "function") {
+      JSON2.stringify = function(value, replacer, space) {
+        var i;
+        gap = "";
+        indent = "";
+        if (typeof space === "number") {
+          for (i = 0;i < space; i += 1) {
+            indent += " ";
+          }
+        } else if (typeof space === "string") {
+          indent = space;
+        }
+        rep = replacer;
+        if (replacer && typeof replacer !== "function" && (typeof replacer !== "object" || typeof replacer.length !== "number")) {
+          throw new Error("JSON.stringify");
+        }
+        return str("", { "": value });
+      };
+    }
+  })();
+});
+// node_modules/.bun/json-bigint@1.0.0/node_modules/json-bigint/lib/parse.js
+var require_parse = __commonJS((exports, module) => {
+  var BigNumber = null;
+  var suspectProtoRx = /(?:_|\\u005[Ff])(?:_|\\u005[Ff])(?:p|\\u0070)(?:r|\\u0072)(?:o|\\u006[Ff])(?:t|\\u0074)(?:o|\\u006[Ff])(?:_|\\u005[Ff])(?:_|\\u005[Ff])/;
+  var suspectConstructorRx = /(?:c|\\u0063)(?:o|\\u006[Ff])(?:n|\\u006[Ee])(?:s|\\u0073)(?:t|\\u0074)(?:r|\\u0072)(?:u|\\u0075)(?:c|\\u0063)(?:t|\\u0074)(?:o|\\u006[Ff])(?:r|\\u0072)/;
+  var json_parse = function(options) {
+    var _options = {
+      strict: false,
+      storeAsString: false,
+      alwaysParseAsBig: false,
+      useNativeBigInt: false,
+      protoAction: "error",
+      constructorAction: "error"
+    };
+    if (options !== undefined && options !== null) {
+      if (options.strict === true) {
+        _options.strict = true;
+      }
+      if (options.storeAsString === true) {
+        _options.storeAsString = true;
+      }
+      _options.alwaysParseAsBig = options.alwaysParseAsBig === true ? options.alwaysParseAsBig : false;
+      _options.useNativeBigInt = options.useNativeBigInt === true ? options.useNativeBigInt : false;
+      if (typeof options.constructorAction !== "undefined") {
+        if (options.constructorAction === "error" || options.constructorAction === "ignore" || options.constructorAction === "preserve") {
+          _options.constructorAction = options.constructorAction;
+        } else {
+          throw new Error(`Incorrect value for constructorAction option, must be "error", "ignore" or undefined but passed ${options.constructorAction}`);
+        }
+      }
+      if (typeof options.protoAction !== "undefined") {
+        if (options.protoAction === "error" || options.protoAction === "ignore" || options.protoAction === "preserve") {
+          _options.protoAction = options.protoAction;
+        } else {
+          throw new Error(`Incorrect value for protoAction option, must be "error", "ignore" or undefined but passed ${options.protoAction}`);
+        }
+      }
+    }
+    var at, ch, escapee = {
+      '"': '"',
+      "\\": "\\",
+      "/": "/",
+      b: "\b",
+      f: "\f",
+      n: `
+`,
+      r: "\r",
+      t: "\t"
+    }, text, error = function(m) {
+      throw {
+        name: "SyntaxError",
+        message: m,
+        at,
+        text
+      };
+    }, next = function(c) {
+      if (c && c !== ch) {
+        error("Expected '" + c + "' instead of '" + ch + "'");
+      }
+      ch = text.charAt(at);
+      at += 1;
+      return ch;
+    }, number = function() {
+      var number2, string2 = "";
+      if (ch === "-") {
+        string2 = "-";
+        next("-");
+      }
+      while (ch >= "0" && ch <= "9") {
+        string2 += ch;
+        next();
+      }
+      if (ch === ".") {
+        string2 += ".";
+        while (next() && ch >= "0" && ch <= "9") {
+          string2 += ch;
+        }
+      }
+      if (ch === "e" || ch === "E") {
+        string2 += ch;
+        next();
+        if (ch === "-" || ch === "+") {
+          string2 += ch;
+          next();
+        }
+        while (ch >= "0" && ch <= "9") {
+          string2 += ch;
+          next();
+        }
+      }
+      number2 = +string2;
+      if (!isFinite(number2)) {
+        error("Bad number");
+      } else {
+        if (BigNumber == null)
+          BigNumber = require_bignumber();
+        if (string2.length > 15)
+          return _options.storeAsString ? string2 : _options.useNativeBigInt ? BigInt(string2) : new BigNumber(string2);
+        else
+          return !_options.alwaysParseAsBig ? number2 : _options.useNativeBigInt ? BigInt(number2) : new BigNumber(number2);
+      }
+    }, string = function() {
+      var hex, i, string2 = "", uffff;
+      if (ch === '"') {
+        var startAt = at;
+        while (next()) {
+          if (ch === '"') {
+            if (at - 1 > startAt)
+              string2 += text.substring(startAt, at - 1);
+            next();
+            return string2;
+          }
+          if (ch === "\\") {
+            if (at - 1 > startAt)
+              string2 += text.substring(startAt, at - 1);
+            next();
+            if (ch === "u") {
+              uffff = 0;
+              for (i = 0;i < 4; i += 1) {
+                hex = parseInt(next(), 16);
+                if (!isFinite(hex)) {
+                  break;
+                }
+                uffff = uffff * 16 + hex;
+              }
+              string2 += String.fromCharCode(uffff);
+            } else if (typeof escapee[ch] === "string") {
+              string2 += escapee[ch];
+            } else {
+              break;
+            }
+            startAt = at;
+          }
+        }
+      }
+      error("Bad string");
+    }, white = function() {
+      while (ch && ch <= " ") {
+        next();
+      }
+    }, word = function() {
+      switch (ch) {
+        case "t":
+          next("t");
+          next("r");
+          next("u");
+          next("e");
+          return true;
+        case "f":
+          next("f");
+          next("a");
+          next("l");
+          next("s");
+          next("e");
+          return false;
+        case "n":
+          next("n");
+          next("u");
+          next("l");
+          next("l");
+          return null;
+      }
+      error("Unexpected '" + ch + "'");
+    }, value, array = function() {
+      var array2 = [];
+      if (ch === "[") {
+        next("[");
+        white();
+        if (ch === "]") {
+          next("]");
+          return array2;
+        }
+        while (ch) {
+          array2.push(value());
+          white();
+          if (ch === "]") {
+            next("]");
+            return array2;
+          }
+          next(",");
+          white();
+        }
+      }
+      error("Bad array");
+    }, object = function() {
+      var key, object2 = Object.create(null);
+      if (ch === "{") {
+        next("{");
+        white();
+        if (ch === "}") {
+          next("}");
+          return object2;
+        }
+        while (ch) {
+          key = string();
+          white();
+          next(":");
+          if (_options.strict === true && Object.hasOwnProperty.call(object2, key)) {
+            error('Duplicate key "' + key + '"');
+          }
+          if (suspectProtoRx.test(key) === true) {
+            if (_options.protoAction === "error") {
+              error("Object contains forbidden prototype property");
+            } else if (_options.protoAction === "ignore") {
+              value();
+            } else {
+              object2[key] = value();
+            }
+          } else if (suspectConstructorRx.test(key) === true) {
+            if (_options.constructorAction === "error") {
+              error("Object contains forbidden constructor property");
+            } else if (_options.constructorAction === "ignore") {
+              value();
+            } else {
+              object2[key] = value();
+            }
+          } else {
+            object2[key] = value();
+          }
+          white();
+          if (ch === "}") {
+            next("}");
+            return object2;
+          }
+          next(",");
+          white();
+        }
+      }
+      error("Bad object");
+    };
+    value = function() {
+      white();
+      switch (ch) {
+        case "{":
+          return object();
+        case "[":
+          return array();
+        case '"':
+          return string();
+        case "-":
+          return number();
+        default:
+          return ch >= "0" && ch <= "9" ? number() : word();
+      }
+    };
+    return function(source, reviver) {
+      var result;
+      text = source + "";
+      at = 0;
+      ch = " ";
+      result = value();
+      white();
+      if (ch) {
+        error("Syntax error");
+      }
+      return typeof reviver === "function" ? function walk(holder, key) {
+        var k, v, value2 = holder[key];
+        if (value2 && typeof value2 === "object") {
+          Object.keys(value2).forEach(function(k2) {
+            v = walk(value2, k2);
+            if (v !== undefined) {
+              value2[k2] = v;
+            } else {
+              delete value2[k2];
+            }
+          });
+        }
+        return reviver.call(holder, key, value2);
+      }({ "": result }, "") : result;
+    };
+  };
+  module.exports = json_parse;
+});
+// node_modules/.bun/json-bigint@1.0.0/node_modules/json-bigint/index.js
+var require_json_bigint = __commonJS((exports, module) => {
+  var json_stringify = require_stringify().stringify;
+  var json_parse = require_parse();
+  module.exports = function(options) {
+    return {
+      parse: json_parse(options),
+      stringify: json_stringify
+    };
+  };
+  module.exports.parse = json_parse();
+  module.exports.stringify = json_stringify;
+});
 // src/lib/search/cache.ts
 import { mkdir, readFile, rename, writeFile } from "node:fs/promises";
 import path2 from "node:path";
-// node_modules/env-paths/index.js
+// node_modules/.bun/env-paths@4.0.0/node_modules/env-paths/index.js
 import path from "node:path";
 import os from "node:os";
 import process2 from "node:process";
-// node_modules/is-safe-filename/index.js
+// node_modules/.bun/is-safe-filename@0.1.1/node_modules/is-safe-filename/index.js
 var unsafeFilenameFixtures = Object.freeze([
   "",
   "   ",
@@ -43,7 +1928,7 @@ function assertSafeFilename(filename) {
   }
 }
-// node_modules/env-paths/index.js
+// node_modules/.bun/env-paths@4.0.0/node_modules/env-paths/index.js
 var homedir = os.homedir();
 var tmpdir = os.tmpdir();
 var { env } = process2;
@@ -155,7 +2040,7 @@ function isNotFoundError(error) {
   return error instanceof Error && "code" in error && error.code === "ENOENT";
 }
-// node_modules/minisearch/dist/es/index.js
+// node_modules/.bun/minisearch@7.2.0/node_modules/minisearch/dist/es/index.js
 var ENTRIES = "ENTRIES";
 var KEYS = "KEYS";
 var VALUES = "VALUES";
@@ -1423,18 +3308,544 @@ function compact(value) {
   return value.toLowerCase().replace(/\s+/g, "");
 }
+// packages/oceanengine-ad-open-sdk/dist/runtime/ApiException.js
+class ApiException extends Error {
+  statusCode;
+  responseBody;
+  headers;
+  constructor(message, options = {}) {
+    super(message);
+    this.name = "ApiException";
+    this.statusCode = options.statusCode;
+    this.responseBody = options.responseBody;
+    this.headers = options.headers;
+  }
+}
+// packages/oceanengine-ad-open-sdk/dist/runtime/json.js
+var import_json_bigint = __toESM(require_json_bigint(), 1);
+var JSONBigStringParser = import_json_bigint.default({ storeAsString: true });
+function parseJsonPreservingLargeIntegers(text) {
+  return JSONBigStringParser.parse(text);
+}
+// packages/oceanengine-ad-open-sdk/dist/runtime/sdk-version.js
+var SDK_VERSION = "1.1.87";
+// packages/oceanengine-ad-open-sdk/dist/runtime/ApiClient.js
+class ApiClient {
+  basePath = "https://api.oceanengine.com";
+  fetchImpl;
+  defaultHeaders = new Headers;
+  constructor(options = {}) {
+    this.fetchImpl = options.fetch ?? fetch;
+    if (options.basePath) {
+      this.basePath = options.basePath;
+    }
+    this.setUserAgent("Bytedance Ads Openapi SDK");
+    this.addDefaultHeader("X-Sdk-Language", "node");
+    this.addDefaultHeader("X-Sdk-Version", SDK_VERSION);
+  }
+  getBasePath() {
+    return this.basePath;
+  }
+  setBasePath(basePath) {
+    this.basePath = basePath;
+    return this;
+  }
+  setUserAgent(userAgent) {
+    this.addDefaultHeader("User-Agent", userAgent);
+    return this;
+  }
+  addDefaultHeader(name, value) {
+    this.defaultHeaders.set(name, value);
+    return this;
+  }
+  setAccessToken(token) {
+    this.addDefaultHeader("Access-Token", token);
+    return this;
+  }
+  buildUrl(path3, queryParams = []) {
+    const url = new URL(path3, this.basePath);
+    for (const param of queryParams) {
+      if (param.value == null) {
+        continue;
+      }
+      if (Array.isArray(param.value)) {
+        if (param.collectionFormat === "multi") {
+          for (const value of param.value) {
+            url.searchParams.append(param.name, this.parameterToString(value));
+          }
+          continue;
+        }
+        if (param.collectionFormat !== "csv") {
+          throw new ApiException(`Unsupported collection format for query parameter '${param.name}'`);
+        }
+        url.searchParams.append(param.name, param.value.map((value) => this.parameterToString(value)).join(","));
+        continue;
+      }
+      url.searchParams.append(param.name, this.parameterToString(param.value));
+    }
+    return url;
+  }
+  async request(options) {
+    const response = await this.requestWithHttpInfo(options);
+    return response.data;
+  }
+  async requestWithHttpInfo(options) {
+    const request = this.buildRequest(options);
+    const response = await this.fetchImpl(request);
+    const data = await this.readResponseBody(response, options.responseType);
+    if (!response.ok) {
+      throw new ApiException(`HTTP ${response.status}`, {
+        statusCode: response.status,
+        responseBody: data,
+        headers: response.headers
+      });
+    }
+    return {
+      data,
+      statusCode: response.status,
+      headers: response.headers
+    };
+  }
+  buildRequest(options) {
+    const headers = new Headers(this.defaultHeaders);
+    for (const [name, value] of Object.entries(options.headers ?? {})) {
+      headers.set(name, value);
+    }
+    let body;
+    if (options.method !== "GET" && (options.formParams || options.files)) {
+      const contentType = options.contentType ?? "application/x-www-form-urlencoded";
+      if (contentType === "multipart/form-data") {
+        body = this.buildMultipartFormBody(options.formParams, options.files);
+      } else if (contentType === "application/x-www-form-urlencoded") {
+        headers.set("Content-Type", contentType);
+        const formBody = new URLSearchParams;
+        for (const [name, value] of Object.entries(options.formParams ?? {})) {
+          if (value != null) {
+            formBody.append(name, this.parameterToString(value));
+          }
+        }
+        body = formBody;
+      } else {
+        throw new ApiException(`Unsupported form content type '${contentType}'`);
+      }
+    } else if (options.method !== "GET" && options.body != null) {
+      const contentType = options.contentType ?? "application/json";
+      headers.set("Content-Type", contentType);
+      body = contentType === "application/json" ? JSON.stringify(options.body) : String(options.body);
+    }
+    return new Request(this.buildUrl(options.path, options.queryParams), {
+      method: options.method,
+      headers,
+      body
+    });
+  }
+  buildMultipartFormBody(formParams = {}, files = {}) {
+    const formBody = new FormData;
+    for (const [name, value] of Object.entries(formParams)) {
+      if (value != null) {
+        formBody.append(name, this.parameterToString(value));
+      }
+    }
+    for (const [name, value] of Object.entries(files)) {
+      if (value != null) {
+        formBody.append(name, value);
+      }
+    }
+    return formBody;
+  }
+  async readResponseBody(response, responseType = "json") {
+    if (responseType === "arrayBuffer") {
+      return response.arrayBuffer();
+    }
+    const text = await response.text();
+    if (!text) {
+      return;
+    }
+    if (responseType === "text") {
+      return text;
+    }
+    const contentType = response.headers.get("Content-Type") ?? "";
+    if (contentType.includes("application/json")) {
+      return parseJsonPreservingLargeIntegers(text);
+    }
+    return text;
+  }
+  parameterToString(value) {
+    if (value instanceof Date) {
+      return value.toISOString();
+    }
+    if (typeof value === "object" && value !== null) {
+      return JSON.stringify(value);
+    }
+    return String(value);
+  }
+}
+// packages/oceanengine-ad-open-sdk/dist/apis/Oauth2AdvertiserGetApi.js
+class Oauth2AdvertiserGetApi {
+  apiClient;
+  constructor(apiClient = new ApiClient) {
+    this.apiClient = apiClient;
+  }
+  getApiClient() {
+    return this.apiClient;
+  }
+  setApiClient(apiClient) {
+    this.apiClient = apiClient;
+  }
+  async openApiOauth2AdvertiserGetGet(request) {
+    const response = await this.openApiOauth2AdvertiserGetGetWithHttpInfo(request);
+    return response.data;
+  }
+  async openApiOauth2AdvertiserGetGetWithHttpInfo(request) {
+    return this.apiClient.requestWithHttpInfo({
+      method: "GET",
+      path: "/open_api/oauth2/advertiser/get/",
+      queryParams: [
+        { name: "access_token", value: request.accessToken }
+      ]
+    });
+  }
+}
+// packages/oceanengine-ad-open-sdk/dist/apis/ProjectListV30Api.js
+class ProjectListV30Api {
+  apiClient;
+  constructor(apiClient = new ApiClient) {
+    this.apiClient = apiClient;
+  }
+  getApiClient() {
+    return this.apiClient;
+  }
+  setApiClient(apiClient) {
+    this.apiClient = apiClient;
+  }
+  async openApiV30ProjectListGet(request) {
+    const response = await this.openApiV30ProjectListGetWithHttpInfo(request);
+    return response.data;
+  }
+  async openApiV30ProjectListGetWithHttpInfo(request) {
+    if (request.advertiserId == null) {
+      throw new ApiException("Missing the required parameter 'advertiserId' when calling openApiV30ProjectListGet");
+    }
+    return this.apiClient.requestWithHttpInfo({
+      method: "GET",
+      path: "/open_api/v3.0/project/list/",
+      queryParams: [
+        { name: "fields", value: request.fields, collectionFormat: "csv" },
+        { name: "filtering", value: request.filtering },
+        { name: "advertiser_id", value: request.advertiserId },
+        { name: "page", value: request.page },
+        { name: "page_size", value: request.pageSize }
+      ]
+    });
+  }
+}
+// packages/oceanengine-ad-open-sdk/dist/apis/PromotionListV30Api.js
+class PromotionListV30Api {
+  apiClient;
+  constructor(apiClient = new ApiClient) {
+    this.apiClient = apiClient;
+  }
+  getApiClient() {
+    return this.apiClient;
+  }
+  setApiClient(apiClient) {
+    this.apiClient = apiClient;
+  }
+  async openApiV30PromotionListGet(request) {
+    const response = await this.openApiV30PromotionListGetWithHttpInfo(request);
+    return response.data;
+  }
+  async openApiV30PromotionListGetWithHttpInfo(request) {
+    if (request.advertiserId == null) {
+      throw new ApiException("Missing the required parameter 'advertiserId' when calling openApiV30PromotionListGet");
+    }
+    return this.apiClient.requestWithHttpInfo({
+      method: "GET",
+      path: "/open_api/v3.0/promotion/list/",
+      queryParams: [
+        { name: "advertiser_id", value: request.advertiserId },
+        { name: "filtering", value: request.filtering },
+        { name: "fields", value: request.fields, collectionFormat: "csv" },
+        { name: "including_material_atrributes", value: request.includingMaterialAtrributes },
+        { name: "page", value: request.page },
+        { name: "page_size", value: request.pageSize },
+        { name: "cursor", value: request.cursor },
+        { name: "count", value: request.count }
+      ]
+    });
+  }
+}
+// src/commands/oceanengine/config.ts
+import { chmod, mkdir as mkdir2, readFile as readFile2, rename as rename2, writeFile as writeFile2 } from "node:fs/promises";
+import path3 from "node:path";
+function getOceanEngineConfigInfo(options = {}) {
+  const configDir = options.configDir ?? envPaths("adcli", { suffix: "" }).cache;
+  return {
+    configPath: path3.join(configDir, "oceanengine.json")
+  };
+}
+async function saveOceanEngineAccessToken(token, options = {}) {
+  const trimmed = token.trim();
+  if (!trimmed) {
+    throw new Error("missing OceanEngine token");
+  }
+  const configInfo = getOceanEngineConfigInfo(options);
+  await mkdir2(path3.dirname(configInfo.configPath), { recursive: true });
+  const tempPath = `${configInfo.configPath}.${process.pid}.tmp`;
+  await writeFile2(tempPath, `${JSON.stringify({ access_token: trimmed })}
+`, {
+    encoding: "utf8",
+    mode: 384
+  });
+  await rename2(tempPath, configInfo.configPath);
+  await chmod(configInfo.configPath, 384);
+  return configInfo;
+}
+async function loadOceanEngineAccessToken(options = {}) {
+  const configInfo = getOceanEngineConfigInfo(options);
+  let config;
+  try {
+    config = JSON.parse(await readFile2(configInfo.configPath, "utf8"));
+  } catch (error) {
+    if (isNotFoundError2(error)) {
+      return;
+    }
+    throw error;
+  }
+  if (typeof config.access_token !== "string" || !config.access_token.trim()) {
+    return;
+  }
+  return config.access_token.trim();
+}
+function isNotFoundError2(error) {
+  return error instanceof Error && "code" in error && error.code === "ENOENT";
+}
+// src/commands/oceanengine/commands.ts
+async function runOceanEngineCommand(argv, options = {}) {
+  const args = parseOceanEngineArgs(argv);
+  if (args.resource === "auth") {
+    const token2 = args.action;
+    if (!token2) {
+      throw new Error("missing OceanEngine token");
+    }
+    const configInfo = await saveOceanEngineAccessToken(token2, { configDir: options.configDir });
+    return {
+      ok: true,
+      config_path: configInfo.configPath
+    };
+  }
+  const token = await resolveAccessToken(args, options);
+  const apiClient = new ApiClient({ fetch: options.fetch }).setAccessToken(token);
+  if (args.resource === "advertiser" && args.action === "list") {
+    return new Oauth2AdvertiserGetApi(apiClient).openApiOauth2AdvertiserGetGet({ accessToken: token });
+  }
+  if (isProjectListCommand(args)) {
+    const advertiserId = getRequiredId(args, "advertiser-id");
+    return new ProjectListV30Api(apiClient).openApiV30ProjectListGet({
+      advertiserId,
+      fields: parseCsv(args.flags.fields),
+      filtering: parseJsonFlag(args.flags.filtering),
+      page: parseNumberFlag(args.flags.page),
+      pageSize: parseNumberFlag(args.flags["page-size"])
+    });
+  }
+  if (args.resource === "promotion" && args.action === "list") {
+    const advertiserId = getRequiredId(args, "advertiser-id");
+    const filtering = {
+      ...parseJsonFlag(args.flags.filtering),
+      ...parseProjectFilter(args.flags["project-id"])
+    };
+    return new PromotionListV30Api(apiClient).openApiV30PromotionListGet({
+      advertiserId,
+      filtering: Object.keys(filtering).length > 0 ? filtering : undefined,
+      fields: parseCsv(args.flags.fields),
+      includingMaterialAtrributes: args.flags["including-material-attributes"],
+      page: parseNumberFlag(args.flags.page),
+      pageSize: parseNumberFlag(args.flags["page-size"]),
+      cursor: parseNumberFlag(args.flags.cursor),
+      count: parseNumberFlag(args.flags.count)
+    });
+  }
+  throw new Error(`unknown oceanengine command: ${[args.resource, args.action].filter(Boolean).join(" ")}`);
+}
+function formatOceanEngineOutput(payload, json, argv = []) {
+  if (json) {
+    return JSON.stringify(payload, null, 2);
+  }
+  if (isOceanEngineErrorPayload(payload)) {
+    return JSON.stringify(payload, null, 2);
+  }
+  if (argv[0] === "project" && argv[1] === "list") {
+    return formatEntityList(payload, "project_id", ["project_id", "id"], ["name", "project_name"]);
+  }
+  if (argv[0] === "promotion" && argv[1] === "list") {
+    return formatEntityList(payload, "promotion_id", ["promotion_id", "id"], ["name", "promotion_name"]);
+  }
+  return JSON.stringify(payload, null, 2);
+}
+function formatOceanEngineError(error) {
+  if (!isRecord(error) || !("responseBody" in error)) {
+    return;
+  }
+  const responseBody = error.responseBody;
+  if (responseBody == null) {
+    return;
+  }
+  if (typeof responseBody === "string") {
+    return responseBody;
+  }
+  return JSON.stringify(responseBody, null, 2);
+}
+function parseOceanEngineArgs(argv) {
+  const args = {
+    resource: argv[0],
+    action: argv[1],
+    flags: {}
+  };
+  for (let index = 2;index < argv.length; index += 1) {
+    const value = argv[index];
+    if (!value?.startsWith("--")) {
+      continue;
+    }
+    const name = value.slice(2);
+    const next = argv[index + 1];
+    if (!next || next.startsWith("--")) {
+      args.flags[name] = true;
+      continue;
+    }
+    args.flags[name] = next;
+    index += 1;
+  }
+  return args;
+}
+async function resolveAccessToken(args, options) {
+  const explicitToken = getOptionalString(args.flags["access-token"]);
+  if (explicitToken) {
+    return explicitToken;
+  }
+  const env2 = options.env ?? process.env;
+  const envToken = getOptionalString(env2.OCEANENGINE_ACCESS_TOKEN);
+  if (envToken) {
+    return envToken;
+  }
+  const savedToken = await loadOceanEngineAccessToken({ configDir: options.configDir });
+  if (savedToken) {
+    return savedToken;
+  }
+  throw new Error("missing --access-token; run adcli oceanengine auth <token> or set OCEANENGINE_ACCESS_TOKEN");
+}
+function getRequiredString(args, flag) {
+  const value = getOptionalString(args.flags[flag]);
+  if (!value) {
+    throw new Error(`missing --${flag}`);
+  }
+  return value;
+}
+function getOptionalString(value) {
+  if (typeof value !== "string" || !value) {
+    return;
+  }
+  return value;
+}
+function getRequiredId(args, flag) {
+  const value = getRequiredString(args, flag);
+  if (!/^\d+$/.test(value)) {
+    throw new Error(`--${flag} must be an integer id`);
+  }
+  return value;
+}
+function parseNumberFlag(value) {
+  if (value == null || value === true) {
+    return;
+  }
+  const parsed = Number(value);
+  if (!Number.isFinite(parsed)) {
+    throw new Error(`numeric flag must be a number: ${value}`);
+  }
+  return parsed;
+}
+function parseCsv(value) {
+  if (typeof value !== "string" || !value) {
+    return;
+  }
+  return value.split(",").map((item) => item.trim()).filter(Boolean);
+}
+function parseJsonFlag(value) {
+  if (typeof value !== "string" || !value) {
+    return;
+  }
+  return parseJsonPreservingLargeIntegers(value);
+}
+function parseProjectFilter(value) {
+  if (typeof value !== "string" || !value) {
+    return {};
+  }
+  if (!/^\d+$/.test(value)) {
+    throw new Error("--project-id must be an integer id");
+  }
+  return { project_id: value };
+}
+function isProjectListCommand(args) {
+  return args.resource === "project" && args.action === "list";
+}
+function formatEntityList(payload, idHeader, idKeys, nameKeys) {
+  const list = getPayloadList(payload);
+  const header = `${idHeader}	name`;
+  if (list.length === 0) {
+    return header;
+  }
+  return [
+    header,
+    ...list.map((item) => {
+      const id = getRecordValue(item, idKeys);
+      const name = getRecordValue(item, nameKeys);
+      return `${id}	${name}`;
+    })
+  ].join(`
+`);
+}
+function getPayloadList(payload) {
+  if (!isRecord(payload) || !isRecord(payload.data) || !Array.isArray(payload.data.list)) {
+    return [];
+  }
+  return payload.data.list.filter(isRecord);
+}
+function getRecordValue(record, keys) {
+  for (const key of keys) {
+    const value = record[key];
+    if (typeof value === "string" || typeof value === "number") {
+      return String(value);
+    }
+  }
+  return "";
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isOceanEngineErrorPayload(payload) {
+  return isRecord(payload) && typeof payload.code === "number" && payload.code !== 0;
+}
 // src/cli.ts
 var help = `adcli
 Usage:
   adcli list [platform] [--json]
   adcli doc <command>
+  adcli oceanengine <resource> <command>
   adcli prompt
   adcli llms
 Commands:
   list          List supported advertising platforms and capabilities
   doc           Search and sync published advertising API docs
+  oceanengine   Call OceanEngine APIs through the generated Node.js SDK
   prompt        Print an AI/Agent instruction prompt for using the docs pack
   llms          Print LLM-readable docs pack entry URLs
 `;
@@ -1448,6 +3859,18 @@ Commands:
   search    Search published advertising API docs
   sync      Download and cache the latest search index
 `;
+var oceanEngineHelp = `adcli oceanengine
+Usage:
+  adcli oceanengine auth <token>
+  adcli oceanengine advertiser list [--access-token token] [--json]
+  adcli oceanengine project list --advertiser-id 123 [--access-token token] [--page 1] [--page-size 20] [--filtering '{"status":"PROJECT_STATUS_ALL"}'] [--json]
+  adcli oceanengine promotion list --advertiser-id 123 [--access-token token] [--project-id 456] [--fields promotion_id,name,status_first] [--filtering '{}'] [--json]
+Environment:
+  Token precedence is --access-token, OCEANENGINE_ACCESS_TOKEN, then the saved token.
+  Project list does not include deleted projects by default; use filtering status PROJECT_STATUS_ALL for all projects.
+`;
 async function main() {
   const args = parseArgs(process.argv.slice(2));
   if (!args.domain || args.domain === "help" || args.domain === "--help" || args.domain === "-h") {
@@ -1482,6 +3905,16 @@ async function main() {
     printLlms(args);
     return;
   }
+  if (args.domain === "oceanengine") {
+    if (!args.command || args.command === "--help" || args.command === "-h" || args.command === "help") {
+      console.log(oceanEngineHelp.trim());
+      return;
+    }
+    const oceanEngineArgv = [args.command, ...args.query];
+    const payload = await runOceanEngineCommand(oceanEngineArgv);
+    console.log(formatOceanEngineOutput(payload, args.json, oceanEngineArgv));
+    return;
+  }
   if (args.domain !== "doc" || args.command !== "search") {
     throw new Error(`unknown command: ${[args.domain, args.command].filter(Boolean).join(" ")}`);
   }
@@ -1645,6 +4078,6 @@ function parseArgs(argv) {
   return args;
 }
 main().catch((error) => {
-  console.error(error instanceof Error ? error.message : error);
+  console.error(formatOceanEngineError(error) ?? (error instanceof Error ? error.message : error));
   process.exit(1);
 });