@wzyjs/utils 0.3.4 → 0.3.6

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.
package/dist/web.esm.js CHANGED
@@ -6613,7 +6613,7 @@ var require_lodash = __commonJS((exports, module) => {
6613
6613
  var tag = baseGetTag(value);
6614
6614
  return tag == errorTag || tag == domExcTag || typeof value.message == "string" && typeof value.name == "string" && !isPlainObject(value);
6615
6615
  }
6616
- function isFinite2(value) {
6616
+ function isFinite(value) {
6617
6617
  return typeof value == "number" && nativeIsFinite(value);
6618
6618
  }
6619
6619
  function isFunction(value) {
@@ -7727,7 +7727,7 @@ __p += '`;
7727
7727
  lodash.isEqual = isEqual;
7728
7728
  lodash.isEqualWith = isEqualWith;
7729
7729
  lodash.isError = isError;
7730
- lodash.isFinite = isFinite2;
7730
+ lodash.isFinite = isFinite;
7731
7731
  lodash.isFunction = isFunction;
7732
7732
  lodash.isInteger = isInteger;
7733
7733
  lodash.isLength = isLength;
@@ -13412,7 +13412,7 @@ var globalFetchAPI = (({ Request, Response }) => ({
13412
13412
  }))(utils_default.global);
13413
13413
  var {
13414
13414
  ReadableStream: ReadableStream2,
13415
- TextEncoder: TextEncoder2
13415
+ TextEncoder
13416
13416
  } = utils_default.global;
13417
13417
  var test = (fn, ...args) => {
13418
13418
  try {
@@ -13433,7 +13433,7 @@ var factory = (env) => {
13433
13433
  return false;
13434
13434
  }
13435
13435
  const isReadableStreamSupported = isFetchSupported && isFunction2(ReadableStream2);
13436
- const encodeText = isFetchSupported && (typeof TextEncoder2 === "function" ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder2) : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
13436
+ const encodeText = isFetchSupported && (typeof TextEncoder === "function" ? ((encoder) => (str) => encoder.encode(str))(new TextEncoder) : async (str) => new Uint8Array(await new Request(str).arrayBuffer()));
13437
13437
  const supportsRequestStream = isRequestSupported && isReadableStreamSupported && test(() => {
13438
13438
  let duplexAccessed = false;
13439
13439
  const hasContentType = new Request(platform_default.origin, {
@@ -18082,14 +18082,6 @@ var coerce = {
18082
18082
  date: (arg) => ZodDate.create({ ...arg, coerce: true })
18083
18083
  };
18084
18084
  var NEVER = INVALID;
18085
- // src/common/ai/302/index.ts
18086
- var exports_302 = {};
18087
- __export(exports_302, {
18088
- image: () => exports_image,
18089
- chat: () => chat,
18090
- audio: () => exports_audio
18091
- });
18092
-
18093
18085
  // src/common/ai/302/axios.ts
18094
18086
  var key = process.env.AI_302_KEY || process.env.NEXT_PUBLIC_AI_302_KEY;
18095
18087
  var axios2 = axios_default.create({
@@ -18112,7 +18104,7 @@ var chat = async (message, model = "gpt-4.1", isParse = true) => {
18112
18104
  message
18113
18105
  }
18114
18106
  });
18115
- console.log(666, "302 chat res", typeof data, data);
18107
+ console.log(666, typeof data, data);
18116
18108
  const output = typeof data === "string" ? import_json5.default.parse(data)?.output : data?.output;
18117
18109
  if (isParse) {
18118
18110
  const match = /```(json)?(.*)```/s.exec(output);
@@ -18124,414 +18116,9 @@ var chat = async (message, model = "gpt-4.1", isParse = true) => {
18124
18116
  }
18125
18117
  return output;
18126
18118
  } catch (error) {
18127
- const responseData = error?.response?.data;
18128
- const message2 = responseData?.error?.message_cn || responseData?.error?.message || responseData?.message || error?.response?.statusText || error?.message || "未知原因";
18129
- throw new Error(message2);
18130
- }
18131
- };
18132
- // src/common/ai/302/audio/index.ts
18133
- var exports_audio = {};
18134
- __export(exports_audio, {
18135
- tts: () => exports_tts,
18136
- doubao: () => exports_doubao
18137
- });
18138
-
18139
- // src/common/ai/302/audio/tts.ts
18140
- var exports_tts = {};
18141
- __export(exports_tts, {
18142
- textToSpeech: () => textToSpeech,
18143
- fetchTask: () => fetchTask,
18144
- fetchProviders: () => fetchProviders
18145
- });
18146
- var fetchProviders = async () => {
18147
- try {
18148
- const { data } = await axios2({
18149
- url: "/302/tts/provider",
18150
- method: "get"
18151
- });
18152
- return data;
18153
- } catch (error) {
18154
- throw error;
18155
- }
18156
- };
18157
- var textToSpeech = async (request) => {
18158
- try {
18159
- const { webhook, run_async, ...body } = request;
18160
- const { data } = await axios2({
18161
- url: "/302/v2/audio/tts",
18162
- method: "post",
18163
- params: {
18164
- webhook,
18165
- run_async
18166
- },
18167
- data: {
18168
- ...body,
18169
- speed: body.speed ?? 1,
18170
- volume: body.volume ?? 1,
18171
- timeout: body.timeout ?? 180
18172
- }
18173
- });
18174
- return data;
18175
- } catch (error) {
18176
- throw error;
18177
- }
18178
- };
18179
- var fetchTask = async (taskId) => {
18180
- if (!taskId) {
18181
- throw new Error("taskId 不能为空");
18182
- }
18183
- try {
18184
- const { data } = await axios2({
18185
- url: `/302/v2/audio/fetch/${encodeURIComponent(taskId)}`,
18186
- method: "get"
18187
- });
18188
- return data;
18189
- } catch (error) {
18190
- throw error;
18191
- }
18192
- };
18193
- // src/common/ai/302/audio/doubao.ts
18194
- var exports_doubao = {};
18195
- __export(exports_doubao, {
18196
- ttsHd: () => ttsHd
18197
- });
18198
- var createReqid = () => {
18199
- if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
18200
- return crypto.randomUUID();
18201
- }
18202
- return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
18203
- };
18204
- var getUtf8ByteLength = (value) => {
18205
- return new TextEncoder().encode(value).length;
18206
- };
18207
- var assertNonEmptyString = (value, label) => {
18208
- if (typeof value !== "string" || !value.trim()) {
18209
- throw new Error(`${label} 不能为空`);
18210
- }
18211
- };
18212
- var assertSpeedRatio = (value) => {
18213
- if (value === undefined)
18214
- return;
18215
- if (typeof value !== "number" || !Number.isFinite(value)) {
18216
- throw new Error("speed_ratio 必须为数字");
18217
- }
18218
- if (value < 0.8 || value > 2) {
18219
- throw new Error("speed_ratio 取值范围为 [0.8, 2]");
18220
- }
18221
- };
18222
- var ttsHd = async (payload) => {
18223
- const { audio, request } = payload;
18224
- const { voice_type, encoding, speed_ratio } = audio;
18225
- const { text, reqid: rawReqid, operation } = request;
18226
- assertNonEmptyString(voice_type, "voice_type");
18227
- assertNonEmptyString(text, "text");
18228
- assertSpeedRatio(speed_ratio);
18229
- const textByteLength = getUtf8ByteLength(text);
18230
- if (textByteLength > 1024) {
18231
- throw new Error(`text 超出长度限制:${textByteLength}/1024 字节`);
18232
- }
18233
- const reqid = rawReqid?.trim() || createReqid();
18234
- const { data } = await axios2({
18235
- url: "/doubao/tts_hd",
18236
- method: "post",
18237
- data: {
18238
- audio: {
18239
- voice_type,
18240
- encoding: encoding ?? "pcm",
18241
- speed_ratio: speed_ratio ?? 1
18242
- },
18243
- request: {
18244
- reqid,
18245
- text,
18246
- operation: operation ?? "query"
18247
- }
18248
- }
18249
- });
18250
- return data;
18251
- };
18252
- // src/common/ai/302/image/index.ts
18253
- var exports_image = {};
18254
- __export(exports_image, {
18255
- midjourney: () => exports_midjourney,
18256
- gpt: () => exports_gpt
18257
- });
18258
-
18259
- // src/common/ai/302/image/midjourney.ts
18260
- var exports_midjourney = {};
18261
- __export(exports_midjourney, {
18262
- getImageStatus: () => getImageStatus,
18263
- generateImage: () => generateImage
18264
- });
18265
- var generateImage = async (prompt, base64Array) => {
18266
- try {
18267
- const { data } = await axios2({
18268
- url: "/mj/submit/imagine",
18269
- method: "post",
18270
- data: {
18271
- prompt,
18272
- base64Array,
18273
- botType: "MID_JOURNEY",
18274
- notifyHook: "",
18275
- state: ""
18276
- }
18277
- });
18278
- return data;
18279
- } catch (error) {
18280
- throw error;
18281
- }
18282
- };
18283
- var getImageStatus = async (taskId) => {
18284
- try {
18285
- const { data } = await axios2({
18286
- url: `/mj/task/${taskId}/fetch`,
18287
- method: "get"
18288
- });
18289
- return data;
18290
- } catch (error) {
18291
- throw error;
18292
- }
18293
- };
18294
- // src/common/ai/302/image/gpt.ts
18295
- var exports_gpt = {};
18296
- __export(exports_gpt, {
18297
- generateImage: () => generateImage2
18298
- });
18299
- var generateImage2 = async (params) => {
18300
- if (params.model === "gpt-4o-plus") {
18301
- const { data: data2 } = await axios2.post("/v1/chat/completions", {
18302
- model: params.model,
18303
- messages: [{ role: "user", content: params.prompt }]
18304
- });
18305
- const content = data2?.choices?.[0]?.message?.content || "";
18306
- const urlMatch = content.match(/!\[.*?\]\((.*?)\)/) || content.match(/(https?:\/\/[^\s]+)/);
18307
- const url = urlMatch ? urlMatch[1] : content;
18308
- return {
18309
- background: "",
18310
- created: data2.created,
18311
- data: [{ url }],
18312
- output_format: "",
18313
- quality: "",
18314
- size: "",
18315
- usage: {
18316
- input_tokens: data2.usage?.prompt_tokens || 0,
18317
- input_tokens_details: {
18318
- image_tokens: data2.usage?.prompt_tokens_details?.image_tokens || 0,
18319
- text_tokens: data2.usage?.prompt_tokens_details?.text_tokens || 0
18320
- },
18321
- output_tokens: data2.usage?.completion_tokens || 0,
18322
- output_tokens_details: {
18323
- image_tokens: data2.usage?.completion_tokens_details?.image_tokens || 0,
18324
- text_tokens: data2.usage?.completion_tokens_details?.content_tokens || 0
18325
- },
18326
- total_tokens: data2.usage?.total_tokens || 0
18327
- }
18328
- };
18329
- }
18330
- const { data } = await axios2.post("/v1/images/generations", params);
18331
- return data;
18332
- };
18333
- // src/common/ai/doubao/index.ts
18334
- var exports_doubao2 = {};
18335
- __export(exports_doubao2, {
18336
- vc: () => vc,
18337
- tts: () => tts
18338
- });
18339
-
18340
- // src/common/ai/doubao/tts.ts
18341
- var createReqid2 = () => {
18342
- if (typeof crypto !== "undefined" && typeof crypto.randomUUID === "function") {
18343
- return crypto.randomUUID();
18344
- }
18345
- return `${Date.now()}-${Math.random().toString(16).slice(2)}`;
18346
- };
18347
- var decodeBase64ToArrayBuffer = (value) => {
18348
- if (typeof window !== "undefined" && typeof window.atob === "function") {
18349
- const binary = window.atob(value);
18350
- const bytes = new Uint8Array(binary.length);
18351
- for (let i = 0;i < binary.length; i++) {
18352
- bytes[i] = binary.charCodeAt(i);
18353
- }
18354
- return bytes.buffer;
18355
- }
18356
- const buf = Buffer.from(value, "base64");
18357
- return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
18358
- };
18359
- var tts = async (params) => {
18360
- const { app, user, audio, request } = params;
18361
- const url = "https://openspeech.bytedance.com/api/v3/tts/unidirectional";
18362
- const reqid = request.reqid || createReqid2();
18363
- const speechRate = audio.speed_ratio ? Math.round((audio.speed_ratio - 1) * 100) : 0;
18364
- const loudnessRate = audio.volume_ratio ? Math.round((audio.volume_ratio - 1) * 100) : 0;
18365
- const headers = {
18366
- "X-Api-App-Id": app.appid || "",
18367
- "X-Api-Access-Key": app.accessToken || "",
18368
- "Content-Type": "application/json",
18369
- "X-Api-Resource-Id": app.resourceId || "seed-tts-2.0",
18370
- "X-Api-Request-Id": reqid
18371
- };
18372
- const payload = {
18373
- user: {
18374
- uid: user?.uid || "uid"
18375
- },
18376
- req_params: {
18377
- text: request.text,
18378
- speaker: audio.voice_type,
18379
- audio_params: {
18380
- format: audio.encoding || "pcm",
18381
- sample_rate: 24000,
18382
- speech_rate: speechRate,
18383
- loudness_rate: loudnessRate,
18384
- emotion: audio.emotion,
18385
- emotion_scale: audio.emotion_scale
18386
- }
18387
- }
18388
- };
18389
- if (audio.context_texts) {
18390
- payload.req_params.additions = JSON.stringify({
18391
- context_texts: audio.context_texts
18392
- });
18393
- }
18394
- try {
18395
- const response = await axios_default.post(url, payload, {
18396
- headers,
18397
- responseType: "arraybuffer"
18398
- });
18399
- const responseText = new TextDecoder().decode(response.data);
18400
- const jsonObjects = [];
18401
- let depth = 0;
18402
- let start = 0;
18403
- for (let i = 0;i < responseText.length; i++) {
18404
- if (responseText[i] === "{") {
18405
- if (depth === 0)
18406
- start = i;
18407
- depth++;
18408
- } else if (responseText[i] === "}") {
18409
- depth--;
18410
- if (depth === 0) {
18411
- try {
18412
- const jsonStr = responseText.substring(start, i + 1);
18413
- const jsonObj = JSON.parse(jsonStr);
18414
- jsonObjects.push(jsonObj);
18415
- } catch (e) {
18416
- console.warn("Failed to parse JSON chunk", e);
18417
- }
18418
- }
18419
- }
18420
- }
18421
- if (jsonObjects.length === 0) {
18422
- try {
18423
- jsonObjects.push(JSON.parse(responseText));
18424
- } catch (e) {
18425
- console.error("Doubao TTS Response Parse Error:", responseText);
18426
- throw new Error("Invalid response format");
18427
- }
18428
- }
18429
- const audioChunks = [];
18430
- let totalLength = 0;
18431
- for (const data of jsonObjects) {
18432
- const code = data.code;
18433
- const message = data.message;
18434
- if (typeof code === "number" && code !== 0 && code !== 20000000) {
18435
- console.error("Doubao TTS Error Response:", JSON.stringify(data, null, 2));
18436
- const err = new Error(`豆包语音合成失败: ${message} (code: ${code})`);
18437
- err.code = code;
18438
- err.reqid = data.reqid;
18439
- throw err;
18440
- }
18441
- if (data.data) {
18442
- const chunkBuffer = decodeBase64ToArrayBuffer(data.data);
18443
- audioChunks.push(chunkBuffer);
18444
- totalLength += chunkBuffer.byteLength;
18445
- }
18446
- }
18447
- if (totalLength === 0) {
18448
- throw new Error("豆包语音合成失败:未返回音频数据");
18449
- }
18450
- const resultBuffer = new Uint8Array(totalLength);
18451
- let offset = 0;
18452
- for (const chunk of audioChunks) {
18453
- resultBuffer.set(new Uint8Array(chunk), offset);
18454
- offset += chunk.byteLength;
18455
- }
18456
- return resultBuffer.buffer;
18457
- } catch (error) {
18458
- if (error.response) {
18459
- try {
18460
- let errorData = error.response.data;
18461
- if (errorData instanceof ArrayBuffer || typeof Buffer !== "undefined" && Buffer.isBuffer(errorData)) {
18462
- errorData = new TextDecoder().decode(errorData);
18463
- } else if (typeof errorData === "object") {
18464
- errorData = JSON.stringify(errorData);
18465
- }
18466
- throw new Error(`Doubao TTS Error: ${error.response.status} - ${errorData}`);
18467
- } catch (e) {
18468
- if (e.message && e.message.startsWith("Doubao TTS Error")) {
18469
- throw e;
18470
- }
18471
- throw new Error(`Doubao TTS Error: ${error.response.status} ${error.message}`);
18472
- }
18473
- }
18474
- throw error;
18475
- }
18476
- };
18477
- // src/common/ai/doubao/vc.ts
18478
- var getHeaders = (accessToken, contentType) => {
18479
- const headers = {
18480
- Authorization: `Bearer; ${accessToken}`
18481
- };
18482
- if (contentType) {
18483
- headers["content-type"] = contentType;
18484
- }
18485
- return headers;
18486
- };
18487
- var handleResponse = (data) => {
18488
- if (data instanceof ArrayBuffer) {
18489
- return data;
18490
- }
18491
- if (typeof Buffer !== "undefined" && Buffer.isBuffer(data)) {
18492
- return data.buffer.slice(data.byteOffset, data.byteOffset + data.byteLength);
18493
- }
18494
- return data;
18495
- };
18496
- var vc = {
18497
- submit: async (params) => {
18498
- const { app, audio, options = {} } = params;
18499
- const url = new URL("https://openspeech.bytedance.com/api/v1/vc/submit");
18500
- url.searchParams.set("appid", app.appid);
18501
- Object.entries(options).forEach(([key2, value]) => {
18502
- if (value !== undefined && value !== null) {
18503
- url.searchParams.set(key2, String(value));
18504
- }
18505
- });
18506
- const response = await axios_default.post(url.toString(), audio.data, {
18507
- headers: getHeaders(app.accessToken, audio.contentType || "audio/wav"),
18508
- responseType: "arraybuffer"
18509
- });
18510
- return handleResponse(response.data);
18511
- },
18512
- query: async (params) => {
18513
- const { app, id, blocking } = params;
18514
- const url = new URL("https://openspeech.bytedance.com/api/v1/vc/query");
18515
- url.searchParams.set("appid", app.appid);
18516
- url.searchParams.set("id", id);
18517
- if (blocking !== undefined) {
18518
- url.searchParams.set("blocking", String(blocking));
18519
- }
18520
- const response = await axios_default.get(url.toString(), {
18521
- headers: getHeaders(app.accessToken),
18522
- responseType: "arraybuffer"
18523
- });
18524
- return handleResponse(response.data);
18119
+ throw new Error(error?.response?.statusText || error?.message || "未知原因");
18525
18120
  }
18526
18121
  };
18527
- // src/common/ai/keling/index.ts
18528
- var exports_keling = {};
18529
- __export(exports_keling, {
18530
- setCookie: () => setCookie,
18531
- getVideoStatus: () => getVideoStatus,
18532
- generateVideo: () => generateVideo
18533
- });
18534
-
18535
18122
  // node:url
18536
18123
  var { URL: J, URLSearchParams: X } = globalThis;
18537
18124
  function F(s) {
@@ -19152,2799 +18739,120 @@ var generateVideo = async (imageUrl, prompt) => {
19152
18739
  console.log(666, "任务 id", taskId);
19153
18740
  return taskId;
19154
18741
  };
19155
- // src/common/base/string.ts
19156
- var getChineseByStr = (str) => {
19157
- if (!str) {
19158
- return "";
19159
- }
19160
- const match = str.match(/[\u4e00-\u9fa5]/g);
19161
- if (!match) {
19162
- return "";
19163
- }
19164
- return match.join("");
19165
- };
19166
- var getStrLength = (value) => {
19167
- if (!value) {
19168
- return 0;
18742
+ // src/common/image.ts
18743
+ async function imageToBase64(url) {
18744
+ try {
18745
+ const response = await axios_default.get(url, {
18746
+ responseType: "arraybuffer"
18747
+ });
18748
+ const base64String = Buffer.from(response.data).toString("base64");
18749
+ return `data:image/*;base64,${base64String}`;
18750
+ } catch (error) {
18751
+ console.error("Failed to fetch the image:", error);
18752
+ throw error;
19169
18753
  }
19170
- const chineseLength = getChineseByStr(value).length;
19171
- return value.length - chineseLength + chineseLength * 2;
19172
- };
19173
- var replaceAll = (str, searchValue, replaceValue) => {
19174
- if (!str || !searchValue || !replaceValue) {
19175
- return str || "";
18754
+ }
18755
+ // src/common/enum.ts
18756
+ class EnumItem {
18757
+ label;
18758
+ value;
18759
+ extra;
18760
+ constructor(config) {
18761
+ this.value = config.value;
18762
+ this.label = config.label;
18763
+ this.extra = config.extra;
19176
18764
  }
19177
- str = str.replace(searchValue, replaceValue);
19178
- if (!str.includes(searchValue)) {
19179
- return str;
18765
+ }
18766
+ var Enum = {
18767
+ create: (members) => {
18768
+ const usedValues = new Set;
18769
+ const enumObj = {};
18770
+ const map = new Map;
18771
+ const options = [];
18772
+ const extras = new Map;
18773
+ const labels = new Map;
18774
+ const enums = {};
18775
+ for (const key2 in members) {
18776
+ const member = members[key2];
18777
+ if (!member)
18778
+ continue;
18779
+ if (usedValues.has(member.value)) {
18780
+ throw new Error(`Duplicate enum value detected: ${member.value}`);
18781
+ }
18782
+ usedValues.add(member.value);
18783
+ const item = new EnumItem(member);
18784
+ enumObj[key2] = item;
18785
+ map.set(item.value, item);
18786
+ labels.set(item.value, item.label);
18787
+ options.push(item);
18788
+ enums[item.value] = { text: item.label, status: item.extra?.status };
18789
+ if (member.extra !== undefined) {
18790
+ extras.set(item.value, { ...member.extra });
18791
+ }
18792
+ }
18793
+ enumObj.map = map;
18794
+ enumObj.options = options;
18795
+ enumObj.extras = extras;
18796
+ enumObj.source = members;
18797
+ enumObj.labels = labels;
18798
+ enumObj.enums = enums;
18799
+ return enumObj;
19180
18800
  }
19181
- return replaceAll(str, searchValue, replaceValue);
19182
18801
  };
19183
- var replaceByRules = (str, rules) => {
19184
- rules.forEach(([searchValue, replaceValue]) => {
19185
- str = str.replaceAll(searchValue, replaceValue);
18802
+ // src/common/dayjs.ts
18803
+ var import_dayjs = __toESM(require_dayjs_min(), 1);
18804
+ var import_isBetween = __toESM(require_isBetween(), 1);
18805
+ var import_weekday = __toESM(require_weekday(), 1);
18806
+ var import_localeData = __toESM(require_localeData(), 1);
18807
+ var import_isoWeek = __toESM(require_isoWeek(), 1);
18808
+ var import_updateLocale = __toESM(require_updateLocale(), 1);
18809
+ var import_timezone = __toESM(require_timezone(), 1);
18810
+ var import_isSameOrAfter = __toESM(require_isSameOrAfter(), 1);
18811
+ var import_isSameOrBefore = __toESM(require_isSameOrBefore(), 1);
18812
+ var import_utc = __toESM(require_utc(), 1);
18813
+ var import_zh_cn = __toESM(require_zh_cn(), 1);
18814
+ var import_dayjs2 = __toESM(require_dayjs_min(), 1);
18815
+ import_dayjs.default.extend(import_utc.default);
18816
+ import_dayjs.default.extend(import_isBetween.default);
18817
+ import_dayjs.default.extend(import_weekday.default);
18818
+ import_dayjs.default.extend(import_localeData.default);
18819
+ import_dayjs.default.extend(import_isoWeek.default);
18820
+ import_dayjs.default.extend(import_updateLocale.default);
18821
+ import_dayjs.default.extend(import_timezone.default);
18822
+ import_dayjs.default.extend(import_isSameOrAfter.default);
18823
+ import_dayjs.default.extend(import_isSameOrBefore.default);
18824
+ var Timezone;
18825
+ ((Timezone2) => {
18826
+ Timezone2["AsiaShanghai"] = "Asia/Shanghai";
18827
+ Timezone2["AsiaTokyo"] = "Asia/Tokyo";
18828
+ Timezone2["AmericaNewYork"] = "America/New_York";
18829
+ Timezone2["EuropeLondon"] = "Europe/London";
18830
+ Timezone2["EuropeBerlin"] = "Europe/Berlin";
18831
+ })(Timezone ||= {});
18832
+ var initChinaDayjs = () => {
18833
+ import_dayjs.default.locale("zh-cn");
18834
+ import_dayjs.default.tz.setDefault("Asia/Shanghai" /* AsiaShanghai */);
18835
+ import_dayjs.default.updateLocale("zh-cn", {
18836
+ weekStart: 1
19186
18837
  });
19187
- return str;
18838
+ return import_dayjs.default;
19188
18839
  };
19189
- var replaceByVariables = (prompt, variables) => {
19190
- if (!variables || Object.keys(variables).length === 0) {
19191
- return prompt;
18840
+ var chinaDayjs = initChinaDayjs();
18841
+ var dayjs_default = import_dayjs.default;
18842
+ // src/web/element.ts
18843
+ var scrollIntoView = (el, option) => {
18844
+ if (!el) {
18845
+ return;
19192
18846
  }
19193
- const regex = /\{\{\s*(\w+)\s*\}\}/g;
19194
- return prompt.replace(regex, (match, p1) => {
19195
- return variables[p1] ?? match;
19196
- });
19197
- };
19198
- var getType = (value) => {
19199
- return Object.prototype.toString.call(value).slice(8, -1);
19200
- };
19201
- var amount = (str) => {
19202
- const reg = /(?=(?!\b)(\d{3})+$)/g;
19203
- return str.replace(reg, ",");
18847
+ el.scrollIntoView({ behavior: "smooth", block: "start", ...option });
19204
18848
  };
19205
- var jsonParse = (value) => {
19206
- if (typeof value === "object") {
19207
- return value;
19208
- }
19209
- try {
19210
- return JSON.parse(value);
19211
- } catch (err) {
19212
- return {};
19213
- }
19214
- };
19215
- var isJson = (str) => {
19216
- try {
19217
- if (getType(JSON.parse(str)) === "Object") {
19218
- return true;
19219
- }
19220
- } catch (e) {}
19221
- return false;
19222
- };
19223
- var toString3 = (value) => {
19224
- return Object.prototype.toString.call(value).slice(8, -1) === "object" ? JSON.stringify(value) : String(value);
19225
- };
19226
- var getRandomColor = () => {
19227
- const color = Math.floor(Math.random() * 16777215).toString(16);
19228
- if (color.length === 6) {
19229
- return color;
19230
- } else {
19231
- return getRandomColor();
19232
- }
19233
- };
19234
- var getRandomString = (length = 4) => {
19235
- return Math.random().toString(36).substr(2, length);
19236
- };
19237
- var getChinese = (str) => {
19238
- if (str == null || str === "") {
19239
- return "";
19240
- }
19241
- const res = str.match(/[\u4e00-\u9fa5]/g);
19242
- if (!res) {
19243
- return "";
19244
- }
19245
- return res.join("");
19246
- };
19247
- var getSliceStr = (str, before, after) => {
19248
- return str.slice(str.indexOf(before) + before.length, str.lastIndexOf(after));
19249
- };
19250
- var getProxyUrl = (url) => {
19251
- const beforeUrl = "https://1141871752167714.cn-hangzhou.fc.aliyuncs.com/2016-08-15/proxy/a.LATEST/proxy/?url=";
19252
- return beforeUrl + url;
19253
- };
19254
- var getLength = (value) => {
19255
- const chineseLength = getChinese(value).length;
19256
- return value.length - chineseLength + chineseLength * 2;
19257
- };
19258
- var getCookie = (name) => {
19259
- const reg = new RegExp(`(^| )${name}=([^;]*)(;|$)`);
19260
- const arr = document.cookie.match(reg);
19261
- return arr ? unescape(arr[2]) : null;
19262
- };
19263
- var generateAlphabetArray = (n) => {
19264
- return Array.from({ length: n }, (_2, i) => String.fromCharCode(97 + i));
19265
- };
19266
- var levenshteinDistance = (a, b) => {
19267
- const matrix = [];
19268
- for (let i = 0;i <= b.length; i++) {
19269
- matrix[i] = [i];
19270
- }
19271
- for (let j3 = 0;j3 <= a.length; j3++) {
19272
- matrix[0][j3] = j3;
19273
- }
19274
- for (let i = 1;i <= b.length; i++) {
19275
- for (let j3 = 1;j3 <= a.length; j3++) {
19276
- if (b[i - 1] === a[j3 - 1]) {
19277
- matrix[i][j3] = matrix[i - 1][j3 - 1];
19278
- } else {
19279
- matrix[i][j3] = Math.min(matrix[i - 1][j3 - 1] + 1, matrix[i][j3 - 1] + 1, matrix[i - 1][j3] + 1);
19280
- }
19281
- }
19282
- }
19283
- return matrix[b.length][a.length];
19284
- };
19285
- var generateUniqueFileName = (name) => {
19286
- const match = name.match(/^(.*?)(\.[^.]*$|$)/);
19287
- if (match) {
19288
- const namePart = match[1];
19289
- const extensionPart = match[2];
19290
- if (extensionPart) {
19291
- return `${namePart}_${Date.now()}${extensionPart}`;
19292
- } else {
19293
- return `${namePart}_${Date.now()}.dat`;
19294
- }
19295
- }
19296
- throw new Error("Invalid filename format.");
19297
- };
19298
-
19299
- // ../../node_modules/decimal.js/decimal.mjs
19300
- /*!
19301
- * decimal.js v10.6.0
19302
- * An arbitrary-precision Decimal type for JavaScript.
19303
- * https://github.com/MikeMcl/decimal.js
19304
- * Copyright (c) 2025 Michael Mclaughlin <M8ch88l@gmail.com>
19305
- * MIT Licence
19306
- */
19307
- var EXP_LIMIT = 9000000000000000;
19308
- var MAX_DIGITS = 1e9;
19309
- var NUMERALS = "0123456789abcdef";
19310
- var LN10 = "2.3025850929940456840179914546843642076011014886287729760333279009675726096773524802359972050895982983419677840422862486334095254650828067566662873690987816894829072083255546808437998948262331985283935053089653777326288461633662222876982198867465436674744042432743651550489343149393914796194044002221051017141748003688084012647080685567743216228355220114804663715659121373450747856947683463616792101806445070648000277502684916746550586856935673420670581136429224554405758925724208241314695689016758940256776311356919292033376587141660230105703089634572075440370847469940168269282808481184289314848524948644871927809676271275775397027668605952496716674183485704422507197965004714951050492214776567636938662976979522110718264549734772662425709429322582798502585509785265383207606726317164309505995087807523710333101197857547331541421808427543863591778117054309827482385045648019095610299291824318237525357709750539565187697510374970888692180205189339507238539205144634197265287286965110862571492198849978748873771345686209167058";
19311
- var PI = "3.1415926535897932384626433832795028841971693993751058209749445923078164062862089986280348253421170679821480865132823066470938446095505822317253594081284811174502841027019385211055596446229489549303819644288109756659334461284756482337867831652712019091456485669234603486104543266482133936072602491412737245870066063155881748815209209628292540917153643678925903600113305305488204665213841469519415116094330572703657595919530921861173819326117931051185480744623799627495673518857527248912279381830119491298336733624406566430860213949463952247371907021798609437027705392171762931767523846748184676694051320005681271452635608277857713427577896091736371787214684409012249534301465495853710507922796892589235420199561121290219608640344181598136297747713099605187072113499999983729780499510597317328160963185950244594553469083026425223082533446850352619311881710100031378387528865875332083814206171776691473035982534904287554687311595628638823537875937519577818577805321712268066130019278766111959092164201989380952572010654858632789";
19312
- var DEFAULTS = {
19313
- precision: 20,
19314
- rounding: 4,
19315
- modulo: 1,
19316
- toExpNeg: -7,
19317
- toExpPos: 21,
19318
- minE: -EXP_LIMIT,
19319
- maxE: EXP_LIMIT,
19320
- crypto: false
19321
- };
19322
- var inexact;
19323
- var quadrant;
19324
- var external2 = true;
19325
- var decimalError = "[DecimalError] ";
19326
- var invalidArgument = decimalError + "Invalid argument: ";
19327
- var precisionLimitExceeded = decimalError + "Precision limit exceeded";
19328
- var cryptoUnavailable = decimalError + "crypto unavailable";
19329
- var tag = "[object Decimal]";
19330
- var mathfloor = Math.floor;
19331
- var mathpow = Math.pow;
19332
- var isBinary = /^0b([01]+(\.[01]*)?|\.[01]+)(p[+-]?\d+)?$/i;
19333
- var isHex = /^0x([0-9a-f]+(\.[0-9a-f]*)?|\.[0-9a-f]+)(p[+-]?\d+)?$/i;
19334
- var isOctal = /^0o([0-7]+(\.[0-7]*)?|\.[0-7]+)(p[+-]?\d+)?$/i;
19335
- var isDecimal = /^(\d+(\.\d*)?|\.\d+)(e[+-]?\d+)?$/i;
19336
- var BASE = 1e7;
19337
- var LOG_BASE = 7;
19338
- var MAX_SAFE_INTEGER = 9007199254740991;
19339
- var LN10_PRECISION = LN10.length - 1;
19340
- var PI_PRECISION = PI.length - 1;
19341
- var P2 = { toStringTag: tag };
19342
- P2.absoluteValue = P2.abs = function() {
19343
- var x2 = new this.constructor(this);
19344
- if (x2.s < 0)
19345
- x2.s = 1;
19346
- return finalise(x2);
19347
- };
19348
- P2.ceil = function() {
19349
- return finalise(new this.constructor(this), this.e + 1, 2);
19350
- };
19351
- P2.clampedTo = P2.clamp = function(min, max) {
19352
- var k3, x2 = this, Ctor = x2.constructor;
19353
- min = new Ctor(min);
19354
- max = new Ctor(max);
19355
- if (!min.s || !max.s)
19356
- return new Ctor(NaN);
19357
- if (min.gt(max))
19358
- throw Error(invalidArgument + max);
19359
- k3 = x2.cmp(min);
19360
- return k3 < 0 ? min : x2.cmp(max) > 0 ? max : new Ctor(x2);
19361
- };
19362
- P2.comparedTo = P2.cmp = function(y2) {
19363
- var i, j3, xdL, ydL, x2 = this, xd = x2.d, yd = (y2 = new x2.constructor(y2)).d, xs = x2.s, ys = y2.s;
19364
- if (!xd || !yd) {
19365
- return !xs || !ys ? NaN : xs !== ys ? xs : xd === yd ? 0 : !xd ^ xs < 0 ? 1 : -1;
19366
- }
19367
- if (!xd[0] || !yd[0])
19368
- return xd[0] ? xs : yd[0] ? -ys : 0;
19369
- if (xs !== ys)
19370
- return xs;
19371
- if (x2.e !== y2.e)
19372
- return x2.e > y2.e ^ xs < 0 ? 1 : -1;
19373
- xdL = xd.length;
19374
- ydL = yd.length;
19375
- for (i = 0, j3 = xdL < ydL ? xdL : ydL;i < j3; ++i) {
19376
- if (xd[i] !== yd[i])
19377
- return xd[i] > yd[i] ^ xs < 0 ? 1 : -1;
19378
- }
19379
- return xdL === ydL ? 0 : xdL > ydL ^ xs < 0 ? 1 : -1;
19380
- };
19381
- P2.cosine = P2.cos = function() {
19382
- var pr, rm, x2 = this, Ctor = x2.constructor;
19383
- if (!x2.d)
19384
- return new Ctor(NaN);
19385
- if (!x2.d[0])
19386
- return new Ctor(1);
19387
- pr = Ctor.precision;
19388
- rm = Ctor.rounding;
19389
- Ctor.precision = pr + Math.max(x2.e, x2.sd()) + LOG_BASE;
19390
- Ctor.rounding = 1;
19391
- x2 = cosine(Ctor, toLessThanHalfPi(Ctor, x2));
19392
- Ctor.precision = pr;
19393
- Ctor.rounding = rm;
19394
- return finalise(quadrant == 2 || quadrant == 3 ? x2.neg() : x2, pr, rm, true);
19395
- };
19396
- P2.cubeRoot = P2.cbrt = function() {
19397
- var e, m2, n, r, rep, s, sd, t, t3, t3plusx, x2 = this, Ctor = x2.constructor;
19398
- if (!x2.isFinite() || x2.isZero())
19399
- return new Ctor(x2);
19400
- external2 = false;
19401
- s = x2.s * mathpow(x2.s * x2, 1 / 3);
19402
- if (!s || Math.abs(s) == 1 / 0) {
19403
- n = digitsToString(x2.d);
19404
- e = x2.e;
19405
- if (s = (e - n.length + 1) % 3)
19406
- n += s == 1 || s == -2 ? "0" : "00";
19407
- s = mathpow(n, 1 / 3);
19408
- e = mathfloor((e + 1) / 3) - (e % 3 == (e < 0 ? -1 : 2));
19409
- if (s == 1 / 0) {
19410
- n = "5e" + e;
19411
- } else {
19412
- n = s.toExponential();
19413
- n = n.slice(0, n.indexOf("e") + 1) + e;
19414
- }
19415
- r = new Ctor(n);
19416
- r.s = x2.s;
19417
- } else {
19418
- r = new Ctor(s.toString());
19419
- }
19420
- sd = (e = Ctor.precision) + 3;
19421
- for (;; ) {
19422
- t = r;
19423
- t3 = t.times(t).times(t);
19424
- t3plusx = t3.plus(x2);
19425
- r = divide(t3plusx.plus(x2).times(t), t3plusx.plus(t3), sd + 2, 1);
19426
- if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {
19427
- n = n.slice(sd - 3, sd + 1);
19428
- if (n == "9999" || !rep && n == "4999") {
19429
- if (!rep) {
19430
- finalise(t, e + 1, 0);
19431
- if (t.times(t).times(t).eq(x2)) {
19432
- r = t;
19433
- break;
19434
- }
19435
- }
19436
- sd += 4;
19437
- rep = 1;
19438
- } else {
19439
- if (!+n || !+n.slice(1) && n.charAt(0) == "5") {
19440
- finalise(r, e + 1, 1);
19441
- m2 = !r.times(r).times(r).eq(x2);
19442
- }
19443
- break;
19444
- }
19445
- }
19446
- }
19447
- external2 = true;
19448
- return finalise(r, e, Ctor.rounding, m2);
19449
- };
19450
- P2.decimalPlaces = P2.dp = function() {
19451
- var w2, d = this.d, n = NaN;
19452
- if (d) {
19453
- w2 = d.length - 1;
19454
- n = (w2 - mathfloor(this.e / LOG_BASE)) * LOG_BASE;
19455
- w2 = d[w2];
19456
- if (w2)
19457
- for (;w2 % 10 == 0; w2 /= 10)
19458
- n--;
19459
- if (n < 0)
19460
- n = 0;
19461
- }
19462
- return n;
19463
- };
19464
- P2.dividedBy = P2.div = function(y2) {
19465
- return divide(this, new this.constructor(y2));
19466
- };
19467
- P2.dividedToIntegerBy = P2.divToInt = function(y2) {
19468
- var x2 = this, Ctor = x2.constructor;
19469
- return finalise(divide(x2, new Ctor(y2), 0, 1, 1), Ctor.precision, Ctor.rounding);
19470
- };
19471
- P2.equals = P2.eq = function(y2) {
19472
- return this.cmp(y2) === 0;
19473
- };
19474
- P2.floor = function() {
19475
- return finalise(new this.constructor(this), this.e + 1, 3);
19476
- };
19477
- P2.greaterThan = P2.gt = function(y2) {
19478
- return this.cmp(y2) > 0;
19479
- };
19480
- P2.greaterThanOrEqualTo = P2.gte = function(y2) {
19481
- var k3 = this.cmp(y2);
19482
- return k3 == 1 || k3 === 0;
19483
- };
19484
- P2.hyperbolicCosine = P2.cosh = function() {
19485
- var k3, n, pr, rm, len, x2 = this, Ctor = x2.constructor, one = new Ctor(1);
19486
- if (!x2.isFinite())
19487
- return new Ctor(x2.s ? 1 / 0 : NaN);
19488
- if (x2.isZero())
19489
- return one;
19490
- pr = Ctor.precision;
19491
- rm = Ctor.rounding;
19492
- Ctor.precision = pr + Math.max(x2.e, x2.sd()) + 4;
19493
- Ctor.rounding = 1;
19494
- len = x2.d.length;
19495
- if (len < 32) {
19496
- k3 = Math.ceil(len / 3);
19497
- n = (1 / tinyPow(4, k3)).toString();
19498
- } else {
19499
- k3 = 16;
19500
- n = "2.3283064365386962890625e-10";
19501
- }
19502
- x2 = taylorSeries(Ctor, 1, x2.times(n), new Ctor(1), true);
19503
- var cosh2_x, i = k3, d8 = new Ctor(8);
19504
- for (;i--; ) {
19505
- cosh2_x = x2.times(x2);
19506
- x2 = one.minus(cosh2_x.times(d8.minus(cosh2_x.times(d8))));
19507
- }
19508
- return finalise(x2, Ctor.precision = pr, Ctor.rounding = rm, true);
19509
- };
19510
- P2.hyperbolicSine = P2.sinh = function() {
19511
- var k3, pr, rm, len, x2 = this, Ctor = x2.constructor;
19512
- if (!x2.isFinite() || x2.isZero())
19513
- return new Ctor(x2);
19514
- pr = Ctor.precision;
19515
- rm = Ctor.rounding;
19516
- Ctor.precision = pr + Math.max(x2.e, x2.sd()) + 4;
19517
- Ctor.rounding = 1;
19518
- len = x2.d.length;
19519
- if (len < 3) {
19520
- x2 = taylorSeries(Ctor, 2, x2, x2, true);
19521
- } else {
19522
- k3 = 1.4 * Math.sqrt(len);
19523
- k3 = k3 > 16 ? 16 : k3 | 0;
19524
- x2 = x2.times(1 / tinyPow(5, k3));
19525
- x2 = taylorSeries(Ctor, 2, x2, x2, true);
19526
- var sinh2_x, d5 = new Ctor(5), d16 = new Ctor(16), d20 = new Ctor(20);
19527
- for (;k3--; ) {
19528
- sinh2_x = x2.times(x2);
19529
- x2 = x2.times(d5.plus(sinh2_x.times(d16.times(sinh2_x).plus(d20))));
19530
- }
19531
- }
19532
- Ctor.precision = pr;
19533
- Ctor.rounding = rm;
19534
- return finalise(x2, pr, rm, true);
19535
- };
19536
- P2.hyperbolicTangent = P2.tanh = function() {
19537
- var pr, rm, x2 = this, Ctor = x2.constructor;
19538
- if (!x2.isFinite())
19539
- return new Ctor(x2.s);
19540
- if (x2.isZero())
19541
- return new Ctor(x2);
19542
- pr = Ctor.precision;
19543
- rm = Ctor.rounding;
19544
- Ctor.precision = pr + 7;
19545
- Ctor.rounding = 1;
19546
- return divide(x2.sinh(), x2.cosh(), Ctor.precision = pr, Ctor.rounding = rm);
19547
- };
19548
- P2.inverseCosine = P2.acos = function() {
19549
- var x2 = this, Ctor = x2.constructor, k3 = x2.abs().cmp(1), pr = Ctor.precision, rm = Ctor.rounding;
19550
- if (k3 !== -1) {
19551
- return k3 === 0 ? x2.isNeg() ? getPi(Ctor, pr, rm) : new Ctor(0) : new Ctor(NaN);
19552
- }
19553
- if (x2.isZero())
19554
- return getPi(Ctor, pr + 4, rm).times(0.5);
19555
- Ctor.precision = pr + 6;
19556
- Ctor.rounding = 1;
19557
- x2 = new Ctor(1).minus(x2).div(x2.plus(1)).sqrt().atan();
19558
- Ctor.precision = pr;
19559
- Ctor.rounding = rm;
19560
- return x2.times(2);
19561
- };
19562
- P2.inverseHyperbolicCosine = P2.acosh = function() {
19563
- var pr, rm, x2 = this, Ctor = x2.constructor;
19564
- if (x2.lte(1))
19565
- return new Ctor(x2.eq(1) ? 0 : NaN);
19566
- if (!x2.isFinite())
19567
- return new Ctor(x2);
19568
- pr = Ctor.precision;
19569
- rm = Ctor.rounding;
19570
- Ctor.precision = pr + Math.max(Math.abs(x2.e), x2.sd()) + 4;
19571
- Ctor.rounding = 1;
19572
- external2 = false;
19573
- x2 = x2.times(x2).minus(1).sqrt().plus(x2);
19574
- external2 = true;
19575
- Ctor.precision = pr;
19576
- Ctor.rounding = rm;
19577
- return x2.ln();
19578
- };
19579
- P2.inverseHyperbolicSine = P2.asinh = function() {
19580
- var pr, rm, x2 = this, Ctor = x2.constructor;
19581
- if (!x2.isFinite() || x2.isZero())
19582
- return new Ctor(x2);
19583
- pr = Ctor.precision;
19584
- rm = Ctor.rounding;
19585
- Ctor.precision = pr + 2 * Math.max(Math.abs(x2.e), x2.sd()) + 6;
19586
- Ctor.rounding = 1;
19587
- external2 = false;
19588
- x2 = x2.times(x2).plus(1).sqrt().plus(x2);
19589
- external2 = true;
19590
- Ctor.precision = pr;
19591
- Ctor.rounding = rm;
19592
- return x2.ln();
19593
- };
19594
- P2.inverseHyperbolicTangent = P2.atanh = function() {
19595
- var pr, rm, wpr, xsd, x2 = this, Ctor = x2.constructor;
19596
- if (!x2.isFinite())
19597
- return new Ctor(NaN);
19598
- if (x2.e >= 0)
19599
- return new Ctor(x2.abs().eq(1) ? x2.s / 0 : x2.isZero() ? x2 : NaN);
19600
- pr = Ctor.precision;
19601
- rm = Ctor.rounding;
19602
- xsd = x2.sd();
19603
- if (Math.max(xsd, pr) < 2 * -x2.e - 1)
19604
- return finalise(new Ctor(x2), pr, rm, true);
19605
- Ctor.precision = wpr = xsd - x2.e;
19606
- x2 = divide(x2.plus(1), new Ctor(1).minus(x2), wpr + pr, 1);
19607
- Ctor.precision = pr + 4;
19608
- Ctor.rounding = 1;
19609
- x2 = x2.ln();
19610
- Ctor.precision = pr;
19611
- Ctor.rounding = rm;
19612
- return x2.times(0.5);
19613
- };
19614
- P2.inverseSine = P2.asin = function() {
19615
- var halfPi, k3, pr, rm, x2 = this, Ctor = x2.constructor;
19616
- if (x2.isZero())
19617
- return new Ctor(x2);
19618
- k3 = x2.abs().cmp(1);
19619
- pr = Ctor.precision;
19620
- rm = Ctor.rounding;
19621
- if (k3 !== -1) {
19622
- if (k3 === 0) {
19623
- halfPi = getPi(Ctor, pr + 4, rm).times(0.5);
19624
- halfPi.s = x2.s;
19625
- return halfPi;
19626
- }
19627
- return new Ctor(NaN);
19628
- }
19629
- Ctor.precision = pr + 6;
19630
- Ctor.rounding = 1;
19631
- x2 = x2.div(new Ctor(1).minus(x2.times(x2)).sqrt().plus(1)).atan();
19632
- Ctor.precision = pr;
19633
- Ctor.rounding = rm;
19634
- return x2.times(2);
19635
- };
19636
- P2.inverseTangent = P2.atan = function() {
19637
- var i, j3, k3, n, px, t, r, wpr, x2, x3 = this, Ctor = x3.constructor, pr = Ctor.precision, rm = Ctor.rounding;
19638
- if (!x3.isFinite()) {
19639
- if (!x3.s)
19640
- return new Ctor(NaN);
19641
- if (pr + 4 <= PI_PRECISION) {
19642
- r = getPi(Ctor, pr + 4, rm).times(0.5);
19643
- r.s = x3.s;
19644
- return r;
19645
- }
19646
- } else if (x3.isZero()) {
19647
- return new Ctor(x3);
19648
- } else if (x3.abs().eq(1) && pr + 4 <= PI_PRECISION) {
19649
- r = getPi(Ctor, pr + 4, rm).times(0.25);
19650
- r.s = x3.s;
19651
- return r;
19652
- }
19653
- Ctor.precision = wpr = pr + 10;
19654
- Ctor.rounding = 1;
19655
- k3 = Math.min(28, wpr / LOG_BASE + 2 | 0);
19656
- for (i = k3;i; --i)
19657
- x3 = x3.div(x3.times(x3).plus(1).sqrt().plus(1));
19658
- external2 = false;
19659
- j3 = Math.ceil(wpr / LOG_BASE);
19660
- n = 1;
19661
- x2 = x3.times(x3);
19662
- r = new Ctor(x3);
19663
- px = x3;
19664
- for (;i !== -1; ) {
19665
- px = px.times(x2);
19666
- t = r.minus(px.div(n += 2));
19667
- px = px.times(x2);
19668
- r = t.plus(px.div(n += 2));
19669
- if (r.d[j3] !== undefined)
19670
- for (i = j3;r.d[i] === t.d[i] && i--; )
19671
- ;
19672
- }
19673
- if (k3)
19674
- r = r.times(2 << k3 - 1);
19675
- external2 = true;
19676
- return finalise(r, Ctor.precision = pr, Ctor.rounding = rm, true);
19677
- };
19678
- P2.isFinite = function() {
19679
- return !!this.d;
19680
- };
19681
- P2.isInteger = P2.isInt = function() {
19682
- return !!this.d && mathfloor(this.e / LOG_BASE) > this.d.length - 2;
19683
- };
19684
- P2.isNaN = function() {
19685
- return !this.s;
19686
- };
19687
- P2.isNegative = P2.isNeg = function() {
19688
- return this.s < 0;
19689
- };
19690
- P2.isPositive = P2.isPos = function() {
19691
- return this.s > 0;
19692
- };
19693
- P2.isZero = function() {
19694
- return !!this.d && this.d[0] === 0;
19695
- };
19696
- P2.lessThan = P2.lt = function(y2) {
19697
- return this.cmp(y2) < 0;
19698
- };
19699
- P2.lessThanOrEqualTo = P2.lte = function(y2) {
19700
- return this.cmp(y2) < 1;
19701
- };
19702
- P2.logarithm = P2.log = function(base) {
19703
- var isBase10, d, denominator, k3, inf, num, sd, r, arg = this, Ctor = arg.constructor, pr = Ctor.precision, rm = Ctor.rounding, guard = 5;
19704
- if (base == null) {
19705
- base = new Ctor(10);
19706
- isBase10 = true;
19707
- } else {
19708
- base = new Ctor(base);
19709
- d = base.d;
19710
- if (base.s < 0 || !d || !d[0] || base.eq(1))
19711
- return new Ctor(NaN);
19712
- isBase10 = base.eq(10);
19713
- }
19714
- d = arg.d;
19715
- if (arg.s < 0 || !d || !d[0] || arg.eq(1)) {
19716
- return new Ctor(d && !d[0] ? -1 / 0 : arg.s != 1 ? NaN : d ? 0 : 1 / 0);
19717
- }
19718
- if (isBase10) {
19719
- if (d.length > 1) {
19720
- inf = true;
19721
- } else {
19722
- for (k3 = d[0];k3 % 10 === 0; )
19723
- k3 /= 10;
19724
- inf = k3 !== 1;
19725
- }
19726
- }
19727
- external2 = false;
19728
- sd = pr + guard;
19729
- num = naturalLogarithm(arg, sd);
19730
- denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);
19731
- r = divide(num, denominator, sd, 1);
19732
- if (checkRoundingDigits(r.d, k3 = pr, rm)) {
19733
- do {
19734
- sd += 10;
19735
- num = naturalLogarithm(arg, sd);
19736
- denominator = isBase10 ? getLn10(Ctor, sd + 10) : naturalLogarithm(base, sd);
19737
- r = divide(num, denominator, sd, 1);
19738
- if (!inf) {
19739
- if (+digitsToString(r.d).slice(k3 + 1, k3 + 15) + 1 == 100000000000000) {
19740
- r = finalise(r, pr + 1, 0);
19741
- }
19742
- break;
19743
- }
19744
- } while (checkRoundingDigits(r.d, k3 += 10, rm));
19745
- }
19746
- external2 = true;
19747
- return finalise(r, pr, rm);
19748
- };
19749
- P2.minus = P2.sub = function(y2) {
19750
- var d, e, i, j3, k3, len, pr, rm, xd, xe, xLTy, yd, x2 = this, Ctor = x2.constructor;
19751
- y2 = new Ctor(y2);
19752
- if (!x2.d || !y2.d) {
19753
- if (!x2.s || !y2.s)
19754
- y2 = new Ctor(NaN);
19755
- else if (x2.d)
19756
- y2.s = -y2.s;
19757
- else
19758
- y2 = new Ctor(y2.d || x2.s !== y2.s ? x2 : NaN);
19759
- return y2;
19760
- }
19761
- if (x2.s != y2.s) {
19762
- y2.s = -y2.s;
19763
- return x2.plus(y2);
19764
- }
19765
- xd = x2.d;
19766
- yd = y2.d;
19767
- pr = Ctor.precision;
19768
- rm = Ctor.rounding;
19769
- if (!xd[0] || !yd[0]) {
19770
- if (yd[0])
19771
- y2.s = -y2.s;
19772
- else if (xd[0])
19773
- y2 = new Ctor(x2);
19774
- else
19775
- return new Ctor(rm === 3 ? -0 : 0);
19776
- return external2 ? finalise(y2, pr, rm) : y2;
19777
- }
19778
- e = mathfloor(y2.e / LOG_BASE);
19779
- xe = mathfloor(x2.e / LOG_BASE);
19780
- xd = xd.slice();
19781
- k3 = xe - e;
19782
- if (k3) {
19783
- xLTy = k3 < 0;
19784
- if (xLTy) {
19785
- d = xd;
19786
- k3 = -k3;
19787
- len = yd.length;
19788
- } else {
19789
- d = yd;
19790
- e = xe;
19791
- len = xd.length;
19792
- }
19793
- i = Math.max(Math.ceil(pr / LOG_BASE), len) + 2;
19794
- if (k3 > i) {
19795
- k3 = i;
19796
- d.length = 1;
19797
- }
19798
- d.reverse();
19799
- for (i = k3;i--; )
19800
- d.push(0);
19801
- d.reverse();
19802
- } else {
19803
- i = xd.length;
19804
- len = yd.length;
19805
- xLTy = i < len;
19806
- if (xLTy)
19807
- len = i;
19808
- for (i = 0;i < len; i++) {
19809
- if (xd[i] != yd[i]) {
19810
- xLTy = xd[i] < yd[i];
19811
- break;
19812
- }
19813
- }
19814
- k3 = 0;
19815
- }
19816
- if (xLTy) {
19817
- d = xd;
19818
- xd = yd;
19819
- yd = d;
19820
- y2.s = -y2.s;
19821
- }
19822
- len = xd.length;
19823
- for (i = yd.length - len;i > 0; --i)
19824
- xd[len++] = 0;
19825
- for (i = yd.length;i > k3; ) {
19826
- if (xd[--i] < yd[i]) {
19827
- for (j3 = i;j3 && xd[--j3] === 0; )
19828
- xd[j3] = BASE - 1;
19829
- --xd[j3];
19830
- xd[i] += BASE;
19831
- }
19832
- xd[i] -= yd[i];
19833
- }
19834
- for (;xd[--len] === 0; )
19835
- xd.pop();
19836
- for (;xd[0] === 0; xd.shift())
19837
- --e;
19838
- if (!xd[0])
19839
- return new Ctor(rm === 3 ? -0 : 0);
19840
- y2.d = xd;
19841
- y2.e = getBase10Exponent(xd, e);
19842
- return external2 ? finalise(y2, pr, rm) : y2;
19843
- };
19844
- P2.modulo = P2.mod = function(y2) {
19845
- var q, x2 = this, Ctor = x2.constructor;
19846
- y2 = new Ctor(y2);
19847
- if (!x2.d || !y2.s || y2.d && !y2.d[0])
19848
- return new Ctor(NaN);
19849
- if (!y2.d || x2.d && !x2.d[0]) {
19850
- return finalise(new Ctor(x2), Ctor.precision, Ctor.rounding);
19851
- }
19852
- external2 = false;
19853
- if (Ctor.modulo == 9) {
19854
- q = divide(x2, y2.abs(), 0, 3, 1);
19855
- q.s *= y2.s;
19856
- } else {
19857
- q = divide(x2, y2, 0, Ctor.modulo, 1);
19858
- }
19859
- q = q.times(y2);
19860
- external2 = true;
19861
- return x2.minus(q);
19862
- };
19863
- P2.naturalExponential = P2.exp = function() {
19864
- return naturalExponential(this);
19865
- };
19866
- P2.naturalLogarithm = P2.ln = function() {
19867
- return naturalLogarithm(this);
19868
- };
19869
- P2.negated = P2.neg = function() {
19870
- var x2 = new this.constructor(this);
19871
- x2.s = -x2.s;
19872
- return finalise(x2);
19873
- };
19874
- P2.plus = P2.add = function(y2) {
19875
- var carry, d, e, i, k3, len, pr, rm, xd, yd, x2 = this, Ctor = x2.constructor;
19876
- y2 = new Ctor(y2);
19877
- if (!x2.d || !y2.d) {
19878
- if (!x2.s || !y2.s)
19879
- y2 = new Ctor(NaN);
19880
- else if (!x2.d)
19881
- y2 = new Ctor(y2.d || x2.s === y2.s ? x2 : NaN);
19882
- return y2;
19883
- }
19884
- if (x2.s != y2.s) {
19885
- y2.s = -y2.s;
19886
- return x2.minus(y2);
19887
- }
19888
- xd = x2.d;
19889
- yd = y2.d;
19890
- pr = Ctor.precision;
19891
- rm = Ctor.rounding;
19892
- if (!xd[0] || !yd[0]) {
19893
- if (!yd[0])
19894
- y2 = new Ctor(x2);
19895
- return external2 ? finalise(y2, pr, rm) : y2;
19896
- }
19897
- k3 = mathfloor(x2.e / LOG_BASE);
19898
- e = mathfloor(y2.e / LOG_BASE);
19899
- xd = xd.slice();
19900
- i = k3 - e;
19901
- if (i) {
19902
- if (i < 0) {
19903
- d = xd;
19904
- i = -i;
19905
- len = yd.length;
19906
- } else {
19907
- d = yd;
19908
- e = k3;
19909
- len = xd.length;
19910
- }
19911
- k3 = Math.ceil(pr / LOG_BASE);
19912
- len = k3 > len ? k3 + 1 : len + 1;
19913
- if (i > len) {
19914
- i = len;
19915
- d.length = 1;
19916
- }
19917
- d.reverse();
19918
- for (;i--; )
19919
- d.push(0);
19920
- d.reverse();
19921
- }
19922
- len = xd.length;
19923
- i = yd.length;
19924
- if (len - i < 0) {
19925
- i = len;
19926
- d = yd;
19927
- yd = xd;
19928
- xd = d;
19929
- }
19930
- for (carry = 0;i; ) {
19931
- carry = (xd[--i] = xd[i] + yd[i] + carry) / BASE | 0;
19932
- xd[i] %= BASE;
19933
- }
19934
- if (carry) {
19935
- xd.unshift(carry);
19936
- ++e;
19937
- }
19938
- for (len = xd.length;xd[--len] == 0; )
19939
- xd.pop();
19940
- y2.d = xd;
19941
- y2.e = getBase10Exponent(xd, e);
19942
- return external2 ? finalise(y2, pr, rm) : y2;
19943
- };
19944
- P2.precision = P2.sd = function(z) {
19945
- var k3, x2 = this;
19946
- if (z !== undefined && z !== !!z && z !== 1 && z !== 0)
19947
- throw Error(invalidArgument + z);
19948
- if (x2.d) {
19949
- k3 = getPrecision(x2.d);
19950
- if (z && x2.e + 1 > k3)
19951
- k3 = x2.e + 1;
19952
- } else {
19953
- k3 = NaN;
19954
- }
19955
- return k3;
19956
- };
19957
- P2.round = function() {
19958
- var x2 = this, Ctor = x2.constructor;
19959
- return finalise(new Ctor(x2), x2.e + 1, Ctor.rounding);
19960
- };
19961
- P2.sine = P2.sin = function() {
19962
- var pr, rm, x2 = this, Ctor = x2.constructor;
19963
- if (!x2.isFinite())
19964
- return new Ctor(NaN);
19965
- if (x2.isZero())
19966
- return new Ctor(x2);
19967
- pr = Ctor.precision;
19968
- rm = Ctor.rounding;
19969
- Ctor.precision = pr + Math.max(x2.e, x2.sd()) + LOG_BASE;
19970
- Ctor.rounding = 1;
19971
- x2 = sine(Ctor, toLessThanHalfPi(Ctor, x2));
19972
- Ctor.precision = pr;
19973
- Ctor.rounding = rm;
19974
- return finalise(quadrant > 2 ? x2.neg() : x2, pr, rm, true);
19975
- };
19976
- P2.squareRoot = P2.sqrt = function() {
19977
- var m2, n, sd, r, rep, t, x2 = this, d = x2.d, e = x2.e, s = x2.s, Ctor = x2.constructor;
19978
- if (s !== 1 || !d || !d[0]) {
19979
- return new Ctor(!s || s < 0 && (!d || d[0]) ? NaN : d ? x2 : 1 / 0);
19980
- }
19981
- external2 = false;
19982
- s = Math.sqrt(+x2);
19983
- if (s == 0 || s == 1 / 0) {
19984
- n = digitsToString(d);
19985
- if ((n.length + e) % 2 == 0)
19986
- n += "0";
19987
- s = Math.sqrt(n);
19988
- e = mathfloor((e + 1) / 2) - (e < 0 || e % 2);
19989
- if (s == 1 / 0) {
19990
- n = "5e" + e;
19991
- } else {
19992
- n = s.toExponential();
19993
- n = n.slice(0, n.indexOf("e") + 1) + e;
19994
- }
19995
- r = new Ctor(n);
19996
- } else {
19997
- r = new Ctor(s.toString());
19998
- }
19999
- sd = (e = Ctor.precision) + 3;
20000
- for (;; ) {
20001
- t = r;
20002
- r = t.plus(divide(x2, t, sd + 2, 1)).times(0.5);
20003
- if (digitsToString(t.d).slice(0, sd) === (n = digitsToString(r.d)).slice(0, sd)) {
20004
- n = n.slice(sd - 3, sd + 1);
20005
- if (n == "9999" || !rep && n == "4999") {
20006
- if (!rep) {
20007
- finalise(t, e + 1, 0);
20008
- if (t.times(t).eq(x2)) {
20009
- r = t;
20010
- break;
20011
- }
20012
- }
20013
- sd += 4;
20014
- rep = 1;
20015
- } else {
20016
- if (!+n || !+n.slice(1) && n.charAt(0) == "5") {
20017
- finalise(r, e + 1, 1);
20018
- m2 = !r.times(r).eq(x2);
20019
- }
20020
- break;
20021
- }
20022
- }
20023
- }
20024
- external2 = true;
20025
- return finalise(r, e, Ctor.rounding, m2);
20026
- };
20027
- P2.tangent = P2.tan = function() {
20028
- var pr, rm, x2 = this, Ctor = x2.constructor;
20029
- if (!x2.isFinite())
20030
- return new Ctor(NaN);
20031
- if (x2.isZero())
20032
- return new Ctor(x2);
20033
- pr = Ctor.precision;
20034
- rm = Ctor.rounding;
20035
- Ctor.precision = pr + 10;
20036
- Ctor.rounding = 1;
20037
- x2 = x2.sin();
20038
- x2.s = 1;
20039
- x2 = divide(x2, new Ctor(1).minus(x2.times(x2)).sqrt(), pr + 10, 0);
20040
- Ctor.precision = pr;
20041
- Ctor.rounding = rm;
20042
- return finalise(quadrant == 2 || quadrant == 4 ? x2.neg() : x2, pr, rm, true);
20043
- };
20044
- P2.times = P2.mul = function(y2) {
20045
- var carry, e, i, k3, r, rL, t, xdL, ydL, x2 = this, Ctor = x2.constructor, xd = x2.d, yd = (y2 = new Ctor(y2)).d;
20046
- y2.s *= x2.s;
20047
- if (!xd || !xd[0] || !yd || !yd[0]) {
20048
- return new Ctor(!y2.s || xd && !xd[0] && !yd || yd && !yd[0] && !xd ? NaN : !xd || !yd ? y2.s / 0 : y2.s * 0);
20049
- }
20050
- e = mathfloor(x2.e / LOG_BASE) + mathfloor(y2.e / LOG_BASE);
20051
- xdL = xd.length;
20052
- ydL = yd.length;
20053
- if (xdL < ydL) {
20054
- r = xd;
20055
- xd = yd;
20056
- yd = r;
20057
- rL = xdL;
20058
- xdL = ydL;
20059
- ydL = rL;
20060
- }
20061
- r = [];
20062
- rL = xdL + ydL;
20063
- for (i = rL;i--; )
20064
- r.push(0);
20065
- for (i = ydL;--i >= 0; ) {
20066
- carry = 0;
20067
- for (k3 = xdL + i;k3 > i; ) {
20068
- t = r[k3] + yd[i] * xd[k3 - i - 1] + carry;
20069
- r[k3--] = t % BASE | 0;
20070
- carry = t / BASE | 0;
20071
- }
20072
- r[k3] = (r[k3] + carry) % BASE | 0;
20073
- }
20074
- for (;!r[--rL]; )
20075
- r.pop();
20076
- if (carry)
20077
- ++e;
20078
- else
20079
- r.shift();
20080
- y2.d = r;
20081
- y2.e = getBase10Exponent(r, e);
20082
- return external2 ? finalise(y2, Ctor.precision, Ctor.rounding) : y2;
20083
- };
20084
- P2.toBinary = function(sd, rm) {
20085
- return toStringBinary(this, 2, sd, rm);
20086
- };
20087
- P2.toDecimalPlaces = P2.toDP = function(dp, rm) {
20088
- var x2 = this, Ctor = x2.constructor;
20089
- x2 = new Ctor(x2);
20090
- if (dp === undefined)
20091
- return x2;
20092
- checkInt32(dp, 0, MAX_DIGITS);
20093
- if (rm === undefined)
20094
- rm = Ctor.rounding;
20095
- else
20096
- checkInt32(rm, 0, 8);
20097
- return finalise(x2, dp + x2.e + 1, rm);
20098
- };
20099
- P2.toExponential = function(dp, rm) {
20100
- var str, x2 = this, Ctor = x2.constructor;
20101
- if (dp === undefined) {
20102
- str = finiteToString(x2, true);
20103
- } else {
20104
- checkInt32(dp, 0, MAX_DIGITS);
20105
- if (rm === undefined)
20106
- rm = Ctor.rounding;
20107
- else
20108
- checkInt32(rm, 0, 8);
20109
- x2 = finalise(new Ctor(x2), dp + 1, rm);
20110
- str = finiteToString(x2, true, dp + 1);
20111
- }
20112
- return x2.isNeg() && !x2.isZero() ? "-" + str : str;
20113
- };
20114
- P2.toFixed = function(dp, rm) {
20115
- var str, y2, x2 = this, Ctor = x2.constructor;
20116
- if (dp === undefined) {
20117
- str = finiteToString(x2);
20118
- } else {
20119
- checkInt32(dp, 0, MAX_DIGITS);
20120
- if (rm === undefined)
20121
- rm = Ctor.rounding;
20122
- else
20123
- checkInt32(rm, 0, 8);
20124
- y2 = finalise(new Ctor(x2), dp + x2.e + 1, rm);
20125
- str = finiteToString(y2, false, dp + y2.e + 1);
20126
- }
20127
- return x2.isNeg() && !x2.isZero() ? "-" + str : str;
20128
- };
20129
- P2.toFraction = function(maxD) {
20130
- var d, d0, d1, d2, e, k3, n, n0, n1, pr, q, r, x2 = this, xd = x2.d, Ctor = x2.constructor;
20131
- if (!xd)
20132
- return new Ctor(x2);
20133
- n1 = d0 = new Ctor(1);
20134
- d1 = n0 = new Ctor(0);
20135
- d = new Ctor(d1);
20136
- e = d.e = getPrecision(xd) - x2.e - 1;
20137
- k3 = e % LOG_BASE;
20138
- d.d[0] = mathpow(10, k3 < 0 ? LOG_BASE + k3 : k3);
20139
- if (maxD == null) {
20140
- maxD = e > 0 ? d : n1;
20141
- } else {
20142
- n = new Ctor(maxD);
20143
- if (!n.isInt() || n.lt(n1))
20144
- throw Error(invalidArgument + n);
20145
- maxD = n.gt(d) ? e > 0 ? d : n1 : n;
20146
- }
20147
- external2 = false;
20148
- n = new Ctor(digitsToString(xd));
20149
- pr = Ctor.precision;
20150
- Ctor.precision = e = xd.length * LOG_BASE * 2;
20151
- for (;; ) {
20152
- q = divide(n, d, 0, 1, 1);
20153
- d2 = d0.plus(q.times(d1));
20154
- if (d2.cmp(maxD) == 1)
20155
- break;
20156
- d0 = d1;
20157
- d1 = d2;
20158
- d2 = n1;
20159
- n1 = n0.plus(q.times(d2));
20160
- n0 = d2;
20161
- d2 = d;
20162
- d = n.minus(q.times(d2));
20163
- n = d2;
20164
- }
20165
- d2 = divide(maxD.minus(d0), d1, 0, 1, 1);
20166
- n0 = n0.plus(d2.times(n1));
20167
- d0 = d0.plus(d2.times(d1));
20168
- n0.s = n1.s = x2.s;
20169
- r = divide(n1, d1, e, 1).minus(x2).abs().cmp(divide(n0, d0, e, 1).minus(x2).abs()) < 1 ? [n1, d1] : [n0, d0];
20170
- Ctor.precision = pr;
20171
- external2 = true;
20172
- return r;
20173
- };
20174
- P2.toHexadecimal = P2.toHex = function(sd, rm) {
20175
- return toStringBinary(this, 16, sd, rm);
20176
- };
20177
- P2.toNearest = function(y2, rm) {
20178
- var x2 = this, Ctor = x2.constructor;
20179
- x2 = new Ctor(x2);
20180
- if (y2 == null) {
20181
- if (!x2.d)
20182
- return x2;
20183
- y2 = new Ctor(1);
20184
- rm = Ctor.rounding;
20185
- } else {
20186
- y2 = new Ctor(y2);
20187
- if (rm === undefined) {
20188
- rm = Ctor.rounding;
20189
- } else {
20190
- checkInt32(rm, 0, 8);
20191
- }
20192
- if (!x2.d)
20193
- return y2.s ? x2 : y2;
20194
- if (!y2.d) {
20195
- if (y2.s)
20196
- y2.s = x2.s;
20197
- return y2;
20198
- }
20199
- }
20200
- if (y2.d[0]) {
20201
- external2 = false;
20202
- x2 = divide(x2, y2, 0, rm, 1).times(y2);
20203
- external2 = true;
20204
- finalise(x2);
20205
- } else {
20206
- y2.s = x2.s;
20207
- x2 = y2;
20208
- }
20209
- return x2;
20210
- };
20211
- P2.toNumber = function() {
20212
- return +this;
20213
- };
20214
- P2.toOctal = function(sd, rm) {
20215
- return toStringBinary(this, 8, sd, rm);
20216
- };
20217
- P2.toPower = P2.pow = function(y2) {
20218
- var e, k3, pr, r, rm, s, x2 = this, Ctor = x2.constructor, yn = +(y2 = new Ctor(y2));
20219
- if (!x2.d || !y2.d || !x2.d[0] || !y2.d[0])
20220
- return new Ctor(mathpow(+x2, yn));
20221
- x2 = new Ctor(x2);
20222
- if (x2.eq(1))
20223
- return x2;
20224
- pr = Ctor.precision;
20225
- rm = Ctor.rounding;
20226
- if (y2.eq(1))
20227
- return finalise(x2, pr, rm);
20228
- e = mathfloor(y2.e / LOG_BASE);
20229
- if (e >= y2.d.length - 1 && (k3 = yn < 0 ? -yn : yn) <= MAX_SAFE_INTEGER) {
20230
- r = intPow(Ctor, x2, k3, pr);
20231
- return y2.s < 0 ? new Ctor(1).div(r) : finalise(r, pr, rm);
20232
- }
20233
- s = x2.s;
20234
- if (s < 0) {
20235
- if (e < y2.d.length - 1)
20236
- return new Ctor(NaN);
20237
- if ((y2.d[e] & 1) == 0)
20238
- s = 1;
20239
- if (x2.e == 0 && x2.d[0] == 1 && x2.d.length == 1) {
20240
- x2.s = s;
20241
- return x2;
20242
- }
20243
- }
20244
- k3 = mathpow(+x2, yn);
20245
- e = k3 == 0 || !isFinite(k3) ? mathfloor(yn * (Math.log("0." + digitsToString(x2.d)) / Math.LN10 + x2.e + 1)) : new Ctor(k3 + "").e;
20246
- if (e > Ctor.maxE + 1 || e < Ctor.minE - 1)
20247
- return new Ctor(e > 0 ? s / 0 : 0);
20248
- external2 = false;
20249
- Ctor.rounding = x2.s = 1;
20250
- k3 = Math.min(12, (e + "").length);
20251
- r = naturalExponential(y2.times(naturalLogarithm(x2, pr + k3)), pr);
20252
- if (r.d) {
20253
- r = finalise(r, pr + 5, 1);
20254
- if (checkRoundingDigits(r.d, pr, rm)) {
20255
- e = pr + 10;
20256
- r = finalise(naturalExponential(y2.times(naturalLogarithm(x2, e + k3)), e), e + 5, 1);
20257
- if (+digitsToString(r.d).slice(pr + 1, pr + 15) + 1 == 100000000000000) {
20258
- r = finalise(r, pr + 1, 0);
20259
- }
20260
- }
20261
- }
20262
- r.s = s;
20263
- external2 = true;
20264
- Ctor.rounding = rm;
20265
- return finalise(r, pr, rm);
20266
- };
20267
- P2.toPrecision = function(sd, rm) {
20268
- var str, x2 = this, Ctor = x2.constructor;
20269
- if (sd === undefined) {
20270
- str = finiteToString(x2, x2.e <= Ctor.toExpNeg || x2.e >= Ctor.toExpPos);
20271
- } else {
20272
- checkInt32(sd, 1, MAX_DIGITS);
20273
- if (rm === undefined)
20274
- rm = Ctor.rounding;
20275
- else
20276
- checkInt32(rm, 0, 8);
20277
- x2 = finalise(new Ctor(x2), sd, rm);
20278
- str = finiteToString(x2, sd <= x2.e || x2.e <= Ctor.toExpNeg, sd);
20279
- }
20280
- return x2.isNeg() && !x2.isZero() ? "-" + str : str;
20281
- };
20282
- P2.toSignificantDigits = P2.toSD = function(sd, rm) {
20283
- var x2 = this, Ctor = x2.constructor;
20284
- if (sd === undefined) {
20285
- sd = Ctor.precision;
20286
- rm = Ctor.rounding;
20287
- } else {
20288
- checkInt32(sd, 1, MAX_DIGITS);
20289
- if (rm === undefined)
20290
- rm = Ctor.rounding;
20291
- else
20292
- checkInt32(rm, 0, 8);
20293
- }
20294
- return finalise(new Ctor(x2), sd, rm);
20295
- };
20296
- P2.toString = function() {
20297
- var x2 = this, Ctor = x2.constructor, str = finiteToString(x2, x2.e <= Ctor.toExpNeg || x2.e >= Ctor.toExpPos);
20298
- return x2.isNeg() && !x2.isZero() ? "-" + str : str;
20299
- };
20300
- P2.truncated = P2.trunc = function() {
20301
- return finalise(new this.constructor(this), this.e + 1, 1);
20302
- };
20303
- P2.valueOf = P2.toJSON = function() {
20304
- var x2 = this, Ctor = x2.constructor, str = finiteToString(x2, x2.e <= Ctor.toExpNeg || x2.e >= Ctor.toExpPos);
20305
- return x2.isNeg() ? "-" + str : str;
20306
- };
20307
- function digitsToString(d) {
20308
- var i, k3, ws, indexOfLastWord = d.length - 1, str = "", w2 = d[0];
20309
- if (indexOfLastWord > 0) {
20310
- str += w2;
20311
- for (i = 1;i < indexOfLastWord; i++) {
20312
- ws = d[i] + "";
20313
- k3 = LOG_BASE - ws.length;
20314
- if (k3)
20315
- str += getZeroString(k3);
20316
- str += ws;
20317
- }
20318
- w2 = d[i];
20319
- ws = w2 + "";
20320
- k3 = LOG_BASE - ws.length;
20321
- if (k3)
20322
- str += getZeroString(k3);
20323
- } else if (w2 === 0) {
20324
- return "0";
20325
- }
20326
- for (;w2 % 10 === 0; )
20327
- w2 /= 10;
20328
- return str + w2;
20329
- }
20330
- function checkInt32(i, min, max) {
20331
- if (i !== ~~i || i < min || i > max) {
20332
- throw Error(invalidArgument + i);
20333
- }
20334
- }
20335
- function checkRoundingDigits(d, i, rm, repeating) {
20336
- var di, k3, r, rd;
20337
- for (k3 = d[0];k3 >= 10; k3 /= 10)
20338
- --i;
20339
- if (--i < 0) {
20340
- i += LOG_BASE;
20341
- di = 0;
20342
- } else {
20343
- di = Math.ceil((i + 1) / LOG_BASE);
20344
- i %= LOG_BASE;
20345
- }
20346
- k3 = mathpow(10, LOG_BASE - i);
20347
- rd = d[di] % k3 | 0;
20348
- if (repeating == null) {
20349
- if (i < 3) {
20350
- if (i == 0)
20351
- rd = rd / 100 | 0;
20352
- else if (i == 1)
20353
- rd = rd / 10 | 0;
20354
- r = rm < 4 && rd == 99999 || rm > 3 && rd == 49999 || rd == 50000 || rd == 0;
20355
- } else {
20356
- r = (rm < 4 && rd + 1 == k3 || rm > 3 && rd + 1 == k3 / 2) && (d[di + 1] / k3 / 100 | 0) == mathpow(10, i - 2) - 1 || (rd == k3 / 2 || rd == 0) && (d[di + 1] / k3 / 100 | 0) == 0;
20357
- }
20358
- } else {
20359
- if (i < 4) {
20360
- if (i == 0)
20361
- rd = rd / 1000 | 0;
20362
- else if (i == 1)
20363
- rd = rd / 100 | 0;
20364
- else if (i == 2)
20365
- rd = rd / 10 | 0;
20366
- r = (repeating || rm < 4) && rd == 9999 || !repeating && rm > 3 && rd == 4999;
20367
- } else {
20368
- r = ((repeating || rm < 4) && rd + 1 == k3 || !repeating && rm > 3 && rd + 1 == k3 / 2) && (d[di + 1] / k3 / 1000 | 0) == mathpow(10, i - 3) - 1;
20369
- }
20370
- }
20371
- return r;
20372
- }
20373
- function convertBase(str, baseIn, baseOut) {
20374
- var j3, arr = [0], arrL, i = 0, strL = str.length;
20375
- for (;i < strL; ) {
20376
- for (arrL = arr.length;arrL--; )
20377
- arr[arrL] *= baseIn;
20378
- arr[0] += NUMERALS.indexOf(str.charAt(i++));
20379
- for (j3 = 0;j3 < arr.length; j3++) {
20380
- if (arr[j3] > baseOut - 1) {
20381
- if (arr[j3 + 1] === undefined)
20382
- arr[j3 + 1] = 0;
20383
- arr[j3 + 1] += arr[j3] / baseOut | 0;
20384
- arr[j3] %= baseOut;
20385
- }
20386
- }
20387
- }
20388
- return arr.reverse();
20389
- }
20390
- function cosine(Ctor, x2) {
20391
- var k3, len, y2;
20392
- if (x2.isZero())
20393
- return x2;
20394
- len = x2.d.length;
20395
- if (len < 32) {
20396
- k3 = Math.ceil(len / 3);
20397
- y2 = (1 / tinyPow(4, k3)).toString();
20398
- } else {
20399
- k3 = 16;
20400
- y2 = "2.3283064365386962890625e-10";
20401
- }
20402
- Ctor.precision += k3;
20403
- x2 = taylorSeries(Ctor, 1, x2.times(y2), new Ctor(1));
20404
- for (var i = k3;i--; ) {
20405
- var cos2x = x2.times(x2);
20406
- x2 = cos2x.times(cos2x).minus(cos2x).times(8).plus(1);
20407
- }
20408
- Ctor.precision -= k3;
20409
- return x2;
20410
- }
20411
- var divide = function() {
20412
- function multiplyInteger(x2, k3, base) {
20413
- var temp, carry = 0, i = x2.length;
20414
- for (x2 = x2.slice();i--; ) {
20415
- temp = x2[i] * k3 + carry;
20416
- x2[i] = temp % base | 0;
20417
- carry = temp / base | 0;
20418
- }
20419
- if (carry)
20420
- x2.unshift(carry);
20421
- return x2;
20422
- }
20423
- function compare(a, b, aL, bL) {
20424
- var i, r;
20425
- if (aL != bL) {
20426
- r = aL > bL ? 1 : -1;
20427
- } else {
20428
- for (i = r = 0;i < aL; i++) {
20429
- if (a[i] != b[i]) {
20430
- r = a[i] > b[i] ? 1 : -1;
20431
- break;
20432
- }
20433
- }
20434
- }
20435
- return r;
20436
- }
20437
- function subtract(a, b, aL, base) {
20438
- var i = 0;
20439
- for (;aL--; ) {
20440
- a[aL] -= i;
20441
- i = a[aL] < b[aL] ? 1 : 0;
20442
- a[aL] = i * base + a[aL] - b[aL];
20443
- }
20444
- for (;!a[0] && a.length > 1; )
20445
- a.shift();
20446
- }
20447
- return function(x2, y2, pr, rm, dp, base) {
20448
- var cmp, e, i, k3, logBase, more, prod, prodL, q, qd, rem, remL, rem0, sd, t, xi, xL, yd0, yL, yz, Ctor = x2.constructor, sign = x2.s == y2.s ? 1 : -1, xd = x2.d, yd = y2.d;
20449
- if (!xd || !xd[0] || !yd || !yd[0]) {
20450
- return new Ctor(!x2.s || !y2.s || (xd ? yd && xd[0] == yd[0] : !yd) ? NaN : xd && xd[0] == 0 || !yd ? sign * 0 : sign / 0);
20451
- }
20452
- if (base) {
20453
- logBase = 1;
20454
- e = x2.e - y2.e;
20455
- } else {
20456
- base = BASE;
20457
- logBase = LOG_BASE;
20458
- e = mathfloor(x2.e / logBase) - mathfloor(y2.e / logBase);
20459
- }
20460
- yL = yd.length;
20461
- xL = xd.length;
20462
- q = new Ctor(sign);
20463
- qd = q.d = [];
20464
- for (i = 0;yd[i] == (xd[i] || 0); i++)
20465
- ;
20466
- if (yd[i] > (xd[i] || 0))
20467
- e--;
20468
- if (pr == null) {
20469
- sd = pr = Ctor.precision;
20470
- rm = Ctor.rounding;
20471
- } else if (dp) {
20472
- sd = pr + (x2.e - y2.e) + 1;
20473
- } else {
20474
- sd = pr;
20475
- }
20476
- if (sd < 0) {
20477
- qd.push(1);
20478
- more = true;
20479
- } else {
20480
- sd = sd / logBase + 2 | 0;
20481
- i = 0;
20482
- if (yL == 1) {
20483
- k3 = 0;
20484
- yd = yd[0];
20485
- sd++;
20486
- for (;(i < xL || k3) && sd--; i++) {
20487
- t = k3 * base + (xd[i] || 0);
20488
- qd[i] = t / yd | 0;
20489
- k3 = t % yd | 0;
20490
- }
20491
- more = k3 || i < xL;
20492
- } else {
20493
- k3 = base / (yd[0] + 1) | 0;
20494
- if (k3 > 1) {
20495
- yd = multiplyInteger(yd, k3, base);
20496
- xd = multiplyInteger(xd, k3, base);
20497
- yL = yd.length;
20498
- xL = xd.length;
20499
- }
20500
- xi = yL;
20501
- rem = xd.slice(0, yL);
20502
- remL = rem.length;
20503
- for (;remL < yL; )
20504
- rem[remL++] = 0;
20505
- yz = yd.slice();
20506
- yz.unshift(0);
20507
- yd0 = yd[0];
20508
- if (yd[1] >= base / 2)
20509
- ++yd0;
20510
- do {
20511
- k3 = 0;
20512
- cmp = compare(yd, rem, yL, remL);
20513
- if (cmp < 0) {
20514
- rem0 = rem[0];
20515
- if (yL != remL)
20516
- rem0 = rem0 * base + (rem[1] || 0);
20517
- k3 = rem0 / yd0 | 0;
20518
- if (k3 > 1) {
20519
- if (k3 >= base)
20520
- k3 = base - 1;
20521
- prod = multiplyInteger(yd, k3, base);
20522
- prodL = prod.length;
20523
- remL = rem.length;
20524
- cmp = compare(prod, rem, prodL, remL);
20525
- if (cmp == 1) {
20526
- k3--;
20527
- subtract(prod, yL < prodL ? yz : yd, prodL, base);
20528
- }
20529
- } else {
20530
- if (k3 == 0)
20531
- cmp = k3 = 1;
20532
- prod = yd.slice();
20533
- }
20534
- prodL = prod.length;
20535
- if (prodL < remL)
20536
- prod.unshift(0);
20537
- subtract(rem, prod, remL, base);
20538
- if (cmp == -1) {
20539
- remL = rem.length;
20540
- cmp = compare(yd, rem, yL, remL);
20541
- if (cmp < 1) {
20542
- k3++;
20543
- subtract(rem, yL < remL ? yz : yd, remL, base);
20544
- }
20545
- }
20546
- remL = rem.length;
20547
- } else if (cmp === 0) {
20548
- k3++;
20549
- rem = [0];
20550
- }
20551
- qd[i++] = k3;
20552
- if (cmp && rem[0]) {
20553
- rem[remL++] = xd[xi] || 0;
20554
- } else {
20555
- rem = [xd[xi]];
20556
- remL = 1;
20557
- }
20558
- } while ((xi++ < xL || rem[0] !== undefined) && sd--);
20559
- more = rem[0] !== undefined;
20560
- }
20561
- if (!qd[0])
20562
- qd.shift();
20563
- }
20564
- if (logBase == 1) {
20565
- q.e = e;
20566
- inexact = more;
20567
- } else {
20568
- for (i = 1, k3 = qd[0];k3 >= 10; k3 /= 10)
20569
- i++;
20570
- q.e = i + e * logBase - 1;
20571
- finalise(q, dp ? pr + q.e + 1 : pr, rm, more);
20572
- }
20573
- return q;
20574
- };
20575
- }();
20576
- function finalise(x2, sd, rm, isTruncated) {
20577
- var digits, i, j3, k3, rd, roundUp, w2, xd, xdi, Ctor = x2.constructor;
20578
- out:
20579
- if (sd != null) {
20580
- xd = x2.d;
20581
- if (!xd)
20582
- return x2;
20583
- for (digits = 1, k3 = xd[0];k3 >= 10; k3 /= 10)
20584
- digits++;
20585
- i = sd - digits;
20586
- if (i < 0) {
20587
- i += LOG_BASE;
20588
- j3 = sd;
20589
- w2 = xd[xdi = 0];
20590
- rd = w2 / mathpow(10, digits - j3 - 1) % 10 | 0;
20591
- } else {
20592
- xdi = Math.ceil((i + 1) / LOG_BASE);
20593
- k3 = xd.length;
20594
- if (xdi >= k3) {
20595
- if (isTruncated) {
20596
- for (;k3++ <= xdi; )
20597
- xd.push(0);
20598
- w2 = rd = 0;
20599
- digits = 1;
20600
- i %= LOG_BASE;
20601
- j3 = i - LOG_BASE + 1;
20602
- } else {
20603
- break out;
20604
- }
20605
- } else {
20606
- w2 = k3 = xd[xdi];
20607
- for (digits = 1;k3 >= 10; k3 /= 10)
20608
- digits++;
20609
- i %= LOG_BASE;
20610
- j3 = i - LOG_BASE + digits;
20611
- rd = j3 < 0 ? 0 : w2 / mathpow(10, digits - j3 - 1) % 10 | 0;
20612
- }
20613
- }
20614
- isTruncated = isTruncated || sd < 0 || xd[xdi + 1] !== undefined || (j3 < 0 ? w2 : w2 % mathpow(10, digits - j3 - 1));
20615
- roundUp = rm < 4 ? (rd || isTruncated) && (rm == 0 || rm == (x2.s < 0 ? 3 : 2)) : rd > 5 || rd == 5 && (rm == 4 || isTruncated || rm == 6 && (i > 0 ? j3 > 0 ? w2 / mathpow(10, digits - j3) : 0 : xd[xdi - 1]) % 10 & 1 || rm == (x2.s < 0 ? 8 : 7));
20616
- if (sd < 1 || !xd[0]) {
20617
- xd.length = 0;
20618
- if (roundUp) {
20619
- sd -= x2.e + 1;
20620
- xd[0] = mathpow(10, (LOG_BASE - sd % LOG_BASE) % LOG_BASE);
20621
- x2.e = -sd || 0;
20622
- } else {
20623
- xd[0] = x2.e = 0;
20624
- }
20625
- return x2;
20626
- }
20627
- if (i == 0) {
20628
- xd.length = xdi;
20629
- k3 = 1;
20630
- xdi--;
20631
- } else {
20632
- xd.length = xdi + 1;
20633
- k3 = mathpow(10, LOG_BASE - i);
20634
- xd[xdi] = j3 > 0 ? (w2 / mathpow(10, digits - j3) % mathpow(10, j3) | 0) * k3 : 0;
20635
- }
20636
- if (roundUp) {
20637
- for (;; ) {
20638
- if (xdi == 0) {
20639
- for (i = 1, j3 = xd[0];j3 >= 10; j3 /= 10)
20640
- i++;
20641
- j3 = xd[0] += k3;
20642
- for (k3 = 1;j3 >= 10; j3 /= 10)
20643
- k3++;
20644
- if (i != k3) {
20645
- x2.e++;
20646
- if (xd[0] == BASE)
20647
- xd[0] = 1;
20648
- }
20649
- break;
20650
- } else {
20651
- xd[xdi] += k3;
20652
- if (xd[xdi] != BASE)
20653
- break;
20654
- xd[xdi--] = 0;
20655
- k3 = 1;
20656
- }
20657
- }
20658
- }
20659
- for (i = xd.length;xd[--i] === 0; )
20660
- xd.pop();
20661
- }
20662
- if (external2) {
20663
- if (x2.e > Ctor.maxE) {
20664
- x2.d = null;
20665
- x2.e = NaN;
20666
- } else if (x2.e < Ctor.minE) {
20667
- x2.e = 0;
20668
- x2.d = [0];
20669
- }
20670
- }
20671
- return x2;
20672
- }
20673
- function finiteToString(x2, isExp, sd) {
20674
- if (!x2.isFinite())
20675
- return nonFiniteToString(x2);
20676
- var k3, e = x2.e, str = digitsToString(x2.d), len = str.length;
20677
- if (isExp) {
20678
- if (sd && (k3 = sd - len) > 0) {
20679
- str = str.charAt(0) + "." + str.slice(1) + getZeroString(k3);
20680
- } else if (len > 1) {
20681
- str = str.charAt(0) + "." + str.slice(1);
20682
- }
20683
- str = str + (x2.e < 0 ? "e" : "e+") + x2.e;
20684
- } else if (e < 0) {
20685
- str = "0." + getZeroString(-e - 1) + str;
20686
- if (sd && (k3 = sd - len) > 0)
20687
- str += getZeroString(k3);
20688
- } else if (e >= len) {
20689
- str += getZeroString(e + 1 - len);
20690
- if (sd && (k3 = sd - e - 1) > 0)
20691
- str = str + "." + getZeroString(k3);
20692
- } else {
20693
- if ((k3 = e + 1) < len)
20694
- str = str.slice(0, k3) + "." + str.slice(k3);
20695
- if (sd && (k3 = sd - len) > 0) {
20696
- if (e + 1 === len)
20697
- str += ".";
20698
- str += getZeroString(k3);
20699
- }
20700
- }
20701
- return str;
20702
- }
20703
- function getBase10Exponent(digits, e) {
20704
- var w2 = digits[0];
20705
- for (e *= LOG_BASE;w2 >= 10; w2 /= 10)
20706
- e++;
20707
- return e;
20708
- }
20709
- function getLn10(Ctor, sd, pr) {
20710
- if (sd > LN10_PRECISION) {
20711
- external2 = true;
20712
- if (pr)
20713
- Ctor.precision = pr;
20714
- throw Error(precisionLimitExceeded);
20715
- }
20716
- return finalise(new Ctor(LN10), sd, 1, true);
20717
- }
20718
- function getPi(Ctor, sd, rm) {
20719
- if (sd > PI_PRECISION)
20720
- throw Error(precisionLimitExceeded);
20721
- return finalise(new Ctor(PI), sd, rm, true);
20722
- }
20723
- function getPrecision(digits) {
20724
- var w2 = digits.length - 1, len = w2 * LOG_BASE + 1;
20725
- w2 = digits[w2];
20726
- if (w2) {
20727
- for (;w2 % 10 == 0; w2 /= 10)
20728
- len--;
20729
- for (w2 = digits[0];w2 >= 10; w2 /= 10)
20730
- len++;
20731
- }
20732
- return len;
20733
- }
20734
- function getZeroString(k3) {
20735
- var zs = "";
20736
- for (;k3--; )
20737
- zs += "0";
20738
- return zs;
20739
- }
20740
- function intPow(Ctor, x2, n, pr) {
20741
- var isTruncated, r = new Ctor(1), k3 = Math.ceil(pr / LOG_BASE + 4);
20742
- external2 = false;
20743
- for (;; ) {
20744
- if (n % 2) {
20745
- r = r.times(x2);
20746
- if (truncate(r.d, k3))
20747
- isTruncated = true;
20748
- }
20749
- n = mathfloor(n / 2);
20750
- if (n === 0) {
20751
- n = r.d.length - 1;
20752
- if (isTruncated && r.d[n] === 0)
20753
- ++r.d[n];
20754
- break;
20755
- }
20756
- x2 = x2.times(x2);
20757
- truncate(x2.d, k3);
20758
- }
20759
- external2 = true;
20760
- return r;
20761
- }
20762
- function isOdd(n) {
20763
- return n.d[n.d.length - 1] & 1;
20764
- }
20765
- function maxOrMin(Ctor, args, n) {
20766
- var k3, y2, x2 = new Ctor(args[0]), i = 0;
20767
- for (;++i < args.length; ) {
20768
- y2 = new Ctor(args[i]);
20769
- if (!y2.s) {
20770
- x2 = y2;
20771
- break;
20772
- }
20773
- k3 = x2.cmp(y2);
20774
- if (k3 === n || k3 === 0 && x2.s === n) {
20775
- x2 = y2;
20776
- }
20777
- }
20778
- return x2;
20779
- }
20780
- function naturalExponential(x2, sd) {
20781
- var denominator, guard, j3, pow, sum, t, wpr, rep = 0, i = 0, k3 = 0, Ctor = x2.constructor, rm = Ctor.rounding, pr = Ctor.precision;
20782
- if (!x2.d || !x2.d[0] || x2.e > 17) {
20783
- return new Ctor(x2.d ? !x2.d[0] ? 1 : x2.s < 0 ? 0 : 1 / 0 : x2.s ? x2.s < 0 ? 0 : x2 : 0 / 0);
20784
- }
20785
- if (sd == null) {
20786
- external2 = false;
20787
- wpr = pr;
20788
- } else {
20789
- wpr = sd;
20790
- }
20791
- t = new Ctor(0.03125);
20792
- while (x2.e > -2) {
20793
- x2 = x2.times(t);
20794
- k3 += 5;
20795
- }
20796
- guard = Math.log(mathpow(2, k3)) / Math.LN10 * 2 + 5 | 0;
20797
- wpr += guard;
20798
- denominator = pow = sum = new Ctor(1);
20799
- Ctor.precision = wpr;
20800
- for (;; ) {
20801
- pow = finalise(pow.times(x2), wpr, 1);
20802
- denominator = denominator.times(++i);
20803
- t = sum.plus(divide(pow, denominator, wpr, 1));
20804
- if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {
20805
- j3 = k3;
20806
- while (j3--)
20807
- sum = finalise(sum.times(sum), wpr, 1);
20808
- if (sd == null) {
20809
- if (rep < 3 && checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {
20810
- Ctor.precision = wpr += 10;
20811
- denominator = pow = t = new Ctor(1);
20812
- i = 0;
20813
- rep++;
20814
- } else {
20815
- return finalise(sum, Ctor.precision = pr, rm, external2 = true);
20816
- }
20817
- } else {
20818
- Ctor.precision = pr;
20819
- return sum;
20820
- }
20821
- }
20822
- sum = t;
20823
- }
20824
- }
20825
- function naturalLogarithm(y2, sd) {
20826
- var c, c0, denominator, e, numerator, rep, sum, t, wpr, x1, x2, n = 1, guard = 10, x3 = y2, xd = x3.d, Ctor = x3.constructor, rm = Ctor.rounding, pr = Ctor.precision;
20827
- if (x3.s < 0 || !xd || !xd[0] || !x3.e && xd[0] == 1 && xd.length == 1) {
20828
- return new Ctor(xd && !xd[0] ? -1 / 0 : x3.s != 1 ? NaN : xd ? 0 : x3);
20829
- }
20830
- if (sd == null) {
20831
- external2 = false;
20832
- wpr = pr;
20833
- } else {
20834
- wpr = sd;
20835
- }
20836
- Ctor.precision = wpr += guard;
20837
- c = digitsToString(xd);
20838
- c0 = c.charAt(0);
20839
- if (Math.abs(e = x3.e) < 1500000000000000) {
20840
- while (c0 < 7 && c0 != 1 || c0 == 1 && c.charAt(1) > 3) {
20841
- x3 = x3.times(y2);
20842
- c = digitsToString(x3.d);
20843
- c0 = c.charAt(0);
20844
- n++;
20845
- }
20846
- e = x3.e;
20847
- if (c0 > 1) {
20848
- x3 = new Ctor("0." + c);
20849
- e++;
20850
- } else {
20851
- x3 = new Ctor(c0 + "." + c.slice(1));
20852
- }
20853
- } else {
20854
- t = getLn10(Ctor, wpr + 2, pr).times(e + "");
20855
- x3 = naturalLogarithm(new Ctor(c0 + "." + c.slice(1)), wpr - guard).plus(t);
20856
- Ctor.precision = pr;
20857
- return sd == null ? finalise(x3, pr, rm, external2 = true) : x3;
20858
- }
20859
- x1 = x3;
20860
- sum = numerator = x3 = divide(x3.minus(1), x3.plus(1), wpr, 1);
20861
- x2 = finalise(x3.times(x3), wpr, 1);
20862
- denominator = 3;
20863
- for (;; ) {
20864
- numerator = finalise(numerator.times(x2), wpr, 1);
20865
- t = sum.plus(divide(numerator, new Ctor(denominator), wpr, 1));
20866
- if (digitsToString(t.d).slice(0, wpr) === digitsToString(sum.d).slice(0, wpr)) {
20867
- sum = sum.times(2);
20868
- if (e !== 0)
20869
- sum = sum.plus(getLn10(Ctor, wpr + 2, pr).times(e + ""));
20870
- sum = divide(sum, new Ctor(n), wpr, 1);
20871
- if (sd == null) {
20872
- if (checkRoundingDigits(sum.d, wpr - guard, rm, rep)) {
20873
- Ctor.precision = wpr += guard;
20874
- t = numerator = x3 = divide(x1.minus(1), x1.plus(1), wpr, 1);
20875
- x2 = finalise(x3.times(x3), wpr, 1);
20876
- denominator = rep = 1;
20877
- } else {
20878
- return finalise(sum, Ctor.precision = pr, rm, external2 = true);
20879
- }
20880
- } else {
20881
- Ctor.precision = pr;
20882
- return sum;
20883
- }
20884
- }
20885
- sum = t;
20886
- denominator += 2;
20887
- }
20888
- }
20889
- function nonFiniteToString(x2) {
20890
- return String(x2.s * x2.s / 0);
20891
- }
20892
- function parseDecimal(x2, str) {
20893
- var e, i, len;
20894
- if ((e = str.indexOf(".")) > -1)
20895
- str = str.replace(".", "");
20896
- if ((i = str.search(/e/i)) > 0) {
20897
- if (e < 0)
20898
- e = i;
20899
- e += +str.slice(i + 1);
20900
- str = str.substring(0, i);
20901
- } else if (e < 0) {
20902
- e = str.length;
20903
- }
20904
- for (i = 0;str.charCodeAt(i) === 48; i++)
20905
- ;
20906
- for (len = str.length;str.charCodeAt(len - 1) === 48; --len)
20907
- ;
20908
- str = str.slice(i, len);
20909
- if (str) {
20910
- len -= i;
20911
- x2.e = e = e - i - 1;
20912
- x2.d = [];
20913
- i = (e + 1) % LOG_BASE;
20914
- if (e < 0)
20915
- i += LOG_BASE;
20916
- if (i < len) {
20917
- if (i)
20918
- x2.d.push(+str.slice(0, i));
20919
- for (len -= LOG_BASE;i < len; )
20920
- x2.d.push(+str.slice(i, i += LOG_BASE));
20921
- str = str.slice(i);
20922
- i = LOG_BASE - str.length;
20923
- } else {
20924
- i -= len;
20925
- }
20926
- for (;i--; )
20927
- str += "0";
20928
- x2.d.push(+str);
20929
- if (external2) {
20930
- if (x2.e > x2.constructor.maxE) {
20931
- x2.d = null;
20932
- x2.e = NaN;
20933
- } else if (x2.e < x2.constructor.minE) {
20934
- x2.e = 0;
20935
- x2.d = [0];
20936
- }
20937
- }
20938
- } else {
20939
- x2.e = 0;
20940
- x2.d = [0];
20941
- }
20942
- return x2;
20943
- }
20944
- function parseOther(x2, str) {
20945
- var base, Ctor, divisor, i, isFloat, len, p, xd, xe;
20946
- if (str.indexOf("_") > -1) {
20947
- str = str.replace(/(\d)_(?=\d)/g, "$1");
20948
- if (isDecimal.test(str))
20949
- return parseDecimal(x2, str);
20950
- } else if (str === "Infinity" || str === "NaN") {
20951
- if (!+str)
20952
- x2.s = NaN;
20953
- x2.e = NaN;
20954
- x2.d = null;
20955
- return x2;
20956
- }
20957
- if (isHex.test(str)) {
20958
- base = 16;
20959
- str = str.toLowerCase();
20960
- } else if (isBinary.test(str)) {
20961
- base = 2;
20962
- } else if (isOctal.test(str)) {
20963
- base = 8;
20964
- } else {
20965
- throw Error(invalidArgument + str);
20966
- }
20967
- i = str.search(/p/i);
20968
- if (i > 0) {
20969
- p = +str.slice(i + 1);
20970
- str = str.substring(2, i);
20971
- } else {
20972
- str = str.slice(2);
20973
- }
20974
- i = str.indexOf(".");
20975
- isFloat = i >= 0;
20976
- Ctor = x2.constructor;
20977
- if (isFloat) {
20978
- str = str.replace(".", "");
20979
- len = str.length;
20980
- i = len - i;
20981
- divisor = intPow(Ctor, new Ctor(base), i, i * 2);
20982
- }
20983
- xd = convertBase(str, base, BASE);
20984
- xe = xd.length - 1;
20985
- for (i = xe;xd[i] === 0; --i)
20986
- xd.pop();
20987
- if (i < 0)
20988
- return new Ctor(x2.s * 0);
20989
- x2.e = getBase10Exponent(xd, xe);
20990
- x2.d = xd;
20991
- external2 = false;
20992
- if (isFloat)
20993
- x2 = divide(x2, divisor, len * 4);
20994
- if (p)
20995
- x2 = x2.times(Math.abs(p) < 54 ? mathpow(2, p) : Decimal.pow(2, p));
20996
- external2 = true;
20997
- return x2;
20998
- }
20999
- function sine(Ctor, x2) {
21000
- var k3, len = x2.d.length;
21001
- if (len < 3) {
21002
- return x2.isZero() ? x2 : taylorSeries(Ctor, 2, x2, x2);
21003
- }
21004
- k3 = 1.4 * Math.sqrt(len);
21005
- k3 = k3 > 16 ? 16 : k3 | 0;
21006
- x2 = x2.times(1 / tinyPow(5, k3));
21007
- x2 = taylorSeries(Ctor, 2, x2, x2);
21008
- var sin2_x, d5 = new Ctor(5), d16 = new Ctor(16), d20 = new Ctor(20);
21009
- for (;k3--; ) {
21010
- sin2_x = x2.times(x2);
21011
- x2 = x2.times(d5.plus(sin2_x.times(d16.times(sin2_x).minus(d20))));
21012
- }
21013
- return x2;
21014
- }
21015
- function taylorSeries(Ctor, n, x2, y2, isHyperbolic) {
21016
- var j3, t, u2, x22, i = 1, pr = Ctor.precision, k3 = Math.ceil(pr / LOG_BASE);
21017
- external2 = false;
21018
- x22 = x2.times(x2);
21019
- u2 = new Ctor(y2);
21020
- for (;; ) {
21021
- t = divide(u2.times(x22), new Ctor(n++ * n++), pr, 1);
21022
- u2 = isHyperbolic ? y2.plus(t) : y2.minus(t);
21023
- y2 = divide(t.times(x22), new Ctor(n++ * n++), pr, 1);
21024
- t = u2.plus(y2);
21025
- if (t.d[k3] !== undefined) {
21026
- for (j3 = k3;t.d[j3] === u2.d[j3] && j3--; )
21027
- ;
21028
- if (j3 == -1)
21029
- break;
21030
- }
21031
- j3 = u2;
21032
- u2 = y2;
21033
- y2 = t;
21034
- t = j3;
21035
- i++;
21036
- }
21037
- external2 = true;
21038
- t.d.length = k3 + 1;
21039
- return t;
21040
- }
21041
- function tinyPow(b, e) {
21042
- var n = b;
21043
- while (--e)
21044
- n *= b;
21045
- return n;
21046
- }
21047
- function toLessThanHalfPi(Ctor, x2) {
21048
- var t, isNeg = x2.s < 0, pi = getPi(Ctor, Ctor.precision, 1), halfPi = pi.times(0.5);
21049
- x2 = x2.abs();
21050
- if (x2.lte(halfPi)) {
21051
- quadrant = isNeg ? 4 : 1;
21052
- return x2;
21053
- }
21054
- t = x2.divToInt(pi);
21055
- if (t.isZero()) {
21056
- quadrant = isNeg ? 3 : 2;
21057
- } else {
21058
- x2 = x2.minus(t.times(pi));
21059
- if (x2.lte(halfPi)) {
21060
- quadrant = isOdd(t) ? isNeg ? 2 : 3 : isNeg ? 4 : 1;
21061
- return x2;
21062
- }
21063
- quadrant = isOdd(t) ? isNeg ? 1 : 4 : isNeg ? 3 : 2;
21064
- }
21065
- return x2.minus(pi).abs();
21066
- }
21067
- function toStringBinary(x2, baseOut, sd, rm) {
21068
- var base, e, i, k3, len, roundUp, str, xd, y2, Ctor = x2.constructor, isExp = sd !== undefined;
21069
- if (isExp) {
21070
- checkInt32(sd, 1, MAX_DIGITS);
21071
- if (rm === undefined)
21072
- rm = Ctor.rounding;
21073
- else
21074
- checkInt32(rm, 0, 8);
21075
- } else {
21076
- sd = Ctor.precision;
21077
- rm = Ctor.rounding;
21078
- }
21079
- if (!x2.isFinite()) {
21080
- str = nonFiniteToString(x2);
21081
- } else {
21082
- str = finiteToString(x2);
21083
- i = str.indexOf(".");
21084
- if (isExp) {
21085
- base = 2;
21086
- if (baseOut == 16) {
21087
- sd = sd * 4 - 3;
21088
- } else if (baseOut == 8) {
21089
- sd = sd * 3 - 2;
21090
- }
21091
- } else {
21092
- base = baseOut;
21093
- }
21094
- if (i >= 0) {
21095
- str = str.replace(".", "");
21096
- y2 = new Ctor(1);
21097
- y2.e = str.length - i;
21098
- y2.d = convertBase(finiteToString(y2), 10, base);
21099
- y2.e = y2.d.length;
21100
- }
21101
- xd = convertBase(str, 10, base);
21102
- e = len = xd.length;
21103
- for (;xd[--len] == 0; )
21104
- xd.pop();
21105
- if (!xd[0]) {
21106
- str = isExp ? "0p+0" : "0";
21107
- } else {
21108
- if (i < 0) {
21109
- e--;
21110
- } else {
21111
- x2 = new Ctor(x2);
21112
- x2.d = xd;
21113
- x2.e = e;
21114
- x2 = divide(x2, y2, sd, rm, 0, base);
21115
- xd = x2.d;
21116
- e = x2.e;
21117
- roundUp = inexact;
21118
- }
21119
- i = xd[sd];
21120
- k3 = base / 2;
21121
- roundUp = roundUp || xd[sd + 1] !== undefined;
21122
- roundUp = rm < 4 ? (i !== undefined || roundUp) && (rm === 0 || rm === (x2.s < 0 ? 3 : 2)) : i > k3 || i === k3 && (rm === 4 || roundUp || rm === 6 && xd[sd - 1] & 1 || rm === (x2.s < 0 ? 8 : 7));
21123
- xd.length = sd;
21124
- if (roundUp) {
21125
- for (;++xd[--sd] > base - 1; ) {
21126
- xd[sd] = 0;
21127
- if (!sd) {
21128
- ++e;
21129
- xd.unshift(1);
21130
- }
21131
- }
21132
- }
21133
- for (len = xd.length;!xd[len - 1]; --len)
21134
- ;
21135
- for (i = 0, str = "";i < len; i++)
21136
- str += NUMERALS.charAt(xd[i]);
21137
- if (isExp) {
21138
- if (len > 1) {
21139
- if (baseOut == 16 || baseOut == 8) {
21140
- i = baseOut == 16 ? 4 : 3;
21141
- for (--len;len % i; len++)
21142
- str += "0";
21143
- xd = convertBase(str, base, baseOut);
21144
- for (len = xd.length;!xd[len - 1]; --len)
21145
- ;
21146
- for (i = 1, str = "1.";i < len; i++)
21147
- str += NUMERALS.charAt(xd[i]);
21148
- } else {
21149
- str = str.charAt(0) + "." + str.slice(1);
21150
- }
21151
- }
21152
- str = str + (e < 0 ? "p" : "p+") + e;
21153
- } else if (e < 0) {
21154
- for (;++e; )
21155
- str = "0" + str;
21156
- str = "0." + str;
21157
- } else {
21158
- if (++e > len)
21159
- for (e -= len;e--; )
21160
- str += "0";
21161
- else if (e < len)
21162
- str = str.slice(0, e) + "." + str.slice(e);
21163
- }
21164
- }
21165
- str = (baseOut == 16 ? "0x" : baseOut == 2 ? "0b" : baseOut == 8 ? "0o" : "") + str;
21166
- }
21167
- return x2.s < 0 ? "-" + str : str;
21168
- }
21169
- function truncate(arr, len) {
21170
- if (arr.length > len) {
21171
- arr.length = len;
21172
- return true;
21173
- }
21174
- }
21175
- function abs(x2) {
21176
- return new this(x2).abs();
21177
- }
21178
- function acos(x2) {
21179
- return new this(x2).acos();
21180
- }
21181
- function acosh(x2) {
21182
- return new this(x2).acosh();
21183
- }
21184
- function add(x2, y2) {
21185
- return new this(x2).plus(y2);
21186
- }
21187
- function asin(x2) {
21188
- return new this(x2).asin();
21189
- }
21190
- function asinh(x2) {
21191
- return new this(x2).asinh();
21192
- }
21193
- function atan(x2) {
21194
- return new this(x2).atan();
21195
- }
21196
- function atanh(x2) {
21197
- return new this(x2).atanh();
21198
- }
21199
- function atan2(y2, x2) {
21200
- y2 = new this(y2);
21201
- x2 = new this(x2);
21202
- var r, pr = this.precision, rm = this.rounding, wpr = pr + 4;
21203
- if (!y2.s || !x2.s) {
21204
- r = new this(NaN);
21205
- } else if (!y2.d && !x2.d) {
21206
- r = getPi(this, wpr, 1).times(x2.s > 0 ? 0.25 : 0.75);
21207
- r.s = y2.s;
21208
- } else if (!x2.d || y2.isZero()) {
21209
- r = x2.s < 0 ? getPi(this, pr, rm) : new this(0);
21210
- r.s = y2.s;
21211
- } else if (!y2.d || x2.isZero()) {
21212
- r = getPi(this, wpr, 1).times(0.5);
21213
- r.s = y2.s;
21214
- } else if (x2.s < 0) {
21215
- this.precision = wpr;
21216
- this.rounding = 1;
21217
- r = this.atan(divide(y2, x2, wpr, 1));
21218
- x2 = getPi(this, wpr, 1);
21219
- this.precision = pr;
21220
- this.rounding = rm;
21221
- r = y2.s < 0 ? r.minus(x2) : r.plus(x2);
21222
- } else {
21223
- r = this.atan(divide(y2, x2, wpr, 1));
21224
- }
21225
- return r;
21226
- }
21227
- function cbrt(x2) {
21228
- return new this(x2).cbrt();
21229
- }
21230
- function ceil(x2) {
21231
- return finalise(x2 = new this(x2), x2.e + 1, 2);
21232
- }
21233
- function clamp(x2, min, max) {
21234
- return new this(x2).clamp(min, max);
21235
- }
21236
- function config(obj) {
21237
- if (!obj || typeof obj !== "object")
21238
- throw Error(decimalError + "Object expected");
21239
- var i, p, v, useDefaults = obj.defaults === true, ps = [
21240
- "precision",
21241
- 1,
21242
- MAX_DIGITS,
21243
- "rounding",
21244
- 0,
21245
- 8,
21246
- "toExpNeg",
21247
- -EXP_LIMIT,
21248
- 0,
21249
- "toExpPos",
21250
- 0,
21251
- EXP_LIMIT,
21252
- "maxE",
21253
- 0,
21254
- EXP_LIMIT,
21255
- "minE",
21256
- -EXP_LIMIT,
21257
- 0,
21258
- "modulo",
21259
- 0,
21260
- 9
21261
- ];
21262
- for (i = 0;i < ps.length; i += 3) {
21263
- if (p = ps[i], useDefaults)
21264
- this[p] = DEFAULTS[p];
21265
- if ((v = obj[p]) !== undefined) {
21266
- if (mathfloor(v) === v && v >= ps[i + 1] && v <= ps[i + 2])
21267
- this[p] = v;
21268
- else
21269
- throw Error(invalidArgument + p + ": " + v);
21270
- }
21271
- }
21272
- if (p = "crypto", useDefaults)
21273
- this[p] = DEFAULTS[p];
21274
- if ((v = obj[p]) !== undefined) {
21275
- if (v === true || v === false || v === 0 || v === 1) {
21276
- if (v) {
21277
- if (typeof crypto != "undefined" && crypto && (crypto.getRandomValues || crypto.randomBytes)) {
21278
- this[p] = true;
21279
- } else {
21280
- throw Error(cryptoUnavailable);
21281
- }
21282
- } else {
21283
- this[p] = false;
21284
- }
21285
- } else {
21286
- throw Error(invalidArgument + p + ": " + v);
21287
- }
21288
- }
21289
- return this;
21290
- }
21291
- function cos(x2) {
21292
- return new this(x2).cos();
21293
- }
21294
- function cosh(x2) {
21295
- return new this(x2).cosh();
21296
- }
21297
- function clone(obj) {
21298
- var i, p, ps;
21299
- function Decimal(v) {
21300
- var e, i2, t, x2 = this;
21301
- if (!(x2 instanceof Decimal))
21302
- return new Decimal(v);
21303
- x2.constructor = Decimal;
21304
- if (isDecimalInstance(v)) {
21305
- x2.s = v.s;
21306
- if (external2) {
21307
- if (!v.d || v.e > Decimal.maxE) {
21308
- x2.e = NaN;
21309
- x2.d = null;
21310
- } else if (v.e < Decimal.minE) {
21311
- x2.e = 0;
21312
- x2.d = [0];
21313
- } else {
21314
- x2.e = v.e;
21315
- x2.d = v.d.slice();
21316
- }
21317
- } else {
21318
- x2.e = v.e;
21319
- x2.d = v.d ? v.d.slice() : v.d;
21320
- }
21321
- return;
21322
- }
21323
- t = typeof v;
21324
- if (t === "number") {
21325
- if (v === 0) {
21326
- x2.s = 1 / v < 0 ? -1 : 1;
21327
- x2.e = 0;
21328
- x2.d = [0];
21329
- return;
21330
- }
21331
- if (v < 0) {
21332
- v = -v;
21333
- x2.s = -1;
21334
- } else {
21335
- x2.s = 1;
21336
- }
21337
- if (v === ~~v && v < 1e7) {
21338
- for (e = 0, i2 = v;i2 >= 10; i2 /= 10)
21339
- e++;
21340
- if (external2) {
21341
- if (e > Decimal.maxE) {
21342
- x2.e = NaN;
21343
- x2.d = null;
21344
- } else if (e < Decimal.minE) {
21345
- x2.e = 0;
21346
- x2.d = [0];
21347
- } else {
21348
- x2.e = e;
21349
- x2.d = [v];
21350
- }
21351
- } else {
21352
- x2.e = e;
21353
- x2.d = [v];
21354
- }
21355
- return;
21356
- }
21357
- if (v * 0 !== 0) {
21358
- if (!v)
21359
- x2.s = NaN;
21360
- x2.e = NaN;
21361
- x2.d = null;
21362
- return;
21363
- }
21364
- return parseDecimal(x2, v.toString());
21365
- }
21366
- if (t === "string") {
21367
- if ((i2 = v.charCodeAt(0)) === 45) {
21368
- v = v.slice(1);
21369
- x2.s = -1;
21370
- } else {
21371
- if (i2 === 43)
21372
- v = v.slice(1);
21373
- x2.s = 1;
21374
- }
21375
- return isDecimal.test(v) ? parseDecimal(x2, v) : parseOther(x2, v);
21376
- }
21377
- if (t === "bigint") {
21378
- if (v < 0) {
21379
- v = -v;
21380
- x2.s = -1;
21381
- } else {
21382
- x2.s = 1;
21383
- }
21384
- return parseDecimal(x2, v.toString());
21385
- }
21386
- throw Error(invalidArgument + v);
21387
- }
21388
- Decimal.prototype = P2;
21389
- Decimal.ROUND_UP = 0;
21390
- Decimal.ROUND_DOWN = 1;
21391
- Decimal.ROUND_CEIL = 2;
21392
- Decimal.ROUND_FLOOR = 3;
21393
- Decimal.ROUND_HALF_UP = 4;
21394
- Decimal.ROUND_HALF_DOWN = 5;
21395
- Decimal.ROUND_HALF_EVEN = 6;
21396
- Decimal.ROUND_HALF_CEIL = 7;
21397
- Decimal.ROUND_HALF_FLOOR = 8;
21398
- Decimal.EUCLID = 9;
21399
- Decimal.config = Decimal.set = config;
21400
- Decimal.clone = clone;
21401
- Decimal.isDecimal = isDecimalInstance;
21402
- Decimal.abs = abs;
21403
- Decimal.acos = acos;
21404
- Decimal.acosh = acosh;
21405
- Decimal.add = add;
21406
- Decimal.asin = asin;
21407
- Decimal.asinh = asinh;
21408
- Decimal.atan = atan;
21409
- Decimal.atanh = atanh;
21410
- Decimal.atan2 = atan2;
21411
- Decimal.cbrt = cbrt;
21412
- Decimal.ceil = ceil;
21413
- Decimal.clamp = clamp;
21414
- Decimal.cos = cos;
21415
- Decimal.cosh = cosh;
21416
- Decimal.div = div;
21417
- Decimal.exp = exp;
21418
- Decimal.floor = floor;
21419
- Decimal.hypot = hypot;
21420
- Decimal.ln = ln;
21421
- Decimal.log = log;
21422
- Decimal.log10 = log10;
21423
- Decimal.log2 = log2;
21424
- Decimal.max = max;
21425
- Decimal.min = min;
21426
- Decimal.mod = mod;
21427
- Decimal.mul = mul;
21428
- Decimal.pow = pow;
21429
- Decimal.random = random;
21430
- Decimal.round = round;
21431
- Decimal.sign = sign;
21432
- Decimal.sin = sin;
21433
- Decimal.sinh = sinh;
21434
- Decimal.sqrt = sqrt;
21435
- Decimal.sub = sub;
21436
- Decimal.sum = sum;
21437
- Decimal.tan = tan;
21438
- Decimal.tanh = tanh;
21439
- Decimal.trunc = trunc;
21440
- if (obj === undefined)
21441
- obj = {};
21442
- if (obj) {
21443
- if (obj.defaults !== true) {
21444
- ps = ["precision", "rounding", "toExpNeg", "toExpPos", "maxE", "minE", "modulo", "crypto"];
21445
- for (i = 0;i < ps.length; )
21446
- if (!obj.hasOwnProperty(p = ps[i++]))
21447
- obj[p] = this[p];
21448
- }
21449
- }
21450
- Decimal.config(obj);
21451
- return Decimal;
21452
- }
21453
- function div(x2, y2) {
21454
- return new this(x2).div(y2);
21455
- }
21456
- function exp(x2) {
21457
- return new this(x2).exp();
21458
- }
21459
- function floor(x2) {
21460
- return finalise(x2 = new this(x2), x2.e + 1, 3);
21461
- }
21462
- function hypot() {
21463
- var i, n, t = new this(0);
21464
- external2 = false;
21465
- for (i = 0;i < arguments.length; ) {
21466
- n = new this(arguments[i++]);
21467
- if (!n.d) {
21468
- if (n.s) {
21469
- external2 = true;
21470
- return new this(1 / 0);
21471
- }
21472
- t = n;
21473
- } else if (t.d) {
21474
- t = t.plus(n.times(n));
21475
- }
21476
- }
21477
- external2 = true;
21478
- return t.sqrt();
21479
- }
21480
- function isDecimalInstance(obj) {
21481
- return obj instanceof Decimal || obj && obj.toStringTag === tag || false;
21482
- }
21483
- function ln(x2) {
21484
- return new this(x2).ln();
21485
- }
21486
- function log(x2, y2) {
21487
- return new this(x2).log(y2);
21488
- }
21489
- function log2(x2) {
21490
- return new this(x2).log(2);
21491
- }
21492
- function log10(x2) {
21493
- return new this(x2).log(10);
21494
- }
21495
- function max() {
21496
- return maxOrMin(this, arguments, -1);
21497
- }
21498
- function min() {
21499
- return maxOrMin(this, arguments, 1);
21500
- }
21501
- function mod(x2, y2) {
21502
- return new this(x2).mod(y2);
21503
- }
21504
- function mul(x2, y2) {
21505
- return new this(x2).mul(y2);
21506
- }
21507
- function pow(x2, y2) {
21508
- return new this(x2).pow(y2);
21509
- }
21510
- function random(sd) {
21511
- var d, e, k3, n, i = 0, r = new this(1), rd = [];
21512
- if (sd === undefined)
21513
- sd = this.precision;
21514
- else
21515
- checkInt32(sd, 1, MAX_DIGITS);
21516
- k3 = Math.ceil(sd / LOG_BASE);
21517
- if (!this.crypto) {
21518
- for (;i < k3; )
21519
- rd[i++] = Math.random() * 1e7 | 0;
21520
- } else if (crypto.getRandomValues) {
21521
- d = crypto.getRandomValues(new Uint32Array(k3));
21522
- for (;i < k3; ) {
21523
- n = d[i];
21524
- if (n >= 4290000000) {
21525
- d[i] = crypto.getRandomValues(new Uint32Array(1))[0];
21526
- } else {
21527
- rd[i++] = n % 1e7;
21528
- }
21529
- }
21530
- } else if (crypto.randomBytes) {
21531
- d = crypto.randomBytes(k3 *= 4);
21532
- for (;i < k3; ) {
21533
- n = d[i] + (d[i + 1] << 8) + (d[i + 2] << 16) + ((d[i + 3] & 127) << 24);
21534
- if (n >= 2140000000) {
21535
- crypto.randomBytes(4).copy(d, i);
21536
- } else {
21537
- rd.push(n % 1e7);
21538
- i += 4;
21539
- }
21540
- }
21541
- i = k3 / 4;
21542
- } else {
21543
- throw Error(cryptoUnavailable);
21544
- }
21545
- k3 = rd[--i];
21546
- sd %= LOG_BASE;
21547
- if (k3 && sd) {
21548
- n = mathpow(10, LOG_BASE - sd);
21549
- rd[i] = (k3 / n | 0) * n;
21550
- }
21551
- for (;rd[i] === 0; i--)
21552
- rd.pop();
21553
- if (i < 0) {
21554
- e = 0;
21555
- rd = [0];
21556
- } else {
21557
- e = -1;
21558
- for (;rd[0] === 0; e -= LOG_BASE)
21559
- rd.shift();
21560
- for (k3 = 1, n = rd[0];n >= 10; n /= 10)
21561
- k3++;
21562
- if (k3 < LOG_BASE)
21563
- e -= LOG_BASE - k3;
21564
- }
21565
- r.e = e;
21566
- r.d = rd;
21567
- return r;
21568
- }
21569
- function round(x2) {
21570
- return finalise(x2 = new this(x2), x2.e + 1, this.rounding);
21571
- }
21572
- function sign(x2) {
21573
- x2 = new this(x2);
21574
- return x2.d ? x2.d[0] ? x2.s : 0 * x2.s : x2.s || NaN;
21575
- }
21576
- function sin(x2) {
21577
- return new this(x2).sin();
21578
- }
21579
- function sinh(x2) {
21580
- return new this(x2).sinh();
21581
- }
21582
- function sqrt(x2) {
21583
- return new this(x2).sqrt();
21584
- }
21585
- function sub(x2, y2) {
21586
- return new this(x2).sub(y2);
21587
- }
21588
- function sum() {
21589
- var i = 0, args = arguments, x2 = new this(args[i]);
21590
- external2 = false;
21591
- for (;x2.s && ++i < args.length; )
21592
- x2 = x2.plus(args[i]);
21593
- external2 = true;
21594
- return finalise(x2, this.precision, this.rounding);
21595
- }
21596
- function tan(x2) {
21597
- return new this(x2).tan();
21598
- }
21599
- function tanh(x2) {
21600
- return new this(x2).tanh();
21601
- }
21602
- function trunc(x2) {
21603
- return finalise(x2 = new this(x2), x2.e + 1, 1);
21604
- }
21605
- P2[Symbol.for("nodejs.util.inspect.custom")] = P2.toString;
21606
- P2[Symbol.toStringTag] = "Decimal";
21607
- var Decimal = P2.constructor = clone(DEFAULTS);
21608
- LN10 = new Decimal(LN10);
21609
- PI = new Decimal(PI);
21610
- var decimal_default = Decimal;
21611
-
21612
- // src/common/base/other.ts
21613
- var delay = (time = 1000) => {
21614
- return new Promise((resolve) => setTimeout(resolve, time));
21615
- };
21616
- var calcJsText = (expr, context) => {
21617
- const keys = Object.keys(context);
21618
- const values = keys.map((key2) => context[key2]);
21619
- return Function(...keys, `return (${expr})`)(...values);
21620
- };
21621
- var optionsToEnum = (options, text, key2) => {
21622
- return options.reduce((acc, cur) => {
21623
- acc[cur[key2]] = {
21624
- text: cur[text]
21625
- };
21626
- return acc;
21627
- }, {});
21628
- };
21629
- var performDecimalOperation = (num1, num2, operator) => {
21630
- if (num1 === undefined || num2 === undefined || !operator) {
21631
- return;
21632
- }
21633
- const decimalNum1 = new decimal_default(Number(num1));
21634
- const decimalNum2 = new decimal_default(Number(num2));
21635
- switch (operator) {
21636
- case "+":
21637
- return decimalNum1.plus(decimalNum2).toNumber();
21638
- case "-":
21639
- return decimalNum1.minus(decimalNum2).toNumber();
21640
- case "*":
21641
- return decimalNum1.times(decimalNum2).toNumber();
21642
- case "/":
21643
- if (num2 !== 0) {
21644
- return decimalNum1.dividedBy(decimalNum2).toNumber();
21645
- } else {
21646
- console.error("Division by zero is not allowed.");
21647
- return NaN;
21648
- }
21649
- default:
21650
- console.error("Invalid operator:", operator);
21651
- return NaN;
21652
- }
21653
- };
21654
- var printConsoleLog = (type, path, params, response) => {
21655
- const styles = {
21656
- header: "color: #fff; background: #35495e; padding: 2px 8px; border-radius: 3px 0 0 3px;",
21657
- value: "color: #35495e; background: #f0f4f8; padding: 2px 6px; border-radius: 0 3px 3px 0;",
21658
- separator: "color: #409EFF; margin: 0 4px;"
21659
- };
21660
- console.groupCollapsed(`666 %c${type}%c${path}`, styles.header, styles.value);
21661
- if (params) {
21662
- console.table(params);
21663
- }
21664
- if (response) {
21665
- console.table(response);
21666
- }
21667
- console.groupEnd();
21668
- };
21669
-
21670
- // src/common/base/array.ts
21671
- var shuffleArray = (array) => {
21672
- const shuffledArray = [...array];
21673
- for (let i = shuffledArray.length - 1;i > 0; i--) {
21674
- const j3 = Math.floor(Math.random() * (i + 1));
21675
- [shuffledArray[i], shuffledArray[j3]] = [shuffledArray[j3], shuffledArray[i]];
21676
- }
21677
- return shuffledArray;
21678
- };
21679
- var removeSimilarDuplicates = (arr, threshold, isLog) => {
21680
- const uniqueArray = [];
21681
- const similarPairs = [];
21682
- for (const str of arr) {
21683
- const isSimilar = uniqueArray.some((uniqueStr) => {
21684
- const distance = levenshteinDistance(str, uniqueStr);
21685
- if (distance <= threshold) {
21686
- similarPairs.push([str, uniqueStr]);
21687
- return true;
21688
- }
21689
- return false;
21690
- });
21691
- if (!isSimilar) {
21692
- uniqueArray.push(str);
21693
- }
21694
- }
21695
- if (isLog) {
21696
- if (similarPairs.length > 0) {
21697
- similarPairs.forEach((pair) => {
21698
- console.log(pair[0]);
21699
- console.log(pair[1]);
21700
- console.log();
21701
- });
21702
- } else {
21703
- console.log("没有找到类似的字符串");
21704
- }
21705
- }
21706
- return uniqueArray;
21707
- };
21708
- var getTotal = (arr, key2) => {
21709
- if (!Array.isArray(arr) || !key2) {
21710
- return 0;
21711
- }
21712
- return arr.reduce((total, item) => {
21713
- const itemValue = Number(item[key2]);
21714
- if (!isNaN(itemValue)) {
21715
- return performDecimalOperation(total, itemValue, "+");
21716
- }
21717
- return total;
21718
- }, 0);
21719
- };
21720
-
21721
- // src/common/base/number.ts
21722
- var getRandomNum = (min2, max2) => {
21723
- return Math.floor(Math.random() * (max2 - min2 + 1) + min2);
21724
- };
21725
- var limitDecimals = (v, num = 2, isForce) => {
21726
- let value = parseFloat(v);
21727
- if (isNaN(value)) {
21728
- if (isForce) {
21729
- value = 0;
21730
- } else {
21731
- return "";
21732
- }
21733
- }
21734
- return value.toFixed(num).toString();
21735
- };
21736
- var getFileSize = (size) => {
21737
- let d = "G";
21738
- let s = size / 1024 / 1024 / 1024;
21739
- if (s < 1) {
21740
- d = "M";
21741
- s *= 1024;
21742
- }
21743
- return `${(s.toFixed(1) / 1).toString()}${d}`;
21744
- };
21745
- var isValidNumber = (value) => {
21746
- if (typeof value !== "number") {
21747
- return false;
21748
- }
21749
- if (isNaN(value)) {
21750
- return false;
21751
- }
21752
- if (value === Infinity || value === -Infinity) {
21753
- return false;
21754
- }
21755
- return true;
21756
- };
21757
- var numberWithCommas = (x2) => {
21758
- if (x2 === undefined || x2 === null) {
21759
- return "";
21760
- }
21761
- return x2.toString().replace(/\B(?=(\d{3})+(?!\d))/g, ",");
21762
- };
21763
-
21764
- // src/common/base/object.ts
21765
- var findItem = (list, attr, value) => {
21766
- return list.find((item) => value === undefined ? item[attr] : item[attr] === value);
21767
- };
21768
- var filterParams = (params, deep = false) => {
21769
- const clean = (value) => {
21770
- if (value === undefined || value === null) {
21771
- return;
21772
- }
21773
- if (!deep) {
21774
- return value;
21775
- }
21776
- if (Array.isArray(value)) {
21777
- return value.map((v) => clean(v)).filter((v) => v !== undefined);
21778
- }
21779
- if (typeof value === "object") {
21780
- return Object.entries(value).reduce((acc, [k3, v]) => {
21781
- const cleaned = clean(v);
21782
- if (cleaned !== undefined)
21783
- acc[k3] = cleaned;
21784
- return acc;
21785
- }, {});
21786
- }
21787
- return value;
21788
- };
21789
- return clean(params);
21790
- };
21791
- var watch = {
21792
- observe(obj, key2, watchFun) {
21793
- const val = obj[key2];
21794
- Object.defineProperty(obj, key2, {
21795
- configurable: true,
21796
- enumerable: true,
21797
- set(value) {
21798
- obj[key2] = value;
21799
- watchFun(value, val);
21800
- },
21801
- get() {
21802
- return val;
21803
- }
21804
- });
21805
- },
21806
- setWatcher(data = {}, watch2 = {}) {
21807
- Object.keys(watch2).forEach((v) => {
21808
- this.observe(data, v, watch2[v]);
21809
- });
21810
- }
21811
- };
21812
-
21813
- // src/common/base/promise.ts
21814
- var executePromise = async (promise) => {
21815
- const start = Date.now();
21816
- const result = await promise;
21817
- const time = Date.now() - start;
21818
- return {
21819
- result,
21820
- time
21821
- };
21822
- };
21823
- var retryPromise = async (promiseFn, retryInterval = 1000, retryCount = 3) => {
21824
- try {
21825
- return await promiseFn();
21826
- } catch (error) {
21827
- if (retryCount <= 0) {
21828
- throw error;
21829
- }
21830
- await new Promise((resolve) => setTimeout(resolve, retryInterval));
21831
- return retryPromise(promiseFn, retryCount - 1, retryInterval);
21832
- }
21833
- };
21834
- // src/common/enum.ts
21835
- class EnumItem {
21836
- label;
21837
- value;
21838
- extra;
21839
- constructor(config2) {
21840
- this.value = config2.value;
21841
- this.label = config2.label;
21842
- this.extra = config2.extra;
21843
- }
21844
- }
21845
- var Enum = {
21846
- create: (members) => {
21847
- const usedValues = new Set;
21848
- const enumObj = {};
21849
- const map = new Map;
21850
- const options = [];
21851
- const extras = new Map;
21852
- const labels = new Map;
21853
- const enums = {};
21854
- for (const key2 in members) {
21855
- const member = members[key2];
21856
- if (!member)
21857
- continue;
21858
- if (usedValues.has(member.value)) {
21859
- throw new Error(`Duplicate enum value detected: ${member.value}`);
21860
- }
21861
- usedValues.add(member.value);
21862
- const item = new EnumItem(member);
21863
- enumObj[key2] = item;
21864
- map.set(item.value, item);
21865
- labels.set(item.value, item.label);
21866
- options.push(item);
21867
- enums[item.value] = { text: item.label, status: item.extra?.status };
21868
- if (member.extra !== undefined) {
21869
- extras.set(item.value, { ...member.extra });
21870
- }
21871
- }
21872
- enumObj.map = map;
21873
- enumObj.options = options;
21874
- enumObj.extras = extras;
21875
- enumObj.source = members;
21876
- enumObj.labels = labels;
21877
- enumObj.enums = enums;
21878
- return enumObj;
21879
- }
21880
- };
21881
- // src/common/image.ts
21882
- async function imageToBase64(url) {
21883
- try {
21884
- const response = await axios_default.get(url, {
21885
- responseType: "arraybuffer"
21886
- });
21887
- const base64String = Buffer.from(response.data).toString("base64");
21888
- return `data:image/*;base64,${base64String}`;
21889
- } catch (error) {
21890
- console.error("Failed to fetch the image:", error);
21891
- throw error;
21892
- }
21893
- }
21894
- // src/common/dayjs.ts
21895
- var import_dayjs = __toESM(require_dayjs_min(), 1);
21896
- var import_isBetween = __toESM(require_isBetween(), 1);
21897
- var import_weekday = __toESM(require_weekday(), 1);
21898
- var import_localeData = __toESM(require_localeData(), 1);
21899
- var import_isoWeek = __toESM(require_isoWeek(), 1);
21900
- var import_updateLocale = __toESM(require_updateLocale(), 1);
21901
- var import_timezone = __toESM(require_timezone(), 1);
21902
- var import_isSameOrAfter = __toESM(require_isSameOrAfter(), 1);
21903
- var import_isSameOrBefore = __toESM(require_isSameOrBefore(), 1);
21904
- var import_utc = __toESM(require_utc(), 1);
21905
- var import_zh_cn = __toESM(require_zh_cn(), 1);
21906
- var import_dayjs2 = __toESM(require_dayjs_min(), 1);
21907
- import_dayjs.default.extend(import_utc.default);
21908
- import_dayjs.default.extend(import_isBetween.default);
21909
- import_dayjs.default.extend(import_weekday.default);
21910
- import_dayjs.default.extend(import_localeData.default);
21911
- import_dayjs.default.extend(import_isoWeek.default);
21912
- import_dayjs.default.extend(import_updateLocale.default);
21913
- import_dayjs.default.extend(import_timezone.default);
21914
- import_dayjs.default.extend(import_isSameOrAfter.default);
21915
- import_dayjs.default.extend(import_isSameOrBefore.default);
21916
- var Timezone;
21917
- ((Timezone2) => {
21918
- Timezone2["AsiaShanghai"] = "Asia/Shanghai";
21919
- Timezone2["AsiaTokyo"] = "Asia/Tokyo";
21920
- Timezone2["AmericaNewYork"] = "America/New_York";
21921
- Timezone2["EuropeLondon"] = "Europe/London";
21922
- Timezone2["EuropeBerlin"] = "Europe/Berlin";
21923
- })(Timezone ||= {});
21924
- var initChinaDayjs = () => {
21925
- import_dayjs.default.locale("zh-cn");
21926
- import_dayjs.default.tz.setDefault("Asia/Shanghai" /* AsiaShanghai */);
21927
- import_dayjs.default.updateLocale("zh-cn", {
21928
- weekStart: 1
21929
- });
21930
- return import_dayjs.default;
21931
- };
21932
- var chinaDayjs = initChinaDayjs();
21933
- var dayjs_default = import_dayjs.default;
21934
- // src/web/element.ts
21935
- var scrollIntoView = (el, option) => {
21936
- if (!el) {
21937
- return;
21938
- }
21939
- el.scrollIntoView({ behavior: "smooth", block: "start", ...option });
21940
- };
21941
- var getElement = (el) => {
21942
- const element = typeof el === "string" ? document.querySelector(el) : el;
21943
- if (!element) {
21944
- return {
21945
- element: null,
21946
- originalStyle: {}
21947
- };
18849
+ var getElement = (el) => {
18850
+ const element = typeof el === "string" ? document.querySelector(el) : el;
18851
+ if (!element) {
18852
+ return {
18853
+ element: null,
18854
+ originalStyle: {}
18855
+ };
21948
18856
  }
21949
18857
  return {
21950
18858
  element,
@@ -22050,6 +18958,9 @@ var readClipboard = async () => {
22050
18958
  return "";
22051
18959
  }
22052
18960
  };
18961
+
18962
+ // src/web.ts
18963
+ console.log(666, 16);
22053
18964
  var export_md5 = import_md5.default;
22054
18965
  var export_localforage = import_localforage.default;
22055
18966
  var export_json5 = import_json52.default;
@@ -22061,7 +18972,6 @@ var export_Dayjs = import_dayjs2.Dayjs;
22061
18972
 
22062
18973
  export {
22063
18974
  exports_external as z,
22064
- watch,
22065
18975
  voidType as void,
22066
18976
  util,
22067
18977
  urlGetPath,
@@ -22071,37 +18981,27 @@ export {
22071
18981
  undefinedType as undefined,
22072
18982
  tupleType as tuple,
22073
18983
  effectsType as transformer,
22074
- toString3 as toString,
22075
18984
  symbolType as symbol,
22076
18985
  stringType as string,
22077
18986
  strictObjectType as strictObject,
22078
- shuffleArray,
22079
18987
  setUrlParams,
22080
18988
  setErrorMap,
18989
+ setCookie,
22081
18990
  setType as set,
22082
18991
  scrollIntoView,
22083
- retryPromise,
22084
- replaceByVariables,
22085
- replaceByRules,
22086
- replaceAll,
22087
- removeSimilarDuplicates,
22088
18992
  recordType as record,
22089
18993
  readClipboard,
22090
18994
  quotelessJson,
22091
18995
  promiseType as promise,
22092
- printConsoleLog,
22093
18996
  preprocessType as preprocess,
22094
18997
  pipelineType as pipeline,
22095
- performDecimalOperation,
22096
18998
  params2Url,
22097
18999
  ostring,
22098
- optionsToEnum,
22099
19000
  optionalType as optional,
22100
19001
  onumber,
22101
19002
  oboolean,
22102
19003
  objectUtil,
22103
19004
  objectType as object,
22104
- numberWithCommas,
22105
19005
  numberType as number,
22106
19006
  nullableType as nullable,
22107
19007
  nullType as null,
@@ -22113,16 +19013,10 @@ export {
22113
19013
  makeIssue,
22114
19014
  export_localforage as localforage,
22115
19015
  literalType as literal,
22116
- limitDecimals,
22117
- levenshteinDistance,
22118
19016
  lazyType as lazy,
22119
19017
  late,
22120
- exports_keling as keling,
22121
- jsonParse,
22122
19018
  export_json5 as json5,
22123
- isValidNumber,
22124
19019
  isValid,
22125
- isJson,
22126
19020
  isElementInViewport,
22127
19021
  isDirty,
22128
19022
  isAsync,
@@ -22132,35 +19026,17 @@ export {
22132
19026
  initChinaDayjs,
22133
19027
  imageToBase64,
22134
19028
  hexToRgba2 as hexToRgba,
22135
- getType,
22136
- getTotal,
22137
- getStrLength,
22138
- getSliceStr,
22139
- getRandomString,
22140
- getRandomNum,
22141
- getRandomColor,
22142
- getProxyUrl,
19029
+ getVideoStatus,
22143
19030
  getParsedType,
22144
- getLength,
22145
- getFileSize,
22146
19031
  getErrorMap,
22147
19032
  getElement,
22148
- getCookie,
22149
- getChineseByStr,
22150
- getChinese,
22151
- generateUniqueFileName,
22152
- generateAlphabetArray,
19033
+ generateVideo,
22153
19034
  functionType as function,
22154
19035
  flashBorder,
22155
19036
  flashBackground,
22156
- findItem,
22157
- filterParams,
22158
- executePromise,
22159
19037
  enumType as enum,
22160
19038
  effectsType as effect,
22161
- exports_doubao2 as doubao,
22162
19039
  discriminatedUnionType as discriminatedUnion,
22163
- delay,
22164
19040
  en_default as defaultErrorMap,
22165
19041
  dayjs_default as dayjs,
22166
19042
  datetimeRegex,
@@ -22171,15 +19047,13 @@ export {
22171
19047
  coerce,
22172
19048
  export_classnames as classnames,
22173
19049
  chinaDayjs,
22174
- calcJsText,
19050
+ chat,
22175
19051
  booleanType as boolean,
22176
19052
  bigIntType as bigint,
22177
19053
  axios_default as axios,
22178
19054
  arrayType as array,
22179
19055
  anyType as any,
22180
19056
  anime_es_default as anime,
22181
- amount,
22182
- exports_302 as ai302,
22183
19057
  addIssueToContext,
22184
19058
  export__ as _,
22185
19059
  ZodVoid,