From 308e8d87fe46badc5b2e98deb4037aa62c2ad780 Mon Sep 17 00:00:00 2001 From: Darlito Date: Wed, 28 Jan 2026 01:42:53 +0000 Subject: [PATCH] Upload files to "/" ARIALLLLLLLLL --- exceljs.min.js | 54736 ++++++++++++++++++++++++++++++++++++++++ pdfmake.min.js | 63309 +++++++++++++++++++++++++++++++++++++++++++++++ vfs_fonts.js | 24 + 3 files changed, 118069 insertions(+) create mode 100644 exceljs.min.js create mode 100644 pdfmake.min.js create mode 100644 vfs_fonts.js diff --git a/exceljs.min.js b/exceljs.min.js new file mode 100644 index 0000000..a95dc94 --- /dev/null +++ b/exceljs.min.js @@ -0,0 +1,54736 @@ +/*! ExcelJS 19-10-2023 */ + +!(function (e) { + if ("object" == typeof exports && "undefined" != typeof module) + module.exports = e(); + else if ("function" == typeof define && define.amd) define([], e); + else { + ("undefined" != typeof window + ? window + : "undefined" != typeof global + ? global + : "undefined" != typeof self + ? self + : this + ).ExcelJS = e(); + } +})(function () { + return (function e(t, r, n) { + function i(o, a) { + if (!r[o]) { + if (!t[o]) { + var l = "function" == typeof require && require; + if (!a && l) return l(o, !0); + if (s) return s(o, !0); + var c = new Error("Cannot find module '" + o + "'"); + throw ((c.code = "MODULE_NOT_FOUND"), c); + } + var u = (r[o] = { exports: {} }); + t[o][0].call( + u.exports, + function (e) { + return i(t[o][1][e] || e); + }, + u, + u.exports, + e, + t, + r, + n, + ); + } + return r[o].exports; + } + for ( + var s = "function" == typeof require && require, o = 0; + o < n.length; + o++ + ) + i(n[o]); + return i; + })( + { + 1: [ + function (e, t, r) { + "use strict"; + const n = e("fs"), + i = e("fast-csv"), + s = e("dayjs/plugin/customParseFormat"), + o = e("dayjs/plugin/utc"), + a = e("dayjs").extend(s).extend(o), + l = e("../utils/stream-buf"), + { + fs: { exists: c }, + } = e("../utils/utils"), + u = { + true: !0, + false: !1, + "#N/A": { error: "#N/A" }, + "#REF!": { error: "#REF!" }, + "#NAME?": { error: "#NAME?" }, + "#DIV/0!": { error: "#DIV/0!" }, + "#NULL!": { error: "#NULL!" }, + "#VALUE!": { error: "#VALUE!" }, + "#NUM!": { error: "#NUM!" }, + }; + t.exports = class { + constructor(e) { + ((this.workbook = e), (this.worksheet = null)); + } + async readFile(e, t) { + if (((t = t || {}), !(await c(e)))) + throw new Error("File not found: " + e); + const r = n.createReadStream(e), + i = await this.read(r, t); + return (r.close(), i); + } + read(e, t) { + return ( + (t = t || {}), + new Promise((r, n) => { + const s = this.workbook.addWorksheet(t.sheetName), + o = t.dateFormats || [ + "YYYY-MM-DD[T]HH:mm:ssZ", + "YYYY-MM-DD[T]HH:mm:ss", + "MM-DD-YYYY", + "YYYY-MM-DD", + ], + l = + t.map || + function (e) { + if ("" === e) return null; + const t = Number(e); + if (!Number.isNaN(t) && t !== 1 / 0) return t; + const r = o.reduce((t, r) => { + if (t) return t; + const n = a(e, r, !0); + return n.isValid() ? n : null; + }, null); + if (r) return new Date(r.valueOf()); + const n = u[e]; + return void 0 !== n ? n : e; + }, + c = i + .parse(t.parserOptions) + .on("data", (e) => { + s.addRow(e.map(l)); + }) + .on("end", () => { + c.emit("worksheet", s); + }); + (c.on("worksheet", r).on("error", n), e.pipe(c)); + }) + ); + } + createInputStream() { + throw new Error( + "`CSV#createInputStream` is deprecated. You should use `CSV#read` instead. This method will be removed in version 5.0. Please follow upgrade instruction: https://github.com/exceljs/exceljs/blob/master/UPGRADE-4.0.md", + ); + } + write(e, t) { + return new Promise((r, n) => { + t = t || {}; + const s = this.workbook.getWorksheet(t.sheetName || t.sheetId), + o = i.format(t.formatterOptions); + (e.on("finish", () => { + r(); + }), + o.on("error", n), + o.pipe(e)); + const { dateFormat: l, dateUTC: c } = t, + u = + t.map || + ((e) => { + if (e) { + if (e.text || e.hyperlink) + return e.hyperlink || e.text || ""; + if (e.formula || e.result) return e.result || ""; + if (e instanceof Date) + return l + ? c + ? a.utc(e).format(l) + : a(e).format(l) + : c + ? a.utc(e).format() + : a(e).format(); + if (e.error) return e.error; + if ("object" == typeof e) return JSON.stringify(e); + } + return e; + }), + h = void 0 === t.includeEmptyRows || t.includeEmptyRows; + let f = 1; + (s && + s.eachRow((e, t) => { + if (h) for (; f++ < t - 1; ) o.write([]); + const { values: r } = e; + (r.shift(), o.write(r.map(u)), (f = t)); + }), + o.end()); + }); + } + writeFile(e, t) { + const r = { encoding: (t = t || {}).encoding || "utf8" }, + i = n.createWriteStream(e, r); + return this.write(i, t); + } + async writeBuffer(e) { + const t = new l(); + return (await this.write(t, e), t.read()); + } + }; + }, + { + "../utils/stream-buf": 24, + "../utils/utils": 27, + dayjs: 391, + "dayjs/plugin/customParseFormat": 392, + "dayjs/plugin/utc": 393, + "fast-csv": 424, + fs: 216, + }, + ], + 2: [ + function (e, t, r) { + "use strict"; + const n = e("../utils/col-cache"); + class i { + constructor(e, t) { + let r = + arguments.length > 2 && void 0 !== arguments[2] + ? arguments[2] + : 0; + if (((this.worksheet = e), t)) + if ("string" == typeof t) { + const e = n.decodeAddress(t); + ((this.nativeCol = e.col + r), + (this.nativeColOff = 0), + (this.nativeRow = e.row + r), + (this.nativeRowOff = 0)); + } else + void 0 !== t.nativeCol + ? ((this.nativeCol = t.nativeCol || 0), + (this.nativeColOff = t.nativeColOff || 0), + (this.nativeRow = t.nativeRow || 0), + (this.nativeRowOff = t.nativeRowOff || 0)) + : void 0 !== t.col + ? ((this.col = t.col + r), (this.row = t.row + r)) + : ((this.nativeCol = 0), + (this.nativeColOff = 0), + (this.nativeRow = 0), + (this.nativeRowOff = 0)); + else + ((this.nativeCol = 0), + (this.nativeColOff = 0), + (this.nativeRow = 0), + (this.nativeRowOff = 0)); + } + static asInstance(e) { + return e instanceof i || null == e ? e : new i(e); + } + get col() { + return ( + this.nativeCol + + Math.min(this.colWidth - 1, this.nativeColOff) / this.colWidth + ); + } + set col(e) { + ((this.nativeCol = Math.floor(e)), + (this.nativeColOff = Math.floor( + (e - this.nativeCol) * this.colWidth, + ))); + } + get row() { + return ( + this.nativeRow + + Math.min(this.rowHeight - 1, this.nativeRowOff) / this.rowHeight + ); + } + set row(e) { + ((this.nativeRow = Math.floor(e)), + (this.nativeRowOff = Math.floor( + (e - this.nativeRow) * this.rowHeight, + ))); + } + get colWidth() { + return this.worksheet && + this.worksheet.getColumn(this.nativeCol + 1) && + this.worksheet.getColumn(this.nativeCol + 1).isCustomWidth + ? Math.floor( + 1e4 * this.worksheet.getColumn(this.nativeCol + 1).width, + ) + : 64e4; + } + get rowHeight() { + return this.worksheet && + this.worksheet.getRow(this.nativeRow + 1) && + this.worksheet.getRow(this.nativeRow + 1).height + ? Math.floor( + 1e4 * this.worksheet.getRow(this.nativeRow + 1).height, + ) + : 18e4; + } + get model() { + return { + nativeCol: this.nativeCol, + nativeColOff: this.nativeColOff, + nativeRow: this.nativeRow, + nativeRowOff: this.nativeRowOff, + }; + } + set model(e) { + ((this.nativeCol = e.nativeCol), + (this.nativeColOff = e.nativeColOff), + (this.nativeRow = e.nativeRow), + (this.nativeRowOff = e.nativeRowOff)); + } + } + t.exports = i; + }, + { "../utils/col-cache": 19 }, + ], + 3: [ + function (e, t, r) { + "use strict"; + const n = e("../utils/col-cache"), + i = e("../utils/under-dash"), + s = e("./enums"), + { slideFormula: o } = e("../utils/shared-formula"), + a = e("./note"); + class l { + constructor(e, t, r) { + if (!e || !t) throw new Error("A Cell needs a Row"); + ((this._row = e), + (this._column = t), + n.validateAddress(r), + (this._address = r), + (this._value = c.create(l.Types.Null, this)), + (this.style = this._mergeStyle(e.style, t.style, {})), + (this._mergeCount = 0)); + } + get worksheet() { + return this._row.worksheet; + } + get workbook() { + return this._row.worksheet.workbook; + } + destroy() { + (delete this.style, + delete this._value, + delete this._row, + delete this._column, + delete this._address); + } + get numFmt() { + return this.style.numFmt; + } + set numFmt(e) { + this.style.numFmt = e; + } + get font() { + return this.style.font; + } + set font(e) { + this.style.font = e; + } + get alignment() { + return this.style.alignment; + } + set alignment(e) { + this.style.alignment = e; + } + get border() { + return this.style.border; + } + set border(e) { + this.style.border = e; + } + get fill() { + return this.style.fill; + } + set fill(e) { + this.style.fill = e; + } + get protection() { + return this.style.protection; + } + set protection(e) { + this.style.protection = e; + } + _mergeStyle(e, t, r) { + const n = (e && e.numFmt) || (t && t.numFmt); + n && (r.numFmt = n); + const i = (e && e.font) || (t && t.font); + i && (r.font = i); + const s = (e && e.alignment) || (t && t.alignment); + s && (r.alignment = s); + const o = (e && e.border) || (t && t.border); + o && (r.border = o); + const a = (e && e.fill) || (t && t.fill); + a && (r.fill = a); + const l = (e && e.protection) || (t && t.protection); + return (l && (r.protection = l), r); + } + get address() { + return this._address; + } + get row() { + return this._row.number; + } + get col() { + return this._column.number; + } + get $col$row() { + return `$${this._column.letter}$${this.row}`; + } + get type() { + return this._value.type; + } + get effectiveType() { + return this._value.effectiveType; + } + toCsvString() { + return this._value.toCsvString(); + } + addMergeRef() { + this._mergeCount++; + } + releaseMergeRef() { + this._mergeCount--; + } + get isMerged() { + return this._mergeCount > 0 || this.type === l.Types.Merge; + } + merge(e, t) { + (this._value.release(), + (this._value = c.create(l.Types.Merge, this, e)), + t || (this.style = e.style)); + } + unmerge() { + this.type === l.Types.Merge && + (this._value.release(), + (this._value = c.create(l.Types.Null, this)), + (this.style = this._mergeStyle( + this._row.style, + this._column.style, + {}, + ))); + } + isMergedTo(e) { + return ( + this._value.type === l.Types.Merge && this._value.isMergedTo(e) + ); + } + get master() { + return this.type === l.Types.Merge ? this._value.master : this; + } + get isHyperlink() { + return this._value.type === l.Types.Hyperlink; + } + get hyperlink() { + return this._value.hyperlink; + } + get value() { + return this._value.value; + } + set value(e) { + this.type !== l.Types.Merge + ? (this._value.release(), + (this._value = c.create(c.getType(e), this, e))) + : (this._value.master.value = e); + } + get note() { + return this._comment && this._comment.note; + } + set note(e) { + this._comment = new a(e); + } + get text() { + return this._value.toString(); + } + get html() { + return i.escapeHtml(this.text); + } + toString() { + return this.text; + } + _upgradeToHyperlink(e) { + this.type === l.Types.String && + (this._value = c.create(l.Types.Hyperlink, this, { + text: this._value.value, + hyperlink: e, + })); + } + get formula() { + return this._value.formula; + } + get result() { + return this._value.result; + } + get formulaType() { + return this._value.formulaType; + } + get fullAddress() { + const { worksheet: e } = this._row; + return { + sheetName: e.name, + address: this.address, + row: this.row, + col: this.col, + }; + } + get name() { + return this.names[0]; + } + set name(e) { + this.names = [e]; + } + get names() { + return this.workbook.definedNames.getNamesEx(this.fullAddress); + } + set names(e) { + const { definedNames: t } = this.workbook; + (t.removeAllNames(this.fullAddress), + e.forEach((e) => { + t.addEx(this.fullAddress, e); + })); + } + addName(e) { + this.workbook.definedNames.addEx(this.fullAddress, e); + } + removeName(e) { + this.workbook.definedNames.removeEx(this.fullAddress, e); + } + removeAllNames() { + this.workbook.definedNames.removeAllNames(this.fullAddress); + } + get _dataValidations() { + return this.worksheet.dataValidations; + } + get dataValidation() { + return this._dataValidations.find(this.address); + } + set dataValidation(e) { + this._dataValidations.add(this.address, e); + } + get model() { + const { model: e } = this._value; + return ( + (e.style = this.style), + this._comment && (e.comment = this._comment.model), + e + ); + } + set model(e) { + if ( + (this._value.release(), + (this._value = c.create(e.type, this)), + (this._value.model = e), + e.comment) + ) + switch (e.comment.type) { + case "note": + this._comment = a.fromModel(e.comment); + } + e.style ? (this.style = e.style) : (this.style = {}); + } + } + l.Types = s.ValueType; + const c = { + getType: (e) => + null == e + ? l.Types.Null + : e instanceof String || "string" == typeof e + ? l.Types.String + : "number" == typeof e + ? l.Types.Number + : "boolean" == typeof e + ? l.Types.Boolean + : e instanceof Date + ? l.Types.Date + : e.text && e.hyperlink + ? l.Types.Hyperlink + : e.formula || e.sharedFormula + ? l.Types.Formula + : e.richText + ? l.Types.RichText + : e.sharedString + ? l.Types.SharedString + : e.error + ? l.Types.Error + : l.Types.JSON, + types: [ + { + t: l.Types.Null, + f: class { + constructor(e) { + this.model = { address: e.address, type: l.Types.Null }; + } + get value() { + return null; + } + set value(e) {} + get type() { + return l.Types.Null; + } + get effectiveType() { + return l.Types.Null; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + toCsvString() { + return ""; + } + release() {} + toString() { + return ""; + } + }, + }, + { + t: l.Types.Number, + f: class { + constructor(e, t) { + this.model = { + address: e.address, + type: l.Types.Number, + value: t, + }; + } + get value() { + return this.model.value; + } + set value(e) { + this.model.value = e; + } + get type() { + return l.Types.Number; + } + get effectiveType() { + return l.Types.Number; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + toCsvString() { + return this.model.value.toString(); + } + release() {} + toString() { + return this.model.value.toString(); + } + }, + }, + { + t: l.Types.String, + f: class { + constructor(e, t) { + this.model = { + address: e.address, + type: l.Types.String, + value: t, + }; + } + get value() { + return this.model.value; + } + set value(e) { + this.model.value = e; + } + get type() { + return l.Types.String; + } + get effectiveType() { + return l.Types.String; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + toCsvString() { + return `"${this.model.value.replace(/"/g, '""')}"`; + } + release() {} + toString() { + return this.model.value; + } + }, + }, + { + t: l.Types.Date, + f: class { + constructor(e, t) { + this.model = { + address: e.address, + type: l.Types.Date, + value: t, + }; + } + get value() { + return this.model.value; + } + set value(e) { + this.model.value = e; + } + get type() { + return l.Types.Date; + } + get effectiveType() { + return l.Types.Date; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + toCsvString() { + return this.model.value.toISOString(); + } + release() {} + toString() { + return this.model.value.toString(); + } + }, + }, + { + t: l.Types.Hyperlink, + f: class { + constructor(e, t) { + ((this.model = { + address: e.address, + type: l.Types.Hyperlink, + text: t ? t.text : void 0, + hyperlink: t ? t.hyperlink : void 0, + }), + t && t.tooltip && (this.model.tooltip = t.tooltip)); + } + get value() { + const e = { + text: this.model.text, + hyperlink: this.model.hyperlink, + }; + return ( + this.model.tooltip && (e.tooltip = this.model.tooltip), + e + ); + } + set value(e) { + ((this.model = { text: e.text, hyperlink: e.hyperlink }), + e.tooltip && (this.model.tooltip = e.tooltip)); + } + get text() { + return this.model.text; + } + set text(e) { + this.model.text = e; + } + get hyperlink() { + return this.model.hyperlink; + } + set hyperlink(e) { + this.model.hyperlink = e; + } + get type() { + return l.Types.Hyperlink; + } + get effectiveType() { + return l.Types.Hyperlink; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + toCsvString() { + return this.model.hyperlink; + } + release() {} + toString() { + return this.model.text; + } + }, + }, + { + t: l.Types.Formula, + f: class { + constructor(e, t) { + ((this.cell = e), + (this.model = { + address: e.address, + type: l.Types.Formula, + shareType: t ? t.shareType : void 0, + ref: t ? t.ref : void 0, + formula: t ? t.formula : void 0, + sharedFormula: t ? t.sharedFormula : void 0, + result: t ? t.result : void 0, + })); + } + _copyModel(e) { + const t = {}, + r = (r) => { + const n = e[r]; + n && (t[r] = n); + }; + return ( + r("formula"), + r("result"), + r("ref"), + r("shareType"), + r("sharedFormula"), + t + ); + } + get value() { + return this._copyModel(this.model); + } + set value(e) { + this.model = this._copyModel(e); + } + validate(e) { + switch (c.getType(e)) { + case l.Types.Null: + case l.Types.String: + case l.Types.Number: + case l.Types.Date: + break; + case l.Types.Hyperlink: + case l.Types.Formula: + default: + throw new Error( + "Cannot process that type of result value", + ); + } + } + get dependencies() { + return { + ranges: this.formula.match( + /([a-zA-Z0-9]+!)?[A-Z]{1,3}\d{1,4}:[A-Z]{1,3}\d{1,4}/g, + ), + cells: this.formula + .replace( + /([a-zA-Z0-9]+!)?[A-Z]{1,3}\d{1,4}:[A-Z]{1,3}\d{1,4}/g, + "", + ) + .match(/([a-zA-Z0-9]+!)?[A-Z]{1,3}\d{1,4}/g), + }; + } + get formula() { + return this.model.formula || this._getTranslatedFormula(); + } + set formula(e) { + this.model.formula = e; + } + get formulaType() { + return this.model.formula + ? s.FormulaType.Master + : this.model.sharedFormula + ? s.FormulaType.Shared + : s.FormulaType.None; + } + get result() { + return this.model.result; + } + set result(e) { + this.model.result = e; + } + get type() { + return l.Types.Formula; + } + get effectiveType() { + const e = this.model.result; + return null == e + ? s.ValueType.Null + : e instanceof String || "string" == typeof e + ? s.ValueType.String + : "number" == typeof e + ? s.ValueType.Number + : e instanceof Date + ? s.ValueType.Date + : e.text && e.hyperlink + ? s.ValueType.Hyperlink + : e.formula + ? s.ValueType.Formula + : s.ValueType.Null; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + _getTranslatedFormula() { + if (!this._translatedFormula && this.model.sharedFormula) { + const { worksheet: e } = this.cell, + t = e.findCell(this.model.sharedFormula); + this._translatedFormula = + t && o(t.formula, t.address, this.model.address); + } + return this._translatedFormula; + } + toCsvString() { + return "" + (this.model.result || ""); + } + release() {} + toString() { + return this.model.result + ? this.model.result.toString() + : ""; + } + }, + }, + { + t: l.Types.Merge, + f: class { + constructor(e, t) { + ((this.model = { + address: e.address, + type: l.Types.Merge, + master: t ? t.address : void 0, + }), + (this._master = t), + t && t.addMergeRef()); + } + get value() { + return this._master.value; + } + set value(e) { + e instanceof l + ? (this._master && this._master.releaseMergeRef(), + e.addMergeRef(), + (this._master = e)) + : (this._master.value = e); + } + isMergedTo(e) { + return e === this._master; + } + get master() { + return this._master; + } + get type() { + return l.Types.Merge; + } + get effectiveType() { + return this._master.effectiveType; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + toCsvString() { + return ""; + } + release() { + this._master.releaseMergeRef(); + } + toString() { + return this.value.toString(); + } + }, + }, + { + t: l.Types.JSON, + f: class { + constructor(e, t) { + this.model = { + address: e.address, + type: l.Types.String, + value: JSON.stringify(t), + rawValue: t, + }; + } + get value() { + return this.model.rawValue; + } + set value(e) { + ((this.model.rawValue = e), + (this.model.value = JSON.stringify(e))); + } + get type() { + return l.Types.String; + } + get effectiveType() { + return l.Types.String; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + toCsvString() { + return this.model.value; + } + release() {} + toString() { + return this.model.value; + } + }, + }, + { + t: l.Types.SharedString, + f: class { + constructor(e, t) { + this.model = { + address: e.address, + type: l.Types.SharedString, + value: t, + }; + } + get value() { + return this.model.value; + } + set value(e) { + this.model.value = e; + } + get type() { + return l.Types.SharedString; + } + get effectiveType() { + return l.Types.SharedString; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + toCsvString() { + return this.model.value.toString(); + } + release() {} + toString() { + return this.model.value.toString(); + } + }, + }, + { + t: l.Types.RichText, + f: class { + constructor(e, t) { + this.model = { + address: e.address, + type: l.Types.String, + value: t, + }; + } + get value() { + return this.model.value; + } + set value(e) { + this.model.value = e; + } + toString() { + return this.model.value.richText + .map((e) => e.text) + .join(""); + } + get type() { + return l.Types.RichText; + } + get effectiveType() { + return l.Types.RichText; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + toCsvString() { + return `"${this.text.replace(/"/g, '""')}"`; + } + release() {} + }, + }, + { + t: l.Types.Boolean, + f: class { + constructor(e, t) { + this.model = { + address: e.address, + type: l.Types.Boolean, + value: t, + }; + } + get value() { + return this.model.value; + } + set value(e) { + this.model.value = e; + } + get type() { + return l.Types.Boolean; + } + get effectiveType() { + return l.Types.Boolean; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + toCsvString() { + return this.model.value ? 1 : 0; + } + release() {} + toString() { + return this.model.value.toString(); + } + }, + }, + { + t: l.Types.Error, + f: class { + constructor(e, t) { + this.model = { + address: e.address, + type: l.Types.Error, + value: t, + }; + } + get value() { + return this.model.value; + } + set value(e) { + this.model.value = e; + } + get type() { + return l.Types.Error; + } + get effectiveType() { + return l.Types.Error; + } + get address() { + return this.model.address; + } + set address(e) { + this.model.address = e; + } + toCsvString() { + return this.toString(); + } + release() {} + toString() { + return this.model.value.error.toString(); + } + }, + }, + ].reduce((e, t) => ((e[t.t] = t.f), e), []), + create(e, t, r) { + const n = this.types[e]; + if (!n) throw new Error("Could not create Value of type " + e); + return new n(t, r); + }, + }; + t.exports = l; + }, + { + "../utils/col-cache": 19, + "../utils/shared-formula": 23, + "../utils/under-dash": 26, + "./enums": 7, + "./note": 9, + }, + ], + 4: [ + function (e, t, r) { + "use strict"; + const n = e("../utils/under-dash"), + i = e("./enums"), + s = e("../utils/col-cache"); + class o { + constructor(e, t, r) { + ((this._worksheet = e), + (this._number = t), + !1 !== r && (this.defn = r)); + } + get number() { + return this._number; + } + get worksheet() { + return this._worksheet; + } + get letter() { + return s.n2l(this._number); + } + get isCustomWidth() { + return void 0 !== this.width && 9 !== this.width; + } + get defn() { + return { + header: this._header, + key: this.key, + width: this.width, + style: this.style, + hidden: this.hidden, + outlineLevel: this.outlineLevel, + }; + } + set defn(e) { + e + ? ((this.key = e.key), + (this.width = void 0 !== e.width ? e.width : 9), + (this.outlineLevel = e.outlineLevel), + e.style ? (this.style = e.style) : (this.style = {}), + (this.header = e.header), + (this._hidden = !!e.hidden)) + : (delete this._header, + delete this._key, + delete this.width, + (this.style = {}), + (this.outlineLevel = 0)); + } + get headers() { + return this._header && this._header instanceof Array + ? this._header + : [this._header]; + } + get header() { + return this._header; + } + set header(e) { + void 0 !== e + ? ((this._header = e), + this.headers.forEach((e, t) => { + this._worksheet.getCell(t + 1, this.number).value = e; + })) + : (this._header = void 0); + } + get key() { + return this._key; + } + set key(e) { + ((this._key && this._worksheet.getColumnKey(this._key)) === + this && this._worksheet.deleteColumnKey(this._key), + (this._key = e), + e && this._worksheet.setColumnKey(this._key, this)); + } + get hidden() { + return !!this._hidden; + } + set hidden(e) { + this._hidden = e; + } + get outlineLevel() { + return this._outlineLevel || 0; + } + set outlineLevel(e) { + this._outlineLevel = e; + } + get collapsed() { + return !!( + this._outlineLevel && + this._outlineLevel >= this._worksheet.properties.outlineLevelCol + ); + } + toString() { + return JSON.stringify({ + key: this.key, + width: this.width, + headers: this.headers.length ? this.headers : void 0, + }); + } + equivalentTo(e) { + return ( + this.width === e.width && + this.hidden === e.hidden && + this.outlineLevel === e.outlineLevel && + n.isEqual(this.style, e.style) + ); + } + get isDefault() { + if (this.isCustomWidth) return !1; + if (this.hidden) return !1; + if (this.outlineLevel) return !1; + const e = this.style; + return ( + !e || + !( + e.font || + e.numFmt || + e.alignment || + e.border || + e.fill || + e.protection + ) + ); + } + get headerCount() { + return this.headers.length; + } + eachCell(e, t) { + const r = this.number; + (t || ((t = e), (e = null)), + this._worksheet.eachRow(e, (e, n) => { + t(e.getCell(r), n); + })); + } + get values() { + const e = []; + return ( + this.eachCell((t, r) => { + t && t.type !== i.ValueType.Null && (e[r] = t.value); + }), + e + ); + } + set values(e) { + if (!e) return; + const t = this.number; + let r = 0; + (e.hasOwnProperty("0") && (r = 1), + e.forEach((e, n) => { + this._worksheet.getCell(n + r, t).value = e; + })); + } + _applyStyle(e, t) { + return ( + (this.style[e] = t), + this.eachCell((r) => { + r[e] = t; + }), + t + ); + } + get numFmt() { + return this.style.numFmt; + } + set numFmt(e) { + this._applyStyle("numFmt", e); + } + get font() { + return this.style.font; + } + set font(e) { + this._applyStyle("font", e); + } + get alignment() { + return this.style.alignment; + } + set alignment(e) { + this._applyStyle("alignment", e); + } + get protection() { + return this.style.protection; + } + set protection(e) { + this._applyStyle("protection", e); + } + get border() { + return this.style.border; + } + set border(e) { + this._applyStyle("border", e); + } + get fill() { + return this.style.fill; + } + set fill(e) { + this._applyStyle("fill", e); + } + static toModel(e) { + const t = []; + let r = null; + return ( + e && + e.forEach((e, n) => { + e.isDefault + ? r && (r = null) + : r && e.equivalentTo(r) + ? (r.max = n + 1) + : ((r = { + min: n + 1, + max: n + 1, + width: void 0 !== e.width ? e.width : 9, + style: e.style, + isCustomWidth: e.isCustomWidth, + hidden: e.hidden, + outlineLevel: e.outlineLevel, + collapsed: e.collapsed, + }), + t.push(r)); + }), + t.length ? t : void 0 + ); + } + static fromModel(e, t) { + const r = []; + let n = 1, + i = 0; + for ( + t = (t = t || []).sort(function (e, t) { + return e.min - t.min; + }); + i < t.length; + ) { + const s = t[i++]; + for (; n < s.min; ) r.push(new o(e, n++)); + for (; n <= s.max; ) r.push(new o(e, n++, s)); + } + return r.length ? r : null; + } + } + t.exports = o; + }, + { "../utils/col-cache": 19, "../utils/under-dash": 26, "./enums": 7 }, + ], + 5: [ + function (e, t, r) { + "use strict"; + t.exports = class { + constructor(e) { + this.model = e || {}; + } + add(e, t) { + return (this.model[e] = t); + } + find(e) { + return this.model[e]; + } + remove(e) { + this.model[e] = void 0; + } + }; + }, + {}, + ], + 6: [ + function (e, t, r) { + "use strict"; + const n = e("../utils/under-dash"), + i = e("../utils/col-cache"), + s = e("../utils/cell-matrix"), + o = e("./range"), + a = /[$](\w+)[$](\d+)(:[$](\w+)[$](\d+))?/; + t.exports = class { + constructor() { + this.matrixMap = {}; + } + getMatrix(e) { + return this.matrixMap[e] || (this.matrixMap[e] = new s()); + } + add(e, t) { + const r = i.decodeEx(e); + this.addEx(r, t); + } + addEx(e, t) { + const r = this.getMatrix(t); + if (e.top) + for (let t = e.left; t <= e.right; t++) + for (let n = e.top; n <= e.bottom; n++) { + const s = { + sheetName: e.sheetName, + address: i.n2l(t) + n, + row: n, + col: t, + }; + r.addCellEx(s); + } + else r.addCellEx(e); + } + remove(e, t) { + const r = i.decodeEx(e); + this.removeEx(r, t); + } + removeEx(e, t) { + this.getMatrix(t).removeCellEx(e); + } + removeAllNames(e) { + n.each(this.matrixMap, (t) => { + t.removeCellEx(e); + }); + } + forEach(e) { + n.each(this.matrixMap, (t, r) => { + t.forEach((t) => { + e(r, t); + }); + }); + } + getNames(e) { + return this.getNamesEx(i.decodeEx(e)); + } + getNamesEx(e) { + return n + .map(this.matrixMap, (t, r) => t.findCellEx(e) && r) + .filter(Boolean); + } + _explore(e, t) { + t.mark = !1; + const { sheetName: r } = t, + n = new o(t.row, t.col, t.row, t.col, r); + let i, s; + function a(i, s) { + const o = e.findCellAt(r, i, t.col); + return !(!o || !o.mark) && ((n[s] = i), (o.mark = !1), !0); + } + for (s = t.row - 1; a(s, "top"); s--); + for (s = t.row + 1; a(s, "bottom"); s++); + function l(t, i) { + const o = []; + for (s = n.top; s <= n.bottom; s++) { + const n = e.findCellAt(r, s, t); + if (!n || !n.mark) return !1; + o.push(n); + } + n[i] = t; + for (let e = 0; e < o.length; e++) o[e].mark = !1; + return !0; + } + for (i = t.col - 1; l(i, "left"); i--); + for (i = t.col + 1; l(i, "right"); i++); + return n; + } + getRanges(e, t) { + if (!(t = t || this.matrixMap[e])) return { name: e, ranges: [] }; + t.forEach((e) => { + e.mark = !0; + }); + return { + name: e, + ranges: t + .map((e) => e.mark && this._explore(t, e)) + .filter(Boolean) + .map((e) => e.$shortRange), + }; + } + normaliseMatrix(e, t) { + e.forEachInSheet(t, (e, t, r) => { + e && + ((e.row === t && e.col === r) || + ((e.row = t), (e.col = r), (e.address = i.n2l(r) + t))); + }); + } + spliceRows(e, t, r, i) { + n.each(this.matrixMap, (n) => { + (n.spliceRows(e, t, r, i), this.normaliseMatrix(n, e)); + }); + } + spliceColumns(e, t, r, i) { + n.each(this.matrixMap, (n) => { + (n.spliceColumns(e, t, r, i), this.normaliseMatrix(n, e)); + }); + } + get model() { + return n + .map(this.matrixMap, (e, t) => this.getRanges(t, e)) + .filter((e) => e.ranges.length); + } + set model(e) { + const t = (this.matrixMap = {}); + e.forEach((e) => { + const r = (t[e.name] = new s()); + e.ranges.forEach((e) => { + a.test(e.split("!").pop() || "") && r.addCell(e); + }); + }); + } + }; + }, + { + "../utils/cell-matrix": 18, + "../utils/col-cache": 19, + "../utils/under-dash": 26, + "./range": 10, + }, + ], + 7: [ + function (e, t, r) { + "use strict"; + t.exports = { + ValueType: { + Null: 0, + Merge: 1, + Number: 2, + String: 3, + Date: 4, + Hyperlink: 5, + Formula: 6, + SharedString: 7, + RichText: 8, + Boolean: 9, + Error: 10, + }, + FormulaType: { None: 0, Master: 1, Shared: 2 }, + RelationshipType: { + None: 0, + OfficeDocument: 1, + Worksheet: 2, + CalcChain: 3, + SharedStrings: 4, + Styles: 5, + Theme: 6, + Hyperlink: 7, + }, + DocumentType: { Xlsx: 1 }, + ReadingOrder: { LeftToRight: 1, RightToLeft: 2 }, + ErrorValue: { + NotApplicable: "#N/A", + Ref: "#REF!", + Name: "#NAME?", + DivZero: "#DIV/0!", + Null: "#NULL!", + Value: "#VALUE!", + Num: "#NUM!", + }, + }; + }, + {}, + ], + 8: [ + function (e, t, r) { + "use strict"; + const n = e("../utils/col-cache"), + i = e("./anchor"); + t.exports = class { + constructor(e, t) { + ((this.worksheet = e), (this.model = t)); + } + get model() { + switch (this.type) { + case "background": + return { type: this.type, imageId: this.imageId }; + case "image": + return { + type: this.type, + imageId: this.imageId, + hyperlinks: this.range.hyperlinks, + range: { + tl: this.range.tl.model, + br: this.range.br && this.range.br.model, + ext: this.range.ext, + editAs: this.range.editAs, + }, + }; + default: + throw new Error("Invalid Image Type"); + } + } + set model(e) { + let { type: t, imageId: r, range: s, hyperlinks: o } = e; + if (((this.type = t), (this.imageId = r), "image" === t)) + if ("string" == typeof s) { + const e = n.decode(s); + this.range = { + tl: new i(this.worksheet, { col: e.left, row: e.top }, -1), + br: new i( + this.worksheet, + { col: e.right, row: e.bottom }, + 0, + ), + editAs: "oneCell", + }; + } else + this.range = { + tl: new i(this.worksheet, s.tl, 0), + br: s.br && new i(this.worksheet, s.br, 0), + ext: s.ext, + editAs: s.editAs, + hyperlinks: o || s.hyperlinks, + }; + } + }; + }, + { "../utils/col-cache": 19, "./anchor": 2 }, + ], + 9: [ + function (e, t, r) { + "use strict"; + const n = e("../utils/under-dash"); + class i { + constructor(e) { + this.note = e; + } + get model() { + let e = null; + switch (typeof this.note) { + case "string": + e = { type: "note", note: { texts: [{ text: this.note }] } }; + break; + default: + e = { type: "note", note: this.note }; + } + return n.deepMerge({}, i.DEFAULT_CONFIGS, e); + } + set model(e) { + const { note: t } = e, + { texts: r } = t; + 1 === r.length && 1 === Object.keys(r[0]).length + ? (this.note = r[0].text) + : (this.note = t); + } + static fromModel(e) { + const t = new i(); + return ((t.model = e), t); + } + } + ((i.DEFAULT_CONFIGS = { + note: { + margins: { insetmode: "auto", inset: [0.13, 0.13, 0.25, 0.25] }, + protection: { locked: "True", lockText: "True" }, + editAs: "absolute", + }, + }), + (t.exports = i)); + }, + { "../utils/under-dash": 26 }, + ], + 10: [ + function (e, t, r) { + "use strict"; + const n = e("../utils/col-cache"); + class i { + constructor() { + this.decode(arguments); + } + setTLBR(e, t, r, i, s) { + if (arguments.length < 4) { + const i = n.decodeAddress(e), + o = n.decodeAddress(t); + ((this.model = { + top: Math.min(i.row, o.row), + left: Math.min(i.col, o.col), + bottom: Math.max(i.row, o.row), + right: Math.max(i.col, o.col), + sheetName: r, + }), + this.setTLBR(i.row, i.col, o.row, o.col, s)); + } else + this.model = { + top: Math.min(e, r), + left: Math.min(t, i), + bottom: Math.max(e, r), + right: Math.max(t, i), + sheetName: s, + }; + } + decode(e) { + switch (e.length) { + case 5: + this.setTLBR(e[0], e[1], e[2], e[3], e[4]); + break; + case 4: + this.setTLBR(e[0], e[1], e[2], e[3]); + break; + case 3: + this.setTLBR(e[0], e[1], e[2]); + break; + case 2: + this.setTLBR(e[0], e[1]); + break; + case 1: { + const t = e[0]; + if (t instanceof i) + this.model = { + top: t.model.top, + left: t.model.left, + bottom: t.model.bottom, + right: t.model.right, + sheetName: t.sheetName, + }; + else if (t instanceof Array) this.decode(t); + else if (t.top && t.left && t.bottom && t.right) + this.model = { + top: t.top, + left: t.left, + bottom: t.bottom, + right: t.right, + sheetName: t.sheetName, + }; + else { + const e = n.decodeEx(t); + e.top + ? (this.model = { + top: e.top, + left: e.left, + bottom: e.bottom, + right: e.right, + sheetName: e.sheetName, + }) + : (this.model = { + top: e.row, + left: e.col, + bottom: e.row, + right: e.col, + sheetName: e.sheetName, + }); + } + break; + } + case 0: + this.model = { top: 0, left: 0, bottom: 0, right: 0 }; + break; + default: + throw new Error( + "Invalid number of arguments to _getDimensions() - " + + e.length, + ); + } + } + get top() { + return this.model.top || 1; + } + set top(e) { + this.model.top = e; + } + get left() { + return this.model.left || 1; + } + set left(e) { + this.model.left = e; + } + get bottom() { + return this.model.bottom || 1; + } + set bottom(e) { + this.model.bottom = e; + } + get right() { + return this.model.right || 1; + } + set right(e) { + this.model.right = e; + } + get sheetName() { + return this.model.sheetName; + } + set sheetName(e) { + this.model.sheetName = e; + } + get _serialisedSheetName() { + const { sheetName: e } = this.model; + return e ? (/^[a-zA-Z0-9]*$/.test(e) ? e + "!" : `'${e}'!`) : ""; + } + expand(e, t, r, n) { + ((!this.model.top || e < this.top) && (this.top = e), + (!this.model.left || t < this.left) && (this.left = t), + (!this.model.bottom || r > this.bottom) && (this.bottom = r), + (!this.model.right || n > this.right) && (this.right = n)); + } + expandRow(e) { + if (e) { + const { dimensions: t, number: r } = e; + t && this.expand(r, t.min, r, t.max); + } + } + expandToAddress(e) { + const t = n.decodeEx(e); + this.expand(t.row, t.col, t.row, t.col); + } + get tl() { + return n.n2l(this.left) + this.top; + } + get $t$l() { + return `$${n.n2l(this.left)}$${this.top}`; + } + get br() { + return n.n2l(this.right) + this.bottom; + } + get $b$r() { + return `$${n.n2l(this.right)}$${this.bottom}`; + } + get range() { + return `${this._serialisedSheetName + this.tl}:${this.br}`; + } + get $range() { + return `${this._serialisedSheetName + this.$t$l}:${this.$b$r}`; + } + get shortRange() { + return this.count > 1 + ? this.range + : this._serialisedSheetName + this.tl; + } + get $shortRange() { + return this.count > 1 + ? this.$range + : this._serialisedSheetName + this.$t$l; + } + get count() { + return ( + (1 + this.bottom - this.top) * (1 + this.right - this.left) + ); + } + toString() { + return this.range; + } + intersects(e) { + return ( + (!e.sheetName || + !this.sheetName || + e.sheetName === this.sheetName) && + !(e.bottom < this.top) && + !(e.top > this.bottom) && + !(e.right < this.left) && + !(e.left > this.right) + ); + } + contains(e) { + const t = n.decodeEx(e); + return this.containsEx(t); + } + containsEx(e) { + return ( + (!e.sheetName || + !this.sheetName || + e.sheetName === this.sheetName) && + e.row >= this.top && + e.row <= this.bottom && + e.col >= this.left && + e.col <= this.right + ); + } + forEachAddress(e) { + for (let t = this.left; t <= this.right; t++) + for (let r = this.top; r <= this.bottom; r++) + e(n.encodeAddress(r, t), r, t); + } + } + t.exports = i; + }, + { "../utils/col-cache": 19 }, + ], + 11: [ + function (e, t, r) { + "use strict"; + const n = e("../utils/under-dash"), + i = e("./enums"), + s = e("../utils/col-cache"), + o = e("./cell"); + t.exports = class { + constructor(e, t) { + ((this._worksheet = e), + (this._number = t), + (this._cells = []), + (this.style = {}), + (this.outlineLevel = 0)); + } + get number() { + return this._number; + } + get worksheet() { + return this._worksheet; + } + commit() { + this._worksheet._commitRow(this); + } + destroy() { + (delete this._worksheet, delete this._cells, delete this.style); + } + findCell(e) { + return this._cells[e - 1]; + } + getCellEx(e) { + let t = this._cells[e.col - 1]; + if (!t) { + const r = this._worksheet.getColumn(e.col); + ((t = new o(this, r, e.address)), (this._cells[e.col - 1] = t)); + } + return t; + } + getCell(e) { + if ("string" == typeof e) { + const t = this._worksheet.getColumnKey(e); + e = t ? t.number : s.l2n(e); + } + return ( + this._cells[e - 1] || + this.getCellEx({ + address: s.encodeAddress(this._number, e), + row: this._number, + col: e, + }) + ); + } + splice(e, t) { + const r = e + t; + for ( + var n = arguments.length, + i = new Array(n > 2 ? n - 2 : 0), + s = 2; + s < n; + s++ + ) + i[s - 2] = arguments[s]; + const o = i.length - t, + a = this._cells.length; + let l, c, u; + if (o < 0) + for (l = e + i.length; l <= a; l++) + ((u = this._cells[l - 1]), + (c = this._cells[l - o - 1]), + c + ? ((u = this.getCell(l)), + (u.value = c.value), + (u.style = c.style), + (u._comment = c._comment)) + : u && + ((u.value = null), + (u.style = {}), + (u._comment = void 0))); + else if (o > 0) + for (l = a; l >= r; l--) + ((c = this._cells[l - 1]), + c + ? ((u = this.getCell(l + o)), + (u.value = c.value), + (u.style = c.style), + (u._comment = c._comment)) + : (this._cells[l + o - 1] = void 0)); + for (l = 0; l < i.length; l++) + ((u = this.getCell(e + l)), + (u.value = i[l]), + (u.style = {}), + (u._comment = void 0)); + } + eachCell(e, t) { + if ((t || ((t = e), (e = null)), e && e.includeEmpty)) { + const e = this._cells.length; + for (let r = 1; r <= e; r++) t(this.getCell(r), r); + } else + this._cells.forEach((e, r) => { + e && e.type !== i.ValueType.Null && t(e, r + 1); + }); + } + addPageBreak(e, t) { + const r = this._worksheet, + n = Math.max(0, e - 1) || 0, + i = Math.max(0, t - 1) || 16838, + s = { id: this._number, max: i, man: 1 }; + (n && (s.min = n), r.rowBreaks.push(s)); + } + get values() { + const e = []; + return ( + this._cells.forEach((t) => { + t && t.type !== i.ValueType.Null && (e[t.col] = t.value); + }), + e + ); + } + set values(e) { + if (((this._cells = []), e)) + if (e instanceof Array) { + let t = 0; + (e.hasOwnProperty("0") && (t = 1), + e.forEach((e, r) => { + void 0 !== e && + (this.getCellEx({ + address: s.encodeAddress(this._number, r + t), + row: this._number, + col: r + t, + }).value = e); + })); + } else + this._worksheet.eachColumnKey((t, r) => { + void 0 !== e[r] && + (this.getCellEx({ + address: s.encodeAddress(this._number, t.number), + row: this._number, + col: t.number, + }).value = e[r]); + }); + else; + } + get hasValues() { + return n.some( + this._cells, + (e) => e && e.type !== i.ValueType.Null, + ); + } + get cellCount() { + return this._cells.length; + } + get actualCellCount() { + let e = 0; + return ( + this.eachCell(() => { + e++; + }), + e + ); + } + get dimensions() { + let e = 0, + t = 0; + return ( + this._cells.forEach((r) => { + r && + r.type !== i.ValueType.Null && + ((!e || e > r.col) && (e = r.col), + t < r.col && (t = r.col)); + }), + e > 0 ? { min: e, max: t } : null + ); + } + _applyStyle(e, t) { + return ( + (this.style[e] = t), + this._cells.forEach((r) => { + r && (r[e] = t); + }), + t + ); + } + get numFmt() { + return this.style.numFmt; + } + set numFmt(e) { + this._applyStyle("numFmt", e); + } + get font() { + return this.style.font; + } + set font(e) { + this._applyStyle("font", e); + } + get alignment() { + return this.style.alignment; + } + set alignment(e) { + this._applyStyle("alignment", e); + } + get protection() { + return this.style.protection; + } + set protection(e) { + this._applyStyle("protection", e); + } + get border() { + return this.style.border; + } + set border(e) { + this._applyStyle("border", e); + } + get fill() { + return this.style.fill; + } + set fill(e) { + this._applyStyle("fill", e); + } + get hidden() { + return !!this._hidden; + } + set hidden(e) { + this._hidden = e; + } + get outlineLevel() { + return this._outlineLevel || 0; + } + set outlineLevel(e) { + this._outlineLevel = e; + } + get collapsed() { + return !!( + this._outlineLevel && + this._outlineLevel >= this._worksheet.properties.outlineLevelRow + ); + } + get model() { + const e = []; + let t = 0, + r = 0; + return ( + this._cells.forEach((n) => { + if (n) { + const i = n.model; + i && + ((!t || t > n.col) && (t = n.col), + r < n.col && (r = n.col), + e.push(i)); + } + }), + this.height || e.length + ? { + cells: e, + number: this.number, + min: t, + max: r, + height: this.height, + style: this.style, + hidden: this.hidden, + outlineLevel: this.outlineLevel, + collapsed: this.collapsed, + } + : null + ); + } + set model(e) { + if (e.number !== this._number) + throw new Error("Invalid row number in model"); + let t; + ((this._cells = []), + e.cells.forEach((e) => { + switch (e.type) { + case o.Types.Merge: + break; + default: { + let r; + if (e.address) r = s.decodeAddress(e.address); + else if (t) { + const { row: e } = t, + n = t.col + 1; + r = { + row: e, + col: n, + address: s.encodeAddress(e, n), + $col$row: `$${s.n2l(n)}$${e}`, + }; + } + t = r; + this.getCellEx(r).model = e; + break; + } + } + }), + e.height ? (this.height = e.height) : delete this.height, + (this.hidden = e.hidden), + (this.outlineLevel = e.outlineLevel || 0), + (this.style = + (e.style && JSON.parse(JSON.stringify(e.style))) || {})); + } + }; + }, + { + "../utils/col-cache": 19, + "../utils/under-dash": 26, + "./cell": 3, + "./enums": 7, + }, + ], + 12: [ + function (e, t, r) { + "use strict"; + const n = e("../utils/col-cache"); + class i { + constructor(e, t, r) { + ((this.table = e), (this.column = t), (this.index = r)); + } + _set(e, t) { + (this.table.cacheState(), (this.column[e] = t)); + } + get name() { + return this.column.name; + } + set name(e) { + this._set("name", e); + } + get filterButton() { + return this.column.filterButton; + } + set filterButton(e) { + this.column.filterButton = e; + } + get style() { + return this.column.style; + } + set style(e) { + this.column.style = e; + } + get totalsRowLabel() { + return this.column.totalsRowLabel; + } + set totalsRowLabel(e) { + this._set("totalsRowLabel", e); + } + get totalsRowFunction() { + return this.column.totalsRowFunction; + } + set totalsRowFunction(e) { + this._set("totalsRowFunction", e); + } + get totalsRowResult() { + return this.column.totalsRowResult; + } + set totalsRowResult(e) { + this._set("totalsRowResult", e); + } + get totalsRowFormula() { + return this.column.totalsRowFormula; + } + set totalsRowFormula(e) { + this._set("totalsRowFormula", e); + } + } + t.exports = class { + constructor(e, t) { + ((this.worksheet = e), + t && ((this.table = t), this.validate(), this.store())); + } + getFormula(e) { + switch (e.totalsRowFunction) { + case "none": + return null; + case "average": + return `SUBTOTAL(101,${this.table.name}[${e.name}])`; + case "countNums": + return `SUBTOTAL(102,${this.table.name}[${e.name}])`; + case "count": + return `SUBTOTAL(103,${this.table.name}[${e.name}])`; + case "max": + return `SUBTOTAL(104,${this.table.name}[${e.name}])`; + case "min": + return `SUBTOTAL(105,${this.table.name}[${e.name}])`; + case "stdDev": + return `SUBTOTAL(106,${this.table.name}[${e.name}])`; + case "var": + return `SUBTOTAL(107,${this.table.name}[${e.name}])`; + case "sum": + return `SUBTOTAL(109,${this.table.name}[${e.name}])`; + case "custom": + return e.totalsRowFormula; + default: + throw new Error( + "Invalid Totals Row Function: " + e.totalsRowFunction, + ); + } + } + get width() { + return this.table.columns.length; + } + get height() { + return this.table.rows.length; + } + get filterHeight() { + return this.height + (this.table.headerRow ? 1 : 0); + } + get tableHeight() { + return this.filterHeight + (this.table.totalsRow ? 1 : 0); + } + validate() { + const { table: e } = this, + t = (e, t, r) => { + void 0 === e[t] && (e[t] = r); + }; + (t(e, "headerRow", !0), + t(e, "totalsRow", !1), + t(e, "style", {}), + t(e.style, "theme", "TableStyleMedium2"), + t(e.style, "showFirstColumn", !1), + t(e.style, "showLastColumn", !1), + t(e.style, "showRowStripes", !1), + t(e.style, "showColumnStripes", !1)); + const r = (e, t) => { + if (!e) throw new Error(t); + }; + (r(e.ref, "Table must have ref"), + r(e.columns, "Table must have column definitions"), + r(e.rows, "Table must have row definitions"), + (e.tl = n.decodeAddress(e.ref))); + const { row: i, col: s } = e.tl; + (r(i > 0, "Table must be on valid row"), + r(s > 0, "Table must be on valid col")); + const { width: o, filterHeight: a, tableHeight: l } = this; + ((e.autoFilterRef = n.encode(i, s, i + a - 1, s + o - 1)), + (e.tableRef = n.encode(i, s, i + l - 1, s + o - 1)), + e.columns.forEach((e, n) => { + (r(e.name, `Column ${n} must have a name`), + 0 === n + ? t(e, "totalsRowLabel", "Total") + : (t(e, "totalsRowFunction", "none"), + (e.totalsRowFormula = this.getFormula(e)))); + })); + } + store() { + const e = (e, t) => { + t && + Object.keys(t).forEach((r) => { + e[r] = t[r]; + }); + }, + { worksheet: t, table: r } = this, + { row: n, col: i } = r.tl; + let s = 0; + if (r.headerRow) { + const o = t.getRow(n + s++); + r.columns.forEach((t, r) => { + const { style: n, name: s } = t, + a = o.getCell(i + r); + ((a.value = s), e(a, n)); + }); + } + if ( + (r.rows.forEach((o) => { + const a = t.getRow(n + s++); + o.forEach((t, n) => { + const s = a.getCell(i + n); + ((s.value = t), e(s, r.columns[n].style)); + }); + }), + r.totalsRow) + ) { + const o = t.getRow(n + s++); + r.columns.forEach((t, r) => { + const n = o.getCell(i + r); + if (0 === r) n.value = t.totalsRowLabel; + else { + const e = this.getFormula(t); + n.value = e + ? { + formula: t.totalsRowFormula, + result: t.totalsRowResult, + } + : null; + } + e(n, t.style); + }); + } + } + load(e) { + const { table: t } = this, + { row: r, col: n } = t.tl; + let i = 0; + if (t.headerRow) { + const s = e.getRow(r + i++); + t.columns.forEach((e, t) => { + s.getCell(n + t).value = e.name; + }); + } + if ( + (t.rows.forEach((t) => { + const s = e.getRow(r + i++); + t.forEach((e, t) => { + s.getCell(n + t).value = e; + }); + }), + t.totalsRow) + ) { + const s = e.getRow(r + i++); + t.columns.forEach((e, t) => { + const r = s.getCell(n + t); + if (0 === t) r.value = e.totalsRowLabel; + else { + this.getFormula(e) && + (r.value = { + formula: e.totalsRowFormula, + result: e.totalsRowResult, + }); + } + }); + } + } + get model() { + return this.table; + } + set model(e) { + this.table = e; + } + cacheState() { + this._cache || + (this._cache = { + ref: this.ref, + width: this.width, + tableHeight: this.tableHeight, + }); + } + commit() { + if (!this._cache) return; + this.validate(); + const e = n.decodeAddress(this._cache.ref); + if (this.ref !== this._cache.ref) + for (let t = 0; t < this._cache.tableHeight; t++) { + const r = this.worksheet.getRow(e.row + t); + for (let t = 0; t < this._cache.width; t++) { + r.getCell(e.col + t).value = null; + } + } + else { + for ( + let t = this.tableHeight; + t < this._cache.tableHeight; + t++ + ) { + const r = this.worksheet.getRow(e.row + t); + for (let t = 0; t < this._cache.width; t++) { + r.getCell(e.col + t).value = null; + } + } + for (let t = 0; t < this.tableHeight; t++) { + const r = this.worksheet.getRow(e.row + t); + for (let t = this.width; t < this._cache.width; t++) { + r.getCell(e.col + t).value = null; + } + } + } + this.store(); + } + addRow(e, t) { + (this.cacheState(), + void 0 === t + ? this.table.rows.push(e) + : this.table.rows.splice(t, 0, e)); + } + removeRows(e) { + let t = + arguments.length > 1 && void 0 !== arguments[1] + ? arguments[1] + : 1; + (this.cacheState(), this.table.rows.splice(e, t)); + } + getColumn(e) { + const t = this.table.columns[e]; + return new i(this, t, e); + } + addColumn(e, t, r) { + (this.cacheState(), + void 0 === r + ? (this.table.columns.push(e), + this.table.rows.forEach((e, r) => { + e.push(t[r]); + })) + : (this.table.columns.splice(r, 0, e), + this.table.rows.forEach((e, n) => { + e.splice(r, 0, t[n]); + }))); + } + removeColumns(e) { + let t = + arguments.length > 1 && void 0 !== arguments[1] + ? arguments[1] + : 1; + (this.cacheState(), + this.table.columns.splice(e, t), + this.table.rows.forEach((r) => { + r.splice(e, t); + })); + } + _assign(e, t, r) { + (this.cacheState(), (e[t] = r)); + } + get ref() { + return this.table.ref; + } + set ref(e) { + this._assign(this.table, "ref", e); + } + get name() { + return this.table.name; + } + set name(e) { + this.table.name = e; + } + get displayName() { + return this.table.displyName || this.table.name; + } + set displayNamename(e) { + this.table.displayName = e; + } + get headerRow() { + return this.table.headerRow; + } + set headerRow(e) { + this._assign(this.table, "headerRow", e); + } + get totalsRow() { + return this.table.totalsRow; + } + set totalsRow(e) { + this._assign(this.table, "totalsRow", e); + } + get theme() { + return this.table.style.name; + } + set theme(e) { + this.table.style.name = e; + } + get showFirstColumn() { + return this.table.style.showFirstColumn; + } + set showFirstColumn(e) { + this.table.style.showFirstColumn = e; + } + get showLastColumn() { + return this.table.style.showLastColumn; + } + set showLastColumn(e) { + this.table.style.showLastColumn = e; + } + get showRowStripes() { + return this.table.style.showRowStripes; + } + set showRowStripes(e) { + this.table.style.showRowStripes = e; + } + get showColumnStripes() { + return this.table.style.showColumnStripes; + } + set showColumnStripes(e) { + this.table.style.showColumnStripes = e; + } + }; + }, + { "../utils/col-cache": 19 }, + ], + 13: [ + function (e, t, r) { + "use strict"; + const n = e("./worksheet"), + i = e("./defined-names"), + s = e("../xlsx/xlsx"), + o = e("../csv/csv"); + t.exports = class { + constructor() { + ((this.category = ""), + (this.company = ""), + (this.created = new Date()), + (this.description = ""), + (this.keywords = ""), + (this.manager = ""), + (this.modified = this.created), + (this.properties = {}), + (this.calcProperties = {}), + (this._worksheets = []), + (this.subject = ""), + (this.title = ""), + (this.views = []), + (this.media = []), + (this._definedNames = new i())); + } + get xlsx() { + return (this._xlsx || (this._xlsx = new s(this)), this._xlsx); + } + get csv() { + return (this._csv || (this._csv = new o(this)), this._csv); + } + get nextId() { + for (let e = 1; e < this._worksheets.length; e++) + if (!this._worksheets[e]) return e; + return this._worksheets.length || 1; + } + addWorksheet(e, t) { + const r = this.nextId; + t && + ("string" == typeof t + ? (console.trace( + 'tabColor argument is now deprecated. Please use workbook.addWorksheet(name, {properties: { tabColor: { argb: "rbg value" } }', + ), + (t = { properties: { tabColor: { argb: t } } })) + : (t.argb || t.theme || t.indexed) && + (console.trace( + "tabColor argument is now deprecated. Please use workbook.addWorksheet(name, {properties: { tabColor: { ... } }", + ), + (t = { properties: { tabColor: t } }))); + const i = this._worksheets.reduce( + (e, t) => ((t && t.orderNo) > e ? t.orderNo : e), + 0, + ), + s = Object.assign({}, t, { + id: r, + name: e, + orderNo: i + 1, + workbook: this, + }), + o = new n(s); + return ((this._worksheets[r] = o), o); + } + removeWorksheetEx(e) { + delete this._worksheets[e.id]; + } + removeWorksheet(e) { + const t = this.getWorksheet(e); + t && t.destroy(); + } + getWorksheet(e) { + return void 0 === e + ? this._worksheets.find(Boolean) + : "number" == typeof e + ? this._worksheets[e] + : "string" == typeof e + ? this._worksheets.find((t) => t && t.name === e) + : void 0; + } + get worksheets() { + return this._worksheets + .slice(1) + .sort((e, t) => e.orderNo - t.orderNo) + .filter(Boolean); + } + eachSheet(e) { + this.worksheets.forEach((t) => { + e(t, t.id); + }); + } + get definedNames() { + return this._definedNames; + } + clearThemes() { + this._themes = void 0; + } + addImage(e) { + const t = this.media.length; + return ( + this.media.push(Object.assign({}, e, { type: "image" })), + t + ); + } + getImage(e) { + return this.media[e]; + } + get model() { + return { + creator: this.creator || "Unknown", + lastModifiedBy: this.lastModifiedBy || "Unknown", + lastPrinted: this.lastPrinted, + created: this.created, + modified: this.modified, + properties: this.properties, + worksheets: this.worksheets.map((e) => e.model), + sheets: this.worksheets.map((e) => e.model).filter(Boolean), + definedNames: this._definedNames.model, + views: this.views, + company: this.company, + manager: this.manager, + title: this.title, + subject: this.subject, + keywords: this.keywords, + category: this.category, + description: this.description, + language: this.language, + revision: this.revision, + contentStatus: this.contentStatus, + themes: this._themes, + media: this.media, + calcProperties: this.calcProperties, + }; + } + set model(e) { + ((this.creator = e.creator), + (this.lastModifiedBy = e.lastModifiedBy), + (this.lastPrinted = e.lastPrinted), + (this.created = e.created), + (this.modified = e.modified), + (this.company = e.company), + (this.manager = e.manager), + (this.title = e.title), + (this.subject = e.subject), + (this.keywords = e.keywords), + (this.category = e.category), + (this.description = e.description), + (this.language = e.language), + (this.revision = e.revision), + (this.contentStatus = e.contentStatus), + (this.properties = e.properties), + (this.calcProperties = e.calcProperties), + (this._worksheets = []), + e.worksheets.forEach((t) => { + const { id: r, name: i, state: s } = t, + o = e.sheets && e.sheets.findIndex((e) => e.id === r); + (this._worksheets[r] = new n({ + id: r, + name: i, + orderNo: o, + state: s, + workbook: this, + })).model = t; + }), + (this._definedNames.model = e.definedNames), + (this.views = e.views), + (this._themes = e.themes), + (this.media = e.media || [])); + } + }; + }, + { + "../csv/csv": 1, + "../xlsx/xlsx": 144, + "./defined-names": 6, + "./worksheet": 14, + }, + ], + 14: [ + function (e, t, r) { + "use strict"; + const n = e("../utils/under-dash"), + i = e("../utils/col-cache"), + s = e("./range"), + o = e("./row"), + a = e("./column"), + l = e("./enums"), + c = e("./image"), + u = e("./table"), + h = e("./data-validations"), + f = e("../utils/encryptor"), + { copyStyle: d } = e("../utils/copy-style"); + t.exports = class { + constructor(e) { + ((e = e || {}), + (this._workbook = e.workbook), + (this.id = e.id), + (this.orderNo = e.orderNo), + (this.name = e.name), + (this.state = e.state || "visible"), + (this._rows = []), + (this._columns = null), + (this._keys = {}), + (this._merges = {}), + (this.rowBreaks = []), + (this.properties = Object.assign( + {}, + { + defaultRowHeight: 15, + dyDescent: 55, + outlineLevelCol: 0, + outlineLevelRow: 0, + }, + e.properties, + )), + (this.pageSetup = Object.assign( + {}, + { + margins: { + left: 0.7, + right: 0.7, + top: 0.75, + bottom: 0.75, + header: 0.3, + footer: 0.3, + }, + orientation: "portrait", + horizontalDpi: 4294967295, + verticalDpi: 4294967295, + fitToPage: !( + !e.pageSetup || + (!e.pageSetup.fitToWidth && !e.pageSetup.fitToHeight) || + e.pageSetup.scale + ), + pageOrder: "downThenOver", + blackAndWhite: !1, + draft: !1, + cellComments: "None", + errors: "displayed", + scale: 100, + fitToWidth: 1, + fitToHeight: 1, + paperSize: void 0, + showRowColHeaders: !1, + showGridLines: !1, + firstPageNumber: void 0, + horizontalCentered: !1, + verticalCentered: !1, + rowBreaks: null, + colBreaks: null, + }, + e.pageSetup, + )), + (this.headerFooter = Object.assign( + {}, + { + differentFirst: !1, + differentOddEven: !1, + oddHeader: null, + oddFooter: null, + evenHeader: null, + evenFooter: null, + firstHeader: null, + firstFooter: null, + }, + e.headerFooter, + )), + (this.dataValidations = new h()), + (this.views = e.views || []), + (this.autoFilter = e.autoFilter || null), + (this._media = []), + (this.sheetProtection = null), + (this.tables = {}), + (this.conditionalFormattings = [])); + } + get name() { + return this._name; + } + set name(e) { + if ((void 0 === e && (e = "sheet" + this.id), this._name !== e)) { + if ("string" != typeof e) + throw new Error("The name has to be a string."); + if ("" === e) throw new Error("The name can't be empty."); + if ("History" === e) + throw new Error( + 'The name "History" is protected. Please use a different name.', + ); + if (/[*?:/\\[\]]/.test(e)) + throw new Error( + `Worksheet name ${e} cannot include any of the following characters: * ? : \\ / [ ]`, + ); + if (/(^')|('$)/.test(e)) + throw new Error( + "The first or last character of worksheet name cannot be a single quotation mark: " + + e, + ); + if ( + (e && + e.length > 31 && + (console.warn( + `Worksheet name ${e} exceeds 31 chars. This will be truncated`, + ), + (e = e.substring(0, 31))), + this._workbook._worksheets.find( + (t) => t && t.name.toLowerCase() === e.toLowerCase(), + )) + ) + throw new Error("Worksheet name already exists: " + e); + this._name = e; + } + } + get workbook() { + return this._workbook; + } + destroy() { + this._workbook.removeWorksheetEx(this); + } + get dimensions() { + const e = new s(); + return ( + this._rows.forEach((t) => { + if (t) { + const r = t.dimensions; + r && e.expand(t.number, r.min, t.number, r.max); + } + }), + e + ); + } + get columns() { + return this._columns; + } + set columns(e) { + this._headerRowCount = e.reduce((e, t) => { + const r = (t.header ? 1 : t.headers && t.headers.length) || 0; + return Math.max(e, r); + }, 0); + let t = 1; + const r = (this._columns = []); + e.forEach((e) => { + const n = new a(this, t++, !1); + (r.push(n), (n.defn = e)); + }); + } + getColumnKey(e) { + return this._keys[e]; + } + setColumnKey(e, t) { + this._keys[e] = t; + } + deleteColumnKey(e) { + delete this._keys[e]; + } + eachColumnKey(e) { + n.each(this._keys, e); + } + getColumn(e) { + if ("string" == typeof e) { + const t = this._keys[e]; + if (t) return t; + e = i.l2n(e); + } + if ( + (this._columns || (this._columns = []), + e > this._columns.length) + ) { + let t = this._columns.length + 1; + for (; t <= e; ) this._columns.push(new a(this, t++)); + } + return this._columns[e - 1]; + } + spliceColumns(e, t) { + const r = this._rows.length; + for ( + var n = arguments.length, + i = new Array(n > 2 ? n - 2 : 0), + s = 2; + s < n; + s++ + ) + i[s - 2] = arguments[s]; + if (i.length > 0) + for (let n = 0; n < r; n++) { + const r = [e, t]; + i.forEach((e) => { + r.push(e[n] || null); + }); + const s = this.getRow(n + 1); + s.splice.apply(s, r); + } + else + this._rows.forEach((r) => { + r && r.splice(e, t); + }); + const o = i.length - t, + a = e + t, + l = this._columns.length; + if (o < 0) + for (let t = e + i.length; t <= l; t++) + this.getColumn(t).defn = this.getColumn(t - o).defn; + else if (o > 0) + for (let e = l; e >= a; e--) + this.getColumn(e + o).defn = this.getColumn(e).defn; + for (let t = e; t < e + i.length; t++) + this.getColumn(t).defn = null; + this.workbook.definedNames.spliceColumns( + this.name, + e, + t, + i.length, + ); + } + get lastColumn() { + return this.getColumn(this.columnCount); + } + get columnCount() { + let e = 0; + return ( + this.eachRow((t) => { + e = Math.max(e, t.cellCount); + }), + e + ); + } + get actualColumnCount() { + const e = []; + let t = 0; + return ( + this.eachRow((r) => { + r.eachCell((r) => { + let { col: n } = r; + e[n] || ((e[n] = !0), t++); + }); + }), + t + ); + } + _commitRow() {} + get _lastRowNumber() { + const e = this._rows; + let t = e.length; + for (; t > 0 && void 0 === e[t - 1]; ) t--; + return t; + } + get _nextRow() { + return this._lastRowNumber + 1; + } + get lastRow() { + if (this._rows.length) return this._rows[this._rows.length - 1]; + } + findRow(e) { + return this._rows[e - 1]; + } + findRows(e, t) { + return this._rows.slice(e - 1, e - 1 + t); + } + get rowCount() { + return this._lastRowNumber; + } + get actualRowCount() { + let e = 0; + return ( + this.eachRow(() => { + e++; + }), + e + ); + } + getRow(e) { + let t = this._rows[e - 1]; + return (t || (t = this._rows[e - 1] = new o(this, e)), t); + } + getRows(e, t) { + if (t < 1) return; + const r = []; + for (let n = e; n < e + t; n++) r.push(this.getRow(n)); + return r; + } + addRow(e) { + let t = + arguments.length > 1 && void 0 !== arguments[1] + ? arguments[1] + : "n"; + const r = this._nextRow, + n = this.getRow(r); + return ( + (n.values = e), + this._setStyleOption(r, "i" === t[0] ? t : "n"), + n + ); + } + addRows(e) { + let t = + arguments.length > 1 && void 0 !== arguments[1] + ? arguments[1] + : "n"; + const r = []; + return ( + e.forEach((e) => { + r.push(this.addRow(e, t)); + }), + r + ); + } + insertRow(e, t) { + let r = + arguments.length > 2 && void 0 !== arguments[2] + ? arguments[2] + : "n"; + return ( + this.spliceRows(e, 0, t), + this._setStyleOption(e, r), + this.getRow(e) + ); + } + insertRows(e, t) { + let r = + arguments.length > 2 && void 0 !== arguments[2] + ? arguments[2] + : "n"; + if ((this.spliceRows(e, 0, ...t), "n" !== r)) + for (let n = 0; n < t.length; n++) + "o" === r[0] && void 0 !== this.findRow(t.length + e + n) + ? this._copyStyle(t.length + e + n, e + n, "+" === r[1]) + : "i" === r[0] && + void 0 !== this.findRow(e - 1) && + this._copyStyle(e - 1, e + n, "+" === r[1]); + return this.getRows(e, t.length); + } + _setStyleOption(e) { + let t = + arguments.length > 1 && void 0 !== arguments[1] + ? arguments[1] + : "n"; + "o" === t[0] && void 0 !== this.findRow(e + 1) + ? this._copyStyle(e + 1, e, "+" === t[1]) + : "i" === t[0] && + void 0 !== this.findRow(e - 1) && + this._copyStyle(e - 1, e, "+" === t[1]); + } + _copyStyle(e, t) { + let r = + arguments.length > 2 && void 0 !== arguments[2] && arguments[2]; + const n = this.getRow(e), + i = this.getRow(t); + ((i.style = d(n.style)), + n.eachCell({ includeEmpty: r }, (e, t) => { + i.getCell(t).style = d(e.style); + }), + (i.height = n.height)); + } + duplicateRow(e, t) { + let r = + arguments.length > 2 && void 0 !== arguments[2] && arguments[2]; + const n = this._rows[e - 1], + i = new Array(t).fill(n.values); + this.spliceRows(e + 1, r ? 0 : t, ...i); + for (let r = 0; r < t; r++) { + const t = this._rows[e + r]; + ((t.style = n.style), + (t.height = n.height), + n.eachCell({ includeEmpty: !0 }, (e, r) => { + t.getCell(r).style = e.style; + })); + } + } + spliceRows(e, t) { + const r = e + t; + for ( + var n = arguments.length, + i = new Array(n > 2 ? n - 2 : 0), + s = 2; + s < n; + s++ + ) + i[s - 2] = arguments[s]; + const o = i.length, + a = o - t, + l = this._rows.length; + let c, u; + if (a < 0) + for ( + e === l && (this._rows[l - 1] = void 0), c = r; + c <= l; + c++ + ) + if (((u = this._rows[c - 1]), u)) { + const e = this.getRow(c + a); + ((e.values = u.values), + (e.style = u.style), + (e.height = u.height), + u.eachCell({ includeEmpty: !0 }, (t, r) => { + e.getCell(r).style = t.style; + }), + (this._rows[c - 1] = void 0)); + } else this._rows[c + a - 1] = void 0; + else if (a > 0) + for (c = l; c >= r; c--) + if (((u = this._rows[c - 1]), u)) { + const e = this.getRow(c + a); + ((e.values = u.values), + (e.style = u.style), + (e.height = u.height), + u.eachCell({ includeEmpty: !0 }, (t, r) => { + if ( + ((e.getCell(r).style = t.style), + "MergeValue" === t._value.constructor.name) + ) { + const e = this.getRow(t._row._number + o).getCell(r), + n = t._value._master, + i = this.getRow(n._row._number + o).getCell( + n._column._number, + ); + e.merge(i); + } + })); + } else this._rows[c + a - 1] = void 0; + for (c = 0; c < o; c++) { + const t = this.getRow(e + c); + ((t.style = {}), (t.values = i[c])); + } + this.workbook.definedNames.spliceRows(this.name, e, t, o); + } + eachRow(e, t) { + if ((t || ((t = e), (e = void 0)), e && e.includeEmpty)) { + const e = this._rows.length; + for (let r = 1; r <= e; r++) t(this.getRow(r), r); + } else + this._rows.forEach((e) => { + e && e.hasValues && t(e, e.number); + }); + } + getSheetValues() { + const e = []; + return ( + this._rows.forEach((t) => { + t && (e[t.number] = t.values); + }), + e + ); + } + findCell(e, t) { + const r = i.getAddress(e, t), + n = this._rows[r.row - 1]; + return n ? n.findCell(r.col) : void 0; + } + getCell(e, t) { + const r = i.getAddress(e, t); + return this.getRow(r.row).getCellEx(r); + } + mergeCells() { + for ( + var e = arguments.length, t = new Array(e), r = 0; + r < e; + r++ + ) + t[r] = arguments[r]; + const n = new s(t); + this._mergeCellsInternal(n); + } + mergeCellsWithoutStyle() { + for ( + var e = arguments.length, t = new Array(e), r = 0; + r < e; + r++ + ) + t[r] = arguments[r]; + const n = new s(t); + this._mergeCellsInternal(n, !0); + } + _mergeCellsInternal(e, t) { + n.each(this._merges, (t) => { + if (t.intersects(e)) + throw new Error("Cannot merge already merged cells"); + }); + const r = this.getCell(e.top, e.left); + for (let n = e.top; n <= e.bottom; n++) + for (let i = e.left; i <= e.right; i++) + (n > e.top || i > e.left) && this.getCell(n, i).merge(r, t); + this._merges[r.address] = e; + } + _unMergeMaster(e) { + const t = this._merges[e.address]; + if (t) { + for (let e = t.top; e <= t.bottom; e++) + for (let r = t.left; r <= t.right; r++) + this.getCell(e, r).unmerge(); + delete this._merges[e.address]; + } + } + get hasMerges() { + return n.some(this._merges, Boolean); + } + unMergeCells() { + for ( + var e = arguments.length, t = new Array(e), r = 0; + r < e; + r++ + ) + t[r] = arguments[r]; + const n = new s(t); + for (let e = n.top; e <= n.bottom; e++) + for (let t = n.left; t <= n.right; t++) { + const r = this.findCell(e, t); + r && + (r.type === l.ValueType.Merge + ? this._unMergeMaster(r.master) + : this._merges[r.address] && this._unMergeMaster(r)); + } + } + fillFormula(e, t, r) { + let n = + arguments.length > 3 && void 0 !== arguments[3] + ? arguments[3] + : "shared"; + const s = i.decode(e), + { top: o, left: a, bottom: l, right: c } = s, + u = c - a + 1, + h = i.encodeAddress(o, a), + f = "shared" === n; + let d; + d = + "function" == typeof r + ? r + : Array.isArray(r) + ? Array.isArray(r[0]) + ? (e, t) => r[e - o][t - a] + : (e, t) => r[(e - o) * u + (t - a)] + : () => {}; + let p = !0; + for (let r = o; r <= l; r++) + for (let i = a; i <= c; i++) + p + ? ((this.getCell(r, i).value = { + shareType: n, + formula: t, + ref: e, + result: d(r, i), + }), + (p = !1)) + : (this.getCell(r, i).value = f + ? { sharedFormula: h, result: d(r, i) } + : d(r, i)); + } + addImage(e, t) { + const r = { type: "image", imageId: e, range: t }; + this._media.push(new c(this, r)); + } + getImages() { + return this._media.filter((e) => "image" === e.type); + } + addBackgroundImage(e) { + const t = { type: "background", imageId: e }; + this._media.push(new c(this, t)); + } + getBackgroundImageId() { + const e = this._media.find((e) => "background" === e.type); + return e && e.imageId; + } + protect(e, t) { + return new Promise((r) => { + ((this.sheetProtection = { sheet: !0 }), + t && + "spinCount" in t && + (t.spinCount = Number.isFinite(t.spinCount) + ? Math.round(Math.max(0, t.spinCount)) + : 1e5), + e && + ((this.sheetProtection.algorithmName = "SHA-512"), + (this.sheetProtection.saltValue = f + .randomBytes(16) + .toString("base64")), + (this.sheetProtection.spinCount = + t && "spinCount" in t ? t.spinCount : 1e5), + (this.sheetProtection.hashValue = f.convertPasswordToHash( + e, + "SHA512", + this.sheetProtection.saltValue, + this.sheetProtection.spinCount, + ))), + t && + ((this.sheetProtection = Object.assign( + this.sheetProtection, + t, + )), + !e && + "spinCount" in t && + delete this.sheetProtection.spinCount), + r()); + }); + } + unprotect() { + this.sheetProtection = null; + } + addTable(e) { + const t = new u(this, e); + return ((this.tables[e.name] = t), t); + } + getTable(e) { + return this.tables[e]; + } + removeTable(e) { + delete this.tables[e]; + } + getTables() { + return Object.values(this.tables); + } + addConditionalFormatting(e) { + this.conditionalFormattings.push(e); + } + removeConditionalFormatting(e) { + "number" == typeof e + ? this.conditionalFormattings.splice(e, 1) + : (this.conditionalFormattings = + e instanceof Function + ? this.conditionalFormattings.filter(e) + : []); + } + get tabColor() { + return ( + console.trace( + "worksheet.tabColor property is now deprecated. Please use worksheet.properties.tabColor", + ), + this.properties.tabColor + ); + } + set tabColor(e) { + (console.trace( + "worksheet.tabColor property is now deprecated. Please use worksheet.properties.tabColor", + ), + (this.properties.tabColor = e)); + } + get model() { + const e = { + id: this.id, + name: this.name, + dataValidations: this.dataValidations.model, + properties: this.properties, + state: this.state, + pageSetup: this.pageSetup, + headerFooter: this.headerFooter, + rowBreaks: this.rowBreaks, + views: this.views, + autoFilter: this.autoFilter, + media: this._media.map((e) => e.model), + sheetProtection: this.sheetProtection, + tables: Object.values(this.tables).map((e) => e.model), + conditionalFormattings: this.conditionalFormattings, + }; + e.cols = a.toModel(this.columns); + const t = (e.rows = []), + r = (e.dimensions = new s()); + return ( + this._rows.forEach((e) => { + const n = e && e.model; + n && (r.expand(n.number, n.min, n.number, n.max), t.push(n)); + }), + (e.merges = []), + n.each(this._merges, (t) => { + e.merges.push(t.range); + }), + e + ); + } + _parseRows(e) { + ((this._rows = []), + e.rows.forEach((e) => { + const t = new o(this, e.number); + ((this._rows[t.number - 1] = t), (t.model = e)); + })); + } + _parseMergeCells(e) { + n.each(e.mergeCells, (e) => { + this.mergeCellsWithoutStyle(e); + }); + } + set model(e) { + ((this.name = e.name), + (this._columns = a.fromModel(this, e.cols)), + this._parseRows(e), + this._parseMergeCells(e), + (this.dataValidations = new h(e.dataValidations)), + (this.properties = e.properties), + (this.pageSetup = e.pageSetup), + (this.headerFooter = e.headerFooter), + (this.views = e.views), + (this.autoFilter = e.autoFilter), + (this._media = e.media.map((e) => new c(this, e))), + (this.sheetProtection = e.sheetProtection), + (this.tables = e.tables.reduce((e, t) => { + const r = new u(); + return ((r.model = t), (e[t.name] = r), e); + }, {})), + (this.conditionalFormattings = e.conditionalFormattings)); + } + }; + }, + { + "../utils/col-cache": 19, + "../utils/copy-style": 20, + "../utils/encryptor": 21, + "../utils/under-dash": 26, + "./column": 4, + "./data-validations": 5, + "./enums": 7, + "./image": 8, + "./range": 10, + "./row": 11, + "./table": 12, + }, + ], + 15: [ + function (e, t, r) { + "use strict"; + (e("core-js/modules/es.promise"), + e("core-js/modules/es.promise.finally"), + e("core-js/modules/es.object.assign"), + e("core-js/modules/es.object.keys"), + e("core-js/modules/es.object.values"), + e("core-js/modules/es.symbol"), + e("core-js/modules/es.symbol.async-iterator"), + e("core-js/modules/es.array.iterator"), + e("core-js/modules/es.array.includes"), + e("core-js/modules/es.array.find-index"), + e("core-js/modules/es.array.find"), + e("core-js/modules/es.string.from-code-point"), + e("core-js/modules/es.string.includes"), + e("core-js/modules/es.number.is-nan"), + e("regenerator-runtime/runtime")); + const n = { Workbook: e("./doc/workbook") }, + i = e("./doc/enums"); + (Object.keys(i).forEach((e) => { + n[e] = i[e]; + }), + (t.exports = n)); + }, + { + "./doc/enums": 7, + "./doc/workbook": 13, + "core-js/modules/es.array.find": 359, + "core-js/modules/es.array.find-index": 358, + "core-js/modules/es.array.includes": 360, + "core-js/modules/es.array.iterator": 361, + "core-js/modules/es.number.is-nan": 363, + "core-js/modules/es.object.assign": 364, + "core-js/modules/es.object.keys": 366, + "core-js/modules/es.object.values": 367, + "core-js/modules/es.promise": 372, + "core-js/modules/es.promise.finally": 371, + "core-js/modules/es.string.from-code-point": 376, + "core-js/modules/es.string.includes": 377, + "core-js/modules/es.symbol": 381, + "core-js/modules/es.symbol.async-iterator": 378, + "regenerator-runtime/runtime": 492, + }, + ], + 16: [ + function (e, t, r) { + "use strict"; + const n = + "undefined" == typeof TextDecoder ? null : new TextDecoder("utf-8"); + r.bufferToString = function (e) { + return "string" == typeof e ? e : n ? n.decode(e) : e.toString(); + }; + }, + {}, + ], + 17: [ + function (e, t, r) { + "use strict"; + const n = + "undefined" == typeof TextEncoder + ? null + : new TextEncoder("utf-8"), + { Buffer: i } = e("buffer"); + r.stringToBuffer = function (e) { + return "string" != typeof e + ? e + : n + ? i.from(n.encode(e).buffer) + : i.from(e); + }; + }, + { buffer: 220 }, + ], + 18: [ + function (e, t, r) { + "use strict"; + const n = e("./under-dash"), + i = e("./col-cache"); + t.exports = class { + constructor(e) { + ((this.template = e), (this.sheets = {})); + } + addCell(e) { + this.addCellEx(i.decodeEx(e)); + } + getCell(e) { + return this.findCellEx(i.decodeEx(e), !0); + } + findCell(e) { + return this.findCellEx(i.decodeEx(e), !1); + } + findCellAt(e, t, r) { + const n = this.sheets[e], + i = n && n[t]; + return i && i[r]; + } + addCellEx(e) { + if (e.top) + for (let t = e.top; t <= e.bottom; t++) + for (let r = e.left; r <= e.right; r++) + this.getCellAt(e.sheetName, t, r); + else this.findCellEx(e, !0); + } + getCellEx(e) { + return this.findCellEx(e, !0); + } + findCellEx(e, t) { + const r = this.findSheet(e, t), + n = this.findSheetRow(r, e, t); + return this.findRowCell(n, e, t); + } + getCellAt(e, t, r) { + const n = this.sheets[e] || (this.sheets[e] = []), + s = n[t] || (n[t] = []); + return ( + s[r] || + (s[r] = { sheetName: e, address: i.n2l(r) + t, row: t, col: r }) + ); + } + removeCellEx(e) { + const t = this.findSheet(e); + if (!t) return; + const r = this.findSheetRow(t, e); + r && delete r[e.col]; + } + forEachInSheet(e, t) { + const r = this.sheets[e]; + r && + r.forEach((e, r) => { + e && + e.forEach((e, n) => { + e && t(e, r, n); + }); + }); + } + forEach(e) { + n.each(this.sheets, (t, r) => { + this.forEachInSheet(r, e); + }); + } + map(e) { + const t = []; + return ( + this.forEach((r) => { + t.push(e(r)); + }), + t + ); + } + findSheet(e, t) { + const r = e.sheetName; + return this.sheets[r] + ? this.sheets[r] + : t + ? (this.sheets[r] = []) + : void 0; + } + findSheetRow(e, t, r) { + const { row: n } = t; + return e && e[n] ? e[n] : r ? (e[n] = []) : void 0; + } + findRowCell(e, t, r) { + const { col: n } = t; + return e && e[n] + ? e[n] + : r + ? (e[n] = this.template + ? Object.assign( + t, + JSON.parse(JSON.stringify(this.template)), + ) + : t) + : void 0; + } + spliceRows(e, t, r, n) { + const i = this.sheets[e]; + if (i) { + const e = []; + for (let t = 0; t < n; t++) e.push([]); + i.splice(t, r, ...e); + } + } + spliceColumns(e, t, r, i) { + const s = this.sheets[e]; + if (s) { + const e = []; + for (let t = 0; t < i; t++) e.push(null); + n.each(s, (n) => { + n.splice(t, r, ...e); + }); + } + } + }; + }, + { "./col-cache": 19, "./under-dash": 26 }, + ], + 19: [ + function (e, t, r) { + "use strict"; + const n = /^[A-Z]+\d+$/, + i = { + _dictionary: [ + "A", + "B", + "C", + "D", + "E", + "F", + "G", + "H", + "I", + "J", + "K", + "L", + "M", + "N", + "O", + "P", + "Q", + "R", + "S", + "T", + "U", + "V", + "W", + "X", + "Y", + "Z", + ], + _l2nFill: 0, + _l2n: {}, + _n2l: [], + _level: (e) => (e <= 26 ? 1 : e <= 676 ? 2 : 3), + _fill(e) { + let t, + r, + n, + i, + s, + o = 1; + if (e >= 4) + throw new Error( + "Out of bounds. Excel supports columns from 1 to 16384", + ); + if (this._l2nFill < 1 && e >= 1) { + for (; o <= 26; ) + ((t = this._dictionary[o - 1]), + (this._n2l[o] = t), + (this._l2n[t] = o), + o++); + this._l2nFill = 1; + } + if (this._l2nFill < 2 && e >= 2) { + for (o = 27; o <= 702; ) + ((r = o - 27), + (n = r % 26), + (i = Math.floor(r / 26)), + (t = this._dictionary[i] + this._dictionary[n]), + (this._n2l[o] = t), + (this._l2n[t] = o), + o++); + this._l2nFill = 2; + } + if (this._l2nFill < 3 && e >= 3) { + for (o = 703; o <= 16384; ) + ((r = o - 703), + (n = r % 26), + (i = Math.floor(r / 26) % 26), + (s = Math.floor(r / 676)), + (t = + this._dictionary[s] + + this._dictionary[i] + + this._dictionary[n]), + (this._n2l[o] = t), + (this._l2n[t] = o), + o++); + this._l2nFill = 3; + } + }, + l2n(e) { + if ((this._l2n[e] || this._fill(e.length), !this._l2n[e])) + throw new Error("Out of bounds. Invalid column letter: " + e); + return this._l2n[e]; + }, + n2l(e) { + if (e < 1 || e > 16384) + throw new Error( + e + + " is out of bounds. Excel supports columns from 1 to 16384", + ); + return ( + this._n2l[e] || this._fill(this._level(e)), + this._n2l[e] + ); + }, + _hash: {}, + validateAddress(e) { + if (!n.test(e)) throw new Error("Invalid Address: " + e); + return !0; + }, + decodeAddress(e) { + const t = e.length < 5 && this._hash[e]; + if (t) return t; + let r = !1, + n = "", + i = 0, + s = !1, + o = "", + a = 0; + for (let t, l = 0; l < e.length; l++) + if (((t = e.charCodeAt(l)), !s && t >= 65 && t <= 90)) + ((r = !0), (n += e[l]), (i = 26 * i + t - 64)); + else if (t >= 48 && t <= 57) + ((s = !0), (o += e[l]), (a = 10 * a + t - 48)); + else if (s && r && 36 !== t) break; + if (r) { + if (i > 16384) + throw new Error( + "Out of bounds. Invalid column letter: " + n, + ); + } else i = void 0; + s || (a = void 0); + const l = { + address: (e = n + o), + col: i, + row: a, + $col$row: `$${n}$${o}`, + }; + return ( + i <= 100 && + a <= 100 && + ((this._hash[e] = l), (this._hash[l.$col$row] = l)), + l + ); + }, + getAddress(e, t) { + if (t) { + const r = this.n2l(t) + e; + return this.decodeAddress(r); + } + return this.decodeAddress(e); + }, + decode(e) { + const t = e.split(":"); + if (2 === t.length) { + const e = this.decodeAddress(t[0]), + r = this.decodeAddress(t[1]), + n = { + top: Math.min(e.row, r.row), + left: Math.min(e.col, r.col), + bottom: Math.max(e.row, r.row), + right: Math.max(e.col, r.col), + }; + return ( + (n.tl = this.n2l(n.left) + n.top), + (n.br = this.n2l(n.right) + n.bottom), + (n.dimensions = `${n.tl}:${n.br}`), + n + ); + } + return this.decodeAddress(e); + }, + decodeEx(e) { + const t = e.match( + /(?:(?:(?:'((?:[^']|'')*)')|([^'^ !]*))!)?(.*)/, + ), + r = t[1] || t[2], + n = t[3], + i = n.split(":"); + if (i.length > 1) { + let e = this.decodeAddress(i[0]), + t = this.decodeAddress(i[1]); + const n = Math.min(e.row, t.row), + s = Math.min(e.col, t.col), + o = Math.max(e.row, t.row), + a = Math.max(e.col, t.col); + return ( + (e = this.n2l(s) + n), + (t = this.n2l(a) + o), + { + top: n, + left: s, + bottom: o, + right: a, + sheetName: r, + tl: { + address: e, + col: s, + row: n, + $col$row: `$${this.n2l(s)}$${n}`, + sheetName: r, + }, + br: { + address: t, + col: a, + row: o, + $col$row: `$${this.n2l(a)}$${o}`, + sheetName: r, + }, + dimensions: `${e}:${t}`, + } + ); + } + if (n.startsWith("#")) + return r ? { sheetName: r, error: n } : { error: n }; + const s = this.decodeAddress(n); + return r ? { sheetName: r, ...s } : s; + }, + encodeAddress: (e, t) => i.n2l(t) + e, + encode() { + switch (arguments.length) { + case 2: + return i.encodeAddress(arguments[0], arguments[1]); + case 4: + return `${i.encodeAddress(arguments[0], arguments[1])}:${i.encodeAddress(arguments[2], arguments[3])}`; + default: + throw new Error("Can only encode with 2 or 4 arguments"); + } + }, + inRange(e, t) { + const [r, n, , i, s] = e, + [o, a] = t; + return o >= r && o <= i && a >= n && a <= s; + }, + }; + t.exports = i; + }, + {}, + ], + 20: [ + function (e, t, r) { + "use strict"; + const n = (e, t) => ({ + ...e, + ...t.reduce((t, r) => (e[r] && (t[r] = { ...e[r] }), t), {}), + }), + i = function (e, t, r) { + let i = + arguments.length > 3 && void 0 !== arguments[3] + ? arguments[3] + : []; + e[r] && (t[r] = n(e[r], i)); + }; + r.copyStyle = (e) => { + if (!e) return e; + if (((t = e), 0 === Object.keys(t).length)) return {}; + var t; + const r = { ...e }; + return ( + i(e, r, "font", ["color"]), + i(e, r, "alignment"), + i(e, r, "protection"), + e.border && + (i(e, r, "border"), + i(e.border, r.border, "top", ["color"]), + i(e.border, r.border, "left", ["color"]), + i(e.border, r.border, "bottom", ["color"]), + i(e.border, r.border, "right", ["color"]), + i(e.border, r.border, "diagonal", ["color"])), + e.fill && + (i(e, r, "fill", ["fgColor", "bgColor", "center"]), + e.fill.stops && + (r.fill.stops = e.fill.stops.map((e) => n(e, ["color"])))), + r + ); + }; + }, + {}, + ], + 21: [ + function (e, t, r) { + (function (r) { + (function () { + "use strict"; + const n = e("crypto"), + i = { + hash(e) { + const t = n.createHash(e); + for ( + var i = arguments.length, + s = new Array(i > 1 ? i - 1 : 0), + o = 1; + o < i; + o++ + ) + s[o - 1] = arguments[o]; + return (t.update(r.concat(s)), t.digest()); + }, + convertPasswordToHash(e, t, i, s) { + t = t.toLowerCase(); + if (n.getHashes().indexOf(t) < 0) + throw new Error(`Hash algorithm '${t}' not supported!`); + const o = r.from(e, "utf16le"); + let a = this.hash(t, r.from(i, "base64"), o); + for (let e = 0; e < s; e++) { + const n = r.alloc(4); + (n.writeUInt32LE(e, 0), (a = this.hash(t, a, n))); + } + return a.toString("base64"); + }, + randomBytes: (e) => n.randomBytes(e), + }; + t.exports = i; + }).call(this); + }).call(this, e("buffer").Buffer); + }, + { buffer: 220, crypto: 390 }, + ], + 22: [ + function (e, t, r) { + "use strict"; + const { SaxesParser: n } = e("saxes"), + { PassThrough: i } = e("readable-stream"), + { bufferToString: s } = e("./browser-buffer-decode"); + t.exports = async function* (e) { + e.pipe && !e[Symbol.asyncIterator] && (e = e.pipe(new i())); + const t = new n(); + let r; + t.on("error", (e) => { + r = e; + }); + let o = []; + (t.on("opentag", (e) => o.push({ eventType: "opentag", value: e })), + t.on("text", (e) => o.push({ eventType: "text", value: e })), + t.on("closetag", (e) => + o.push({ eventType: "closetag", value: e }), + )); + for await (const n of e) { + if ((t.write(s(n)), r)) throw r; + (yield o, (o = [])); + } + }; + }, + { "./browser-buffer-decode": 16, "readable-stream": 491, saxes: 496 }, + ], + 23: [ + function (e, t, r) { + "use strict"; + const n = e("./col-cache"), + i = /(([a-z_\-0-9]*)!)?([a-z0-9_$]{2,})([(])?/gi, + s = /^([$])?([a-z]+)([$])?([1-9][0-9]*)$/i; + t.exports = { + slideFormula: function (e, t, r) { + const o = n.decode(t), + a = n.decode(r); + return e.replace(i, (e, t, r, i, l) => { + if (l) return e; + const c = s.exec(i); + if (c) { + const r = c[1], + i = c[2].toUpperCase(), + s = c[3], + l = c[4]; + if (i.length > 3 || (3 === i.length && i > "XFD")) return e; + let u = n.l2n(i), + h = parseInt(l, 10); + (r || (u += a.col - o.col), s || (h += a.row - o.row)); + return (t || "") + (r || "") + n.n2l(u) + (s || "") + h; + } + return e; + }); + }, + }; + }, + { "./col-cache": 19 }, + ], + 24: [ + function (e, t, r) { + (function (r, n) { + (function () { + "use strict"; + const i = e("readable-stream"), + s = e("./utils"), + o = e("./string-buf"); + class a { + constructor(e, t) { + ((this._data = e), (this._encoding = t)); + } + get length() { + return this.toBuffer().length; + } + copy(e, t, r, n) { + return this.toBuffer().copy(e, t, r, n); + } + toBuffer() { + return ( + this._buffer || + (this._buffer = n.from(this._data, this._encoding)), + this._buffer + ); + } + } + class l { + constructor(e) { + this._data = e; + } + get length() { + return this._data.length; + } + copy(e, t, r, n) { + return this._data._buf.copy(e, t, r, n); + } + toBuffer() { + return this._data.toBuffer(); + } + } + class c { + constructor(e) { + this._data = e; + } + get length() { + return this._data.length; + } + copy(e, t, r, n) { + this._data.copy(e, t, r, n); + } + toBuffer() { + return this._data; + } + } + class u { + constructor(e) { + ((this.size = e), + (this.buffer = n.alloc(e)), + (this.iRead = 0), + (this.iWrite = 0)); + } + toBuffer() { + if (0 === this.iRead && this.iWrite === this.size) + return this.buffer; + const e = n.alloc(this.iWrite - this.iRead); + return (this.buffer.copy(e, 0, this.iRead, this.iWrite), e); + } + get length() { + return this.iWrite - this.iRead; + } + get eod() { + return this.iRead === this.iWrite; + } + get full() { + return this.iWrite === this.size; + } + read(e) { + let t; + return 0 === e + ? null + : void 0 === e || e >= this.length + ? ((t = this.toBuffer()), (this.iRead = this.iWrite), t) + : ((t = n.alloc(e)), + this.buffer.copy(t, 0, this.iRead, e), + (this.iRead += e), + t); + } + write(e, t, r) { + const n = Math.min(r, this.size - this.iWrite); + return ( + e.copy(this.buffer, this.iWrite, t, t + n), + (this.iWrite += n), + n + ); + } + } + const h = function (e) { + ((e = e || {}), + (this.bufSize = e.bufSize || 1048576), + (this.buffers = []), + (this.batch = e.batch || !1), + (this.corked = !1), + (this.inPos = 0), + (this.outPos = 0), + (this.pipes = []), + (this.paused = !1), + (this.encoding = null)); + }; + (s.inherits(h, i.Duplex, { + toBuffer() { + switch (this.buffers.length) { + case 0: + return null; + case 1: + return this.buffers[0].toBuffer(); + default: + return n.concat(this.buffers.map((e) => e.toBuffer())); + } + }, + _getWritableBuffer() { + if (this.buffers.length) { + const e = this.buffers[this.buffers.length - 1]; + if (!e.full) return e; + } + const e = new u(this.bufSize); + return (this.buffers.push(e), e); + }, + async _pipe(e) { + await Promise.all( + this.pipes.map(function (t) { + return new Promise((r) => { + t.write(e.toBuffer(), () => { + r(); + }); + }); + }), + ); + }, + _writeToBuffers(e) { + let t = 0; + const r = e.length; + for (; t < r; ) { + t += this._getWritableBuffer().write(e, t, r - t); + } + }, + async write(e, t, i) { + let u; + if ( + (t instanceof Function && ((i = t), (t = "utf8")), + (i = i || s.nop), + e instanceof o) + ) + u = new l(e); + else if (e instanceof n) u = new c(e); + else { + if ( + !( + "string" == typeof e || + e instanceof String || + e instanceof ArrayBuffer + ) + ) + throw new Error( + "Chunk must be one of type String, Buffer or StringBuf.", + ); + u = new a(e, t); + } + if (this.pipes.length) + if (this.batch) + for ( + this._writeToBuffers(u); + !this.corked && this.buffers.length > 1; + ) + this._pipe(this.buffers.shift()); + else + this.corked + ? (this._writeToBuffers(u), r.nextTick(i)) + : (await this._pipe(u), i()); + else + (this.paused || this.emit("data", u.toBuffer()), + this._writeToBuffers(u), + this.emit("readable")); + return !0; + }, + cork() { + this.corked = !0; + }, + _flush() { + if (this.pipes.length) + for (; this.buffers.length; ) + this._pipe(this.buffers.shift()); + }, + uncork() { + ((this.corked = !1), this._flush()); + }, + end(e, t, r) { + const n = (e) => { + e + ? r(e) + : (this._flush(), + this.pipes.forEach((e) => { + e.end(); + }), + this.emit("finish")); + }; + e ? this.write(e, t, n) : n(); + }, + read(e) { + let t; + if (e) { + for ( + t = []; + e && this.buffers.length && !this.buffers[0].eod; + ) { + const r = this.buffers[0], + n = r.read(e); + ((e -= n.length), + t.push(n), + r.eod && r.full && this.buffers.shift()); + } + return n.concat(t); + } + return ( + (t = this.buffers.map((e) => e.toBuffer()).filter(Boolean)), + (this.buffers = []), + n.concat(t) + ); + }, + setEncoding(e) { + this.encoding = e; + }, + pause() { + this.paused = !0; + }, + resume() { + this.paused = !1; + }, + isPaused() { + return !!this.paused; + }, + pipe(e) { + (this.pipes.push(e), + !this.paused && this.buffers.length && this.end()); + }, + unpipe(e) { + this.pipes = this.pipes.filter((t) => t !== e); + }, + unshift() { + throw new Error("Not Implemented"); + }, + wrap() { + throw new Error("Not Implemented"); + }, + }), + (t.exports = h)); + }).call(this); + }).call(this, e("_process"), e("buffer").Buffer); + }, + { + "./string-buf": 25, + "./utils": 27, + _process: 467, + buffer: 220, + "readable-stream": 491, + }, + ], + 25: [ + function (e, t, r) { + (function (e) { + (function () { + "use strict"; + t.exports = class { + constructor(t) { + ((this._buf = e.alloc((t && t.size) || 16384)), + (this._encoding = (t && t.encoding) || "utf8"), + (this._inPos = 0), + (this._buffer = void 0)); + } + get length() { + return this._inPos; + } + get capacity() { + return this._buf.length; + } + get buffer() { + return this._buf; + } + toBuffer() { + return ( + this._buffer || + ((this._buffer = e.alloc(this.length)), + this._buf.copy(this._buffer, 0, 0, this.length)), + this._buffer + ); + } + reset(e) { + ((e = e || 0), (this._buffer = void 0), (this._inPos = e)); + } + _grow(t) { + let r = 2 * this._buf.length; + for (; r < t; ) r *= 2; + const n = e.alloc(r); + (this._buf.copy(n, 0), (this._buf = n)); + } + addText(e) { + this._buffer = void 0; + let t = + this._inPos + + this._buf.write(e, this._inPos, this._encoding); + for (; t >= this._buf.length - 4; ) + (this._grow(this._inPos + e.length), + (t = + this._inPos + + this._buf.write(e, this._inPos, this._encoding))); + this._inPos = t; + } + addStringBuf(e) { + e.length && + ((this._buffer = void 0), + this.length + e.length > this.capacity && + this._grow(this.length + e.length), + e._buf.copy(this._buf, this._inPos, 0, e.length), + (this._inPos += e.length)); + } + }; + }).call(this); + }).call(this, e("buffer").Buffer); + }, + { buffer: 220 }, + ], + 26: [ + function (e, t, r) { + "use strict"; + const { toString: n } = Object.prototype, + i = /["&<>]/, + s = { + each: function (e, t) { + e && + (Array.isArray(e) + ? e.forEach(t) + : Object.keys(e).forEach((r) => { + t(e[r], r); + })); + }, + some: function (e, t) { + return ( + !!e && + (Array.isArray(e) + ? e.some(t) + : Object.keys(e).some((r) => t(e[r], r))) + ); + }, + every: function (e, t) { + return ( + !e || + (Array.isArray(e) + ? e.every(t) + : Object.keys(e).every((r) => t(e[r], r))) + ); + }, + map: function (e, t) { + return e + ? Array.isArray(e) + ? e.map(t) + : Object.keys(e).map((r) => t(e[r], r)) + : []; + }, + keyBy: (e, t) => e.reduce((e, r) => ((e[r[t]] = r), e), {}), + isEqual: function (e, t) { + const r = typeof e, + n = typeof t, + i = Array.isArray(e), + o = Array.isArray(t); + let a; + if (r !== n) return !1; + switch (typeof e) { + case "object": + if (i || o) + return ( + !(!i || !o) && + e.length === t.length && + e.every((e, r) => { + const n = t[r]; + return s.isEqual(e, n); + }) + ); + if (null === e || null === t) return e === t; + if ( + ((a = Object.keys(e)), Object.keys(t).length !== a.length) + ) + return !1; + for (const e of a) if (!t.hasOwnProperty(e)) return !1; + return s.every(e, (e, r) => { + const n = t[r]; + return s.isEqual(e, n); + }); + default: + return e === t; + } + }, + escapeHtml(e) { + const t = i.exec(e); + if (!t) return e; + let r = "", + n = "", + s = 0, + o = t.index; + for (; o < e.length; o++) { + switch (e.charAt(o)) { + case '"': + n = """; + break; + case "&": + n = "&"; + break; + case "'": + n = "'"; + break; + case "<": + n = "<"; + break; + case ">": + n = ">"; + break; + default: + continue; + } + (s !== o && (r += e.substring(s, o)), (s = o + 1), (r += n)); + } + return s !== o ? r + e.substring(s, o) : r; + }, + strcmp: (e, t) => (e < t ? -1 : e > t ? 1 : 0), + isUndefined: (e) => "[object Undefined]" === n.call(e), + isObject: (e) => "[object Object]" === n.call(e), + deepMerge() { + const e = arguments[0] || {}, + { length: t } = arguments; + let r, n, i; + function o(t, o) { + ((r = e[o]), + (i = Array.isArray(t)), + s.isObject(t) || i + ? (i + ? ((i = !1), (n = r && Array.isArray(r) ? r : [])) + : (n = r && s.isObject(r) ? r : {}), + (e[o] = s.deepMerge(n, t))) + : s.isUndefined(t) || (e[o] = t)); + } + for (let e = 0; e < t; e++) s.each(arguments[e], o); + return e; + }, + }; + t.exports = s; + }, + {}, + ], + 27: [ + function (e, t, r) { + (function (r, n) { + (function () { + "use strict"; + const i = e("fs"), + s = /[<>&'"\x7F\x00-\x08\x0B-\x0C\x0E-\x1F]/, + o = { + nop() {}, + promiseImmediate: (e) => + new Promise((t) => { + r.setImmediate + ? n(() => { + t(e); + }) + : setTimeout(() => { + t(e); + }, 1); + }), + inherits: function (e, t, r, n) { + ((e.super_ = t), + n || ((n = r), (r = null)), + r && + Object.keys(r).forEach((t) => { + Object.defineProperty( + e, + t, + Object.getOwnPropertyDescriptor(r, t), + ); + })); + const i = { + constructor: { + value: e, + enumerable: !1, + writable: !1, + configurable: !0, + }, + }; + (n && + Object.keys(n).forEach((e) => { + i[e] = Object.getOwnPropertyDescriptor(n, e); + }), + (e.prototype = Object.create(t.prototype, i))); + }, + dateToExcel: (e, t) => + 25569 + e.getTime() / 864e5 - (t ? 1462 : 0), + excelToDate(e, t) { + const r = Math.round( + 24 * (e - 25569 + (t ? 1462 : 0)) * 3600 * 1e3, + ); + return new Date(r); + }, + parsePath(e) { + const t = e.lastIndexOf("/"); + return { + path: e.substring(0, t), + name: e.substring(t + 1), + }; + }, + getRelsPath(e) { + const t = o.parsePath(e); + return `${t.path}/_rels/${t.name}.rels`; + }, + xmlEncode(e) { + const t = s.exec(e); + if (!t) return e; + let r = "", + n = "", + i = 0, + o = t.index; + for (; o < e.length; o++) { + const t = e.charCodeAt(o); + switch (t) { + case 34: + n = """; + break; + case 38: + n = "&"; + break; + case 39: + n = "'"; + break; + case 60: + n = "<"; + break; + case 62: + n = ">"; + break; + case 127: + n = ""; + break; + default: + if (t <= 31 && (t <= 8 || (t >= 11 && 13 !== t))) { + n = ""; + break; + } + continue; + } + (i !== o && (r += e.substring(i, o)), + (i = o + 1), + n && (r += n)); + } + return i !== o ? r + e.substring(i, o) : r; + }, + xmlDecode: (e) => + e.replace(/&([a-z]*);/g, (e) => { + switch (e) { + case "<": + return "<"; + case ">": + return ">"; + case "&": + return "&"; + case "'": + return "'"; + case """: + return '"'; + default: + return e; + } + }), + validInt(e) { + const t = parseInt(e, 10); + return Number.isNaN(t) ? 0 : t; + }, + isDateFmt(e) { + if (!e) return !1; + return ( + null !== + (e = (e = e.replace(/\[[^\]]*]/g, "")).replace( + /"[^"]*"/g, + "", + )).match(/[ymdhMsb]+/) + ); + }, + fs: { + exists: (e) => + new Promise((t) => { + i.access(e, i.constants.F_OK, (e) => { + t(!e); + }); + }), + }, + toIsoDateString: (e) => e.toIsoString().subsstr(0, 10), + parseBoolean: (e) => + !0 === e || "true" === e || 1 === e || "1" === e, + }; + t.exports = o; + }).call(this); + }).call( + this, + "undefined" != typeof global + ? global + : "undefined" != typeof self + ? self + : "undefined" != typeof window + ? window + : {}, + e("timers").setImmediate, + ); + }, + { fs: 216, timers: 523 }, + ], + 28: [ + function (e, t, r) { + "use strict"; + const n = e("./under-dash"), + i = e("./utils"); + function s(e, t, r) { + e.push(` ${t}="${i.xmlEncode(r.toString())}"`); + } + function o(e, t) { + if (t) { + const r = []; + (n.each(t, (e, t) => { + void 0 !== e && s(r, t, e); + }), + e.push(r.join(""))); + } + } + class a { + constructor() { + ((this._xml = []), (this._stack = []), (this._rollbacks = [])); + } + get tos() { + return this._stack.length + ? this._stack[this._stack.length - 1] + : void 0; + } + get cursor() { + return this._xml.length; + } + openXml(e) { + const t = this._xml; + (t.push("\n")); + } + openNode(e, t) { + const r = this.tos, + n = this._xml; + (r && this.open && n.push(">"), + this._stack.push(e), + n.push("<"), + n.push(e), + o(n, t), + (this.leaf = !0), + (this.open = !0)); + } + addAttribute(e, t) { + if (!this.open) + throw new Error( + "Cannot write attributes to node if it is not open", + ); + void 0 !== t && s(this._xml, e, t); + } + addAttributes(e) { + if (!this.open) + throw new Error( + "Cannot write attributes to node if it is not open", + ); + o(this._xml, e); + } + writeText(e) { + const t = this._xml; + (this.open && (t.push(">"), (this.open = !1)), + (this.leaf = !1), + t.push(i.xmlEncode(e.toString()))); + } + writeXml(e) { + (this.open && (this._xml.push(">"), (this.open = !1)), + (this.leaf = !1), + this._xml.push(e)); + } + closeNode() { + const e = this._stack.pop(), + t = this._xml; + (this.leaf + ? t.push("/>") + : (t.push("")), + (this.open = !1), + (this.leaf = !1)); + } + leafNode(e, t, r) { + (this.openNode(e, t), + void 0 !== r && this.writeText(r), + this.closeNode()); + } + closeAll() { + for (; this._stack.length; ) this.closeNode(); + } + addRollback() { + return ( + this._rollbacks.push({ + xml: this._xml.length, + stack: this._stack.length, + leaf: this.leaf, + open: this.open, + }), + this.cursor + ); + } + commit() { + this._rollbacks.pop(); + } + rollback() { + const e = this._rollbacks.pop(); + (this._xml.length > e.xml && + this._xml.splice(e.xml, this._xml.length - e.xml), + this._stack.length > e.stack && + this._stack.splice(e.stack, this._stack.length - e.stack), + (this.leaf = e.leaf), + (this.open = e.open)); + } + get xml() { + return (this.closeAll(), this._xml.join("")); + } + } + ((a.StdDocAttributes = { + version: "1.0", + encoding: "UTF-8", + standalone: "yes", + }), + (t.exports = a)); + }, + { "./under-dash": 26, "./utils": 27 }, + ], + 29: [ + function (e, t, r) { + (function (r) { + (function () { + "use strict"; + const n = e("events"), + i = e("jszip"), + s = e("./stream-buf"), + { stringToBuffer: o } = e("./browser-buffer-encode"); + class a extends n.EventEmitter { + constructor(e) { + (super(), + (this.options = Object.assign( + { type: "nodebuffer", compression: "DEFLATE" }, + e, + )), + (this.zip = new i()), + (this.stream = new s())); + } + append(e, t) { + t.hasOwnProperty("base64") && t.base64 + ? this.zip.file(t.name, e, { base64: !0 }) + : (r.browser && "string" == typeof e && (e = o(e)), + this.zip.file(t.name, e)); + } + async finalize() { + const e = await this.zip.generateAsync(this.options); + (this.stream.end(e), this.emit("finish")); + } + read(e) { + return this.stream.read(e); + } + setEncoding(e) { + return this.stream.setEncoding(e); + } + pause() { + return this.stream.pause(); + } + resume() { + return this.stream.resume(); + } + isPaused() { + return this.stream.isPaused(); + } + pipe(e, t) { + return this.stream.pipe(e, t); + } + unpipe(e) { + return this.stream.unpipe(e); + } + unshift(e) { + return this.stream.unshift(e); + } + wrap(e) { + return this.stream.wrap(e); + } + } + t.exports = { ZipWriter: a }; + }).call(this); + }).call(this, e("_process")); + }, + { + "./browser-buffer-encode": 17, + "./stream-buf": 24, + _process: 467, + events: 422, + jszip: 441, + }, + ], + 30: [ + function (e, t, r) { + "use strict"; + t.exports = { + 0: { f: "General" }, + 1: { f: "0" }, + 2: { f: "0.00" }, + 3: { f: "#,##0" }, + 4: { f: "#,##0.00" }, + 9: { f: "0%" }, + 10: { f: "0.00%" }, + 11: { f: "0.00E+00" }, + 12: { f: "# ?/?" }, + 13: { f: "# ??/??" }, + 14: { f: "mm-dd-yy" }, + 15: { f: "d-mmm-yy" }, + 16: { f: "d-mmm" }, + 17: { f: "mmm-yy" }, + 18: { f: "h:mm AM/PM" }, + 19: { f: "h:mm:ss AM/PM" }, + 20: { f: "h:mm" }, + 21: { f: "h:mm:ss" }, + 22: { f: 'm/d/yy "h":mm' }, + 27: { + "zh-tw": "[$-404]e/m/d", + "zh-cn": 'yyyy"\u5e74"m"\u6708"', + "ja-jp": "[$-411]ge.m.d", + "ko-kr": 'yyyy"\u5e74" mm"\u6708" dd"\u65e5"', + }, + 28: { + "zh-tw": '[$-404]e"\u5e74"m"\u6708"d"\u65e5"', + "zh-cn": 'm"\u6708"d"\u65e5"', + "ja-jp": '[$-411]ggge"\u5e74"m"\u6708"d"\u65e5"', + "ko-kr": "mm-dd", + }, + 29: { + "zh-tw": '[$-404]e"\u5e74"m"\u6708"d"\u65e5"', + "zh-cn": 'm"\u6708"d"\u65e5"', + "ja-jp": '[$-411]ggge"\u5e74"m"\u6708"d"\u65e5"', + "ko-kr": "mm-dd", + }, + 30: { + "zh-tw": "m/d/yy ", + "zh-cn": "m-d-yy", + "ja-jp": "m/d/yy", + "ko-kr": "mm-dd-yy", + }, + 31: { + "zh-tw": 'yyyy"\u5e74"m"\u6708"d"\u65e5"', + "zh-cn": 'yyyy"\u5e74"m"\u6708"d"\u65e5"', + "ja-jp": 'yyyy"\u5e74"m"\u6708"d"\u65e5"', + "ko-kr": 'yyyy"\ub144" mm"\uc6d4" dd"\uc77c"', + }, + 32: { + "zh-tw": 'hh"\u6642"mm"\u5206"', + "zh-cn": 'h"\u65f6"mm"\u5206"', + "ja-jp": 'h"\u6642"mm"\u5206"', + "ko-kr": 'h"\uc2dc" mm"\ubd84"', + }, + 33: { + "zh-tw": 'hh"\u6642"mm"\u5206"ss"\u79d2"', + "zh-cn": 'h"\u65f6"mm"\u5206"ss"\u79d2"', + "ja-jp": 'h"\u6642"mm"\u5206"ss"\u79d2"', + "ko-kr": 'h"\uc2dc" mm"\ubd84" ss"\ucd08"', + }, + 34: { + "zh-tw": '\u4e0a\u5348/\u4e0b\u5348 hh"\u6642"mm"\u5206"', + "zh-cn": '\u4e0a\u5348/\u4e0b\u5348 h"\u65f6"mm"\u5206"', + "ja-jp": 'yyyy"\u5e74"m"\u6708"', + "ko-kr": "yyyy-mm-dd", + }, + 35: { + "zh-tw": + '\u4e0a\u5348/\u4e0b\u5348 hh"\u6642"mm"\u5206"ss"\u79d2"', + "zh-cn": + '\u4e0a\u5348/\u4e0b\u5348 h"\u65f6"mm"\u5206"ss"\u79d2"', + "ja-jp": 'm"\u6708"d"\u65e5"', + "ko-kr": "yyyy-mm-dd", + }, + 36: { + "zh-tw": "[$-404]e/m/d", + "zh-cn": 'yyyy"\u5e74"m"\u6708"', + "ja-jp": "[$-411]ge.m.d", + "ko-kr": 'yyyy"\u5e74" mm"\u6708" dd"\u65e5"', + }, + 37: { f: "#,##0 ;(#,##0)" }, + 38: { f: "#,##0 ;[Red](#,##0)" }, + 39: { f: "#,##0.00 ;(#,##0.00)" }, + 40: { f: "#,##0.00 ;[Red](#,##0.00)" }, + 45: { f: "mm:ss" }, + 46: { f: "[h]:mm:ss" }, + 47: { f: "mmss.0" }, + 48: { f: "##0.0E+0" }, + 49: { f: "@" }, + 50: { + "zh-tw": "[$-404]e/m/d", + "zh-cn": 'yyyy"\u5e74"m"\u6708"', + "ja-jp": "[$-411]ge.m.d", + "ko-kr": 'yyyy"\u5e74" mm"\u6708" dd"\u65e5"', + }, + 51: { + "zh-tw": '[$-404]e"\u5e74"m"\u6708"d"\u65e5"', + "zh-cn": 'm"\u6708"d"\u65e5"', + "ja-jp": '[$-411]ggge"\u5e74"m"\u6708"d"\u65e5"', + "ko-kr": "mm-dd", + }, + 52: { + "zh-tw": '\u4e0a\u5348/\u4e0b\u5348 hh"\u6642"mm"\u5206"', + "zh-cn": 'yyyy"\u5e74"m"\u6708"', + "ja-jp": 'yyyy"\u5e74"m"\u6708"', + "ko-kr": "yyyy-mm-dd", + }, + 53: { + "zh-tw": + '\u4e0a\u5348/\u4e0b\u5348 hh"\u6642"mm"\u5206"ss"\u79d2"', + "zh-cn": 'm"\u6708"d"\u65e5"', + "ja-jp": 'm"\u6708"d"\u65e5"', + "ko-kr": "yyyy-mm-dd", + }, + 54: { + "zh-tw": '[$-404]e"\u5e74"m"\u6708"d"\u65e5"', + "zh-cn": 'm"\u6708"d"\u65e5"', + "ja-jp": '[$-411]ggge"\u5e74"m"\u6708"d"\u65e5"', + "ko-kr": "mm-dd", + }, + 55: { + "zh-tw": '\u4e0a\u5348/\u4e0b\u5348 hh"\u6642"mm"\u5206"', + "zh-cn": '\u4e0a\u5348/\u4e0b\u5348 h"\u65f6"mm"\u5206"', + "ja-jp": 'yyyy"\u5e74"m"\u6708"', + "ko-kr": "yyyy-mm-dd", + }, + 56: { + "zh-tw": + '\u4e0a\u5348/\u4e0b\u5348 hh"\u6642"mm"\u5206"ss"\u79d2"', + "zh-cn": + '\u4e0a\u5348/\u4e0b\u5348 h"\u65f6"mm"\u5206"ss"\u79d2"', + "ja-jp": 'm"\u6708"d"\u65e5"', + "ko-kr": "yyyy-mm-dd", + }, + 57: { + "zh-tw": "[$-404]e/m/d", + "zh-cn": 'yyyy"\u5e74"m"\u6708"', + "ja-jp": "[$-411]ge.m.d", + "ko-kr": 'yyyy"\u5e74" mm"\u6708" dd"\u65e5"', + }, + 58: { + "zh-tw": '[$-404]e"\u5e74"m"\u6708"d"\u65e5"', + "zh-cn": 'm"\u6708"d"\u65e5"', + "ja-jp": '[$-411]ggge"\u5e74"m"\u6708"d"\u65e5"', + "ko-kr": "mm-dd", + }, + 59: { "th-th": "t0" }, + 60: { "th-th": "t0.00" }, + 61: { "th-th": "t#,##0" }, + 62: { "th-th": "t#,##0.00" }, + 67: { "th-th": "t0%" }, + 68: { "th-th": "t0.00%" }, + 69: { "th-th": "t# ?/?" }, + 70: { "th-th": "t# ??/??" }, + 81: { "th-th": "d/m/bb" }, + }; + }, + {}, + ], + 31: [ + function (e, t, r) { + "use strict"; + t.exports = { + OfficeDocument: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument", + Worksheet: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet", + CalcChain: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/calcChain", + SharedStrings: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings", + Styles: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles", + Theme: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/theme", + Hyperlink: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/hyperlink", + Image: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image", + CoreProperties: + "http://schemas.openxmlformats.org/package/2006/relationships/metadata/core-properties", + ExtenderProperties: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties", + Comments: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/comments", + VmlDrawing: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/vmlDrawing", + Table: + "http://schemas.openxmlformats.org/officeDocument/2006/relationships/table", + }; + }, + {}, + ], + 32: [ + function (e, t, r) { + "use strict"; + const n = e("../../utils/parse-sax"), + i = e("../../utils/xml-stream"); + class s { + prepare() {} + render() {} + parseOpen(e) {} + parseText(e) {} + parseClose(e) {} + reconcile(e, t) {} + reset() { + ((this.model = null), + this.map && + Object.values(this.map).forEach((e) => { + e instanceof s ? e.reset() : e.xform && e.xform.reset(); + })); + } + mergeModel(e) { + this.model = Object.assign(this.model || {}, e); + } + async parse(e) { + for await (const t of e) + for (const { eventType: e, value: r } of t) + if ("opentag" === e) this.parseOpen(r); + else if ("text" === e) this.parseText(r); + else if ("closetag" === e && !this.parseClose(r.name)) + return this.model; + return this.model; + } + async parseStream(e) { + return this.parse(n(e)); + } + get xml() { + return this.toXml(this.model); + } + toXml(e) { + const t = new i(); + return (this.render(t, e), t.xml); + } + static toAttribute(e, t) { + let r = + arguments.length > 2 && void 0 !== arguments[2] && arguments[2]; + if (void 0 === e) { + if (r) return t; + } else if (r || e !== t) return e.toString(); + } + static toStringAttribute(e, t) { + let r = + arguments.length > 2 && void 0 !== arguments[2] && arguments[2]; + return s.toAttribute(e, t, r); + } + static toStringValue(e, t) { + return void 0 === e ? t : e; + } + static toBoolAttribute(e, t) { + let r = + arguments.length > 2 && void 0 !== arguments[2] && arguments[2]; + if (void 0 === e) { + if (r) return t; + } else if (r || e !== t) return e ? "1" : "0"; + } + static toBoolValue(e, t) { + return void 0 === e ? t : "1" === e; + } + static toIntAttribute(e, t) { + let r = + arguments.length > 2 && void 0 !== arguments[2] && arguments[2]; + return s.toAttribute(e, t, r); + } + static toIntValue(e, t) { + return void 0 === e ? t : parseInt(e, 10); + } + static toFloatAttribute(e, t) { + let r = + arguments.length > 2 && void 0 !== arguments[2] && arguments[2]; + return s.toAttribute(e, t, r); + } + static toFloatValue(e, t) { + return void 0 === e ? t : parseFloat(e); + } + } + t.exports = s; + }, + { "../../utils/parse-sax": 22, "../../utils/xml-stream": 28 }, + ], + 33: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("../../../utils/col-cache"); + function s(e) { + try { + return (i.decodeEx(e), !0); + } catch (e) { + return !1; + } + } + function o(e) { + const t = []; + let r = !1, + n = ""; + return ( + e.split(",").forEach((e) => { + if (!e) return; + const i = (e.match(/'/g) || []).length; + if (!i) return void (r ? (n += e + ",") : s(e) && t.push(e)); + const o = i % 2 == 0; + !r && o && s(e) + ? t.push(e) + : r && !o + ? ((r = !1), s(n + e) && t.push(n + e), (n = "")) + : ((r = !0), (n += e + ",")); + }), + t + ); + } + t.exports = class extends n { + render(e, t) { + (e.openNode("definedName", { + name: t.name, + localSheetId: t.localSheetId, + }), + e.writeText(t.ranges.join(",")), + e.closeNode()); + } + parseOpen(e) { + switch (e.name) { + case "definedName": + return ( + (this._parsedName = e.attributes.name), + (this._parsedLocalSheetId = e.attributes.localSheetId), + (this._parsedText = []), + !0 + ); + default: + return !1; + } + } + parseText(e) { + this._parsedText.push(e); + } + parseClose() { + return ( + (this.model = { + name: this._parsedName, + ranges: o(this._parsedText.join("")), + }), + void 0 !== this._parsedLocalSheetId && + (this.model.localSheetId = parseInt( + this._parsedLocalSheetId, + 10, + )), + !1 + ); + } + }; + }, + { "../../../utils/col-cache": 19, "../base-xform": 32 }, + ], + 34: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/utils"), + i = e("../base-xform"); + t.exports = class extends i { + render(e, t) { + e.leafNode("sheet", { + sheetId: t.id, + name: t.name, + state: t.state, + "r:id": t.rId, + }); + } + parseOpen(e) { + return ( + "sheet" === e.name && + ((this.model = { + name: n.xmlDecode(e.attributes.name), + id: parseInt(e.attributes.sheetId, 10), + state: e.attributes.state, + rId: e.attributes["r:id"], + }), + !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../../../utils/utils": 27, "../base-xform": 32 }, + ], + 35: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + render(e, t) { + e.leafNode("calcPr", { + calcId: 171027, + fullCalcOnLoad: t.fullCalcOnLoad ? 1 : void 0, + }); + } + parseOpen(e) { + return "calcPr" === e.name && ((this.model = {}), !0); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 36: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + render(e, t) { + e.leafNode("workbookPr", { + date1904: t.date1904 ? 1 : void 0, + defaultThemeVersion: 164011, + filterPrivacy: 1, + }); + } + parseOpen(e) { + return ( + "workbookPr" === e.name && + ((this.model = { date1904: "1" === e.attributes.date1904 }), !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 37: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + render(e, t) { + const r = { + xWindow: t.x || 0, + yWindow: t.y || 0, + windowWidth: t.width || 12e3, + windowHeight: t.height || 24e3, + firstSheet: t.firstSheet, + activeTab: t.activeTab, + }; + (t.visibility && + "visible" !== t.visibility && + (r.visibility = t.visibility), + e.leafNode("workbookView", r)); + } + parseOpen(e) { + if ("workbookView" === e.name) { + const t = (this.model = {}), + r = function (e, r, n) { + const i = void 0 !== r ? (t[e] = r) : n; + void 0 !== i && (t[e] = i); + }, + n = function (e, r, n) { + const i = void 0 !== r ? (t[e] = parseInt(r, 10)) : n; + void 0 !== i && (t[e] = i); + }; + return ( + n("x", e.attributes.xWindow, 0), + n("y", e.attributes.yWindow, 0), + n("width", e.attributes.windowWidth, 25e3), + n("height", e.attributes.windowHeight, 1e4), + r("visibility", e.attributes.visibility, "visible"), + n("activeTab", e.attributes.activeTab, void 0), + n("firstSheet", e.attributes.firstSheet, void 0), + !0 + ); + } + return !1; + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 38: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/under-dash"), + i = e("../../../utils/col-cache"), + s = e("../../../utils/xml-stream"), + o = e("../base-xform"), + a = e("../static-xform"), + l = e("../list-xform"), + c = e("./defined-name-xform"), + u = e("./sheet-xform"), + h = e("./workbook-view-xform"), + f = e("./workbook-properties-xform"), + d = e("./workbook-calc-properties-xform"); + class p extends o { + constructor() { + (super(), + (this.map = { + fileVersion: p.STATIC_XFORMS.fileVersion, + workbookPr: new f(), + bookViews: new l({ + tag: "bookViews", + count: !1, + childXform: new h(), + }), + sheets: new l({ + tag: "sheets", + count: !1, + childXform: new u(), + }), + definedNames: new l({ + tag: "definedNames", + count: !1, + childXform: new c(), + }), + calcPr: new d(), + })); + } + prepare(e) { + e.sheets = e.worksheets; + const t = []; + let r = 0; + (e.sheets.forEach((e) => { + if ( + (e.pageSetup && + e.pageSetup.printArea && + e.pageSetup.printArea.split("&&").forEach((n) => { + const i = n.split(":"), + s = { + name: "_xlnm.Print_Area", + ranges: [`'${e.name}'!$${i[0]}:$${i[1]}`], + localSheetId: r, + }; + t.push(s); + }), + e.pageSetup && + (e.pageSetup.printTitlesRow || + e.pageSetup.printTitlesColumn)) + ) { + const n = []; + if (e.pageSetup.printTitlesColumn) { + const t = e.pageSetup.printTitlesColumn.split(":"); + n.push(`'${e.name}'!$${t[0]}:$${t[1]}`); + } + if (e.pageSetup.printTitlesRow) { + const t = e.pageSetup.printTitlesRow.split(":"); + n.push(`'${e.name}'!$${t[0]}:$${t[1]}`); + } + const i = { + name: "_xlnm.Print_Titles", + ranges: n, + localSheetId: r, + }; + t.push(i); + } + r++; + }), + t.length && (e.definedNames = e.definedNames.concat(t)), + (e.media || []).forEach((e, t) => { + e.name = e.type + (t + 1); + })); + } + render(e, t) { + (e.openXml(s.StdDocAttributes), + e.openNode("workbook", p.WORKBOOK_ATTRIBUTES), + this.map.fileVersion.render(e), + this.map.workbookPr.render(e, t.properties), + this.map.bookViews.render(e, t.views), + this.map.sheets.render(e, t.sheets), + this.map.definedNames.render(e, t.definedNames), + this.map.calcPr.render(e, t.calcProperties), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "workbook": + return !0; + default: + return ( + (this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e), + !0 + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case "workbook": + return ( + (this.model = { + sheets: this.map.sheets.model, + properties: this.map.workbookPr.model || {}, + views: this.map.bookViews.model, + calcProperties: {}, + }), + this.map.definedNames.model && + (this.model.definedNames = this.map.definedNames.model), + !1 + ); + default: + return !0; + } + } + reconcile(e) { + const t = (e.workbookRels || []).reduce( + (e, t) => ((e[t.Id] = t), e), + {}, + ), + r = []; + let s, + o = 0; + (e.sheets || []).forEach((n) => { + const i = t[n.rId]; + i && + ((s = + e.worksheetHash[ + "xl/" + i.Target.replace(/^(\s|\/xl\/)+/, "") + ]), + s && + ((s.name = n.name), + (s.id = n.id), + (s.state = n.state), + (r[o++] = s))); + }); + const a = []; + (n.each(e.definedNames, (e) => { + if ("_xlnm.Print_Area" === e.name) { + if (((s = r[e.localSheetId]), s)) { + s.pageSetup || (s.pageSetup = {}); + const t = i.decodeEx(e.ranges[0]); + s.pageSetup.printArea = s.pageSetup.printArea + ? `${s.pageSetup.printArea}&&${t.dimensions}` + : t.dimensions; + } + } else if ("_xlnm.Print_Titles" === e.name) { + if (((s = r[e.localSheetId]), s)) { + s.pageSetup || (s.pageSetup = {}); + const t = e.ranges.join(","), + r = /\$/g, + n = /\$\d+:\$\d+/, + i = t.match(n); + if (i && i.length) { + const e = i[0]; + s.pageSetup.printTitlesRow = e.replace(r, ""); + } + const o = /\$[A-Z]+:\$[A-Z]+/, + a = t.match(o); + if (a && a.length) { + const e = a[0]; + s.pageSetup.printTitlesColumn = e.replace(r, ""); + } + } + } else a.push(e); + }), + (e.definedNames = a), + e.media.forEach((e, t) => { + e.index = t; + })); + } + } + ((p.WORKBOOK_ATTRIBUTES = { + xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main", + "xmlns:r": + "http://schemas.openxmlformats.org/officeDocument/2006/relationships", + "xmlns:mc": + "http://schemas.openxmlformats.org/markup-compatibility/2006", + "mc:Ignorable": "x15", + "xmlns:x15": + "http://schemas.microsoft.com/office/spreadsheetml/2010/11/main", + }), + (p.STATIC_XFORMS = { + fileVersion: new a({ + tag: "fileVersion", + $: { + appName: "xl", + lastEdited: 5, + lowestEdited: 5, + rupBuild: 9303, + }, + }), + }), + (t.exports = p)); + }, + { + "../../../utils/col-cache": 19, + "../../../utils/under-dash": 26, + "../../../utils/xml-stream": 28, + "../base-xform": 32, + "../list-xform": 71, + "../static-xform": 120, + "./defined-name-xform": 33, + "./sheet-xform": 34, + "./workbook-calc-properties-xform": 35, + "./workbook-properties-xform": 36, + "./workbook-view-xform": 37, + }, + ], + 39: [ + function (e, t, r) { + "use strict"; + const n = e("../strings/rich-text-xform"), + i = e("../../../utils/utils"), + s = e("../base-xform"), + o = (t.exports = function (e) { + this.model = e; + }); + i.inherits(o, s, { + get tag() { + return "r"; + }, + get richTextXform() { + return ( + this._richTextXform || (this._richTextXform = new n()), + this._richTextXform + ); + }, + render(e, t) { + ((t = t || this.model), + e.openNode("comment", { ref: t.ref, authorId: 0 }), + e.openNode("text"), + t && + t.note && + t.note.texts && + t.note.texts.forEach((t) => { + this.richTextXform.render(e, t); + }), + e.closeNode(), + e.closeNode()); + }, + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "comment": + return ( + (this.model = { + type: "note", + note: { texts: [] }, + ...e.attributes, + }), + !0 + ); + case "r": + return ( + (this.parser = this.richTextXform), + this.parser.parseOpen(e), + !0 + ); + default: + return !1; + } + }, + parseText(e) { + this.parser && this.parser.parseText(e); + }, + parseClose(e) { + switch (e) { + case "comment": + return !1; + case "r": + return ( + this.model.note.texts.push(this.parser.model), + (this.parser = void 0), + !0 + ); + default: + return (this.parser && this.parser.parseClose(e), !0); + } + }, + }); + }, + { + "../../../utils/utils": 27, + "../base-xform": 32, + "../strings/rich-text-xform": 122, + }, + ], + 40: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/xml-stream"), + i = e("../../../utils/utils"), + s = e("../base-xform"), + o = e("./comment-xform"), + a = (t.exports = function () { + this.map = { comment: new o() }; + }); + i.inherits( + a, + s, + { + COMMENTS_ATTRIBUTES: { + xmlns: + "http://schemas.openxmlformats.org/spreadsheetml/2006/main", + }, + }, + { + render(e, t) { + ((t = t || this.model), + e.openXml(n.StdDocAttributes), + e.openNode("comments", a.COMMENTS_ATTRIBUTES), + e.openNode("authors"), + e.leafNode("author", null, "Author"), + e.closeNode(), + e.openNode("commentList"), + t.comments.forEach((t) => { + this.map.comment.render(e, t); + }), + e.closeNode(), + e.closeNode()); + }, + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "commentList": + return ((this.model = { comments: [] }), !0); + case "comment": + return ( + (this.parser = this.map.comment), + this.parser.parseOpen(e), + !0 + ); + default: + return !1; + } + }, + parseText(e) { + this.parser && this.parser.parseText(e); + }, + parseClose(e) { + switch (e) { + case "commentList": + return !1; + case "comment": + return ( + this.model.comments.push(this.parser.model), + (this.parser = void 0), + !0 + ); + default: + return (this.parser && this.parser.parseClose(e), !0); + } + }, + }, + ); + }, + { + "../../../utils/utils": 27, + "../../../utils/xml-stream": 28, + "../base-xform": 32, + "./comment-xform": 39, + }, + ], + 41: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"); + t.exports = class extends n { + constructor(e) { + (super(), (this._model = e)); + } + get tag() { + return this._model && this._model.tag; + } + render(e, t, r) { + (t === r[2] || ("x:SizeWithCells" === this.tag && t === r[1])) && + e.leafNode(this.tag); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ((this.model = {}), (this.model[this.tag] = !0), !0); + default: + return !1; + } + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../../base-xform": 32 }, + ], + 42: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"); + t.exports = class extends n { + constructor(e) { + (super(), (this._model = e)); + } + get tag() { + return this._model && this._model.tag; + } + render(e, t) { + e.leafNode(this.tag, null, t); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ((this.text = ""), !0); + default: + return !1; + } + } + parseText(e) { + this.text = e; + } + parseClose() { + return !1; + } + }; + }, + { "../../base-xform": 32 }, + ], + 43: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "x:Anchor"; + } + getAnchorRect(e) { + const t = Math.floor(e.left), + r = Math.floor(68 * (e.left - t)), + n = Math.floor(e.top), + i = Math.floor(18 * (e.top - n)), + s = Math.floor(e.right), + o = Math.floor(68 * (e.right - s)), + a = Math.floor(e.bottom); + return [t, r, n, i, s, o, a, Math.floor(18 * (e.bottom - a))]; + } + getDefaultRect(e) { + const t = e.col, + r = Math.max(e.row - 2, 0); + return [t, 6, r, 14, t + 2, 2, r + 4, 16]; + } + render(e, t) { + const r = t.anchor + ? this.getAnchorRect(t.anchor) + : this.getDefaultRect(t.refAddress); + e.leafNode("x:Anchor", null, r.join(", ")); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ((this.text = ""), !0); + default: + return !1; + } + } + parseText(e) { + this.text = e; + } + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 44: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("./vml-anchor-xform"), + s = e("./style/vml-protection-xform"), + o = e("./style/vml-position-xform"), + a = ["twoCells", "oneCells", "absolute"]; + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + "x:Anchor": new i(), + "x:Locked": new s({ tag: "x:Locked" }), + "x:LockText": new s({ tag: "x:LockText" }), + "x:SizeWithCells": new o({ tag: "x:SizeWithCells" }), + "x:MoveWithCells": new o({ tag: "x:MoveWithCells" }), + })); + } + get tag() { + return "x:ClientData"; + } + render(e, t) { + const { protection: r, editAs: n } = t.note; + (e.openNode(this.tag, { ObjectType: "Note" }), + this.map["x:MoveWithCells"].render(e, n, a), + this.map["x:SizeWithCells"].render(e, n, a), + this.map["x:Anchor"].render(e, t), + this.map["x:Locked"].render(e, r.locked), + e.leafNode("x:AutoFill", null, "False"), + this.map["x:LockText"].render(e, r.lockText), + e.leafNode("x:Row", null, t.refAddress.row - 1), + e.leafNode("x:Column", null, t.refAddress.col - 1), + e.closeNode()); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + (this.reset(), + (this.model = { anchor: [], protection: {}, editAs: "" })); + break; + default: + ((this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e)); + } + return !0; + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case this.tag: + return (this.normalizeModel(), !1); + default: + return !0; + } + } + normalizeModel() { + const e = Object.assign( + {}, + this.map["x:MoveWithCells"].model, + this.map["x:SizeWithCells"].model, + ), + t = Object.keys(e).length; + ((this.model.editAs = a[t]), + (this.model.anchor = this.map["x:Anchor"].text), + (this.model.protection.locked = this.map["x:Locked"].text), + (this.model.protection.lockText = this.map["x:LockText"].text)); + } + }; + }, + { + "../base-xform": 32, + "./style/vml-position-xform": 41, + "./style/vml-protection-xform": 42, + "./vml-anchor-xform": 43, + }, + ], + 45: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/xml-stream"), + i = e("../base-xform"), + s = e("./vml-shape-xform"); + class o extends i { + constructor() { + (super(), (this.map = { "v:shape": new s() })); + } + get tag() { + return "xml"; + } + render(e, t) { + (e.openXml(n.StdDocAttributes), + e.openNode(this.tag, o.DRAWING_ATTRIBUTES), + e.openNode("o:shapelayout", { "v:ext": "edit" }), + e.leafNode("o:idmap", { "v:ext": "edit", data: 1 }), + e.closeNode(), + e.openNode("v:shapetype", { + id: "_x0000_t202", + coordsize: "21600,21600", + "o:spt": 202, + path: "m,l,21600r21600,l21600,xe", + }), + e.leafNode("v:stroke", { joinstyle: "miter" }), + e.leafNode("v:path", { + gradientshapeok: "t", + "o:connecttype": "rect", + }), + e.closeNode(), + t.comments.forEach((t, r) => { + this.map["v:shape"].render(e, t, r); + }), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + (this.reset(), (this.model = { comments: [] })); + break; + default: + ((this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e)); + } + return !0; + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || + (this.model.comments.push(this.parser.model), + (this.parser = void 0)), + !0 + ); + switch (e) { + case this.tag: + return !1; + default: + return !0; + } + } + reconcile(e, t) { + e.anchors.forEach((e) => { + e.br + ? this.map["xdr:twoCellAnchor"].reconcile(e, t) + : this.map["xdr:oneCellAnchor"].reconcile(e, t); + }); + } + } + ((o.DRAWING_ATTRIBUTES = { + "xmlns:v": "urn:schemas-microsoft-com:vml", + "xmlns:o": "urn:schemas-microsoft-com:office:office", + "xmlns:x": "urn:schemas-microsoft-com:office:excel", + }), + (t.exports = o)); + }, + { + "../../../utils/xml-stream": 28, + "../base-xform": 32, + "./vml-shape-xform": 46, + }, + ], + 46: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("./vml-textbox-xform"), + s = e("./vml-client-data-xform"); + class o extends n { + constructor() { + (super(), + (this.map = { "v:textbox": new i(), "x:ClientData": new s() })); + } + get tag() { + return "v:shape"; + } + render(e, t, r) { + (e.openNode("v:shape", o.V_SHAPE_ATTRIBUTES(t, r)), + e.leafNode("v:fill", { color2: "infoBackground [80]" }), + e.leafNode("v:shadow", { color: "none [81]", obscured: "t" }), + e.leafNode("v:path", { "o:connecttype": "none" }), + this.map["v:textbox"].render(e, t), + this.map["x:ClientData"].render(e, t), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + (this.reset(), + (this.model = { + margins: { insetmode: e.attributes["o:insetmode"] }, + anchor: "", + editAs: "", + protection: {}, + })); + break; + default: + ((this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e)); + } + return !0; + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case this.tag: + return ( + (this.model.margins.inset = + this.map["v:textbox"].model && + this.map["v:textbox"].model.inset), + (this.model.protection = + this.map["x:ClientData"].model && + this.map["x:ClientData"].model.protection), + (this.model.anchor = + this.map["x:ClientData"].model && + this.map["x:ClientData"].model.anchor), + (this.model.editAs = + this.map["x:ClientData"].model && + this.map["x:ClientData"].model.editAs), + !1 + ); + default: + return !0; + } + } + } + ((o.V_SHAPE_ATTRIBUTES = (e, t) => ({ + id: "_x0000_s" + (1025 + t), + type: "#_x0000_t202", + style: + "position:absolute; margin-left:105.3pt;margin-top:10.5pt;width:97.8pt;height:59.1pt;z-index:1;visibility:hidden", + fillcolor: "infoBackground [80]", + strokecolor: "none [81]", + "o:insetmode": e.note.margins && e.note.margins.insetmode, + })), + (t.exports = o)); + }, + { + "../base-xform": 32, + "./vml-client-data-xform": 44, + "./vml-textbox-xform": 47, + }, + ], + 47: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "v:textbox"; + } + conversionUnit(e, t, r) { + return `${parseFloat(e) * t.toFixed(2)}${r}`; + } + reverseConversionUnit(e) { + return (e || "") + .split(",") + .map((e) => + Number( + parseFloat( + this.conversionUnit(parseFloat(e), 0.1, ""), + ).toFixed(2), + ), + ); + } + render(e, t) { + const r = { style: "mso-direction-alt:auto" }; + if (t && t.note) { + let { inset: e } = t.note && t.note.margins; + (Array.isArray(e) && + (e = e + .map((e) => this.conversionUnit(e, 10, "mm")) + .join(",")), + e && (r.inset = e)); + } + (e.openNode("v:textbox", r), + e.leafNode("div", { style: "text-align:left" }), + e.closeNode()); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ( + (this.model = { + inset: this.reverseConversionUnit(e.attributes.inset), + }), + !0 + ); + default: + return !0; + } + } + parseText() {} + parseClose(e) { + switch (e) { + case this.tag: + return !1; + default: + return !0; + } + } + }; + }, + { "../base-xform": 32 }, + ], + 48: [ + function (e, t, r) { + "use strict"; + const n = e("./base-xform"); + t.exports = class extends n { + createNewModel(e) { + return {}; + } + parseOpen(e) { + return ( + (this.parser = this.parser || this.map[e.name]), + this.parser + ? (this.parser.parseOpen(e), !0) + : e.name === this.tag && + ((this.model = this.createNewModel(e)), !0) + ); + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + onParserClose(e, t) { + this.model[e] = t.model; + } + parseClose(e) { + return this.parser + ? (this.parser.parseClose(e) || + (this.onParserClose(e, this.parser), + (this.parser = void 0)), + !0) + : e !== this.tag; + } + }; + }, + { "./base-xform": 32 }, + ], + 49: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + render(e, t) { + (e.openNode("HeadingPairs"), + e.openNode("vt:vector", { size: 2, baseType: "variant" }), + e.openNode("vt:variant"), + e.leafNode("vt:lpstr", void 0, "Worksheets"), + e.closeNode(), + e.openNode("vt:variant"), + e.leafNode("vt:i4", void 0, t.length), + e.closeNode(), + e.closeNode(), + e.closeNode()); + } + parseOpen(e) { + return "HeadingPairs" === e.name; + } + parseText() {} + parseClose(e) { + return "HeadingPairs" !== e; + } + }; + }, + { "../base-xform": 32 }, + ], + 50: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + render(e, t) { + (e.openNode("TitlesOfParts"), + e.openNode("vt:vector", { size: t.length, baseType: "lpstr" }), + t.forEach((t) => { + e.leafNode("vt:lpstr", void 0, t.name); + }), + e.closeNode(), + e.closeNode()); + } + parseOpen(e) { + return "TitlesOfParts" === e.name; + } + parseText() {} + parseClose(e) { + return "TitlesOfParts" !== e; + } + }; + }, + { "../base-xform": 32 }, + ], + 51: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/xml-stream"), + i = e("../base-xform"), + s = e("../simple/string-xform"), + o = e("./app-heading-pairs-xform"), + a = e("./app-titles-of-parts-xform"); + class l extends i { + constructor() { + (super(), + (this.map = { + Company: new s({ tag: "Company" }), + Manager: new s({ tag: "Manager" }), + HeadingPairs: new o(), + TitleOfParts: new a(), + })); + } + render(e, t) { + (e.openXml(n.StdDocAttributes), + e.openNode("Properties", l.PROPERTY_ATTRIBUTES), + e.leafNode("Application", void 0, "Microsoft Excel"), + e.leafNode("DocSecurity", void 0, "0"), + e.leafNode("ScaleCrop", void 0, "false"), + this.map.HeadingPairs.render(e, t.worksheets), + this.map.TitleOfParts.render(e, t.worksheets), + this.map.Company.render(e, t.company || ""), + this.map.Manager.render(e, t.manager), + e.leafNode("LinksUpToDate", void 0, "false"), + e.leafNode("SharedDoc", void 0, "false"), + e.leafNode("HyperlinksChanged", void 0, "false"), + e.leafNode("AppVersion", void 0, "16.0300"), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "Properties": + return !0; + default: + return ( + (this.parser = this.map[e.name]), + !!this.parser && (this.parser.parseOpen(e), !0) + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case "Properties": + return ( + (this.model = { + worksheets: this.map.TitleOfParts.model, + company: this.map.Company.model, + manager: this.map.Manager.model, + }), + !1 + ); + default: + return !0; + } + } + } + ((l.DateFormat = function (e) { + return e.toISOString().replace(/[.]\d{3,6}/, ""); + }), + (l.DateAttrs = { "xsi:type": "dcterms:W3CDTF" }), + (l.PROPERTY_ATTRIBUTES = { + xmlns: + "http://schemas.openxmlformats.org/officeDocument/2006/extended-properties", + "xmlns:vt": + "http://schemas.openxmlformats.org/officeDocument/2006/docPropsVTypes", + }), + (t.exports = l)); + }, + { + "../../../utils/xml-stream": 28, + "../base-xform": 32, + "../simple/string-xform": 119, + "./app-heading-pairs-xform": 49, + "./app-titles-of-parts-xform": 50, + }, + ], + 52: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/xml-stream"), + i = e("../base-xform"); + class s extends i { + render(e, t) { + (e.openXml(n.StdDocAttributes), + e.openNode("Types", s.PROPERTY_ATTRIBUTES)); + const r = {}; + ((t.media || []).forEach((t) => { + if ("image" === t.type) { + const n = t.extension; + r[n] || + ((r[n] = !0), + e.leafNode("Default", { + Extension: n, + ContentType: "image/" + n, + })); + } + }), + e.leafNode("Default", { + Extension: "rels", + ContentType: + "application/vnd.openxmlformats-package.relationships+xml", + }), + e.leafNode("Default", { + Extension: "xml", + ContentType: "application/xml", + }), + e.leafNode("Override", { + PartName: "/xl/workbook.xml", + ContentType: + "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml", + }), + t.worksheets.forEach((t) => { + const r = `/xl/worksheets/sheet${t.id}.xml`; + e.leafNode("Override", { + PartName: r, + ContentType: + "application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml", + }); + }), + e.leafNode("Override", { + PartName: "/xl/theme/theme1.xml", + ContentType: + "application/vnd.openxmlformats-officedocument.theme+xml", + }), + e.leafNode("Override", { + PartName: "/xl/styles.xml", + ContentType: + "application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml", + })); + (t.sharedStrings && + t.sharedStrings.count && + e.leafNode("Override", { + PartName: "/xl/sharedStrings.xml", + ContentType: + "application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml", + }), + t.tables && + t.tables.forEach((t) => { + e.leafNode("Override", { + PartName: "/xl/tables/" + t.target, + ContentType: + "application/vnd.openxmlformats-officedocument.spreadsheetml.table+xml", + }); + }), + t.drawings && + t.drawings.forEach((t) => { + e.leafNode("Override", { + PartName: `/xl/drawings/${t.name}.xml`, + ContentType: + "application/vnd.openxmlformats-officedocument.drawing+xml", + }); + }), + t.commentRefs && + (e.leafNode("Default", { + Extension: "vml", + ContentType: + "application/vnd.openxmlformats-officedocument.vmlDrawing", + }), + t.commentRefs.forEach((t) => { + let { commentName: r } = t; + e.leafNode("Override", { + PartName: `/xl/${r}.xml`, + ContentType: + "application/vnd.openxmlformats-officedocument.spreadsheetml.comments+xml", + }); + })), + e.leafNode("Override", { + PartName: "/docProps/core.xml", + ContentType: + "application/vnd.openxmlformats-package.core-properties+xml", + }), + e.leafNode("Override", { + PartName: "/docProps/app.xml", + ContentType: + "application/vnd.openxmlformats-officedocument.extended-properties+xml", + }), + e.closeNode()); + } + parseOpen() { + return !1; + } + parseText() {} + parseClose() { + return !1; + } + } + ((s.PROPERTY_ATTRIBUTES = { + xmlns: + "http://schemas.openxmlformats.org/package/2006/content-types", + }), + (t.exports = s)); + }, + { "../../../utils/xml-stream": 28, "../base-xform": 32 }, + ], + 53: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/xml-stream"), + i = e("../base-xform"), + s = e("../simple/date-xform"), + o = e("../simple/string-xform"), + a = e("../simple/integer-xform"); + class l extends i { + constructor() { + (super(), + (this.map = { + "dc:creator": new o({ tag: "dc:creator" }), + "dc:title": new o({ tag: "dc:title" }), + "dc:subject": new o({ tag: "dc:subject" }), + "dc:description": new o({ tag: "dc:description" }), + "dc:identifier": new o({ tag: "dc:identifier" }), + "dc:language": new o({ tag: "dc:language" }), + "cp:keywords": new o({ tag: "cp:keywords" }), + "cp:category": new o({ tag: "cp:category" }), + "cp:lastModifiedBy": new o({ tag: "cp:lastModifiedBy" }), + "cp:lastPrinted": new s({ + tag: "cp:lastPrinted", + format: l.DateFormat, + }), + "cp:revision": new a({ tag: "cp:revision" }), + "cp:version": new o({ tag: "cp:version" }), + "cp:contentStatus": new o({ tag: "cp:contentStatus" }), + "cp:contentType": new o({ tag: "cp:contentType" }), + "dcterms:created": new s({ + tag: "dcterms:created", + attrs: l.DateAttrs, + format: l.DateFormat, + }), + "dcterms:modified": new s({ + tag: "dcterms:modified", + attrs: l.DateAttrs, + format: l.DateFormat, + }), + })); + } + render(e, t) { + (e.openXml(n.StdDocAttributes), + e.openNode("cp:coreProperties", l.CORE_PROPERTY_ATTRIBUTES), + this.map["dc:creator"].render(e, t.creator), + this.map["dc:title"].render(e, t.title), + this.map["dc:subject"].render(e, t.subject), + this.map["dc:description"].render(e, t.description), + this.map["dc:identifier"].render(e, t.identifier), + this.map["dc:language"].render(e, t.language), + this.map["cp:keywords"].render(e, t.keywords), + this.map["cp:category"].render(e, t.category), + this.map["cp:lastModifiedBy"].render(e, t.lastModifiedBy), + this.map["cp:lastPrinted"].render(e, t.lastPrinted), + this.map["cp:revision"].render(e, t.revision), + this.map["cp:version"].render(e, t.version), + this.map["cp:contentStatus"].render(e, t.contentStatus), + this.map["cp:contentType"].render(e, t.contentType), + this.map["dcterms:created"].render(e, t.created), + this.map["dcterms:modified"].render(e, t.modified), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "cp:coreProperties": + case "coreProperties": + return !0; + default: + if (((this.parser = this.map[e.name]), this.parser)) + return (this.parser.parseOpen(e), !0); + throw new Error( + "Unexpected xml node in parseOpen: " + JSON.stringify(e), + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case "cp:coreProperties": + case "coreProperties": + return ( + (this.model = { + creator: this.map["dc:creator"].model, + title: this.map["dc:title"].model, + subject: this.map["dc:subject"].model, + description: this.map["dc:description"].model, + identifier: this.map["dc:identifier"].model, + language: this.map["dc:language"].model, + keywords: this.map["cp:keywords"].model, + category: this.map["cp:category"].model, + lastModifiedBy: this.map["cp:lastModifiedBy"].model, + lastPrinted: this.map["cp:lastPrinted"].model, + revision: this.map["cp:revision"].model, + contentStatus: this.map["cp:contentStatus"].model, + contentType: this.map["cp:contentType"].model, + created: this.map["dcterms:created"].model, + modified: this.map["dcterms:modified"].model, + }), + !1 + ); + default: + throw new Error("Unexpected xml node in parseClose: " + e); + } + } + } + ((l.DateFormat = function (e) { + return e.toISOString().replace(/[.]\d{3}/, ""); + }), + (l.DateAttrs = { "xsi:type": "dcterms:W3CDTF" }), + (l.CORE_PROPERTY_ATTRIBUTES = { + "xmlns:cp": + "http://schemas.openxmlformats.org/package/2006/metadata/core-properties", + "xmlns:dc": "http://purl.org/dc/elements/1.1/", + "xmlns:dcterms": "http://purl.org/dc/terms/", + "xmlns:dcmitype": "http://purl.org/dc/dcmitype/", + "xmlns:xsi": "http://www.w3.org/2001/XMLSchema-instance", + }), + (t.exports = l)); + }, + { + "../../../utils/xml-stream": 28, + "../base-xform": 32, + "../simple/date-xform": 117, + "../simple/integer-xform": 118, + "../simple/string-xform": 119, + }, + ], + 54: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + render(e, t) { + e.leafNode("Relationship", t); + } + parseOpen(e) { + switch (e.name) { + case "Relationship": + return ((this.model = e.attributes), !0); + default: + return !1; + } + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 55: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/xml-stream"), + i = e("../base-xform"), + s = e("./relationship-xform"); + class o extends i { + constructor() { + (super(), (this.map = { Relationship: new s() })); + } + render(e, t) { + ((t = t || this._values), + e.openXml(n.StdDocAttributes), + e.openNode("Relationships", o.RELATIONSHIPS_ATTRIBUTES), + t.forEach((t) => { + this.map.Relationship.render(e, t); + }), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "Relationships": + return ((this.model = []), !0); + default: + if (((this.parser = this.map[e.name]), this.parser)) + return (this.parser.parseOpen(e), !0); + throw new Error( + "Unexpected xml node in parseOpen: " + JSON.stringify(e), + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || + (this.model.push(this.parser.model), + (this.parser = void 0)), + !0 + ); + switch (e) { + case "Relationships": + return !1; + default: + throw new Error("Unexpected xml node in parseClose: " + e); + } + } + } + ((o.RELATIONSHIPS_ATTRIBUTES = { + xmlns: + "http://schemas.openxmlformats.org/package/2006/relationships", + }), + (t.exports = o)); + }, + { + "../../../utils/xml-stream": 28, + "../base-xform": 32, + "./relationship-xform": 54, + }, + ], + 56: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + (this.reset(), + (this.model = { + range: { editAs: e.attributes.editAs || "oneCell" }, + })); + break; + default: + ((this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e)); + } + return !0; + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + reconcilePicture(e, t) { + if (e && e.rId) { + const r = t.rels[e.rId].Target.match( + /.*\/media\/(.+[.][a-zA-Z]{3,4})/, + ); + if (r) { + const e = r[1], + n = t.mediaIndex[e]; + return t.media[n]; + } + } + } + }; + }, + { "../base-xform": 32 }, + ], + 57: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("./blip-xform"); + t.exports = class extends n { + constructor() { + (super(), (this.map = { "a:blip": new i() })); + } + get tag() { + return "xdr:blipFill"; + } + render(e, t) { + (e.openNode(this.tag), + this.map["a:blip"].render(e, t), + e.openNode("a:stretch"), + e.leafNode("a:fillRect"), + e.closeNode(), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + this.reset(); + break; + default: + ((this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e)); + } + return !0; + } + parseText() {} + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case this.tag: + return ((this.model = this.map["a:blip"].model), !1); + default: + return !0; + } + } + }; + }, + { "../base-xform": 32, "./blip-xform": 58 }, + ], + 58: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "a:blip"; + } + render(e, t) { + e.leafNode(this.tag, { + "xmlns:r": + "http://schemas.openxmlformats.org/officeDocument/2006/relationships", + "r:embed": t.rId, + cstate: "print", + }); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ((this.model = { rId: e.attributes["r:embed"] }), !0); + default: + return !0; + } + } + parseText() {} + parseClose(e) { + switch (e) { + case this.tag: + return !1; + default: + return !0; + } + } + }; + }, + { "../base-xform": 32 }, + ], + 59: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "xdr:cNvPicPr"; + } + render(e) { + (e.openNode(this.tag), + e.leafNode("a:picLocks", { noChangeAspect: "1" }), + e.closeNode()); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + default: + return !0; + } + } + parseText() {} + parseClose(e) { + switch (e) { + case this.tag: + return !1; + default: + return !0; + } + } + }; + }, + { "../base-xform": 32 }, + ], + 60: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("./hlink-click-xform"), + s = e("./ext-lst-xform"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { "a:hlinkClick": new i(), "a:extLst": new s() })); + } + get tag() { + return "xdr:cNvPr"; + } + render(e, t) { + (e.openNode(this.tag, { + id: t.index, + name: "Picture " + t.index, + }), + this.map["a:hlinkClick"].render(e, t), + this.map["a:extLst"].render(e, t), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + this.reset(); + break; + default: + ((this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e)); + } + return !0; + } + parseText() {} + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case this.tag: + return ((this.model = this.map["a:hlinkClick"].model), !1); + default: + return !0; + } + } + }; + }, + { + "../base-xform": 32, + "./ext-lst-xform": 63, + "./hlink-click-xform": 65, + }, + ], + 61: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("../simple/integer-xform"); + t.exports = class extends n { + constructor(e) { + (super(), + (this.tag = e.tag), + (this.map = { + "xdr:col": new i({ tag: "xdr:col", zero: !0 }), + "xdr:colOff": new i({ tag: "xdr:colOff", zero: !0 }), + "xdr:row": new i({ tag: "xdr:row", zero: !0 }), + "xdr:rowOff": new i({ tag: "xdr:rowOff", zero: !0 }), + })); + } + render(e, t) { + (e.openNode(this.tag), + this.map["xdr:col"].render(e, t.nativeCol), + this.map["xdr:colOff"].render(e, t.nativeColOff), + this.map["xdr:row"].render(e, t.nativeRow), + this.map["xdr:rowOff"].render(e, t.nativeRowOff), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + this.reset(); + break; + default: + ((this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e)); + } + return !0; + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case this.tag: + return ( + (this.model = { + nativeCol: this.map["xdr:col"].model, + nativeColOff: this.map["xdr:colOff"].model, + nativeRow: this.map["xdr:row"].model, + nativeRowOff: this.map["xdr:rowOff"].model, + }), + !1 + ); + default: + return !0; + } + } + }; + }, + { "../base-xform": 32, "../simple/integer-xform": 118 }, + ], + 62: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/col-cache"), + i = e("../../../utils/xml-stream"), + s = e("../base-xform"), + o = e("./two-cell-anchor-xform"), + a = e("./one-cell-anchor-xform"); + class l extends s { + constructor() { + (super(), + (this.map = { + "xdr:twoCellAnchor": new o(), + "xdr:oneCellAnchor": new a(), + })); + } + prepare(e) { + e.anchors.forEach((e, t) => { + e.anchorType = (function (e) { + return ("string" == typeof e.range + ? n.decode(e.range) + : e.range + ).br + ? "xdr:twoCellAnchor" + : "xdr:oneCellAnchor"; + })(e); + this.map[e.anchorType].prepare(e, { index: t }); + }); + } + get tag() { + return "xdr:wsDr"; + } + render(e, t) { + (e.openXml(i.StdDocAttributes), + e.openNode(this.tag, l.DRAWING_ATTRIBUTES), + t.anchors.forEach((t) => { + this.map[t.anchorType].render(e, t); + }), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + (this.reset(), (this.model = { anchors: [] })); + break; + default: + ((this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e)); + } + return !0; + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || + (this.model.anchors.push(this.parser.model), + (this.parser = void 0)), + !0 + ); + switch (e) { + case this.tag: + return !1; + default: + return !0; + } + } + reconcile(e, t) { + e.anchors.forEach((e) => { + e.br + ? this.map["xdr:twoCellAnchor"].reconcile(e, t) + : this.map["xdr:oneCellAnchor"].reconcile(e, t); + }); + } + } + ((l.DRAWING_ATTRIBUTES = { + "xmlns:xdr": + "http://schemas.openxmlformats.org/drawingml/2006/spreadsheetDrawing", + "xmlns:a": "http://schemas.openxmlformats.org/drawingml/2006/main", + }), + (t.exports = l)); + }, + { + "../../../utils/col-cache": 19, + "../../../utils/xml-stream": 28, + "../base-xform": 32, + "./one-cell-anchor-xform": 67, + "./two-cell-anchor-xform": 70, + }, + ], + 63: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "a:extLst"; + } + render(e) { + (e.openNode(this.tag), + e.openNode("a:ext", { + uri: "{FF2B5EF4-FFF2-40B4-BE49-F238E27FC236}", + }), + e.leafNode("a16:creationId", { + "xmlns:a16": + "http://schemas.microsoft.com/office/drawing/2014/main", + id: "{00000000-0008-0000-0000-000002000000}", + }), + e.closeNode(), + e.closeNode()); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + default: + return !0; + } + } + parseText() {} + parseClose(e) { + switch (e) { + case this.tag: + return !1; + default: + return !0; + } + } + }; + }, + { "../base-xform": 32 }, + ], + 64: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + constructor(e) { + (super(), (this.tag = e.tag), (this.map = {})); + } + render(e, t) { + e.openNode(this.tag); + const r = Math.floor(9525 * t.width), + n = Math.floor(9525 * t.height); + (e.addAttribute("cx", r), e.addAttribute("cy", n), e.closeNode()); + } + parseOpen(e) { + return ( + e.name === this.tag && + ((this.model = { + width: parseInt(e.attributes.cx || "0", 10) / 9525, + height: parseInt(e.attributes.cy || "0", 10) / 9525, + }), + !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 65: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "a:hlinkClick"; + } + render(e, t) { + t.hyperlinks && + t.hyperlinks.rId && + e.leafNode(this.tag, { + "xmlns:r": + "http://schemas.openxmlformats.org/officeDocument/2006/relationships", + "r:id": t.hyperlinks.rId, + tooltip: t.hyperlinks.tooltip, + }); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ( + (this.model = { + hyperlinks: { + rId: e.attributes["r:id"], + tooltip: e.attributes.tooltip, + }, + }), + !0 + ); + default: + return !0; + } + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 66: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("./c-nv-pr-xform"), + s = e("./c-nv-pic-pr-xform"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { "xdr:cNvPr": new i(), "xdr:cNvPicPr": new s() })); + } + get tag() { + return "xdr:nvPicPr"; + } + render(e, t) { + (e.openNode(this.tag), + this.map["xdr:cNvPr"].render(e, t), + this.map["xdr:cNvPicPr"].render(e, t), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + this.reset(); + break; + default: + ((this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e)); + } + return !0; + } + parseText() {} + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case this.tag: + return ((this.model = this.map["xdr:cNvPr"].model), !1); + default: + return !0; + } + } + }; + }, + { + "../base-xform": 32, + "./c-nv-pic-pr-xform": 59, + "./c-nv-pr-xform": 60, + }, + ], + 67: [ + function (e, t, r) { + "use strict"; + const n = e("./base-cell-anchor-xform"), + i = e("../static-xform"), + s = e("./cell-position-xform"), + o = e("./ext-xform"), + a = e("./pic-xform"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + "xdr:from": new s({ tag: "xdr:from" }), + "xdr:ext": new o({ tag: "xdr:ext" }), + "xdr:pic": new a(), + "xdr:clientData": new i({ tag: "xdr:clientData" }), + })); + } + get tag() { + return "xdr:oneCellAnchor"; + } + prepare(e, t) { + this.map["xdr:pic"].prepare(e.picture, t); + } + render(e, t) { + (e.openNode(this.tag, { editAs: t.range.editAs || "oneCell" }), + this.map["xdr:from"].render(e, t.range.tl), + this.map["xdr:ext"].render(e, t.range.ext), + this.map["xdr:pic"].render(e, t.picture), + this.map["xdr:clientData"].render(e, {}), + e.closeNode()); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case this.tag: + return ( + (this.model.range.tl = this.map["xdr:from"].model), + (this.model.range.ext = this.map["xdr:ext"].model), + (this.model.picture = this.map["xdr:pic"].model), + !1 + ); + default: + return !0; + } + } + reconcile(e, t) { + e.medium = this.reconcilePicture(e.picture, t); + } + }; + }, + { + "../static-xform": 120, + "./base-cell-anchor-xform": 56, + "./cell-position-xform": 61, + "./ext-xform": 64, + "./pic-xform": 68, + }, + ], + 68: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("../static-xform"), + s = e("./blip-fill-xform"), + o = e("./nv-pic-pr-xform"), + a = e("./sp-pr"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + "xdr:nvPicPr": new o(), + "xdr:blipFill": new s(), + "xdr:spPr": new i(a), + })); + } + get tag() { + return "xdr:pic"; + } + prepare(e, t) { + e.index = t.index + 1; + } + render(e, t) { + (e.openNode(this.tag), + this.map["xdr:nvPicPr"].render(e, t), + this.map["xdr:blipFill"].render(e, t), + this.map["xdr:spPr"].render(e, t), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + this.reset(); + break; + default: + ((this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e)); + } + return !0; + } + parseText() {} + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || + (this.mergeModel(this.parser.model), + (this.parser = void 0)), + !0 + ); + switch (e) { + case this.tag: + return !1; + default: + return !0; + } + } + }; + }, + { + "../base-xform": 32, + "../static-xform": 120, + "./blip-fill-xform": 57, + "./nv-pic-pr-xform": 66, + "./sp-pr": 69, + }, + ], + 69: [ + function (e, t, r) { + "use strict"; + t.exports = { + tag: "xdr:spPr", + c: [ + { + tag: "a:xfrm", + c: [ + { tag: "a:off", $: { x: "0", y: "0" } }, + { tag: "a:ext", $: { cx: "0", cy: "0" } }, + ], + }, + { + tag: "a:prstGeom", + $: { prst: "rect" }, + c: [{ tag: "a:avLst" }], + }, + ], + }; + }, + {}, + ], + 70: [ + function (e, t, r) { + "use strict"; + const n = e("./base-cell-anchor-xform"), + i = e("../static-xform"), + s = e("./cell-position-xform"), + o = e("./pic-xform"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + "xdr:from": new s({ tag: "xdr:from" }), + "xdr:to": new s({ tag: "xdr:to" }), + "xdr:pic": new o(), + "xdr:clientData": new i({ tag: "xdr:clientData" }), + })); + } + get tag() { + return "xdr:twoCellAnchor"; + } + prepare(e, t) { + this.map["xdr:pic"].prepare(e.picture, t); + } + render(e, t) { + (e.openNode(this.tag, { editAs: t.range.editAs || "oneCell" }), + this.map["xdr:from"].render(e, t.range.tl), + this.map["xdr:to"].render(e, t.range.br), + this.map["xdr:pic"].render(e, t.picture), + this.map["xdr:clientData"].render(e, {}), + e.closeNode()); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case this.tag: + return ( + (this.model.range.tl = this.map["xdr:from"].model), + (this.model.range.br = this.map["xdr:to"].model), + (this.model.picture = this.map["xdr:pic"].model), + !1 + ); + default: + return !0; + } + } + reconcile(e, t) { + e.medium = this.reconcilePicture(e.picture, t); + } + }; + }, + { + "../static-xform": 120, + "./base-cell-anchor-xform": 56, + "./cell-position-xform": 61, + "./pic-xform": 68, + }, + ], + 71: [ + function (e, t, r) { + "use strict"; + const n = e("./base-xform"); + t.exports = class extends n { + constructor(e) { + (super(), + (this.tag = e.tag), + (this.always = !!e.always), + (this.count = e.count), + (this.empty = e.empty), + (this.$count = e.$count || "count"), + (this.$ = e.$), + (this.childXform = e.childXform), + (this.maxItems = e.maxItems)); + } + prepare(e, t) { + const { childXform: r } = this; + e && + e.forEach((e, n) => { + ((t.index = n), r.prepare(e, t)); + }); + } + render(e, t) { + if (this.always || (t && t.length)) { + (e.openNode(this.tag, this.$), + this.count && + e.addAttribute(this.$count, (t && t.length) || 0)); + const { childXform: r } = this; + ((t || []).forEach((t, n) => { + r.render(e, t, n); + }), + e.closeNode()); + } else this.empty && e.leafNode(this.tag); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + return ((this.model = []), !0); + default: + return ( + !!this.childXform.parseOpen(e) && + ((this.parser = this.childXform), !0) + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) { + if ( + !this.parser.parseClose(e) && + (this.model.push(this.parser.model), + (this.parser = void 0), + this.maxItems && this.model.length > this.maxItems) + ) + throw new Error( + `Max ${this.childXform.tag} count (${this.maxItems}) exceeded`, + ); + return !0; + } + return !1; + } + reconcile(e, t) { + if (e) { + const { childXform: r } = this; + e.forEach((e) => { + r.reconcile(e, t); + }); + } + } + }; + }, + { "./base-xform": 32 }, + ], + 72: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/col-cache"), + i = e("../base-xform"); + t.exports = class extends i { + get tag() { + return "autoFilter"; + } + render(e, t) { + if (t) + if ("string" == typeof t) e.leafNode("autoFilter", { ref: t }); + else { + const r = function (e) { + return "string" == typeof e + ? e + : n.getAddress(e.row, e.column).address; + }, + i = r(t.from), + s = r(t.to); + i && s && e.leafNode("autoFilter", { ref: `${i}:${s}` }); + } + } + parseOpen(e) { + "autoFilter" === e.name && (this.model = e.attributes.ref); + } + }; + }, + { "../../../utils/col-cache": 19, "../base-xform": 32 }, + ], + 73: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/utils"), + i = e("../base-xform"), + s = e("../../../doc/range"), + o = e("../../../doc/enums"), + a = e("../strings/rich-text-xform"); + function l(e) { + if (null == e) return o.ValueType.Null; + if (e instanceof String || "string" == typeof e) + return o.ValueType.String; + if ("number" == typeof e) return o.ValueType.Number; + if ("boolean" == typeof e) return o.ValueType.Boolean; + if (e instanceof Date) return o.ValueType.Date; + if (e.text && e.hyperlink) return o.ValueType.Hyperlink; + if (e.formula) return o.ValueType.Formula; + if (e.error) return o.ValueType.Error; + throw new Error("I could not understand type of value"); + } + t.exports = class extends i { + constructor() { + (super(), (this.richTextXForm = new a())); + } + get tag() { + return "c"; + } + prepare(e, t) { + const r = t.styles.addStyleModel( + e.style || {}, + (function (e) { + switch (e.type) { + case o.ValueType.Formula: + return l(e.result); + default: + return e.type; + } + })(e), + ); + switch ( + (r && (e.styleId = r), + e.comment && t.comments.push({ ...e.comment, ref: e.address }), + e.type) + ) { + case o.ValueType.String: + case o.ValueType.RichText: + t.sharedStrings && (e.ssId = t.sharedStrings.add(e.value)); + break; + case o.ValueType.Date: + t.date1904 && (e.date1904 = !0); + break; + case o.ValueType.Hyperlink: + (t.sharedStrings && + void 0 !== e.text && + null !== e.text && + (e.ssId = t.sharedStrings.add(e.text)), + t.hyperlinks.push({ + address: e.address, + target: e.hyperlink, + tooltip: e.tooltip, + })); + break; + case o.ValueType.Merge: + t.merges.add(e); + break; + case o.ValueType.Formula: + if ( + (t.date1904 && (e.date1904 = !0), + "shared" === e.shareType && (e.si = t.siFormulae++), + e.formula) + ) + t.formulae[e.address] = e; + else if (e.sharedFormula) { + const r = t.formulae[e.sharedFormula]; + if (!r) + throw new Error( + "Shared Formula master must exist above and or left of clone for cell " + + e.address, + ); + (void 0 === r.si + ? ((r.shareType = "shared"), + (r.si = t.siFormulae++), + (r.range = new s(r.address, e.address))) + : r.range && r.range.expandToAddress(e.address), + (e.si = r.si)); + } + } + } + renderFormula(e, t) { + let r = null; + switch (t.shareType) { + case "shared": + r = { t: "shared", ref: t.ref || t.range.range, si: t.si }; + break; + case "array": + r = { t: "array", ref: t.ref }; + break; + default: + void 0 !== t.si && (r = { t: "shared", si: t.si }); + } + switch (l(t.result)) { + case o.ValueType.Null: + e.leafNode("f", r, t.formula); + break; + case o.ValueType.String: + (e.addAttribute("t", "str"), + e.leafNode("f", r, t.formula), + e.leafNode("v", null, t.result)); + break; + case o.ValueType.Number: + (e.leafNode("f", r, t.formula), + e.leafNode("v", null, t.result)); + break; + case o.ValueType.Boolean: + (e.addAttribute("t", "b"), + e.leafNode("f", r, t.formula), + e.leafNode("v", null, t.result ? 1 : 0)); + break; + case o.ValueType.Error: + (e.addAttribute("t", "e"), + e.leafNode("f", r, t.formula), + e.leafNode("v", null, t.result.error)); + break; + case o.ValueType.Date: + (e.leafNode("f", r, t.formula), + e.leafNode("v", null, n.dateToExcel(t.result, t.date1904))); + break; + default: + throw new Error("I could not understand type of value"); + } + } + render(e, t) { + if (t.type !== o.ValueType.Null || t.styleId) { + switch ( + (e.openNode("c"), + e.addAttribute("r", t.address), + t.styleId && e.addAttribute("s", t.styleId), + t.type) + ) { + case o.ValueType.Null: + break; + case o.ValueType.Number: + e.leafNode("v", null, t.value); + break; + case o.ValueType.Boolean: + (e.addAttribute("t", "b"), + e.leafNode("v", null, t.value ? "1" : "0")); + break; + case o.ValueType.Error: + (e.addAttribute("t", "e"), + e.leafNode("v", null, t.value.error)); + break; + case o.ValueType.String: + case o.ValueType.RichText: + void 0 !== t.ssId + ? (e.addAttribute("t", "s"), + e.leafNode("v", null, t.ssId)) + : t.value && t.value.richText + ? (e.addAttribute("t", "inlineStr"), + e.openNode("is"), + t.value.richText.forEach((t) => { + this.richTextXForm.render(e, t); + }), + e.closeNode("is")) + : (e.addAttribute("t", "str"), + e.leafNode("v", null, t.value)); + break; + case o.ValueType.Date: + e.leafNode("v", null, n.dateToExcel(t.value, t.date1904)); + break; + case o.ValueType.Hyperlink: + void 0 !== t.ssId + ? (e.addAttribute("t", "s"), + e.leafNode("v", null, t.ssId)) + : (e.addAttribute("t", "str"), + e.leafNode("v", null, t.text)); + break; + case o.ValueType.Formula: + this.renderFormula(e, t); + break; + case o.ValueType.Merge: + } + e.closeNode(); + } + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "c": + return ( + (this.model = { address: e.attributes.r }), + (this.t = e.attributes.t), + e.attributes.s && + (this.model.styleId = parseInt(e.attributes.s, 10)), + !0 + ); + case "f": + return ( + (this.currentNode = "f"), + (this.model.si = e.attributes.si), + (this.model.shareType = e.attributes.t), + (this.model.ref = e.attributes.ref), + !0 + ); + case "v": + return ((this.currentNode = "v"), !0); + case "t": + return ((this.currentNode = "t"), !0); + case "r": + return ( + (this.parser = this.richTextXForm), + this.parser.parseOpen(e), + !0 + ); + default: + return !1; + } + } + parseText(e) { + if (this.parser) this.parser.parseText(e); + else + switch (this.currentNode) { + case "f": + this.model.formula = this.model.formula + ? this.model.formula + e + : e; + break; + case "v": + case "t": + this.model.value && this.model.value.richText + ? (this.model.value.richText.text = this.model.value + .richText.text + ? this.model.value.richText.text + e + : e) + : (this.model.value = this.model.value + ? this.model.value + e + : e); + } + } + parseClose(e) { + switch (e) { + case "c": { + const { model: e } = this; + if (e.formula || e.shareType) + ((e.type = o.ValueType.Formula), + e.value && + ("str" === this.t + ? (e.result = n.xmlDecode(e.value)) + : "b" === this.t + ? (e.result = 0 !== parseInt(e.value, 10)) + : "e" === this.t + ? (e.result = { error: e.value }) + : (e.result = parseFloat(e.value)), + (e.value = void 0))); + else if (void 0 !== e.value) + switch (this.t) { + case "s": + ((e.type = o.ValueType.String), + (e.value = parseInt(e.value, 10))); + break; + case "str": + ((e.type = o.ValueType.String), + (e.value = n.xmlDecode(e.value))); + break; + case "inlineStr": + e.type = o.ValueType.String; + break; + case "b": + ((e.type = o.ValueType.Boolean), + (e.value = 0 !== parseInt(e.value, 10))); + break; + case "e": + ((e.type = o.ValueType.Error), + (e.value = { error: e.value })); + break; + default: + ((e.type = o.ValueType.Number), + (e.value = parseFloat(e.value))); + } + else + e.styleId + ? (e.type = o.ValueType.Null) + : (e.type = o.ValueType.Merge); + return !1; + } + case "f": + case "v": + case "is": + return ((this.currentNode = void 0), !0); + case "t": + return this.parser + ? (this.parser.parseClose(e), !0) + : ((this.currentNode = void 0), !0); + case "r": + return ( + (this.model.value = this.model.value || {}), + (this.model.value.richText = + this.model.value.richText || []), + this.model.value.richText.push(this.parser.model), + (this.parser = void 0), + (this.currentNode = void 0), + !0 + ); + default: + return !!this.parser && (this.parser.parseClose(e), !0); + } + } + reconcile(e, t) { + const r = + e.styleId && t.styles && t.styles.getStyleModel(e.styleId); + switch ( + (r && (e.style = r), + void 0 !== e.styleId && (e.styleId = void 0), + e.type) + ) { + case o.ValueType.String: + ("number" == typeof e.value && + t.sharedStrings && + (e.value = t.sharedStrings.getString(e.value)), + e.value.richText && (e.type = o.ValueType.RichText)); + break; + case o.ValueType.Number: + r && + n.isDateFmt(r.numFmt) && + ((e.type = o.ValueType.Date), + (e.value = n.excelToDate(e.value, t.date1904))); + break; + case o.ValueType.Formula: + (void 0 !== e.result && + r && + n.isDateFmt(r.numFmt) && + (e.result = n.excelToDate(e.result, t.date1904)), + "shared" === e.shareType && + (e.ref + ? (t.formulae[e.si] = e.address) + : ((e.sharedFormula = t.formulae[e.si]), + delete e.shareType), + delete e.si)); + } + const i = t.hyperlinkMap[e.address]; + i && + (e.type === o.ValueType.Formula + ? ((e.text = e.result), (e.result = void 0)) + : ((e.text = e.value), (e.value = void 0)), + (e.type = o.ValueType.Hyperlink), + (e.hyperlink = i)); + const s = t.commentsMap && t.commentsMap[e.address]; + s && (e.comment = s); + } + }; + }, + { + "../../../doc/enums": 7, + "../../../doc/range": 10, + "../../../utils/utils": 27, + "../base-xform": 32, + "../strings/rich-text-xform": 122, + }, + ], + 74: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"); + t.exports = class extends n { + get tag() { + return "x14:cfIcon"; + } + render(e, t) { + e.leafNode(this.tag, { iconSet: t.iconSet, iconId: t.iconId }); + } + parseOpen(e) { + let { attributes: t } = e; + this.model = { + iconSet: t.iconSet, + iconId: n.toIntValue(t.iconId), + }; + } + parseClose(e) { + return e !== this.tag; + } + }; + }, + { "../../base-xform": 32 }, + ], + 75: [ + function (e, t, r) { + "use strict"; + const { v4: n } = e("uuid"), + i = e("../../base-xform"), + s = e("../../composite-xform"), + o = e("./databar-ext-xform"), + a = e("./icon-set-ext-xform"), + l = { "3Triangles": !0, "3Stars": !0, "5Boxes": !0 }; + class c extends s { + constructor() { + (super(), + (this.map = { + "x14:dataBar": (this.databarXform = new o()), + "x14:iconSet": (this.iconSetXform = new a()), + })); + } + get tag() { + return "x14:cfRule"; + } + static isExt(e) { + return "dataBar" === e.type + ? o.isExt(e) + : !("iconSet" !== e.type || (!e.custom && !l[e.iconSet])); + } + prepare(e) { + c.isExt(e) && (e.x14Id = `{${n()}}`.toUpperCase()); + } + render(e, t) { + if (c.isExt(t)) + switch (t.type) { + case "dataBar": + this.renderDataBar(e, t); + break; + case "iconSet": + this.renderIconSet(e, t); + } + } + renderDataBar(e, t) { + (e.openNode(this.tag, { type: "dataBar", id: t.x14Id }), + this.databarXform.render(e, t), + e.closeNode()); + } + renderIconSet(e, t) { + (e.openNode(this.tag, { + type: "iconSet", + priority: t.priority, + id: t.x14Id || `{${n()}}`, + }), + this.iconSetXform.render(e, t), + e.closeNode()); + } + createNewModel(e) { + let { attributes: t } = e; + return { + type: t.type, + x14Id: t.id, + priority: i.toIntValue(t.priority), + }; + } + onParserClose(e, t) { + Object.assign(this.model, t.model); + } + } + t.exports = c; + }, + { + "../../base-xform": 32, + "../../composite-xform": 48, + "./databar-ext-xform": 79, + "./icon-set-ext-xform": 81, + uuid: 528, + }, + ], + 76: [ + function (e, t, r) { + "use strict"; + const n = e("../../composite-xform"), + i = e("./f-ext-xform"); + t.exports = class extends n { + constructor() { + (super(), (this.map = { "xm:f": (this.fExtXform = new i()) })); + } + get tag() { + return "x14:cfvo"; + } + render(e, t) { + (e.openNode(this.tag, { type: t.type }), + void 0 !== t.value && this.fExtXform.render(e, t.value), + e.closeNode()); + } + createNewModel(e) { + return { type: e.attributes.type }; + } + onParserClose(e, t) { + switch (e) { + case "xm:f": + this.model.value = t.model ? parseFloat(t.model) : 0; + } + } + }; + }, + { "../../composite-xform": 48, "./f-ext-xform": 80 }, + ], + 77: [ + function (e, t, r) { + "use strict"; + const n = e("../../composite-xform"), + i = e("./sqref-ext-xform"), + s = e("./cf-rule-ext-xform"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + "xm:sqref": (this.sqRef = new i()), + "x14:cfRule": (this.cfRule = new s()), + })); + } + get tag() { + return "x14:conditionalFormatting"; + } + prepare(e, t) { + e.rules.forEach((e) => { + this.cfRule.prepare(e, t); + }); + } + render(e, t) { + t.rules.some(s.isExt) && + (e.openNode(this.tag, { + "xmlns:xm": + "http://schemas.microsoft.com/office/excel/2006/main", + }), + t.rules + .filter(s.isExt) + .forEach((t) => this.cfRule.render(e, t)), + this.sqRef.render(e, t.ref), + e.closeNode()); + } + createNewModel() { + return { rules: [] }; + } + onParserClose(e, t) { + switch (e) { + case "xm:sqref": + this.model.ref = t.model; + break; + case "x14:cfRule": + this.model.rules.push(t.model); + } + } + }; + }, + { + "../../composite-xform": 48, + "./cf-rule-ext-xform": 75, + "./sqref-ext-xform": 82, + }, + ], + 78: [ + function (e, t, r) { + "use strict"; + const n = e("../../composite-xform"), + i = e("./cf-rule-ext-xform"), + s = e("./conditional-formatting-ext-xform"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + "x14:conditionalFormatting": (this.cfXform = new s()), + })); + } + get tag() { + return "x14:conditionalFormattings"; + } + hasContent(e) { + return ( + void 0 === e.hasExtContent && + (e.hasExtContent = e.some((e) => e.rules.some(i.isExt))), + e.hasExtContent + ); + } + prepare(e, t) { + e.forEach((e) => { + this.cfXform.prepare(e, t); + }); + } + render(e, t) { + this.hasContent(t) && + (e.openNode(this.tag), + t.forEach((t) => this.cfXform.render(e, t)), + e.closeNode()); + } + createNewModel() { + return []; + } + onParserClose(e, t) { + this.model.push(t.model); + } + }; + }, + { + "../../composite-xform": 48, + "./cf-rule-ext-xform": 75, + "./conditional-formatting-ext-xform": 77, + }, + ], + 79: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"), + i = e("../../composite-xform"), + s = e("../../style/color-xform"), + o = e("./cfvo-ext-xform"); + t.exports = class extends i { + constructor() { + (super(), + (this.map = { + "x14:cfvo": (this.cfvoXform = new o()), + "x14:borderColor": (this.borderColorXform = new s( + "x14:borderColor", + )), + "x14:negativeBorderColor": (this.negativeBorderColorXform = + new s("x14:negativeBorderColor")), + "x14:negativeFillColor": (this.negativeFillColorXform = new s( + "x14:negativeFillColor", + )), + "x14:axisColor": (this.axisColorXform = new s( + "x14:axisColor", + )), + })); + } + static isExt(e) { + return !e.gradient; + } + get tag() { + return "x14:dataBar"; + } + render(e, t) { + (e.openNode(this.tag, { + minLength: n.toIntAttribute(t.minLength, 0, !0), + maxLength: n.toIntAttribute(t.maxLength, 100, !0), + border: n.toBoolAttribute(t.border, !1), + gradient: n.toBoolAttribute(t.gradient, !0), + negativeBarColorSameAsPositive: n.toBoolAttribute( + t.negativeBarColorSameAsPositive, + !0, + ), + negativeBarBorderColorSameAsPositive: n.toBoolAttribute( + t.negativeBarBorderColorSameAsPositive, + !0, + ), + axisPosition: n.toAttribute(t.axisPosition, "auto"), + direction: n.toAttribute(t.direction, "leftToRight"), + }), + t.cfvo.forEach((t) => { + this.cfvoXform.render(e, t); + }), + this.borderColorXform.render(e, t.borderColor), + this.negativeBorderColorXform.render(e, t.negativeBorderColor), + this.negativeFillColorXform.render(e, t.negativeFillColor), + this.axisColorXform.render(e, t.axisColor), + e.closeNode()); + } + createNewModel(e) { + let { attributes: t } = e; + return { + cfvo: [], + minLength: n.toIntValue(t.minLength, 0), + maxLength: n.toIntValue(t.maxLength, 100), + border: n.toBoolValue(t.border, !1), + gradient: n.toBoolValue(t.gradient, !0), + negativeBarColorSameAsPositive: n.toBoolValue( + t.negativeBarColorSameAsPositive, + !0, + ), + negativeBarBorderColorSameAsPositive: n.toBoolValue( + t.negativeBarBorderColorSameAsPositive, + !0, + ), + axisPosition: n.toStringValue(t.axisPosition, "auto"), + direction: n.toStringValue(t.direction, "leftToRight"), + }; + } + onParserClose(e, t) { + const [, r] = e.split(":"); + switch (r) { + case "cfvo": + this.model.cfvo.push(t.model); + break; + default: + this.model[r] = t.model; + } + } + }; + }, + { + "../../base-xform": 32, + "../../composite-xform": 48, + "../../style/color-xform": 128, + "./cfvo-ext-xform": 76, + }, + ], + 80: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"); + t.exports = class extends n { + get tag() { + return "xm:f"; + } + render(e, t) { + e.leafNode(this.tag, null, t); + } + parseOpen() { + this.model = ""; + } + parseText(e) { + this.model += e; + } + parseClose(e) { + return e !== this.tag; + } + }; + }, + { "../../base-xform": 32 }, + ], + 81: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"), + i = e("../../composite-xform"), + s = e("./cfvo-ext-xform"), + o = e("./cf-icon-ext-xform"); + t.exports = class extends i { + constructor() { + (super(), + (this.map = { + "x14:cfvo": (this.cfvoXform = new s()), + "x14:cfIcon": (this.cfIconXform = new o()), + })); + } + get tag() { + return "x14:iconSet"; + } + render(e, t) { + (e.openNode(this.tag, { + iconSet: n.toStringAttribute(t.iconSet), + reverse: n.toBoolAttribute(t.reverse, !1), + showValue: n.toBoolAttribute(t.showValue, !0), + custom: n.toBoolAttribute(t.icons, !1), + }), + t.cfvo.forEach((t) => { + this.cfvoXform.render(e, t); + }), + t.icons && + t.icons.forEach((t, r) => { + ((t.iconId = r), this.cfIconXform.render(e, t)); + }), + e.closeNode()); + } + createNewModel(e) { + let { attributes: t } = e; + return { + cfvo: [], + iconSet: n.toStringValue(t.iconSet, "3TrafficLights"), + reverse: n.toBoolValue(t.reverse, !1), + showValue: n.toBoolValue(t.showValue, !0), + }; + } + onParserClose(e, t) { + const [, r] = e.split(":"); + switch (r) { + case "cfvo": + this.model.cfvo.push(t.model); + break; + case "cfIcon": + (this.model.icons || (this.model.icons = []), + this.model.icons.push(t.model)); + break; + default: + this.model[r] = t.model; + } + } + }; + }, + { + "../../base-xform": 32, + "../../composite-xform": 48, + "./cf-icon-ext-xform": 74, + "./cfvo-ext-xform": 76, + }, + ], + 82: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"); + t.exports = class extends n { + get tag() { + return "xm:sqref"; + } + render(e, t) { + e.leafNode(this.tag, null, t); + } + parseOpen() { + this.model = ""; + } + parseText(e) { + this.model += e; + } + parseClose(e) { + return e !== this.tag; + } + }; + }, + { "../../base-xform": 32 }, + ], + 83: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"), + i = e("../../composite-xform"), + s = e("../../../../doc/range"), + o = e("./databar-xform"), + a = e("./ext-lst-ref-xform"), + l = e("./formula-xform"), + c = e("./color-scale-xform"), + u = e("./icon-set-xform"), + h = { "3Triangles": !0, "3Stars": !0, "5Boxes": !0 }, + f = (e) => { + const { type: t, operator: r } = e; + switch (t) { + case "containsText": + case "containsBlanks": + case "notContainsBlanks": + case "containsErrors": + case "notContainsErrors": + return { type: "containsText", operator: t }; + default: + return { type: t, operator: r }; + } + }; + class d extends i { + constructor() { + (super(), + (this.map = { + dataBar: (this.databarXform = new o()), + extLst: (this.extLstRefXform = new a()), + formula: (this.formulaXform = new l()), + colorScale: (this.colorScaleXform = new c()), + iconSet: (this.iconSetXform = new u()), + })); + } + get tag() { + return "cfRule"; + } + static isPrimitive(e) { + return "iconSet" !== e.type || (!e.custom && !h[e.iconSet]); + } + render(e, t) { + switch (t.type) { + case "expression": + this.renderExpression(e, t); + break; + case "cellIs": + this.renderCellIs(e, t); + break; + case "top10": + this.renderTop10(e, t); + break; + case "aboveAverage": + this.renderAboveAverage(e, t); + break; + case "dataBar": + this.renderDataBar(e, t); + break; + case "colorScale": + this.renderColorScale(e, t); + break; + case "iconSet": + this.renderIconSet(e, t); + break; + case "containsText": + this.renderText(e, t); + break; + case "timePeriod": + this.renderTimePeriod(e, t); + } + } + renderExpression(e, t) { + (e.openNode(this.tag, { + type: "expression", + dxfId: t.dxfId, + priority: t.priority, + }), + this.formulaXform.render(e, t.formulae[0]), + e.closeNode()); + } + renderCellIs(e, t) { + (e.openNode(this.tag, { + type: "cellIs", + dxfId: t.dxfId, + priority: t.priority, + operator: t.operator, + }), + t.formulae.forEach((t) => { + this.formulaXform.render(e, t); + }), + e.closeNode()); + } + renderTop10(e, t) { + e.leafNode(this.tag, { + type: "top10", + dxfId: t.dxfId, + priority: t.priority, + percent: n.toBoolAttribute(t.percent, !1), + bottom: n.toBoolAttribute(t.bottom, !1), + rank: n.toIntValue(t.rank, 10, !0), + }); + } + renderAboveAverage(e, t) { + e.leafNode(this.tag, { + type: "aboveAverage", + dxfId: t.dxfId, + priority: t.priority, + aboveAverage: n.toBoolAttribute(t.aboveAverage, !0), + }); + } + renderDataBar(e, t) { + (e.openNode(this.tag, { type: "dataBar", priority: t.priority }), + this.databarXform.render(e, t), + this.extLstRefXform.render(e, t), + e.closeNode()); + } + renderColorScale(e, t) { + (e.openNode(this.tag, { + type: "colorScale", + priority: t.priority, + }), + this.colorScaleXform.render(e, t), + e.closeNode()); + } + renderIconSet(e, t) { + d.isPrimitive(t) && + (e.openNode(this.tag, { + type: "iconSet", + priority: t.priority, + }), + this.iconSetXform.render(e, t), + e.closeNode()); + } + renderText(e, t) { + e.openNode(this.tag, { + type: t.operator, + dxfId: t.dxfId, + priority: t.priority, + operator: n.toStringAttribute(t.operator, "containsText"), + }); + const r = ((e) => { + if (e.formulae && e.formulae[0]) return e.formulae[0]; + const t = new s(e.ref), + { tl: r } = t; + switch (e.operator) { + case "containsText": + return `NOT(ISERROR(SEARCH("${e.text}",${r})))`; + case "containsBlanks": + return `LEN(TRIM(${r}))=0`; + case "notContainsBlanks": + return `LEN(TRIM(${r}))>0`; + case "containsErrors": + return `ISERROR(${r})`; + case "notContainsErrors": + return `NOT(ISERROR(${r}))`; + default: + return; + } + })(t); + (r && this.formulaXform.render(e, r), e.closeNode()); + } + renderTimePeriod(e, t) { + e.openNode(this.tag, { + type: "timePeriod", + dxfId: t.dxfId, + priority: t.priority, + timePeriod: t.timePeriod, + }); + const r = ((e) => { + if (e.formulae && e.formulae[0]) return e.formulae[0]; + const t = new s(e.ref), + { tl: r } = t; + switch (e.timePeriod) { + case "thisWeek": + return `AND(TODAY()-ROUNDDOWN(${r},0)<=WEEKDAY(TODAY())-1,ROUNDDOWN(${r},0)-TODAY()<=7-WEEKDAY(TODAY()))`; + case "lastWeek": + return `AND(TODAY()-ROUNDDOWN(${r},0)>=(WEEKDAY(TODAY())),TODAY()-ROUNDDOWN(${r},0)<(WEEKDAY(TODAY())+7))`; + case "nextWeek": + return `AND(ROUNDDOWN(${r},0)-TODAY()>(7-WEEKDAY(TODAY())),ROUNDDOWN(${r},0)-TODAY()<(15-WEEKDAY(TODAY())))`; + case "yesterday": + return `FLOOR(${r},1)=TODAY()-1`; + case "today": + return `FLOOR(${r},1)=TODAY()`; + case "tomorrow": + return `FLOOR(${r},1)=TODAY()+1`; + case "last7Days": + return `AND(TODAY()-FLOOR(${r},1)<=6,FLOOR(${r},1)<=TODAY())`; + case "lastMonth": + return `AND(MONTH(${r})=MONTH(EDATE(TODAY(),0-1)),YEAR(${r})=YEAR(EDATE(TODAY(),0-1)))`; + case "thisMonth": + return `AND(MONTH(${r})=MONTH(TODAY()),YEAR(${r})=YEAR(TODAY()))`; + case "nextMonth": + return `AND(MONTH(${r})=MONTH(EDATE(TODAY(),0+1)),YEAR(${r})=YEAR(EDATE(TODAY(),0+1)))`; + default: + return; + } + })(t); + (r && this.formulaXform.render(e, r), e.closeNode()); + } + createNewModel(e) { + let { attributes: t } = e; + return { + ...f(t), + dxfId: n.toIntValue(t.dxfId), + priority: n.toIntValue(t.priority), + timePeriod: t.timePeriod, + percent: n.toBoolValue(t.percent), + bottom: n.toBoolValue(t.bottom), + rank: n.toIntValue(t.rank), + aboveAverage: n.toBoolValue(t.aboveAverage), + }; + } + onParserClose(e, t) { + switch (e) { + case "dataBar": + case "extLst": + case "colorScale": + case "iconSet": + Object.assign(this.model, t.model); + break; + case "formula": + ((this.model.formulae = this.model.formulae || []), + this.model.formulae.push(t.model)); + } + } + } + t.exports = d; + }, + { + "../../../../doc/range": 10, + "../../base-xform": 32, + "../../composite-xform": 48, + "./color-scale-xform": 85, + "./databar-xform": 88, + "./ext-lst-ref-xform": 89, + "./formula-xform": 90, + "./icon-set-xform": 91, + }, + ], + 84: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"); + t.exports = class extends n { + get tag() { + return "cfvo"; + } + render(e, t) { + e.leafNode(this.tag, { type: t.type, val: t.value }); + } + parseOpen(e) { + this.model = { + type: e.attributes.type, + value: n.toFloatValue(e.attributes.val), + }; + } + parseClose(e) { + return e !== this.tag; + } + }; + }, + { "../../base-xform": 32 }, + ], + 85: [ + function (e, t, r) { + "use strict"; + const n = e("../../composite-xform"), + i = e("../../style/color-xform"), + s = e("./cfvo-xform"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + cfvo: (this.cfvoXform = new s()), + color: (this.colorXform = new i()), + })); + } + get tag() { + return "colorScale"; + } + render(e, t) { + (e.openNode(this.tag), + t.cfvo.forEach((t) => { + this.cfvoXform.render(e, t); + }), + t.color.forEach((t) => { + this.colorXform.render(e, t); + }), + e.closeNode()); + } + createNewModel(e) { + return { cfvo: [], color: [] }; + } + onParserClose(e, t) { + this.model[e].push(t.model); + } + }; + }, + { + "../../composite-xform": 48, + "../../style/color-xform": 128, + "./cfvo-xform": 84, + }, + ], + 86: [ + function (e, t, r) { + "use strict"; + const n = e("../../composite-xform"), + i = e("./cf-rule-xform"); + t.exports = class extends n { + constructor() { + (super(), (this.map = { cfRule: new i() })); + } + get tag() { + return "conditionalFormatting"; + } + render(e, t) { + t.rules.some(i.isPrimitive) && + (e.openNode(this.tag, { sqref: t.ref }), + t.rules.forEach((r) => { + i.isPrimitive(r) && + ((r.ref = t.ref), this.map.cfRule.render(e, r)); + }), + e.closeNode()); + } + createNewModel(e) { + let { attributes: t } = e; + return { ref: t.sqref, rules: [] }; + } + onParserClose(e, t) { + this.model.rules.push(t.model); + } + }; + }, + { "../../composite-xform": 48, "./cf-rule-xform": 83 }, + ], + 87: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"), + i = e("./conditional-formatting-xform"); + t.exports = class extends n { + constructor() { + (super(), (this.cfXform = new i())); + } + get tag() { + return "conditionalFormatting"; + } + reset() { + this.model = []; + } + prepare(e, t) { + let r = e.reduce( + (e, t) => Math.max(e, ...t.rules.map((e) => e.priority || 0)), + 1, + ); + e.forEach((e) => { + e.rules.forEach((e) => { + (e.priority || (e.priority = r++), + e.style && (e.dxfId = t.styles.addDxfStyle(e.style))); + }); + }); + } + render(e, t) { + t.forEach((t) => { + this.cfXform.render(e, t); + }); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "conditionalFormatting": + return ( + (this.parser = this.cfXform), + this.parser.parseOpen(e), + !0 + ); + default: + return !1; + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + return ( + !!this.parser && + (!!this.parser.parseClose(e) || + (this.model.push(this.parser.model), + (this.parser = void 0), + !1)) + ); + } + reconcile(e, t) { + e.forEach((e) => { + e.rules.forEach((e) => { + void 0 !== e.dxfId && + ((e.style = t.styles.getDxfStyle(e.dxfId)), delete e.dxfId); + }); + }); + } + }; + }, + { "../../base-xform": 32, "./conditional-formatting-xform": 86 }, + ], + 88: [ + function (e, t, r) { + "use strict"; + const n = e("../../composite-xform"), + i = e("../../style/color-xform"), + s = e("./cfvo-xform"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + cfvo: (this.cfvoXform = new s()), + color: (this.colorXform = new i()), + })); + } + get tag() { + return "dataBar"; + } + render(e, t) { + (e.openNode(this.tag), + t.cfvo.forEach((t) => { + this.cfvoXform.render(e, t); + }), + this.colorXform.render(e, t.color), + e.closeNode()); + } + createNewModel() { + return { cfvo: [] }; + } + onParserClose(e, t) { + switch (e) { + case "cfvo": + this.model.cfvo.push(t.model); + break; + case "color": + this.model.color = t.model; + } + } + }; + }, + { + "../../composite-xform": 48, + "../../style/color-xform": 128, + "./cfvo-xform": 84, + }, + ], + 89: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"), + i = e("../../composite-xform"); + class s extends n { + get tag() { + return "x14:id"; + } + render(e, t) { + e.leafNode(this.tag, null, t); + } + parseOpen() { + this.model = ""; + } + parseText(e) { + this.model += e; + } + parseClose(e) { + return e !== this.tag; + } + } + class o extends i { + constructor() { + (super(), (this.map = { "x14:id": (this.idXform = new s()) })); + } + get tag() { + return "ext"; + } + render(e, t) { + (e.openNode(this.tag, { + uri: "{B025F937-C7B1-47D3-B67F-A62EFF666E3E}", + "xmlns:x14": + "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main", + }), + this.idXform.render(e, t.x14Id), + e.closeNode()); + } + createNewModel() { + return {}; + } + onParserClose(e, t) { + this.model.x14Id = t.model; + } + } + t.exports = class extends i { + constructor() { + (super(), (this.map = { ext: new o() })); + } + get tag() { + return "extLst"; + } + render(e, t) { + (e.openNode(this.tag), this.map.ext.render(e, t), e.closeNode()); + } + createNewModel() { + return {}; + } + onParserClose(e, t) { + Object.assign(this.model, t.model); + } + }; + }, + { "../../base-xform": 32, "../../composite-xform": 48 }, + ], + 90: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"); + t.exports = class extends n { + get tag() { + return "formula"; + } + render(e, t) { + e.leafNode(this.tag, null, t); + } + parseOpen() { + this.model = ""; + } + parseText(e) { + this.model += e; + } + parseClose(e) { + return e !== this.tag; + } + }; + }, + { "../../base-xform": 32 }, + ], + 91: [ + function (e, t, r) { + "use strict"; + const n = e("../../base-xform"), + i = e("../../composite-xform"), + s = e("./cfvo-xform"); + t.exports = class extends i { + constructor() { + (super(), (this.map = { cfvo: (this.cfvoXform = new s()) })); + } + get tag() { + return "iconSet"; + } + render(e, t) { + (e.openNode(this.tag, { + iconSet: n.toStringAttribute(t.iconSet, "3TrafficLights"), + reverse: n.toBoolAttribute(t.reverse, !1), + showValue: n.toBoolAttribute(t.showValue, !0), + }), + t.cfvo.forEach((t) => { + this.cfvoXform.render(e, t); + }), + e.closeNode()); + } + createNewModel(e) { + let { attributes: t } = e; + return { + iconSet: n.toStringValue(t.iconSet, "3TrafficLights"), + reverse: n.toBoolValue(t.reverse), + showValue: n.toBoolValue(t.showValue), + cfvo: [], + }; + } + onParserClose(e, t) { + this.model[e].push(t.model); + } + }; + }, + { + "../../base-xform": 32, + "../../composite-xform": 48, + "./cfvo-xform": 84, + }, + ], + 92: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/utils"), + i = e("../base-xform"); + t.exports = class extends i { + get tag() { + return "col"; + } + prepare(e, t) { + const r = t.styles.addStyleModel(e.style || {}); + r && (e.styleId = r); + } + render(e, t) { + (e.openNode("col"), + e.addAttribute("min", t.min), + e.addAttribute("max", t.max), + t.width && e.addAttribute("width", t.width), + t.styleId && e.addAttribute("style", t.styleId), + t.hidden && e.addAttribute("hidden", "1"), + t.bestFit && e.addAttribute("bestFit", "1"), + t.outlineLevel && + e.addAttribute("outlineLevel", t.outlineLevel), + t.collapsed && e.addAttribute("collapsed", "1"), + e.addAttribute("customWidth", "1"), + e.closeNode()); + } + parseOpen(e) { + if ("col" === e.name) { + const t = (this.model = { + min: parseInt(e.attributes.min || "0", 10), + max: parseInt(e.attributes.max || "0", 10), + width: + void 0 === e.attributes.width + ? void 0 + : parseFloat(e.attributes.width || "0"), + }); + return ( + e.attributes.style && + (t.styleId = parseInt(e.attributes.style, 10)), + n.parseBoolean(e.attributes.hidden) && (t.hidden = !0), + n.parseBoolean(e.attributes.bestFit) && (t.bestFit = !0), + e.attributes.outlineLevel && + (t.outlineLevel = parseInt(e.attributes.outlineLevel, 10)), + n.parseBoolean(e.attributes.collapsed) && (t.collapsed = !0), + !0 + ); + } + return !1; + } + parseText() {} + parseClose() { + return !1; + } + reconcile(e, t) { + e.styleId && (e.style = t.styles.getStyleModel(e.styleId)); + } + }; + }, + { "../../../utils/utils": 27, "../base-xform": 32 }, + ], + 93: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/under-dash"), + i = e("../../../utils/utils"), + s = e("../../../utils/col-cache"), + o = e("../base-xform"), + a = e("../../../doc/range"); + function l(e, t, r, n) { + const i = t[r]; + void 0 !== i ? (e[r] = i) : void 0 !== n && (e[r] = n); + } + function c(e, t, r, n) { + const s = t[r]; + void 0 !== s + ? (e[r] = i.parseBoolean(s)) + : void 0 !== n && (e[r] = n); + } + t.exports = class extends o { + get tag() { + return "dataValidations"; + } + render(e, t) { + const r = (function (e) { + const t = n + .map(e, (e, t) => ({ + address: t, + dataValidation: e, + marked: !1, + })) + .sort((e, t) => n.strcmp(e.address, t.address)), + r = n.keyBy(t, "address"), + i = (t, r, i) => { + for (let o = 0; o < r; o++) { + const r = s.encodeAddress(t.row + o, i); + if (!e[r] || !n.isEqual(e[t.address], e[r])) return !1; + } + return !0; + }; + return t + .map((t) => { + if (!t.marked) { + const o = s.decodeEx(t.address); + if (o.dimensions) + return ( + (r[o.dimensions].marked = !0), + { ...t.dataValidation, sqref: t.address } + ); + let a = 1, + l = s.encodeAddress(o.row + a, o.col); + for (; e[l] && n.isEqual(t.dataValidation, e[l]); ) + (a++, (l = s.encodeAddress(o.row + a, o.col))); + let c = 1; + for (; i(o, a, o.col + c); ) c++; + for (let e = 0; e < a; e++) + for (let t = 0; t < c; t++) + ((l = s.encodeAddress(o.row + e, o.col + t)), + (r[l].marked = !0)); + if (a > 1 || c > 1) { + const e = o.row + (a - 1), + r = o.col + (c - 1); + return { + ...t.dataValidation, + sqref: `${t.address}:${s.encodeAddress(e, r)}`, + }; + } + return { ...t.dataValidation, sqref: t.address }; + } + return null; + }) + .filter(Boolean); + })(t); + r.length && + (e.openNode("dataValidations", { count: r.length }), + r.forEach((t) => { + (e.openNode("dataValidation"), + "any" !== t.type && + (e.addAttribute("type", t.type), + t.operator && + "list" !== t.type && + "between" !== t.operator && + e.addAttribute("operator", t.operator), + t.allowBlank && e.addAttribute("allowBlank", "1")), + t.showInputMessage && + e.addAttribute("showInputMessage", "1"), + t.promptTitle && + e.addAttribute("promptTitle", t.promptTitle), + t.prompt && e.addAttribute("prompt", t.prompt), + t.showErrorMessage && + e.addAttribute("showErrorMessage", "1"), + t.errorStyle && e.addAttribute("errorStyle", t.errorStyle), + t.errorTitle && e.addAttribute("errorTitle", t.errorTitle), + t.error && e.addAttribute("error", t.error), + e.addAttribute("sqref", t.sqref), + (t.formulae || []).forEach((r, n) => { + (e.openNode("formula" + (n + 1)), + "date" === t.type + ? e.writeText(i.dateToExcel(new Date(r))) + : e.writeText(r), + e.closeNode()); + }), + e.closeNode()); + }), + e.closeNode()); + } + parseOpen(e) { + switch (e.name) { + case "dataValidations": + return ((this.model = {}), !0); + case "dataValidation": { + this._address = e.attributes.sqref; + const t = { type: e.attributes.type || "any", formulae: [] }; + switch ( + (e.attributes.type && c(t, e.attributes, "allowBlank"), + c(t, e.attributes, "showInputMessage"), + c(t, e.attributes, "showErrorMessage"), + t.type) + ) { + case "any": + case "list": + case "custom": + break; + default: + l(t, e.attributes, "operator", "between"); + } + return ( + l(t, e.attributes, "promptTitle"), + l(t, e.attributes, "prompt"), + l(t, e.attributes, "errorStyle"), + l(t, e.attributes, "errorTitle"), + l(t, e.attributes, "error"), + (this._dataValidation = t), + !0 + ); + } + case "formula1": + case "formula2": + return ((this._formula = []), !0); + default: + return !1; + } + } + parseText(e) { + this._formula && this._formula.push(e); + } + parseClose(e) { + switch (e) { + case "dataValidations": + return !1; + case "dataValidation": + (this._dataValidation.formulae && + this._dataValidation.formulae.length) || + (delete this._dataValidation.formulae, + delete this._dataValidation.operator); + return ( + (this._address.split(/\s+/g) || []).forEach((e) => { + if (e.includes(":")) { + new a(e).forEachAddress((e) => { + this.model[e] = this._dataValidation; + }); + } else this.model[e] = this._dataValidation; + }), + !0 + ); + case "formula1": + case "formula2": { + let e = this._formula.join(""); + switch (this._dataValidation.type) { + case "whole": + case "textLength": + e = parseInt(e, 10); + break; + case "decimal": + e = parseFloat(e); + break; + case "date": + e = i.excelToDate(parseFloat(e)); + } + return ( + this._dataValidation.formulae.push(e), + (this._formula = void 0), + !0 + ); + } + default: + return !0; + } + } + }; + }, + { + "../../../doc/range": 10, + "../../../utils/col-cache": 19, + "../../../utils/under-dash": 26, + "../../../utils/utils": 27, + "../base-xform": 32, + }, + ], + 94: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "dimension"; + } + render(e, t) { + t && e.leafNode("dimension", { ref: t }); + } + parseOpen(e) { + return ( + "dimension" === e.name && ((this.model = e.attributes.ref), !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 95: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "drawing"; + } + render(e, t) { + t && e.leafNode(this.tag, { "r:id": t.rId }); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ((this.model = { rId: e.attributes["r:id"] }), !0); + default: + return !1; + } + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 96: [ + function (e, t, r) { + "use strict"; + const n = e("../composite-xform"), + i = e("./cf-ext/conditional-formattings-ext-xform"); + class s extends n { + constructor() { + (super(), + (this.map = { + "x14:conditionalFormattings": (this.conditionalFormattings = + new i()), + })); + } + get tag() { + return "ext"; + } + hasContent(e) { + return this.conditionalFormattings.hasContent( + e.conditionalFormattings, + ); + } + prepare(e, t) { + this.conditionalFormattings.prepare(e.conditionalFormattings, t); + } + render(e, t) { + (e.openNode("ext", { + uri: "{78C0D931-6437-407d-A8EE-F0AAD7539E65}", + "xmlns:x14": + "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main", + }), + this.conditionalFormattings.render(e, t.conditionalFormattings), + e.closeNode()); + } + createNewModel() { + return {}; + } + onParserClose(e, t) { + this.model[e] = t.model; + } + } + t.exports = class extends n { + constructor() { + (super(), (this.map = { ext: (this.ext = new s()) })); + } + get tag() { + return "extLst"; + } + prepare(e, t) { + this.ext.prepare(e, t); + } + hasContent(e) { + return this.ext.hasContent(e); + } + render(e, t) { + this.hasContent(t) && + (e.openNode("extLst"), this.ext.render(e, t), e.closeNode()); + } + createNewModel() { + return {}; + } + onParserClose(e, t) { + Object.assign(this.model, t.model); + } + }; + }, + { + "../composite-xform": 48, + "./cf-ext/conditional-formattings-ext-xform": 78, + }, + ], + 97: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "headerFooter"; + } + render(e, t) { + if (t) { + e.addRollback(); + let r = !1; + (e.openNode("headerFooter"), + t.differentFirst && + (e.addAttribute("differentFirst", "1"), (r = !0)), + t.differentOddEven && + (e.addAttribute("differentOddEven", "1"), (r = !0)), + t.oddHeader && + "string" == typeof t.oddHeader && + (e.leafNode("oddHeader", null, t.oddHeader), (r = !0)), + t.oddFooter && + "string" == typeof t.oddFooter && + (e.leafNode("oddFooter", null, t.oddFooter), (r = !0)), + t.evenHeader && + "string" == typeof t.evenHeader && + (e.leafNode("evenHeader", null, t.evenHeader), (r = !0)), + t.evenFooter && + "string" == typeof t.evenFooter && + (e.leafNode("evenFooter", null, t.evenFooter), (r = !0)), + t.firstHeader && + "string" == typeof t.firstHeader && + (e.leafNode("firstHeader", null, t.firstHeader), (r = !0)), + t.firstFooter && + "string" == typeof t.firstFooter && + (e.leafNode("firstFooter", null, t.firstFooter), (r = !0)), + r ? (e.closeNode(), e.commit()) : e.rollback()); + } + } + parseOpen(e) { + switch (e.name) { + case "headerFooter": + return ( + (this.model = {}), + e.attributes.differentFirst && + (this.model.differentFirst = + 1 === parseInt(e.attributes.differentFirst, 0)), + e.attributes.differentOddEven && + (this.model.differentOddEven = + 1 === parseInt(e.attributes.differentOddEven, 0)), + !0 + ); + case "oddHeader": + return ((this.currentNode = "oddHeader"), !0); + case "oddFooter": + return ((this.currentNode = "oddFooter"), !0); + case "evenHeader": + return ((this.currentNode = "evenHeader"), !0); + case "evenFooter": + return ((this.currentNode = "evenFooter"), !0); + case "firstHeader": + return ((this.currentNode = "firstHeader"), !0); + case "firstFooter": + return ((this.currentNode = "firstFooter"), !0); + default: + return !1; + } + } + parseText(e) { + switch (this.currentNode) { + case "oddHeader": + this.model.oddHeader = e; + break; + case "oddFooter": + this.model.oddFooter = e; + break; + case "evenHeader": + this.model.evenHeader = e; + break; + case "evenFooter": + this.model.evenFooter = e; + break; + case "firstHeader": + this.model.firstHeader = e; + break; + case "firstFooter": + this.model.firstFooter = e; + } + } + parseClose() { + switch (this.currentNode) { + case "oddHeader": + case "oddFooter": + case "evenHeader": + case "evenFooter": + case "firstHeader": + case "firstFooter": + return ((this.currentNode = void 0), !0); + default: + return !1; + } + } + }; + }, + { "../base-xform": 32 }, + ], + 98: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "hyperlink"; + } + render(e, t) { + this.isInternalLink(t) + ? e.leafNode("hyperlink", { + ref: t.address, + "r:id": t.rId, + tooltip: t.tooltip, + location: t.target, + }) + : e.leafNode("hyperlink", { + ref: t.address, + "r:id": t.rId, + tooltip: t.tooltip, + }); + } + parseOpen(e) { + return ( + "hyperlink" === e.name && + ((this.model = { + address: e.attributes.ref, + rId: e.attributes["r:id"], + tooltip: e.attributes.tooltip, + }), + e.attributes.location && + (this.model.target = e.attributes.location), + !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + isInternalLink(e) { + return e.target && /^[^!]+![a-zA-Z]+[\d]+$/.test(e.target); + } + }; + }, + { "../base-xform": 32 }, + ], + 99: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "mergeCell"; + } + render(e, t) { + e.leafNode("mergeCell", { ref: t }); + } + parseOpen(e) { + return ( + "mergeCell" === e.name && ((this.model = e.attributes.ref), !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 100: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/under-dash"), + i = e("../../../doc/range"), + s = e("../../../utils/col-cache"), + o = e("../../../doc/enums"); + t.exports = class { + constructor() { + this.merges = {}; + } + add(e) { + if (this.merges[e.master]) + this.merges[e.master].expandToAddress(e.address); + else { + const t = `${e.master}:${e.address}`; + this.merges[e.master] = new i(t); + } + } + get mergeCells() { + return n.map(this.merges, (e) => e.range); + } + reconcile(e, t) { + n.each(e, (e) => { + const r = s.decode(e); + for (let e = r.top; e <= r.bottom; e++) { + const n = t[e - 1]; + for (let t = r.left; t <= r.right; t++) { + const i = n.cells[t - 1]; + i + ? i.type === o.ValueType.Merge && (i.master = r.tl) + : (n.cells[t] = { + type: o.ValueType.Null, + address: s.encodeAddress(e, t), + }); + } + } + }); + } + getMasterAddress(e) { + const t = this.hash[e]; + return t && t.tl; + } + }; + }, + { + "../../../doc/enums": 7, + "../../../doc/range": 10, + "../../../utils/col-cache": 19, + "../../../utils/under-dash": 26, + }, + ], + 101: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = (e) => void 0 !== e; + t.exports = class extends n { + get tag() { + return "outlinePr"; + } + render(e, t) { + return ( + !(!t || (!i(t.summaryBelow) && !i(t.summaryRight))) && + (e.leafNode(this.tag, { + summaryBelow: i(t.summaryBelow) + ? Number(t.summaryBelow) + : void 0, + summaryRight: i(t.summaryRight) + ? Number(t.summaryRight) + : void 0, + }), + !0) + ); + } + parseOpen(e) { + return ( + e.name === this.tag && + ((this.model = { + summaryBelow: i(e.attributes.summaryBelow) + ? Boolean(Number(e.attributes.summaryBelow)) + : void 0, + summaryRight: i(e.attributes.summaryRight) + ? Boolean(Number(e.attributes.summaryRight)) + : void 0, + }), + !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 102: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "brk"; + } + render(e, t) { + e.leafNode("brk", t); + } + parseOpen(e) { + return "brk" === e.name && ((this.model = e.attributes.ref), !0); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 103: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/under-dash"), + i = e("../base-xform"); + t.exports = class extends i { + get tag() { + return "pageMargins"; + } + render(e, t) { + if (t) { + const r = { + left: t.left, + right: t.right, + top: t.top, + bottom: t.bottom, + header: t.header, + footer: t.footer, + }; + n.some(r, (e) => void 0 !== e) && e.leafNode(this.tag, r); + } + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ( + (this.model = { + left: parseFloat(e.attributes.left || 0.7), + right: parseFloat(e.attributes.right || 0.7), + top: parseFloat(e.attributes.top || 0.75), + bottom: parseFloat(e.attributes.bottom || 0.75), + header: parseFloat(e.attributes.header || 0.3), + footer: parseFloat(e.attributes.footer || 0.3), + }), + !0 + ); + default: + return !1; + } + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../../../utils/under-dash": 26, "../base-xform": 32 }, + ], + 104: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "pageSetUpPr"; + } + render(e, t) { + return ( + !(!t || !t.fitToPage) && + (e.leafNode(this.tag, { + fitToPage: t.fitToPage ? "1" : void 0, + }), + !0) + ); + } + parseOpen(e) { + return ( + e.name === this.tag && + ((this.model = { fitToPage: "1" === e.attributes.fitToPage }), + !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 105: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/under-dash"), + i = e("../base-xform"); + function s(e) { + return e ? "1" : void 0; + } + function o(e) { + switch (e) { + case "overThenDown": + return e; + default: + return; + } + } + function a(e) { + switch (e) { + case "atEnd": + case "asDisplyed": + return e; + default: + return; + } + } + function l(e) { + switch (e) { + case "dash": + case "blank": + case "NA": + return e; + default: + return; + } + } + t.exports = class extends i { + get tag() { + return "pageSetup"; + } + render(e, t) { + if (t) { + const r = { + paperSize: t.paperSize, + orientation: t.orientation, + horizontalDpi: t.horizontalDpi, + verticalDpi: t.verticalDpi, + pageOrder: o(t.pageOrder), + blackAndWhite: s(t.blackAndWhite), + draft: s(t.draft), + cellComments: a(t.cellComments), + errors: l(t.errors), + scale: t.scale, + fitToWidth: t.fitToWidth, + fitToHeight: t.fitToHeight, + firstPageNumber: t.firstPageNumber, + useFirstPageNumber: s(t.firstPageNumber), + usePrinterDefaults: s(t.usePrinterDefaults), + copies: t.copies, + }; + n.some(r, (e) => void 0 !== e) && e.leafNode(this.tag, r); + } + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ( + (this.model = { + paperSize: + ((t = e.attributes.paperSize), + void 0 !== t ? parseInt(t, 10) : void 0), + orientation: e.attributes.orientation || "portrait", + horizontalDpi: parseInt( + e.attributes.horizontalDpi || "4294967295", + 10, + ), + verticalDpi: parseInt( + e.attributes.verticalDpi || "4294967295", + 10, + ), + pageOrder: e.attributes.pageOrder || "downThenOver", + blackAndWhite: "1" === e.attributes.blackAndWhite, + draft: "1" === e.attributes.draft, + cellComments: e.attributes.cellComments || "None", + errors: e.attributes.errors || "displayed", + scale: parseInt(e.attributes.scale || "100", 10), + fitToWidth: parseInt(e.attributes.fitToWidth || "1", 10), + fitToHeight: parseInt( + e.attributes.fitToHeight || "1", + 10, + ), + firstPageNumber: parseInt( + e.attributes.firstPageNumber || "1", + 10, + ), + useFirstPageNumber: + "1" === e.attributes.useFirstPageNumber, + usePrinterDefaults: + "1" === e.attributes.usePrinterDefaults, + copies: parseInt(e.attributes.copies || "1", 10), + }), + !0 + ); + default: + return !1; + } + var t; + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../../../utils/under-dash": 26, "../base-xform": 32 }, + ], + 106: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "picture"; + } + render(e, t) { + t && e.leafNode(this.tag, { "r:id": t.rId }); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ((this.model = { rId: e.attributes["r:id"] }), !0); + default: + return !1; + } + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 107: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/under-dash"), + i = e("../base-xform"); + function s(e) { + return e ? "1" : void 0; + } + t.exports = class extends i { + get tag() { + return "printOptions"; + } + render(e, t) { + if (t) { + const r = { + headings: s(t.showRowColHeaders), + gridLines: s(t.showGridLines), + horizontalCentered: s(t.horizontalCentered), + verticalCentered: s(t.verticalCentered), + }; + n.some(r, (e) => void 0 !== e) && e.leafNode(this.tag, r); + } + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ( + (this.model = { + showRowColHeaders: "1" === e.attributes.headings, + showGridLines: "1" === e.attributes.gridLines, + horizontalCentered: + "1" === e.attributes.horizontalCentered, + verticalCentered: "1" === e.attributes.verticalCentered, + }), + !0 + ); + default: + return !1; + } + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../../../utils/under-dash": 26, "../base-xform": 32 }, + ], + 108: [ + function (e, t, r) { + "use strict"; + const n = e("./page-breaks-xform"), + i = e("../list-xform"); + t.exports = class extends i { + constructor() { + super({ tag: "rowBreaks", count: !0, childXform: new n() }); + } + render(e, t) { + if (t && t.length) { + (e.openNode(this.tag, this.$), + this.count && + (e.addAttribute(this.$count, t.length), + e.addAttribute("manualBreakCount", t.length))); + const { childXform: r } = this; + (t.forEach((t) => { + r.render(e, t); + }), + e.closeNode()); + } else this.empty && e.leafNode(this.tag); + } + }; + }, + { "../list-xform": 71, "./page-breaks-xform": 102 }, + ], + 109: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("../../../utils/utils"), + s = e("./cell-xform"); + t.exports = class extends n { + constructor(e) { + (super(), + (this.maxItems = e && e.maxItems), + (this.map = { c: new s() })); + } + get tag() { + return "row"; + } + prepare(e, t) { + const r = t.styles.addStyleModel(e.style); + r && (e.styleId = r); + const n = this.map.c; + e.cells.forEach((e) => { + n.prepare(e, t); + }); + } + render(e, t, r) { + (e.openNode("row"), + e.addAttribute("r", t.number), + t.height && + (e.addAttribute("ht", t.height), + e.addAttribute("customHeight", "1")), + t.hidden && e.addAttribute("hidden", "1"), + t.min > 0 && + t.max > 0 && + t.min <= t.max && + e.addAttribute("spans", `${t.min}:${t.max}`), + t.styleId && + (e.addAttribute("s", t.styleId), + e.addAttribute("customFormat", "1")), + e.addAttribute("x14ac:dyDescent", "0.25"), + t.outlineLevel && + e.addAttribute("outlineLevel", t.outlineLevel), + t.collapsed && e.addAttribute("collapsed", "1")); + const n = this.map.c; + (t.cells.forEach((t) => { + n.render(e, t, r); + }), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + if ("row" === e.name) { + this.numRowsSeen += 1; + const t = e.attributes.spans + ? e.attributes.spans.split(":").map((e) => parseInt(e, 10)) + : [void 0, void 0], + r = (this.model = { + number: parseInt(e.attributes.r, 10), + min: t[0], + max: t[1], + cells: [], + }); + return ( + e.attributes.s && (r.styleId = parseInt(e.attributes.s, 10)), + i.parseBoolean(e.attributes.hidden) && (r.hidden = !0), + i.parseBoolean(e.attributes.bestFit) && (r.bestFit = !0), + e.attributes.ht && (r.height = parseFloat(e.attributes.ht)), + e.attributes.outlineLevel && + (r.outlineLevel = parseInt(e.attributes.outlineLevel, 10)), + i.parseBoolean(e.attributes.collapsed) && (r.collapsed = !0), + !0 + ); + } + return ( + (this.parser = this.map[e.name]), + !!this.parser && (this.parser.parseOpen(e), !0) + ); + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) { + if (!this.parser.parseClose(e)) { + if ( + (this.model.cells.push(this.parser.model), + this.maxItems && this.model.cells.length > this.maxItems) + ) + throw new Error( + `Max column count (${this.maxItems}) exceeded`, + ); + this.parser = void 0; + } + return !0; + } + return !1; + } + reconcile(e, t) { + ((e.style = e.styleId ? t.styles.getStyleModel(e.styleId) : {}), + void 0 !== e.styleId && (e.styleId = void 0)); + const r = this.map.c; + e.cells.forEach((e) => { + r.reconcile(e, t); + }); + } + }; + }, + { "../../../utils/utils": 27, "../base-xform": 32, "./cell-xform": 73 }, + ], + 110: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/under-dash"), + i = e("../base-xform"); + t.exports = class extends i { + get tag() { + return "sheetFormatPr"; + } + render(e, t) { + if (t) { + const r = { + defaultRowHeight: t.defaultRowHeight, + outlineLevelRow: t.outlineLevelRow, + outlineLevelCol: t.outlineLevelCol, + "x14ac:dyDescent": t.dyDescent, + }; + (t.defaultColWidth && (r.defaultColWidth = t.defaultColWidth), + (t.defaultRowHeight && 15 === t.defaultRowHeight) || + (r.customHeight = "1"), + n.some(r, (e) => void 0 !== e) && + e.leafNode("sheetFormatPr", r)); + } + } + parseOpen(e) { + return ( + "sheetFormatPr" === e.name && + ((this.model = { + defaultRowHeight: parseFloat( + e.attributes.defaultRowHeight || "0", + ), + dyDescent: parseFloat(e.attributes["x14ac:dyDescent"] || "0"), + outlineLevelRow: parseInt( + e.attributes.outlineLevelRow || "0", + 10, + ), + outlineLevelCol: parseInt( + e.attributes.outlineLevelCol || "0", + 10, + ), + }), + e.attributes.defaultColWidth && + (this.model.defaultColWidth = parseFloat( + e.attributes.defaultColWidth, + )), + !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../../../utils/under-dash": 26, "../base-xform": 32 }, + ], + 111: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("../style/color-xform"), + s = e("./page-setup-properties-xform"), + o = e("./outline-properties-xform"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + tabColor: new i("tabColor"), + pageSetUpPr: new s(), + outlinePr: new o(), + })); + } + get tag() { + return "sheetPr"; + } + render(e, t) { + if (t) { + (e.addRollback(), e.openNode("sheetPr")); + let r = !1; + ((r = this.map.tabColor.render(e, t.tabColor) || r), + (r = this.map.pageSetUpPr.render(e, t.pageSetup) || r), + (r = this.map.outlinePr.render(e, t.outlineProperties) || r), + r ? (e.closeNode(), e.commit()) : e.rollback()); + } + } + parseOpen(e) { + return this.parser + ? (this.parser.parseOpen(e), !0) + : e.name === this.tag + ? (this.reset(), !0) + : !!this.map[e.name] && + ((this.parser = this.map[e.name]), + this.parser.parseOpen(e), + !0); + } + parseText(e) { + return !!this.parser && (this.parser.parseText(e), !0); + } + parseClose(e) { + return this.parser + ? (this.parser.parseClose(e) || (this.parser = void 0), !0) + : (this.map.tabColor.model || + this.map.pageSetUpPr.model || + this.map.outlinePr.model + ? ((this.model = {}), + this.map.tabColor.model && + (this.model.tabColor = this.map.tabColor.model), + this.map.pageSetUpPr.model && + (this.model.pageSetup = this.map.pageSetUpPr.model), + this.map.outlinePr.model && + (this.model.outlineProperties = + this.map.outlinePr.model)) + : (this.model = null), + !1); + } + }; + }, + { + "../base-xform": 32, + "../style/color-xform": 128, + "./outline-properties-xform": 101, + "./page-setup-properties-xform": 104, + }, + ], + 112: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/under-dash"), + i = e("../base-xform"); + function s(e, t) { + return e ? t : void 0; + } + function o(e, t) { + return e === t || void 0; + } + t.exports = class extends i { + get tag() { + return "sheetProtection"; + } + render(e, t) { + if (t) { + const r = { + sheet: s(t.sheet, "1"), + selectLockedCells: !1 === t.selectLockedCells ? "1" : void 0, + selectUnlockedCells: + !1 === t.selectUnlockedCells ? "1" : void 0, + formatCells: s(t.formatCells, "0"), + formatColumns: s(t.formatColumns, "0"), + formatRows: s(t.formatRows, "0"), + insertColumns: s(t.insertColumns, "0"), + insertRows: s(t.insertRows, "0"), + insertHyperlinks: s(t.insertHyperlinks, "0"), + deleteColumns: s(t.deleteColumns, "0"), + deleteRows: s(t.deleteRows, "0"), + sort: s(t.sort, "0"), + autoFilter: s(t.autoFilter, "0"), + pivotTables: s(t.pivotTables, "0"), + }; + (t.sheet && + ((r.algorithmName = t.algorithmName), + (r.hashValue = t.hashValue), + (r.saltValue = t.saltValue), + (r.spinCount = t.spinCount), + (r.objects = s(!1 === t.objects, "1")), + (r.scenarios = s(!1 === t.scenarios, "1"))), + n.some(r, (e) => void 0 !== e) && e.leafNode(this.tag, r)); + } + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ( + (this.model = { + sheet: o(e.attributes.sheet, "1"), + objects: "1" !== e.attributes.objects && void 0, + scenarios: "1" !== e.attributes.scenarios && void 0, + selectLockedCells: + "1" !== e.attributes.selectLockedCells && void 0, + selectUnlockedCells: + "1" !== e.attributes.selectUnlockedCells && void 0, + formatCells: o(e.attributes.formatCells, "0"), + formatColumns: o(e.attributes.formatColumns, "0"), + formatRows: o(e.attributes.formatRows, "0"), + insertColumns: o(e.attributes.insertColumns, "0"), + insertRows: o(e.attributes.insertRows, "0"), + insertHyperlinks: o(e.attributes.insertHyperlinks, "0"), + deleteColumns: o(e.attributes.deleteColumns, "0"), + deleteRows: o(e.attributes.deleteRows, "0"), + sort: o(e.attributes.sort, "0"), + autoFilter: o(e.attributes.autoFilter, "0"), + pivotTables: o(e.attributes.pivotTables, "0"), + }), + e.attributes.algorithmName && + ((this.model.algorithmName = e.attributes.algorithmName), + (this.model.hashValue = e.attributes.hashValue), + (this.model.saltValue = e.attributes.saltValue), + (this.model.spinCount = parseInt( + e.attributes.spinCount, + 10, + ))), + !0 + ); + default: + return !1; + } + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../../../utils/under-dash": 26, "../base-xform": 32 }, + ], + 113: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/col-cache"), + i = e("../base-xform"), + s = { frozen: "frozen", frozenSplit: "frozen", split: "split" }; + t.exports = class extends i { + get tag() { + return "sheetView"; + } + prepare(e) { + switch (e.state) { + case "frozen": + case "split": + break; + default: + e.state = "normal"; + } + } + render(e, t) { + e.openNode("sheetView", { + workbookViewId: t.workbookViewId || 0, + }); + const r = function (t, r, n) { + n && e.addAttribute(t, r); + }; + let i, s, o, a; + switch ( + (r("rightToLeft", "1", !0 === t.rightToLeft), + r("tabSelected", "1", t.tabSelected), + r("showRuler", "0", !1 === t.showRuler), + r("showRowColHeaders", "0", !1 === t.showRowColHeaders), + r("showGridLines", "0", !1 === t.showGridLines), + r("zoomScale", t.zoomScale, t.zoomScale), + r("zoomScaleNormal", t.zoomScaleNormal, t.zoomScaleNormal), + r("view", t.style, t.style), + t.state) + ) { + case "frozen": + ((s = t.xSplit || 0), + (o = t.ySplit || 0), + (i = t.topLeftCell || n.getAddress(o + 1, s + 1).address), + (a = + (t.xSplit && t.ySplit + ? "bottomRight" + : t.xSplit && "topRight") || "bottomLeft"), + e.leafNode("pane", { + xSplit: t.xSplit || void 0, + ySplit: t.ySplit || void 0, + topLeftCell: i, + activePane: a, + state: "frozen", + }), + e.leafNode("selection", { + pane: a, + activeCell: t.activeCell, + sqref: t.activeCell, + })); + break; + case "split": + ("topLeft" === t.activePane && (t.activePane = void 0), + e.leafNode("pane", { + xSplit: t.xSplit || void 0, + ySplit: t.ySplit || void 0, + topLeftCell: t.topLeftCell, + activePane: t.activePane, + }), + e.leafNode("selection", { + pane: t.activePane, + activeCell: t.activeCell, + sqref: t.activeCell, + })); + break; + case "normal": + t.activeCell && + e.leafNode("selection", { + activeCell: t.activeCell, + sqref: t.activeCell, + }); + } + e.closeNode(); + } + parseOpen(e) { + switch (e.name) { + case "sheetView": + return ( + (this.sheetView = { + workbookViewId: parseInt(e.attributes.workbookViewId, 10), + rightToLeft: "1" === e.attributes.rightToLeft, + tabSelected: "1" === e.attributes.tabSelected, + showRuler: !("0" === e.attributes.showRuler), + showRowColHeaders: !( + "0" === e.attributes.showRowColHeaders + ), + showGridLines: !("0" === e.attributes.showGridLines), + zoomScale: parseInt(e.attributes.zoomScale || "100", 10), + zoomScaleNormal: parseInt( + e.attributes.zoomScaleNormal || "100", + 10, + ), + style: e.attributes.view, + }), + (this.pane = void 0), + (this.selections = {}), + !0 + ); + case "pane": + return ( + (this.pane = { + xSplit: parseInt(e.attributes.xSplit || "0", 10), + ySplit: parseInt(e.attributes.ySplit || "0", 10), + topLeftCell: e.attributes.topLeftCell, + activePane: e.attributes.activePane || "topLeft", + state: e.attributes.state, + }), + !0 + ); + case "selection": { + const t = e.attributes.pane || "topLeft"; + return ( + (this.selections[t] = { + pane: t, + activeCell: e.attributes.activeCell, + }), + !0 + ); + } + default: + return !1; + } + } + parseText() {} + parseClose(e) { + let t, r; + switch (e) { + case "sheetView": + return ( + this.sheetView && this.pane + ? ((t = this.model = + { + workbookViewId: this.sheetView.workbookViewId, + rightToLeft: this.sheetView.rightToLeft, + state: s[this.pane.state] || "split", + xSplit: this.pane.xSplit, + ySplit: this.pane.ySplit, + topLeftCell: this.pane.topLeftCell, + showRuler: this.sheetView.showRuler, + showRowColHeaders: this.sheetView.showRowColHeaders, + showGridLines: this.sheetView.showGridLines, + zoomScale: this.sheetView.zoomScale, + zoomScaleNormal: this.sheetView.zoomScaleNormal, + }), + "split" === this.model.state && + (t.activePane = this.pane.activePane), + (r = this.selections[this.pane.activePane]), + r && r.activeCell && (t.activeCell = r.activeCell), + this.sheetView.style && + (t.style = this.sheetView.style)) + : ((t = this.model = + { + workbookViewId: this.sheetView.workbookViewId, + rightToLeft: this.sheetView.rightToLeft, + state: "normal", + showRuler: this.sheetView.showRuler, + showRowColHeaders: this.sheetView.showRowColHeaders, + showGridLines: this.sheetView.showGridLines, + zoomScale: this.sheetView.zoomScale, + zoomScaleNormal: this.sheetView.zoomScaleNormal, + }), + (r = this.selections.topLeft), + r && r.activeCell && (t.activeCell = r.activeCell), + this.sheetView.style && + (t.style = this.sheetView.style)), + !1 + ); + default: + return !0; + } + } + reconcile() {} + }; + }, + { "../../../utils/col-cache": 19, "../base-xform": 32 }, + ], + 114: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "tablePart"; + } + render(e, t) { + t && e.leafNode(this.tag, { "r:id": t.rId }); + } + parseOpen(e) { + switch (e.name) { + case this.tag: + return ((this.model = { rId: e.attributes["r:id"] }), !0); + default: + return !1; + } + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 115: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/under-dash"), + i = e("../../../utils/col-cache"), + s = e("../../../utils/xml-stream"), + o = e("../../rel-type"), + a = e("./merges"), + l = e("../base-xform"), + c = e("../list-xform"), + u = e("./row-xform"), + h = e("./col-xform"), + f = e("./dimension-xform"), + d = e("./hyperlink-xform"), + p = e("./merge-cell-xform"), + m = e("./data-validations-xform"), + b = e("./sheet-properties-xform"), + g = e("./sheet-format-properties-xform"), + y = e("./sheet-view-xform"), + v = e("./sheet-protection-xform"), + w = e("./page-margins-xform"), + _ = e("./page-setup-xform"), + x = e("./print-options-xform"), + k = e("./auto-filter-xform"), + S = e("./picture-xform"), + M = e("./drawing-xform"), + C = e("./table-part-xform"), + T = e("./row-breaks-xform"), + E = e("./header-footer-xform"), + A = e("./cf/conditional-formattings-xform"), + R = e("./ext-lst-xform"), + O = (e, t) => { + if (!t || !t.length) return e; + if (!e || !e.length) return t; + const r = {}, + n = {}; + return ( + e.forEach((e) => { + ((r[e.ref] = e), + e.rules.forEach((e) => { + const { x14Id: t } = e; + t && (n[t] = e); + })); + }), + t.forEach((t) => { + t.rules.forEach((i) => { + const s = n[i.x14Id]; + s + ? ((e, t) => { + Object.keys(t).forEach((r) => { + const n = e[r], + i = t[r]; + void 0 === n && void 0 !== i && (e[r] = i); + }); + })(s, i) + : r[t.ref] + ? r[t.ref].rules.push(i) + : e.push({ ref: t.ref, rules: [i] }); + }); + }), + e + ); + }; + class j extends l { + constructor(e) { + super(); + const { maxRows: t, maxCols: r, ignoreNodes: n } = e || {}; + ((this.ignoreNodes = n || []), + (this.map = { + sheetPr: new b(), + dimension: new f(), + sheetViews: new c({ + tag: "sheetViews", + count: !1, + childXform: new y(), + }), + sheetFormatPr: new g(), + cols: new c({ tag: "cols", count: !1, childXform: new h() }), + sheetData: new c({ + tag: "sheetData", + count: !1, + empty: !0, + childXform: new u({ maxItems: r }), + maxItems: t, + }), + autoFilter: new k(), + mergeCells: new c({ + tag: "mergeCells", + count: !0, + childXform: new p(), + }), + rowBreaks: new T(), + hyperlinks: new c({ + tag: "hyperlinks", + count: !1, + childXform: new d(), + }), + pageMargins: new w(), + dataValidations: new m(), + pageSetup: new _(), + headerFooter: new E(), + printOptions: new x(), + picture: new S(), + drawing: new M(), + sheetProtection: new v(), + tableParts: new c({ + tag: "tableParts", + count: !0, + childXform: new C(), + }), + conditionalFormatting: new A(), + extLst: new R(), + })); + } + prepare(e, t) { + ((t.merges = new a()), + (e.hyperlinks = t.hyperlinks = []), + (e.comments = t.comments = []), + (t.formulae = {}), + (t.siFormulae = 0), + this.map.cols.prepare(e.cols, t), + this.map.sheetData.prepare(e.rows, t), + this.map.conditionalFormatting.prepare( + e.conditionalFormattings, + t, + ), + (e.mergeCells = t.merges.mergeCells)); + const r = (e.rels = []); + function n(e) { + return "rId" + (e.length + 1); + } + if ( + (e.hyperlinks.forEach((e) => { + const t = n(r); + ((e.rId = t), + r.push({ + Id: t, + Type: o.Hyperlink, + Target: e.target, + TargetMode: "External", + })); + }), + e.comments.length > 0) + ) { + const s = { + Id: n(r), + Type: o.Comments, + Target: `../comments${e.id}.xml`, + }; + r.push(s); + const a = { + Id: n(r), + Type: o.VmlDrawing, + Target: `../drawings/vmlDrawing${e.id}.vml`, + }; + (r.push(a), + e.comments.forEach((e) => { + e.refAddress = i.decodeAddress(e.ref); + }), + t.commentRefs.push({ + commentName: "comments" + e.id, + vmlDrawing: "vmlDrawing" + e.id, + })); + } + const s = []; + let l; + (e.media.forEach((i) => { + if ("background" === i.type) { + const s = n(r); + ((l = t.media[i.imageId]), + r.push({ + Id: s, + Type: o.Image, + Target: `../media/${l.name}.${l.extension}`, + }), + (e.background = { rId: s }), + (e.image = t.media[i.imageId])); + } else if ("image" === i.type) { + let { drawing: a } = e; + ((l = t.media[i.imageId]), + a || + ((a = e.drawing = + { + rId: n(r), + name: "drawing" + ++t.drawingsCount, + anchors: [], + rels: [], + }), + t.drawings.push(a), + r.push({ + Id: a.rId, + Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/drawing", + Target: `../drawings/${a.name}.xml`, + }))); + let c = + this.preImageId === i.imageId + ? s[i.imageId] + : s[a.rels.length]; + c || + ((c = n(a.rels)), + (s[a.rels.length] = c), + a.rels.push({ + Id: c, + Type: "http://schemas.openxmlformats.org/officeDocument/2006/relationships/image", + Target: `../media/${l.name}.${l.extension}`, + })); + const u = { picture: { rId: c }, range: i.range }; + if (i.hyperlinks && i.hyperlinks.hyperlink) { + const e = n(a.rels); + ((s[a.rels.length] = e), + (u.picture.hyperlinks = { + tooltip: i.hyperlinks.tooltip, + rId: e, + }), + a.rels.push({ + Id: e, + Type: o.Hyperlink, + Target: i.hyperlinks.hyperlink, + TargetMode: "External", + })); + } + ((this.preImageId = i.imageId), a.anchors.push(u)); + } + }), + e.tables.forEach((e) => { + const i = n(r); + ((e.rId = i), + r.push({ + Id: i, + Type: o.Table, + Target: "../tables/" + e.target, + }), + e.columns.forEach((e) => { + const { style: r } = e; + r && (e.dxfId = t.styles.addDxfStyle(r)); + })); + }), + this.map.extLst.prepare(e, t)); + } + render(e, t) { + (e.openXml(s.StdDocAttributes), + e.openNode("worksheet", j.WORKSHEET_ATTRIBUTES)); + const r = t.properties + ? { + defaultRowHeight: t.properties.defaultRowHeight, + dyDescent: t.properties.dyDescent, + outlineLevelCol: t.properties.outlineLevelCol, + outlineLevelRow: t.properties.outlineLevelRow, + } + : void 0; + t.properties && + t.properties.defaultColWidth && + (r.defaultColWidth = t.properties.defaultColWidth); + const n = { + outlineProperties: + t.properties && t.properties.outlineProperties, + tabColor: t.properties && t.properties.tabColor, + pageSetup: + t.pageSetup && t.pageSetup.fitToPage + ? { fitToPage: t.pageSetup.fitToPage } + : void 0, + }, + i = t.pageSetup && t.pageSetup.margins, + a = { + showRowColHeaders: + t.pageSetup && t.pageSetup.showRowColHeaders, + showGridLines: t.pageSetup && t.pageSetup.showGridLines, + horizontalCentered: + t.pageSetup && t.pageSetup.horizontalCentered, + verticalCentered: t.pageSetup && t.pageSetup.verticalCentered, + }, + l = t.sheetProtection; + (this.map.sheetPr.render(e, n), + this.map.dimension.render(e, t.dimensions), + this.map.sheetViews.render(e, t.views), + this.map.sheetFormatPr.render(e, r), + this.map.cols.render(e, t.cols), + this.map.sheetData.render(e, t.rows), + this.map.sheetProtection.render(e, l), + this.map.autoFilter.render(e, t.autoFilter), + this.map.mergeCells.render(e, t.mergeCells), + this.map.conditionalFormatting.render( + e, + t.conditionalFormattings, + ), + this.map.dataValidations.render(e, t.dataValidations), + this.map.hyperlinks.render(e, t.hyperlinks), + this.map.printOptions.render(e, a), + this.map.pageMargins.render(e, i), + this.map.pageSetup.render(e, t.pageSetup), + this.map.headerFooter.render(e, t.headerFooter), + this.map.rowBreaks.render(e, t.rowBreaks), + this.map.drawing.render(e, t.drawing), + this.map.picture.render(e, t.background), + this.map.tableParts.render(e, t.tables), + this.map.extLst.render(e, t), + t.rels && + t.rels.forEach((t) => { + t.Type === o.VmlDrawing && + e.leafNode("legacyDrawing", { "r:id": t.Id }); + }), + e.closeNode()); + } + parseOpen(e) { + return this.parser + ? (this.parser.parseOpen(e), !0) + : "worksheet" === e.name + ? (n.each(this.map, (e) => { + e.reset(); + }), + !0) + : (this.map[e.name] && + !this.ignoreNodes.includes(e.name) && + ((this.parser = this.map[e.name]), + this.parser.parseOpen(e)), + !0); + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case "worksheet": { + const e = this.map.sheetFormatPr.model || {}; + (this.map.sheetPr.model && + this.map.sheetPr.model.tabColor && + (e.tabColor = this.map.sheetPr.model.tabColor), + this.map.sheetPr.model && + this.map.sheetPr.model.outlineProperties && + (e.outlineProperties = + this.map.sheetPr.model.outlineProperties)); + const t = { + fitToPage: + (this.map.sheetPr.model && + this.map.sheetPr.model.pageSetup && + this.map.sheetPr.model.pageSetup.fitToPage) || + !1, + margins: this.map.pageMargins.model, + }, + r = Object.assign( + t, + this.map.pageSetup.model, + this.map.printOptions.model, + ), + n = O( + this.map.conditionalFormatting.model, + this.map.extLst.model && + this.map.extLst.model["x14:conditionalFormattings"], + ); + return ( + (this.model = { + dimensions: this.map.dimension.model, + cols: this.map.cols.model, + rows: this.map.sheetData.model, + mergeCells: this.map.mergeCells.model, + hyperlinks: this.map.hyperlinks.model, + dataValidations: this.map.dataValidations.model, + properties: e, + views: this.map.sheetViews.model, + pageSetup: r, + headerFooter: this.map.headerFooter.model, + background: this.map.picture.model, + drawing: this.map.drawing.model, + tables: this.map.tableParts.model, + conditionalFormattings: n, + }), + this.map.autoFilter.model && + (this.model.autoFilter = this.map.autoFilter.model), + this.map.sheetProtection.model && + (this.model.sheetProtection = + this.map.sheetProtection.model), + !1 + ); + } + default: + return !0; + } + } + reconcile(e, t) { + const r = (e.relationships || []).reduce((r, n) => { + if ( + ((r[n.Id] = n), + n.Type === o.Comments && + (e.comments = t.comments[n.Target].comments), + n.Type === o.VmlDrawing && e.comments && e.comments.length) + ) { + const r = t.vmlDrawings[n.Target].comments; + e.comments.forEach((e, t) => { + e.note = Object.assign({}, e.note, r[t]); + }); + } + return r; + }, {}); + if ( + ((t.commentsMap = (e.comments || []).reduce( + (e, t) => (t.ref && (e[t.ref] = t), e), + {}, + )), + (t.hyperlinkMap = (e.hyperlinks || []).reduce( + (e, t) => (t.rId && (e[t.address] = r[t.rId].Target), e), + {}, + )), + (t.formulae = {}), + (e.rows = (e.rows && e.rows.filter(Boolean)) || []), + e.rows.forEach((e) => { + e.cells = (e.cells && e.cells.filter(Boolean)) || []; + }), + this.map.cols.reconcile(e.cols, t), + this.map.sheetData.reconcile(e.rows, t), + this.map.conditionalFormatting.reconcile( + e.conditionalFormattings, + t, + ), + (e.media = []), + e.drawing) + ) { + const n = r[e.drawing.rId].Target.match( + /\/drawings\/([a-zA-Z0-9]+)[.][a-zA-Z]{3,4}$/, + ); + if (n) { + const r = n[1]; + t.drawings[r].anchors.forEach((t) => { + if (t.medium) { + const r = { + type: "image", + imageId: t.medium.index, + range: t.range, + hyperlinks: t.picture.hyperlinks, + }; + e.media.push(r); + } + }); + } + } + const n = e.background && r[e.background.rId]; + if (n) { + const r = n.Target.split("/media/")[1], + i = t.mediaIndex && t.mediaIndex[r]; + void 0 !== i && + e.media.push({ type: "background", imageId: i }); + } + ((e.tables = (e.tables || []).map((e) => { + const n = r[e.rId]; + return t.tables[n.Target]; + })), + delete e.relationships, + delete e.hyperlinks, + delete e.comments); + } + } + ((j.WORKSHEET_ATTRIBUTES = { + xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main", + "xmlns:r": + "http://schemas.openxmlformats.org/officeDocument/2006/relationships", + "xmlns:mc": + "http://schemas.openxmlformats.org/markup-compatibility/2006", + "mc:Ignorable": "x14ac", + "xmlns:x14ac": + "http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac", + }), + (t.exports = j)); + }, + { + "../../../utils/col-cache": 19, + "../../../utils/under-dash": 26, + "../../../utils/xml-stream": 28, + "../../rel-type": 31, + "../base-xform": 32, + "../list-xform": 71, + "./auto-filter-xform": 72, + "./cf/conditional-formattings-xform": 87, + "./col-xform": 92, + "./data-validations-xform": 93, + "./dimension-xform": 94, + "./drawing-xform": 95, + "./ext-lst-xform": 96, + "./header-footer-xform": 97, + "./hyperlink-xform": 98, + "./merge-cell-xform": 99, + "./merges": 100, + "./page-margins-xform": 103, + "./page-setup-xform": 105, + "./picture-xform": 106, + "./print-options-xform": 107, + "./row-breaks-xform": 108, + "./row-xform": 109, + "./sheet-format-properties-xform": 110, + "./sheet-properties-xform": 111, + "./sheet-protection-xform": 112, + "./sheet-view-xform": 113, + "./table-part-xform": 114, + }, + ], + 116: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + constructor(e) { + (super(), (this.tag = e.tag), (this.attr = e.attr)); + } + render(e, t) { + t && (e.openNode(this.tag), e.closeNode()); + } + parseOpen(e) { + e.name === this.tag && (this.model = !0); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 117: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + constructor(e) { + (super(), + (this.tag = e.tag), + (this.attr = e.attr), + (this.attrs = e.attrs), + (this._format = + e.format || + function (e) { + try { + return Number.isNaN(e.getTime()) ? "" : e.toISOString(); + } catch (e) { + return ""; + } + }), + (this._parse = + e.parse || + function (e) { + return new Date(e); + })); + } + render(e, t) { + t && + (e.openNode(this.tag), + this.attrs && e.addAttributes(this.attrs), + this.attr + ? e.addAttribute(this.attr, this._format(t)) + : e.writeText(this._format(t)), + e.closeNode()); + } + parseOpen(e) { + e.name === this.tag && + (this.attr + ? (this.model = this._parse(e.attributes[this.attr])) + : (this.text = [])); + } + parseText(e) { + this.attr || this.text.push(e); + } + parseClose() { + return ( + this.attr || (this.model = this._parse(this.text.join(""))), + !1 + ); + } + }; + }, + { "../base-xform": 32 }, + ], + 118: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + constructor(e) { + (super(), + (this.tag = e.tag), + (this.attr = e.attr), + (this.attrs = e.attrs), + (this.zero = e.zero)); + } + render(e, t) { + (t || this.zero) && + (e.openNode(this.tag), + this.attrs && e.addAttributes(this.attrs), + this.attr ? e.addAttribute(this.attr, t) : e.writeText(t), + e.closeNode()); + } + parseOpen(e) { + return ( + e.name === this.tag && + (this.attr + ? (this.model = parseInt(e.attributes[this.attr], 10)) + : (this.text = []), + !0) + ); + } + parseText(e) { + this.attr || this.text.push(e); + } + parseClose() { + return ( + this.attr || + (this.model = parseInt(this.text.join("") || 0, 10)), + !1 + ); + } + }; + }, + { "../base-xform": 32 }, + ], + 119: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + constructor(e) { + (super(), + (this.tag = e.tag), + (this.attr = e.attr), + (this.attrs = e.attrs)); + } + render(e, t) { + void 0 !== t && + (e.openNode(this.tag), + this.attrs && e.addAttributes(this.attrs), + this.attr ? e.addAttribute(this.attr, t) : e.writeText(t), + e.closeNode()); + } + parseOpen(e) { + e.name === this.tag && + (this.attr + ? (this.model = e.attributes[this.attr]) + : (this.text = [])); + } + parseText(e) { + this.attr || this.text.push(e); + } + parseClose() { + return (this.attr || (this.model = this.text.join("")), !1); + } + }; + }, + { "../base-xform": 32 }, + ], + 120: [ + function (e, t, r) { + "use strict"; + const n = e("./base-xform"), + i = e("../../utils/xml-stream"); + t.exports = class extends n { + constructor(e) { + (super(), (this._model = e)); + } + render(e) { + if (!this._xml) { + const e = new i(); + (!(function e(t, r) { + (t.openNode(r.tag, r.$), + r.c && + r.c.forEach((r) => { + e(t, r); + }), + r.t && t.writeText(r.t), + t.closeNode()); + })(e, this._model), + (this._xml = e.xml)); + } + e.writeXml(this._xml); + } + parseOpen() { + return !0; + } + parseText() {} + parseClose(e) { + switch (e) { + case this._model.tag: + return !1; + default: + return !0; + } + } + }; + }, + { "../../utils/xml-stream": 28, "./base-xform": 32 }, + ], + 121: [ + function (e, t, r) { + "use strict"; + const n = e("./text-xform"), + i = e("./rich-text-xform"), + s = e("../base-xform"); + t.exports = class extends s { + constructor() { + (super(), (this.map = { r: new i(), t: new n() })); + } + get tag() { + return "rPh"; + } + render(e, t) { + if ( + (e.openNode(this.tag, { sb: t.sb || 0, eb: t.eb || 0 }), + t && t.hasOwnProperty("richText") && t.richText) + ) { + const { r: r } = this.map; + t.richText.forEach((t) => { + r.render(e, t); + }); + } else t && this.map.t.render(e, t.text); + e.closeNode(); + } + parseOpen(e) { + const { name: t } = e; + return this.parser + ? (this.parser.parseOpen(e), !0) + : t === this.tag + ? ((this.model = { + sb: parseInt(e.attributes.sb, 10), + eb: parseInt(e.attributes.eb, 10), + }), + !0) + : ((this.parser = this.map[t]), + !!this.parser && (this.parser.parseOpen(e), !0)); + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) { + if (!this.parser.parseClose(e)) { + switch (e) { + case "r": { + let e = this.model.richText; + (e || (e = this.model.richText = []), + e.push(this.parser.model)); + break; + } + case "t": + this.model.text = this.parser.model; + } + this.parser = void 0; + } + return !0; + } + switch (e) { + case this.tag: + return !1; + default: + return !0; + } + } + }; + }, + { "../base-xform": 32, "./rich-text-xform": 122, "./text-xform": 125 }, + ], + 122: [ + function (e, t, r) { + "use strict"; + const n = e("./text-xform"), + i = e("../style/font-xform"), + s = e("../base-xform"); + class o extends s { + constructor(e) { + (super(), (this.model = e)); + } + get tag() { + return "r"; + } + get textXform() { + return this._textXform || (this._textXform = new n()); + } + get fontXform() { + return ( + this._fontXform || (this._fontXform = new i(o.FONT_OPTIONS)) + ); + } + render(e, t) { + ((t = t || this.model), + e.openNode("r"), + t.font && this.fontXform.render(e, t.font), + this.textXform.render(e, t.text), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "r": + return ((this.model = {}), !0); + case "t": + return ( + (this.parser = this.textXform), + this.parser.parseOpen(e), + !0 + ); + case "rPr": + return ( + (this.parser = this.fontXform), + this.parser.parseOpen(e), + !0 + ); + default: + return !1; + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + switch (e) { + case "r": + return !1; + case "t": + return ( + (this.model.text = this.parser.model), + (this.parser = void 0), + !0 + ); + case "rPr": + return ( + (this.model.font = this.parser.model), + (this.parser = void 0), + !0 + ); + default: + return (this.parser && this.parser.parseClose(e), !0); + } + } + } + ((o.FONT_OPTIONS = { tagName: "rPr", fontNameTag: "rFont" }), + (t.exports = o)); + }, + { + "../base-xform": 32, + "../style/font-xform": 131, + "./text-xform": 125, + }, + ], + 123: [ + function (e, t, r) { + "use strict"; + const n = e("./text-xform"), + i = e("./rich-text-xform"), + s = e("./phonetic-text-xform"), + o = e("../base-xform"); + t.exports = class extends o { + constructor(e) { + (super(), + (this.model = e), + (this.map = { r: new i(), t: new n(), rPh: new s() })); + } + get tag() { + return "si"; + } + render(e, t) { + (e.openNode(this.tag), + t && t.hasOwnProperty("richText") && t.richText + ? t.richText.length + ? t.richText.forEach((t) => { + this.map.r.render(e, t); + }) + : this.map.t.render(e, "") + : null != t && this.map.t.render(e, t), + e.closeNode()); + } + parseOpen(e) { + const { name: t } = e; + return this.parser + ? (this.parser.parseOpen(e), !0) + : t === this.tag + ? ((this.model = {}), !0) + : ((this.parser = this.map[t]), + !!this.parser && (this.parser.parseOpen(e), !0)); + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) { + if (!this.parser.parseClose(e)) { + switch (e) { + case "r": { + let e = this.model.richText; + (e || (e = this.model.richText = []), + e.push(this.parser.model)); + break; + } + case "t": + this.model = this.parser.model; + } + this.parser = void 0; + } + return !0; + } + switch (e) { + case this.tag: + return !1; + default: + return !0; + } + } + }; + }, + { + "../base-xform": 32, + "./phonetic-text-xform": 121, + "./rich-text-xform": 122, + "./text-xform": 125, + }, + ], + 124: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/xml-stream"), + i = e("../base-xform"), + s = e("./shared-string-xform"); + t.exports = class extends i { + constructor(e) { + (super(), + (this.model = e || { values: [], count: 0 }), + (this.hash = Object.create(null)), + (this.rich = Object.create(null))); + } + get sharedStringXform() { + return ( + this._sharedStringXform || (this._sharedStringXform = new s()) + ); + } + get values() { + return this.model.values; + } + get uniqueCount() { + return this.model.values.length; + } + get count() { + return this.model.count; + } + getString(e) { + return this.model.values[e]; + } + add(e) { + return e.richText ? this.addRichText(e) : this.addText(e); + } + addText(e) { + let t = this.hash[e]; + return ( + void 0 === t && + ((t = this.hash[e] = this.model.values.length), + this.model.values.push(e)), + this.model.count++, + t + ); + } + addRichText(e) { + const t = this.sharedStringXform.toXml(e); + let r = this.rich[t]; + return ( + void 0 === r && + ((r = this.rich[t] = this.model.values.length), + this.model.values.push(e)), + this.model.count++, + r + ); + } + render(e, t) { + ((t = t || this._values), + e.openXml(n.StdDocAttributes), + e.openNode("sst", { + xmlns: + "http://schemas.openxmlformats.org/spreadsheetml/2006/main", + count: t.count, + uniqueCount: t.values.length, + })); + const r = this.sharedStringXform; + (t.values.forEach((t) => { + r.render(e, t); + }), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "sst": + return !0; + case "si": + return ( + (this.parser = this.sharedStringXform), + this.parser.parseOpen(e), + !0 + ); + default: + throw new Error( + "Unexpected xml node in parseOpen: " + JSON.stringify(e), + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || + (this.model.values.push(this.parser.model), + this.model.count++, + (this.parser = void 0)), + !0 + ); + switch (e) { + case "sst": + return !1; + default: + throw new Error("Unexpected xml node in parseClose: " + e); + } + } + }; + }, + { + "../../../utils/xml-stream": 28, + "../base-xform": 32, + "./shared-string-xform": 123, + }, + ], + 125: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "t"; + } + render(e, t) { + (e.openNode("t"), + /^\s|\n|\s$/.test(t) && e.addAttribute("xml:space", "preserve"), + e.writeText(t), + e.closeNode()); + } + get model() { + return this._text + .join("") + .replace(/_x([0-9A-F]{4})_/g, (e, t) => + String.fromCharCode(parseInt(t, 16)), + ); + } + parseOpen(e) { + switch (e.name) { + case "t": + return ((this._text = []), !0); + default: + return !1; + } + } + parseText(e) { + this._text.push(e); + } + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 126: [ + function (e, t, r) { + "use strict"; + const n = e("../../../doc/enums"), + i = e("../../../utils/utils"), + s = e("../base-xform"), + o = { + horizontalValues: [ + "left", + "center", + "right", + "fill", + "centerContinuous", + "distributed", + "justify", + ].reduce((e, t) => ((e[t] = !0), e), {}), + horizontal(e) { + return this.horizontalValues[e] ? e : void 0; + }, + verticalValues: [ + "top", + "middle", + "bottom", + "distributed", + "justify", + ].reduce((e, t) => ((e[t] = !0), e), {}), + vertical(e) { + return "middle" === e + ? "center" + : this.verticalValues[e] + ? e + : void 0; + }, + wrapText: (e) => !!e || void 0, + shrinkToFit: (e) => !!e || void 0, + textRotation(e) { + switch (e) { + case "vertical": + return e; + default: + return (e = i.validInt(e)) >= -90 && e <= 90 ? e : void 0; + } + }, + indent: (e) => ((e = i.validInt(e)), Math.max(0, e)), + readingOrder(e) { + switch (e) { + case "ltr": + return n.ReadingOrder.LeftToRight; + case "rtl": + return n.ReadingOrder.RightToLeft; + default: + return; + } + }, + }, + a = { + toXml(e) { + if ((e = o.textRotation(e))) { + if ("vertical" === e) return 255; + const t = Math.round(e); + if (t >= 0 && t <= 90) return t; + if (t < 0 && t >= -90) return 90 - t; + } + }, + toModel(e) { + const t = i.validInt(e); + if (void 0 !== t) { + if (255 === t) return "vertical"; + if (t >= 0 && t <= 90) return t; + if (t > 90 && t <= 180) return 90 - t; + } + }, + }; + t.exports = class extends s { + get tag() { + return "alignment"; + } + render(e, t) { + (e.addRollback(), e.openNode("alignment")); + let r = !1; + function n(t, n) { + n && (e.addAttribute(t, n), (r = !0)); + } + (n("horizontal", o.horizontal(t.horizontal)), + n("vertical", o.vertical(t.vertical)), + n("wrapText", !!o.wrapText(t.wrapText) && "1"), + n("shrinkToFit", !!o.shrinkToFit(t.shrinkToFit) && "1"), + n("indent", o.indent(t.indent)), + n("textRotation", a.toXml(t.textRotation)), + n("readingOrder", o.readingOrder(t.readingOrder)), + e.closeNode(), + r ? e.commit() : e.rollback()); + } + parseOpen(e) { + const t = {}; + let r = !1; + function n(e, n, i) { + e && ((t[n] = i), (r = !0)); + } + (n( + e.attributes.horizontal, + "horizontal", + e.attributes.horizontal, + ), + n( + e.attributes.vertical, + "vertical", + "center" === e.attributes.vertical + ? "middle" + : e.attributes.vertical, + ), + n( + e.attributes.wrapText, + "wrapText", + i.parseBoolean(e.attributes.wrapText), + ), + n( + e.attributes.shrinkToFit, + "shrinkToFit", + i.parseBoolean(e.attributes.shrinkToFit), + ), + n( + e.attributes.indent, + "indent", + parseInt(e.attributes.indent, 10), + ), + n( + e.attributes.textRotation, + "textRotation", + a.toModel(e.attributes.textRotation), + ), + n( + e.attributes.readingOrder, + "readingOrder", + "2" === e.attributes.readingOrder ? "rtl" : "ltr", + ), + (this.model = r ? t : null)); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { + "../../../doc/enums": 7, + "../../../utils/utils": 27, + "../base-xform": 32, + }, + ], + 127: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("../../../utils/utils"), + s = e("./color-xform"); + class o extends n { + constructor(e) { + (super(), (this.name = e), (this.map = { color: new s() })); + } + get tag() { + return this.name; + } + render(e, t, r) { + const n = (t && t.color) || r || this.defaultColor; + (e.openNode(this.name), + t && + t.style && + (e.addAttribute("style", t.style), + n && this.map.color.render(e, n)), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.name: { + const { style: t } = e.attributes; + return ((this.model = t ? { style: t } : void 0), !0); + } + case "color": + return ( + (this.parser = this.map.color), + this.parser.parseOpen(e), + !0 + ); + default: + return !1; + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + return this.parser + ? (this.parser.parseClose(e) || (this.parser = void 0), !0) + : (e === this.name && + this.map.color.model && + (this.model || (this.model = {}), + (this.model.color = this.map.color.model)), + !1); + } + validStyle(e) { + return o.validStyleValues[e]; + } + } + o.validStyleValues = [ + "thin", + "dashed", + "dotted", + "dashDot", + "hair", + "dashDotDot", + "slantDashDot", + "mediumDashed", + "mediumDashDotDot", + "mediumDashDot", + "medium", + "double", + "thick", + ].reduce((e, t) => ((e[t] = !0), e), {}); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + top: new o("top"), + left: new o("left"), + bottom: new o("bottom"), + right: new o("right"), + diagonal: new o("diagonal"), + })); + } + render(e, t) { + const { color: r } = t; + function n(n, i) { + (n && !n.color && t.color && (n = { ...n, color: t.color }), + i.render(e, n, r)); + } + (e.openNode("border"), + t.diagonal && + t.diagonal.style && + (t.diagonal.up && e.addAttribute("diagonalUp", "1"), + t.diagonal.down && e.addAttribute("diagonalDown", "1")), + n(t.left, this.map.left), + n(t.right, this.map.right), + n(t.top, this.map.top), + n(t.bottom, this.map.bottom), + n(t.diagonal, this.map.diagonal), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "border": + return ( + this.reset(), + (this.diagonalUp = i.parseBoolean(e.attributes.diagonalUp)), + (this.diagonalDown = i.parseBoolean( + e.attributes.diagonalDown, + )), + !0 + ); + default: + return ( + (this.parser = this.map[e.name]), + !!this.parser && (this.parser.parseOpen(e), !0) + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + if ("border" === e) { + const e = (this.model = {}), + t = function (t, r, n) { + r && (n && Object.assign(r, n), (e[t] = r)); + }; + (t("left", this.map.left.model), + t("right", this.map.right.model), + t("top", this.map.top.model), + t("bottom", this.map.bottom.model), + t("diagonal", this.map.diagonal.model, { + up: this.diagonalUp, + down: this.diagonalDown, + })); + } + return !1; + } + }; + }, + { + "../../../utils/utils": 27, + "../base-xform": 32, + "./color-xform": 128, + }, + ], + 128: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + constructor(e) { + (super(), (this.name = e || "color")); + } + get tag() { + return this.name; + } + render(e, t) { + return ( + !!t && + (e.openNode(this.name), + t.argb + ? e.addAttribute("rgb", t.argb) + : void 0 !== t.theme + ? (e.addAttribute("theme", t.theme), + void 0 !== t.tint && e.addAttribute("tint", t.tint)) + : void 0 !== t.indexed + ? e.addAttribute("indexed", t.indexed) + : e.addAttribute("auto", "1"), + e.closeNode(), + !0) + ); + } + parseOpen(e) { + return ( + e.name === this.name && + (e.attributes.rgb + ? (this.model = { argb: e.attributes.rgb }) + : e.attributes.theme + ? ((this.model = { + theme: parseInt(e.attributes.theme, 10), + }), + e.attributes.tint && + (this.model.tint = parseFloat(e.attributes.tint))) + : e.attributes.indexed + ? (this.model = { + indexed: parseInt(e.attributes.indexed, 10), + }) + : (this.model = void 0), + !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 129: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("./alignment-xform"), + s = e("./border-xform"), + o = e("./fill-xform"), + a = e("./font-xform"), + l = e("./numfmt-xform"), + c = e("./protection-xform"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + alignment: new i(), + border: new s(), + fill: new o(), + font: new a(), + numFmt: new l(), + protection: new c(), + })); + } + get tag() { + return "dxf"; + } + render(e, t) { + if ( + (e.openNode(this.tag), + t.font && this.map.font.render(e, t.font), + t.numFmt && t.numFmtId) + ) { + const r = { id: t.numFmtId, formatCode: t.numFmt }; + this.map.numFmt.render(e, r); + } + (t.fill && this.map.fill.render(e, t.fill), + t.alignment && this.map.alignment.render(e, t.alignment), + t.border && this.map.border.render(e, t.border), + t.protection && this.map.protection.render(e, t.protection), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + return (this.reset(), !0); + default: + return ( + (this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e), + !0 + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + return this.parser + ? (this.parser.parseClose(e) || (this.parser = void 0), !0) + : e !== this.tag || + ((this.model = { + alignment: this.map.alignment.model, + border: this.map.border.model, + fill: this.map.fill.model, + font: this.map.font.model, + numFmt: this.map.numFmt.model, + protection: this.map.protection.model, + }), + !1); + } + }; + }, + { + "../base-xform": 32, + "./alignment-xform": 126, + "./border-xform": 127, + "./fill-xform": 130, + "./font-xform": 131, + "./numfmt-xform": 132, + "./protection-xform": 133, + }, + ], + 130: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("./color-xform"); + class s extends n { + constructor() { + (super(), (this.map = { color: new i() })); + } + get tag() { + return "stop"; + } + render(e, t) { + (e.openNode("stop"), + e.addAttribute("position", t.position), + this.map.color.render(e, t.color), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "stop": + return ( + (this.model = { + position: parseFloat(e.attributes.position), + }), + !0 + ); + case "color": + return ( + (this.parser = this.map.color), + this.parser.parseOpen(e), + !0 + ); + default: + return !1; + } + } + parseText() {} + parseClose(e) { + return ( + !!this.parser && + (this.parser.parseClose(e) || + ((this.model.color = this.parser.model), + (this.parser = void 0)), + !0) + ); + } + } + class o extends n { + constructor() { + (super(), + (this.map = { + fgColor: new i("fgColor"), + bgColor: new i("bgColor"), + })); + } + get name() { + return "pattern"; + } + get tag() { + return "patternFill"; + } + render(e, t) { + (e.openNode("patternFill"), + e.addAttribute("patternType", t.pattern), + t.fgColor && this.map.fgColor.render(e, t.fgColor), + t.bgColor && this.map.bgColor.render(e, t.bgColor), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "patternFill": + return ( + (this.model = { + type: "pattern", + pattern: e.attributes.patternType, + }), + !0 + ); + default: + return ( + (this.parser = this.map[e.name]), + !!this.parser && (this.parser.parseOpen(e), !0) + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + return ( + !!this.parser && + (this.parser.parseClose(e) || + (this.parser.model && (this.model[e] = this.parser.model), + (this.parser = void 0)), + !0) + ); + } + } + class a extends n { + constructor() { + (super(), (this.map = { stop: new s() })); + } + get name() { + return "gradient"; + } + get tag() { + return "gradientFill"; + } + render(e, t) { + switch ((e.openNode("gradientFill"), t.gradient)) { + case "angle": + e.addAttribute("degree", t.degree); + break; + case "path": + (e.addAttribute("type", "path"), + t.center.left && + (e.addAttribute("left", t.center.left), + void 0 === t.center.right && + e.addAttribute("right", t.center.left)), + t.center.right && e.addAttribute("right", t.center.right), + t.center.top && + (e.addAttribute("top", t.center.top), + void 0 === t.center.bottom && + e.addAttribute("bottom", t.center.top)), + t.center.bottom && + e.addAttribute("bottom", t.center.bottom)); + } + const r = this.map.stop; + (t.stops.forEach((t) => { + r.render(e, t); + }), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "gradientFill": { + const t = (this.model = { stops: [] }); + return ( + e.attributes.degree + ? ((t.gradient = "angle"), + (t.degree = parseInt(e.attributes.degree, 10))) + : "path" === e.attributes.type && + ((t.gradient = "path"), + (t.center = { + left: e.attributes.left + ? parseFloat(e.attributes.left) + : 0, + top: e.attributes.top + ? parseFloat(e.attributes.top) + : 0, + }), + e.attributes.right !== e.attributes.left && + (t.center.right = e.attributes.right + ? parseFloat(e.attributes.right) + : 0), + e.attributes.bottom !== e.attributes.top && + (t.center.bottom = e.attributes.bottom + ? parseFloat(e.attributes.bottom) + : 0)), + !0 + ); + } + case "stop": + return ( + (this.parser = this.map.stop), + this.parser.parseOpen(e), + !0 + ); + default: + return !1; + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + return ( + !!this.parser && + (this.parser.parseClose(e) || + (this.model.stops.push(this.parser.model), + (this.parser = void 0)), + !0) + ); + } + } + class l extends n { + constructor() { + (super(), + (this.map = { patternFill: new o(), gradientFill: new a() })); + } + get tag() { + return "fill"; + } + render(e, t) { + switch ((e.addRollback(), e.openNode("fill"), t.type)) { + case "pattern": + this.map.patternFill.render(e, t); + break; + case "gradient": + this.map.gradientFill.render(e, t); + break; + default: + return void e.rollback(); + } + (e.closeNode(), e.commit()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "fill": + return ((this.model = {}), !0); + default: + return ( + (this.parser = this.map[e.name]), + !!this.parser && (this.parser.parseOpen(e), !0) + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + return ( + !!this.parser && + (this.parser.parseClose(e) || + ((this.model = this.parser.model), + (this.model.type = this.parser.name), + (this.parser = void 0)), + !0) + ); + } + validStyle(e) { + return l.validPatternValues[e]; + } + } + ((l.validPatternValues = [ + "none", + "solid", + "darkVertical", + "darkGray", + "mediumGray", + "lightGray", + "gray125", + "gray0625", + "darkHorizontal", + "darkVertical", + "darkDown", + "darkUp", + "darkGrid", + "darkTrellis", + "lightHorizontal", + "lightVertical", + "lightDown", + "lightUp", + "lightGrid", + "lightTrellis", + "lightGrid", + ].reduce((e, t) => ((e[t] = !0), e), {})), + (l.StopXform = s), + (l.PatternFillXform = o), + (l.GradientFillXform = a), + (t.exports = l)); + }, + { "../base-xform": 32, "./color-xform": 128 }, + ], + 131: [ + function (e, t, r) { + "use strict"; + const n = e("./color-xform"), + i = e("../simple/boolean-xform"), + s = e("../simple/integer-xform"), + o = e("../simple/string-xform"), + a = e("./underline-xform"), + l = e("../../../utils/under-dash"), + c = e("../base-xform"); + class u extends c { + constructor(e) { + (super(), + (this.options = e || u.OPTIONS), + (this.map = { + b: { prop: "bold", xform: new i({ tag: "b", attr: "val" }) }, + i: { + prop: "italic", + xform: new i({ tag: "i", attr: "val" }), + }, + u: { prop: "underline", xform: new a() }, + charset: { + prop: "charset", + xform: new s({ tag: "charset", attr: "val" }), + }, + color: { prop: "color", xform: new n() }, + condense: { + prop: "condense", + xform: new i({ tag: "condense", attr: "val" }), + }, + extend: { + prop: "extend", + xform: new i({ tag: "extend", attr: "val" }), + }, + family: { + prop: "family", + xform: new s({ tag: "family", attr: "val" }), + }, + outline: { + prop: "outline", + xform: new i({ tag: "outline", attr: "val" }), + }, + vertAlign: { + prop: "vertAlign", + xform: new o({ tag: "vertAlign", attr: "val" }), + }, + scheme: { + prop: "scheme", + xform: new o({ tag: "scheme", attr: "val" }), + }, + shadow: { + prop: "shadow", + xform: new i({ tag: "shadow", attr: "val" }), + }, + strike: { + prop: "strike", + xform: new i({ tag: "strike", attr: "val" }), + }, + sz: { + prop: "size", + xform: new s({ tag: "sz", attr: "val" }), + }, + }), + (this.map[this.options.fontNameTag] = { + prop: "name", + xform: new o({ tag: this.options.fontNameTag, attr: "val" }), + })); + } + get tag() { + return this.options.tagName; + } + render(e, t) { + const { map: r } = this; + (e.openNode(this.options.tagName), + l.each(this.map, (n, i) => { + r[i].xform.render(e, t[n.prop]); + }), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + if (this.map[e.name]) + return ( + (this.parser = this.map[e.name].xform), + this.parser.parseOpen(e) + ); + switch (e.name) { + case this.options.tagName: + return ((this.model = {}), !0); + default: + return !1; + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser && !this.parser.parseClose(e)) { + const t = this.map[e]; + return ( + this.parser.model && (this.model[t.prop] = this.parser.model), + (this.parser = void 0), + !0 + ); + } + switch (e) { + case this.options.tagName: + return !1; + default: + return !0; + } + } + } + ((u.OPTIONS = { tagName: "font", fontNameTag: "name" }), + (t.exports = u)); + }, + { + "../../../utils/under-dash": 26, + "../base-xform": 32, + "../simple/boolean-xform": 116, + "../simple/integer-xform": 118, + "../simple/string-xform": 119, + "./color-xform": 128, + "./underline-xform": 136, + }, + ], + 132: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/under-dash"), + i = e("../../defaultnumformats"), + s = e("../base-xform"); + const o = (function () { + const e = {}; + return ( + n.each(i, (t, r) => { + t.f && (e[t.f] = parseInt(r, 10)); + }), + e + ); + })(); + class a extends s { + constructor(e, t) { + (super(), (this.id = e), (this.formatCode = t)); + } + get tag() { + return "numFmt"; + } + render(e, t) { + e.leafNode("numFmt", { + numFmtId: t.id, + formatCode: t.formatCode, + }); + } + parseOpen(e) { + switch (e.name) { + case "numFmt": + return ( + (this.model = { + id: parseInt(e.attributes.numFmtId, 10), + formatCode: e.attributes.formatCode.replace( + /[\\](.)/g, + "$1", + ), + }), + !0 + ); + default: + return !1; + } + } + parseText() {} + parseClose() { + return !1; + } + } + ((a.getDefaultFmtId = function (e) { + return o[e]; + }), + (a.getDefaultFmtCode = function (e) { + return i[e] && i[e].f; + }), + (t.exports = a)); + }, + { + "../../../utils/under-dash": 26, + "../../defaultnumformats": 30, + "../base-xform": 32, + }, + ], + 133: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = { boolean: (e, t) => (void 0 === e ? t : e) }; + t.exports = class extends n { + get tag() { + return "protection"; + } + render(e, t) { + (e.addRollback(), e.openNode("protection")); + let r = !1; + function n(t, n) { + void 0 !== n && (e.addAttribute(t, n), (r = !0)); + } + (n("locked", i.boolean(t.locked, !0) ? void 0 : "0"), + n("hidden", i.boolean(t.hidden, !1) ? "1" : void 0), + e.closeNode(), + r ? e.commit() : e.rollback()); + } + parseOpen(e) { + const t = { + locked: !("0" === e.attributes.locked), + hidden: "1" === e.attributes.hidden, + }, + r = !t.locked || t.hidden; + this.model = r ? t : null; + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 134: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("./alignment-xform"), + s = e("./protection-xform"); + t.exports = class extends n { + constructor(e) { + (super(), + (this.xfId = !(!e || !e.xfId)), + (this.map = { alignment: new i(), protection: new s() })); + } + get tag() { + return "xf"; + } + render(e, t) { + (e.openNode("xf", { + numFmtId: t.numFmtId || 0, + fontId: t.fontId || 0, + fillId: t.fillId || 0, + borderId: t.borderId || 0, + }), + this.xfId && e.addAttribute("xfId", t.xfId || 0), + t.numFmtId && e.addAttribute("applyNumberFormat", "1"), + t.fontId && e.addAttribute("applyFont", "1"), + t.fillId && e.addAttribute("applyFill", "1"), + t.borderId && e.addAttribute("applyBorder", "1"), + t.alignment && e.addAttribute("applyAlignment", "1"), + t.protection && e.addAttribute("applyProtection", "1"), + t.alignment && this.map.alignment.render(e, t.alignment), + t.protection && this.map.protection.render(e, t.protection), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "xf": + return ( + (this.model = { + numFmtId: parseInt(e.attributes.numFmtId, 10), + fontId: parseInt(e.attributes.fontId, 10), + fillId: parseInt(e.attributes.fillId, 10), + borderId: parseInt(e.attributes.borderId, 10), + }), + this.xfId && + (this.model.xfId = parseInt(e.attributes.xfId, 10)), + !0 + ); + case "alignment": + return ( + (this.parser = this.map.alignment), + this.parser.parseOpen(e), + !0 + ); + case "protection": + return ( + (this.parser = this.map.protection), + this.parser.parseOpen(e), + !0 + ); + default: + return !1; + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + return this.parser + ? (this.parser.parseClose(e) || + (this.map.protection === this.parser + ? (this.model.protection = this.parser.model) + : (this.model.alignment = this.parser.model), + (this.parser = void 0)), + !0) + : "xf" !== e; + } + }; + }, + { + "../base-xform": 32, + "./alignment-xform": 126, + "./protection-xform": 133, + }, + ], + 135: [ + function (e, t, r) { + "use strict"; + const n = e("../../../doc/enums"), + i = e("../../../utils/xml-stream"), + s = e("../base-xform"), + o = e("../static-xform"), + a = e("../list-xform"), + l = e("./font-xform"), + c = e("./fill-xform"), + u = e("./border-xform"), + h = e("./numfmt-xform"), + f = e("./style-xform"), + d = e("./dxf-xform"); + class p extends s { + constructor(e) { + (super(), + (this.map = { + numFmts: new a({ + tag: "numFmts", + count: !0, + childXform: new h(), + }), + fonts: new a({ + tag: "fonts", + count: !0, + childXform: new l(), + $: { "x14ac:knownFonts": 1 }, + }), + fills: new a({ + tag: "fills", + count: !0, + childXform: new c(), + }), + borders: new a({ + tag: "borders", + count: !0, + childXform: new u(), + }), + cellStyleXfs: new a({ + tag: "cellStyleXfs", + count: !0, + childXform: new f(), + }), + cellXfs: new a({ + tag: "cellXfs", + count: !0, + childXform: new f({ xfId: !0 }), + }), + dxfs: new a({ + tag: "dxfs", + always: !0, + count: !0, + childXform: new d(), + }), + numFmt: new h(), + font: new l(), + fill: new c(), + border: new u(), + style: new f({ xfId: !0 }), + cellStyles: p.STATIC_XFORMS.cellStyles, + tableStyles: p.STATIC_XFORMS.tableStyles, + extLst: p.STATIC_XFORMS.extLst, + }), + e && this.init()); + } + initIndex() { + this.index = { + style: {}, + numFmt: {}, + numFmtNextId: 164, + font: {}, + border: {}, + fill: {}, + }; + } + init() { + ((this.model = { + styles: [], + numFmts: [], + fonts: [], + borders: [], + fills: [], + dxfs: [], + }), + this.initIndex(), + this._addBorder({}), + this._addStyle({ + numFmtId: 0, + fontId: 0, + fillId: 0, + borderId: 0, + xfId: 0, + }), + this._addFill({ type: "pattern", pattern: "none" }), + this._addFill({ type: "pattern", pattern: "gray125" }), + (this.weakMap = new WeakMap())); + } + render(e, t) { + ((t = t || this.model), + e.openXml(i.StdDocAttributes), + e.openNode("styleSheet", p.STYLESHEET_ATTRIBUTES), + this.index + ? (t.numFmts && + t.numFmts.length && + (e.openNode("numFmts", { count: t.numFmts.length }), + t.numFmts.forEach((t) => { + e.writeXml(t); + }), + e.closeNode()), + t.fonts.length || + this._addFont({ + size: 11, + color: { theme: 1 }, + name: "Calibri", + family: 2, + scheme: "minor", + }), + e.openNode("fonts", { + count: t.fonts.length, + "x14ac:knownFonts": 1, + }), + t.fonts.forEach((t) => { + e.writeXml(t); + }), + e.closeNode(), + e.openNode("fills", { count: t.fills.length }), + t.fills.forEach((t) => { + e.writeXml(t); + }), + e.closeNode(), + e.openNode("borders", { count: t.borders.length }), + t.borders.forEach((t) => { + e.writeXml(t); + }), + e.closeNode(), + this.map.cellStyleXfs.render(e, [ + { + numFmtId: 0, + fontId: 0, + fillId: 0, + borderId: 0, + xfId: 0, + }, + ]), + e.openNode("cellXfs", { count: t.styles.length }), + t.styles.forEach((t) => { + e.writeXml(t); + }), + e.closeNode()) + : (this.map.numFmts.render(e, t.numFmts), + this.map.fonts.render(e, t.fonts), + this.map.fills.render(e, t.fills), + this.map.borders.render(e, t.borders), + this.map.cellStyleXfs.render(e, [ + { + numFmtId: 0, + fontId: 0, + fillId: 0, + borderId: 0, + xfId: 0, + }, + ]), + this.map.cellXfs.render(e, t.styles)), + p.STATIC_XFORMS.cellStyles.render(e), + this.map.dxfs.render(e, t.dxfs), + p.STATIC_XFORMS.tableStyles.render(e), + p.STATIC_XFORMS.extLst.render(e), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case "styleSheet": + return (this.initIndex(), !0); + default: + return ( + (this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e), + !0 + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case "styleSheet": { + this.model = {}; + const e = (e, t) => { + t.model && t.model.length && (this.model[e] = t.model); + }; + if ( + (e("numFmts", this.map.numFmts), + e("fonts", this.map.fonts), + e("fills", this.map.fills), + e("borders", this.map.borders), + e("styles", this.map.cellXfs), + e("dxfs", this.map.dxfs), + (this.index = { model: [], numFmt: [] }), + this.model.numFmts) + ) { + const e = this.index.numFmt; + this.model.numFmts.forEach((t) => { + e[t.id] = t.formatCode; + }); + } + return !1; + } + default: + return !0; + } + } + addStyleModel(e, t) { + if (!e) return 0; + if ( + (this.model.fonts.length || + this._addFont({ + size: 11, + color: { theme: 1 }, + name: "Calibri", + family: 2, + scheme: "minor", + }), + this.weakMap && this.weakMap.has(e)) + ) + return this.weakMap.get(e); + const r = {}; + if (((t = t || n.ValueType.Number), e.numFmt)) + r.numFmtId = this._addNumFmtStr(e.numFmt); + else + switch (t) { + case n.ValueType.Number: + r.numFmtId = this._addNumFmtStr("General"); + break; + case n.ValueType.Date: + r.numFmtId = this._addNumFmtStr("mm-dd-yy"); + } + (e.font && (r.fontId = this._addFont(e.font)), + e.border && (r.borderId = this._addBorder(e.border)), + e.fill && (r.fillId = this._addFill(e.fill)), + e.alignment && (r.alignment = e.alignment), + e.protection && (r.protection = e.protection)); + const i = this._addStyle(r); + return (this.weakMap && this.weakMap.set(e, i), i); + } + getStyleModel(e) { + const t = this.model.styles[e]; + if (!t) return null; + let r = this.index.model[e]; + if (r) return r; + if (((r = this.index.model[e] = {}), t.numFmtId)) { + const e = + this.index.numFmt[t.numFmtId] || + h.getDefaultFmtCode(t.numFmtId); + e && (r.numFmt = e); + } + function n(e, t, n) { + if (n || 0 === n) { + const i = t[n]; + i && (r[e] = i); + } + } + return ( + n("font", this.model.fonts, t.fontId), + n("border", this.model.borders, t.borderId), + n("fill", this.model.fills, t.fillId), + t.alignment && (r.alignment = t.alignment), + t.protection && (r.protection = t.protection), + r + ); + } + addDxfStyle(e) { + return ( + e.numFmt && (e.numFmtId = this._addNumFmtStr(e.numFmt)), + this.model.dxfs.push(e), + this.model.dxfs.length - 1 + ); + } + getDxfStyle(e) { + return this.model.dxfs[e]; + } + _addStyle(e) { + const t = this.map.style.toXml(e); + let r = this.index.style[t]; + return ( + void 0 === r && + ((r = this.index.style[t] = this.model.styles.length), + this.model.styles.push(t)), + r + ); + } + _addNumFmtStr(e) { + let t = h.getDefaultFmtId(e); + if (void 0 !== t) return t; + if (((t = this.index.numFmt[e]), void 0 !== t)) return t; + t = this.index.numFmt[e] = 164 + this.model.numFmts.length; + const r = this.map.numFmt.toXml({ id: t, formatCode: e }); + return (this.model.numFmts.push(r), t); + } + _addFont(e) { + const t = this.map.font.toXml(e); + let r = this.index.font[t]; + return ( + void 0 === r && + ((r = this.index.font[t] = this.model.fonts.length), + this.model.fonts.push(t)), + r + ); + } + _addBorder(e) { + const t = this.map.border.toXml(e); + let r = this.index.border[t]; + return ( + void 0 === r && + ((r = this.index.border[t] = this.model.borders.length), + this.model.borders.push(t)), + r + ); + } + _addFill(e) { + const t = this.map.fill.toXml(e); + let r = this.index.fill[t]; + return ( + void 0 === r && + ((r = this.index.fill[t] = this.model.fills.length), + this.model.fills.push(t)), + r + ); + } + } + ((p.STYLESHEET_ATTRIBUTES = { + xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main", + "xmlns:mc": + "http://schemas.openxmlformats.org/markup-compatibility/2006", + "mc:Ignorable": "x14ac x16r2", + "xmlns:x14ac": + "http://schemas.microsoft.com/office/spreadsheetml/2009/9/ac", + "xmlns:x16r2": + "http://schemas.microsoft.com/office/spreadsheetml/2015/02/main", + }), + (p.STATIC_XFORMS = { + cellStyles: new o({ + tag: "cellStyles", + $: { count: 1 }, + c: [ + { + tag: "cellStyle", + $: { name: "Normal", xfId: 0, builtinId: 0 }, + }, + ], + }), + dxfs: new o({ tag: "dxfs", $: { count: 0 } }), + tableStyles: new o({ + tag: "tableStyles", + $: { + count: 0, + defaultTableStyle: "TableStyleMedium2", + defaultPivotStyle: "PivotStyleLight16", + }, + }), + extLst: new o({ + tag: "extLst", + c: [ + { + tag: "ext", + $: { + uri: "{EB79DEF2-80B8-43e5-95BD-54CBDDF9020C}", + "xmlns:x14": + "http://schemas.microsoft.com/office/spreadsheetml/2009/9/main", + }, + c: [ + { + tag: "x14:slicerStyles", + $: { defaultSlicerStyle: "SlicerStyleLight1" }, + }, + ], + }, + { + tag: "ext", + $: { + uri: "{9260A510-F301-46a8-8635-F512D64BE5F5}", + "xmlns:x15": + "http://schemas.microsoft.com/office/spreadsheetml/2010/11/main", + }, + c: [ + { + tag: "x15:timelineStyles", + $: { defaultTimelineStyle: "TimeSlicerStyleLight1" }, + }, + ], + }, + ], + }), + })); + ((p.Mock = class extends p { + constructor() { + (super(), + (this.model = { + styles: [ + { numFmtId: 0, fontId: 0, fillId: 0, borderId: 0, xfId: 0 }, + ], + numFmts: [], + fonts: [ + { + size: 11, + color: { theme: 1 }, + name: "Calibri", + family: 2, + scheme: "minor", + }, + ], + borders: [{}], + fills: [ + { type: "pattern", pattern: "none" }, + { type: "pattern", pattern: "gray125" }, + ], + })); + } + parseStream(e) { + return (e.autodrain(), Promise.resolve()); + } + addStyleModel(e, t) { + switch (t) { + case n.ValueType.Date: + return this.dateStyleId; + default: + return 0; + } + } + get dateStyleId() { + if (!this._dateStyleId) { + const e = { numFmtId: h.getDefaultFmtId("mm-dd-yy") }; + ((this._dateStyleId = this.model.styles.length), + this.model.styles.push(e)); + } + return this._dateStyleId; + } + getStyleModel() { + return {}; + } + }), + (t.exports = p)); + }, + { + "../../../doc/enums": 7, + "../../../utils/xml-stream": 28, + "../base-xform": 32, + "../list-xform": 71, + "../static-xform": 120, + "./border-xform": 127, + "./dxf-xform": 129, + "./fill-xform": 130, + "./font-xform": 131, + "./numfmt-xform": 132, + "./style-xform": 134, + }, + ], + 136: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + class i extends n { + constructor(e) { + (super(), (this.model = e)); + } + get tag() { + return "u"; + } + render(e, t) { + if (!0 === (t = t || this.model)) e.leafNode("u"); + else { + const r = i.Attributes[t]; + r && e.leafNode("u", r); + } + } + parseOpen(e) { + "u" === e.name && (this.model = e.attributes.val || !0); + } + parseText() {} + parseClose() { + return !1; + } + } + ((i.Attributes = { + single: {}, + double: { val: "double" }, + singleAccounting: { val: "singleAccounting" }, + doubleAccounting: { val: "doubleAccounting" }, + }), + (t.exports = i)); + }, + { "../base-xform": 32 }, + ], + 137: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("./filter-column-xform"); + t.exports = class extends n { + constructor() { + (super(), (this.map = { filterColumn: new i() })); + } + get tag() { + return "autoFilter"; + } + prepare(e) { + e.columns.forEach((e, t) => { + this.map.filterColumn.prepare(e, { index: t }); + }); + } + render(e, t) { + return ( + e.openNode(this.tag, { ref: t.autoFilterRef }), + t.columns.forEach((t) => { + this.map.filterColumn.render(e, t); + }), + e.closeNode(), + !0 + ); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + switch (e.name) { + case this.tag: + return ( + (this.model = { + autoFilterRef: e.attributes.ref, + columns: [], + }), + !0 + ); + default: + if (((this.parser = this.map[e.name]), this.parser)) + return (this.parseOpen(e), !0); + throw new Error( + "Unexpected xml node in parseOpen: " + JSON.stringify(e), + ); + } + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || + (this.model.columns.push(this.parser.model), + (this.parser = void 0)), + !0 + ); + switch (e) { + case this.tag: + return !1; + default: + throw new Error("Unexpected xml node in parseClose: " + e); + } + } + }; + }, + { "../base-xform": 32, "./filter-column-xform": 139 }, + ], + 138: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "customFilter"; + } + render(e, t) { + e.leafNode(this.tag, { val: t.val, operator: t.operator }); + } + parseOpen(e) { + return ( + e.name === this.tag && + ((this.model = { + val: e.attributes.val, + operator: e.attributes.operator, + }), + !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 139: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"), + i = e("../list-xform"), + s = e("./custom-filter-xform"), + o = e("./filter-xform"); + t.exports = class extends n { + constructor() { + (super(), + (this.map = { + customFilters: new i({ + tag: "customFilters", + count: !1, + empty: !0, + childXform: new s(), + }), + filters: new i({ + tag: "filters", + count: !1, + empty: !0, + childXform: new o(), + }), + })); + } + get tag() { + return "filterColumn"; + } + prepare(e, t) { + e.colId = t.index.toString(); + } + render(e, t) { + return t.customFilters + ? (e.openNode(this.tag, { + colId: t.colId, + hiddenButton: t.filterButton ? "0" : "1", + }), + this.map.customFilters.render(e, t.customFilters), + e.closeNode(), + !0) + : (e.leafNode(this.tag, { + colId: t.colId, + hiddenButton: t.filterButton ? "0" : "1", + }), + !0); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + const { attributes: t } = e; + switch (e.name) { + case this.tag: + return ( + (this.model = { filterButton: "0" === t.hiddenButton }), + !0 + ); + default: + if (((this.parser = this.map[e.name]), this.parser)) + return (this.parseOpen(e), !0); + throw new Error( + "Unexpected xml node in parseOpen: " + JSON.stringify(e), + ); + } + } + parseText() {} + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case this.tag: + return ( + (this.model.customFilters = this.map.customFilters.model), + !1 + ); + default: + return !0; + } + } + }; + }, + { + "../base-xform": 32, + "../list-xform": 71, + "./custom-filter-xform": 138, + "./filter-xform": 140, + }, + ], + 140: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "filter"; + } + render(e, t) { + e.leafNode(this.tag, { val: t.val }); + } + parseOpen(e) { + return ( + e.name === this.tag && + ((this.model = { val: e.attributes.val }), !0) + ); + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 141: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "tableColumn"; + } + prepare(e, t) { + e.id = t.index + 1; + } + render(e, t) { + return ( + e.leafNode(this.tag, { + id: t.id.toString(), + name: t.name, + totalsRowLabel: t.totalsRowLabel, + totalsRowFunction: t.totalsRowFunction, + dxfId: t.dxfId, + }), + !0 + ); + } + parseOpen(e) { + if (e.name === this.tag) { + const { attributes: t } = e; + return ( + (this.model = { + name: t.name, + totalsRowLabel: t.totalsRowLabel, + totalsRowFunction: t.totalsRowFunction, + dxfId: t.dxfId, + }), + !0 + ); + } + return !1; + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 142: [ + function (e, t, r) { + "use strict"; + const n = e("../base-xform"); + t.exports = class extends n { + get tag() { + return "tableStyleInfo"; + } + render(e, t) { + return ( + e.leafNode(this.tag, { + name: t.theme ? t.theme : void 0, + showFirstColumn: t.showFirstColumn ? "1" : "0", + showLastColumn: t.showLastColumn ? "1" : "0", + showRowStripes: t.showRowStripes ? "1" : "0", + showColumnStripes: t.showColumnStripes ? "1" : "0", + }), + !0 + ); + } + parseOpen(e) { + if (e.name === this.tag) { + const { attributes: t } = e; + return ( + (this.model = { + theme: t.name ? t.name : null, + showFirstColumn: "1" === t.showFirstColumn, + showLastColumn: "1" === t.showLastColumn, + showRowStripes: "1" === t.showRowStripes, + showColumnStripes: "1" === t.showColumnStripes, + }), + !0 + ); + } + return !1; + } + parseText() {} + parseClose() { + return !1; + } + }; + }, + { "../base-xform": 32 }, + ], + 143: [ + function (e, t, r) { + "use strict"; + const n = e("../../../utils/xml-stream"), + i = e("../base-xform"), + s = e("../list-xform"), + o = e("./auto-filter-xform"), + a = e("./table-column-xform"), + l = e("./table-style-info-xform"); + class c extends i { + constructor() { + (super(), + (this.map = { + autoFilter: new o(), + tableColumns: new s({ + tag: "tableColumns", + count: !0, + empty: !0, + childXform: new a(), + }), + tableStyleInfo: new l(), + })); + } + prepare(e, t) { + (this.map.autoFilter.prepare(e), + this.map.tableColumns.prepare(e.columns, t)); + } + get tag() { + return "table"; + } + render(e, t) { + (e.openXml(n.StdDocAttributes), + e.openNode(this.tag, { + ...c.TABLE_ATTRIBUTES, + id: t.id, + name: t.name, + displayName: t.displayName || t.name, + ref: t.tableRef, + totalsRowCount: t.totalsRow ? "1" : void 0, + totalsRowShown: t.totalsRow ? void 0 : "1", + headerRowCount: t.headerRow ? "1" : "0", + }), + this.map.autoFilter.render(e, t), + this.map.tableColumns.render(e, t.columns), + this.map.tableStyleInfo.render(e, t.style), + e.closeNode()); + } + parseOpen(e) { + if (this.parser) return (this.parser.parseOpen(e), !0); + const { name: t, attributes: r } = e; + switch (t) { + case this.tag: + (this.reset(), + (this.model = { + name: r.name, + displayName: r.displayName || r.name, + tableRef: r.ref, + totalsRow: "1" === r.totalsRowCount, + headerRow: "1" === r.headerRowCount, + })); + break; + default: + ((this.parser = this.map[e.name]), + this.parser && this.parser.parseOpen(e)); + } + return !0; + } + parseText(e) { + this.parser && this.parser.parseText(e); + } + parseClose(e) { + if (this.parser) + return ( + this.parser.parseClose(e) || (this.parser = void 0), + !0 + ); + switch (e) { + case this.tag: + return ( + (this.model.columns = this.map.tableColumns.model), + this.map.autoFilter.model && + ((this.model.autoFilterRef = + this.map.autoFilter.model.autoFilterRef), + this.map.autoFilter.model.columns.forEach((e, t) => { + this.model.columns[t].filterButton = e.filterButton; + })), + (this.model.style = this.map.tableStyleInfo.model), + !1 + ); + default: + return !0; + } + } + reconcile(e, t) { + e.columns.forEach((e) => { + void 0 !== e.dxfId && (e.style = t.styles.getDxfStyle(e.dxfId)); + }); + } + } + ((c.TABLE_ATTRIBUTES = { + xmlns: "http://schemas.openxmlformats.org/spreadsheetml/2006/main", + "xmlns:mc": + "http://schemas.openxmlformats.org/markup-compatibility/2006", + "mc:Ignorable": "xr xr3", + "xmlns:xr": + "http://schemas.microsoft.com/office/spreadsheetml/2014/revision", + "xmlns:xr3": + "http://schemas.microsoft.com/office/spreadsheetml/2016/revision3", + }), + (t.exports = c)); + }, + { + "../../../utils/xml-stream": 28, + "../base-xform": 32, + "../list-xform": 71, + "./auto-filter-xform": 137, + "./table-column-xform": 141, + "./table-style-info-xform": 142, + }, + ], + 144: [ + function (e, t, r) { + (function (r, n) { + (function () { + "use strict"; + const i = e("fs"), + s = e("jszip"), + { PassThrough: o } = e("readable-stream"), + a = e("../utils/zip-stream"), + l = e("../utils/stream-buf"), + c = e("../utils/utils"), + u = e("../utils/xml-stream"), + { bufferToString: h } = e("../utils/browser-buffer-decode"), + f = e("./xform/style/styles-xform"), + d = e("./xform/core/core-xform"), + p = e("./xform/strings/shared-strings-xform"), + m = e("./xform/core/relationships-xform"), + b = e("./xform/core/content-types-xform"), + g = e("./xform/core/app-xform"), + y = e("./xform/book/workbook-xform"), + v = e("./xform/sheet/worksheet-xform"), + w = e("./xform/drawing/drawing-xform"), + _ = e("./xform/table/table-xform"), + x = e("./xform/comment/comments-xform"), + k = e("./xform/comment/vml-notes-xform"), + S = e("./xml/theme1"); + class M { + constructor(e) { + this.workbook = e; + } + async readFile(e, t) { + if (!(await c.fs.exists(e))) + throw new Error("File not found: " + e); + const r = i.createReadStream(e); + try { + const e = await this.read(r, t); + return (r.close(), e); + } catch (e) { + throw (r.close(), e); + } + } + parseRels(e) { + return new m().parseStream(e); + } + parseWorkbook(e) { + return new y().parseStream(e); + } + parseSharedStrings(e) { + return new p().parseStream(e); + } + reconcile(e, t) { + const r = new y(), + n = new v(t), + i = new w(), + s = new _(); + r.reconcile(e); + const o = { media: e.media, mediaIndex: e.mediaIndex }; + Object.keys(e.drawings).forEach((t) => { + const r = e.drawings[t], + n = e.drawingRels[t]; + n && + ((o.rels = n.reduce((e, t) => ((e[t.Id] = t), e), {})), + (r.anchors || []).forEach((e) => { + const t = e.picture && e.picture.hyperlinks; + t && + o.rels[t.rId] && + ((t.hyperlink = o.rels[t.rId].Target), delete t.rId); + }), + i.reconcile(r, o)); + }); + const a = { styles: e.styles }; + Object.values(e.tables).forEach((e) => { + s.reconcile(e, a); + }); + const l = { + styles: e.styles, + sharedStrings: e.sharedStrings, + media: e.media, + mediaIndex: e.mediaIndex, + date1904: e.properties && e.properties.date1904, + drawings: e.drawings, + comments: e.comments, + tables: e.tables, + vmlDrawings: e.vmlDrawings, + }; + (e.worksheets.forEach((t) => { + ((t.relationships = e.worksheetRels[t.sheetNo]), + n.reconcile(t, l)); + }), + delete e.worksheetHash, + delete e.worksheetRels, + delete e.globalRels, + delete e.sharedStrings, + delete e.workbookRels, + delete e.sheetDefs, + delete e.styles, + delete e.mediaIndex, + delete e.drawings, + delete e.drawingRels, + delete e.vmlDrawings); + } + async _processWorksheetEntry(e, t, r, n, i) { + const s = new v(n), + o = await s.parseStream(e); + ((o.sheetNo = r), + (t.worksheetHash[i] = o), + t.worksheets.push(o)); + } + async _processCommentEntry(e, t, r) { + const n = new x(), + i = await n.parseStream(e); + t.comments[`../${r}.xml`] = i; + } + async _processTableEntry(e, t, r) { + const n = new _(), + i = await n.parseStream(e); + t.tables[`../tables/${r}.xml`] = i; + } + async _processWorksheetRelsEntry(e, t, r) { + const n = new m(), + i = await n.parseStream(e); + t.worksheetRels[r] = i; + } + async _processMediaEntry(e, t, r) { + const n = r.lastIndexOf("."); + if (n >= 1) { + const i = r.substr(n + 1), + s = r.substr(0, n); + await new Promise((n, o) => { + const a = new l(); + (a.on("finish", () => { + ((t.mediaIndex[r] = t.media.length), + (t.mediaIndex[s] = t.media.length)); + const e = { + type: "image", + name: s, + extension: i, + buffer: a.toBuffer(), + }; + (t.media.push(e), n()); + }), + e.on("error", (e) => { + o(e); + }), + e.pipe(a)); + }); + } + } + async _processDrawingEntry(e, t, r) { + const n = new w(), + i = await n.parseStream(e); + t.drawings[r] = i; + } + async _processDrawingRelsEntry(e, t, r) { + const n = new m(), + i = await n.parseStream(e); + t.drawingRels[r] = i; + } + async _processVmlDrawingEntry(e, t, r) { + const n = new k(), + i = await n.parseStream(e); + t.vmlDrawings[`../drawings/${r}.vml`] = i; + } + async _processThemeEntry(e, t, r) { + await new Promise((n, i) => { + const s = new l(); + (e.on("error", i), + s.on("error", i), + s.on("finish", () => { + ((t.themes[r] = s.read().toString()), n()); + }), + e.pipe(s)); + }); + } + createInputStream() { + throw new Error( + "`XLSX#createInputStream` is deprecated. You should use `XLSX#read` instead. This method will be removed in version 5.0. Please follow upgrade instruction: https://github.com/exceljs/exceljs/blob/master/UPGRADE-4.0.md", + ); + } + async read(e, t) { + !e[Symbol.asyncIterator] && e.pipe && (e = e.pipe(new o())); + const r = []; + for await (const t of e) r.push(t); + return this.load(n.concat(r), t); + } + async load(e, t) { + let i; + i = t && t.base64 ? n.from(e.toString(), "base64") : e; + const a = { + worksheets: [], + worksheetHash: {}, + worksheetRels: [], + themes: {}, + media: [], + mediaIndex: {}, + drawings: {}, + drawingRels: {}, + comments: {}, + tables: {}, + vmlDrawings: {}, + }, + l = await s.loadAsync(i); + for (const e of Object.values(l.files)) + if (!e.dir) { + let n, + i = e.name; + if ( + ("/" === i[0] && (i = i.substr(1)), + i.match(/xl\/media\//) || + i.match(/xl\/theme\/([a-zA-Z0-9]+)[.]xml/)) + ) + ((n = new o()), n.write(await e.async("nodebuffer"))); + else { + let t; + ((n = new o({ + writableObjectMode: !0, + readableObjectMode: !0, + })), + (t = r.browser + ? h(await e.async("nodebuffer")) + : await e.async("string"))); + const i = 16384; + for (let e = 0; e < t.length; e += i) + n.write(t.substring(e, e + i)); + } + switch ((n.end(), i)) { + case "_rels/.rels": + a.globalRels = await this.parseRels(n); + break; + case "xl/workbook.xml": { + const e = await this.parseWorkbook(n); + ((a.sheets = e.sheets), + (a.definedNames = e.definedNames), + (a.views = e.views), + (a.properties = e.properties), + (a.calcProperties = e.calcProperties)); + break; + } + case "xl/_rels/workbook.xml.rels": + a.workbookRels = await this.parseRels(n); + break; + case "xl/sharedStrings.xml": + ((a.sharedStrings = new p()), + await a.sharedStrings.parseStream(n)); + break; + case "xl/styles.xml": + ((a.styles = new f()), await a.styles.parseStream(n)); + break; + case "docProps/app.xml": { + const e = new g(), + t = await e.parseStream(n); + ((a.company = t.company), (a.manager = t.manager)); + break; + } + case "docProps/core.xml": { + const e = new d(), + t = await e.parseStream(n); + Object.assign(a, t); + break; + } + default: { + let e = i.match(/xl\/worksheets\/sheet(\d+)[.]xml/); + if (e) { + await this._processWorksheetEntry(n, a, e[1], t, i); + break; + } + if ( + ((e = i.match( + /xl\/worksheets\/_rels\/sheet(\d+)[.]xml.rels/, + )), + e) + ) { + await this._processWorksheetRelsEntry(n, a, e[1]); + break; + } + if ( + ((e = i.match(/xl\/theme\/([a-zA-Z0-9]+)[.]xml/)), + e) + ) { + await this._processThemeEntry(n, a, e[1]); + break; + } + if ( + ((e = i.match( + /xl\/media\/([a-zA-Z0-9]+[.][a-zA-Z0-9]{3,4})$/, + )), + e) + ) { + await this._processMediaEntry(n, a, e[1]); + break; + } + if ( + ((e = i.match( + /xl\/drawings\/([a-zA-Z0-9]+)[.]xml/, + )), + e) + ) { + await this._processDrawingEntry(n, a, e[1]); + break; + } + if (((e = i.match(/xl\/(comments\d+)[.]xml/)), e)) { + await this._processCommentEntry(n, a, e[1]); + break; + } + if ( + ((e = i.match(/xl\/tables\/(table\d+)[.]xml/)), e) + ) { + await this._processTableEntry(n, a, e[1]); + break; + } + if ( + ((e = i.match( + /xl\/drawings\/_rels\/([a-zA-Z0-9]+)[.]xml[.]rels/, + )), + e) + ) { + await this._processDrawingRelsEntry(n, a, e[1]); + break; + } + if ( + ((e = i.match( + /xl\/drawings\/(vmlDrawing\d+)[.]vml/, + )), + e) + ) { + await this._processVmlDrawingEntry(n, a, e[1]); + break; + } + } + } + } + return ( + this.reconcile(a, t), + (this.workbook.model = a), + this.workbook + ); + } + async addMedia(e, t) { + await Promise.all( + t.media.map(async (t) => { + if ("image" === t.type) { + const r = `xl/media/${t.name}.${t.extension}`; + if (t.filename) { + const n = await (function (e, t) { + return new Promise((r, n) => { + i.readFile(e, t, (e, t) => { + e ? n(e) : r(t); + }); + }); + })(t.filename); + return e.append(n, { name: r }); + } + if (t.buffer) return e.append(t.buffer, { name: r }); + if (t.base64) { + const n = t.base64, + i = n.substring(n.indexOf(",") + 1); + return e.append(i, { name: r, base64: !0 }); + } + } + throw new Error("Unsupported media"); + }), + ); + } + addDrawings(e, t) { + const r = new w(), + n = new m(); + t.worksheets.forEach((t) => { + const { drawing: i } = t; + if (i) { + r.prepare(i, {}); + let t = r.toXml(i); + (e.append(t, { name: `xl/drawings/${i.name}.xml` }), + (t = n.toXml(i.rels)), + e.append(t, { + name: `xl/drawings/_rels/${i.name}.xml.rels`, + })); + } + }); + } + addTables(e, t) { + const r = new _(); + t.worksheets.forEach((t) => { + const { tables: n } = t; + n.forEach((t) => { + r.prepare(t, {}); + const n = r.toXml(t); + e.append(n, { name: "xl/tables/" + t.target }); + }); + }); + } + async addContentTypes(e, t) { + const r = new b().toXml(t); + e.append(r, { name: "[Content_Types].xml" }); + } + async addApp(e, t) { + const r = new g().toXml(t); + e.append(r, { name: "docProps/app.xml" }); + } + async addCore(e, t) { + const r = new d(); + e.append(r.toXml(t), { name: "docProps/core.xml" }); + } + async addThemes(e, t) { + const r = t.themes || { theme1: S }; + Object.keys(r).forEach((t) => { + const n = r[t], + i = `xl/theme/${t}.xml`; + e.append(n, { name: i }); + }); + } + async addOfficeRels(e) { + const t = new m().toXml([ + { + Id: "rId1", + Type: M.RelType.OfficeDocument, + Target: "xl/workbook.xml", + }, + { + Id: "rId2", + Type: M.RelType.CoreProperties, + Target: "docProps/core.xml", + }, + { + Id: "rId3", + Type: M.RelType.ExtenderProperties, + Target: "docProps/app.xml", + }, + ]); + e.append(t, { name: "_rels/.rels" }); + } + async addWorkbookRels(e, t) { + let r = 1; + const n = [ + { + Id: "rId" + r++, + Type: M.RelType.Styles, + Target: "styles.xml", + }, + { + Id: "rId" + r++, + Type: M.RelType.Theme, + Target: "theme/theme1.xml", + }, + ]; + (t.sharedStrings.count && + n.push({ + Id: "rId" + r++, + Type: M.RelType.SharedStrings, + Target: "sharedStrings.xml", + }), + t.worksheets.forEach((e) => { + ((e.rId = "rId" + r++), + n.push({ + Id: e.rId, + Type: M.RelType.Worksheet, + Target: `worksheets/sheet${e.id}.xml`, + })); + })); + const i = new m().toXml(n); + e.append(i, { name: "xl/_rels/workbook.xml.rels" }); + } + async addSharedStrings(e, t) { + t.sharedStrings && + t.sharedStrings.count && + e.append(t.sharedStrings.xml, { + name: "xl/sharedStrings.xml", + }); + } + async addStyles(e, t) { + const { xml: r } = t.styles; + r && e.append(r, { name: "xl/styles.xml" }); + } + async addWorkbook(e, t) { + const r = new y(); + e.append(r.toXml(t), { name: "xl/workbook.xml" }); + } + async addWorksheets(e, t) { + const r = new v(), + n = new m(), + i = new x(), + s = new k(); + t.worksheets.forEach((t) => { + let o = new u(); + (r.render(o, t), + e.append(o.xml, { + name: `xl/worksheets/sheet${t.id}.xml`, + }), + t.rels && + t.rels.length && + ((o = new u()), + n.render(o, t.rels), + e.append(o.xml, { + name: `xl/worksheets/_rels/sheet${t.id}.xml.rels`, + })), + t.comments.length > 0 && + ((o = new u()), + i.render(o, t), + e.append(o.xml, { name: `xl/comments${t.id}.xml` }), + (o = new u()), + s.render(o, t), + e.append(o.xml, { + name: `xl/drawings/vmlDrawing${t.id}.vml`, + }))); + }); + } + _finalize(e) { + return new Promise((t, r) => { + (e.on("finish", () => { + t(this); + }), + e.on("error", r), + e.finalize()); + }); + } + prepareModel(e, t) { + ((e.creator = e.creator || "ExcelJS"), + (e.lastModifiedBy = e.lastModifiedBy || "ExcelJS"), + (e.created = e.created || new Date()), + (e.modified = e.modified || new Date()), + (e.useSharedStrings = + void 0 === t.useSharedStrings || t.useSharedStrings), + (e.useStyles = void 0 === t.useStyles || t.useStyles), + (e.sharedStrings = new p()), + (e.styles = e.useStyles ? new f(!0) : new f.Mock())); + const r = new y(), + n = new v(); + r.prepare(e); + const i = { + sharedStrings: e.sharedStrings, + styles: e.styles, + date1904: e.properties.date1904, + drawingsCount: 0, + media: e.media, + }; + ((i.drawings = e.drawings = []), + (i.commentRefs = e.commentRefs = [])); + let s = 0; + ((e.tables = []), + e.worksheets.forEach((t) => { + (t.tables.forEach((t) => { + (s++, + (t.target = `table${s}.xml`), + (t.id = s), + e.tables.push(t)); + }), + n.prepare(t, i)); + })); + } + async write(e, t) { + t = t || {}; + const { model: r } = this.workbook, + n = new a.ZipWriter(t.zip); + return ( + n.pipe(e), + this.prepareModel(r, t), + await this.addContentTypes(n, r), + await this.addOfficeRels(n, r), + await this.addWorkbookRels(n, r), + await this.addWorksheets(n, r), + await this.addSharedStrings(n, r), + await this.addDrawings(n, r), + await this.addTables(n, r), + await Promise.all([ + this.addThemes(n, r), + this.addStyles(n, r), + ]), + await this.addMedia(n, r), + await Promise.all([this.addApp(n, r), this.addCore(n, r)]), + await this.addWorkbook(n, r), + this._finalize(n) + ); + } + writeFile(e, t) { + const r = i.createWriteStream(e); + return new Promise((e, n) => { + (r.on("finish", () => { + e(); + }), + r.on("error", (e) => { + n(e); + }), + this.write(r, t) + .then(() => { + r.end(); + }) + .catch((e) => { + n(e); + })); + }); + } + async writeBuffer(e) { + const t = new l(); + return (await this.write(t, e), t.read()); + } + } + ((M.RelType = e("./rel-type")), (t.exports = M)); + }).call(this); + }).call(this, e("_process"), e("buffer").Buffer); + }, + { + "../utils/browser-buffer-decode": 16, + "../utils/stream-buf": 24, + "../utils/utils": 27, + "../utils/xml-stream": 28, + "../utils/zip-stream": 29, + "./rel-type": 31, + "./xform/book/workbook-xform": 38, + "./xform/comment/comments-xform": 40, + "./xform/comment/vml-notes-xform": 45, + "./xform/core/app-xform": 51, + "./xform/core/content-types-xform": 52, + "./xform/core/core-xform": 53, + "./xform/core/relationships-xform": 55, + "./xform/drawing/drawing-xform": 62, + "./xform/sheet/worksheet-xform": 115, + "./xform/strings/shared-strings-xform": 124, + "./xform/style/styles-xform": 135, + "./xform/table/table-xform": 143, + "./xml/theme1": 145, + _process: 467, + buffer: 220, + fs: 216, + jszip: 441, + "readable-stream": 491, + }, + ], + 145: [ + function (e, t, r) { + "use strict"; + t.exports = + '\n '; + }, + {}, + ], + 146: [ + function (e, t, r) { + (function (t) { + (function () { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.CsvFormatterStream = void 0)); + const n = e("stream"), + i = e("./formatter"); + class s extends n.Transform { + constructor(e) { + (super({ writableObjectMode: e.objectMode }), + (this.hasWrittenBOM = !1), + (this.formatterOptions = e), + (this.rowFormatter = new i.RowFormatter(e)), + (this.hasWrittenBOM = !e.writeBOM)); + } + transform(e) { + return ((this.rowFormatter.rowTransform = e), this); + } + _transform(e, r, n) { + let i = !1; + try { + (this.hasWrittenBOM || + (this.push(this.formatterOptions.BOM), + (this.hasWrittenBOM = !0)), + this.rowFormatter.format(e, (e, r) => + e + ? ((i = !0), n(e)) + : (r && + r.forEach((e) => { + this.push(t.from(e, "utf8")); + }), + (i = !0), + n()), + )); + } catch (e) { + if (i) throw e; + n(e); + } + } + _flush(e) { + this.rowFormatter.finish((r, n) => + r + ? e(r) + : (n && + n.forEach((e) => { + this.push(t.from(e, "utf8")); + }), + e()), + ); + } + } + r.CsvFormatterStream = s; + }).call(this); + }).call(this, e("buffer").Buffer); + }, + { "./formatter": 150, buffer: 220, stream: 505 }, + ], + 147: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.FormatterOptions = void 0)); + r.FormatterOptions = class { + constructor() { + let e = + arguments.length > 0 && void 0 !== arguments[0] + ? arguments[0] + : {}; + var t; + ((this.objectMode = !0), + (this.delimiter = ","), + (this.rowDelimiter = "\n"), + (this.quote = '"'), + (this.escape = this.quote), + (this.quoteColumns = !1), + (this.quoteHeaders = this.quoteColumns), + (this.headers = null), + (this.includeEndRowDelimiter = !1), + (this.writeBOM = !1), + (this.BOM = "\ufeff"), + (this.alwaysWriteHeaders = !1), + Object.assign(this, e || {}), + void 0 === (null == e ? void 0 : e.quoteHeaders) && + (this.quoteHeaders = this.quoteColumns), + !0 === (null == e ? void 0 : e.quote) + ? (this.quote = '"') + : !1 === (null == e ? void 0 : e.quote) && (this.quote = ""), + "string" != typeof (null == e ? void 0 : e.escape) && + (this.escape = this.quote), + (this.shouldWriteHeaders = + !!this.headers && + (null === (t = e.writeHeaders) || void 0 === t || t)), + (this.headers = Array.isArray(this.headers) + ? this.headers + : null), + (this.escapedQuote = `${this.escape}${this.quote}`)); + } + }; + }, + {}, + ], + 148: [ + function (e, t, r) { + "use strict"; + var n = function (e) { + return e && e.__esModule ? e : { default: e }; + }; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.FieldFormatter = void 0)); + const i = n(e("lodash.isboolean")), + s = n(e("lodash.isnil")), + o = n(e("lodash.escaperegexp")); + r.FieldFormatter = class { + constructor(e) { + ((this._headers = null), + (this.formatterOptions = e), + null !== e.headers && (this.headers = e.headers), + (this.REPLACE_REGEXP = new RegExp(e.quote, "g"))); + const t = `[${e.delimiter}${o.default(e.rowDelimiter)}|\r|\n]`; + this.ESCAPE_REGEXP = new RegExp(t); + } + set headers(e) { + this._headers = e; + } + shouldQuote(e, t) { + const r = t + ? this.formatterOptions.quoteHeaders + : this.formatterOptions.quoteColumns; + return i.default(r) + ? r + : Array.isArray(r) + ? r[e] + : null !== this._headers && r[this._headers[e]]; + } + format(e, t, r) { + const n = ("" + (s.default(e) ? "" : e)).replace(/\0/g, ""), + { formatterOptions: i } = this; + if ("" !== i.quote) { + if (-1 !== n.indexOf(i.quote)) + return this.quoteField( + n.replace(this.REPLACE_REGEXP, i.escapedQuote), + ); + } + return -1 !== n.search(this.ESCAPE_REGEXP) || + this.shouldQuote(t, r) + ? this.quoteField(n) + : n; + } + quoteField(e) { + const { quote: t } = this.formatterOptions; + return `${t}${e}${t}`; + } + }; + }, + { + "lodash.escaperegexp": 442, + "lodash.isboolean": 444, + "lodash.isnil": 447, + }, + ], + 149: [ + function (e, t, r) { + "use strict"; + var n = function (e) { + return e && e.__esModule ? e : { default: e }; + }; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.RowFormatter = void 0)); + const i = n(e("lodash.isfunction")), + s = n(e("lodash.isequal")), + o = e("./FieldFormatter"), + a = e("../types"); + class l { + constructor(e) { + ((this.rowCount = 0), + (this.formatterOptions = e), + (this.fieldFormatter = new o.FieldFormatter(e)), + (this.headers = e.headers), + (this.shouldWriteHeaders = e.shouldWriteHeaders), + (this.hasWrittenHeaders = !1), + null !== this.headers && + (this.fieldFormatter.headers = this.headers), + e.transform && (this.rowTransform = e.transform)); + } + static isRowHashArray(e) { + return ( + !!Array.isArray(e) && Array.isArray(e[0]) && 2 === e[0].length + ); + } + static isRowArray(e) { + return Array.isArray(e) && !this.isRowHashArray(e); + } + static gatherHeaders(e) { + return l.isRowHashArray(e) + ? e.map((e) => e[0]) + : Array.isArray(e) + ? e + : Object.keys(e); + } + static createTransform(e) { + return a.isSyncTransform(e) + ? (t, r) => { + let n = null; + try { + n = e(t); + } catch (e) { + return r(e); + } + return r(null, n); + } + : (t, r) => { + e(t, r); + }; + } + set rowTransform(e) { + if (!i.default(e)) + throw new TypeError("The transform should be a function"); + this._rowTransform = l.createTransform(e); + } + format(e, t) { + this.callTransformer(e, (r, n) => { + if (r) return t(r); + if (!e) return t(null); + const i = []; + if (n) { + const { shouldFormatColumns: e, headers: t } = + this.checkHeaders(n); + if ( + (this.shouldWriteHeaders && + t && + !this.hasWrittenHeaders && + (i.push(this.formatColumns(t, !0)), + (this.hasWrittenHeaders = !0)), + e) + ) { + const e = this.gatherColumns(n); + i.push(this.formatColumns(e, !1)); + } + } + return t(null, i); + }); + } + finish(e) { + const t = []; + if ( + this.formatterOptions.alwaysWriteHeaders && + 0 === this.rowCount + ) { + if (!this.headers) + return e( + new Error( + "`alwaysWriteHeaders` option is set to true but `headers` option not provided.", + ), + ); + t.push(this.formatColumns(this.headers, !0)); + } + return ( + this.formatterOptions.includeEndRowDelimiter && + t.push(this.formatterOptions.rowDelimiter), + e(null, t) + ); + } + checkHeaders(e) { + if (this.headers) + return { shouldFormatColumns: !0, headers: this.headers }; + const t = l.gatherHeaders(e); + return ( + (this.headers = t), + (this.fieldFormatter.headers = t), + this.shouldWriteHeaders + ? { shouldFormatColumns: !s.default(t, e), headers: t } + : { shouldFormatColumns: !0, headers: null } + ); + } + gatherColumns(e) { + if (null === this.headers) + throw new Error("Headers is currently null"); + return Array.isArray(e) + ? l.isRowHashArray(e) + ? this.headers.map((t, r) => { + const n = e[r]; + return n ? n[1] : ""; + }) + : l.isRowArray(e) && !this.shouldWriteHeaders + ? e + : this.headers.map((t, r) => e[r]) + : this.headers.map((t) => e[t]); + } + callTransformer(e, t) { + return this._rowTransform ? this._rowTransform(e, t) : t(null, e); + } + formatColumns(e, t) { + const r = e + .map((e, r) => this.fieldFormatter.format(e, r, t)) + .join(this.formatterOptions.delimiter), + { rowCount: n } = this; + return ( + (this.rowCount += 1), + n ? [this.formatterOptions.rowDelimiter, r].join("") : r + ); + } + } + r.RowFormatter = l; + }, + { + "../types": 152, + "./FieldFormatter": 148, + "lodash.isequal": 445, + "lodash.isfunction": 446, + }, + ], + 150: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.FieldFormatter = r.RowFormatter = void 0)); + var n = e("./RowFormatter"); + Object.defineProperty(r, "RowFormatter", { + enumerable: !0, + get: function () { + return n.RowFormatter; + }, + }); + var i = e("./FieldFormatter"); + Object.defineProperty(r, "FieldFormatter", { + enumerable: !0, + get: function () { + return i.FieldFormatter; + }, + }); + }, + { "./FieldFormatter": 148, "./RowFormatter": 149 }, + ], + 151: [ + function (e, t, r) { + (function (t) { + (function () { + "use strict"; + var n = Object.create + ? function (e, t, r, n) { + (void 0 === n && (n = r), + Object.defineProperty(e, n, { + enumerable: !0, + get: function () { + return t[r]; + }, + })); + } + : function (e, t, r, n) { + (void 0 === n && (n = r), (e[n] = t[r])); + }, + i = Object.create + ? function (e, t) { + Object.defineProperty(e, "default", { + enumerable: !0, + value: t, + }); + } + : function (e, t) { + e.default = t; + }, + s = function (e) { + if (e && e.__esModule) return e; + var t = {}; + if (null != e) + for (var r in e) + "default" !== r && + Object.prototype.hasOwnProperty.call(e, r) && + n(t, e, r); + return (i(t, e), t); + }, + o = function (e, t) { + for (var r in e) + "default" === r || + Object.prototype.hasOwnProperty.call(t, r) || + n(t, e, r); + }; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.writeToPath = + r.writeToString = + r.writeToBuffer = + r.writeToStream = + r.write = + r.format = + r.FormatterOptions = + r.CsvFormatterStream = + void 0)); + const a = e("util"), + l = e("stream"), + c = s(e("fs")), + u = e("./FormatterOptions"), + h = e("./CsvFormatterStream"); + o(e("./types"), r); + var f = e("./CsvFormatterStream"); + Object.defineProperty(r, "CsvFormatterStream", { + enumerable: !0, + get: function () { + return f.CsvFormatterStream; + }, + }); + var d = e("./FormatterOptions"); + (Object.defineProperty(r, "FormatterOptions", { + enumerable: !0, + get: function () { + return d.FormatterOptions; + }, + }), + (r.format = (e) => + new h.CsvFormatterStream(new u.FormatterOptions(e))), + (r.write = (e, t) => { + const n = r.format(t), + i = a.promisify((e, t) => { + n.write(e, void 0, t); + }); + return ( + e + .reduce((e, t) => e.then(() => i(t)), Promise.resolve()) + .then(() => n.end()) + .catch((e) => { + n.emit("error", e); + }), + n + ); + }), + (r.writeToStream = (e, t, n) => r.write(t, n).pipe(e)), + (r.writeToBuffer = function (e) { + let n = + arguments.length > 1 && void 0 !== arguments[1] + ? arguments[1] + : {}; + const i = [], + s = new l.Writable({ + write(e, t, r) { + (i.push(e), r()); + }, + }); + return new Promise((o, a) => { + (s.on("error", a).on("finish", () => o(t.concat(i))), + r.write(e, n).pipe(s)); + }); + }), + (r.writeToString = (e, t) => + r.writeToBuffer(e, t).then((e) => e.toString())), + (r.writeToPath = (e, t, n) => { + const i = c.createWriteStream(e, { encoding: "utf8" }); + return r.write(t, n).pipe(i); + })); + }).call(this); + }).call(this, e("buffer").Buffer); + }, + { + "./CsvFormatterStream": 146, + "./FormatterOptions": 147, + "./types": 152, + buffer: 220, + fs: 216, + stream: 505, + util: 527, + }, + ], + 152: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.isSyncTransform = void 0), + (r.isSyncTransform = (e) => 1 === e.length)); + }, + {}, + ], + 153: [ + function (e, t, r) { + (function (t) { + (function () { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.CsvParserStream = void 0)); + const n = e("string_decoder"), + i = e("stream"), + s = e("./transforms"), + o = e("./parser"); + class a extends i.Transform { + constructor(e) { + (super({ objectMode: e.objectMode }), + (this.lines = ""), + (this.rowCount = 0), + (this.parsedRowCount = 0), + (this.parsedLineCount = 0), + (this.endEmitted = !1), + (this.headersEmitted = !1), + (this.parserOptions = e), + (this.parser = new o.Parser(e)), + (this.headerTransformer = new s.HeaderTransformer(e)), + (this.decoder = new n.StringDecoder(e.encoding)), + (this.rowTransformerValidator = + new s.RowTransformerValidator())); + } + get hasHitRowLimit() { + return ( + this.parserOptions.limitRows && + this.rowCount >= this.parserOptions.maxRows + ); + } + get shouldEmitRows() { + return this.parsedRowCount > this.parserOptions.skipRows; + } + get shouldSkipLine() { + return this.parsedLineCount <= this.parserOptions.skipLines; + } + transform(e) { + return ( + (this.rowTransformerValidator.rowTransform = e), + this + ); + } + validate(e) { + return ( + (this.rowTransformerValidator.rowValidator = e), + this + ); + } + emit(e) { + if ("end" === e) + return ( + this.endEmitted || + ((this.endEmitted = !0), + super.emit("end", this.rowCount)), + !1 + ); + for ( + var t = arguments.length, + r = new Array(t > 1 ? t - 1 : 0), + n = 1; + n < t; + n++ + ) + r[n - 1] = arguments[n]; + return super.emit(e, ...r); + } + _transform(e, t, r) { + if (this.hasHitRowLimit) return r(); + const n = a.wrapDoneCallback(r); + try { + const { lines: t } = this, + r = t + this.decoder.write(e), + i = this.parse(r, !0); + return this.processRows(i, n); + } catch (e) { + return n(e); + } + } + _flush(e) { + const t = a.wrapDoneCallback(e); + if (this.hasHitRowLimit) return t(); + try { + const e = this.lines + this.decoder.end(), + r = this.parse(e, !1); + return this.processRows(r, t); + } catch (e) { + return t(e); + } + } + parse(e, t) { + if (!e) return []; + const { line: r, rows: n } = this.parser.parse(e, t); + return ((this.lines = r), n); + } + processRows(e, r) { + const n = e.length, + i = (s) => { + const o = (e) => + e + ? r(e) + : s % 100 != 0 + ? i(s + 1) + : void t(() => i(s + 1)); + if ( + (this.checkAndEmitHeaders(), + s >= n || this.hasHitRowLimit) + ) + return r(); + if (((this.parsedLineCount += 1), this.shouldSkipLine)) + return o(); + const a = e[s]; + ((this.rowCount += 1), (this.parsedRowCount += 1)); + const l = this.rowCount; + return this.transformRow(a, (e, t) => { + if (e) return ((this.rowCount -= 1), o(e)); + if (!t) + return o(new Error("expected transform result")); + if (t.isValid) { + if (t.row) return this.pushRow(t.row, o); + } else this.emit("data-invalid", t.row, l, t.reason); + return o(); + }); + }; + i(0); + } + transformRow(e, t) { + try { + this.headerTransformer.transform(e, (r, n) => + r + ? t(r) + : n + ? n.isValid + ? n.row + ? this.shouldEmitRows + ? this.rowTransformerValidator.transformAndValidate( + n.row, + t, + ) + : this.skipRow(t) + : ((this.rowCount -= 1), + (this.parsedRowCount -= 1), + t(null, { row: null, isValid: !0 })) + : this.shouldEmitRows + ? t(null, { isValid: !1, row: e }) + : this.skipRow(t) + : t( + new Error( + "Expected result from header transform", + ), + ), + ); + } catch (e) { + t(e); + } + } + checkAndEmitHeaders() { + !this.headersEmitted && + this.headerTransformer.headers && + ((this.headersEmitted = !0), + this.emit("headers", this.headerTransformer.headers)); + } + skipRow(e) { + return ( + (this.rowCount -= 1), + e(null, { row: null, isValid: !0 }) + ); + } + pushRow(e, t) { + try { + (this.parserOptions.objectMode + ? this.push(e) + : this.push(JSON.stringify(e)), + t()); + } catch (e) { + t(e); + } + } + static wrapDoneCallback(e) { + let t = !1; + return function (r) { + if (r) { + if (t) throw r; + return ((t = !0), void e(r)); + } + for ( + var n = arguments.length, + i = new Array(n > 1 ? n - 1 : 0), + s = 1; + s < n; + s++ + ) + i[s - 1] = arguments[s]; + e(...i); + }; + } + } + r.CsvParserStream = a; + }).call(this); + }).call(this, e("timers").setImmediate); + }, + { + "./parser": 165, + "./transforms": 168, + stream: 505, + string_decoder: 218, + timers: 523, + }, + ], + 154: [ + function (e, t, r) { + "use strict"; + var n = function (e) { + return e && e.__esModule ? e : { default: e }; + }; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.ParserOptions = void 0)); + const i = n(e("lodash.escaperegexp")), + s = n(e("lodash.isnil")); + r.ParserOptions = class { + constructor(e) { + var t; + if ( + ((this.objectMode = !0), + (this.delimiter = ","), + (this.ignoreEmpty = !1), + (this.quote = '"'), + (this.escape = null), + (this.escapeChar = this.quote), + (this.comment = null), + (this.supportsComments = !1), + (this.ltrim = !1), + (this.rtrim = !1), + (this.trim = !1), + (this.headers = null), + (this.renameHeaders = !1), + (this.strictColumnHandling = !1), + (this.discardUnmappedColumns = !1), + (this.carriageReturn = "\r"), + (this.encoding = "utf8"), + (this.limitRows = !1), + (this.maxRows = 0), + (this.skipLines = 0), + (this.skipRows = 0), + Object.assign(this, e || {}), + this.delimiter.length > 1) + ) + throw new Error("delimiter option must be one character long"); + ((this.escapedDelimiter = i.default(this.delimiter)), + (this.escapeChar = + null !== (t = this.escape) && void 0 !== t ? t : this.quote), + (this.supportsComments = !s.default(this.comment)), + (this.NEXT_TOKEN_REGEXP = new RegExp( + `([^\\s]|\\r\\n|\\n|\\r|${this.escapedDelimiter})`, + )), + this.maxRows > 0 && (this.limitRows = !0)); + } + }; + }, + { "lodash.escaperegexp": 442, "lodash.isnil": 447 }, + ], + 155: [ + function (e, t, r) { + "use strict"; + var n = Object.create + ? function (e, t, r, n) { + (void 0 === n && (n = r), + Object.defineProperty(e, n, { + enumerable: !0, + get: function () { + return t[r]; + }, + })); + } + : function (e, t, r, n) { + (void 0 === n && (n = r), (e[n] = t[r])); + }, + i = Object.create + ? function (e, t) { + Object.defineProperty(e, "default", { + enumerable: !0, + value: t, + }); + } + : function (e, t) { + e.default = t; + }, + s = function (e) { + if (e && e.__esModule) return e; + var t = {}; + if (null != e) + for (var r in e) + "default" !== r && + Object.prototype.hasOwnProperty.call(e, r) && + n(t, e, r); + return (i(t, e), t); + }, + o = function (e, t) { + for (var r in e) + "default" === r || + Object.prototype.hasOwnProperty.call(t, r) || + n(t, e, r); + }; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.parseString = + r.parseFile = + r.parseStream = + r.parse = + r.ParserOptions = + r.CsvParserStream = + void 0)); + const a = s(e("fs")), + l = e("stream"), + c = e("./ParserOptions"), + u = e("./CsvParserStream"); + o(e("./types"), r); + var h = e("./CsvParserStream"); + Object.defineProperty(r, "CsvParserStream", { + enumerable: !0, + get: function () { + return h.CsvParserStream; + }, + }); + var f = e("./ParserOptions"); + (Object.defineProperty(r, "ParserOptions", { + enumerable: !0, + get: function () { + return f.ParserOptions; + }, + }), + (r.parse = (e) => new u.CsvParserStream(new c.ParserOptions(e))), + (r.parseStream = (e, t) => + e.pipe(new u.CsvParserStream(new c.ParserOptions(t)))), + (r.parseFile = function (e) { + let t = + arguments.length > 1 && void 0 !== arguments[1] + ? arguments[1] + : {}; + return a + .createReadStream(e) + .pipe(new u.CsvParserStream(new c.ParserOptions(t))); + }), + (r.parseString = (e, t) => { + const r = new l.Readable(); + return ( + r.push(e), + r.push(null), + r.pipe(new u.CsvParserStream(new c.ParserOptions(t))) + ); + })); + }, + { + "./CsvParserStream": 153, + "./ParserOptions": 154, + "./types": 169, + fs: 216, + stream: 505, + }, + ], + 156: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.Parser = void 0)); + const n = e("./Scanner"), + i = e("./RowParser"), + s = e("./Token"); + class o { + constructor(e) { + ((this.parserOptions = e), + (this.rowParser = new i.RowParser(this.parserOptions))); + } + static removeBOM(e) { + return e && 65279 === e.charCodeAt(0) ? e.slice(1) : e; + } + parse(e, t) { + const r = new n.Scanner({ + line: o.removeBOM(e), + parserOptions: this.parserOptions, + hasMoreData: t, + }); + return this.parserOptions.supportsComments + ? this.parseWithComments(r) + : this.parseWithoutComments(r); + } + parseWithoutComments(e) { + const t = []; + let r = !0; + for (; r; ) r = this.parseRow(e, t); + return { line: e.line, rows: t }; + } + parseWithComments(e) { + const { parserOptions: t } = this, + r = []; + for ( + let n = e.nextCharacterToken; + null !== n; + n = e.nextCharacterToken + ) + if (s.Token.isTokenComment(n, t)) { + if (null === e.advancePastLine()) + return { line: e.lineFromCursor, rows: r }; + if (!e.hasMoreCharacters) + return { line: e.lineFromCursor, rows: r }; + e.truncateToCursor(); + } else if (!this.parseRow(e, r)) break; + return { line: e.line, rows: r }; + } + parseRow(e, t) { + if (!e.nextNonSpaceToken) return !1; + const r = this.rowParser.parse(e); + return ( + null !== r && + ((this.parserOptions.ignoreEmpty && + i.RowParser.isEmptyRow(r)) || + t.push(r), + !0) + ); + } + } + r.Parser = o; + }, + { "./RowParser": 157, "./Scanner": 158, "./Token": 159 }, + ], + 157: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.RowParser = void 0)); + const n = e("./column"), + i = e("./Token"); + r.RowParser = class { + constructor(e) { + ((this.parserOptions = e), + (this.columnParser = new n.ColumnParser(e))); + } + static isEmptyRow(e) { + return "" === e.join("").replace(/\s+/g, ""); + } + parse(e) { + const { parserOptions: t } = this, + { hasMoreData: r } = e, + n = e, + s = []; + let o = this.getStartToken(n, s); + for (; o; ) { + if (i.Token.isTokenRowDelimiter(o)) + return ( + n.advancePastToken(o), + !n.hasMoreCharacters && + i.Token.isTokenCarriageReturn(o, t) && + r + ? null + : (n.truncateToCursor(), s) + ); + if (!this.shouldSkipColumnParse(n, o, s)) { + const e = this.columnParser.parse(n); + if (null === e) return null; + s.push(e); + } + o = n.nextNonSpaceToken; + } + return r ? null : (n.truncateToCursor(), s); + } + getStartToken(e, t) { + const r = e.nextNonSpaceToken; + return null !== r && + i.Token.isTokenDelimiter(r, this.parserOptions) + ? (t.push(""), e.nextNonSpaceToken) + : r; + } + shouldSkipColumnParse(e, t, r) { + const { parserOptions: n } = this; + if (i.Token.isTokenDelimiter(t, n)) { + e.advancePastToken(t); + const s = e.nextCharacterToken; + if ( + !e.hasMoreCharacters || + (null !== s && i.Token.isTokenRowDelimiter(s)) + ) + return (r.push(""), !0); + if (null !== s && i.Token.isTokenDelimiter(s, n)) + return (r.push(""), !0); + } + return !1; + } + }; + }, + { "./Token": 159, "./column": 164 }, + ], + 158: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.Scanner = void 0)); + const n = e("./Token"), + i = /((?:\r\n)|\n|\r)/; + r.Scanner = class { + constructor(e) { + ((this.cursor = 0), + (this.line = e.line), + (this.lineLength = this.line.length), + (this.parserOptions = e.parserOptions), + (this.hasMoreData = e.hasMoreData), + (this.cursor = e.cursor || 0)); + } + get hasMoreCharacters() { + return this.lineLength > this.cursor; + } + get nextNonSpaceToken() { + const { lineFromCursor: e } = this, + t = this.parserOptions.NEXT_TOKEN_REGEXP; + if (-1 === e.search(t)) return null; + const r = t.exec(e); + if (null == r) return null; + const i = r[1], + s = this.cursor + (r.index || 0); + return new n.Token({ + token: i, + startCursor: s, + endCursor: s + i.length - 1, + }); + } + get nextCharacterToken() { + const { cursor: e, lineLength: t } = this; + return t <= e + ? null + : new n.Token({ + token: this.line[e], + startCursor: e, + endCursor: e, + }); + } + get lineFromCursor() { + return this.line.substr(this.cursor); + } + advancePastLine() { + const e = i.exec(this.lineFromCursor); + return e + ? ((this.cursor += (e.index || 0) + e[0].length), this) + : this.hasMoreData + ? null + : ((this.cursor = this.lineLength), this); + } + advanceTo(e) { + return ((this.cursor = e), this); + } + advanceToToken(e) { + return ((this.cursor = e.startCursor), this); + } + advancePastToken(e) { + return ((this.cursor = e.endCursor + 1), this); + } + truncateToCursor() { + return ( + (this.line = this.lineFromCursor), + (this.lineLength = this.line.length), + (this.cursor = 0), + this + ); + } + }; + }, + { "./Token": 159 }, + ], + 159: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.Token = void 0)); + r.Token = class { + constructor(e) { + ((this.token = e.token), + (this.startCursor = e.startCursor), + (this.endCursor = e.endCursor)); + } + static isTokenRowDelimiter(e) { + const t = e.token; + return "\r" === t || "\n" === t || "\r\n" === t; + } + static isTokenCarriageReturn(e, t) { + return e.token === t.carriageReturn; + } + static isTokenComment(e, t) { + return t.supportsComments && !!e && e.token === t.comment; + } + static isTokenEscapeCharacter(e, t) { + return e.token === t.escapeChar; + } + static isTokenQuote(e, t) { + return e.token === t.quote; + } + static isTokenDelimiter(e, t) { + return e.token === t.delimiter; + } + }; + }, + {}, + ], + 160: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.ColumnFormatter = void 0)); + r.ColumnFormatter = class { + constructor(e) { + e.trim + ? (this.format = (e) => e.trim()) + : e.ltrim + ? (this.format = (e) => e.trimLeft()) + : e.rtrim + ? (this.format = (e) => e.trimRight()) + : (this.format = (e) => e); + } + }; + }, + {}, + ], + 161: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.ColumnParser = void 0)); + const n = e("./NonQuotedColumnParser"), + i = e("./QuotedColumnParser"), + s = e("../Token"); + r.ColumnParser = class { + constructor(e) { + ((this.parserOptions = e), + (this.quotedColumnParser = new i.QuotedColumnParser(e)), + (this.nonQuotedColumnParser = new n.NonQuotedColumnParser(e))); + } + parse(e) { + const { nextNonSpaceToken: t } = e; + return null !== t && s.Token.isTokenQuote(t, this.parserOptions) + ? (e.advanceToToken(t), this.quotedColumnParser.parse(e)) + : this.nonQuotedColumnParser.parse(e); + } + }; + }, + { + "../Token": 159, + "./NonQuotedColumnParser": 162, + "./QuotedColumnParser": 163, + }, + ], + 162: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.NonQuotedColumnParser = void 0)); + const n = e("./ColumnFormatter"), + i = e("../Token"); + r.NonQuotedColumnParser = class { + constructor(e) { + ((this.parserOptions = e), + (this.columnFormatter = new n.ColumnFormatter(e))); + } + parse(e) { + if (!e.hasMoreCharacters) return null; + const { parserOptions: t } = this, + r = []; + let n = e.nextCharacterToken; + for ( + ; + n && + !i.Token.isTokenDelimiter(n, t) && + !i.Token.isTokenRowDelimiter(n); + n = e.nextCharacterToken + ) + (r.push(n.token), e.advancePastToken(n)); + return this.columnFormatter.format(r.join("")); + } + }; + }, + { "../Token": 159, "./ColumnFormatter": 160 }, + ], + 163: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.QuotedColumnParser = void 0)); + const n = e("./ColumnFormatter"), + i = e("../Token"); + r.QuotedColumnParser = class { + constructor(e) { + ((this.parserOptions = e), + (this.columnFormatter = new n.ColumnFormatter(e))); + } + parse(e) { + if (!e.hasMoreCharacters) return null; + const t = e.cursor, + { foundClosingQuote: r, col: n } = + this.gatherDataBetweenQuotes(e); + if (!r) { + if ((e.advanceTo(t), !e.hasMoreData)) + throw new Error( + `Parse Error: missing closing: '${this.parserOptions.quote || ""}' in line: at '${e.lineFromCursor.replace(/[\r\n]/g, "\\n'")}'`, + ); + return null; + } + return (this.checkForMalformedColumn(e), n); + } + gatherDataBetweenQuotes(e) { + const { parserOptions: t } = this; + let r = !1, + n = !1; + const s = []; + let o = e.nextCharacterToken; + for (; !n && null !== o; o = e.nextCharacterToken) { + const a = i.Token.isTokenQuote(o, t); + if (!r && a) r = !0; + else if (r) + if (i.Token.isTokenEscapeCharacter(o, t)) { + e.advancePastToken(o); + const r = e.nextCharacterToken; + null !== r && + (i.Token.isTokenQuote(r, t) || + i.Token.isTokenEscapeCharacter(r, t)) + ? (s.push(r.token), (o = r)) + : a + ? (n = !0) + : s.push(o.token); + } else a ? (n = !0) : s.push(o.token); + e.advancePastToken(o); + } + return { + col: this.columnFormatter.format(s.join("")), + foundClosingQuote: n, + }; + } + checkForMalformedColumn(e) { + const { parserOptions: t } = this, + { nextNonSpaceToken: r } = e; + if (r) { + const n = i.Token.isTokenDelimiter(r, t), + s = i.Token.isTokenRowDelimiter(r); + if (!n && !s) { + const n = e.lineFromCursor + .substr(0, 10) + .replace(/[\r\n]/g, "\\n'"); + throw new Error( + `Parse Error: expected: '${t.escapedDelimiter}' OR new line got: '${r.token}'. at '${n}`, + ); + } + e.advanceToToken(r); + } else e.hasMoreData || e.advancePastLine(); + } + }; + }, + { "../Token": 159, "./ColumnFormatter": 160 }, + ], + 164: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.ColumnFormatter = + r.QuotedColumnParser = + r.NonQuotedColumnParser = + r.ColumnParser = + void 0)); + var n = e("./ColumnParser"); + Object.defineProperty(r, "ColumnParser", { + enumerable: !0, + get: function () { + return n.ColumnParser; + }, + }); + var i = e("./NonQuotedColumnParser"); + Object.defineProperty(r, "NonQuotedColumnParser", { + enumerable: !0, + get: function () { + return i.NonQuotedColumnParser; + }, + }); + var s = e("./QuotedColumnParser"); + Object.defineProperty(r, "QuotedColumnParser", { + enumerable: !0, + get: function () { + return s.QuotedColumnParser; + }, + }); + var o = e("./ColumnFormatter"); + Object.defineProperty(r, "ColumnFormatter", { + enumerable: !0, + get: function () { + return o.ColumnFormatter; + }, + }); + }, + { + "./ColumnFormatter": 160, + "./ColumnParser": 161, + "./NonQuotedColumnParser": 162, + "./QuotedColumnParser": 163, + }, + ], + 165: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.QuotedColumnParser = + r.NonQuotedColumnParser = + r.ColumnParser = + r.Token = + r.Scanner = + r.RowParser = + r.Parser = + void 0)); + var n = e("./Parser"); + Object.defineProperty(r, "Parser", { + enumerable: !0, + get: function () { + return n.Parser; + }, + }); + var i = e("./RowParser"); + Object.defineProperty(r, "RowParser", { + enumerable: !0, + get: function () { + return i.RowParser; + }, + }); + var s = e("./Scanner"); + Object.defineProperty(r, "Scanner", { + enumerable: !0, + get: function () { + return s.Scanner; + }, + }); + var o = e("./Token"); + Object.defineProperty(r, "Token", { + enumerable: !0, + get: function () { + return o.Token; + }, + }); + var a = e("./column"); + (Object.defineProperty(r, "ColumnParser", { + enumerable: !0, + get: function () { + return a.ColumnParser; + }, + }), + Object.defineProperty(r, "NonQuotedColumnParser", { + enumerable: !0, + get: function () { + return a.NonQuotedColumnParser; + }, + }), + Object.defineProperty(r, "QuotedColumnParser", { + enumerable: !0, + get: function () { + return a.QuotedColumnParser; + }, + })); + }, + { + "./Parser": 156, + "./RowParser": 157, + "./Scanner": 158, + "./Token": 159, + "./column": 164, + }, + ], + 166: [ + function (e, t, r) { + "use strict"; + var n = function (e) { + return e && e.__esModule ? e : { default: e }; + }; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.HeaderTransformer = void 0)); + const i = n(e("lodash.isundefined")), + s = n(e("lodash.isfunction")), + o = n(e("lodash.uniq")), + a = n(e("lodash.groupby")); + r.HeaderTransformer = class { + constructor(e) { + ((this.headers = null), + (this.receivedHeaders = !1), + (this.shouldUseFirstRow = !1), + (this.processedFirstRow = !1), + (this.headersLength = 0), + (this.parserOptions = e), + !0 === e.headers + ? (this.shouldUseFirstRow = !0) + : Array.isArray(e.headers) + ? this.setHeaders(e.headers) + : s.default(e.headers) && + (this.headersTransform = e.headers)); + } + transform(e, t) { + return this.shouldMapRow(e) + ? t(null, this.processRow(e)) + : t(null, { row: null, isValid: !0 }); + } + shouldMapRow(e) { + const { parserOptions: t } = this; + if ( + !this.headersTransform && + t.renameHeaders && + !this.processedFirstRow + ) { + if (!this.receivedHeaders) + throw new Error( + "Error renaming headers: new headers must be provided in an array", + ); + return ((this.processedFirstRow = !0), !1); + } + if (!this.receivedHeaders && Array.isArray(e)) { + if (this.headersTransform) + this.setHeaders(this.headersTransform(e)); + else { + if (!this.shouldUseFirstRow) return !0; + this.setHeaders(e); + } + return !1; + } + return !0; + } + processRow(e) { + if (!this.headers) return { row: e, isValid: !0 }; + const { parserOptions: t } = this; + if (!t.discardUnmappedColumns && e.length > this.headersLength) { + if (!t.strictColumnHandling) + throw new Error( + `Unexpected Error: column header mismatch expected: ${this.headersLength} columns got: ${e.length}`, + ); + return { + row: e, + isValid: !1, + reason: `Column header mismatch expected: ${this.headersLength} columns got: ${e.length}`, + }; + } + return t.strictColumnHandling && e.length < this.headersLength + ? { + row: e, + isValid: !1, + reason: `Column header mismatch expected: ${this.headersLength} columns got: ${e.length}`, + } + : { row: this.mapHeaders(e), isValid: !0 }; + } + mapHeaders(e) { + const t = {}, + { headers: r, headersLength: n } = this; + for (let s = 0; s < n; s += 1) { + const n = r[s]; + if (!i.default(n)) { + const r = e[s]; + i.default(r) ? (t[n] = "") : (t[n] = r); + } + } + return t; + } + setHeaders(e) { + var t; + const r = e.filter((e) => !!e); + if (o.default(r).length !== r.length) { + const e = a.default(r), + t = Object.keys(e).filter((t) => e[t].length > 1); + throw new Error("Duplicate headers found " + JSON.stringify(t)); + } + ((this.headers = e), + (this.receivedHeaders = !0), + (this.headersLength = + (null === (t = this.headers) || void 0 === t + ? void 0 + : t.length) || 0)); + } + }; + }, + { + "lodash.groupby": 443, + "lodash.isfunction": 446, + "lodash.isundefined": 448, + "lodash.uniq": 449, + }, + ], + 167: [ + function (e, t, r) { + "use strict"; + var n = function (e) { + return e && e.__esModule ? e : { default: e }; + }; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.RowTransformerValidator = void 0)); + const i = n(e("lodash.isfunction")), + s = e("../types"); + class o { + constructor() { + ((this._rowTransform = null), (this._rowValidator = null)); + } + static createTransform(e) { + return s.isSyncTransform(e) + ? (t, r) => { + let n = null; + try { + n = e(t); + } catch (e) { + return r(e); + } + return r(null, n); + } + : e; + } + static createValidator(e) { + return s.isSyncValidate(e) + ? (t, r) => { + r(null, { row: t, isValid: e(t) }); + } + : (t, r) => { + e(t, (e, n, i) => + e + ? r(e) + : r( + null, + n + ? { row: t, isValid: n, reason: i } + : { row: t, isValid: !1, reason: i }, + ), + ); + }; + } + set rowTransform(e) { + if (!i.default(e)) + throw new TypeError("The transform should be a function"); + this._rowTransform = o.createTransform(e); + } + set rowValidator(e) { + if (!i.default(e)) + throw new TypeError("The validate should be a function"); + this._rowValidator = o.createValidator(e); + } + transformAndValidate(e, t) { + return this.callTransformer(e, (e, r) => + e + ? t(e) + : r + ? this.callValidator(r, (e, n) => + e + ? t(e) + : n && !n.isValid + ? t(null, { row: r, isValid: !1, reason: n.reason }) + : t(null, { row: r, isValid: !0 }), + ) + : t(null, { row: null, isValid: !0 }), + ); + } + callTransformer(e, t) { + return this._rowTransform ? this._rowTransform(e, t) : t(null, e); + } + callValidator(e, t) { + return this._rowValidator + ? this._rowValidator(e, t) + : t(null, { row: e, isValid: !0 }); + } + } + r.RowTransformerValidator = o; + }, + { "../types": 169, "lodash.isfunction": 446 }, + ], + 168: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.HeaderTransformer = r.RowTransformerValidator = void 0)); + var n = e("./RowTransformerValidator"); + Object.defineProperty(r, "RowTransformerValidator", { + enumerable: !0, + get: function () { + return n.RowTransformerValidator; + }, + }); + var i = e("./HeaderTransformer"); + Object.defineProperty(r, "HeaderTransformer", { + enumerable: !0, + get: function () { + return i.HeaderTransformer; + }, + }); + }, + { "./HeaderTransformer": 166, "./RowTransformerValidator": 167 }, + ], + 169: [ + function (e, t, r) { + "use strict"; + (Object.defineProperty(r, "__esModule", { value: !0 }), + (r.isSyncValidate = r.isSyncTransform = void 0), + (r.isSyncTransform = (e) => 1 === e.length), + (r.isSyncValidate = (e) => 1 === e.length)); + }, + {}, + ], + 170: [ + function (e, t, r) { + "use strict"; + const n = r; + ((n.bignum = e("bn.js")), + (n.define = e("./asn1/api").define), + (n.base = e("./asn1/base")), + (n.constants = e("./asn1/constants")), + (n.decoders = e("./asn1/decoders")), + (n.encoders = e("./asn1/encoders"))); + }, + { + "./asn1/api": 171, + "./asn1/base": 173, + "./asn1/constants": 177, + "./asn1/decoders": 179, + "./asn1/encoders": 182, + "bn.js": 184, + }, + ], + 171: [ + function (e, t, r) { + "use strict"; + const n = e("./encoders"), + i = e("./decoders"), + s = e("inherits"); + function o(e, t) { + ((this.name = e), + (this.body = t), + (this.decoders = {}), + (this.encoders = {})); + } + ((r.define = function (e, t) { + return new o(e, t); + }), + (o.prototype._createNamed = function (e) { + const t = this.name; + function r(e) { + this._initNamed(e, t); + } + return ( + s(r, e), + (r.prototype._initNamed = function (t, r) { + e.call(this, t, r); + }), + new r(this) + ); + }), + (o.prototype._getDecoder = function (e) { + return ( + (e = e || "der"), + this.decoders.hasOwnProperty(e) || + (this.decoders[e] = this._createNamed(i[e])), + this.decoders[e] + ); + }), + (o.prototype.decode = function (e, t, r) { + return this._getDecoder(t).decode(e, r); + }), + (o.prototype._getEncoder = function (e) { + return ( + (e = e || "der"), + this.encoders.hasOwnProperty(e) || + (this.encoders[e] = this._createNamed(n[e])), + this.encoders[e] + ); + }), + (o.prototype.encode = function (e, t, r) { + return this._getEncoder(t).encode(e, r); + })); + }, + { "./decoders": 179, "./encoders": 182, inherits: 440 }, + ], + 172: [ + function (e, t, r) { + "use strict"; + const n = e("inherits"), + i = e("../base/reporter").Reporter, + s = e("safer-buffer").Buffer; + function o(e, t) { + (i.call(this, t), + s.isBuffer(e) + ? ((this.base = e), (this.offset = 0), (this.length = e.length)) + : this.error("Input not Buffer")); + } + function a(e, t) { + if (Array.isArray(e)) + ((this.length = 0), + (this.value = e.map(function (e) { + return ( + a.isEncoderBuffer(e) || (e = new a(e, t)), + (this.length += e.length), + e + ); + }, this))); + else if ("number" == typeof e) { + if (!(0 <= e && e <= 255)) + return t.error("non-byte EncoderBuffer value"); + ((this.value = e), (this.length = 1)); + } else if ("string" == typeof e) + ((this.value = e), (this.length = s.byteLength(e))); + else { + if (!s.isBuffer(e)) + return t.error("Unsupported type: " + typeof e); + ((this.value = e), (this.length = e.length)); + } + } + (n(o, i), + (r.DecoderBuffer = o), + (o.isDecoderBuffer = function (e) { + if (e instanceof o) return !0; + return ( + "object" == typeof e && + s.isBuffer(e.base) && + "DecoderBuffer" === e.constructor.name && + "number" == typeof e.offset && + "number" == typeof e.length && + "function" == typeof e.save && + "function" == typeof e.restore && + "function" == typeof e.isEmpty && + "function" == typeof e.readUInt8 && + "function" == typeof e.skip && + "function" == typeof e.raw + ); + }), + (o.prototype.save = function () { + return { + offset: this.offset, + reporter: i.prototype.save.call(this), + }; + }), + (o.prototype.restore = function (e) { + const t = new o(this.base); + return ( + (t.offset = e.offset), + (t.length = this.offset), + (this.offset = e.offset), + i.prototype.restore.call(this, e.reporter), + t + ); + }), + (o.prototype.isEmpty = function () { + return this.offset === this.length; + }), + (o.prototype.readUInt8 = function (e) { + return this.offset + 1 <= this.length + ? this.base.readUInt8(this.offset++, !0) + : this.error(e || "DecoderBuffer overrun"); + }), + (o.prototype.skip = function (e, t) { + if (!(this.offset + e <= this.length)) + return this.error(t || "DecoderBuffer overrun"); + const r = new o(this.base); + return ( + (r._reporterState = this._reporterState), + (r.offset = this.offset), + (r.length = this.offset + e), + (this.offset += e), + r + ); + }), + (o.prototype.raw = function (e) { + return this.base.slice(e ? e.offset : this.offset, this.length); + }), + (r.EncoderBuffer = a), + (a.isEncoderBuffer = function (e) { + if (e instanceof a) return !0; + return ( + "object" == typeof e && + "EncoderBuffer" === e.constructor.name && + "number" == typeof e.length && + "function" == typeof e.join + ); + }), + (a.prototype.join = function (e, t) { + return ( + e || (e = s.alloc(this.length)), + t || (t = 0), + 0 === this.length || + (Array.isArray(this.value) + ? this.value.forEach(function (r) { + (r.join(e, t), (t += r.length)); + }) + : ("number" == typeof this.value + ? (e[t] = this.value) + : "string" == typeof this.value + ? e.write(this.value, t) + : s.isBuffer(this.value) && this.value.copy(e, t), + (t += this.length))), + e + ); + })); + }, + { "../base/reporter": 175, inherits: 440, "safer-buffer": 495 }, + ], + 173: [ + function (e, t, r) { + "use strict"; + const n = r; + ((n.Reporter = e("./reporter").Reporter), + (n.DecoderBuffer = e("./buffer").DecoderBuffer), + (n.EncoderBuffer = e("./buffer").EncoderBuffer), + (n.Node = e("./node"))); + }, + { "./buffer": 172, "./node": 174, "./reporter": 175 }, + ], + 174: [ + function (e, t, r) { + "use strict"; + const n = e("../base/reporter").Reporter, + i = e("../base/buffer").EncoderBuffer, + s = e("../base/buffer").DecoderBuffer, + o = e("minimalistic-assert"), + a = [ + "seq", + "seqof", + "set", + "setof", + "objid", + "bool", + "gentime", + "utctime", + "null_", + "enum", + "int", + "objDesc", + "bitstr", + "bmpstr", + "charstr", + "genstr", + "graphstr", + "ia5str", + "iso646str", + "numstr", + "octstr", + "printstr", + "t61str", + "unistr", + "utf8str", + "videostr", + ], + l = [ + "key", + "obj", + "use", + "optional", + "explicit", + "implicit", + "def", + "choice", + "any", + "contains", + ].concat(a); + function c(e, t, r) { + const n = {}; + ((this._baseState = n), + (n.name = r), + (n.enc = e), + (n.parent = t || null), + (n.children = null), + (n.tag = null), + (n.args = null), + (n.reverseArgs = null), + (n.choice = null), + (n.optional = !1), + (n.any = !1), + (n.obj = !1), + (n.use = null), + (n.useDecoder = null), + (n.key = null), + (n.default = null), + (n.explicit = null), + (n.implicit = null), + (n.contains = null), + n.parent || ((n.children = []), this._wrap())); + } + t.exports = c; + const u = [ + "enc", + "parent", + "children", + "tag", + "args", + "reverseArgs", + "choice", + "optional", + "any", + "obj", + "use", + "alteredUse", + "key", + "default", + "explicit", + "implicit", + "contains", + ]; + ((c.prototype.clone = function () { + const e = this._baseState, + t = {}; + u.forEach(function (r) { + t[r] = e[r]; + }); + const r = new this.constructor(t.parent); + return ((r._baseState = t), r); + }), + (c.prototype._wrap = function () { + const e = this._baseState; + l.forEach(function (t) { + this[t] = function () { + const r = new this.constructor(this); + return (e.children.push(r), r[t].apply(r, arguments)); + }; + }, this); + }), + (c.prototype._init = function (e) { + const t = this._baseState; + (o(null === t.parent), + e.call(this), + (t.children = t.children.filter(function (e) { + return e._baseState.parent === this; + }, this)), + o.equal( + t.children.length, + 1, + "Root node can have only one child", + )); + }), + (c.prototype._useArgs = function (e) { + const t = this._baseState, + r = e.filter(function (e) { + return e instanceof this.constructor; + }, this); + ((e = e.filter(function (e) { + return !(e instanceof this.constructor); + }, this)), + 0 !== r.length && + (o(null === t.children), + (t.children = r), + r.forEach(function (e) { + e._baseState.parent = this; + }, this)), + 0 !== e.length && + (o(null === t.args), + (t.args = e), + (t.reverseArgs = e.map(function (e) { + if ("object" != typeof e || e.constructor !== Object) + return e; + const t = {}; + return ( + Object.keys(e).forEach(function (r) { + r == (0 | r) && (r |= 0); + const n = e[r]; + t[n] = r; + }), + t + ); + })))); + }), + [ + "_peekTag", + "_decodeTag", + "_use", + "_decodeStr", + "_decodeObjid", + "_decodeTime", + "_decodeNull", + "_decodeInt", + "_decodeBool", + "_decodeList", + "_encodeComposite", + "_encodeStr", + "_encodeObjid", + "_encodeTime", + "_encodeNull", + "_encodeInt", + "_encodeBool", + ].forEach(function (e) { + c.prototype[e] = function () { + const t = this._baseState; + throw new Error(e + " not implemented for encoding: " + t.enc); + }; + }), + a.forEach(function (e) { + c.prototype[e] = function () { + const t = this._baseState, + r = Array.prototype.slice.call(arguments); + return (o(null === t.tag), (t.tag = e), this._useArgs(r), this); + }; + }), + (c.prototype.use = function (e) { + o(e); + const t = this._baseState; + return (o(null === t.use), (t.use = e), this); + }), + (c.prototype.optional = function () { + return ((this._baseState.optional = !0), this); + }), + (c.prototype.def = function (e) { + const t = this._baseState; + return ( + o(null === t.default), + (t.default = e), + (t.optional = !0), + this + ); + }), + (c.prototype.explicit = function (e) { + const t = this._baseState; + return ( + o(null === t.explicit && null === t.implicit), + (t.explicit = e), + this + ); + }), + (c.prototype.implicit = function (e) { + const t = this._baseState; + return ( + o(null === t.explicit && null === t.implicit), + (t.implicit = e), + this + ); + }), + (c.prototype.obj = function () { + const e = this._baseState, + t = Array.prototype.slice.call(arguments); + return ((e.obj = !0), 0 !== t.length && this._useArgs(t), this); + }), + (c.prototype.key = function (e) { + const t = this._baseState; + return (o(null === t.key), (t.key = e), this); + }), + (c.prototype.any = function () { + return ((this._baseState.any = !0), this); + }), + (c.prototype.choice = function (e) { + const t = this._baseState; + return ( + o(null === t.choice), + (t.choice = e), + this._useArgs( + Object.keys(e).map(function (t) { + return e[t]; + }), + ), + this + ); + }), + (c.prototype.contains = function (e) { + const t = this._baseState; + return (o(null === t.use), (t.contains = e), this); + }), + (c.prototype._decode = function (e, t) { + const r = this._baseState; + if (null === r.parent) + return e.wrapResult(r.children[0]._decode(e, t)); + let n, + i = r.default, + o = !0, + a = null; + if ((null !== r.key && (a = e.enterKey(r.key)), r.optional)) { + let n = null; + if ( + (null !== r.explicit + ? (n = r.explicit) + : null !== r.implicit + ? (n = r.implicit) + : null !== r.tag && (n = r.tag), + null !== n || r.any) + ) { + if (((o = this._peekTag(e, n, r.any)), e.isError(o))) + return o; + } else { + const n = e.save(); + try { + (null === r.choice + ? this._decodeGeneric(r.tag, e, t) + : this._decodeChoice(e, t), + (o = !0)); + } catch (e) { + o = !1; + } + e.restore(n); + } + } + if ((r.obj && o && (n = e.enterObject()), o)) { + if (null !== r.explicit) { + const t = this._decodeTag(e, r.explicit); + if (e.isError(t)) return t; + e = t; + } + const n = e.offset; + if (null === r.use && null === r.choice) { + let t; + r.any && (t = e.save()); + const n = this._decodeTag( + e, + null !== r.implicit ? r.implicit : r.tag, + r.any, + ); + if (e.isError(n)) return n; + r.any ? (i = e.raw(t)) : (e = n); + } + if ( + (t && + t.track && + null !== r.tag && + t.track(e.path(), n, e.length, "tagged"), + t && + t.track && + null !== r.tag && + t.track(e.path(), e.offset, e.length, "content"), + r.any || + (i = + null === r.choice + ? this._decodeGeneric(r.tag, e, t) + : this._decodeChoice(e, t)), + e.isError(i)) + ) + return i; + if ( + (r.any || + null !== r.choice || + null === r.children || + r.children.forEach(function (r) { + r._decode(e, t); + }), + r.contains && ("octstr" === r.tag || "bitstr" === r.tag)) + ) { + const n = new s(i); + i = this._getUse(r.contains, e._reporterState.obj)._decode( + n, + t, + ); + } + } + return ( + r.obj && o && (i = e.leaveObject(n)), + null === r.key || (null === i && !0 !== o) + ? null !== a && e.exitKey(a) + : e.leaveKey(a, r.key, i), + i + ); + }), + (c.prototype._decodeGeneric = function (e, t, r) { + const n = this._baseState; + return "seq" === e || "set" === e + ? null + : "seqof" === e || "setof" === e + ? this._decodeList(t, e, n.args[0], r) + : /str$/.test(e) + ? this._decodeStr(t, e, r) + : "objid" === e && n.args + ? this._decodeObjid(t, n.args[0], n.args[1], r) + : "objid" === e + ? this._decodeObjid(t, null, null, r) + : "gentime" === e || "utctime" === e + ? this._decodeTime(t, e, r) + : "null_" === e + ? this._decodeNull(t, r) + : "bool" === e + ? this._decodeBool(t, r) + : "objDesc" === e + ? this._decodeStr(t, e, r) + : "int" === e || "enum" === e + ? this._decodeInt(t, n.args && n.args[0], r) + : null !== n.use + ? this._getUse( + n.use, + t._reporterState.obj, + )._decode(t, r) + : t.error("unknown tag: " + e); + }), + (c.prototype._getUse = function (e, t) { + const r = this._baseState; + return ( + (r.useDecoder = this._use(e, t)), + o(null === r.useDecoder._baseState.parent), + (r.useDecoder = r.useDecoder._baseState.children[0]), + r.implicit !== r.useDecoder._baseState.implicit && + ((r.useDecoder = r.useDecoder.clone()), + (r.useDecoder._baseState.implicit = r.implicit)), + r.useDecoder + ); + }), + (c.prototype._decodeChoice = function (e, t) { + const r = this._baseState; + let n = null, + i = !1; + return ( + Object.keys(r.choice).some(function (s) { + const o = e.save(), + a = r.choice[s]; + try { + const r = a._decode(e, t); + if (e.isError(r)) return !1; + ((n = { type: s, value: r }), (i = !0)); + } catch (t) { + return (e.restore(o), !1); + } + return !0; + }, this), + i ? n : e.error("Choice not matched") + ); + }), + (c.prototype._createEncoderBuffer = function (e) { + return new i(e, this.reporter); + }), + (c.prototype._encode = function (e, t, r) { + const n = this._baseState; + if (null !== n.default && n.default === e) return; + const i = this._encodeValue(e, t, r); + return void 0 === i || this._skipDefault(i, t, r) ? void 0 : i; + }), + (c.prototype._encodeValue = function (e, t, r) { + const i = this._baseState; + if (null === i.parent) + return i.children[0]._encode(e, t || new n()); + let s = null; + if (((this.reporter = t), i.optional && void 0 === e)) { + if (null === i.default) return; + e = i.default; + } + let o = null, + a = !1; + if (i.any) s = this._createEncoderBuffer(e); + else if (i.choice) s = this._encodeChoice(e, t); + else if (i.contains) + ((o = this._getUse(i.contains, r)._encode(e, t)), (a = !0)); + else if (i.children) + ((o = i.children + .map(function (r) { + if ("null_" === r._baseState.tag) + return r._encode(null, t, e); + if (null === r._baseState.key) + return t.error("Child should have a key"); + const n = t.enterKey(r._baseState.key); + if ("object" != typeof e) + return t.error("Child expected, but input is not object"); + const i = r._encode(e[r._baseState.key], t, e); + return (t.leaveKey(n), i); + }, this) + .filter(function (e) { + return e; + })), + (o = this._createEncoderBuffer(o))); + else if ("seqof" === i.tag || "setof" === i.tag) { + if (!i.args || 1 !== i.args.length) + return t.error("Too many args for : " + i.tag); + if (!Array.isArray(e)) + return t.error("seqof/setof, but data is not Array"); + const r = this.clone(); + ((r._baseState.implicit = null), + (o = this._createEncoderBuffer( + e.map(function (r) { + const n = this._baseState; + return this._getUse(n.args[0], e)._encode(r, t); + }, r), + ))); + } else + null !== i.use + ? (s = this._getUse(i.use, r)._encode(e, t)) + : ((o = this._encodePrimitive(i.tag, e)), (a = !0)); + if (!i.any && null === i.choice) { + const e = null !== i.implicit ? i.implicit : i.tag, + r = null === i.implicit ? "universal" : "context"; + null === e + ? null === i.use && + t.error("Tag could be omitted only for .use()") + : null === i.use && (s = this._encodeComposite(e, a, r, o)); + } + return ( + null !== i.explicit && + (s = this._encodeComposite(i.explicit, !1, "context", s)), + s + ); + }), + (c.prototype._encodeChoice = function (e, t) { + const r = this._baseState, + n = r.choice[e.type]; + return ( + n || + o( + !1, + e.type + + " not found in " + + JSON.stringify(Object.keys(r.choice)), + ), + n._encode(e.value, t) + ); + }), + (c.prototype._encodePrimitive = function (e, t) { + const r = this._baseState; + if (/str$/.test(e)) return this._encodeStr(t, e); + if ("objid" === e && r.args) + return this._encodeObjid(t, r.reverseArgs[0], r.args[1]); + if ("objid" === e) return this._encodeObjid(t, null, null); + if ("gentime" === e || "utctime" === e) + return this._encodeTime(t, e); + if ("null_" === e) return this._encodeNull(); + if ("int" === e || "enum" === e) + return this._encodeInt(t, r.args && r.reverseArgs[0]); + if ("bool" === e) return this._encodeBool(t); + if ("objDesc" === e) return this._encodeStr(t, e); + throw new Error("Unsupported tag: " + e); + }), + (c.prototype._isNumstr = function (e) { + return /^[0-9 ]*$/.test(e); + }), + (c.prototype._isPrintstr = function (e) { + return /^[A-Za-z0-9 '()+,-./:=?]*$/.test(e); + })); + }, + { + "../base/buffer": 172, + "../base/reporter": 175, + "minimalistic-assert": 453, + }, + ], + 175: [ + function (e, t, r) { + "use strict"; + const n = e("inherits"); + function i(e) { + this._reporterState = { + obj: null, + path: [], + options: e || {}, + errors: [], + }; + } + function s(e, t) { + ((this.path = e), this.rethrow(t)); + } + ((r.Reporter = i), + (i.prototype.isError = function (e) { + return e instanceof s; + }), + (i.prototype.save = function () { + const e = this._reporterState; + return { obj: e.obj, pathLen: e.path.length }; + }), + (i.prototype.restore = function (e) { + const t = this._reporterState; + ((t.obj = e.obj), (t.path = t.path.slice(0, e.pathLen))); + }), + (i.prototype.enterKey = function (e) { + return this._reporterState.path.push(e); + }), + (i.prototype.exitKey = function (e) { + const t = this._reporterState; + t.path = t.path.slice(0, e - 1); + }), + (i.prototype.leaveKey = function (e, t, r) { + const n = this._reporterState; + (this.exitKey(e), null !== n.obj && (n.obj[t] = r)); + }), + (i.prototype.path = function () { + return this._reporterState.path.join("/"); + }), + (i.prototype.enterObject = function () { + const e = this._reporterState, + t = e.obj; + return ((e.obj = {}), t); + }), + (i.prototype.leaveObject = function (e) { + const t = this._reporterState, + r = t.obj; + return ((t.obj = e), r); + }), + (i.prototype.error = function (e) { + let t; + const r = this._reporterState, + n = e instanceof s; + if ( + ((t = n + ? e + : new s( + r.path + .map(function (e) { + return "[" + JSON.stringify(e) + "]"; + }) + .join(""), + e.message || e, + e.stack, + )), + !r.options.partial) + ) + throw t; + return (n || r.errors.push(t), t); + }), + (i.prototype.wrapResult = function (e) { + const t = this._reporterState; + return t.options.partial + ? { result: this.isError(e) ? null : e, errors: t.errors } + : e; + }), + n(s, Error), + (s.prototype.rethrow = function (e) { + if ( + ((this.message = e + " at: " + (this.path || "(shallow)")), + Error.captureStackTrace && Error.captureStackTrace(this, s), + !this.stack) + ) + try { + throw new Error(this.message); + } catch (e) { + this.stack = e.stack; + } + return this; + })); + }, + { inherits: 440 }, + ], + 176: [ + function (e, t, r) { + "use strict"; + function n(e) { + const t = {}; + return ( + Object.keys(e).forEach(function (r) { + (0 | r) == r && (r |= 0); + const n = e[r]; + t[n] = r; + }), + t + ); + } + ((r.tagClass = { + 0: "universal", + 1: "application", + 2: "context", + 3: "private", + }), + (r.tagClassByName = n(r.tagClass)), + (r.tag = { + 0: "end", + 1: "bool", + 2: "int", + 3: "bitstr", + 4: "octstr", + 5: "null_", + 6: "objid", + 7: "objDesc", + 8: "external", + 9: "real", + 10: "enum", + 11: "embed", + 12: "utf8str", + 13: "relativeOid", + 16: "seq", + 17: "set", + 18: "numstr", + 19: "printstr", + 20: "t61str", + 21: "videostr", + 22: "ia5str", + 23: "utctime", + 24: "gentime", + 25: "graphstr", + 26: "iso646str", + 27: "genstr", + 28: "unistr", + 29: "charstr", + 30: "bmpstr", + }), + (r.tagByName = n(r.tag))); + }, + {}, + ], + 177: [ + function (e, t, r) { + "use strict"; + const n = r; + ((n._reverse = function (e) { + const t = {}; + return ( + Object.keys(e).forEach(function (r) { + (0 | r) == r && (r |= 0); + const n = e[r]; + t[n] = r; + }), + t + ); + }), + (n.der = e("./der"))); + }, + { "./der": 176 }, + ], + 178: [ + function (e, t, r) { + "use strict"; + const n = e("inherits"), + i = e("bn.js"), + s = e("../base/buffer").DecoderBuffer, + o = e("../base/node"), + a = e("../constants/der"); + function l(e) { + ((this.enc = "der"), + (this.name = e.name), + (this.entity = e), + (this.tree = new c()), + this.tree._init(e.body)); + } + function c(e) { + o.call(this, "der", e); + } + function u(e, t) { + let r = e.readUInt8(t); + if (e.isError(r)) return r; + const n = a.tagClass[r >> 6], + i = 0 == (32 & r); + if (31 == (31 & r)) { + let n = r; + for (r = 0; 128 == (128 & n); ) { + if (((n = e.readUInt8(t)), e.isError(n))) return n; + ((r <<= 7), (r |= 127 & n)); + } + } else r &= 31; + return { cls: n, primitive: i, tag: r, tagStr: a.tag[r] }; + } + function h(e, t, r) { + let n = e.readUInt8(r); + if (e.isError(n)) return n; + if (!t && 128 === n) return null; + if (0 == (128 & n)) return n; + const i = 127 & n; + if (i > 4) return e.error("length octect is too long"); + n = 0; + for (let t = 0; t < i; t++) { + n <<= 8; + const t = e.readUInt8(r); + if (e.isError(t)) return t; + n |= t; + } + return n; + } + ((t.exports = l), + (l.prototype.decode = function (e, t) { + return ( + s.isDecoderBuffer(e) || (e = new s(e, t)), + this.tree._decode(e, t) + ); + }), + n(c, o), + (c.prototype._peekTag = function (e, t, r) { + if (e.isEmpty()) return !1; + const n = e.save(), + i = u(e, 'Failed to peek tag: "' + t + '"'); + return e.isError(i) + ? i + : (e.restore(n), + i.tag === t || i.tagStr === t || i.tagStr + "of" === t || r); + }), + (c.prototype._decodeTag = function (e, t, r) { + const n = u(e, 'Failed to decode tag of "' + t + '"'); + if (e.isError(n)) return n; + let i = h(e, n.primitive, 'Failed to get length of "' + t + '"'); + if (e.isError(i)) return i; + if (!r && n.tag !== t && n.tagStr !== t && n.tagStr + "of" !== t) + return e.error('Failed to match tag: "' + t + '"'); + if (n.primitive || null !== i) + return e.skip(i, 'Failed to match body of: "' + t + '"'); + const s = e.save(), + o = this._skipUntilEnd( + e, + 'Failed to skip indefinite length body: "' + this.tag + '"', + ); + return e.isError(o) + ? o + : ((i = e.offset - s.offset), + e.restore(s), + e.skip(i, 'Failed to match body of: "' + t + '"')); + }), + (c.prototype._skipUntilEnd = function (e, t) { + for (;;) { + const r = u(e, t); + if (e.isError(r)) return r; + const n = h(e, r.primitive, t); + if (e.isError(n)) return n; + let i; + if ( + ((i = + r.primitive || null !== n + ? e.skip(n) + : this._skipUntilEnd(e, t)), + e.isError(i)) + ) + return i; + if ("end" === r.tagStr) break; + } + }), + (c.prototype._decodeList = function (e, t, r, n) { + const i = []; + for (; !e.isEmpty(); ) { + const t = this._peekTag(e, "end"); + if (e.isError(t)) return t; + const s = r.decode(e, "der", n); + if (e.isError(s) && t) break; + i.push(s); + } + return i; + }), + (c.prototype._decodeStr = function (e, t) { + if ("bitstr" === t) { + const t = e.readUInt8(); + return e.isError(t) ? t : { unused: t, data: e.raw() }; + } + if ("bmpstr" === t) { + const t = e.raw(); + if (t.length % 2 == 1) + return e.error( + "Decoding of string type: bmpstr length mismatch", + ); + let r = ""; + for (let e = 0; e < t.length / 2; e++) + r += String.fromCharCode(t.readUInt16BE(2 * e)); + return r; + } + if ("numstr" === t) { + const t = e.raw().toString("ascii"); + return this._isNumstr(t) + ? t + : e.error( + "Decoding of string type: numstr unsupported characters", + ); + } + if ("octstr" === t) return e.raw(); + if ("objDesc" === t) return e.raw(); + if ("printstr" === t) { + const t = e.raw().toString("ascii"); + return this._isPrintstr(t) + ? t + : e.error( + "Decoding of string type: printstr unsupported characters", + ); + } + return /str$/.test(t) + ? e.raw().toString() + : e.error("Decoding of string type: " + t + " unsupported"); + }), + (c.prototype._decodeObjid = function (e, t, r) { + let n; + const i = []; + let s = 0, + o = 0; + for (; !e.isEmpty(); ) + ((o = e.readUInt8()), + (s <<= 7), + (s |= 127 & o), + 0 == (128 & o) && (i.push(s), (s = 0))); + 128 & o && i.push(s); + const a = (i[0] / 40) | 0, + l = i[0] % 40; + if (((n = r ? i : [a, l].concat(i.slice(1))), t)) { + let e = t[n.join(" ")]; + (void 0 === e && (e = t[n.join(".")]), void 0 !== e && (n = e)); + } + return n; + }), + (c.prototype._decodeTime = function (e, t) { + const r = e.raw().toString(); + let n, i, s, o, a, l; + if ("gentime" === t) + ((n = 0 | r.slice(0, 4)), + (i = 0 | r.slice(4, 6)), + (s = 0 | r.slice(6, 8)), + (o = 0 | r.slice(8, 10)), + (a = 0 | r.slice(10, 12)), + (l = 0 | r.slice(12, 14))); + else { + if ("utctime" !== t) + return e.error( + "Decoding " + t + " time is not supported yet", + ); + ((n = 0 | r.slice(0, 2)), + (i = 0 | r.slice(2, 4)), + (s = 0 | r.slice(4, 6)), + (o = 0 | r.slice(6, 8)), + (a = 0 | r.slice(8, 10)), + (l = 0 | r.slice(10, 12)), + (n = n < 70 ? 2e3 + n : 1900 + n)); + } + return Date.UTC(n, i - 1, s, o, a, l, 0); + }), + (c.prototype._decodeNull = function () { + return null; + }), + (c.prototype._decodeBool = function (e) { + const t = e.readUInt8(); + return e.isError(t) ? t : 0 !== t; + }), + (c.prototype._decodeInt = function (e, t) { + const r = e.raw(); + let n = new i(r); + return (t && (n = t[n.toString(10)] || n), n); + }), + (c.prototype._use = function (e, t) { + return ( + "function" == typeof e && (e = e(t)), + e._getDecoder("der").tree + ); + })); + }, + { + "../base/buffer": 172, + "../base/node": 174, + "../constants/der": 176, + "bn.js": 184, + inherits: 440, + }, + ], + 179: [ + function (e, t, r) { + "use strict"; + const n = r; + ((n.der = e("./der")), (n.pem = e("./pem"))); + }, + { "./der": 178, "./pem": 180 }, + ], + 180: [ + function (e, t, r) { + "use strict"; + const n = e("inherits"), + i = e("safer-buffer").Buffer, + s = e("./der"); + function o(e) { + (s.call(this, e), (this.enc = "pem")); + } + (n(o, s), + (t.exports = o), + (o.prototype.decode = function (e, t) { + const r = e.toString().split(/[\r\n]+/g), + n = t.label.toUpperCase(), + o = /^-----(BEGIN|END) ([^-]+)-----$/; + let a = -1, + l = -1; + for (let e = 0; e < r.length; e++) { + const t = r[e].match(o); + if (null !== t && t[2] === n) { + if (-1 !== a) { + if ("END" !== t[1]) break; + l = e; + break; + } + if ("BEGIN" !== t[1]) break; + a = e; + } + } + if (-1 === a || -1 === l) + throw new Error("PEM section not found for: " + n); + const c = r.slice(a + 1, l).join(""); + c.replace(/[^a-z0-9+/=]+/gi, ""); + const u = i.from(c, "base64"); + return s.prototype.decode.call(this, u, t); + })); + }, + { "./der": 178, inherits: 440, "safer-buffer": 495 }, + ], + 181: [ + function (e, t, r) { + "use strict"; + const n = e("inherits"), + i = e("safer-buffer").Buffer, + s = e("../base/node"), + o = e("../constants/der"); + function a(e) { + ((this.enc = "der"), + (this.name = e.name), + (this.entity = e), + (this.tree = new l()), + this.tree._init(e.body)); + } + function l(e) { + s.call(this, "der", e); + } + function c(e) { + return e < 10 ? "0" + e : e; + } + ((t.exports = a), + (a.prototype.encode = function (e, t) { + return this.tree._encode(e, t).join(); + }), + n(l, s), + (l.prototype._encodeComposite = function (e, t, r, n) { + const s = (function (e, t, r, n) { + let i; + "seqof" === e ? (e = "seq") : "setof" === e && (e = "set"); + if (o.tagByName.hasOwnProperty(e)) i = o.tagByName[e]; + else { + if ("number" != typeof e || (0 | e) !== e) + return n.error("Unknown tag: " + e); + i = e; + } + if (i >= 31) + return n.error("Multi-octet tag encoding unsupported"); + t || (i |= 32); + return ((i |= o.tagClassByName[r || "universal"] << 6), i); + })(e, t, r, this.reporter); + if (n.length < 128) { + const e = i.alloc(2); + return ( + (e[0] = s), + (e[1] = n.length), + this._createEncoderBuffer([e, n]) + ); + } + let a = 1; + for (let e = n.length; e >= 256; e >>= 8) a++; + const l = i.alloc(2 + a); + ((l[0] = s), (l[1] = 128 | a)); + for (let e = 1 + a, t = n.length; t > 0; e--, t >>= 8) + l[e] = 255 & t; + return this._createEncoderBuffer([l, n]); + }), + (l.prototype._encodeStr = function (e, t) { + if ("bitstr" === t) + return this._createEncoderBuffer([0 | e.unused, e.data]); + if ("bmpstr" === t) { + const t = i.alloc(2 * e.length); + for (let r = 0; r < e.length; r++) + t.writeUInt16BE(e.charCodeAt(r), 2 * r); + return this._createEncoderBuffer(t); + } + return "numstr" === t + ? this._isNumstr(e) + ? this._createEncoderBuffer(e) + : this.reporter.error( + "Encoding of string type: numstr supports only digits and space", + ) + : "printstr" === t + ? this._isPrintstr(e) + ? this._createEncoderBuffer(e) + : this.reporter.error( + "Encoding of string type: printstr supports only latin upper and lower case letters, digits, space, apostrophe, left and rigth parenthesis, plus sign, comma, hyphen, dot, slash, colon, equal sign, question mark", + ) + : /str$/.test(t) || "objDesc" === t + ? this._createEncoderBuffer(e) + : this.reporter.error( + "Encoding of string type: " + t + " unsupported", + ); + }), + (l.prototype._encodeObjid = function (e, t, r) { + if ("string" == typeof e) { + if (!t) + return this.reporter.error( + "string objid given, but no values map found", + ); + if (!t.hasOwnProperty(e)) + return this.reporter.error("objid not found in values map"); + e = t[e].split(/[\s.]+/g); + for (let t = 0; t < e.length; t++) e[t] |= 0; + } else if (Array.isArray(e)) { + e = e.slice(); + for (let t = 0; t < e.length; t++) e[t] |= 0; + } + if (!Array.isArray(e)) + return this.reporter.error( + "objid() should be either array or string, got: " + + JSON.stringify(e), + ); + if (!r) { + if (e[1] >= 40) + return this.reporter.error("Second objid identifier OOB"); + e.splice(0, 2, 40 * e[0] + e[1]); + } + let n = 0; + for (let t = 0; t < e.length; t++) { + let r = e[t]; + for (n++; r >= 128; r >>= 7) n++; + } + const s = i.alloc(n); + let o = s.length - 1; + for (let t = e.length - 1; t >= 0; t--) { + let r = e[t]; + for (s[o--] = 127 & r; (r >>= 7) > 0; ) + s[o--] = 128 | (127 & r); + } + return this._createEncoderBuffer(s); + }), + (l.prototype._encodeTime = function (e, t) { + let r; + const n = new Date(e); + return ( + "gentime" === t + ? (r = [ + c(n.getUTCFullYear()), + c(n.getUTCMonth() + 1), + c(n.getUTCDate()), + c(n.getUTCHours()), + c(n.getUTCMinutes()), + c(n.getUTCSeconds()), + "Z", + ].join("")) + : "utctime" === t + ? (r = [ + c(n.getUTCFullYear() % 100), + c(n.getUTCMonth() + 1), + c(n.getUTCDate()), + c(n.getUTCHours()), + c(n.getUTCMinutes()), + c(n.getUTCSeconds()), + "Z", + ].join("")) + : this.reporter.error( + "Encoding " + t + " time is not supported yet", + ), + this._encodeStr(r, "octstr") + ); + }), + (l.prototype._encodeNull = function () { + return this._createEncoderBuffer(""); + }), + (l.prototype._encodeInt = function (e, t) { + if ("string" == typeof e) { + if (!t) + return this.reporter.error( + "String int or enum given, but no values map", + ); + if (!t.hasOwnProperty(e)) + return this.reporter.error( + "Values map doesn't contain: " + JSON.stringify(e), + ); + e = t[e]; + } + if ("number" != typeof e && !i.isBuffer(e)) { + const t = e.toArray(); + (!e.sign && 128 & t[0] && t.unshift(0), (e = i.from(t))); + } + if (i.isBuffer(e)) { + let t = e.length; + 0 === e.length && t++; + const r = i.alloc(t); + return ( + e.copy(r), + 0 === e.length && (r[0] = 0), + this._createEncoderBuffer(r) + ); + } + if (e < 128) return this._createEncoderBuffer(e); + if (e < 256) return this._createEncoderBuffer([0, e]); + let r = 1; + for (let t = e; t >= 256; t >>= 8) r++; + const n = new Array(r); + for (let t = n.length - 1; t >= 0; t--) + ((n[t] = 255 & e), (e >>= 8)); + return ( + 128 & n[0] && n.unshift(0), + this._createEncoderBuffer(i.from(n)) + ); + }), + (l.prototype._encodeBool = function (e) { + return this._createEncoderBuffer(e ? 255 : 0); + }), + (l.prototype._use = function (e, t) { + return ( + "function" == typeof e && (e = e(t)), + e._getEncoder("der").tree + ); + }), + (l.prototype._skipDefault = function (e, t, r) { + const n = this._baseState; + let i; + if (null === n.default) return !1; + const s = e.join(); + if ( + (void 0 === n.defaultBuffer && + (n.defaultBuffer = this._encodeValue(n.default, t, r).join()), + s.length !== n.defaultBuffer.length) + ) + return !1; + for (i = 0; i < s.length; i++) + if (s[i] !== n.defaultBuffer[i]) return !1; + return !0; + })); + }, + { + "../base/node": 174, + "../constants/der": 176, + inherits: 440, + "safer-buffer": 495, + }, + ], + 182: [ + function (e, t, r) { + "use strict"; + const n = r; + ((n.der = e("./der")), (n.pem = e("./pem"))); + }, + { "./der": 181, "./pem": 183 }, + ], + 183: [ + function (e, t, r) { + "use strict"; + const n = e("inherits"), + i = e("./der"); + function s(e) { + (i.call(this, e), (this.enc = "pem")); + } + (n(s, i), + (t.exports = s), + (s.prototype.encode = function (e, t) { + const r = i.prototype.encode.call(this, e).toString("base64"), + n = ["-----BEGIN " + t.label + "-----"]; + for (let e = 0; e < r.length; e += 64) n.push(r.slice(e, e + 64)); + return (n.push("-----END " + t.label + "-----"), n.join("\n")); + })); + }, + { "./der": 181, inherits: 440 }, + ], + 184: [ + function (e, t, r) { + "use strict"; + !(function (t, r) { + function n(e, t) { + if (!e) throw new Error(t || "Assertion failed"); + } + function i(e, t) { + e.super_ = t; + var r = function () {}; + ((r.prototype = t.prototype), + (e.prototype = new r()), + (e.prototype.constructor = e)); + } + function s(e, t, r) { + if (s.isBN(e)) return e; + ((this.negative = 0), + (this.words = null), + (this.length = 0), + (this.red = null), + null !== e && + (("le" !== t && "be" !== t) || ((r = t), (t = 10)), + this._init(e || 0, t || 10, r || "be"))); + } + var o; + ("object" == typeof t ? (t.exports = s) : ((void 0).BN = s), + (s.BN = s), + (s.wordSize = 26)); + try { + o = + "undefined" != typeof window && void 0 !== window.Buffer + ? window.Buffer + : e("buffer").Buffer; + } catch (e) {} + function a(e, t) { + var r = e.charCodeAt(t); + return r >= 65 && r <= 70 + ? r - 55 + : r >= 97 && r <= 102 + ? r - 87 + : (r - 48) & 15; + } + function l(e, t, r) { + var n = a(e, r); + return (r - 1 >= t && (n |= a(e, r - 1) << 4), n); + } + function c(e, t, r, n) { + for (var i = 0, s = Math.min(e.length, r), o = t; o < s; o++) { + var a = e.charCodeAt(o) - 48; + ((i *= n), + (i += a >= 49 ? a - 49 + 10 : a >= 17 ? a - 17 + 10 : a)); + } + return i; + } + ((s.isBN = function (e) { + return ( + e instanceof s || + (null !== e && + "object" == typeof e && + e.constructor.wordSize === s.wordSize && + Array.isArray(e.words)) + ); + }), + (s.max = function (e, t) { + return e.cmp(t) > 0 ? e : t; + }), + (s.min = function (e, t) { + return e.cmp(t) < 0 ? e : t; + }), + (s.prototype._init = function (e, t, r) { + if ("number" == typeof e) return this._initNumber(e, t, r); + if ("object" == typeof e) return this._initArray(e, t, r); + ("hex" === t && (t = 16), + n(t === (0 | t) && t >= 2 && t <= 36)); + var i = 0; + ("-" === (e = e.toString().replace(/\s+/g, ""))[0] && + (i++, (this.negative = 1)), + i < e.length && + (16 === t + ? this._parseHex(e, i, r) + : (this._parseBase(e, t, i), + "le" === r && this._initArray(this.toArray(), t, r)))); + }), + (s.prototype._initNumber = function (e, t, r) { + (e < 0 && ((this.negative = 1), (e = -e)), + e < 67108864 + ? ((this.words = [67108863 & e]), (this.length = 1)) + : e < 4503599627370496 + ? ((this.words = [ + 67108863 & e, + (e / 67108864) & 67108863, + ]), + (this.length = 2)) + : (n(e < 9007199254740992), + (this.words = [ + 67108863 & e, + (e / 67108864) & 67108863, + 1, + ]), + (this.length = 3)), + "le" === r && this._initArray(this.toArray(), t, r)); + }), + (s.prototype._initArray = function (e, t, r) { + if ((n("number" == typeof e.length), e.length <= 0)) + return ((this.words = [0]), (this.length = 1), this); + ((this.length = Math.ceil(e.length / 3)), + (this.words = new Array(this.length))); + for (var i = 0; i < this.length; i++) this.words[i] = 0; + var s, + o, + a = 0; + if ("be" === r) + for (i = e.length - 1, s = 0; i >= 0; i -= 3) + ((o = e[i] | (e[i - 1] << 8) | (e[i - 2] << 16)), + (this.words[s] |= (o << a) & 67108863), + (this.words[s + 1] = (o >>> (26 - a)) & 67108863), + (a += 24) >= 26 && ((a -= 26), s++)); + else if ("le" === r) + for (i = 0, s = 0; i < e.length; i += 3) + ((o = e[i] | (e[i + 1] << 8) | (e[i + 2] << 16)), + (this.words[s] |= (o << a) & 67108863), + (this.words[s + 1] = (o >>> (26 - a)) & 67108863), + (a += 24) >= 26 && ((a -= 26), s++)); + return this.strip(); + }), + (s.prototype._parseHex = function (e, t, r) { + ((this.length = Math.ceil((e.length - t) / 6)), + (this.words = new Array(this.length))); + for (var n = 0; n < this.length; n++) this.words[n] = 0; + var i, + s = 0, + o = 0; + if ("be" === r) + for (n = e.length - 1; n >= t; n -= 2) + ((i = l(e, t, n) << s), + (this.words[o] |= 67108863 & i), + s >= 18 + ? ((s -= 18), (o += 1), (this.words[o] |= i >>> 26)) + : (s += 8)); + else + for ( + n = (e.length - t) % 2 == 0 ? t + 1 : t; + n < e.length; + n += 2 + ) + ((i = l(e, t, n) << s), + (this.words[o] |= 67108863 & i), + s >= 18 + ? ((s -= 18), (o += 1), (this.words[o] |= i >>> 26)) + : (s += 8)); + this.strip(); + }), + (s.prototype._parseBase = function (e, t, r) { + ((this.words = [0]), (this.length = 1)); + for (var n = 0, i = 1; i <= 67108863; i *= t) n++; + (n--, (i = (i / t) | 0)); + for ( + var s = e.length - r, + o = s % n, + a = Math.min(s, s - o) + r, + l = 0, + u = r; + u < a; + u += n + ) + ((l = c(e, u, u + n, t)), + this.imuln(i), + this.words[0] + l < 67108864 + ? (this.words[0] += l) + : this._iaddn(l)); + if (0 !== o) { + var h = 1; + for (l = c(e, u, e.length, t), u = 0; u < o; u++) h *= t; + (this.imuln(h), + this.words[0] + l < 67108864 + ? (this.words[0] += l) + : this._iaddn(l)); + } + this.strip(); + }), + (s.prototype.copy = function (e) { + e.words = new Array(this.length); + for (var t = 0; t < this.length; t++) + e.words[t] = this.words[t]; + ((e.length = this.length), + (e.negative = this.negative), + (e.red = this.red)); + }), + (s.prototype.clone = function () { + var e = new s(null); + return (this.copy(e), e); + }), + (s.prototype._expand = function (e) { + for (; this.length < e; ) this.words[this.length++] = 0; + return this; + }), + (s.prototype.strip = function () { + for (; this.length > 1 && 0 === this.words[this.length - 1]; ) + this.length--; + return this._normSign(); + }), + (s.prototype._normSign = function () { + return ( + 1 === this.length && + 0 === this.words[0] && + (this.negative = 0), + this + ); + }), + (s.prototype.inspect = function () { + return ( + (this.red ? "" + ); + })); + var u = [ + "", + "0", + "00", + "000", + "0000", + "00000", + "000000", + "0000000", + "00000000", + "000000000", + "0000000000", + "00000000000", + "000000000000", + "0000000000000", + "00000000000000", + "000000000000000", + "0000000000000000", + "00000000000000000", + "000000000000000000", + "0000000000000000000", + "00000000000000000000", + "000000000000000000000", + "0000000000000000000000", + "00000000000000000000000", + "000000000000000000000000", + "0000000000000000000000000", + ], + h = [ + 0, 0, 25, 16, 12, 11, 10, 9, 8, 8, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, + 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + ], + f = [ + 0, 0, 33554432, 43046721, 16777216, 48828125, 60466176, + 40353607, 16777216, 43046721, 1e7, 19487171, 35831808, 62748517, + 7529536, 11390625, 16777216, 24137569, 34012224, 47045881, 64e6, + 4084101, 5153632, 6436343, 7962624, 9765625, 11881376, 14348907, + 17210368, 20511149, 243e5, 28629151, 33554432, 39135393, + 45435424, 52521875, 60466176, + ]; + function d(e, t, r) { + r.negative = t.negative ^ e.negative; + var n = (e.length + t.length) | 0; + ((r.length = n), (n = (n - 1) | 0)); + var i = 0 | e.words[0], + s = 0 | t.words[0], + o = i * s, + a = 67108863 & o, + l = (o / 67108864) | 0; + r.words[0] = a; + for (var c = 1; c < n; c++) { + for ( + var u = l >>> 26, + h = 67108863 & l, + f = Math.min(c, t.length - 1), + d = Math.max(0, c - e.length + 1); + d <= f; + d++ + ) { + var p = (c - d) | 0; + ((u += + ((o = (i = 0 | e.words[p]) * (s = 0 | t.words[d]) + h) / + 67108864) | + 0), + (h = 67108863 & o)); + } + ((r.words[c] = 0 | h), (l = 0 | u)); + } + return (0 !== l ? (r.words[c] = 0 | l) : r.length--, r.strip()); + } + ((s.prototype.toString = function (e, t) { + var r; + if (((t = 0 | t || 1), 16 === (e = e || 10) || "hex" === e)) { + r = ""; + for (var i = 0, s = 0, o = 0; o < this.length; o++) { + var a = this.words[o], + l = (16777215 & ((a << i) | s)).toString(16); + ((r = + 0 !== (s = (a >>> (24 - i)) & 16777215) || + o !== this.length - 1 + ? u[6 - l.length] + l + r + : l + r), + (i += 2) >= 26 && ((i -= 26), o--)); + } + for (0 !== s && (r = s.toString(16) + r); r.length % t != 0; ) + r = "0" + r; + return (0 !== this.negative && (r = "-" + r), r); + } + if (e === (0 | e) && e >= 2 && e <= 36) { + var c = h[e], + d = f[e]; + r = ""; + var p = this.clone(); + for (p.negative = 0; !p.isZero(); ) { + var m = p.modn(d).toString(e); + r = (p = p.idivn(d)).isZero() + ? m + r + : u[c - m.length] + m + r; + } + for (this.isZero() && (r = "0" + r); r.length % t != 0; ) + r = "0" + r; + return (0 !== this.negative && (r = "-" + r), r); + } + n(!1, "Base should be between 2 and 36"); + }), + (s.prototype.toNumber = function () { + var e = this.words[0]; + return ( + 2 === this.length + ? (e += 67108864 * this.words[1]) + : 3 === this.length && 1 === this.words[2] + ? (e += 4503599627370496 + 67108864 * this.words[1]) + : this.length > 2 && + n(!1, "Number can only safely store up to 53 bits"), + 0 !== this.negative ? -e : e + ); + }), + (s.prototype.toJSON = function () { + return this.toString(16); + }), + (s.prototype.toBuffer = function (e, t) { + return (n(void 0 !== o), this.toArrayLike(o, e, t)); + }), + (s.prototype.toArray = function (e, t) { + return this.toArrayLike(Array, e, t); + }), + (s.prototype.toArrayLike = function (e, t, r) { + var i = this.byteLength(), + s = r || Math.max(1, i); + (n(i <= s, "byte array longer than desired length"), + n(s > 0, "Requested array length <= 0"), + this.strip()); + var o, + a, + l = "le" === t, + c = new e(s), + u = this.clone(); + if (l) { + for (a = 0; !u.isZero(); a++) + ((o = u.andln(255)), u.iushrn(8), (c[a] = o)); + for (; a < s; a++) c[a] = 0; + } else { + for (a = 0; a < s - i; a++) c[a] = 0; + for (a = 0; !u.isZero(); a++) + ((o = u.andln(255)), u.iushrn(8), (c[s - a - 1] = o)); + } + return c; + }), + Math.clz32 + ? (s.prototype._countBits = function (e) { + return 32 - Math.clz32(e); + }) + : (s.prototype._countBits = function (e) { + var t = e, + r = 0; + return ( + t >= 4096 && ((r += 13), (t >>>= 13)), + t >= 64 && ((r += 7), (t >>>= 7)), + t >= 8 && ((r += 4), (t >>>= 4)), + t >= 2 && ((r += 2), (t >>>= 2)), + r + t + ); + }), + (s.prototype._zeroBits = function (e) { + if (0 === e) return 26; + var t = e, + r = 0; + return ( + 0 == (8191 & t) && ((r += 13), (t >>>= 13)), + 0 == (127 & t) && ((r += 7), (t >>>= 7)), + 0 == (15 & t) && ((r += 4), (t >>>= 4)), + 0 == (3 & t) && ((r += 2), (t >>>= 2)), + 0 == (1 & t) && r++, + r + ); + }), + (s.prototype.bitLength = function () { + var e = this.words[this.length - 1], + t = this._countBits(e); + return 26 * (this.length - 1) + t; + }), + (s.prototype.zeroBits = function () { + if (this.isZero()) return 0; + for (var e = 0, t = 0; t < this.length; t++) { + var r = this._zeroBits(this.words[t]); + if (((e += r), 26 !== r)) break; + } + return e; + }), + (s.prototype.byteLength = function () { + return Math.ceil(this.bitLength() / 8); + }), + (s.prototype.toTwos = function (e) { + return 0 !== this.negative + ? this.abs().inotn(e).iaddn(1) + : this.clone(); + }), + (s.prototype.fromTwos = function (e) { + return this.testn(e - 1) + ? this.notn(e).iaddn(1).ineg() + : this.clone(); + }), + (s.prototype.isNeg = function () { + return 0 !== this.negative; + }), + (s.prototype.neg = function () { + return this.clone().ineg(); + }), + (s.prototype.ineg = function () { + return (this.isZero() || (this.negative ^= 1), this); + }), + (s.prototype.iuor = function (e) { + for (; this.length < e.length; ) this.words[this.length++] = 0; + for (var t = 0; t < e.length; t++) + this.words[t] = this.words[t] | e.words[t]; + return this.strip(); + }), + (s.prototype.ior = function (e) { + return (n(0 == (this.negative | e.negative)), this.iuor(e)); + }), + (s.prototype.or = function (e) { + return this.length > e.length + ? this.clone().ior(e) + : e.clone().ior(this); + }), + (s.prototype.uor = function (e) { + return this.length > e.length + ? this.clone().iuor(e) + : e.clone().iuor(this); + }), + (s.prototype.iuand = function (e) { + var t; + t = this.length > e.length ? e : this; + for (var r = 0; r < t.length; r++) + this.words[r] = this.words[r] & e.words[r]; + return ((this.length = t.length), this.strip()); + }), + (s.prototype.iand = function (e) { + return (n(0 == (this.negative | e.negative)), this.iuand(e)); + }), + (s.prototype.and = function (e) { + return this.length > e.length + ? this.clone().iand(e) + : e.clone().iand(this); + }), + (s.prototype.uand = function (e) { + return this.length > e.length + ? this.clone().iuand(e) + : e.clone().iuand(this); + }), + (s.prototype.iuxor = function (e) { + var t, r; + this.length > e.length + ? ((t = this), (r = e)) + : ((t = e), (r = this)); + for (var n = 0; n < r.length; n++) + this.words[n] = t.words[n] ^ r.words[n]; + if (this !== t) + for (; n < t.length; n++) this.words[n] = t.words[n]; + return ((this.length = t.length), this.strip()); + }), + (s.prototype.ixor = function (e) { + return (n(0 == (this.negative | e.negative)), this.iuxor(e)); + }), + (s.prototype.xor = function (e) { + return this.length > e.length + ? this.clone().ixor(e) + : e.clone().ixor(this); + }), + (s.prototype.uxor = function (e) { + return this.length > e.length + ? this.clone().iuxor(e) + : e.clone().iuxor(this); + }), + (s.prototype.inotn = function (e) { + n("number" == typeof e && e >= 0); + var t = 0 | Math.ceil(e / 26), + r = e % 26; + (this._expand(t), r > 0 && t--); + for (var i = 0; i < t; i++) + this.words[i] = 67108863 & ~this.words[i]; + return ( + r > 0 && + (this.words[i] = ~this.words[i] & (67108863 >> (26 - r))), + this.strip() + ); + }), + (s.prototype.notn = function (e) { + return this.clone().inotn(e); + }), + (s.prototype.setn = function (e, t) { + n("number" == typeof e && e >= 0); + var r = (e / 26) | 0, + i = e % 26; + return ( + this._expand(r + 1), + (this.words[r] = t + ? this.words[r] | (1 << i) + : this.words[r] & ~(1 << i)), + this.strip() + ); + }), + (s.prototype.iadd = function (e) { + var t, r, n; + if (0 !== this.negative && 0 === e.negative) + return ( + (this.negative = 0), + (t = this.isub(e)), + (this.negative ^= 1), + this._normSign() + ); + if (0 === this.negative && 0 !== e.negative) + return ( + (e.negative = 0), + (t = this.isub(e)), + (e.negative = 1), + t._normSign() + ); + this.length > e.length + ? ((r = this), (n = e)) + : ((r = e), (n = this)); + for (var i = 0, s = 0; s < n.length; s++) + ((t = (0 | r.words[s]) + (0 | n.words[s]) + i), + (this.words[s] = 67108863 & t), + (i = t >>> 26)); + for (; 0 !== i && s < r.length; s++) + ((t = (0 | r.words[s]) + i), + (this.words[s] = 67108863 & t), + (i = t >>> 26)); + if (((this.length = r.length), 0 !== i)) + ((this.words[this.length] = i), this.length++); + else if (r !== this) + for (; s < r.length; s++) this.words[s] = r.words[s]; + return this; + }), + (s.prototype.add = function (e) { + var t; + return 0 !== e.negative && 0 === this.negative + ? ((e.negative = 0), (t = this.sub(e)), (e.negative ^= 1), t) + : 0 === e.negative && 0 !== this.negative + ? ((this.negative = 0), + (t = e.sub(this)), + (this.negative = 1), + t) + : this.length > e.length + ? this.clone().iadd(e) + : e.clone().iadd(this); + }), + (s.prototype.isub = function (e) { + if (0 !== e.negative) { + e.negative = 0; + var t = this.iadd(e); + return ((e.negative = 1), t._normSign()); + } + if (0 !== this.negative) + return ( + (this.negative = 0), + this.iadd(e), + (this.negative = 1), + this._normSign() + ); + var r, + n, + i = this.cmp(e); + if (0 === i) + return ( + (this.negative = 0), + (this.length = 1), + (this.words[0] = 0), + this + ); + i > 0 ? ((r = this), (n = e)) : ((r = e), (n = this)); + for (var s = 0, o = 0; o < n.length; o++) + ((s = (t = (0 | r.words[o]) - (0 | n.words[o]) + s) >> 26), + (this.words[o] = 67108863 & t)); + for (; 0 !== s && o < r.length; o++) + ((s = (t = (0 | r.words[o]) + s) >> 26), + (this.words[o] = 67108863 & t)); + if (0 === s && o < r.length && r !== this) + for (; o < r.length; o++) this.words[o] = r.words[o]; + return ( + (this.length = Math.max(this.length, o)), + r !== this && (this.negative = 1), + this.strip() + ); + }), + (s.prototype.sub = function (e) { + return this.clone().isub(e); + })); + var p = function (e, t, r) { + var n, + i, + s, + o = e.words, + a = t.words, + l = r.words, + c = 0, + u = 0 | o[0], + h = 8191 & u, + f = u >>> 13, + d = 0 | o[1], + p = 8191 & d, + m = d >>> 13, + b = 0 | o[2], + g = 8191 & b, + y = b >>> 13, + v = 0 | o[3], + w = 8191 & v, + _ = v >>> 13, + x = 0 | o[4], + k = 8191 & x, + S = x >>> 13, + M = 0 | o[5], + C = 8191 & M, + T = M >>> 13, + E = 0 | o[6], + A = 8191 & E, + R = E >>> 13, + O = 0 | o[7], + j = 8191 & O, + I = O >>> 13, + N = 0 | o[8], + P = 8191 & N, + B = N >>> 13, + D = 0 | o[9], + F = 8191 & D, + L = D >>> 13, + z = 0 | a[0], + U = 8191 & z, + $ = z >>> 13, + H = 0 | a[1], + V = 8191 & H, + q = H >>> 13, + W = 0 | a[2], + X = 8191 & W, + K = W >>> 13, + Y = 0 | a[3], + Z = 8191 & Y, + G = Y >>> 13, + J = 0 | a[4], + Q = 8191 & J, + ee = J >>> 13, + te = 0 | a[5], + re = 8191 & te, + ne = te >>> 13, + ie = 0 | a[6], + se = 8191 & ie, + oe = ie >>> 13, + ae = 0 | a[7], + le = 8191 & ae, + ce = ae >>> 13, + ue = 0 | a[8], + he = 8191 & ue, + fe = ue >>> 13, + de = 0 | a[9], + pe = 8191 & de, + me = de >>> 13; + ((r.negative = e.negative ^ t.negative), (r.length = 19)); + var be = + (((c + (n = Math.imul(h, U))) | 0) + + ((8191 & + (i = ((i = Math.imul(h, $)) + Math.imul(f, U)) | 0)) << + 13)) | + 0; + ((c = + ((((s = Math.imul(f, $)) + (i >>> 13)) | 0) + (be >>> 26)) | 0), + (be &= 67108863), + (n = Math.imul(p, U)), + (i = ((i = Math.imul(p, $)) + Math.imul(m, U)) | 0), + (s = Math.imul(m, $))); + var ge = + (((c + (n = (n + Math.imul(h, V)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, q)) | 0) + Math.imul(f, V)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, q)) | 0) + (i >>> 13)) | 0) + + (ge >>> 26)) | + 0), + (ge &= 67108863), + (n = Math.imul(g, U)), + (i = ((i = Math.imul(g, $)) + Math.imul(y, U)) | 0), + (s = Math.imul(y, $)), + (n = (n + Math.imul(p, V)) | 0), + (i = ((i = (i + Math.imul(p, q)) | 0) + Math.imul(m, V)) | 0), + (s = (s + Math.imul(m, q)) | 0)); + var ye = + (((c + (n = (n + Math.imul(h, X)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, K)) | 0) + Math.imul(f, X)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, K)) | 0) + (i >>> 13)) | 0) + + (ye >>> 26)) | + 0), + (ye &= 67108863), + (n = Math.imul(w, U)), + (i = ((i = Math.imul(w, $)) + Math.imul(_, U)) | 0), + (s = Math.imul(_, $)), + (n = (n + Math.imul(g, V)) | 0), + (i = ((i = (i + Math.imul(g, q)) | 0) + Math.imul(y, V)) | 0), + (s = (s + Math.imul(y, q)) | 0), + (n = (n + Math.imul(p, X)) | 0), + (i = ((i = (i + Math.imul(p, K)) | 0) + Math.imul(m, X)) | 0), + (s = (s + Math.imul(m, K)) | 0)); + var ve = + (((c + (n = (n + Math.imul(h, Z)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, G)) | 0) + Math.imul(f, Z)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, G)) | 0) + (i >>> 13)) | 0) + + (ve >>> 26)) | + 0), + (ve &= 67108863), + (n = Math.imul(k, U)), + (i = ((i = Math.imul(k, $)) + Math.imul(S, U)) | 0), + (s = Math.imul(S, $)), + (n = (n + Math.imul(w, V)) | 0), + (i = ((i = (i + Math.imul(w, q)) | 0) + Math.imul(_, V)) | 0), + (s = (s + Math.imul(_, q)) | 0), + (n = (n + Math.imul(g, X)) | 0), + (i = ((i = (i + Math.imul(g, K)) | 0) + Math.imul(y, X)) | 0), + (s = (s + Math.imul(y, K)) | 0), + (n = (n + Math.imul(p, Z)) | 0), + (i = ((i = (i + Math.imul(p, G)) | 0) + Math.imul(m, Z)) | 0), + (s = (s + Math.imul(m, G)) | 0)); + var we = + (((c + (n = (n + Math.imul(h, Q)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, ee)) | 0) + Math.imul(f, Q)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, ee)) | 0) + (i >>> 13)) | 0) + + (we >>> 26)) | + 0), + (we &= 67108863), + (n = Math.imul(C, U)), + (i = ((i = Math.imul(C, $)) + Math.imul(T, U)) | 0), + (s = Math.imul(T, $)), + (n = (n + Math.imul(k, V)) | 0), + (i = ((i = (i + Math.imul(k, q)) | 0) + Math.imul(S, V)) | 0), + (s = (s + Math.imul(S, q)) | 0), + (n = (n + Math.imul(w, X)) | 0), + (i = ((i = (i + Math.imul(w, K)) | 0) + Math.imul(_, X)) | 0), + (s = (s + Math.imul(_, K)) | 0), + (n = (n + Math.imul(g, Z)) | 0), + (i = ((i = (i + Math.imul(g, G)) | 0) + Math.imul(y, Z)) | 0), + (s = (s + Math.imul(y, G)) | 0), + (n = (n + Math.imul(p, Q)) | 0), + (i = ((i = (i + Math.imul(p, ee)) | 0) + Math.imul(m, Q)) | 0), + (s = (s + Math.imul(m, ee)) | 0)); + var _e = + (((c + (n = (n + Math.imul(h, re)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, ne)) | 0) + Math.imul(f, re)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, ne)) | 0) + (i >>> 13)) | 0) + + (_e >>> 26)) | + 0), + (_e &= 67108863), + (n = Math.imul(A, U)), + (i = ((i = Math.imul(A, $)) + Math.imul(R, U)) | 0), + (s = Math.imul(R, $)), + (n = (n + Math.imul(C, V)) | 0), + (i = ((i = (i + Math.imul(C, q)) | 0) + Math.imul(T, V)) | 0), + (s = (s + Math.imul(T, q)) | 0), + (n = (n + Math.imul(k, X)) | 0), + (i = ((i = (i + Math.imul(k, K)) | 0) + Math.imul(S, X)) | 0), + (s = (s + Math.imul(S, K)) | 0), + (n = (n + Math.imul(w, Z)) | 0), + (i = ((i = (i + Math.imul(w, G)) | 0) + Math.imul(_, Z)) | 0), + (s = (s + Math.imul(_, G)) | 0), + (n = (n + Math.imul(g, Q)) | 0), + (i = ((i = (i + Math.imul(g, ee)) | 0) + Math.imul(y, Q)) | 0), + (s = (s + Math.imul(y, ee)) | 0), + (n = (n + Math.imul(p, re)) | 0), + (i = ((i = (i + Math.imul(p, ne)) | 0) + Math.imul(m, re)) | 0), + (s = (s + Math.imul(m, ne)) | 0)); + var xe = + (((c + (n = (n + Math.imul(h, se)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, oe)) | 0) + Math.imul(f, se)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, oe)) | 0) + (i >>> 13)) | 0) + + (xe >>> 26)) | + 0), + (xe &= 67108863), + (n = Math.imul(j, U)), + (i = ((i = Math.imul(j, $)) + Math.imul(I, U)) | 0), + (s = Math.imul(I, $)), + (n = (n + Math.imul(A, V)) | 0), + (i = ((i = (i + Math.imul(A, q)) | 0) + Math.imul(R, V)) | 0), + (s = (s + Math.imul(R, q)) | 0), + (n = (n + Math.imul(C, X)) | 0), + (i = ((i = (i + Math.imul(C, K)) | 0) + Math.imul(T, X)) | 0), + (s = (s + Math.imul(T, K)) | 0), + (n = (n + Math.imul(k, Z)) | 0), + (i = ((i = (i + Math.imul(k, G)) | 0) + Math.imul(S, Z)) | 0), + (s = (s + Math.imul(S, G)) | 0), + (n = (n + Math.imul(w, Q)) | 0), + (i = ((i = (i + Math.imul(w, ee)) | 0) + Math.imul(_, Q)) | 0), + (s = (s + Math.imul(_, ee)) | 0), + (n = (n + Math.imul(g, re)) | 0), + (i = ((i = (i + Math.imul(g, ne)) | 0) + Math.imul(y, re)) | 0), + (s = (s + Math.imul(y, ne)) | 0), + (n = (n + Math.imul(p, se)) | 0), + (i = ((i = (i + Math.imul(p, oe)) | 0) + Math.imul(m, se)) | 0), + (s = (s + Math.imul(m, oe)) | 0)); + var ke = + (((c + (n = (n + Math.imul(h, le)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, ce)) | 0) + Math.imul(f, le)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, ce)) | 0) + (i >>> 13)) | 0) + + (ke >>> 26)) | + 0), + (ke &= 67108863), + (n = Math.imul(P, U)), + (i = ((i = Math.imul(P, $)) + Math.imul(B, U)) | 0), + (s = Math.imul(B, $)), + (n = (n + Math.imul(j, V)) | 0), + (i = ((i = (i + Math.imul(j, q)) | 0) + Math.imul(I, V)) | 0), + (s = (s + Math.imul(I, q)) | 0), + (n = (n + Math.imul(A, X)) | 0), + (i = ((i = (i + Math.imul(A, K)) | 0) + Math.imul(R, X)) | 0), + (s = (s + Math.imul(R, K)) | 0), + (n = (n + Math.imul(C, Z)) | 0), + (i = ((i = (i + Math.imul(C, G)) | 0) + Math.imul(T, Z)) | 0), + (s = (s + Math.imul(T, G)) | 0), + (n = (n + Math.imul(k, Q)) | 0), + (i = ((i = (i + Math.imul(k, ee)) | 0) + Math.imul(S, Q)) | 0), + (s = (s + Math.imul(S, ee)) | 0), + (n = (n + Math.imul(w, re)) | 0), + (i = ((i = (i + Math.imul(w, ne)) | 0) + Math.imul(_, re)) | 0), + (s = (s + Math.imul(_, ne)) | 0), + (n = (n + Math.imul(g, se)) | 0), + (i = ((i = (i + Math.imul(g, oe)) | 0) + Math.imul(y, se)) | 0), + (s = (s + Math.imul(y, oe)) | 0), + (n = (n + Math.imul(p, le)) | 0), + (i = ((i = (i + Math.imul(p, ce)) | 0) + Math.imul(m, le)) | 0), + (s = (s + Math.imul(m, ce)) | 0)); + var Se = + (((c + (n = (n + Math.imul(h, he)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, fe)) | 0) + Math.imul(f, he)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, fe)) | 0) + (i >>> 13)) | 0) + + (Se >>> 26)) | + 0), + (Se &= 67108863), + (n = Math.imul(F, U)), + (i = ((i = Math.imul(F, $)) + Math.imul(L, U)) | 0), + (s = Math.imul(L, $)), + (n = (n + Math.imul(P, V)) | 0), + (i = ((i = (i + Math.imul(P, q)) | 0) + Math.imul(B, V)) | 0), + (s = (s + Math.imul(B, q)) | 0), + (n = (n + Math.imul(j, X)) | 0), + (i = ((i = (i + Math.imul(j, K)) | 0) + Math.imul(I, X)) | 0), + (s = (s + Math.imul(I, K)) | 0), + (n = (n + Math.imul(A, Z)) | 0), + (i = ((i = (i + Math.imul(A, G)) | 0) + Math.imul(R, Z)) | 0), + (s = (s + Math.imul(R, G)) | 0), + (n = (n + Math.imul(C, Q)) | 0), + (i = ((i = (i + Math.imul(C, ee)) | 0) + Math.imul(T, Q)) | 0), + (s = (s + Math.imul(T, ee)) | 0), + (n = (n + Math.imul(k, re)) | 0), + (i = ((i = (i + Math.imul(k, ne)) | 0) + Math.imul(S, re)) | 0), + (s = (s + Math.imul(S, ne)) | 0), + (n = (n + Math.imul(w, se)) | 0), + (i = ((i = (i + Math.imul(w, oe)) | 0) + Math.imul(_, se)) | 0), + (s = (s + Math.imul(_, oe)) | 0), + (n = (n + Math.imul(g, le)) | 0), + (i = ((i = (i + Math.imul(g, ce)) | 0) + Math.imul(y, le)) | 0), + (s = (s + Math.imul(y, ce)) | 0), + (n = (n + Math.imul(p, he)) | 0), + (i = ((i = (i + Math.imul(p, fe)) | 0) + Math.imul(m, he)) | 0), + (s = (s + Math.imul(m, fe)) | 0)); + var Me = + (((c + (n = (n + Math.imul(h, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, me)) | 0) + Math.imul(f, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, me)) | 0) + (i >>> 13)) | 0) + + (Me >>> 26)) | + 0), + (Me &= 67108863), + (n = Math.imul(F, V)), + (i = ((i = Math.imul(F, q)) + Math.imul(L, V)) | 0), + (s = Math.imul(L, q)), + (n = (n + Math.imul(P, X)) | 0), + (i = ((i = (i + Math.imul(P, K)) | 0) + Math.imul(B, X)) | 0), + (s = (s + Math.imul(B, K)) | 0), + (n = (n + Math.imul(j, Z)) | 0), + (i = ((i = (i + Math.imul(j, G)) | 0) + Math.imul(I, Z)) | 0), + (s = (s + Math.imul(I, G)) | 0), + (n = (n + Math.imul(A, Q)) | 0), + (i = ((i = (i + Math.imul(A, ee)) | 0) + Math.imul(R, Q)) | 0), + (s = (s + Math.imul(R, ee)) | 0), + (n = (n + Math.imul(C, re)) | 0), + (i = ((i = (i + Math.imul(C, ne)) | 0) + Math.imul(T, re)) | 0), + (s = (s + Math.imul(T, ne)) | 0), + (n = (n + Math.imul(k, se)) | 0), + (i = ((i = (i + Math.imul(k, oe)) | 0) + Math.imul(S, se)) | 0), + (s = (s + Math.imul(S, oe)) | 0), + (n = (n + Math.imul(w, le)) | 0), + (i = ((i = (i + Math.imul(w, ce)) | 0) + Math.imul(_, le)) | 0), + (s = (s + Math.imul(_, ce)) | 0), + (n = (n + Math.imul(g, he)) | 0), + (i = ((i = (i + Math.imul(g, fe)) | 0) + Math.imul(y, he)) | 0), + (s = (s + Math.imul(y, fe)) | 0)); + var Ce = + (((c + (n = (n + Math.imul(p, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(p, me)) | 0) + Math.imul(m, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(m, me)) | 0) + (i >>> 13)) | 0) + + (Ce >>> 26)) | + 0), + (Ce &= 67108863), + (n = Math.imul(F, X)), + (i = ((i = Math.imul(F, K)) + Math.imul(L, X)) | 0), + (s = Math.imul(L, K)), + (n = (n + Math.imul(P, Z)) | 0), + (i = ((i = (i + Math.imul(P, G)) | 0) + Math.imul(B, Z)) | 0), + (s = (s + Math.imul(B, G)) | 0), + (n = (n + Math.imul(j, Q)) | 0), + (i = ((i = (i + Math.imul(j, ee)) | 0) + Math.imul(I, Q)) | 0), + (s = (s + Math.imul(I, ee)) | 0), + (n = (n + Math.imul(A, re)) | 0), + (i = ((i = (i + Math.imul(A, ne)) | 0) + Math.imul(R, re)) | 0), + (s = (s + Math.imul(R, ne)) | 0), + (n = (n + Math.imul(C, se)) | 0), + (i = ((i = (i + Math.imul(C, oe)) | 0) + Math.imul(T, se)) | 0), + (s = (s + Math.imul(T, oe)) | 0), + (n = (n + Math.imul(k, le)) | 0), + (i = ((i = (i + Math.imul(k, ce)) | 0) + Math.imul(S, le)) | 0), + (s = (s + Math.imul(S, ce)) | 0), + (n = (n + Math.imul(w, he)) | 0), + (i = ((i = (i + Math.imul(w, fe)) | 0) + Math.imul(_, he)) | 0), + (s = (s + Math.imul(_, fe)) | 0)); + var Te = + (((c + (n = (n + Math.imul(g, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(g, me)) | 0) + Math.imul(y, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(y, me)) | 0) + (i >>> 13)) | 0) + + (Te >>> 26)) | + 0), + (Te &= 67108863), + (n = Math.imul(F, Z)), + (i = ((i = Math.imul(F, G)) + Math.imul(L, Z)) | 0), + (s = Math.imul(L, G)), + (n = (n + Math.imul(P, Q)) | 0), + (i = ((i = (i + Math.imul(P, ee)) | 0) + Math.imul(B, Q)) | 0), + (s = (s + Math.imul(B, ee)) | 0), + (n = (n + Math.imul(j, re)) | 0), + (i = ((i = (i + Math.imul(j, ne)) | 0) + Math.imul(I, re)) | 0), + (s = (s + Math.imul(I, ne)) | 0), + (n = (n + Math.imul(A, se)) | 0), + (i = ((i = (i + Math.imul(A, oe)) | 0) + Math.imul(R, se)) | 0), + (s = (s + Math.imul(R, oe)) | 0), + (n = (n + Math.imul(C, le)) | 0), + (i = ((i = (i + Math.imul(C, ce)) | 0) + Math.imul(T, le)) | 0), + (s = (s + Math.imul(T, ce)) | 0), + (n = (n + Math.imul(k, he)) | 0), + (i = ((i = (i + Math.imul(k, fe)) | 0) + Math.imul(S, he)) | 0), + (s = (s + Math.imul(S, fe)) | 0)); + var Ee = + (((c + (n = (n + Math.imul(w, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(w, me)) | 0) + Math.imul(_, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(_, me)) | 0) + (i >>> 13)) | 0) + + (Ee >>> 26)) | + 0), + (Ee &= 67108863), + (n = Math.imul(F, Q)), + (i = ((i = Math.imul(F, ee)) + Math.imul(L, Q)) | 0), + (s = Math.imul(L, ee)), + (n = (n + Math.imul(P, re)) | 0), + (i = ((i = (i + Math.imul(P, ne)) | 0) + Math.imul(B, re)) | 0), + (s = (s + Math.imul(B, ne)) | 0), + (n = (n + Math.imul(j, se)) | 0), + (i = ((i = (i + Math.imul(j, oe)) | 0) + Math.imul(I, se)) | 0), + (s = (s + Math.imul(I, oe)) | 0), + (n = (n + Math.imul(A, le)) | 0), + (i = ((i = (i + Math.imul(A, ce)) | 0) + Math.imul(R, le)) | 0), + (s = (s + Math.imul(R, ce)) | 0), + (n = (n + Math.imul(C, he)) | 0), + (i = ((i = (i + Math.imul(C, fe)) | 0) + Math.imul(T, he)) | 0), + (s = (s + Math.imul(T, fe)) | 0)); + var Ae = + (((c + (n = (n + Math.imul(k, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(k, me)) | 0) + Math.imul(S, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(S, me)) | 0) + (i >>> 13)) | 0) + + (Ae >>> 26)) | + 0), + (Ae &= 67108863), + (n = Math.imul(F, re)), + (i = ((i = Math.imul(F, ne)) + Math.imul(L, re)) | 0), + (s = Math.imul(L, ne)), + (n = (n + Math.imul(P, se)) | 0), + (i = ((i = (i + Math.imul(P, oe)) | 0) + Math.imul(B, se)) | 0), + (s = (s + Math.imul(B, oe)) | 0), + (n = (n + Math.imul(j, le)) | 0), + (i = ((i = (i + Math.imul(j, ce)) | 0) + Math.imul(I, le)) | 0), + (s = (s + Math.imul(I, ce)) | 0), + (n = (n + Math.imul(A, he)) | 0), + (i = ((i = (i + Math.imul(A, fe)) | 0) + Math.imul(R, he)) | 0), + (s = (s + Math.imul(R, fe)) | 0)); + var Re = + (((c + (n = (n + Math.imul(C, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(C, me)) | 0) + Math.imul(T, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(T, me)) | 0) + (i >>> 13)) | 0) + + (Re >>> 26)) | + 0), + (Re &= 67108863), + (n = Math.imul(F, se)), + (i = ((i = Math.imul(F, oe)) + Math.imul(L, se)) | 0), + (s = Math.imul(L, oe)), + (n = (n + Math.imul(P, le)) | 0), + (i = ((i = (i + Math.imul(P, ce)) | 0) + Math.imul(B, le)) | 0), + (s = (s + Math.imul(B, ce)) | 0), + (n = (n + Math.imul(j, he)) | 0), + (i = ((i = (i + Math.imul(j, fe)) | 0) + Math.imul(I, he)) | 0), + (s = (s + Math.imul(I, fe)) | 0)); + var Oe = + (((c + (n = (n + Math.imul(A, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(A, me)) | 0) + Math.imul(R, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(R, me)) | 0) + (i >>> 13)) | 0) + + (Oe >>> 26)) | + 0), + (Oe &= 67108863), + (n = Math.imul(F, le)), + (i = ((i = Math.imul(F, ce)) + Math.imul(L, le)) | 0), + (s = Math.imul(L, ce)), + (n = (n + Math.imul(P, he)) | 0), + (i = ((i = (i + Math.imul(P, fe)) | 0) + Math.imul(B, he)) | 0), + (s = (s + Math.imul(B, fe)) | 0)); + var je = + (((c + (n = (n + Math.imul(j, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(j, me)) | 0) + Math.imul(I, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(I, me)) | 0) + (i >>> 13)) | 0) + + (je >>> 26)) | + 0), + (je &= 67108863), + (n = Math.imul(F, he)), + (i = ((i = Math.imul(F, fe)) + Math.imul(L, he)) | 0), + (s = Math.imul(L, fe))); + var Ie = + (((c + (n = (n + Math.imul(P, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(P, me)) | 0) + Math.imul(B, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(B, me)) | 0) + (i >>> 13)) | 0) + + (Ie >>> 26)) | + 0), + (Ie &= 67108863)); + var Ne = + (((c + (n = Math.imul(F, pe))) | 0) + + ((8191 & + (i = ((i = Math.imul(F, me)) + Math.imul(L, pe)) | 0)) << + 13)) | + 0; + return ( + (c = + ((((s = Math.imul(L, me)) + (i >>> 13)) | 0) + (Ne >>> 26)) | + 0), + (Ne &= 67108863), + (l[0] = be), + (l[1] = ge), + (l[2] = ye), + (l[3] = ve), + (l[4] = we), + (l[5] = _e), + (l[6] = xe), + (l[7] = ke), + (l[8] = Se), + (l[9] = Me), + (l[10] = Ce), + (l[11] = Te), + (l[12] = Ee), + (l[13] = Ae), + (l[14] = Re), + (l[15] = Oe), + (l[16] = je), + (l[17] = Ie), + (l[18] = Ne), + 0 !== c && ((l[19] = c), r.length++), + r + ); + }; + function m(e, t, r) { + return new b().mulp(e, t, r); + } + function b(e, t) { + ((this.x = e), (this.y = t)); + } + (Math.imul || (p = d), + (s.prototype.mulTo = function (e, t) { + var r = this.length + e.length; + return 10 === this.length && 10 === e.length + ? p(this, e, t) + : r < 63 + ? d(this, e, t) + : r < 1024 + ? (function (e, t, r) { + ((r.negative = t.negative ^ e.negative), + (r.length = e.length + t.length)); + for (var n = 0, i = 0, s = 0; s < r.length - 1; s++) { + var o = i; + i = 0; + for ( + var a = 67108863 & n, + l = Math.min(s, t.length - 1), + c = Math.max(0, s - e.length + 1); + c <= l; + c++ + ) { + var u = s - c, + h = (0 | e.words[u]) * (0 | t.words[c]), + f = 67108863 & h; + ((a = 67108863 & (f = (f + a) | 0)), + (i += + (o = + ((o = (o + ((h / 67108864) | 0)) | 0) + + (f >>> 26)) | + 0) >>> 26), + (o &= 67108863)); + } + ((r.words[s] = a), (n = o), (o = i)); + } + return ( + 0 !== n ? (r.words[s] = n) : r.length--, + r.strip() + ); + })(this, e, t) + : m(this, e, t); + }), + (b.prototype.makeRBT = function (e) { + for ( + var t = new Array(e), + r = s.prototype._countBits(e) - 1, + n = 0; + n < e; + n++ + ) + t[n] = this.revBin(n, r, e); + return t; + }), + (b.prototype.revBin = function (e, t, r) { + if (0 === e || e === r - 1) return e; + for (var n = 0, i = 0; i < t; i++) + ((n |= (1 & e) << (t - i - 1)), (e >>= 1)); + return n; + }), + (b.prototype.permute = function (e, t, r, n, i, s) { + for (var o = 0; o < s; o++) + ((n[o] = t[e[o]]), (i[o] = r[e[o]])); + }), + (b.prototype.transform = function (e, t, r, n, i, s) { + this.permute(s, e, t, r, n, i); + for (var o = 1; o < i; o <<= 1) + for ( + var a = o << 1, + l = Math.cos((2 * Math.PI) / a), + c = Math.sin((2 * Math.PI) / a), + u = 0; + u < i; + u += a + ) + for (var h = l, f = c, d = 0; d < o; d++) { + var p = r[u + d], + m = n[u + d], + b = r[u + d + o], + g = n[u + d + o], + y = h * b - f * g; + ((g = h * g + f * b), + (b = y), + (r[u + d] = p + b), + (n[u + d] = m + g), + (r[u + d + o] = p - b), + (n[u + d + o] = m - g), + d !== a && + ((y = l * h - c * f), (f = l * f + c * h), (h = y))); + } + }), + (b.prototype.guessLen13b = function (e, t) { + var r = 1 | Math.max(t, e), + n = 1 & r, + i = 0; + for (r = (r / 2) | 0; r; r >>>= 1) i++; + return 1 << (i + 1 + n); + }), + (b.prototype.conjugate = function (e, t, r) { + if (!(r <= 1)) + for (var n = 0; n < r / 2; n++) { + var i = e[n]; + ((e[n] = e[r - n - 1]), + (e[r - n - 1] = i), + (i = t[n]), + (t[n] = -t[r - n - 1]), + (t[r - n - 1] = -i)); + } + }), + (b.prototype.normalize13b = function (e, t) { + for (var r = 0, n = 0; n < t / 2; n++) { + var i = + 8192 * Math.round(e[2 * n + 1] / t) + + Math.round(e[2 * n] / t) + + r; + ((e[n] = 67108863 & i), + (r = i < 67108864 ? 0 : (i / 67108864) | 0)); + } + return e; + }), + (b.prototype.convert13b = function (e, t, r, i) { + for (var s = 0, o = 0; o < t; o++) + ((s += 0 | e[o]), + (r[2 * o] = 8191 & s), + (s >>>= 13), + (r[2 * o + 1] = 8191 & s), + (s >>>= 13)); + for (o = 2 * t; o < i; ++o) r[o] = 0; + (n(0 === s), n(0 == (-8192 & s))); + }), + (b.prototype.stub = function (e) { + for (var t = new Array(e), r = 0; r < e; r++) t[r] = 0; + return t; + }), + (b.prototype.mulp = function (e, t, r) { + var n = 2 * this.guessLen13b(e.length, t.length), + i = this.makeRBT(n), + s = this.stub(n), + o = new Array(n), + a = new Array(n), + l = new Array(n), + c = new Array(n), + u = new Array(n), + h = new Array(n), + f = r.words; + ((f.length = n), + this.convert13b(e.words, e.length, o, n), + this.convert13b(t.words, t.length, c, n), + this.transform(o, s, a, l, n, i), + this.transform(c, s, u, h, n, i)); + for (var d = 0; d < n; d++) { + var p = a[d] * u[d] - l[d] * h[d]; + ((l[d] = a[d] * h[d] + l[d] * u[d]), (a[d] = p)); + } + return ( + this.conjugate(a, l, n), + this.transform(a, l, f, s, n, i), + this.conjugate(f, s, n), + this.normalize13b(f, n), + (r.negative = e.negative ^ t.negative), + (r.length = e.length + t.length), + r.strip() + ); + }), + (s.prototype.mul = function (e) { + var t = new s(null); + return ( + (t.words = new Array(this.length + e.length)), + this.mulTo(e, t) + ); + }), + (s.prototype.mulf = function (e) { + var t = new s(null); + return ( + (t.words = new Array(this.length + e.length)), + m(this, e, t) + ); + }), + (s.prototype.imul = function (e) { + return this.clone().mulTo(e, this); + }), + (s.prototype.imuln = function (e) { + (n("number" == typeof e), n(e < 67108864)); + for (var t = 0, r = 0; r < this.length; r++) { + var i = (0 | this.words[r]) * e, + s = (67108863 & i) + (67108863 & t); + ((t >>= 26), + (t += (i / 67108864) | 0), + (t += s >>> 26), + (this.words[r] = 67108863 & s)); + } + return (0 !== t && ((this.words[r] = t), this.length++), this); + }), + (s.prototype.muln = function (e) { + return this.clone().imuln(e); + }), + (s.prototype.sqr = function () { + return this.mul(this); + }), + (s.prototype.isqr = function () { + return this.imul(this.clone()); + }), + (s.prototype.pow = function (e) { + var t = (function (e) { + for ( + var t = new Array(e.bitLength()), r = 0; + r < t.length; + r++ + ) { + var n = (r / 26) | 0, + i = r % 26; + t[r] = (e.words[n] & (1 << i)) >>> i; + } + return t; + })(e); + if (0 === t.length) return new s(1); + for ( + var r = this, n = 0; + n < t.length && 0 === t[n]; + n++, r = r.sqr() + ); + if (++n < t.length) + for (var i = r.sqr(); n < t.length; n++, i = i.sqr()) + 0 !== t[n] && (r = r.mul(i)); + return r; + }), + (s.prototype.iushln = function (e) { + n("number" == typeof e && e >= 0); + var t, + r = e % 26, + i = (e - r) / 26, + s = (67108863 >>> (26 - r)) << (26 - r); + if (0 !== r) { + var o = 0; + for (t = 0; t < this.length; t++) { + var a = this.words[t] & s, + l = ((0 | this.words[t]) - a) << r; + ((this.words[t] = l | o), (o = a >>> (26 - r))); + } + o && ((this.words[t] = o), this.length++); + } + if (0 !== i) { + for (t = this.length - 1; t >= 0; t--) + this.words[t + i] = this.words[t]; + for (t = 0; t < i; t++) this.words[t] = 0; + this.length += i; + } + return this.strip(); + }), + (s.prototype.ishln = function (e) { + return (n(0 === this.negative), this.iushln(e)); + }), + (s.prototype.iushrn = function (e, t, r) { + var i; + (n("number" == typeof e && e >= 0), + (i = t ? (t - (t % 26)) / 26 : 0)); + var s = e % 26, + o = Math.min((e - s) / 26, this.length), + a = 67108863 ^ ((67108863 >>> s) << s), + l = r; + if (((i -= o), (i = Math.max(0, i)), l)) { + for (var c = 0; c < o; c++) l.words[c] = this.words[c]; + l.length = o; + } + if (0 === o); + else if (this.length > o) + for (this.length -= o, c = 0; c < this.length; c++) + this.words[c] = this.words[c + o]; + else ((this.words[0] = 0), (this.length = 1)); + var u = 0; + for (c = this.length - 1; c >= 0 && (0 !== u || c >= i); c--) { + var h = 0 | this.words[c]; + ((this.words[c] = (u << (26 - s)) | (h >>> s)), (u = h & a)); + } + return ( + l && 0 !== u && (l.words[l.length++] = u), + 0 === this.length && ((this.words[0] = 0), (this.length = 1)), + this.strip() + ); + }), + (s.prototype.ishrn = function (e, t, r) { + return (n(0 === this.negative), this.iushrn(e, t, r)); + }), + (s.prototype.shln = function (e) { + return this.clone().ishln(e); + }), + (s.prototype.ushln = function (e) { + return this.clone().iushln(e); + }), + (s.prototype.shrn = function (e) { + return this.clone().ishrn(e); + }), + (s.prototype.ushrn = function (e) { + return this.clone().iushrn(e); + }), + (s.prototype.testn = function (e) { + n("number" == typeof e && e >= 0); + var t = e % 26, + r = (e - t) / 26, + i = 1 << t; + return !(this.length <= r) && !!(this.words[r] & i); + }), + (s.prototype.imaskn = function (e) { + n("number" == typeof e && e >= 0); + var t = e % 26, + r = (e - t) / 26; + if ( + (n( + 0 === this.negative, + "imaskn works only with positive numbers", + ), + this.length <= r) + ) + return this; + if ( + (0 !== t && r++, + (this.length = Math.min(r, this.length)), + 0 !== t) + ) { + var i = 67108863 ^ ((67108863 >>> t) << t); + this.words[this.length - 1] &= i; + } + return this.strip(); + }), + (s.prototype.maskn = function (e) { + return this.clone().imaskn(e); + }), + (s.prototype.iaddn = function (e) { + return ( + n("number" == typeof e), + n(e < 67108864), + e < 0 + ? this.isubn(-e) + : 0 !== this.negative + ? 1 === this.length && (0 | this.words[0]) < e + ? ((this.words[0] = e - (0 | this.words[0])), + (this.negative = 0), + this) + : ((this.negative = 0), + this.isubn(e), + (this.negative = 1), + this) + : this._iaddn(e) + ); + }), + (s.prototype._iaddn = function (e) { + this.words[0] += e; + for ( + var t = 0; + t < this.length && this.words[t] >= 67108864; + t++ + ) + ((this.words[t] -= 67108864), + t === this.length - 1 + ? (this.words[t + 1] = 1) + : this.words[t + 1]++); + return ((this.length = Math.max(this.length, t + 1)), this); + }), + (s.prototype.isubn = function (e) { + if ((n("number" == typeof e), n(e < 67108864), e < 0)) + return this.iaddn(-e); + if (0 !== this.negative) + return ( + (this.negative = 0), + this.iaddn(e), + (this.negative = 1), + this + ); + if ( + ((this.words[0] -= e), 1 === this.length && this.words[0] < 0) + ) + ((this.words[0] = -this.words[0]), (this.negative = 1)); + else + for (var t = 0; t < this.length && this.words[t] < 0; t++) + ((this.words[t] += 67108864), (this.words[t + 1] -= 1)); + return this.strip(); + }), + (s.prototype.addn = function (e) { + return this.clone().iaddn(e); + }), + (s.prototype.subn = function (e) { + return this.clone().isubn(e); + }), + (s.prototype.iabs = function () { + return ((this.negative = 0), this); + }), + (s.prototype.abs = function () { + return this.clone().iabs(); + }), + (s.prototype._ishlnsubmul = function (e, t, r) { + var i, + s, + o = e.length + r; + this._expand(o); + var a = 0; + for (i = 0; i < e.length; i++) { + s = (0 | this.words[i + r]) + a; + var l = (0 | e.words[i]) * t; + ((a = ((s -= 67108863 & l) >> 26) - ((l / 67108864) | 0)), + (this.words[i + r] = 67108863 & s)); + } + for (; i < this.length - r; i++) + ((a = (s = (0 | this.words[i + r]) + a) >> 26), + (this.words[i + r] = 67108863 & s)); + if (0 === a) return this.strip(); + for (n(-1 === a), a = 0, i = 0; i < this.length; i++) + ((a = (s = -(0 | this.words[i]) + a) >> 26), + (this.words[i] = 67108863 & s)); + return ((this.negative = 1), this.strip()); + }), + (s.prototype._wordDiv = function (e, t) { + var r = (this.length, e.length), + n = this.clone(), + i = e, + o = 0 | i.words[i.length - 1]; + 0 !== (r = 26 - this._countBits(o)) && + ((i = i.ushln(r)), + n.iushln(r), + (o = 0 | i.words[i.length - 1])); + var a, + l = n.length - i.length; + if ("mod" !== t) { + (((a = new s(null)).length = l + 1), + (a.words = new Array(a.length))); + for (var c = 0; c < a.length; c++) a.words[c] = 0; + } + var u = n.clone()._ishlnsubmul(i, 1, l); + 0 === u.negative && ((n = u), a && (a.words[l] = 1)); + for (var h = l - 1; h >= 0; h--) { + var f = + 67108864 * (0 | n.words[i.length + h]) + + (0 | n.words[i.length + h - 1]); + for ( + f = Math.min((f / o) | 0, 67108863), + n._ishlnsubmul(i, f, h); + 0 !== n.negative; + ) + (f--, + (n.negative = 0), + n._ishlnsubmul(i, 1, h), + n.isZero() || (n.negative ^= 1)); + a && (a.words[h] = f); + } + return ( + a && a.strip(), + n.strip(), + "div" !== t && 0 !== r && n.iushrn(r), + { div: a || null, mod: n } + ); + }), + (s.prototype.divmod = function (e, t, r) { + return ( + n(!e.isZero()), + this.isZero() + ? { div: new s(0), mod: new s(0) } + : 0 !== this.negative && 0 === e.negative + ? ((a = this.neg().divmod(e, t)), + "mod" !== t && (i = a.div.neg()), + "div" !== t && + ((o = a.mod.neg()), + r && 0 !== o.negative && o.iadd(e)), + { div: i, mod: o }) + : 0 === this.negative && 0 !== e.negative + ? ((a = this.divmod(e.neg(), t)), + "mod" !== t && (i = a.div.neg()), + { div: i, mod: a.mod }) + : 0 != (this.negative & e.negative) + ? ((a = this.neg().divmod(e.neg(), t)), + "div" !== t && + ((o = a.mod.neg()), + r && 0 !== o.negative && o.isub(e)), + { div: a.div, mod: o }) + : e.length > this.length || this.cmp(e) < 0 + ? { div: new s(0), mod: this } + : 1 === e.length + ? "div" === t + ? { div: this.divn(e.words[0]), mod: null } + : "mod" === t + ? { + div: null, + mod: new s(this.modn(e.words[0])), + } + : { + div: this.divn(e.words[0]), + mod: new s(this.modn(e.words[0])), + } + : this._wordDiv(e, t) + ); + var i, o, a; + }), + (s.prototype.div = function (e) { + return this.divmod(e, "div", !1).div; + }), + (s.prototype.mod = function (e) { + return this.divmod(e, "mod", !1).mod; + }), + (s.prototype.umod = function (e) { + return this.divmod(e, "mod", !0).mod; + }), + (s.prototype.divRound = function (e) { + var t = this.divmod(e); + if (t.mod.isZero()) return t.div; + var r = 0 !== t.div.negative ? t.mod.isub(e) : t.mod, + n = e.ushrn(1), + i = e.andln(1), + s = r.cmp(n); + return s < 0 || (1 === i && 0 === s) + ? t.div + : 0 !== t.div.negative + ? t.div.isubn(1) + : t.div.iaddn(1); + }), + (s.prototype.modn = function (e) { + n(e <= 67108863); + for ( + var t = (1 << 26) % e, r = 0, i = this.length - 1; + i >= 0; + i-- + ) + r = (t * r + (0 | this.words[i])) % e; + return r; + }), + (s.prototype.idivn = function (e) { + n(e <= 67108863); + for (var t = 0, r = this.length - 1; r >= 0; r--) { + var i = (0 | this.words[r]) + 67108864 * t; + ((this.words[r] = (i / e) | 0), (t = i % e)); + } + return this.strip(); + }), + (s.prototype.divn = function (e) { + return this.clone().idivn(e); + }), + (s.prototype.egcd = function (e) { + (n(0 === e.negative), n(!e.isZero())); + var t = this, + r = e.clone(); + t = 0 !== t.negative ? t.umod(e) : t.clone(); + for ( + var i = new s(1), + o = new s(0), + a = new s(0), + l = new s(1), + c = 0; + t.isEven() && r.isEven(); + ) + (t.iushrn(1), r.iushrn(1), ++c); + for (var u = r.clone(), h = t.clone(); !t.isZero(); ) { + for ( + var f = 0, d = 1; + 0 == (t.words[0] & d) && f < 26; + ++f, d <<= 1 + ); + if (f > 0) + for (t.iushrn(f); f-- > 0; ) + ((i.isOdd() || o.isOdd()) && (i.iadd(u), o.isub(h)), + i.iushrn(1), + o.iushrn(1)); + for ( + var p = 0, m = 1; + 0 == (r.words[0] & m) && p < 26; + ++p, m <<= 1 + ); + if (p > 0) + for (r.iushrn(p); p-- > 0; ) + ((a.isOdd() || l.isOdd()) && (a.iadd(u), l.isub(h)), + a.iushrn(1), + l.iushrn(1)); + t.cmp(r) >= 0 + ? (t.isub(r), i.isub(a), o.isub(l)) + : (r.isub(t), a.isub(i), l.isub(o)); + } + return { a: a, b: l, gcd: r.iushln(c) }; + }), + (s.prototype._invmp = function (e) { + (n(0 === e.negative), n(!e.isZero())); + var t = this, + r = e.clone(); + t = 0 !== t.negative ? t.umod(e) : t.clone(); + for ( + var i, o = new s(1), a = new s(0), l = r.clone(); + t.cmpn(1) > 0 && r.cmpn(1) > 0; + ) { + for ( + var c = 0, u = 1; + 0 == (t.words[0] & u) && c < 26; + ++c, u <<= 1 + ); + if (c > 0) + for (t.iushrn(c); c-- > 0; ) + (o.isOdd() && o.iadd(l), o.iushrn(1)); + for ( + var h = 0, f = 1; + 0 == (r.words[0] & f) && h < 26; + ++h, f <<= 1 + ); + if (h > 0) + for (r.iushrn(h); h-- > 0; ) + (a.isOdd() && a.iadd(l), a.iushrn(1)); + t.cmp(r) >= 0 + ? (t.isub(r), o.isub(a)) + : (r.isub(t), a.isub(o)); + } + return ( + (i = 0 === t.cmpn(1) ? o : a).cmpn(0) < 0 && i.iadd(e), + i + ); + }), + (s.prototype.gcd = function (e) { + if (this.isZero()) return e.abs(); + if (e.isZero()) return this.abs(); + var t = this.clone(), + r = e.clone(); + ((t.negative = 0), (r.negative = 0)); + for (var n = 0; t.isEven() && r.isEven(); n++) + (t.iushrn(1), r.iushrn(1)); + for (;;) { + for (; t.isEven(); ) t.iushrn(1); + for (; r.isEven(); ) r.iushrn(1); + var i = t.cmp(r); + if (i < 0) { + var s = t; + ((t = r), (r = s)); + } else if (0 === i || 0 === r.cmpn(1)) break; + t.isub(r); + } + return r.iushln(n); + }), + (s.prototype.invm = function (e) { + return this.egcd(e).a.umod(e); + }), + (s.prototype.isEven = function () { + return 0 == (1 & this.words[0]); + }), + (s.prototype.isOdd = function () { + return 1 == (1 & this.words[0]); + }), + (s.prototype.andln = function (e) { + return this.words[0] & e; + }), + (s.prototype.bincn = function (e) { + n("number" == typeof e); + var t = e % 26, + r = (e - t) / 26, + i = 1 << t; + if (this.length <= r) + return (this._expand(r + 1), (this.words[r] |= i), this); + for (var s = i, o = r; 0 !== s && o < this.length; o++) { + var a = 0 | this.words[o]; + ((s = (a += s) >>> 26), (a &= 67108863), (this.words[o] = a)); + } + return (0 !== s && ((this.words[o] = s), this.length++), this); + }), + (s.prototype.isZero = function () { + return 1 === this.length && 0 === this.words[0]; + }), + (s.prototype.cmpn = function (e) { + var t, + r = e < 0; + if (0 !== this.negative && !r) return -1; + if (0 === this.negative && r) return 1; + if ((this.strip(), this.length > 1)) t = 1; + else { + (r && (e = -e), n(e <= 67108863, "Number is too big")); + var i = 0 | this.words[0]; + t = i === e ? 0 : i < e ? -1 : 1; + } + return 0 !== this.negative ? 0 | -t : t; + }), + (s.prototype.cmp = function (e) { + if (0 !== this.negative && 0 === e.negative) return -1; + if (0 === this.negative && 0 !== e.negative) return 1; + var t = this.ucmp(e); + return 0 !== this.negative ? 0 | -t : t; + }), + (s.prototype.ucmp = function (e) { + if (this.length > e.length) return 1; + if (this.length < e.length) return -1; + for (var t = 0, r = this.length - 1; r >= 0; r--) { + var n = 0 | this.words[r], + i = 0 | e.words[r]; + if (n !== i) { + n < i ? (t = -1) : n > i && (t = 1); + break; + } + } + return t; + }), + (s.prototype.gtn = function (e) { + return 1 === this.cmpn(e); + }), + (s.prototype.gt = function (e) { + return 1 === this.cmp(e); + }), + (s.prototype.gten = function (e) { + return this.cmpn(e) >= 0; + }), + (s.prototype.gte = function (e) { + return this.cmp(e) >= 0; + }), + (s.prototype.ltn = function (e) { + return -1 === this.cmpn(e); + }), + (s.prototype.lt = function (e) { + return -1 === this.cmp(e); + }), + (s.prototype.lten = function (e) { + return this.cmpn(e) <= 0; + }), + (s.prototype.lte = function (e) { + return this.cmp(e) <= 0; + }), + (s.prototype.eqn = function (e) { + return 0 === this.cmpn(e); + }), + (s.prototype.eq = function (e) { + return 0 === this.cmp(e); + }), + (s.red = function (e) { + return new k(e); + }), + (s.prototype.toRed = function (e) { + return ( + n(!this.red, "Already a number in reduction context"), + n(0 === this.negative, "red works only with positives"), + e.convertTo(this)._forceRed(e) + ); + }), + (s.prototype.fromRed = function () { + return ( + n( + this.red, + "fromRed works only with numbers in reduction context", + ), + this.red.convertFrom(this) + ); + }), + (s.prototype._forceRed = function (e) { + return ((this.red = e), this); + }), + (s.prototype.forceRed = function (e) { + return ( + n(!this.red, "Already a number in reduction context"), + this._forceRed(e) + ); + }), + (s.prototype.redAdd = function (e) { + return ( + n(this.red, "redAdd works only with red numbers"), + this.red.add(this, e) + ); + }), + (s.prototype.redIAdd = function (e) { + return ( + n(this.red, "redIAdd works only with red numbers"), + this.red.iadd(this, e) + ); + }), + (s.prototype.redSub = function (e) { + return ( + n(this.red, "redSub works only with red numbers"), + this.red.sub(this, e) + ); + }), + (s.prototype.redISub = function (e) { + return ( + n(this.red, "redISub works only with red numbers"), + this.red.isub(this, e) + ); + }), + (s.prototype.redShl = function (e) { + return ( + n(this.red, "redShl works only with red numbers"), + this.red.shl(this, e) + ); + }), + (s.prototype.redMul = function (e) { + return ( + n(this.red, "redMul works only with red numbers"), + this.red._verify2(this, e), + this.red.mul(this, e) + ); + }), + (s.prototype.redIMul = function (e) { + return ( + n(this.red, "redMul works only with red numbers"), + this.red._verify2(this, e), + this.red.imul(this, e) + ); + }), + (s.prototype.redSqr = function () { + return ( + n(this.red, "redSqr works only with red numbers"), + this.red._verify1(this), + this.red.sqr(this) + ); + }), + (s.prototype.redISqr = function () { + return ( + n(this.red, "redISqr works only with red numbers"), + this.red._verify1(this), + this.red.isqr(this) + ); + }), + (s.prototype.redSqrt = function () { + return ( + n(this.red, "redSqrt works only with red numbers"), + this.red._verify1(this), + this.red.sqrt(this) + ); + }), + (s.prototype.redInvm = function () { + return ( + n(this.red, "redInvm works only with red numbers"), + this.red._verify1(this), + this.red.invm(this) + ); + }), + (s.prototype.redNeg = function () { + return ( + n(this.red, "redNeg works only with red numbers"), + this.red._verify1(this), + this.red.neg(this) + ); + }), + (s.prototype.redPow = function (e) { + return ( + n(this.red && !e.red, "redPow(normalNum)"), + this.red._verify1(this), + this.red.pow(this, e) + ); + })); + var g = { k256: null, p224: null, p192: null, p25519: null }; + function y(e, t) { + ((this.name = e), + (this.p = new s(t, 16)), + (this.n = this.p.bitLength()), + (this.k = new s(1).iushln(this.n).isub(this.p)), + (this.tmp = this._tmp())); + } + function v() { + y.call( + this, + "k256", + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f", + ); + } + function w() { + y.call( + this, + "p224", + "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001", + ); + } + function _() { + y.call( + this, + "p192", + "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff", + ); + } + function x() { + y.call( + this, + "25519", + "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", + ); + } + function k(e) { + if ("string" == typeof e) { + var t = s._prime(e); + ((this.m = t.p), (this.prime = t)); + } else + (n(e.gtn(1), "modulus must be greater than 1"), + (this.m = e), + (this.prime = null)); + } + function S(e) { + (k.call(this, e), + (this.shift = this.m.bitLength()), + this.shift % 26 != 0 && (this.shift += 26 - (this.shift % 26)), + (this.r = new s(1).iushln(this.shift)), + (this.r2 = this.imod(this.r.sqr())), + (this.rinv = this.r._invmp(this.m)), + (this.minv = this.rinv.mul(this.r).isubn(1).div(this.m)), + (this.minv = this.minv.umod(this.r)), + (this.minv = this.r.sub(this.minv))); + } + ((y.prototype._tmp = function () { + var e = new s(null); + return ((e.words = new Array(Math.ceil(this.n / 13))), e); + }), + (y.prototype.ireduce = function (e) { + var t, + r = e; + do { + (this.split(r, this.tmp), + (t = (r = (r = this.imulK(r)).iadd(this.tmp)).bitLength())); + } while (t > this.n); + var n = t < this.n ? -1 : r.ucmp(this.p); + return ( + 0 === n + ? ((r.words[0] = 0), (r.length = 1)) + : n > 0 + ? r.isub(this.p) + : void 0 !== r.strip + ? r.strip() + : r._strip(), + r + ); + }), + (y.prototype.split = function (e, t) { + e.iushrn(this.n, 0, t); + }), + (y.prototype.imulK = function (e) { + return e.imul(this.k); + }), + i(v, y), + (v.prototype.split = function (e, t) { + for (var r = Math.min(e.length, 9), n = 0; n < r; n++) + t.words[n] = e.words[n]; + if (((t.length = r), e.length <= 9)) + return ((e.words[0] = 0), void (e.length = 1)); + var i = e.words[9]; + for ( + t.words[t.length++] = 4194303 & i, n = 10; + n < e.length; + n++ + ) { + var s = 0 | e.words[n]; + ((e.words[n - 10] = ((4194303 & s) << 4) | (i >>> 22)), + (i = s)); + } + ((i >>>= 22), + (e.words[n - 10] = i), + 0 === i && e.length > 10 + ? (e.length -= 10) + : (e.length -= 9)); + }), + (v.prototype.imulK = function (e) { + ((e.words[e.length] = 0), + (e.words[e.length + 1] = 0), + (e.length += 2)); + for (var t = 0, r = 0; r < e.length; r++) { + var n = 0 | e.words[r]; + ((t += 977 * n), + (e.words[r] = 67108863 & t), + (t = 64 * n + ((t / 67108864) | 0))); + } + return ( + 0 === e.words[e.length - 1] && + (e.length--, 0 === e.words[e.length - 1] && e.length--), + e + ); + }), + i(w, y), + i(_, y), + i(x, y), + (x.prototype.imulK = function (e) { + for (var t = 0, r = 0; r < e.length; r++) { + var n = 19 * (0 | e.words[r]) + t, + i = 67108863 & n; + ((n >>>= 26), (e.words[r] = i), (t = n)); + } + return (0 !== t && (e.words[e.length++] = t), e); + }), + (s._prime = function (e) { + if (g[e]) return g[e]; + var t; + if ("k256" === e) t = new v(); + else if ("p224" === e) t = new w(); + else if ("p192" === e) t = new _(); + else { + if ("p25519" !== e) throw new Error("Unknown prime " + e); + t = new x(); + } + return ((g[e] = t), t); + }), + (k.prototype._verify1 = function (e) { + (n(0 === e.negative, "red works only with positives"), + n(e.red, "red works only with red numbers")); + }), + (k.prototype._verify2 = function (e, t) { + (n( + 0 == (e.negative | t.negative), + "red works only with positives", + ), + n( + e.red && e.red === t.red, + "red works only with red numbers", + )); + }), + (k.prototype.imod = function (e) { + return this.prime + ? this.prime.ireduce(e)._forceRed(this) + : e.umod(this.m)._forceRed(this); + }), + (k.prototype.neg = function (e) { + return e.isZero() ? e.clone() : this.m.sub(e)._forceRed(this); + }), + (k.prototype.add = function (e, t) { + this._verify2(e, t); + var r = e.add(t); + return ( + r.cmp(this.m) >= 0 && r.isub(this.m), + r._forceRed(this) + ); + }), + (k.prototype.iadd = function (e, t) { + this._verify2(e, t); + var r = e.iadd(t); + return (r.cmp(this.m) >= 0 && r.isub(this.m), r); + }), + (k.prototype.sub = function (e, t) { + this._verify2(e, t); + var r = e.sub(t); + return (r.cmpn(0) < 0 && r.iadd(this.m), r._forceRed(this)); + }), + (k.prototype.isub = function (e, t) { + this._verify2(e, t); + var r = e.isub(t); + return (r.cmpn(0) < 0 && r.iadd(this.m), r); + }), + (k.prototype.shl = function (e, t) { + return (this._verify1(e), this.imod(e.ushln(t))); + }), + (k.prototype.imul = function (e, t) { + return (this._verify2(e, t), this.imod(e.imul(t))); + }), + (k.prototype.mul = function (e, t) { + return (this._verify2(e, t), this.imod(e.mul(t))); + }), + (k.prototype.isqr = function (e) { + return this.imul(e, e.clone()); + }), + (k.prototype.sqr = function (e) { + return this.mul(e, e); + }), + (k.prototype.sqrt = function (e) { + if (e.isZero()) return e.clone(); + var t = this.m.andln(3); + if ((n(t % 2 == 1), 3 === t)) { + var r = this.m.add(new s(1)).iushrn(2); + return this.pow(e, r); + } + for ( + var i = this.m.subn(1), o = 0; + !i.isZero() && 0 === i.andln(1); + ) + (o++, i.iushrn(1)); + n(!i.isZero()); + var a = new s(1).toRed(this), + l = a.redNeg(), + c = this.m.subn(1).iushrn(1), + u = this.m.bitLength(); + for ( + u = new s(2 * u * u).toRed(this); + 0 !== this.pow(u, c).cmp(l); + ) + u.redIAdd(l); + for ( + var h = this.pow(u, i), + f = this.pow(e, i.addn(1).iushrn(1)), + d = this.pow(e, i), + p = o; + 0 !== d.cmp(a); + ) { + for (var m = d, b = 0; 0 !== m.cmp(a); b++) m = m.redSqr(); + n(b < p); + var g = this.pow(h, new s(1).iushln(p - b - 1)); + ((f = f.redMul(g)), + (h = g.redSqr()), + (d = d.redMul(h)), + (p = b)); + } + return f; + }), + (k.prototype.invm = function (e) { + var t = e._invmp(this.m); + return 0 !== t.negative + ? ((t.negative = 0), this.imod(t).redNeg()) + : this.imod(t); + }), + (k.prototype.pow = function (e, t) { + if (t.isZero()) return new s(1).toRed(this); + if (0 === t.cmpn(1)) return e.clone(); + var r = new Array(16); + ((r[0] = new s(1).toRed(this)), (r[1] = e)); + for (var n = 2; n < r.length; n++) r[n] = this.mul(r[n - 1], e); + var i = r[0], + o = 0, + a = 0, + l = t.bitLength() % 26; + for (0 === l && (l = 26), n = t.length - 1; n >= 0; n--) { + for (var c = t.words[n], u = l - 1; u >= 0; u--) { + var h = (c >> u) & 1; + (i !== r[0] && (i = this.sqr(i)), + 0 !== h || 0 !== o + ? ((o <<= 1), + (o |= h), + (4 === ++a || (0 === n && 0 === u)) && + ((i = this.mul(i, r[o])), (a = 0), (o = 0))) + : (a = 0)); + } + l = 26; + } + return i; + }), + (k.prototype.convertTo = function (e) { + var t = e.umod(this.m); + return t === e ? t.clone() : t; + }), + (k.prototype.convertFrom = function (e) { + var t = e.clone(); + return ((t.red = null), t); + }), + (s.mont = function (e) { + return new S(e); + }), + i(S, k), + (S.prototype.convertTo = function (e) { + return this.imod(e.ushln(this.shift)); + }), + (S.prototype.convertFrom = function (e) { + var t = this.imod(e.mul(this.rinv)); + return ((t.red = null), t); + }), + (S.prototype.imul = function (e, t) { + if (e.isZero() || t.isZero()) + return ((e.words[0] = 0), (e.length = 1), e); + var r = e.imul(t), + n = r + .maskn(this.shift) + .mul(this.minv) + .imaskn(this.shift) + .mul(this.m), + i = r.isub(n).iushrn(this.shift), + s = i; + return ( + i.cmp(this.m) >= 0 + ? (s = i.isub(this.m)) + : i.cmpn(0) < 0 && (s = i.iadd(this.m)), + s._forceRed(this) + ); + }), + (S.prototype.mul = function (e, t) { + if (e.isZero() || t.isZero()) return new s(0)._forceRed(this); + var r = e.mul(t), + n = r + .maskn(this.shift) + .mul(this.minv) + .imaskn(this.shift) + .mul(this.m), + i = r.isub(n).iushrn(this.shift), + o = i; + return ( + i.cmp(this.m) >= 0 + ? (o = i.isub(this.m)) + : i.cmpn(0) < 0 && (o = i.iadd(this.m)), + o._forceRed(this) + ); + }), + (S.prototype.invm = function (e) { + return this.imod(e._invmp(this.m).mul(this.r2))._forceRed(this); + })); + })(void 0 === t || t); + }, + { buffer: 188 }, + ], + 185: [ + function (e, t, r) { + "use strict"; + ((r.byteLength = function (e) { + var t = c(e), + r = t[0], + n = t[1]; + return (3 * (r + n)) / 4 - n; + }), + (r.toByteArray = function (e) { + var t, + r, + n = c(e), + o = n[0], + a = n[1], + l = new s( + (function (e, t, r) { + return (3 * (t + r)) / 4 - r; + })(0, o, a), + ), + u = 0, + h = a > 0 ? o - 4 : o; + for (r = 0; r < h; r += 4) + ((t = + (i[e.charCodeAt(r)] << 18) | + (i[e.charCodeAt(r + 1)] << 12) | + (i[e.charCodeAt(r + 2)] << 6) | + i[e.charCodeAt(r + 3)]), + (l[u++] = (t >> 16) & 255), + (l[u++] = (t >> 8) & 255), + (l[u++] = 255 & t)); + 2 === a && + ((t = + (i[e.charCodeAt(r)] << 2) | (i[e.charCodeAt(r + 1)] >> 4)), + (l[u++] = 255 & t)); + 1 === a && + ((t = + (i[e.charCodeAt(r)] << 10) | + (i[e.charCodeAt(r + 1)] << 4) | + (i[e.charCodeAt(r + 2)] >> 2)), + (l[u++] = (t >> 8) & 255), + (l[u++] = 255 & t)); + return l; + }), + (r.fromByteArray = function (e) { + for ( + var t, r = e.length, i = r % 3, s = [], o = 0, a = r - i; + o < a; + o += 16383 + ) + s.push(u(e, o, o + 16383 > a ? a : o + 16383)); + 1 === i + ? ((t = e[r - 1]), s.push(n[t >> 2] + n[(t << 4) & 63] + "==")) + : 2 === i && + ((t = (e[r - 2] << 8) + e[r - 1]), + s.push( + n[t >> 10] + n[(t >> 4) & 63] + n[(t << 2) & 63] + "=", + )); + return s.join(""); + })); + for ( + var n = [], + i = [], + s = "undefined" != typeof Uint8Array ? Uint8Array : Array, + o = + "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/", + a = 0, + l = o.length; + a < l; + ++a + ) + ((n[a] = o[a]), (i[o.charCodeAt(a)] = a)); + function c(e) { + var t = e.length; + if (t % 4 > 0) + throw new Error("Invalid string. Length must be a multiple of 4"); + var r = e.indexOf("="); + return (-1 === r && (r = t), [r, r === t ? 0 : 4 - (r % 4)]); + } + function u(e, t, r) { + for (var i, s, o = [], a = t; a < r; a += 3) + ((i = + ((e[a] << 16) & 16711680) + + ((e[a + 1] << 8) & 65280) + + (255 & e[a + 2])), + o.push( + n[((s = i) >> 18) & 63] + + n[(s >> 12) & 63] + + n[(s >> 6) & 63] + + n[63 & s], + )); + return o.join(""); + } + ((i["-".charCodeAt(0)] = 62), (i["_".charCodeAt(0)] = 63)); + }, + {}, + ], + 186: [ + function (e, t, r) { + "use strict"; + !(function (t, r) { + function n(e, t) { + if (!e) throw new Error(t || "Assertion failed"); + } + function i(e, t) { + e.super_ = t; + var r = function () {}; + ((r.prototype = t.prototype), + (e.prototype = new r()), + (e.prototype.constructor = e)); + } + function s(e, t, r) { + if (s.isBN(e)) return e; + ((this.negative = 0), + (this.words = null), + (this.length = 0), + (this.red = null), + null !== e && + (("le" !== t && "be" !== t) || ((r = t), (t = 10)), + this._init(e || 0, t || 10, r || "be"))); + } + var o; + ("object" == typeof t ? (t.exports = s) : ((void 0).BN = s), + (s.BN = s), + (s.wordSize = 26)); + try { + o = + "undefined" != typeof window && void 0 !== window.Buffer + ? window.Buffer + : e("buffer").Buffer; + } catch (e) {} + function a(e, t) { + var r = e.charCodeAt(t); + return r >= 48 && r <= 57 + ? r - 48 + : r >= 65 && r <= 70 + ? r - 55 + : r >= 97 && r <= 102 + ? r - 87 + : void n(!1, "Invalid character in " + e); + } + function l(e, t, r) { + var n = a(e, r); + return (r - 1 >= t && (n |= a(e, r - 1) << 4), n); + } + function c(e, t, r, i) { + for ( + var s = 0, o = 0, a = Math.min(e.length, r), l = t; + l < a; + l++ + ) { + var c = e.charCodeAt(l) - 48; + ((s *= i), + (o = c >= 49 ? c - 49 + 10 : c >= 17 ? c - 17 + 10 : c), + n(c >= 0 && o < i, "Invalid character"), + (s += o)); + } + return s; + } + function u(e, t) { + ((e.words = t.words), + (e.length = t.length), + (e.negative = t.negative), + (e.red = t.red)); + } + if ( + ((s.isBN = function (e) { + return ( + e instanceof s || + (null !== e && + "object" == typeof e && + e.constructor.wordSize === s.wordSize && + Array.isArray(e.words)) + ); + }), + (s.max = function (e, t) { + return e.cmp(t) > 0 ? e : t; + }), + (s.min = function (e, t) { + return e.cmp(t) < 0 ? e : t; + }), + (s.prototype._init = function (e, t, r) { + if ("number" == typeof e) return this._initNumber(e, t, r); + if ("object" == typeof e) return this._initArray(e, t, r); + ("hex" === t && (t = 16), + n(t === (0 | t) && t >= 2 && t <= 36)); + var i = 0; + ("-" === (e = e.toString().replace(/\s+/g, ""))[0] && + (i++, (this.negative = 1)), + i < e.length && + (16 === t + ? this._parseHex(e, i, r) + : (this._parseBase(e, t, i), + "le" === r && this._initArray(this.toArray(), t, r)))); + }), + (s.prototype._initNumber = function (e, t, r) { + (e < 0 && ((this.negative = 1), (e = -e)), + e < 67108864 + ? ((this.words = [67108863 & e]), (this.length = 1)) + : e < 4503599627370496 + ? ((this.words = [ + 67108863 & e, + (e / 67108864) & 67108863, + ]), + (this.length = 2)) + : (n(e < 9007199254740992), + (this.words = [ + 67108863 & e, + (e / 67108864) & 67108863, + 1, + ]), + (this.length = 3)), + "le" === r && this._initArray(this.toArray(), t, r)); + }), + (s.prototype._initArray = function (e, t, r) { + if ((n("number" == typeof e.length), e.length <= 0)) + return ((this.words = [0]), (this.length = 1), this); + ((this.length = Math.ceil(e.length / 3)), + (this.words = new Array(this.length))); + for (var i = 0; i < this.length; i++) this.words[i] = 0; + var s, + o, + a = 0; + if ("be" === r) + for (i = e.length - 1, s = 0; i >= 0; i -= 3) + ((o = e[i] | (e[i - 1] << 8) | (e[i - 2] << 16)), + (this.words[s] |= (o << a) & 67108863), + (this.words[s + 1] = (o >>> (26 - a)) & 67108863), + (a += 24) >= 26 && ((a -= 26), s++)); + else if ("le" === r) + for (i = 0, s = 0; i < e.length; i += 3) + ((o = e[i] | (e[i + 1] << 8) | (e[i + 2] << 16)), + (this.words[s] |= (o << a) & 67108863), + (this.words[s + 1] = (o >>> (26 - a)) & 67108863), + (a += 24) >= 26 && ((a -= 26), s++)); + return this._strip(); + }), + (s.prototype._parseHex = function (e, t, r) { + ((this.length = Math.ceil((e.length - t) / 6)), + (this.words = new Array(this.length))); + for (var n = 0; n < this.length; n++) this.words[n] = 0; + var i, + s = 0, + o = 0; + if ("be" === r) + for (n = e.length - 1; n >= t; n -= 2) + ((i = l(e, t, n) << s), + (this.words[o] |= 67108863 & i), + s >= 18 + ? ((s -= 18), (o += 1), (this.words[o] |= i >>> 26)) + : (s += 8)); + else + for ( + n = (e.length - t) % 2 == 0 ? t + 1 : t; + n < e.length; + n += 2 + ) + ((i = l(e, t, n) << s), + (this.words[o] |= 67108863 & i), + s >= 18 + ? ((s -= 18), (o += 1), (this.words[o] |= i >>> 26)) + : (s += 8)); + this._strip(); + }), + (s.prototype._parseBase = function (e, t, r) { + ((this.words = [0]), (this.length = 1)); + for (var n = 0, i = 1; i <= 67108863; i *= t) n++; + (n--, (i = (i / t) | 0)); + for ( + var s = e.length - r, + o = s % n, + a = Math.min(s, s - o) + r, + l = 0, + u = r; + u < a; + u += n + ) + ((l = c(e, u, u + n, t)), + this.imuln(i), + this.words[0] + l < 67108864 + ? (this.words[0] += l) + : this._iaddn(l)); + if (0 !== o) { + var h = 1; + for (l = c(e, u, e.length, t), u = 0; u < o; u++) h *= t; + (this.imuln(h), + this.words[0] + l < 67108864 + ? (this.words[0] += l) + : this._iaddn(l)); + } + this._strip(); + }), + (s.prototype.copy = function (e) { + e.words = new Array(this.length); + for (var t = 0; t < this.length; t++) + e.words[t] = this.words[t]; + ((e.length = this.length), + (e.negative = this.negative), + (e.red = this.red)); + }), + (s.prototype._move = function (e) { + u(e, this); + }), + (s.prototype.clone = function () { + var e = new s(null); + return (this.copy(e), e); + }), + (s.prototype._expand = function (e) { + for (; this.length < e; ) this.words[this.length++] = 0; + return this; + }), + (s.prototype._strip = function () { + for (; this.length > 1 && 0 === this.words[this.length - 1]; ) + this.length--; + return this._normSign(); + }), + (s.prototype._normSign = function () { + return ( + 1 === this.length && + 0 === this.words[0] && + (this.negative = 0), + this + ); + }), + "undefined" != typeof Symbol && "function" == typeof Symbol.for) + ) + try { + s.prototype[Symbol.for("nodejs.util.inspect.custom")] = h; + } catch (e) { + s.prototype.inspect = h; + } + else s.prototype.inspect = h; + function h() { + return (this.red ? ""; + } + var f = [ + "", + "0", + "00", + "000", + "0000", + "00000", + "000000", + "0000000", + "00000000", + "000000000", + "0000000000", + "00000000000", + "000000000000", + "0000000000000", + "00000000000000", + "000000000000000", + "0000000000000000", + "00000000000000000", + "000000000000000000", + "0000000000000000000", + "00000000000000000000", + "000000000000000000000", + "0000000000000000000000", + "00000000000000000000000", + "000000000000000000000000", + "0000000000000000000000000", + ], + d = [ + 0, 0, 25, 16, 12, 11, 10, 9, 8, 8, 7, 7, 7, 7, 6, 6, 6, 6, 6, 6, + 6, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, + ], + p = [ + 0, 0, 33554432, 43046721, 16777216, 48828125, 60466176, + 40353607, 16777216, 43046721, 1e7, 19487171, 35831808, 62748517, + 7529536, 11390625, 16777216, 24137569, 34012224, 47045881, 64e6, + 4084101, 5153632, 6436343, 7962624, 9765625, 11881376, 14348907, + 17210368, 20511149, 243e5, 28629151, 33554432, 39135393, + 45435424, 52521875, 60466176, + ]; + ((s.prototype.toString = function (e, t) { + var r; + if (((t = 0 | t || 1), 16 === (e = e || 10) || "hex" === e)) { + r = ""; + for (var i = 0, s = 0, o = 0; o < this.length; o++) { + var a = this.words[o], + l = (16777215 & ((a << i) | s)).toString(16); + ((s = (a >>> (24 - i)) & 16777215), + (i += 2) >= 26 && ((i -= 26), o--), + (r = + 0 !== s || o !== this.length - 1 + ? f[6 - l.length] + l + r + : l + r)); + } + for (0 !== s && (r = s.toString(16) + r); r.length % t != 0; ) + r = "0" + r; + return (0 !== this.negative && (r = "-" + r), r); + } + if (e === (0 | e) && e >= 2 && e <= 36) { + var c = d[e], + u = p[e]; + r = ""; + var h = this.clone(); + for (h.negative = 0; !h.isZero(); ) { + var m = h.modrn(u).toString(e); + r = (h = h.idivn(u)).isZero() + ? m + r + : f[c - m.length] + m + r; + } + for (this.isZero() && (r = "0" + r); r.length % t != 0; ) + r = "0" + r; + return (0 !== this.negative && (r = "-" + r), r); + } + n(!1, "Base should be between 2 and 36"); + }), + (s.prototype.toNumber = function () { + var e = this.words[0]; + return ( + 2 === this.length + ? (e += 67108864 * this.words[1]) + : 3 === this.length && 1 === this.words[2] + ? (e += 4503599627370496 + 67108864 * this.words[1]) + : this.length > 2 && + n(!1, "Number can only safely store up to 53 bits"), + 0 !== this.negative ? -e : e + ); + }), + (s.prototype.toJSON = function () { + return this.toString(16, 2); + }), + o && + (s.prototype.toBuffer = function (e, t) { + return this.toArrayLike(o, e, t); + }), + (s.prototype.toArray = function (e, t) { + return this.toArrayLike(Array, e, t); + })); + function m(e, t, r) { + r.negative = t.negative ^ e.negative; + var n = (e.length + t.length) | 0; + ((r.length = n), (n = (n - 1) | 0)); + var i = 0 | e.words[0], + s = 0 | t.words[0], + o = i * s, + a = 67108863 & o, + l = (o / 67108864) | 0; + r.words[0] = a; + for (var c = 1; c < n; c++) { + for ( + var u = l >>> 26, + h = 67108863 & l, + f = Math.min(c, t.length - 1), + d = Math.max(0, c - e.length + 1); + d <= f; + d++ + ) { + var p = (c - d) | 0; + ((u += + ((o = (i = 0 | e.words[p]) * (s = 0 | t.words[d]) + h) / + 67108864) | + 0), + (h = 67108863 & o)); + } + ((r.words[c] = 0 | h), (l = 0 | u)); + } + return (0 !== l ? (r.words[c] = 0 | l) : r.length--, r._strip()); + } + ((s.prototype.toArrayLike = function (e, t, r) { + this._strip(); + var i = this.byteLength(), + s = r || Math.max(1, i); + (n(i <= s, "byte array longer than desired length"), + n(s > 0, "Requested array length <= 0")); + var o = (function (e, t) { + return e.allocUnsafe ? e.allocUnsafe(t) : new e(t); + })(e, s); + return ( + this["_toArrayLike" + ("le" === t ? "LE" : "BE")](o, i), + o + ); + }), + (s.prototype._toArrayLikeLE = function (e, t) { + for (var r = 0, n = 0, i = 0, s = 0; i < this.length; i++) { + var o = (this.words[i] << s) | n; + ((e[r++] = 255 & o), + r < e.length && (e[r++] = (o >> 8) & 255), + r < e.length && (e[r++] = (o >> 16) & 255), + 6 === s + ? (r < e.length && (e[r++] = (o >> 24) & 255), + (n = 0), + (s = 0)) + : ((n = o >>> 24), (s += 2))); + } + if (r < e.length) for (e[r++] = n; r < e.length; ) e[r++] = 0; + }), + (s.prototype._toArrayLikeBE = function (e, t) { + for ( + var r = e.length - 1, n = 0, i = 0, s = 0; + i < this.length; + i++ + ) { + var o = (this.words[i] << s) | n; + ((e[r--] = 255 & o), + r >= 0 && (e[r--] = (o >> 8) & 255), + r >= 0 && (e[r--] = (o >> 16) & 255), + 6 === s + ? (r >= 0 && (e[r--] = (o >> 24) & 255), (n = 0), (s = 0)) + : ((n = o >>> 24), (s += 2))); + } + if (r >= 0) for (e[r--] = n; r >= 0; ) e[r--] = 0; + }), + Math.clz32 + ? (s.prototype._countBits = function (e) { + return 32 - Math.clz32(e); + }) + : (s.prototype._countBits = function (e) { + var t = e, + r = 0; + return ( + t >= 4096 && ((r += 13), (t >>>= 13)), + t >= 64 && ((r += 7), (t >>>= 7)), + t >= 8 && ((r += 4), (t >>>= 4)), + t >= 2 && ((r += 2), (t >>>= 2)), + r + t + ); + }), + (s.prototype._zeroBits = function (e) { + if (0 === e) return 26; + var t = e, + r = 0; + return ( + 0 == (8191 & t) && ((r += 13), (t >>>= 13)), + 0 == (127 & t) && ((r += 7), (t >>>= 7)), + 0 == (15 & t) && ((r += 4), (t >>>= 4)), + 0 == (3 & t) && ((r += 2), (t >>>= 2)), + 0 == (1 & t) && r++, + r + ); + }), + (s.prototype.bitLength = function () { + var e = this.words[this.length - 1], + t = this._countBits(e); + return 26 * (this.length - 1) + t; + }), + (s.prototype.zeroBits = function () { + if (this.isZero()) return 0; + for (var e = 0, t = 0; t < this.length; t++) { + var r = this._zeroBits(this.words[t]); + if (((e += r), 26 !== r)) break; + } + return e; + }), + (s.prototype.byteLength = function () { + return Math.ceil(this.bitLength() / 8); + }), + (s.prototype.toTwos = function (e) { + return 0 !== this.negative + ? this.abs().inotn(e).iaddn(1) + : this.clone(); + }), + (s.prototype.fromTwos = function (e) { + return this.testn(e - 1) + ? this.notn(e).iaddn(1).ineg() + : this.clone(); + }), + (s.prototype.isNeg = function () { + return 0 !== this.negative; + }), + (s.prototype.neg = function () { + return this.clone().ineg(); + }), + (s.prototype.ineg = function () { + return (this.isZero() || (this.negative ^= 1), this); + }), + (s.prototype.iuor = function (e) { + for (; this.length < e.length; ) this.words[this.length++] = 0; + for (var t = 0; t < e.length; t++) + this.words[t] = this.words[t] | e.words[t]; + return this._strip(); + }), + (s.prototype.ior = function (e) { + return (n(0 == (this.negative | e.negative)), this.iuor(e)); + }), + (s.prototype.or = function (e) { + return this.length > e.length + ? this.clone().ior(e) + : e.clone().ior(this); + }), + (s.prototype.uor = function (e) { + return this.length > e.length + ? this.clone().iuor(e) + : e.clone().iuor(this); + }), + (s.prototype.iuand = function (e) { + var t; + t = this.length > e.length ? e : this; + for (var r = 0; r < t.length; r++) + this.words[r] = this.words[r] & e.words[r]; + return ((this.length = t.length), this._strip()); + }), + (s.prototype.iand = function (e) { + return (n(0 == (this.negative | e.negative)), this.iuand(e)); + }), + (s.prototype.and = function (e) { + return this.length > e.length + ? this.clone().iand(e) + : e.clone().iand(this); + }), + (s.prototype.uand = function (e) { + return this.length > e.length + ? this.clone().iuand(e) + : e.clone().iuand(this); + }), + (s.prototype.iuxor = function (e) { + var t, r; + this.length > e.length + ? ((t = this), (r = e)) + : ((t = e), (r = this)); + for (var n = 0; n < r.length; n++) + this.words[n] = t.words[n] ^ r.words[n]; + if (this !== t) + for (; n < t.length; n++) this.words[n] = t.words[n]; + return ((this.length = t.length), this._strip()); + }), + (s.prototype.ixor = function (e) { + return (n(0 == (this.negative | e.negative)), this.iuxor(e)); + }), + (s.prototype.xor = function (e) { + return this.length > e.length + ? this.clone().ixor(e) + : e.clone().ixor(this); + }), + (s.prototype.uxor = function (e) { + return this.length > e.length + ? this.clone().iuxor(e) + : e.clone().iuxor(this); + }), + (s.prototype.inotn = function (e) { + n("number" == typeof e && e >= 0); + var t = 0 | Math.ceil(e / 26), + r = e % 26; + (this._expand(t), r > 0 && t--); + for (var i = 0; i < t; i++) + this.words[i] = 67108863 & ~this.words[i]; + return ( + r > 0 && + (this.words[i] = ~this.words[i] & (67108863 >> (26 - r))), + this._strip() + ); + }), + (s.prototype.notn = function (e) { + return this.clone().inotn(e); + }), + (s.prototype.setn = function (e, t) { + n("number" == typeof e && e >= 0); + var r = (e / 26) | 0, + i = e % 26; + return ( + this._expand(r + 1), + (this.words[r] = t + ? this.words[r] | (1 << i) + : this.words[r] & ~(1 << i)), + this._strip() + ); + }), + (s.prototype.iadd = function (e) { + var t, r, n; + if (0 !== this.negative && 0 === e.negative) + return ( + (this.negative = 0), + (t = this.isub(e)), + (this.negative ^= 1), + this._normSign() + ); + if (0 === this.negative && 0 !== e.negative) + return ( + (e.negative = 0), + (t = this.isub(e)), + (e.negative = 1), + t._normSign() + ); + this.length > e.length + ? ((r = this), (n = e)) + : ((r = e), (n = this)); + for (var i = 0, s = 0; s < n.length; s++) + ((t = (0 | r.words[s]) + (0 | n.words[s]) + i), + (this.words[s] = 67108863 & t), + (i = t >>> 26)); + for (; 0 !== i && s < r.length; s++) + ((t = (0 | r.words[s]) + i), + (this.words[s] = 67108863 & t), + (i = t >>> 26)); + if (((this.length = r.length), 0 !== i)) + ((this.words[this.length] = i), this.length++); + else if (r !== this) + for (; s < r.length; s++) this.words[s] = r.words[s]; + return this; + }), + (s.prototype.add = function (e) { + var t; + return 0 !== e.negative && 0 === this.negative + ? ((e.negative = 0), (t = this.sub(e)), (e.negative ^= 1), t) + : 0 === e.negative && 0 !== this.negative + ? ((this.negative = 0), + (t = e.sub(this)), + (this.negative = 1), + t) + : this.length > e.length + ? this.clone().iadd(e) + : e.clone().iadd(this); + }), + (s.prototype.isub = function (e) { + if (0 !== e.negative) { + e.negative = 0; + var t = this.iadd(e); + return ((e.negative = 1), t._normSign()); + } + if (0 !== this.negative) + return ( + (this.negative = 0), + this.iadd(e), + (this.negative = 1), + this._normSign() + ); + var r, + n, + i = this.cmp(e); + if (0 === i) + return ( + (this.negative = 0), + (this.length = 1), + (this.words[0] = 0), + this + ); + i > 0 ? ((r = this), (n = e)) : ((r = e), (n = this)); + for (var s = 0, o = 0; o < n.length; o++) + ((s = (t = (0 | r.words[o]) - (0 | n.words[o]) + s) >> 26), + (this.words[o] = 67108863 & t)); + for (; 0 !== s && o < r.length; o++) + ((s = (t = (0 | r.words[o]) + s) >> 26), + (this.words[o] = 67108863 & t)); + if (0 === s && o < r.length && r !== this) + for (; o < r.length; o++) this.words[o] = r.words[o]; + return ( + (this.length = Math.max(this.length, o)), + r !== this && (this.negative = 1), + this._strip() + ); + }), + (s.prototype.sub = function (e) { + return this.clone().isub(e); + })); + var b = function (e, t, r) { + var n, + i, + s, + o = e.words, + a = t.words, + l = r.words, + c = 0, + u = 0 | o[0], + h = 8191 & u, + f = u >>> 13, + d = 0 | o[1], + p = 8191 & d, + m = d >>> 13, + b = 0 | o[2], + g = 8191 & b, + y = b >>> 13, + v = 0 | o[3], + w = 8191 & v, + _ = v >>> 13, + x = 0 | o[4], + k = 8191 & x, + S = x >>> 13, + M = 0 | o[5], + C = 8191 & M, + T = M >>> 13, + E = 0 | o[6], + A = 8191 & E, + R = E >>> 13, + O = 0 | o[7], + j = 8191 & O, + I = O >>> 13, + N = 0 | o[8], + P = 8191 & N, + B = N >>> 13, + D = 0 | o[9], + F = 8191 & D, + L = D >>> 13, + z = 0 | a[0], + U = 8191 & z, + $ = z >>> 13, + H = 0 | a[1], + V = 8191 & H, + q = H >>> 13, + W = 0 | a[2], + X = 8191 & W, + K = W >>> 13, + Y = 0 | a[3], + Z = 8191 & Y, + G = Y >>> 13, + J = 0 | a[4], + Q = 8191 & J, + ee = J >>> 13, + te = 0 | a[5], + re = 8191 & te, + ne = te >>> 13, + ie = 0 | a[6], + se = 8191 & ie, + oe = ie >>> 13, + ae = 0 | a[7], + le = 8191 & ae, + ce = ae >>> 13, + ue = 0 | a[8], + he = 8191 & ue, + fe = ue >>> 13, + de = 0 | a[9], + pe = 8191 & de, + me = de >>> 13; + ((r.negative = e.negative ^ t.negative), (r.length = 19)); + var be = + (((c + (n = Math.imul(h, U))) | 0) + + ((8191 & + (i = ((i = Math.imul(h, $)) + Math.imul(f, U)) | 0)) << + 13)) | + 0; + ((c = + ((((s = Math.imul(f, $)) + (i >>> 13)) | 0) + (be >>> 26)) | 0), + (be &= 67108863), + (n = Math.imul(p, U)), + (i = ((i = Math.imul(p, $)) + Math.imul(m, U)) | 0), + (s = Math.imul(m, $))); + var ge = + (((c + (n = (n + Math.imul(h, V)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, q)) | 0) + Math.imul(f, V)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, q)) | 0) + (i >>> 13)) | 0) + + (ge >>> 26)) | + 0), + (ge &= 67108863), + (n = Math.imul(g, U)), + (i = ((i = Math.imul(g, $)) + Math.imul(y, U)) | 0), + (s = Math.imul(y, $)), + (n = (n + Math.imul(p, V)) | 0), + (i = ((i = (i + Math.imul(p, q)) | 0) + Math.imul(m, V)) | 0), + (s = (s + Math.imul(m, q)) | 0)); + var ye = + (((c + (n = (n + Math.imul(h, X)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, K)) | 0) + Math.imul(f, X)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, K)) | 0) + (i >>> 13)) | 0) + + (ye >>> 26)) | + 0), + (ye &= 67108863), + (n = Math.imul(w, U)), + (i = ((i = Math.imul(w, $)) + Math.imul(_, U)) | 0), + (s = Math.imul(_, $)), + (n = (n + Math.imul(g, V)) | 0), + (i = ((i = (i + Math.imul(g, q)) | 0) + Math.imul(y, V)) | 0), + (s = (s + Math.imul(y, q)) | 0), + (n = (n + Math.imul(p, X)) | 0), + (i = ((i = (i + Math.imul(p, K)) | 0) + Math.imul(m, X)) | 0), + (s = (s + Math.imul(m, K)) | 0)); + var ve = + (((c + (n = (n + Math.imul(h, Z)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, G)) | 0) + Math.imul(f, Z)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, G)) | 0) + (i >>> 13)) | 0) + + (ve >>> 26)) | + 0), + (ve &= 67108863), + (n = Math.imul(k, U)), + (i = ((i = Math.imul(k, $)) + Math.imul(S, U)) | 0), + (s = Math.imul(S, $)), + (n = (n + Math.imul(w, V)) | 0), + (i = ((i = (i + Math.imul(w, q)) | 0) + Math.imul(_, V)) | 0), + (s = (s + Math.imul(_, q)) | 0), + (n = (n + Math.imul(g, X)) | 0), + (i = ((i = (i + Math.imul(g, K)) | 0) + Math.imul(y, X)) | 0), + (s = (s + Math.imul(y, K)) | 0), + (n = (n + Math.imul(p, Z)) | 0), + (i = ((i = (i + Math.imul(p, G)) | 0) + Math.imul(m, Z)) | 0), + (s = (s + Math.imul(m, G)) | 0)); + var we = + (((c + (n = (n + Math.imul(h, Q)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, ee)) | 0) + Math.imul(f, Q)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, ee)) | 0) + (i >>> 13)) | 0) + + (we >>> 26)) | + 0), + (we &= 67108863), + (n = Math.imul(C, U)), + (i = ((i = Math.imul(C, $)) + Math.imul(T, U)) | 0), + (s = Math.imul(T, $)), + (n = (n + Math.imul(k, V)) | 0), + (i = ((i = (i + Math.imul(k, q)) | 0) + Math.imul(S, V)) | 0), + (s = (s + Math.imul(S, q)) | 0), + (n = (n + Math.imul(w, X)) | 0), + (i = ((i = (i + Math.imul(w, K)) | 0) + Math.imul(_, X)) | 0), + (s = (s + Math.imul(_, K)) | 0), + (n = (n + Math.imul(g, Z)) | 0), + (i = ((i = (i + Math.imul(g, G)) | 0) + Math.imul(y, Z)) | 0), + (s = (s + Math.imul(y, G)) | 0), + (n = (n + Math.imul(p, Q)) | 0), + (i = ((i = (i + Math.imul(p, ee)) | 0) + Math.imul(m, Q)) | 0), + (s = (s + Math.imul(m, ee)) | 0)); + var _e = + (((c + (n = (n + Math.imul(h, re)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, ne)) | 0) + Math.imul(f, re)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, ne)) | 0) + (i >>> 13)) | 0) + + (_e >>> 26)) | + 0), + (_e &= 67108863), + (n = Math.imul(A, U)), + (i = ((i = Math.imul(A, $)) + Math.imul(R, U)) | 0), + (s = Math.imul(R, $)), + (n = (n + Math.imul(C, V)) | 0), + (i = ((i = (i + Math.imul(C, q)) | 0) + Math.imul(T, V)) | 0), + (s = (s + Math.imul(T, q)) | 0), + (n = (n + Math.imul(k, X)) | 0), + (i = ((i = (i + Math.imul(k, K)) | 0) + Math.imul(S, X)) | 0), + (s = (s + Math.imul(S, K)) | 0), + (n = (n + Math.imul(w, Z)) | 0), + (i = ((i = (i + Math.imul(w, G)) | 0) + Math.imul(_, Z)) | 0), + (s = (s + Math.imul(_, G)) | 0), + (n = (n + Math.imul(g, Q)) | 0), + (i = ((i = (i + Math.imul(g, ee)) | 0) + Math.imul(y, Q)) | 0), + (s = (s + Math.imul(y, ee)) | 0), + (n = (n + Math.imul(p, re)) | 0), + (i = ((i = (i + Math.imul(p, ne)) | 0) + Math.imul(m, re)) | 0), + (s = (s + Math.imul(m, ne)) | 0)); + var xe = + (((c + (n = (n + Math.imul(h, se)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, oe)) | 0) + Math.imul(f, se)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, oe)) | 0) + (i >>> 13)) | 0) + + (xe >>> 26)) | + 0), + (xe &= 67108863), + (n = Math.imul(j, U)), + (i = ((i = Math.imul(j, $)) + Math.imul(I, U)) | 0), + (s = Math.imul(I, $)), + (n = (n + Math.imul(A, V)) | 0), + (i = ((i = (i + Math.imul(A, q)) | 0) + Math.imul(R, V)) | 0), + (s = (s + Math.imul(R, q)) | 0), + (n = (n + Math.imul(C, X)) | 0), + (i = ((i = (i + Math.imul(C, K)) | 0) + Math.imul(T, X)) | 0), + (s = (s + Math.imul(T, K)) | 0), + (n = (n + Math.imul(k, Z)) | 0), + (i = ((i = (i + Math.imul(k, G)) | 0) + Math.imul(S, Z)) | 0), + (s = (s + Math.imul(S, G)) | 0), + (n = (n + Math.imul(w, Q)) | 0), + (i = ((i = (i + Math.imul(w, ee)) | 0) + Math.imul(_, Q)) | 0), + (s = (s + Math.imul(_, ee)) | 0), + (n = (n + Math.imul(g, re)) | 0), + (i = ((i = (i + Math.imul(g, ne)) | 0) + Math.imul(y, re)) | 0), + (s = (s + Math.imul(y, ne)) | 0), + (n = (n + Math.imul(p, se)) | 0), + (i = ((i = (i + Math.imul(p, oe)) | 0) + Math.imul(m, se)) | 0), + (s = (s + Math.imul(m, oe)) | 0)); + var ke = + (((c + (n = (n + Math.imul(h, le)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, ce)) | 0) + Math.imul(f, le)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, ce)) | 0) + (i >>> 13)) | 0) + + (ke >>> 26)) | + 0), + (ke &= 67108863), + (n = Math.imul(P, U)), + (i = ((i = Math.imul(P, $)) + Math.imul(B, U)) | 0), + (s = Math.imul(B, $)), + (n = (n + Math.imul(j, V)) | 0), + (i = ((i = (i + Math.imul(j, q)) | 0) + Math.imul(I, V)) | 0), + (s = (s + Math.imul(I, q)) | 0), + (n = (n + Math.imul(A, X)) | 0), + (i = ((i = (i + Math.imul(A, K)) | 0) + Math.imul(R, X)) | 0), + (s = (s + Math.imul(R, K)) | 0), + (n = (n + Math.imul(C, Z)) | 0), + (i = ((i = (i + Math.imul(C, G)) | 0) + Math.imul(T, Z)) | 0), + (s = (s + Math.imul(T, G)) | 0), + (n = (n + Math.imul(k, Q)) | 0), + (i = ((i = (i + Math.imul(k, ee)) | 0) + Math.imul(S, Q)) | 0), + (s = (s + Math.imul(S, ee)) | 0), + (n = (n + Math.imul(w, re)) | 0), + (i = ((i = (i + Math.imul(w, ne)) | 0) + Math.imul(_, re)) | 0), + (s = (s + Math.imul(_, ne)) | 0), + (n = (n + Math.imul(g, se)) | 0), + (i = ((i = (i + Math.imul(g, oe)) | 0) + Math.imul(y, se)) | 0), + (s = (s + Math.imul(y, oe)) | 0), + (n = (n + Math.imul(p, le)) | 0), + (i = ((i = (i + Math.imul(p, ce)) | 0) + Math.imul(m, le)) | 0), + (s = (s + Math.imul(m, ce)) | 0)); + var Se = + (((c + (n = (n + Math.imul(h, he)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, fe)) | 0) + Math.imul(f, he)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, fe)) | 0) + (i >>> 13)) | 0) + + (Se >>> 26)) | + 0), + (Se &= 67108863), + (n = Math.imul(F, U)), + (i = ((i = Math.imul(F, $)) + Math.imul(L, U)) | 0), + (s = Math.imul(L, $)), + (n = (n + Math.imul(P, V)) | 0), + (i = ((i = (i + Math.imul(P, q)) | 0) + Math.imul(B, V)) | 0), + (s = (s + Math.imul(B, q)) | 0), + (n = (n + Math.imul(j, X)) | 0), + (i = ((i = (i + Math.imul(j, K)) | 0) + Math.imul(I, X)) | 0), + (s = (s + Math.imul(I, K)) | 0), + (n = (n + Math.imul(A, Z)) | 0), + (i = ((i = (i + Math.imul(A, G)) | 0) + Math.imul(R, Z)) | 0), + (s = (s + Math.imul(R, G)) | 0), + (n = (n + Math.imul(C, Q)) | 0), + (i = ((i = (i + Math.imul(C, ee)) | 0) + Math.imul(T, Q)) | 0), + (s = (s + Math.imul(T, ee)) | 0), + (n = (n + Math.imul(k, re)) | 0), + (i = ((i = (i + Math.imul(k, ne)) | 0) + Math.imul(S, re)) | 0), + (s = (s + Math.imul(S, ne)) | 0), + (n = (n + Math.imul(w, se)) | 0), + (i = ((i = (i + Math.imul(w, oe)) | 0) + Math.imul(_, se)) | 0), + (s = (s + Math.imul(_, oe)) | 0), + (n = (n + Math.imul(g, le)) | 0), + (i = ((i = (i + Math.imul(g, ce)) | 0) + Math.imul(y, le)) | 0), + (s = (s + Math.imul(y, ce)) | 0), + (n = (n + Math.imul(p, he)) | 0), + (i = ((i = (i + Math.imul(p, fe)) | 0) + Math.imul(m, he)) | 0), + (s = (s + Math.imul(m, fe)) | 0)); + var Me = + (((c + (n = (n + Math.imul(h, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(h, me)) | 0) + Math.imul(f, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(f, me)) | 0) + (i >>> 13)) | 0) + + (Me >>> 26)) | + 0), + (Me &= 67108863), + (n = Math.imul(F, V)), + (i = ((i = Math.imul(F, q)) + Math.imul(L, V)) | 0), + (s = Math.imul(L, q)), + (n = (n + Math.imul(P, X)) | 0), + (i = ((i = (i + Math.imul(P, K)) | 0) + Math.imul(B, X)) | 0), + (s = (s + Math.imul(B, K)) | 0), + (n = (n + Math.imul(j, Z)) | 0), + (i = ((i = (i + Math.imul(j, G)) | 0) + Math.imul(I, Z)) | 0), + (s = (s + Math.imul(I, G)) | 0), + (n = (n + Math.imul(A, Q)) | 0), + (i = ((i = (i + Math.imul(A, ee)) | 0) + Math.imul(R, Q)) | 0), + (s = (s + Math.imul(R, ee)) | 0), + (n = (n + Math.imul(C, re)) | 0), + (i = ((i = (i + Math.imul(C, ne)) | 0) + Math.imul(T, re)) | 0), + (s = (s + Math.imul(T, ne)) | 0), + (n = (n + Math.imul(k, se)) | 0), + (i = ((i = (i + Math.imul(k, oe)) | 0) + Math.imul(S, se)) | 0), + (s = (s + Math.imul(S, oe)) | 0), + (n = (n + Math.imul(w, le)) | 0), + (i = ((i = (i + Math.imul(w, ce)) | 0) + Math.imul(_, le)) | 0), + (s = (s + Math.imul(_, ce)) | 0), + (n = (n + Math.imul(g, he)) | 0), + (i = ((i = (i + Math.imul(g, fe)) | 0) + Math.imul(y, he)) | 0), + (s = (s + Math.imul(y, fe)) | 0)); + var Ce = + (((c + (n = (n + Math.imul(p, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(p, me)) | 0) + Math.imul(m, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(m, me)) | 0) + (i >>> 13)) | 0) + + (Ce >>> 26)) | + 0), + (Ce &= 67108863), + (n = Math.imul(F, X)), + (i = ((i = Math.imul(F, K)) + Math.imul(L, X)) | 0), + (s = Math.imul(L, K)), + (n = (n + Math.imul(P, Z)) | 0), + (i = ((i = (i + Math.imul(P, G)) | 0) + Math.imul(B, Z)) | 0), + (s = (s + Math.imul(B, G)) | 0), + (n = (n + Math.imul(j, Q)) | 0), + (i = ((i = (i + Math.imul(j, ee)) | 0) + Math.imul(I, Q)) | 0), + (s = (s + Math.imul(I, ee)) | 0), + (n = (n + Math.imul(A, re)) | 0), + (i = ((i = (i + Math.imul(A, ne)) | 0) + Math.imul(R, re)) | 0), + (s = (s + Math.imul(R, ne)) | 0), + (n = (n + Math.imul(C, se)) | 0), + (i = ((i = (i + Math.imul(C, oe)) | 0) + Math.imul(T, se)) | 0), + (s = (s + Math.imul(T, oe)) | 0), + (n = (n + Math.imul(k, le)) | 0), + (i = ((i = (i + Math.imul(k, ce)) | 0) + Math.imul(S, le)) | 0), + (s = (s + Math.imul(S, ce)) | 0), + (n = (n + Math.imul(w, he)) | 0), + (i = ((i = (i + Math.imul(w, fe)) | 0) + Math.imul(_, he)) | 0), + (s = (s + Math.imul(_, fe)) | 0)); + var Te = + (((c + (n = (n + Math.imul(g, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(g, me)) | 0) + Math.imul(y, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(y, me)) | 0) + (i >>> 13)) | 0) + + (Te >>> 26)) | + 0), + (Te &= 67108863), + (n = Math.imul(F, Z)), + (i = ((i = Math.imul(F, G)) + Math.imul(L, Z)) | 0), + (s = Math.imul(L, G)), + (n = (n + Math.imul(P, Q)) | 0), + (i = ((i = (i + Math.imul(P, ee)) | 0) + Math.imul(B, Q)) | 0), + (s = (s + Math.imul(B, ee)) | 0), + (n = (n + Math.imul(j, re)) | 0), + (i = ((i = (i + Math.imul(j, ne)) | 0) + Math.imul(I, re)) | 0), + (s = (s + Math.imul(I, ne)) | 0), + (n = (n + Math.imul(A, se)) | 0), + (i = ((i = (i + Math.imul(A, oe)) | 0) + Math.imul(R, se)) | 0), + (s = (s + Math.imul(R, oe)) | 0), + (n = (n + Math.imul(C, le)) | 0), + (i = ((i = (i + Math.imul(C, ce)) | 0) + Math.imul(T, le)) | 0), + (s = (s + Math.imul(T, ce)) | 0), + (n = (n + Math.imul(k, he)) | 0), + (i = ((i = (i + Math.imul(k, fe)) | 0) + Math.imul(S, he)) | 0), + (s = (s + Math.imul(S, fe)) | 0)); + var Ee = + (((c + (n = (n + Math.imul(w, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(w, me)) | 0) + Math.imul(_, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(_, me)) | 0) + (i >>> 13)) | 0) + + (Ee >>> 26)) | + 0), + (Ee &= 67108863), + (n = Math.imul(F, Q)), + (i = ((i = Math.imul(F, ee)) + Math.imul(L, Q)) | 0), + (s = Math.imul(L, ee)), + (n = (n + Math.imul(P, re)) | 0), + (i = ((i = (i + Math.imul(P, ne)) | 0) + Math.imul(B, re)) | 0), + (s = (s + Math.imul(B, ne)) | 0), + (n = (n + Math.imul(j, se)) | 0), + (i = ((i = (i + Math.imul(j, oe)) | 0) + Math.imul(I, se)) | 0), + (s = (s + Math.imul(I, oe)) | 0), + (n = (n + Math.imul(A, le)) | 0), + (i = ((i = (i + Math.imul(A, ce)) | 0) + Math.imul(R, le)) | 0), + (s = (s + Math.imul(R, ce)) | 0), + (n = (n + Math.imul(C, he)) | 0), + (i = ((i = (i + Math.imul(C, fe)) | 0) + Math.imul(T, he)) | 0), + (s = (s + Math.imul(T, fe)) | 0)); + var Ae = + (((c + (n = (n + Math.imul(k, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(k, me)) | 0) + Math.imul(S, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(S, me)) | 0) + (i >>> 13)) | 0) + + (Ae >>> 26)) | + 0), + (Ae &= 67108863), + (n = Math.imul(F, re)), + (i = ((i = Math.imul(F, ne)) + Math.imul(L, re)) | 0), + (s = Math.imul(L, ne)), + (n = (n + Math.imul(P, se)) | 0), + (i = ((i = (i + Math.imul(P, oe)) | 0) + Math.imul(B, se)) | 0), + (s = (s + Math.imul(B, oe)) | 0), + (n = (n + Math.imul(j, le)) | 0), + (i = ((i = (i + Math.imul(j, ce)) | 0) + Math.imul(I, le)) | 0), + (s = (s + Math.imul(I, ce)) | 0), + (n = (n + Math.imul(A, he)) | 0), + (i = ((i = (i + Math.imul(A, fe)) | 0) + Math.imul(R, he)) | 0), + (s = (s + Math.imul(R, fe)) | 0)); + var Re = + (((c + (n = (n + Math.imul(C, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(C, me)) | 0) + Math.imul(T, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(T, me)) | 0) + (i >>> 13)) | 0) + + (Re >>> 26)) | + 0), + (Re &= 67108863), + (n = Math.imul(F, se)), + (i = ((i = Math.imul(F, oe)) + Math.imul(L, se)) | 0), + (s = Math.imul(L, oe)), + (n = (n + Math.imul(P, le)) | 0), + (i = ((i = (i + Math.imul(P, ce)) | 0) + Math.imul(B, le)) | 0), + (s = (s + Math.imul(B, ce)) | 0), + (n = (n + Math.imul(j, he)) | 0), + (i = ((i = (i + Math.imul(j, fe)) | 0) + Math.imul(I, he)) | 0), + (s = (s + Math.imul(I, fe)) | 0)); + var Oe = + (((c + (n = (n + Math.imul(A, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(A, me)) | 0) + Math.imul(R, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(R, me)) | 0) + (i >>> 13)) | 0) + + (Oe >>> 26)) | + 0), + (Oe &= 67108863), + (n = Math.imul(F, le)), + (i = ((i = Math.imul(F, ce)) + Math.imul(L, le)) | 0), + (s = Math.imul(L, ce)), + (n = (n + Math.imul(P, he)) | 0), + (i = ((i = (i + Math.imul(P, fe)) | 0) + Math.imul(B, he)) | 0), + (s = (s + Math.imul(B, fe)) | 0)); + var je = + (((c + (n = (n + Math.imul(j, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(j, me)) | 0) + Math.imul(I, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(I, me)) | 0) + (i >>> 13)) | 0) + + (je >>> 26)) | + 0), + (je &= 67108863), + (n = Math.imul(F, he)), + (i = ((i = Math.imul(F, fe)) + Math.imul(L, he)) | 0), + (s = Math.imul(L, fe))); + var Ie = + (((c + (n = (n + Math.imul(P, pe)) | 0)) | 0) + + ((8191 & + (i = + ((i = (i + Math.imul(P, me)) | 0) + Math.imul(B, pe)) | + 0)) << + 13)) | + 0; + ((c = + ((((s = (s + Math.imul(B, me)) | 0) + (i >>> 13)) | 0) + + (Ie >>> 26)) | + 0), + (Ie &= 67108863)); + var Ne = + (((c + (n = Math.imul(F, pe))) | 0) + + ((8191 & + (i = ((i = Math.imul(F, me)) + Math.imul(L, pe)) | 0)) << + 13)) | + 0; + return ( + (c = + ((((s = Math.imul(L, me)) + (i >>> 13)) | 0) + (Ne >>> 26)) | + 0), + (Ne &= 67108863), + (l[0] = be), + (l[1] = ge), + (l[2] = ye), + (l[3] = ve), + (l[4] = we), + (l[5] = _e), + (l[6] = xe), + (l[7] = ke), + (l[8] = Se), + (l[9] = Me), + (l[10] = Ce), + (l[11] = Te), + (l[12] = Ee), + (l[13] = Ae), + (l[14] = Re), + (l[15] = Oe), + (l[16] = je), + (l[17] = Ie), + (l[18] = Ne), + 0 !== c && ((l[19] = c), r.length++), + r + ); + }; + function g(e, t, r) { + ((r.negative = t.negative ^ e.negative), + (r.length = e.length + t.length)); + for (var n = 0, i = 0, s = 0; s < r.length - 1; s++) { + var o = i; + i = 0; + for ( + var a = 67108863 & n, + l = Math.min(s, t.length - 1), + c = Math.max(0, s - e.length + 1); + c <= l; + c++ + ) { + var u = s - c, + h = (0 | e.words[u]) * (0 | t.words[c]), + f = 67108863 & h; + ((a = 67108863 & (f = (f + a) | 0)), + (i += + (o = + ((o = (o + ((h / 67108864) | 0)) | 0) + (f >>> 26)) | + 0) >>> 26), + (o &= 67108863)); + } + ((r.words[s] = a), (n = o), (o = i)); + } + return (0 !== n ? (r.words[s] = n) : r.length--, r._strip()); + } + function y(e, t, r) { + return g(e, t, r); + } + function v(e, t) { + ((this.x = e), (this.y = t)); + } + (Math.imul || (b = m), + (s.prototype.mulTo = function (e, t) { + var r = this.length + e.length; + return 10 === this.length && 10 === e.length + ? b(this, e, t) + : r < 63 + ? m(this, e, t) + : r < 1024 + ? g(this, e, t) + : y(this, e, t); + }), + (v.prototype.makeRBT = function (e) { + for ( + var t = new Array(e), + r = s.prototype._countBits(e) - 1, + n = 0; + n < e; + n++ + ) + t[n] = this.revBin(n, r, e); + return t; + }), + (v.prototype.revBin = function (e, t, r) { + if (0 === e || e === r - 1) return e; + for (var n = 0, i = 0; i < t; i++) + ((n |= (1 & e) << (t - i - 1)), (e >>= 1)); + return n; + }), + (v.prototype.permute = function (e, t, r, n, i, s) { + for (var o = 0; o < s; o++) + ((n[o] = t[e[o]]), (i[o] = r[e[o]])); + }), + (v.prototype.transform = function (e, t, r, n, i, s) { + this.permute(s, e, t, r, n, i); + for (var o = 1; o < i; o <<= 1) + for ( + var a = o << 1, + l = Math.cos((2 * Math.PI) / a), + c = Math.sin((2 * Math.PI) / a), + u = 0; + u < i; + u += a + ) + for (var h = l, f = c, d = 0; d < o; d++) { + var p = r[u + d], + m = n[u + d], + b = r[u + d + o], + g = n[u + d + o], + y = h * b - f * g; + ((g = h * g + f * b), + (b = y), + (r[u + d] = p + b), + (n[u + d] = m + g), + (r[u + d + o] = p - b), + (n[u + d + o] = m - g), + d !== a && + ((y = l * h - c * f), (f = l * f + c * h), (h = y))); + } + }), + (v.prototype.guessLen13b = function (e, t) { + var r = 1 | Math.max(t, e), + n = 1 & r, + i = 0; + for (r = (r / 2) | 0; r; r >>>= 1) i++; + return 1 << (i + 1 + n); + }), + (v.prototype.conjugate = function (e, t, r) { + if (!(r <= 1)) + for (var n = 0; n < r / 2; n++) { + var i = e[n]; + ((e[n] = e[r - n - 1]), + (e[r - n - 1] = i), + (i = t[n]), + (t[n] = -t[r - n - 1]), + (t[r - n - 1] = -i)); + } + }), + (v.prototype.normalize13b = function (e, t) { + for (var r = 0, n = 0; n < t / 2; n++) { + var i = + 8192 * Math.round(e[2 * n + 1] / t) + + Math.round(e[2 * n] / t) + + r; + ((e[n] = 67108863 & i), + (r = i < 67108864 ? 0 : (i / 67108864) | 0)); + } + return e; + }), + (v.prototype.convert13b = function (e, t, r, i) { + for (var s = 0, o = 0; o < t; o++) + ((s += 0 | e[o]), + (r[2 * o] = 8191 & s), + (s >>>= 13), + (r[2 * o + 1] = 8191 & s), + (s >>>= 13)); + for (o = 2 * t; o < i; ++o) r[o] = 0; + (n(0 === s), n(0 == (-8192 & s))); + }), + (v.prototype.stub = function (e) { + for (var t = new Array(e), r = 0; r < e; r++) t[r] = 0; + return t; + }), + (v.prototype.mulp = function (e, t, r) { + var n = 2 * this.guessLen13b(e.length, t.length), + i = this.makeRBT(n), + s = this.stub(n), + o = new Array(n), + a = new Array(n), + l = new Array(n), + c = new Array(n), + u = new Array(n), + h = new Array(n), + f = r.words; + ((f.length = n), + this.convert13b(e.words, e.length, o, n), + this.convert13b(t.words, t.length, c, n), + this.transform(o, s, a, l, n, i), + this.transform(c, s, u, h, n, i)); + for (var d = 0; d < n; d++) { + var p = a[d] * u[d] - l[d] * h[d]; + ((l[d] = a[d] * h[d] + l[d] * u[d]), (a[d] = p)); + } + return ( + this.conjugate(a, l, n), + this.transform(a, l, f, s, n, i), + this.conjugate(f, s, n), + this.normalize13b(f, n), + (r.negative = e.negative ^ t.negative), + (r.length = e.length + t.length), + r._strip() + ); + }), + (s.prototype.mul = function (e) { + var t = new s(null); + return ( + (t.words = new Array(this.length + e.length)), + this.mulTo(e, t) + ); + }), + (s.prototype.mulf = function (e) { + var t = new s(null); + return ( + (t.words = new Array(this.length + e.length)), + y(this, e, t) + ); + }), + (s.prototype.imul = function (e) { + return this.clone().mulTo(e, this); + }), + (s.prototype.imuln = function (e) { + var t = e < 0; + (t && (e = -e), n("number" == typeof e), n(e < 67108864)); + for (var r = 0, i = 0; i < this.length; i++) { + var s = (0 | this.words[i]) * e, + o = (67108863 & s) + (67108863 & r); + ((r >>= 26), + (r += (s / 67108864) | 0), + (r += o >>> 26), + (this.words[i] = 67108863 & o)); + } + return ( + 0 !== r && ((this.words[i] = r), this.length++), + t ? this.ineg() : this + ); + }), + (s.prototype.muln = function (e) { + return this.clone().imuln(e); + }), + (s.prototype.sqr = function () { + return this.mul(this); + }), + (s.prototype.isqr = function () { + return this.imul(this.clone()); + }), + (s.prototype.pow = function (e) { + var t = (function (e) { + for ( + var t = new Array(e.bitLength()), r = 0; + r < t.length; + r++ + ) { + var n = (r / 26) | 0, + i = r % 26; + t[r] = (e.words[n] >>> i) & 1; + } + return t; + })(e); + if (0 === t.length) return new s(1); + for ( + var r = this, n = 0; + n < t.length && 0 === t[n]; + n++, r = r.sqr() + ); + if (++n < t.length) + for (var i = r.sqr(); n < t.length; n++, i = i.sqr()) + 0 !== t[n] && (r = r.mul(i)); + return r; + }), + (s.prototype.iushln = function (e) { + n("number" == typeof e && e >= 0); + var t, + r = e % 26, + i = (e - r) / 26, + s = (67108863 >>> (26 - r)) << (26 - r); + if (0 !== r) { + var o = 0; + for (t = 0; t < this.length; t++) { + var a = this.words[t] & s, + l = ((0 | this.words[t]) - a) << r; + ((this.words[t] = l | o), (o = a >>> (26 - r))); + } + o && ((this.words[t] = o), this.length++); + } + if (0 !== i) { + for (t = this.length - 1; t >= 0; t--) + this.words[t + i] = this.words[t]; + for (t = 0; t < i; t++) this.words[t] = 0; + this.length += i; + } + return this._strip(); + }), + (s.prototype.ishln = function (e) { + return (n(0 === this.negative), this.iushln(e)); + }), + (s.prototype.iushrn = function (e, t, r) { + var i; + (n("number" == typeof e && e >= 0), + (i = t ? (t - (t % 26)) / 26 : 0)); + var s = e % 26, + o = Math.min((e - s) / 26, this.length), + a = 67108863 ^ ((67108863 >>> s) << s), + l = r; + if (((i -= o), (i = Math.max(0, i)), l)) { + for (var c = 0; c < o; c++) l.words[c] = this.words[c]; + l.length = o; + } + if (0 === o); + else if (this.length > o) + for (this.length -= o, c = 0; c < this.length; c++) + this.words[c] = this.words[c + o]; + else ((this.words[0] = 0), (this.length = 1)); + var u = 0; + for (c = this.length - 1; c >= 0 && (0 !== u || c >= i); c--) { + var h = 0 | this.words[c]; + ((this.words[c] = (u << (26 - s)) | (h >>> s)), (u = h & a)); + } + return ( + l && 0 !== u && (l.words[l.length++] = u), + 0 === this.length && ((this.words[0] = 0), (this.length = 1)), + this._strip() + ); + }), + (s.prototype.ishrn = function (e, t, r) { + return (n(0 === this.negative), this.iushrn(e, t, r)); + }), + (s.prototype.shln = function (e) { + return this.clone().ishln(e); + }), + (s.prototype.ushln = function (e) { + return this.clone().iushln(e); + }), + (s.prototype.shrn = function (e) { + return this.clone().ishrn(e); + }), + (s.prototype.ushrn = function (e) { + return this.clone().iushrn(e); + }), + (s.prototype.testn = function (e) { + n("number" == typeof e && e >= 0); + var t = e % 26, + r = (e - t) / 26, + i = 1 << t; + return !(this.length <= r) && !!(this.words[r] & i); + }), + (s.prototype.imaskn = function (e) { + n("number" == typeof e && e >= 0); + var t = e % 26, + r = (e - t) / 26; + if ( + (n( + 0 === this.negative, + "imaskn works only with positive numbers", + ), + this.length <= r) + ) + return this; + if ( + (0 !== t && r++, + (this.length = Math.min(r, this.length)), + 0 !== t) + ) { + var i = 67108863 ^ ((67108863 >>> t) << t); + this.words[this.length - 1] &= i; + } + return this._strip(); + }), + (s.prototype.maskn = function (e) { + return this.clone().imaskn(e); + }), + (s.prototype.iaddn = function (e) { + return ( + n("number" == typeof e), + n(e < 67108864), + e < 0 + ? this.isubn(-e) + : 0 !== this.negative + ? 1 === this.length && (0 | this.words[0]) <= e + ? ((this.words[0] = e - (0 | this.words[0])), + (this.negative = 0), + this) + : ((this.negative = 0), + this.isubn(e), + (this.negative = 1), + this) + : this._iaddn(e) + ); + }), + (s.prototype._iaddn = function (e) { + this.words[0] += e; + for ( + var t = 0; + t < this.length && this.words[t] >= 67108864; + t++ + ) + ((this.words[t] -= 67108864), + t === this.length - 1 + ? (this.words[t + 1] = 1) + : this.words[t + 1]++); + return ((this.length = Math.max(this.length, t + 1)), this); + }), + (s.prototype.isubn = function (e) { + if ((n("number" == typeof e), n(e < 67108864), e < 0)) + return this.iaddn(-e); + if (0 !== this.negative) + return ( + (this.negative = 0), + this.iaddn(e), + (this.negative = 1), + this + ); + if ( + ((this.words[0] -= e), 1 === this.length && this.words[0] < 0) + ) + ((this.words[0] = -this.words[0]), (this.negative = 1)); + else + for (var t = 0; t < this.length && this.words[t] < 0; t++) + ((this.words[t] += 67108864), (this.words[t + 1] -= 1)); + return this._strip(); + }), + (s.prototype.addn = function (e) { + return this.clone().iaddn(e); + }), + (s.prototype.subn = function (e) { + return this.clone().isubn(e); + }), + (s.prototype.iabs = function () { + return ((this.negative = 0), this); + }), + (s.prototype.abs = function () { + return this.clone().iabs(); + }), + (s.prototype._ishlnsubmul = function (e, t, r) { + var i, + s, + o = e.length + r; + this._expand(o); + var a = 0; + for (i = 0; i < e.length; i++) { + s = (0 | this.words[i + r]) + a; + var l = (0 | e.words[i]) * t; + ((a = ((s -= 67108863 & l) >> 26) - ((l / 67108864) | 0)), + (this.words[i + r] = 67108863 & s)); + } + for (; i < this.length - r; i++) + ((a = (s = (0 | this.words[i + r]) + a) >> 26), + (this.words[i + r] = 67108863 & s)); + if (0 === a) return this._strip(); + for (n(-1 === a), a = 0, i = 0; i < this.length; i++) + ((a = (s = -(0 | this.words[i]) + a) >> 26), + (this.words[i] = 67108863 & s)); + return ((this.negative = 1), this._strip()); + }), + (s.prototype._wordDiv = function (e, t) { + var r = (this.length, e.length), + n = this.clone(), + i = e, + o = 0 | i.words[i.length - 1]; + 0 !== (r = 26 - this._countBits(o)) && + ((i = i.ushln(r)), + n.iushln(r), + (o = 0 | i.words[i.length - 1])); + var a, + l = n.length - i.length; + if ("mod" !== t) { + (((a = new s(null)).length = l + 1), + (a.words = new Array(a.length))); + for (var c = 0; c < a.length; c++) a.words[c] = 0; + } + var u = n.clone()._ishlnsubmul(i, 1, l); + 0 === u.negative && ((n = u), a && (a.words[l] = 1)); + for (var h = l - 1; h >= 0; h--) { + var f = + 67108864 * (0 | n.words[i.length + h]) + + (0 | n.words[i.length + h - 1]); + for ( + f = Math.min((f / o) | 0, 67108863), + n._ishlnsubmul(i, f, h); + 0 !== n.negative; + ) + (f--, + (n.negative = 0), + n._ishlnsubmul(i, 1, h), + n.isZero() || (n.negative ^= 1)); + a && (a.words[h] = f); + } + return ( + a && a._strip(), + n._strip(), + "div" !== t && 0 !== r && n.iushrn(r), + { div: a || null, mod: n } + ); + }), + (s.prototype.divmod = function (e, t, r) { + return ( + n(!e.isZero()), + this.isZero() + ? { div: new s(0), mod: new s(0) } + : 0 !== this.negative && 0 === e.negative + ? ((a = this.neg().divmod(e, t)), + "mod" !== t && (i = a.div.neg()), + "div" !== t && + ((o = a.mod.neg()), + r && 0 !== o.negative && o.iadd(e)), + { div: i, mod: o }) + : 0 === this.negative && 0 !== e.negative + ? ((a = this.divmod(e.neg(), t)), + "mod" !== t && (i = a.div.neg()), + { div: i, mod: a.mod }) + : 0 != (this.negative & e.negative) + ? ((a = this.neg().divmod(e.neg(), t)), + "div" !== t && + ((o = a.mod.neg()), + r && 0 !== o.negative && o.isub(e)), + { div: a.div, mod: o }) + : e.length > this.length || this.cmp(e) < 0 + ? { div: new s(0), mod: this } + : 1 === e.length + ? "div" === t + ? { div: this.divn(e.words[0]), mod: null } + : "mod" === t + ? { + div: null, + mod: new s(this.modrn(e.words[0])), + } + : { + div: this.divn(e.words[0]), + mod: new s(this.modrn(e.words[0])), + } + : this._wordDiv(e, t) + ); + var i, o, a; + }), + (s.prototype.div = function (e) { + return this.divmod(e, "div", !1).div; + }), + (s.prototype.mod = function (e) { + return this.divmod(e, "mod", !1).mod; + }), + (s.prototype.umod = function (e) { + return this.divmod(e, "mod", !0).mod; + }), + (s.prototype.divRound = function (e) { + var t = this.divmod(e); + if (t.mod.isZero()) return t.div; + var r = 0 !== t.div.negative ? t.mod.isub(e) : t.mod, + n = e.ushrn(1), + i = e.andln(1), + s = r.cmp(n); + return s < 0 || (1 === i && 0 === s) + ? t.div + : 0 !== t.div.negative + ? t.div.isubn(1) + : t.div.iaddn(1); + }), + (s.prototype.modrn = function (e) { + var t = e < 0; + (t && (e = -e), n(e <= 67108863)); + for ( + var r = (1 << 26) % e, i = 0, s = this.length - 1; + s >= 0; + s-- + ) + i = (r * i + (0 | this.words[s])) % e; + return t ? -i : i; + }), + (s.prototype.modn = function (e) { + return this.modrn(e); + }), + (s.prototype.idivn = function (e) { + var t = e < 0; + (t && (e = -e), n(e <= 67108863)); + for (var r = 0, i = this.length - 1; i >= 0; i--) { + var s = (0 | this.words[i]) + 67108864 * r; + ((this.words[i] = (s / e) | 0), (r = s % e)); + } + return (this._strip(), t ? this.ineg() : this); + }), + (s.prototype.divn = function (e) { + return this.clone().idivn(e); + }), + (s.prototype.egcd = function (e) { + (n(0 === e.negative), n(!e.isZero())); + var t = this, + r = e.clone(); + t = 0 !== t.negative ? t.umod(e) : t.clone(); + for ( + var i = new s(1), + o = new s(0), + a = new s(0), + l = new s(1), + c = 0; + t.isEven() && r.isEven(); + ) + (t.iushrn(1), r.iushrn(1), ++c); + for (var u = r.clone(), h = t.clone(); !t.isZero(); ) { + for ( + var f = 0, d = 1; + 0 == (t.words[0] & d) && f < 26; + ++f, d <<= 1 + ); + if (f > 0) + for (t.iushrn(f); f-- > 0; ) + ((i.isOdd() || o.isOdd()) && (i.iadd(u), o.isub(h)), + i.iushrn(1), + o.iushrn(1)); + for ( + var p = 0, m = 1; + 0 == (r.words[0] & m) && p < 26; + ++p, m <<= 1 + ); + if (p > 0) + for (r.iushrn(p); p-- > 0; ) + ((a.isOdd() || l.isOdd()) && (a.iadd(u), l.isub(h)), + a.iushrn(1), + l.iushrn(1)); + t.cmp(r) >= 0 + ? (t.isub(r), i.isub(a), o.isub(l)) + : (r.isub(t), a.isub(i), l.isub(o)); + } + return { a: a, b: l, gcd: r.iushln(c) }; + }), + (s.prototype._invmp = function (e) { + (n(0 === e.negative), n(!e.isZero())); + var t = this, + r = e.clone(); + t = 0 !== t.negative ? t.umod(e) : t.clone(); + for ( + var i, o = new s(1), a = new s(0), l = r.clone(); + t.cmpn(1) > 0 && r.cmpn(1) > 0; + ) { + for ( + var c = 0, u = 1; + 0 == (t.words[0] & u) && c < 26; + ++c, u <<= 1 + ); + if (c > 0) + for (t.iushrn(c); c-- > 0; ) + (o.isOdd() && o.iadd(l), o.iushrn(1)); + for ( + var h = 0, f = 1; + 0 == (r.words[0] & f) && h < 26; + ++h, f <<= 1 + ); + if (h > 0) + for (r.iushrn(h); h-- > 0; ) + (a.isOdd() && a.iadd(l), a.iushrn(1)); + t.cmp(r) >= 0 + ? (t.isub(r), o.isub(a)) + : (r.isub(t), a.isub(o)); + } + return ( + (i = 0 === t.cmpn(1) ? o : a).cmpn(0) < 0 && i.iadd(e), + i + ); + }), + (s.prototype.gcd = function (e) { + if (this.isZero()) return e.abs(); + if (e.isZero()) return this.abs(); + var t = this.clone(), + r = e.clone(); + ((t.negative = 0), (r.negative = 0)); + for (var n = 0; t.isEven() && r.isEven(); n++) + (t.iushrn(1), r.iushrn(1)); + for (;;) { + for (; t.isEven(); ) t.iushrn(1); + for (; r.isEven(); ) r.iushrn(1); + var i = t.cmp(r); + if (i < 0) { + var s = t; + ((t = r), (r = s)); + } else if (0 === i || 0 === r.cmpn(1)) break; + t.isub(r); + } + return r.iushln(n); + }), + (s.prototype.invm = function (e) { + return this.egcd(e).a.umod(e); + }), + (s.prototype.isEven = function () { + return 0 == (1 & this.words[0]); + }), + (s.prototype.isOdd = function () { + return 1 == (1 & this.words[0]); + }), + (s.prototype.andln = function (e) { + return this.words[0] & e; + }), + (s.prototype.bincn = function (e) { + n("number" == typeof e); + var t = e % 26, + r = (e - t) / 26, + i = 1 << t; + if (this.length <= r) + return (this._expand(r + 1), (this.words[r] |= i), this); + for (var s = i, o = r; 0 !== s && o < this.length; o++) { + var a = 0 | this.words[o]; + ((s = (a += s) >>> 26), (a &= 67108863), (this.words[o] = a)); + } + return (0 !== s && ((this.words[o] = s), this.length++), this); + }), + (s.prototype.isZero = function () { + return 1 === this.length && 0 === this.words[0]; + }), + (s.prototype.cmpn = function (e) { + var t, + r = e < 0; + if (0 !== this.negative && !r) return -1; + if (0 === this.negative && r) return 1; + if ((this._strip(), this.length > 1)) t = 1; + else { + (r && (e = -e), n(e <= 67108863, "Number is too big")); + var i = 0 | this.words[0]; + t = i === e ? 0 : i < e ? -1 : 1; + } + return 0 !== this.negative ? 0 | -t : t; + }), + (s.prototype.cmp = function (e) { + if (0 !== this.negative && 0 === e.negative) return -1; + if (0 === this.negative && 0 !== e.negative) return 1; + var t = this.ucmp(e); + return 0 !== this.negative ? 0 | -t : t; + }), + (s.prototype.ucmp = function (e) { + if (this.length > e.length) return 1; + if (this.length < e.length) return -1; + for (var t = 0, r = this.length - 1; r >= 0; r--) { + var n = 0 | this.words[r], + i = 0 | e.words[r]; + if (n !== i) { + n < i ? (t = -1) : n > i && (t = 1); + break; + } + } + return t; + }), + (s.prototype.gtn = function (e) { + return 1 === this.cmpn(e); + }), + (s.prototype.gt = function (e) { + return 1 === this.cmp(e); + }), + (s.prototype.gten = function (e) { + return this.cmpn(e) >= 0; + }), + (s.prototype.gte = function (e) { + return this.cmp(e) >= 0; + }), + (s.prototype.ltn = function (e) { + return -1 === this.cmpn(e); + }), + (s.prototype.lt = function (e) { + return -1 === this.cmp(e); + }), + (s.prototype.lten = function (e) { + return this.cmpn(e) <= 0; + }), + (s.prototype.lte = function (e) { + return this.cmp(e) <= 0; + }), + (s.prototype.eqn = function (e) { + return 0 === this.cmpn(e); + }), + (s.prototype.eq = function (e) { + return 0 === this.cmp(e); + }), + (s.red = function (e) { + return new C(e); + }), + (s.prototype.toRed = function (e) { + return ( + n(!this.red, "Already a number in reduction context"), + n(0 === this.negative, "red works only with positives"), + e.convertTo(this)._forceRed(e) + ); + }), + (s.prototype.fromRed = function () { + return ( + n( + this.red, + "fromRed works only with numbers in reduction context", + ), + this.red.convertFrom(this) + ); + }), + (s.prototype._forceRed = function (e) { + return ((this.red = e), this); + }), + (s.prototype.forceRed = function (e) { + return ( + n(!this.red, "Already a number in reduction context"), + this._forceRed(e) + ); + }), + (s.prototype.redAdd = function (e) { + return ( + n(this.red, "redAdd works only with red numbers"), + this.red.add(this, e) + ); + }), + (s.prototype.redIAdd = function (e) { + return ( + n(this.red, "redIAdd works only with red numbers"), + this.red.iadd(this, e) + ); + }), + (s.prototype.redSub = function (e) { + return ( + n(this.red, "redSub works only with red numbers"), + this.red.sub(this, e) + ); + }), + (s.prototype.redISub = function (e) { + return ( + n(this.red, "redISub works only with red numbers"), + this.red.isub(this, e) + ); + }), + (s.prototype.redShl = function (e) { + return ( + n(this.red, "redShl works only with red numbers"), + this.red.shl(this, e) + ); + }), + (s.prototype.redMul = function (e) { + return ( + n(this.red, "redMul works only with red numbers"), + this.red._verify2(this, e), + this.red.mul(this, e) + ); + }), + (s.prototype.redIMul = function (e) { + return ( + n(this.red, "redMul works only with red numbers"), + this.red._verify2(this, e), + this.red.imul(this, e) + ); + }), + (s.prototype.redSqr = function () { + return ( + n(this.red, "redSqr works only with red numbers"), + this.red._verify1(this), + this.red.sqr(this) + ); + }), + (s.prototype.redISqr = function () { + return ( + n(this.red, "redISqr works only with red numbers"), + this.red._verify1(this), + this.red.isqr(this) + ); + }), + (s.prototype.redSqrt = function () { + return ( + n(this.red, "redSqrt works only with red numbers"), + this.red._verify1(this), + this.red.sqrt(this) + ); + }), + (s.prototype.redInvm = function () { + return ( + n(this.red, "redInvm works only with red numbers"), + this.red._verify1(this), + this.red.invm(this) + ); + }), + (s.prototype.redNeg = function () { + return ( + n(this.red, "redNeg works only with red numbers"), + this.red._verify1(this), + this.red.neg(this) + ); + }), + (s.prototype.redPow = function (e) { + return ( + n(this.red && !e.red, "redPow(normalNum)"), + this.red._verify1(this), + this.red.pow(this, e) + ); + })); + var w = { k256: null, p224: null, p192: null, p25519: null }; + function _(e, t) { + ((this.name = e), + (this.p = new s(t, 16)), + (this.n = this.p.bitLength()), + (this.k = new s(1).iushln(this.n).isub(this.p)), + (this.tmp = this._tmp())); + } + function x() { + _.call( + this, + "k256", + "ffffffff ffffffff ffffffff ffffffff ffffffff ffffffff fffffffe fffffc2f", + ); + } + function k() { + _.call( + this, + "p224", + "ffffffff ffffffff ffffffff ffffffff 00000000 00000000 00000001", + ); + } + function S() { + _.call( + this, + "p192", + "ffffffff ffffffff ffffffff fffffffe ffffffff ffffffff", + ); + } + function M() { + _.call( + this, + "25519", + "7fffffffffffffff ffffffffffffffff ffffffffffffffff ffffffffffffffed", + ); + } + function C(e) { + if ("string" == typeof e) { + var t = s._prime(e); + ((this.m = t.p), (this.prime = t)); + } else + (n(e.gtn(1), "modulus must be greater than 1"), + (this.m = e), + (this.prime = null)); + } + function T(e) { + (C.call(this, e), + (this.shift = this.m.bitLength()), + this.shift % 26 != 0 && (this.shift += 26 - (this.shift % 26)), + (this.r = new s(1).iushln(this.shift)), + (this.r2 = this.imod(this.r.sqr())), + (this.rinv = this.r._invmp(this.m)), + (this.minv = this.rinv.mul(this.r).isubn(1).div(this.m)), + (this.minv = this.minv.umod(this.r)), + (this.minv = this.r.sub(this.minv))); + } + ((_.prototype._tmp = function () { + var e = new s(null); + return ((e.words = new Array(Math.ceil(this.n / 13))), e); + }), + (_.prototype.ireduce = function (e) { + var t, + r = e; + do { + (this.split(r, this.tmp), + (t = (r = (r = this.imulK(r)).iadd(this.tmp)).bitLength())); + } while (t > this.n); + var n = t < this.n ? -1 : r.ucmp(this.p); + return ( + 0 === n + ? ((r.words[0] = 0), (r.length = 1)) + : n > 0 + ? r.isub(this.p) + : void 0 !== r.strip + ? r.strip() + : r._strip(), + r + ); + }), + (_.prototype.split = function (e, t) { + e.iushrn(this.n, 0, t); + }), + (_.prototype.imulK = function (e) { + return e.imul(this.k); + }), + i(x, _), + (x.prototype.split = function (e, t) { + for (var r = Math.min(e.length, 9), n = 0; n < r; n++) + t.words[n] = e.words[n]; + if (((t.length = r), e.length <= 9)) + return ((e.words[0] = 0), void (e.length = 1)); + var i = e.words[9]; + for ( + t.words[t.length++] = 4194303 & i, n = 10; + n < e.length; + n++ + ) { + var s = 0 | e.words[n]; + ((e.words[n - 10] = ((4194303 & s) << 4) | (i >>> 22)), + (i = s)); + } + ((i >>>= 22), + (e.words[n - 10] = i), + 0 === i && e.length > 10 + ? (e.length -= 10) + : (e.length -= 9)); + }), + (x.prototype.imulK = function (e) { + ((e.words[e.length] = 0), + (e.words[e.length + 1] = 0), + (e.length += 2)); + for (var t = 0, r = 0; r < e.length; r++) { + var n = 0 | e.words[r]; + ((t += 977 * n), + (e.words[r] = 67108863 & t), + (t = 64 * n + ((t / 67108864) | 0))); + } + return ( + 0 === e.words[e.length - 1] && + (e.length--, 0 === e.words[e.length - 1] && e.length--), + e + ); + }), + i(k, _), + i(S, _), + i(M, _), + (M.prototype.imulK = function (e) { + for (var t = 0, r = 0; r < e.length; r++) { + var n = 19 * (0 | e.words[r]) + t, + i = 67108863 & n; + ((n >>>= 26), (e.words[r] = i), (t = n)); + } + return (0 !== t && (e.words[e.length++] = t), e); + }), + (s._prime = function (e) { + if (w[e]) return w[e]; + var t; + if ("k256" === e) t = new x(); + else if ("p224" === e) t = new k(); + else if ("p192" === e) t = new S(); + else { + if ("p25519" !== e) throw new Error("Unknown prime " + e); + t = new M(); + } + return ((w[e] = t), t); + }), + (C.prototype._verify1 = function (e) { + (n(0 === e.negative, "red works only with positives"), + n(e.red, "red works only with red numbers")); + }), + (C.prototype._verify2 = function (e, t) { + (n( + 0 == (e.negative | t.negative), + "red works only with positives", + ), + n( + e.red && e.red === t.red, + "red works only with red numbers", + )); + }), + (C.prototype.imod = function (e) { + return this.prime + ? this.prime.ireduce(e)._forceRed(this) + : (u(e, e.umod(this.m)._forceRed(this)), e); + }), + (C.prototype.neg = function (e) { + return e.isZero() ? e.clone() : this.m.sub(e)._forceRed(this); + }), + (C.prototype.add = function (e, t) { + this._verify2(e, t); + var r = e.add(t); + return ( + r.cmp(this.m) >= 0 && r.isub(this.m), + r._forceRed(this) + ); + }), + (C.prototype.iadd = function (e, t) { + this._verify2(e, t); + var r = e.iadd(t); + return (r.cmp(this.m) >= 0 && r.isub(this.m), r); + }), + (C.prototype.sub = function (e, t) { + this._verify2(e, t); + var r = e.sub(t); + return (r.cmpn(0) < 0 && r.iadd(this.m), r._forceRed(this)); + }), + (C.prototype.isub = function (e, t) { + this._verify2(e, t); + var r = e.isub(t); + return (r.cmpn(0) < 0 && r.iadd(this.m), r); + }), + (C.prototype.shl = function (e, t) { + return (this._verify1(e), this.imod(e.ushln(t))); + }), + (C.prototype.imul = function (e, t) { + return (this._verify2(e, t), this.imod(e.imul(t))); + }), + (C.prototype.mul = function (e, t) { + return (this._verify2(e, t), this.imod(e.mul(t))); + }), + (C.prototype.isqr = function (e) { + return this.imul(e, e.clone()); + }), + (C.prototype.sqr = function (e) { + return this.mul(e, e); + }), + (C.prototype.sqrt = function (e) { + if (e.isZero()) return e.clone(); + var t = this.m.andln(3); + if ((n(t % 2 == 1), 3 === t)) { + var r = this.m.add(new s(1)).iushrn(2); + return this.pow(e, r); + } + for ( + var i = this.m.subn(1), o = 0; + !i.isZero() && 0 === i.andln(1); + ) + (o++, i.iushrn(1)); + n(!i.isZero()); + var a = new s(1).toRed(this), + l = a.redNeg(), + c = this.m.subn(1).iushrn(1), + u = this.m.bitLength(); + for ( + u = new s(2 * u * u).toRed(this); + 0 !== this.pow(u, c).cmp(l); + ) + u.redIAdd(l); + for ( + var h = this.pow(u, i), + f = this.pow(e, i.addn(1).iushrn(1)), + d = this.pow(e, i), + p = o; + 0 !== d.cmp(a); + ) { + for (var m = d, b = 0; 0 !== m.cmp(a); b++) m = m.redSqr(); + n(b < p); + var g = this.pow(h, new s(1).iushln(p - b - 1)); + ((f = f.redMul(g)), + (h = g.redSqr()), + (d = d.redMul(h)), + (p = b)); + } + return f; + }), + (C.prototype.invm = function (e) { + var t = e._invmp(this.m); + return 0 !== t.negative + ? ((t.negative = 0), this.imod(t).redNeg()) + : this.imod(t); + }), + (C.prototype.pow = function (e, t) { + if (t.isZero()) return new s(1).toRed(this); + if (0 === t.cmpn(1)) return e.clone(); + var r = new Array(16); + ((r[0] = new s(1).toRed(this)), (r[1] = e)); + for (var n = 2; n < r.length; n++) r[n] = this.mul(r[n - 1], e); + var i = r[0], + o = 0, + a = 0, + l = t.bitLength() % 26; + for (0 === l && (l = 26), n = t.length - 1; n >= 0; n--) { + for (var c = t.words[n], u = l - 1; u >= 0; u--) { + var h = (c >> u) & 1; + (i !== r[0] && (i = this.sqr(i)), + 0 !== h || 0 !== o + ? ((o <<= 1), + (o |= h), + (4 === ++a || (0 === n && 0 === u)) && + ((i = this.mul(i, r[o])), (a = 0), (o = 0))) + : (a = 0)); + } + l = 26; + } + return i; + }), + (C.prototype.convertTo = function (e) { + var t = e.umod(this.m); + return t === e ? t.clone() : t; + }), + (C.prototype.convertFrom = function (e) { + var t = e.clone(); + return ((t.red = null), t); + }), + (s.mont = function (e) { + return new T(e); + }), + i(T, C), + (T.prototype.convertTo = function (e) { + return this.imod(e.ushln(this.shift)); + }), + (T.prototype.convertFrom = function (e) { + var t = this.imod(e.mul(this.rinv)); + return ((t.red = null), t); + }), + (T.prototype.imul = function (e, t) { + if (e.isZero() || t.isZero()) + return ((e.words[0] = 0), (e.length = 1), e); + var r = e.imul(t), + n = r + .maskn(this.shift) + .mul(this.minv) + .imaskn(this.shift) + .mul(this.m), + i = r.isub(n).iushrn(this.shift), + s = i; + return ( + i.cmp(this.m) >= 0 + ? (s = i.isub(this.m)) + : i.cmpn(0) < 0 && (s = i.iadd(this.m)), + s._forceRed(this) + ); + }), + (T.prototype.mul = function (e, t) { + if (e.isZero() || t.isZero()) return new s(0)._forceRed(this); + var r = e.mul(t), + n = r + .maskn(this.shift) + .mul(this.minv) + .imaskn(this.shift) + .mul(this.m), + i = r.isub(n).iushrn(this.shift), + o = i; + return ( + i.cmp(this.m) >= 0 + ? (o = i.isub(this.m)) + : i.cmpn(0) < 0 && (o = i.iadd(this.m)), + o._forceRed(this) + ); + }), + (T.prototype.invm = function (e) { + return this.imod(e._invmp(this.m).mul(this.r2))._forceRed(this); + })); + })(void 0 === t || t); + }, + { buffer: 188 }, + ], + 187: [ + function (e, t, r) { + "use strict"; + var n; + function i(e) { + this.rand = e; + } + if ( + ((t.exports = function (e) { + return (n || (n = new i(null)), n.generate(e)); + }), + (t.exports.Rand = i), + (i.prototype.generate = function (e) { + return this._rand(e); + }), + (i.prototype._rand = function (e) { + if (this.rand.getBytes) return this.rand.getBytes(e); + for (var t = new Uint8Array(e), r = 0; r < t.length; r++) + t[r] = this.rand.getByte(); + return t; + }), + "object" == typeof self) + ) + self.crypto && self.crypto.getRandomValues + ? (i.prototype._rand = function (e) { + var t = new Uint8Array(e); + return (self.crypto.getRandomValues(t), t); + }) + : self.msCrypto && self.msCrypto.getRandomValues + ? (i.prototype._rand = function (e) { + var t = new Uint8Array(e); + return (self.msCrypto.getRandomValues(t), t); + }) + : "object" == typeof window && + (i.prototype._rand = function () { + throw new Error("Not implemented yet"); + }); + else + try { + var s = e("crypto"); + if ("function" != typeof s.randomBytes) + throw new Error("Not supported"); + i.prototype._rand = function (e) { + return s.randomBytes(e); + }; + } catch (e) {} + }, + { crypto: 188 }, + ], + 188: [function (e, t, r) {}, {}], + 189: [ + function (e, t, r) { + "use strict"; + var n = e("safe-buffer").Buffer; + function i(e) { + n.isBuffer(e) || (e = n.from(e)); + for ( + var t = (e.length / 4) | 0, r = new Array(t), i = 0; + i < t; + i++ + ) + r[i] = e.readUInt32BE(4 * i); + return r; + } + function s(e) { + for (; 0 < e.length; e++) e[0] = 0; + } + function o(e, t, r, n, i) { + for ( + var s, + o, + a, + l, + c = r[0], + u = r[1], + h = r[2], + f = r[3], + d = e[0] ^ t[0], + p = e[1] ^ t[1], + m = e[2] ^ t[2], + b = e[3] ^ t[3], + g = 4, + y = 1; + y < i; + y++ + ) + ((s = + c[d >>> 24] ^ + u[(p >>> 16) & 255] ^ + h[(m >>> 8) & 255] ^ + f[255 & b] ^ + t[g++]), + (o = + c[p >>> 24] ^ + u[(m >>> 16) & 255] ^ + h[(b >>> 8) & 255] ^ + f[255 & d] ^ + t[g++]), + (a = + c[m >>> 24] ^ + u[(b >>> 16) & 255] ^ + h[(d >>> 8) & 255] ^ + f[255 & p] ^ + t[g++]), + (l = + c[b >>> 24] ^ + u[(d >>> 16) & 255] ^ + h[(p >>> 8) & 255] ^ + f[255 & m] ^ + t[g++]), + (d = s), + (p = o), + (m = a), + (b = l)); + return ( + (s = + ((n[d >>> 24] << 24) | + (n[(p >>> 16) & 255] << 16) | + (n[(m >>> 8) & 255] << 8) | + n[255 & b]) ^ + t[g++]), + (o = + ((n[p >>> 24] << 24) | + (n[(m >>> 16) & 255] << 16) | + (n[(b >>> 8) & 255] << 8) | + n[255 & d]) ^ + t[g++]), + (a = + ((n[m >>> 24] << 24) | + (n[(b >>> 16) & 255] << 16) | + (n[(d >>> 8) & 255] << 8) | + n[255 & p]) ^ + t[g++]), + (l = + ((n[b >>> 24] << 24) | + (n[(d >>> 16) & 255] << 16) | + (n[(p >>> 8) & 255] << 8) | + n[255 & m]) ^ + t[g++]), + [(s >>>= 0), (o >>>= 0), (a >>>= 0), (l >>>= 0)] + ); + } + var a = [0, 1, 2, 4, 8, 16, 32, 64, 128, 27, 54], + l = (function () { + for (var e = new Array(256), t = 0; t < 256; t++) + e[t] = t < 128 ? t << 1 : (t << 1) ^ 283; + for ( + var r = [], + n = [], + i = [[], [], [], []], + s = [[], [], [], []], + o = 0, + a = 0, + l = 0; + l < 256; + ++l + ) { + var c = a ^ (a << 1) ^ (a << 2) ^ (a << 3) ^ (a << 4); + ((c = (c >>> 8) ^ (255 & c) ^ 99), (r[o] = c), (n[c] = o)); + var u = e[o], + h = e[u], + f = e[h], + d = (257 * e[c]) ^ (16843008 * c); + ((i[0][o] = (d << 24) | (d >>> 8)), + (i[1][o] = (d << 16) | (d >>> 16)), + (i[2][o] = (d << 8) | (d >>> 24)), + (i[3][o] = d), + (d = + (16843009 * f) ^ (65537 * h) ^ (257 * u) ^ (16843008 * o)), + (s[0][c] = (d << 24) | (d >>> 8)), + (s[1][c] = (d << 16) | (d >>> 16)), + (s[2][c] = (d << 8) | (d >>> 24)), + (s[3][c] = d), + 0 === o + ? (o = a = 1) + : ((o = u ^ e[e[e[f ^ u]]]), (a ^= e[e[a]]))); + } + return { SBOX: r, INV_SBOX: n, SUB_MIX: i, INV_SUB_MIX: s }; + })(); + function c(e) { + ((this._key = i(e)), this._reset()); + } + ((c.blockSize = 16), + (c.keySize = 32), + (c.prototype.blockSize = c.blockSize), + (c.prototype.keySize = c.keySize), + (c.prototype._reset = function () { + for ( + var e = this._key, + t = e.length, + r = t + 6, + n = 4 * (r + 1), + i = [], + s = 0; + s < t; + s++ + ) + i[s] = e[s]; + for (s = t; s < n; s++) { + var o = i[s - 1]; + (s % t == 0 + ? ((o = (o << 8) | (o >>> 24)), + (o = + (l.SBOX[o >>> 24] << 24) | + (l.SBOX[(o >>> 16) & 255] << 16) | + (l.SBOX[(o >>> 8) & 255] << 8) | + l.SBOX[255 & o]), + (o ^= a[(s / t) | 0] << 24)) + : t > 6 && + s % t == 4 && + (o = + (l.SBOX[o >>> 24] << 24) | + (l.SBOX[(o >>> 16) & 255] << 16) | + (l.SBOX[(o >>> 8) & 255] << 8) | + l.SBOX[255 & o]), + (i[s] = i[s - t] ^ o)); + } + for (var c = [], u = 0; u < n; u++) { + var h = n - u, + f = i[h - (u % 4 ? 0 : 4)]; + c[u] = + u < 4 || h <= 4 + ? f + : l.INV_SUB_MIX[0][l.SBOX[f >>> 24]] ^ + l.INV_SUB_MIX[1][l.SBOX[(f >>> 16) & 255]] ^ + l.INV_SUB_MIX[2][l.SBOX[(f >>> 8) & 255]] ^ + l.INV_SUB_MIX[3][l.SBOX[255 & f]]; + } + ((this._nRounds = r), + (this._keySchedule = i), + (this._invKeySchedule = c)); + }), + (c.prototype.encryptBlockRaw = function (e) { + return o( + (e = i(e)), + this._keySchedule, + l.SUB_MIX, + l.SBOX, + this._nRounds, + ); + }), + (c.prototype.encryptBlock = function (e) { + var t = this.encryptBlockRaw(e), + r = n.allocUnsafe(16); + return ( + r.writeUInt32BE(t[0], 0), + r.writeUInt32BE(t[1], 4), + r.writeUInt32BE(t[2], 8), + r.writeUInt32BE(t[3], 12), + r + ); + }), + (c.prototype.decryptBlock = function (e) { + var t = (e = i(e))[1]; + ((e[1] = e[3]), (e[3] = t)); + var r = o( + e, + this._invKeySchedule, + l.INV_SUB_MIX, + l.INV_SBOX, + this._nRounds, + ), + s = n.allocUnsafe(16); + return ( + s.writeUInt32BE(r[0], 0), + s.writeUInt32BE(r[3], 4), + s.writeUInt32BE(r[2], 8), + s.writeUInt32BE(r[1], 12), + s + ); + }), + (c.prototype.scrub = function () { + (s(this._keySchedule), s(this._invKeySchedule), s(this._key)); + }), + (t.exports.AES = c)); + }, + { "safe-buffer": 494 }, + ], + 190: [ + function (e, t, r) { + "use strict"; + var n = e("./aes"), + i = e("safe-buffer").Buffer, + s = e("cipher-base"), + o = e("inherits"), + a = e("./ghash"), + l = e("buffer-xor"), + c = e("./incr32"); + function u(e, t, r, o) { + s.call(this); + var l = i.alloc(4, 0); + this._cipher = new n.AES(t); + var u = this._cipher.encryptBlock(l); + ((this._ghash = new a(u)), + (r = (function (e, t, r) { + if (12 === t.length) + return ( + (e._finID = i.concat([t, i.from([0, 0, 0, 1])])), + i.concat([t, i.from([0, 0, 0, 2])]) + ); + var n = new a(r), + s = t.length, + o = s % 16; + (n.update(t), + o && ((o = 16 - o), n.update(i.alloc(o, 0))), + n.update(i.alloc(8, 0))); + var l = 8 * s, + u = i.alloc(8); + (u.writeUIntBE(l, 0, 8), n.update(u), (e._finID = n.state)); + var h = i.from(e._finID); + return (c(h), h); + })(this, r, u)), + (this._prev = i.from(r)), + (this._cache = i.allocUnsafe(0)), + (this._secCache = i.allocUnsafe(0)), + (this._decrypt = o), + (this._alen = 0), + (this._len = 0), + (this._mode = e), + (this._authTag = null), + (this._called = !1)); + } + (o(u, s), + (u.prototype._update = function (e) { + if (!this._called && this._alen) { + var t = 16 - (this._alen % 16); + t < 16 && ((t = i.alloc(t, 0)), this._ghash.update(t)); + } + this._called = !0; + var r = this._mode.encrypt(this, e); + return ( + this._decrypt ? this._ghash.update(e) : this._ghash.update(r), + (this._len += e.length), + r + ); + }), + (u.prototype._final = function () { + if (this._decrypt && !this._authTag) + throw new Error( + "Unsupported state or unable to authenticate data", + ); + var e = l( + this._ghash.final(8 * this._alen, 8 * this._len), + this._cipher.encryptBlock(this._finID), + ); + if ( + this._decrypt && + (function (e, t) { + var r = 0; + e.length !== t.length && r++; + for (var n = Math.min(e.length, t.length), i = 0; i < n; ++i) + r += e[i] ^ t[i]; + return r; + })(e, this._authTag) + ) + throw new Error( + "Unsupported state or unable to authenticate data", + ); + ((this._authTag = e), this._cipher.scrub()); + }), + (u.prototype.getAuthTag = function () { + if (this._decrypt || !i.isBuffer(this._authTag)) + throw new Error( + "Attempting to get auth tag in unsupported state", + ); + return this._authTag; + }), + (u.prototype.setAuthTag = function (e) { + if (!this._decrypt) + throw new Error( + "Attempting to set auth tag in unsupported state", + ); + this._authTag = e; + }), + (u.prototype.setAAD = function (e) { + if (this._called) + throw new Error("Attempting to set AAD in unsupported state"); + (this._ghash.update(e), (this._alen += e.length)); + }), + (t.exports = u)); + }, + { + "./aes": 189, + "./ghash": 194, + "./incr32": 195, + "buffer-xor": 219, + "cipher-base": 221, + inherits: 440, + "safe-buffer": 494, + }, + ], + 191: [ + function (e, t, r) { + "use strict"; + var n = e("./encrypter"), + i = e("./decrypter"), + s = e("./modes/list.json"); + ((r.createCipher = r.Cipher = n.createCipher), + (r.createCipheriv = r.Cipheriv = n.createCipheriv), + (r.createDecipher = r.Decipher = i.createDecipher), + (r.createDecipheriv = r.Decipheriv = i.createDecipheriv), + (r.listCiphers = r.getCiphers = + function () { + return Object.keys(s); + })); + }, + { "./decrypter": 192, "./encrypter": 193, "./modes/list.json": 203 }, + ], + 192: [ + function (e, t, r) { + "use strict"; + var n = e("./authCipher"), + i = e("safe-buffer").Buffer, + s = e("./modes"), + o = e("./streamCipher"), + a = e("cipher-base"), + l = e("./aes"), + c = e("evp_bytestokey"); + function u(e, t, r) { + (a.call(this), + (this._cache = new h()), + (this._last = void 0), + (this._cipher = new l.AES(t)), + (this._prev = i.from(r)), + (this._mode = e), + (this._autopadding = !0)); + } + function h() { + this.cache = i.allocUnsafe(0); + } + function f(e, t, r) { + var a = s[e.toLowerCase()]; + if (!a) throw new TypeError("invalid suite type"); + if ( + ("string" == typeof r && (r = i.from(r)), + "GCM" !== a.mode && r.length !== a.iv) + ) + throw new TypeError("invalid iv length " + r.length); + if ( + ("string" == typeof t && (t = i.from(t)), t.length !== a.key / 8) + ) + throw new TypeError("invalid key length " + t.length); + return "stream" === a.type + ? new o(a.module, t, r, !0) + : "auth" === a.type + ? new n(a.module, t, r, !0) + : new u(a.module, t, r); + } + (e("inherits")(u, a), + (u.prototype._update = function (e) { + var t, r; + this._cache.add(e); + for (var n = []; (t = this._cache.get(this._autopadding)); ) + ((r = this._mode.decrypt(this, t)), n.push(r)); + return i.concat(n); + }), + (u.prototype._final = function () { + var e = this._cache.flush(); + if (this._autopadding) + return (function (e) { + var t = e[15]; + if (t < 1 || t > 16) + throw new Error("unable to decrypt data"); + var r = -1; + for (; ++r < t; ) + if (e[r + (16 - t)] !== t) + throw new Error("unable to decrypt data"); + if (16 === t) return; + return e.slice(0, 16 - t); + })(this._mode.decrypt(this, e)); + if (e) throw new Error("data not multiple of block length"); + }), + (u.prototype.setAutoPadding = function (e) { + return ((this._autopadding = !!e), this); + }), + (h.prototype.add = function (e) { + this.cache = i.concat([this.cache, e]); + }), + (h.prototype.get = function (e) { + var t; + if (e) { + if (this.cache.length > 16) + return ( + (t = this.cache.slice(0, 16)), + (this.cache = this.cache.slice(16)), + t + ); + } else if (this.cache.length >= 16) + return ( + (t = this.cache.slice(0, 16)), + (this.cache = this.cache.slice(16)), + t + ); + return null; + }), + (h.prototype.flush = function () { + if (this.cache.length) return this.cache; + }), + (r.createDecipher = function (e, t) { + var r = s[e.toLowerCase()]; + if (!r) throw new TypeError("invalid suite type"); + var n = c(t, !1, r.key, r.iv); + return f(e, n.key, n.iv); + }), + (r.createDecipheriv = f)); + }, + { + "./aes": 189, + "./authCipher": 190, + "./modes": 202, + "./streamCipher": 205, + "cipher-base": 221, + evp_bytestokey: 423, + inherits: 440, + "safe-buffer": 494, + }, + ], + 193: [ + function (e, t, r) { + "use strict"; + var n = e("./modes"), + i = e("./authCipher"), + s = e("safe-buffer").Buffer, + o = e("./streamCipher"), + a = e("cipher-base"), + l = e("./aes"), + c = e("evp_bytestokey"); + function u(e, t, r) { + (a.call(this), + (this._cache = new f()), + (this._cipher = new l.AES(t)), + (this._prev = s.from(r)), + (this._mode = e), + (this._autopadding = !0)); + } + (e("inherits")(u, a), + (u.prototype._update = function (e) { + var t, r; + this._cache.add(e); + for (var n = []; (t = this._cache.get()); ) + ((r = this._mode.encrypt(this, t)), n.push(r)); + return s.concat(n); + })); + var h = s.alloc(16, 16); + function f() { + this.cache = s.allocUnsafe(0); + } + function d(e, t, r) { + var a = n[e.toLowerCase()]; + if (!a) throw new TypeError("invalid suite type"); + if ( + ("string" == typeof t && (t = s.from(t)), t.length !== a.key / 8) + ) + throw new TypeError("invalid key length " + t.length); + if ( + ("string" == typeof r && (r = s.from(r)), + "GCM" !== a.mode && r.length !== a.iv) + ) + throw new TypeError("invalid iv length " + r.length); + return "stream" === a.type + ? new o(a.module, t, r) + : "auth" === a.type + ? new i(a.module, t, r) + : new u(a.module, t, r); + } + ((u.prototype._final = function () { + var e = this._cache.flush(); + if (this._autopadding) + return ( + (e = this._mode.encrypt(this, e)), + this._cipher.scrub(), + e + ); + if (!e.equals(h)) + throw ( + this._cipher.scrub(), + new Error("data not multiple of block length") + ); + }), + (u.prototype.setAutoPadding = function (e) { + return ((this._autopadding = !!e), this); + }), + (f.prototype.add = function (e) { + this.cache = s.concat([this.cache, e]); + }), + (f.prototype.get = function () { + if (this.cache.length > 15) { + var e = this.cache.slice(0, 16); + return ((this.cache = this.cache.slice(16)), e); + } + return null; + }), + (f.prototype.flush = function () { + for ( + var e = 16 - this.cache.length, t = s.allocUnsafe(e), r = -1; + ++r < e; + ) + t.writeUInt8(e, r); + return s.concat([this.cache, t]); + }), + (r.createCipheriv = d), + (r.createCipher = function (e, t) { + var r = n[e.toLowerCase()]; + if (!r) throw new TypeError("invalid suite type"); + var i = c(t, !1, r.key, r.iv); + return d(e, i.key, i.iv); + })); + }, + { + "./aes": 189, + "./authCipher": 190, + "./modes": 202, + "./streamCipher": 205, + "cipher-base": 221, + evp_bytestokey: 423, + inherits: 440, + "safe-buffer": 494, + }, + ], + 194: [ + function (e, t, r) { + "use strict"; + var n = e("safe-buffer").Buffer, + i = n.alloc(16, 0); + function s(e) { + var t = n.allocUnsafe(16); + return ( + t.writeUInt32BE(e[0] >>> 0, 0), + t.writeUInt32BE(e[1] >>> 0, 4), + t.writeUInt32BE(e[2] >>> 0, 8), + t.writeUInt32BE(e[3] >>> 0, 12), + t + ); + } + function o(e) { + ((this.h = e), + (this.state = n.alloc(16, 0)), + (this.cache = n.allocUnsafe(0))); + } + ((o.prototype.ghash = function (e) { + for (var t = -1; ++t < e.length; ) this.state[t] ^= e[t]; + this._multiply(); + }), + (o.prototype._multiply = function () { + for ( + var e, + t, + r, + n = [ + (e = this.h).readUInt32BE(0), + e.readUInt32BE(4), + e.readUInt32BE(8), + e.readUInt32BE(12), + ], + i = [0, 0, 0, 0], + o = -1; + ++o < 128; + ) { + for ( + 0 != (this.state[~~(o / 8)] & (1 << (7 - (o % 8)))) && + ((i[0] ^= n[0]), + (i[1] ^= n[1]), + (i[2] ^= n[2]), + (i[3] ^= n[3])), + r = 0 != (1 & n[3]), + t = 3; + t > 0; + t-- + ) + n[t] = (n[t] >>> 1) | ((1 & n[t - 1]) << 31); + ((n[0] = n[0] >>> 1), r && (n[0] = n[0] ^ (225 << 24))); + } + this.state = s(i); + }), + (o.prototype.update = function (e) { + var t; + for ( + this.cache = n.concat([this.cache, e]); + this.cache.length >= 16; + ) + ((t = this.cache.slice(0, 16)), + (this.cache = this.cache.slice(16)), + this.ghash(t)); + }), + (o.prototype.final = function (e, t) { + return ( + this.cache.length && this.ghash(n.concat([this.cache, i], 16)), + this.ghash(s([0, e, 0, t])), + this.state + ); + }), + (t.exports = o)); + }, + { "safe-buffer": 494 }, + ], + 195: [ + function (e, t, r) { + "use strict"; + t.exports = function (e) { + for (var t, r = e.length; r--; ) { + if (255 !== (t = e.readUInt8(r))) { + (t++, e.writeUInt8(t, r)); + break; + } + e.writeUInt8(0, r); + } + }; + }, + {}, + ], + 196: [ + function (e, t, r) { + "use strict"; + var n = e("buffer-xor"); + ((r.encrypt = function (e, t) { + var r = n(t, e._prev); + return ((e._prev = e._cipher.encryptBlock(r)), e._prev); + }), + (r.decrypt = function (e, t) { + var r = e._prev; + e._prev = t; + var i = e._cipher.decryptBlock(t); + return n(i, r); + })); + }, + { "buffer-xor": 219 }, + ], + 197: [ + function (e, t, r) { + "use strict"; + var n = e("safe-buffer").Buffer, + i = e("buffer-xor"); + function s(e, t, r) { + var s = t.length, + o = i(t, e._cache); + return ( + (e._cache = e._cache.slice(s)), + (e._prev = n.concat([e._prev, r ? t : o])), + o + ); + } + r.encrypt = function (e, t, r) { + for (var i, o = n.allocUnsafe(0); t.length; ) { + if ( + (0 === e._cache.length && + ((e._cache = e._cipher.encryptBlock(e._prev)), + (e._prev = n.allocUnsafe(0))), + !(e._cache.length <= t.length)) + ) { + o = n.concat([o, s(e, t, r)]); + break; + } + ((i = e._cache.length), + (o = n.concat([o, s(e, t.slice(0, i), r)])), + (t = t.slice(i))); + } + return o; + }; + }, + { "buffer-xor": 219, "safe-buffer": 494 }, + ], + 198: [ + function (e, t, r) { + "use strict"; + var n = e("safe-buffer").Buffer; + function i(e, t, r) { + for (var n, i, o = -1, a = 0; ++o < 8; ) + ((n = t & (1 << (7 - o)) ? 128 : 0), + (a += + (128 & (i = e._cipher.encryptBlock(e._prev)[0] ^ n)) >> + (o % 8)), + (e._prev = s(e._prev, r ? n : i))); + return a; + } + function s(e, t) { + var r = e.length, + i = -1, + s = n.allocUnsafe(e.length); + for (e = n.concat([e, n.from([t])]); ++i < r; ) + s[i] = (e[i] << 1) | (e[i + 1] >> 7); + return s; + } + r.encrypt = function (e, t, r) { + for (var s = t.length, o = n.allocUnsafe(s), a = -1; ++a < s; ) + o[a] = i(e, t[a], r); + return o; + }; + }, + { "safe-buffer": 494 }, + ], + 199: [ + function (e, t, r) { + "use strict"; + var n = e("safe-buffer").Buffer; + function i(e, t, r) { + var i = e._cipher.encryptBlock(e._prev)[0] ^ t; + return ( + (e._prev = n.concat([e._prev.slice(1), n.from([r ? t : i])])), + i + ); + } + r.encrypt = function (e, t, r) { + for (var s = t.length, o = n.allocUnsafe(s), a = -1; ++a < s; ) + o[a] = i(e, t[a], r); + return o; + }; + }, + { "safe-buffer": 494 }, + ], + 200: [ + function (e, t, r) { + "use strict"; + var n = e("buffer-xor"), + i = e("safe-buffer").Buffer, + s = e("../incr32"); + function o(e) { + var t = e._cipher.encryptBlockRaw(e._prev); + return (s(e._prev), t); + } + r.encrypt = function (e, t) { + var r = Math.ceil(t.length / 16), + s = e._cache.length; + e._cache = i.concat([e._cache, i.allocUnsafe(16 * r)]); + for (var a = 0; a < r; a++) { + var l = o(e), + c = s + 16 * a; + (e._cache.writeUInt32BE(l[0], c + 0), + e._cache.writeUInt32BE(l[1], c + 4), + e._cache.writeUInt32BE(l[2], c + 8), + e._cache.writeUInt32BE(l[3], c + 12)); + } + var u = e._cache.slice(0, t.length); + return ((e._cache = e._cache.slice(t.length)), n(t, u)); + }; + }, + { "../incr32": 195, "buffer-xor": 219, "safe-buffer": 494 }, + ], + 201: [ + function (e, t, r) { + "use strict"; + ((r.encrypt = function (e, t) { + return e._cipher.encryptBlock(t); + }), + (r.decrypt = function (e, t) { + return e._cipher.decryptBlock(t); + })); + }, + {}, + ], + 202: [ + function (e, t, r) { + "use strict"; + var n = { + ECB: e("./ecb"), + CBC: e("./cbc"), + CFB: e("./cfb"), + CFB8: e("./cfb8"), + CFB1: e("./cfb1"), + OFB: e("./ofb"), + CTR: e("./ctr"), + GCM: e("./ctr"), + }, + i = e("./list.json"); + for (var s in i) i[s].module = n[i[s].mode]; + t.exports = i; + }, + { + "./cbc": 196, + "./cfb": 197, + "./cfb1": 198, + "./cfb8": 199, + "./ctr": 200, + "./ecb": 201, + "./list.json": 203, + "./ofb": 204, + }, + ], + 203: [ + function (e, t, r) { + t.exports = { + "aes-128-ecb": { + cipher: "AES", + key: 128, + iv: 0, + mode: "ECB", + type: "block", + }, + "aes-192-ecb": { + cipher: "AES", + key: 192, + iv: 0, + mode: "ECB", + type: "block", + }, + "aes-256-ecb": { + cipher: "AES", + key: 256, + iv: 0, + mode: "ECB", + type: "block", + }, + "aes-128-cbc": { + cipher: "AES", + key: 128, + iv: 16, + mode: "CBC", + type: "block", + }, + "aes-192-cbc": { + cipher: "AES", + key: 192, + iv: 16, + mode: "CBC", + type: "block", + }, + "aes-256-cbc": { + cipher: "AES", + key: 256, + iv: 16, + mode: "CBC", + type: "block", + }, + aes128: { + cipher: "AES", + key: 128, + iv: 16, + mode: "CBC", + type: "block", + }, + aes192: { + cipher: "AES", + key: 192, + iv: 16, + mode: "CBC", + type: "block", + }, + aes256: { + cipher: "AES", + key: 256, + iv: 16, + mode: "CBC", + type: "block", + }, + "aes-128-cfb": { + cipher: "AES", + key: 128, + iv: 16, + mode: "CFB", + type: "stream", + }, + "aes-192-cfb": { + cipher: "AES", + key: 192, + iv: 16, + mode: "CFB", + type: "stream", + }, + "aes-256-cfb": { + cipher: "AES", + key: 256, + iv: 16, + mode: "CFB", + type: "stream", + }, + "aes-128-cfb8": { + cipher: "AES", + key: 128, + iv: 16, + mode: "CFB8", + type: "stream", + }, + "aes-192-cfb8": { + cipher: "AES", + key: 192, + iv: 16, + mode: "CFB8", + type: "stream", + }, + "aes-256-cfb8": { + cipher: "AES", + key: 256, + iv: 16, + mode: "CFB8", + type: "stream", + }, + "aes-128-cfb1": { + cipher: "AES", + key: 128, + iv: 16, + mode: "CFB1", + type: "stream", + }, + "aes-192-cfb1": { + cipher: "AES", + key: 192, + iv: 16, + mode: "CFB1", + type: "stream", + }, + "aes-256-cfb1": { + cipher: "AES", + key: 256, + iv: 16, + mode: "CFB1", + type: "stream", + }, + "aes-128-ofb": { + cipher: "AES", + key: 128, + iv: 16, + mode: "OFB", + type: "stream", + }, + "aes-192-ofb": { + cipher: "AES", + key: 192, + iv: 16, + mode: "OFB", + type: "stream", + }, + "aes-256-ofb": { + cipher: "AES", + key: 256, + iv: 16, + mode: "OFB", + type: "stream", + }, + "aes-128-ctr": { + cipher: "AES", + key: 128, + iv: 16, + mode: "CTR", + type: "stream", + }, + "aes-192-ctr": { + cipher: "AES", + key: 192, + iv: 16, + mode: "CTR", + type: "stream", + }, + "aes-256-ctr": { + cipher: "AES", + key: 256, + iv: 16, + mode: "CTR", + type: "stream", + }, + "aes-128-gcm": { + cipher: "AES", + key: 128, + iv: 12, + mode: "GCM", + type: "auth", + }, + "aes-192-gcm": { + cipher: "AES", + key: 192, + iv: 12, + mode: "GCM", + type: "auth", + }, + "aes-256-gcm": { + cipher: "AES", + key: 256, + iv: 12, + mode: "GCM", + type: "auth", + }, + }; + }, + {}, + ], + 204: [ + function (e, t, r) { + (function (t) { + (function () { + "use strict"; + var n = e("buffer-xor"); + function i(e) { + return ((e._prev = e._cipher.encryptBlock(e._prev)), e._prev); + } + r.encrypt = function (e, r) { + for (; e._cache.length < r.length; ) + e._cache = t.concat([e._cache, i(e)]); + var s = e._cache.slice(0, r.length); + return ((e._cache = e._cache.slice(r.length)), n(r, s)); + }; + }).call(this); + }).call(this, e("buffer").Buffer); + }, + { buffer: 220, "buffer-xor": 219 }, + ], + 205: [ + function (e, t, r) { + "use strict"; + var n = e("./aes"), + i = e("safe-buffer").Buffer, + s = e("cipher-base"); + function o(e, t, r, o) { + (s.call(this), + (this._cipher = new n.AES(t)), + (this._prev = i.from(r)), + (this._cache = i.allocUnsafe(0)), + (this._secCache = i.allocUnsafe(0)), + (this._decrypt = o), + (this._mode = e)); + } + (e("inherits")(o, s), + (o.prototype._update = function (e) { + return this._mode.encrypt(this, e, this._decrypt); + }), + (o.prototype._final = function () { + this._cipher.scrub(); + }), + (t.exports = o)); + }, + { "./aes": 189, "cipher-base": 221, inherits: 440, "safe-buffer": 494 }, + ], + 206: [ + function (e, t, r) { + "use strict"; + var n = e("browserify-des"), + i = e("browserify-aes/browser"), + s = e("browserify-aes/modes"), + o = e("browserify-des/modes"), + a = e("evp_bytestokey"); + function l(e, t, r) { + if (((e = e.toLowerCase()), s[e])) return i.createCipheriv(e, t, r); + if (o[e]) return new n({ key: t, iv: r, mode: e }); + throw new TypeError("invalid suite type"); + } + function c(e, t, r) { + if (((e = e.toLowerCase()), s[e])) + return i.createDecipheriv(e, t, r); + if (o[e]) return new n({ key: t, iv: r, mode: e, decrypt: !0 }); + throw new TypeError("invalid suite type"); + } + ((r.createCipher = r.Cipher = + function (e, t) { + var r, n; + if (((e = e.toLowerCase()), s[e])) + ((r = s[e].key), (n = s[e].iv)); + else { + if (!o[e]) throw new TypeError("invalid suite type"); + ((r = 8 * o[e].key), (n = o[e].iv)); + } + var i = a(t, !1, r, n); + return l(e, i.key, i.iv); + }), + (r.createCipheriv = r.Cipheriv = l), + (r.createDecipher = r.Decipher = + function (e, t) { + var r, n; + if (((e = e.toLowerCase()), s[e])) + ((r = s[e].key), (n = s[e].iv)); + else { + if (!o[e]) throw new TypeError("invalid suite type"); + ((r = 8 * o[e].key), (n = o[e].iv)); + } + var i = a(t, !1, r, n); + return c(e, i.key, i.iv); + }), + (r.createDecipheriv = r.Decipheriv = c), + (r.listCiphers = r.getCiphers = + function () { + return Object.keys(o).concat(i.getCiphers()); + })); + }, + { + "browserify-aes/browser": 191, + "browserify-aes/modes": 202, + "browserify-des": 207, + "browserify-des/modes": 208, + evp_bytestokey: 423, + }, + ], + 207: [ + function (e, t, r) { + "use strict"; + var n = e("cipher-base"), + i = e("des.js"), + s = e("inherits"), + o = e("safe-buffer").Buffer, + a = { + "des-ede3-cbc": i.CBC.instantiate(i.EDE), + "des-ede3": i.EDE, + "des-ede-cbc": i.CBC.instantiate(i.EDE), + "des-ede": i.EDE, + "des-cbc": i.CBC.instantiate(i.DES), + "des-ecb": i.DES, + }; + function l(e) { + n.call(this); + var t, + r = e.mode.toLowerCase(), + i = a[r]; + t = e.decrypt ? "decrypt" : "encrypt"; + var s = e.key; + (o.isBuffer(s) || (s = o.from(s)), + ("des-ede" !== r && "des-ede-cbc" !== r) || + (s = o.concat([s, s.slice(0, 8)]))); + var l = e.iv; + (o.isBuffer(l) || (l = o.from(l)), + (this._des = i.create({ key: s, iv: l, type: t }))); + } + ((a.des = a["des-cbc"]), + (a.des3 = a["des-ede3-cbc"]), + (t.exports = l), + s(l, n), + (l.prototype._update = function (e) { + return o.from(this._des.update(e)); + }), + (l.prototype._final = function () { + return o.from(this._des.final()); + })); + }, + { + "cipher-base": 221, + "des.js": 394, + inherits: 440, + "safe-buffer": 494, + }, + ], + 208: [ + function (e, t, r) { + "use strict"; + ((r["des-ecb"] = { key: 8, iv: 0 }), + (r["des-cbc"] = r.des = { key: 8, iv: 8 }), + (r["des-ede3-cbc"] = r.des3 = { key: 24, iv: 8 }), + (r["des-ede3"] = { key: 24, iv: 0 }), + (r["des-ede-cbc"] = { key: 16, iv: 8 }), + (r["des-ede"] = { key: 16, iv: 0 })); + }, + {}, + ], + 209: [ + function (e, t, r) { + (function (r) { + (function () { + "use strict"; + var n = e("bn.js"), + i = e("randombytes"); + function s(e) { + var t, + r = e.modulus.byteLength(); + do { + t = new n(i(r)); + } while ( + t.cmp(e.modulus) >= 0 || + !t.umod(e.prime1) || + !t.umod(e.prime2) + ); + return t; + } + function o(e, t) { + var i = (function (e) { + var t = s(e); + return { + blinder: t + .toRed(n.mont(e.modulus)) + .redPow(new n(e.publicExponent)) + .fromRed(), + unblinder: t.invm(e.modulus), + }; + })(t), + o = t.modulus.byteLength(), + a = new n(e).mul(i.blinder).umod(t.modulus), + l = a.toRed(n.mont(t.prime1)), + c = a.toRed(n.mont(t.prime2)), + u = t.coefficient, + h = t.prime1, + f = t.prime2, + d = l.redPow(t.exponent1).fromRed(), + p = c.redPow(t.exponent2).fromRed(), + m = d.isub(p).imul(u).umod(h).imul(f); + return p + .iadd(m) + .imul(i.unblinder) + .umod(t.modulus) + .toArrayLike(r, "be", o); + } + ((o.getr = s), (t.exports = o)); + }).call(this); + }).call(this, e("buffer").Buffer); + }, + { "bn.js": 186, buffer: 220, randombytes: 475 }, + ], + 210: [ + function (e, t, r) { + "use strict"; + t.exports = e("./browser/algorithms.json"); + }, + { "./browser/algorithms.json": 211 }, + ], + 211: [ + function (e, t, r) { + t.exports = { + sha224WithRSAEncryption: { + sign: "rsa", + hash: "sha224", + id: "302d300d06096086480165030402040500041c", + }, + "RSA-SHA224": { + sign: "ecdsa/rsa", + hash: "sha224", + id: "302d300d06096086480165030402040500041c", + }, + sha256WithRSAEncryption: { + sign: "rsa", + hash: "sha256", + id: "3031300d060960864801650304020105000420", + }, + "RSA-SHA256": { + sign: "ecdsa/rsa", + hash: "sha256", + id: "3031300d060960864801650304020105000420", + }, + sha384WithRSAEncryption: { + sign: "rsa", + hash: "sha384", + id: "3041300d060960864801650304020205000430", + }, + "RSA-SHA384": { + sign: "ecdsa/rsa", + hash: "sha384", + id: "3041300d060960864801650304020205000430", + }, + sha512WithRSAEncryption: { + sign: "rsa", + hash: "sha512", + id: "3051300d060960864801650304020305000440", + }, + "RSA-SHA512": { + sign: "ecdsa/rsa", + hash: "sha512", + id: "3051300d060960864801650304020305000440", + }, + "RSA-SHA1": { + sign: "rsa", + hash: "sha1", + id: "3021300906052b0e03021a05000414", + }, + "ecdsa-with-SHA1": { sign: "ecdsa", hash: "sha1", id: "" }, + sha256: { sign: "ecdsa", hash: "sha256", id: "" }, + sha224: { sign: "ecdsa", hash: "sha224", id: "" }, + sha384: { sign: "ecdsa", hash: "sha384", id: "" }, + sha512: { sign: "ecdsa", hash: "sha512", id: "" }, + "DSA-SHA": { sign: "dsa", hash: "sha1", id: "" }, + "DSA-SHA1": { sign: "dsa", hash: "sha1", id: "" }, + DSA: { sign: "dsa", hash: "sha1", id: "" }, + "DSA-WITH-SHA224": { sign: "dsa", hash: "sha224", id: "" }, + "DSA-SHA224": { sign: "dsa", hash: "sha224", id: "" }, + "DSA-WITH-SHA256": { sign: "dsa", hash: "sha256", id: "" }, + "DSA-SHA256": { sign: "dsa", hash: "sha256", id: "" }, + "DSA-WITH-SHA384": { sign: "dsa", hash: "sha384", id: "" }, + "DSA-SHA384": { sign: "dsa", hash: "sha384", id: "" }, + "DSA-WITH-SHA512": { sign: "dsa", hash: "sha512", id: "" }, + "DSA-SHA512": { sign: "dsa", hash: "sha512", id: "" }, + "DSA-RIPEMD160": { sign: "dsa", hash: "rmd160", id: "" }, + ripemd160WithRSA: { + sign: "rsa", + hash: "rmd160", + id: "3021300906052b2403020105000414", + }, + "RSA-RIPEMD160": { + sign: "rsa", + hash: "rmd160", + id: "3021300906052b2403020105000414", + }, + md5WithRSAEncryption: { + sign: "rsa", + hash: "md5", + id: "3020300c06082a864886f70d020505000410", + }, + "RSA-MD5": { + sign: "rsa", + hash: "md5", + id: "3020300c06082a864886f70d020505000410", + }, + }; + }, + {}, + ], + 212: [ + function (e, t, r) { + t.exports = { + "1.3.132.0.10": "secp256k1", + "1.3.132.0.33": "p224", + "1.2.840.10045.3.1.1": "p192", + "1.2.840.10045.3.1.7": "p256", + "1.3.132.0.34": "p384", + "1.3.132.0.35": "p521", + }; + }, + {}, + ], + 213: [ + function (e, t, r) { + "use strict"; + var n = e("safe-buffer").Buffer, + i = e("create-hash"), + s = e("readable-stream"), + o = e("inherits"), + a = e("./sign"), + l = e("./verify"), + c = e("./algorithms.json"); + function u(e) { + s.Writable.call(this); + var t = c[e]; + if (!t) throw new Error("Unknown message digest"); + ((this._hashType = t.hash), + (this._hash = i(t.hash)), + (this._tag = t.id), + (this._signType = t.sign)); + } + function h(e) { + s.Writable.call(this); + var t = c[e]; + if (!t) throw new Error("Unknown message digest"); + ((this._hash = i(t.hash)), + (this._tag = t.id), + (this._signType = t.sign)); + } + function f(e) { + return new u(e); + } + function d(e) { + return new h(e); + } + (Object.keys(c).forEach(function (e) { + ((c[e].id = n.from(c[e].id, "hex")), (c[e.toLowerCase()] = c[e])); + }), + o(u, s.Writable), + (u.prototype._write = function (e, t, r) { + (this._hash.update(e), r()); + }), + (u.prototype.update = function (e, t) { + return ( + "string" == typeof e && (e = n.from(e, t)), + this._hash.update(e), + this + ); + }), + (u.prototype.sign = function (e, t) { + this.end(); + var r = this._hash.digest(), + n = a(r, e, this._hashType, this._signType, this._tag); + return t ? n.toString(t) : n; + }), + o(h, s.Writable), + (h.prototype._write = function (e, t, r) { + (this._hash.update(e), r()); + }), + (h.prototype.update = function (e, t) { + return ( + "string" == typeof e && (e = n.from(e, t)), + this._hash.update(e), + this + ); + }), + (h.prototype.verify = function (e, t, r) { + ("string" == typeof t && (t = n.from(t, r)), this.end()); + var i = this._hash.digest(); + return l(t, i, e, this._signType, this._tag); + }), + (t.exports = { + Sign: f, + Verify: d, + createSign: f, + createVerify: d, + })); + }, + { + "./algorithms.json": 211, + "./sign": 214, + "./verify": 215, + "create-hash": 386, + inherits: 440, + "readable-stream": 491, + "safe-buffer": 494, + }, + ], + 214: [ + function (e, t, r) { + "use strict"; + var n = e("safe-buffer").Buffer, + i = e("create-hmac"), + s = e("browserify-rsa"), + o = e("elliptic").ec, + a = e("bn.js"), + l = e("parse-asn1"), + c = e("./curves.json"); + function u(e, t, r, s) { + if ((e = n.from(e.toArray())).length < t.byteLength()) { + var o = n.alloc(t.byteLength() - e.length); + e = n.concat([o, e]); + } + var a = r.length, + l = (function (e, t) { + e = (e = h(e, t)).mod(t); + var r = n.from(e.toArray()); + if (r.length < t.byteLength()) { + var i = n.alloc(t.byteLength() - r.length); + r = n.concat([i, r]); + } + return r; + })(r, t), + c = n.alloc(a); + c.fill(1); + var u = n.alloc(a); + return ( + (u = i(s, u) + .update(c) + .update(n.from([0])) + .update(e) + .update(l) + .digest()), + (c = i(s, u).update(c).digest()), + { + k: (u = i(s, u) + .update(c) + .update(n.from([1])) + .update(e) + .update(l) + .digest()), + v: (c = i(s, u).update(c).digest()), + } + ); + } + function h(e, t) { + var r = new a(e), + n = (e.length << 3) - t.bitLength(); + return (n > 0 && r.ishrn(n), r); + } + function f(e, t, r) { + var s, o; + do { + for (s = n.alloc(0); 8 * s.length < e.bitLength(); ) + ((t.v = i(r, t.k).update(t.v).digest()), + (s = n.concat([s, t.v]))); + ((o = h(s, e)), + (t.k = i(r, t.k) + .update(t.v) + .update(n.from([0])) + .digest()), + (t.v = i(r, t.k).update(t.v).digest())); + } while (-1 !== o.cmp(e)); + return o; + } + function d(e, t, r, n) { + return e.toRed(a.mont(r)).redPow(t).fromRed().mod(n); + } + ((t.exports = function (e, t, r, i, p) { + var m = l(t); + if (m.curve) { + if ("ecdsa" !== i && "ecdsa/rsa" !== i) + throw new Error("wrong private key type"); + return (function (e, t) { + var r = c[t.curve.join(".")]; + if (!r) throw new Error("unknown curve " + t.curve.join(".")); + var i = new o(r).keyFromPrivate(t.privateKey).sign(e); + return n.from(i.toDER()); + })(e, m); + } + if ("dsa" === m.type) { + if ("dsa" !== i) throw new Error("wrong private key type"); + return (function (e, t, r) { + var i, + s = t.params.priv_key, + o = t.params.p, + l = t.params.q, + c = t.params.g, + p = new a(0), + m = h(e, l).mod(l), + b = !1, + g = u(s, l, e, r); + for (; !1 === b; ) + ((i = f(l, g, r)), + (p = d(c, i, o, l)), + 0 === + (b = i + .invm(l) + .imul(m.add(s.mul(p))) + .mod(l)).cmpn(0) && ((b = !1), (p = new a(0)))); + return (function (e, t) { + ((e = e.toArray()), + (t = t.toArray()), + 128 & e[0] && (e = [0].concat(e))); + 128 & t[0] && (t = [0].concat(t)); + var r = [48, e.length + t.length + 4, 2, e.length]; + return ((r = r.concat(e, [2, t.length], t)), n.from(r)); + })(p, b); + })(e, m, r); + } + if ("rsa" !== i && "ecdsa/rsa" !== i) + throw new Error("wrong private key type"); + e = n.concat([p, e]); + for ( + var b = m.modulus.byteLength(), g = [0, 1]; + e.length + g.length + 1 < b; + ) + g.push(255); + g.push(0); + for (var y = -1; ++y < e.length; ) g.push(e[y]); + return s(g, m); + }), + (t.exports.getKey = u), + (t.exports.makeKey = f)); + }, + { + "./curves.json": 212, + "bn.js": 186, + "browserify-rsa": 209, + "create-hmac": 388, + elliptic: 405, + "parse-asn1": 459, + "safe-buffer": 494, + }, + ], + 215: [ + function (e, t, r) { + "use strict"; + var n = e("safe-buffer").Buffer, + i = e("bn.js"), + s = e("elliptic").ec, + o = e("parse-asn1"), + a = e("./curves.json"); + function l(e, t) { + if (e.cmpn(0) <= 0) throw new Error("invalid sig"); + if (e.cmp(t) >= t) throw new Error("invalid sig"); + } + t.exports = function (e, t, r, c, u) { + var h = o(r); + if ("ec" === h.type) { + if ("ecdsa" !== c && "ecdsa/rsa" !== c) + throw new Error("wrong public key type"); + return (function (e, t, r) { + var n = a[r.data.algorithm.curve.join(".")]; + if (!n) + throw new Error( + "unknown curve " + r.data.algorithm.curve.join("."), + ); + var i = new s(n), + o = r.data.subjectPrivateKey.data; + return i.verify(t, e, o); + })(e, t, h); + } + if ("dsa" === h.type) { + if ("dsa" !== c) throw new Error("wrong public key type"); + return (function (e, t, r) { + var n = r.data.p, + s = r.data.q, + a = r.data.g, + c = r.data.pub_key, + u = o.signature.decode(e, "der"), + h = u.s, + f = u.r; + (l(h, s), l(f, s)); + var d = i.mont(n), + p = h.invm(s); + return ( + 0 === + a + .toRed(d) + .redPow(new i(t).mul(p).mod(s)) + .fromRed() + .mul(c.toRed(d).redPow(f.mul(p).mod(s)).fromRed()) + .mod(n) + .mod(s) + .cmp(f) + ); + })(e, t, h); + } + if ("rsa" !== c && "ecdsa/rsa" !== c) + throw new Error("wrong public key type"); + t = n.concat([u, t]); + for ( + var f = h.modulus.byteLength(), d = [1], p = 0; + t.length + d.length + 2 < f; + ) + (d.push(255), p++); + d.push(0); + for (var m = -1; ++m < t.length; ) d.push(t[m]); + d = n.from(d); + var b = i.mont(h.modulus); + ((e = (e = new i(e).toRed(b)).redPow(new i(h.publicExponent))), + (e = n.from(e.fromRed().toArray()))); + var g = p < 8 ? 1 : 0; + for ( + f = Math.min(e.length, d.length), + e.length !== d.length && (g = 1), + m = -1; + ++m < f; + ) + g |= e[m] ^ d[m]; + return 0 === g; + }; + }, + { + "./curves.json": 212, + "bn.js": 186, + elliptic: 405, + "parse-asn1": 459, + "safe-buffer": 494, + }, + ], + 216: [function (e, t, r) {}, {}], + 217: [ + function (e, t, r) { + "use strict"; + var n = e("buffer"), + i = n.Buffer; + function s(e, t) { + for (var r in e) t[r] = e[r]; + } + function o(e, t, r) { + return i(e, t, r); + } + (i.from && i.alloc && i.allocUnsafe && i.allocUnsafeSlow + ? (t.exports = n) + : (s(n, r), (r.Buffer = o)), + s(i, o), + (o.from = function (e, t, r) { + if ("number" == typeof e) + throw new TypeError("Argument must not be a number"); + return i(e, t, r); + }), + (o.alloc = function (e, t, r) { + if ("number" != typeof e) + throw new TypeError("Argument must be a number"); + var n = i(e); + return ( + void 0 !== t + ? "string" == typeof r + ? n.fill(t, r) + : n.fill(t) + : n.fill(0), + n + ); + }), + (o.allocUnsafe = function (e) { + if ("number" != typeof e) + throw new TypeError("Argument must be a number"); + return i(e); + }), + (o.allocUnsafeSlow = function (e) { + if ("number" != typeof e) + throw new TypeError("Argument must be a number"); + return n.SlowBuffer(e); + })); + }, + { buffer: 220 }, + ], + 218: [ + function (e, t, r) { + "use strict"; + var n = e("safe-buffer").Buffer, + i = + n.isEncoding || + function (e) { + switch ((e = "" + e) && e.toLowerCase()) { + case "hex": + case "utf8": + case "utf-8": + case "ascii": + case "binary": + case "base64": + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + case "raw": + return !0; + default: + return !1; + } + }; + function s(e) { + var t; + switch ( + ((this.encoding = (function (e) { + var t = (function (e) { + if (!e) return "utf8"; + for (var t; ; ) + switch (e) { + case "utf8": + case "utf-8": + return "utf8"; + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return "utf16le"; + case "latin1": + case "binary": + return "latin1"; + case "base64": + case "ascii": + case "hex": + return e; + default: + if (t) return; + ((e = ("" + e).toLowerCase()), (t = !0)); + } + })(e); + if ("string" != typeof t && (n.isEncoding === i || !i(e))) + throw new Error("Unknown encoding: " + e); + return t || e; + })(e)), + this.encoding) + ) { + case "utf16le": + ((this.text = l), (this.end = c), (t = 4)); + break; + case "utf8": + ((this.fillLast = a), (t = 4)); + break; + case "base64": + ((this.text = u), (this.end = h), (t = 3)); + break; + default: + return ((this.write = f), void (this.end = d)); + } + ((this.lastNeed = 0), + (this.lastTotal = 0), + (this.lastChar = n.allocUnsafe(t))); + } + function o(e) { + return e <= 127 + ? 0 + : e >> 5 == 6 + ? 2 + : e >> 4 == 14 + ? 3 + : e >> 3 == 30 + ? 4 + : e >> 6 == 2 + ? -1 + : -2; + } + function a(e) { + var t = this.lastTotal - this.lastNeed, + r = (function (e, t, r) { + if (128 != (192 & t[0])) return ((e.lastNeed = 0), "\ufffd"); + if (e.lastNeed > 1 && t.length > 1) { + if (128 != (192 & t[1])) return ((e.lastNeed = 1), "\ufffd"); + if (e.lastNeed > 2 && t.length > 2 && 128 != (192 & t[2])) + return ((e.lastNeed = 2), "\ufffd"); + } + })(this, e); + return void 0 !== r + ? r + : this.lastNeed <= e.length + ? (e.copy(this.lastChar, t, 0, this.lastNeed), + this.lastChar.toString(this.encoding, 0, this.lastTotal)) + : (e.copy(this.lastChar, t, 0, e.length), + void (this.lastNeed -= e.length)); + } + function l(e, t) { + if ((e.length - t) % 2 == 0) { + var r = e.toString("utf16le", t); + if (r) { + var n = r.charCodeAt(r.length - 1); + if (n >= 55296 && n <= 56319) + return ( + (this.lastNeed = 2), + (this.lastTotal = 4), + (this.lastChar[0] = e[e.length - 2]), + (this.lastChar[1] = e[e.length - 1]), + r.slice(0, -1) + ); + } + return r; + } + return ( + (this.lastNeed = 1), + (this.lastTotal = 2), + (this.lastChar[0] = e[e.length - 1]), + e.toString("utf16le", t, e.length - 1) + ); + } + function c(e) { + var t = e && e.length ? this.write(e) : ""; + if (this.lastNeed) { + var r = this.lastTotal - this.lastNeed; + return t + this.lastChar.toString("utf16le", 0, r); + } + return t; + } + function u(e, t) { + var r = (e.length - t) % 3; + return 0 === r + ? e.toString("base64", t) + : ((this.lastNeed = 3 - r), + (this.lastTotal = 3), + 1 === r + ? (this.lastChar[0] = e[e.length - 1]) + : ((this.lastChar[0] = e[e.length - 2]), + (this.lastChar[1] = e[e.length - 1])), + e.toString("base64", t, e.length - r)); + } + function h(e) { + var t = e && e.length ? this.write(e) : ""; + return this.lastNeed + ? t + this.lastChar.toString("base64", 0, 3 - this.lastNeed) + : t; + } + function f(e) { + return e.toString(this.encoding); + } + function d(e) { + return e && e.length ? this.write(e) : ""; + } + ((r.StringDecoder = s), + (s.prototype.write = function (e) { + if (0 === e.length) return ""; + var t, r; + if (this.lastNeed) { + if (void 0 === (t = this.fillLast(e))) return ""; + ((r = this.lastNeed), (this.lastNeed = 0)); + } else r = 0; + return r < e.length + ? t + ? t + this.text(e, r) + : this.text(e, r) + : t || ""; + }), + (s.prototype.end = function (e) { + var t = e && e.length ? this.write(e) : ""; + return this.lastNeed ? t + "\ufffd" : t; + }), + (s.prototype.text = function (e, t) { + var r = (function (e, t, r) { + var n = t.length - 1; + if (n < r) return 0; + var i = o(t[n]); + if (i >= 0) return (i > 0 && (e.lastNeed = i - 1), i); + if (--n < r || -2 === i) return 0; + if ((i = o(t[n])) >= 0) + return (i > 0 && (e.lastNeed = i - 2), i); + if (--n < r || -2 === i) return 0; + if ((i = o(t[n])) >= 0) + return ( + i > 0 && (2 === i ? (i = 0) : (e.lastNeed = i - 3)), + i + ); + return 0; + })(this, e, t); + if (!this.lastNeed) return e.toString("utf8", t); + this.lastTotal = r; + var n = e.length - (r - this.lastNeed); + return (e.copy(this.lastChar, 0, n), e.toString("utf8", t, n)); + }), + (s.prototype.fillLast = function (e) { + if (this.lastNeed <= e.length) + return ( + e.copy( + this.lastChar, + this.lastTotal - this.lastNeed, + 0, + this.lastNeed, + ), + this.lastChar.toString(this.encoding, 0, this.lastTotal) + ); + (e.copy( + this.lastChar, + this.lastTotal - this.lastNeed, + 0, + e.length, + ), + (this.lastNeed -= e.length)); + })); + }, + { "safe-buffer": 217 }, + ], + 219: [ + function (e, t, r) { + (function (e) { + (function () { + "use strict"; + t.exports = function (t, r) { + for ( + var n = Math.min(t.length, r.length), i = new e(n), s = 0; + s < n; + ++s + ) + i[s] = t[s] ^ r[s]; + return i; + }; + }).call(this); + }).call(this, e("buffer").Buffer); + }, + { buffer: 220 }, + ], + 220: [ + function (e, t, r) { + (function (t) { + (function () { + /*! + * The buffer module from node.js, for the browser. + * + * @author Feross Aboukhadijeh + * @license MIT + */ + "use strict"; + var t = e("base64-js"), + n = e("ieee754"); + ((r.Buffer = s), + (r.SlowBuffer = function (e) { + +e != e && (e = 0); + return s.alloc(+e); + }), + (r.INSPECT_MAX_BYTES = 50)); + function i(e) { + if (e > 2147483647) + throw new RangeError( + 'The value "' + e + '" is invalid for option "size"', + ); + var t = new Uint8Array(e); + return ((t.__proto__ = s.prototype), t); + } + function s(e, t, r) { + if ("number" == typeof e) { + if ("string" == typeof t) + throw new TypeError( + 'The "string" argument must be of type string. Received type number', + ); + return l(e); + } + return o(e, t, r); + } + function o(e, t, r) { + if ("string" == typeof e) + return (function (e, t) { + ("string" == typeof t && "" !== t) || (t = "utf8"); + if (!s.isEncoding(t)) + throw new TypeError("Unknown encoding: " + t); + var r = 0 | h(e, t), + n = i(r), + o = n.write(e, t); + o !== r && (n = n.slice(0, o)); + return n; + })(e, t); + if (ArrayBuffer.isView(e)) return c(e); + if (null == e) + throw TypeError( + "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + + typeof e, + ); + if (F(e, ArrayBuffer) || (e && F(e.buffer, ArrayBuffer))) + return (function (e, t, r) { + if (t < 0 || e.byteLength < t) + throw new RangeError( + '"offset" is outside of buffer bounds', + ); + if (e.byteLength < t + (r || 0)) + throw new RangeError( + '"length" is outside of buffer bounds', + ); + var n; + n = + void 0 === t && void 0 === r + ? new Uint8Array(e) + : void 0 === r + ? new Uint8Array(e, t) + : new Uint8Array(e, t, r); + return ((n.__proto__ = s.prototype), n); + })(e, t, r); + if ("number" == typeof e) + throw new TypeError( + 'The "value" argument must not be of type number. Received type number', + ); + var n = e.valueOf && e.valueOf(); + if (null != n && n !== e) return s.from(n, t, r); + var o = (function (e) { + if (s.isBuffer(e)) { + var t = 0 | u(e.length), + r = i(t); + return (0 === r.length || e.copy(r, 0, 0, t), r); + } + if (void 0 !== e.length) + return "number" != typeof e.length || L(e.length) + ? i(0) + : c(e); + if ("Buffer" === e.type && Array.isArray(e.data)) + return c(e.data); + })(e); + if (o) return o; + if ( + "undefined" != typeof Symbol && + null != Symbol.toPrimitive && + "function" == typeof e[Symbol.toPrimitive] + ) + return s.from(e[Symbol.toPrimitive]("string"), t, r); + throw new TypeError( + "The first argument must be one of type string, Buffer, ArrayBuffer, Array, or Array-like Object. Received type " + + typeof e, + ); + } + function a(e) { + if ("number" != typeof e) + throw new TypeError('"size" argument must be of type number'); + if (e < 0) + throw new RangeError( + 'The value "' + e + '" is invalid for option "size"', + ); + } + function l(e) { + return (a(e), i(e < 0 ? 0 : 0 | u(e))); + } + function c(e) { + for ( + var t = e.length < 0 ? 0 : 0 | u(e.length), r = i(t), n = 0; + n < t; + n += 1 + ) + r[n] = 255 & e[n]; + return r; + } + function u(e) { + if (e >= 2147483647) + throw new RangeError( + "Attempt to allocate Buffer larger than maximum size: 0x" + + (2147483647).toString(16) + + " bytes", + ); + return 0 | e; + } + function h(e, t) { + if (s.isBuffer(e)) return e.length; + if (ArrayBuffer.isView(e) || F(e, ArrayBuffer)) + return e.byteLength; + if ("string" != typeof e) + throw new TypeError( + 'The "string" argument must be one of type string, Buffer, or ArrayBuffer. Received type ' + + typeof e, + ); + var r = e.length, + n = arguments.length > 2 && !0 === arguments[2]; + if (!n && 0 === r) return 0; + for (var i = !1; ; ) + switch (t) { + case "ascii": + case "latin1": + case "binary": + return r; + case "utf8": + case "utf-8": + return P(e).length; + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return 2 * r; + case "hex": + return r >>> 1; + case "base64": + return B(e).length; + default: + if (i) return n ? -1 : P(e).length; + ((t = ("" + t).toLowerCase()), (i = !0)); + } + } + function f(e, t, r) { + var n = !1; + if (((void 0 === t || t < 0) && (t = 0), t > this.length)) + return ""; + if ( + ((void 0 === r || r > this.length) && (r = this.length), + r <= 0) + ) + return ""; + if ((r >>>= 0) <= (t >>>= 0)) return ""; + for (e || (e = "utf8"); ; ) + switch (e) { + case "hex": + return C(this, t, r); + case "utf8": + case "utf-8": + return k(this, t, r); + case "ascii": + return S(this, t, r); + case "latin1": + case "binary": + return M(this, t, r); + case "base64": + return x(this, t, r); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return T(this, t, r); + default: + if (n) throw new TypeError("Unknown encoding: " + e); + ((e = (e + "").toLowerCase()), (n = !0)); + } + } + function d(e, t, r) { + var n = e[t]; + ((e[t] = e[r]), (e[r] = n)); + } + function p(e, t, r, n, i) { + if (0 === e.length) return -1; + if ( + ("string" == typeof r + ? ((n = r), (r = 0)) + : r > 2147483647 + ? (r = 2147483647) + : r < -2147483648 && (r = -2147483648), + L((r = +r)) && (r = i ? 0 : e.length - 1), + r < 0 && (r = e.length + r), + r >= e.length) + ) { + if (i) return -1; + r = e.length - 1; + } else if (r < 0) { + if (!i) return -1; + r = 0; + } + if (("string" == typeof t && (t = s.from(t, n)), s.isBuffer(t))) + return 0 === t.length ? -1 : m(e, t, r, n, i); + if ("number" == typeof t) + return ( + (t &= 255), + "function" == typeof Uint8Array.prototype.indexOf + ? i + ? Uint8Array.prototype.indexOf.call(e, t, r) + : Uint8Array.prototype.lastIndexOf.call(e, t, r) + : m(e, [t], r, n, i) + ); + throw new TypeError("val must be string, number or Buffer"); + } + function m(e, t, r, n, i) { + var s, + o = 1, + a = e.length, + l = t.length; + if ( + void 0 !== n && + ("ucs2" === (n = String(n).toLowerCase()) || + "ucs-2" === n || + "utf16le" === n || + "utf-16le" === n) + ) { + if (e.length < 2 || t.length < 2) return -1; + ((o = 2), (a /= 2), (l /= 2), (r /= 2)); + } + function c(e, t) { + return 1 === o ? e[t] : e.readUInt16BE(t * o); + } + if (i) { + var u = -1; + for (s = r; s < a; s++) + if (c(e, s) === c(t, -1 === u ? 0 : s - u)) { + if ((-1 === u && (u = s), s - u + 1 === l)) return u * o; + } else (-1 !== u && (s -= s - u), (u = -1)); + } else + for (r + l > a && (r = a - l), s = r; s >= 0; s--) { + for (var h = !0, f = 0; f < l; f++) + if (c(e, s + f) !== c(t, f)) { + h = !1; + break; + } + if (h) return s; + } + return -1; + } + function b(e, t, r, n) { + r = Number(r) || 0; + var i = e.length - r; + n ? (n = Number(n)) > i && (n = i) : (n = i); + var s = t.length; + n > s / 2 && (n = s / 2); + for (var o = 0; o < n; ++o) { + var a = parseInt(t.substr(2 * o, 2), 16); + if (L(a)) return o; + e[r + o] = a; + } + return o; + } + function g(e, t, r, n) { + return D(P(t, e.length - r), e, r, n); + } + function y(e, t, r, n) { + return D( + (function (e) { + for (var t = [], r = 0; r < e.length; ++r) + t.push(255 & e.charCodeAt(r)); + return t; + })(t), + e, + r, + n, + ); + } + function v(e, t, r, n) { + return y(e, t, r, n); + } + function w(e, t, r, n) { + return D(B(t), e, r, n); + } + function _(e, t, r, n) { + return D( + (function (e, t) { + for ( + var r, n, i, s = [], o = 0; + o < e.length && !((t -= 2) < 0); + ++o + ) + ((r = e.charCodeAt(o)), + (n = r >> 8), + (i = r % 256), + s.push(i), + s.push(n)); + return s; + })(t, e.length - r), + e, + r, + n, + ); + } + function x(e, r, n) { + return 0 === r && n === e.length + ? t.fromByteArray(e) + : t.fromByteArray(e.slice(r, n)); + } + function k(e, t, r) { + r = Math.min(e.length, r); + for (var n = [], i = t; i < r; ) { + var s, + o, + a, + l, + c = e[i], + u = null, + h = c > 239 ? 4 : c > 223 ? 3 : c > 191 ? 2 : 1; + if (i + h <= r) + switch (h) { + case 1: + c < 128 && (u = c); + break; + case 2: + 128 == (192 & (s = e[i + 1])) && + (l = ((31 & c) << 6) | (63 & s)) > 127 && + (u = l); + break; + case 3: + ((s = e[i + 1]), + (o = e[i + 2]), + 128 == (192 & s) && + 128 == (192 & o) && + (l = + ((15 & c) << 12) | ((63 & s) << 6) | (63 & o)) > + 2047 && + (l < 55296 || l > 57343) && + (u = l)); + break; + case 4: + ((s = e[i + 1]), + (o = e[i + 2]), + (a = e[i + 3]), + 128 == (192 & s) && + 128 == (192 & o) && + 128 == (192 & a) && + (l = + ((15 & c) << 18) | + ((63 & s) << 12) | + ((63 & o) << 6) | + (63 & a)) > 65535 && + l < 1114112 && + (u = l)); + } + (null === u + ? ((u = 65533), (h = 1)) + : u > 65535 && + ((u -= 65536), + n.push(((u >>> 10) & 1023) | 55296), + (u = 56320 | (1023 & u))), + n.push(u), + (i += h)); + } + return (function (e) { + var t = e.length; + if (t <= 4096) return String.fromCharCode.apply(String, e); + var r = "", + n = 0; + for (; n < t; ) + r += String.fromCharCode.apply( + String, + e.slice(n, (n += 4096)), + ); + return r; + })(n); + } + ((r.kMaxLength = 2147483647), + (s.TYPED_ARRAY_SUPPORT = (function () { + try { + var e = new Uint8Array(1); + return ( + (e.__proto__ = { + __proto__: Uint8Array.prototype, + foo: function () { + return 42; + }, + }), + 42 === e.foo() + ); + } catch (e) { + return !1; + } + })()), + s.TYPED_ARRAY_SUPPORT || + "undefined" == typeof console || + "function" != typeof console.error || + console.error( + "This browser lacks typed array (Uint8Array) support which is required by `buffer` v5.x. Use `buffer` v4.x if you require old browser support.", + ), + Object.defineProperty(s.prototype, "parent", { + enumerable: !0, + get: function () { + if (s.isBuffer(this)) return this.buffer; + }, + }), + Object.defineProperty(s.prototype, "offset", { + enumerable: !0, + get: function () { + if (s.isBuffer(this)) return this.byteOffset; + }, + }), + "undefined" != typeof Symbol && + null != Symbol.species && + s[Symbol.species] === s && + Object.defineProperty(s, Symbol.species, { + value: null, + configurable: !0, + enumerable: !1, + writable: !1, + }), + (s.poolSize = 8192), + (s.from = function (e, t, r) { + return o(e, t, r); + }), + (s.prototype.__proto__ = Uint8Array.prototype), + (s.__proto__ = Uint8Array), + (s.alloc = function (e, t, r) { + return (function (e, t, r) { + return ( + a(e), + e <= 0 + ? i(e) + : void 0 !== t + ? "string" == typeof r + ? i(e).fill(t, r) + : i(e).fill(t) + : i(e) + ); + })(e, t, r); + }), + (s.allocUnsafe = function (e) { + return l(e); + }), + (s.allocUnsafeSlow = function (e) { + return l(e); + }), + (s.isBuffer = function (e) { + return null != e && !0 === e._isBuffer && e !== s.prototype; + }), + (s.compare = function (e, t) { + if ( + (F(e, Uint8Array) && + (e = s.from(e, e.offset, e.byteLength)), + F(t, Uint8Array) && (t = s.from(t, t.offset, t.byteLength)), + !s.isBuffer(e) || !s.isBuffer(t)) + ) + throw new TypeError( + 'The "buf1", "buf2" arguments must be one of type Buffer or Uint8Array', + ); + if (e === t) return 0; + for ( + var r = e.length, n = t.length, i = 0, o = Math.min(r, n); + i < o; + ++i + ) + if (e[i] !== t[i]) { + ((r = e[i]), (n = t[i])); + break; + } + return r < n ? -1 : n < r ? 1 : 0; + }), + (s.isEncoding = function (e) { + switch (String(e).toLowerCase()) { + case "hex": + case "utf8": + case "utf-8": + case "ascii": + case "latin1": + case "binary": + case "base64": + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return !0; + default: + return !1; + } + }), + (s.concat = function (e, t) { + if (!Array.isArray(e)) + throw new TypeError( + '"list" argument must be an Array of Buffers', + ); + if (0 === e.length) return s.alloc(0); + var r; + if (void 0 === t) + for (t = 0, r = 0; r < e.length; ++r) t += e[r].length; + var n = s.allocUnsafe(t), + i = 0; + for (r = 0; r < e.length; ++r) { + var o = e[r]; + if ((F(o, Uint8Array) && (o = s.from(o)), !s.isBuffer(o))) + throw new TypeError( + '"list" argument must be an Array of Buffers', + ); + (o.copy(n, i), (i += o.length)); + } + return n; + }), + (s.byteLength = h), + (s.prototype._isBuffer = !0), + (s.prototype.swap16 = function () { + var e = this.length; + if (e % 2 != 0) + throw new RangeError( + "Buffer size must be a multiple of 16-bits", + ); + for (var t = 0; t < e; t += 2) d(this, t, t + 1); + return this; + }), + (s.prototype.swap32 = function () { + var e = this.length; + if (e % 4 != 0) + throw new RangeError( + "Buffer size must be a multiple of 32-bits", + ); + for (var t = 0; t < e; t += 4) + (d(this, t, t + 3), d(this, t + 1, t + 2)); + return this; + }), + (s.prototype.swap64 = function () { + var e = this.length; + if (e % 8 != 0) + throw new RangeError( + "Buffer size must be a multiple of 64-bits", + ); + for (var t = 0; t < e; t += 8) + (d(this, t, t + 7), + d(this, t + 1, t + 6), + d(this, t + 2, t + 5), + d(this, t + 3, t + 4)); + return this; + }), + (s.prototype.toString = function () { + var e = this.length; + return 0 === e + ? "" + : 0 === arguments.length + ? k(this, 0, e) + : f.apply(this, arguments); + }), + (s.prototype.toLocaleString = s.prototype.toString), + (s.prototype.equals = function (e) { + if (!s.isBuffer(e)) + throw new TypeError("Argument must be a Buffer"); + return this === e || 0 === s.compare(this, e); + }), + (s.prototype.inspect = function () { + var e = "", + t = r.INSPECT_MAX_BYTES; + return ( + (e = this.toString("hex", 0, t) + .replace(/(.{2})/g, "$1 ") + .trim()), + this.length > t && (e += " ... "), + "" + ); + }), + (s.prototype.compare = function (e, t, r, n, i) { + if ( + (F(e, Uint8Array) && + (e = s.from(e, e.offset, e.byteLength)), + !s.isBuffer(e)) + ) + throw new TypeError( + 'The "target" argument must be one of type Buffer or Uint8Array. Received type ' + + typeof e, + ); + if ( + (void 0 === t && (t = 0), + void 0 === r && (r = e ? e.length : 0), + void 0 === n && (n = 0), + void 0 === i && (i = this.length), + t < 0 || r > e.length || n < 0 || i > this.length) + ) + throw new RangeError("out of range index"); + if (n >= i && t >= r) return 0; + if (n >= i) return -1; + if (t >= r) return 1; + if (this === e) return 0; + for ( + var o = (i >>>= 0) - (n >>>= 0), + a = (r >>>= 0) - (t >>>= 0), + l = Math.min(o, a), + c = this.slice(n, i), + u = e.slice(t, r), + h = 0; + h < l; + ++h + ) + if (c[h] !== u[h]) { + ((o = c[h]), (a = u[h])); + break; + } + return o < a ? -1 : a < o ? 1 : 0; + }), + (s.prototype.includes = function (e, t, r) { + return -1 !== this.indexOf(e, t, r); + }), + (s.prototype.indexOf = function (e, t, r) { + return p(this, e, t, r, !0); + }), + (s.prototype.lastIndexOf = function (e, t, r) { + return p(this, e, t, r, !1); + }), + (s.prototype.write = function (e, t, r, n) { + if (void 0 === t) ((n = "utf8"), (r = this.length), (t = 0)); + else if (void 0 === r && "string" == typeof t) + ((n = t), (r = this.length), (t = 0)); + else { + if (!isFinite(t)) + throw new Error( + "Buffer.write(string, encoding, offset[, length]) is no longer supported", + ); + ((t >>>= 0), + isFinite(r) + ? ((r >>>= 0), void 0 === n && (n = "utf8")) + : ((n = r), (r = void 0))); + } + var i = this.length - t; + if ( + ((void 0 === r || r > i) && (r = i), + (e.length > 0 && (r < 0 || t < 0)) || t > this.length) + ) + throw new RangeError( + "Attempt to write outside buffer bounds", + ); + n || (n = "utf8"); + for (var s = !1; ; ) + switch (n) { + case "hex": + return b(this, e, t, r); + case "utf8": + case "utf-8": + return g(this, e, t, r); + case "ascii": + return y(this, e, t, r); + case "latin1": + case "binary": + return v(this, e, t, r); + case "base64": + return w(this, e, t, r); + case "ucs2": + case "ucs-2": + case "utf16le": + case "utf-16le": + return _(this, e, t, r); + default: + if (s) throw new TypeError("Unknown encoding: " + n); + ((n = ("" + n).toLowerCase()), (s = !0)); + } + }), + (s.prototype.toJSON = function () { + return { + type: "Buffer", + data: Array.prototype.slice.call(this._arr || this, 0), + }; + })); + function S(e, t, r) { + var n = ""; + r = Math.min(e.length, r); + for (var i = t; i < r; ++i) + n += String.fromCharCode(127 & e[i]); + return n; + } + function M(e, t, r) { + var n = ""; + r = Math.min(e.length, r); + for (var i = t; i < r; ++i) n += String.fromCharCode(e[i]); + return n; + } + function C(e, t, r) { + var n = e.length; + ((!t || t < 0) && (t = 0), (!r || r < 0 || r > n) && (r = n)); + for (var i = "", s = t; s < r; ++s) i += N(e[s]); + return i; + } + function T(e, t, r) { + for (var n = e.slice(t, r), i = "", s = 0; s < n.length; s += 2) + i += String.fromCharCode(n[s] + 256 * n[s + 1]); + return i; + } + function E(e, t, r) { + if (e % 1 != 0 || e < 0) + throw new RangeError("offset is not uint"); + if (e + t > r) + throw new RangeError("Trying to access beyond buffer length"); + } + function A(e, t, r, n, i, o) { + if (!s.isBuffer(e)) + throw new TypeError( + '"buffer" argument must be a Buffer instance', + ); + if (t > i || t < o) + throw new RangeError('"value" argument is out of bounds'); + if (r + n > e.length) + throw new RangeError("Index out of range"); + } + function R(e, t, r, n, i, s) { + if (r + n > e.length) + throw new RangeError("Index out of range"); + if (r < 0) throw new RangeError("Index out of range"); + } + function O(e, t, r, i, s) { + return ( + (t = +t), + (r >>>= 0), + s || R(e, 0, r, 4), + n.write(e, t, r, i, 23, 4), + r + 4 + ); + } + function j(e, t, r, i, s) { + return ( + (t = +t), + (r >>>= 0), + s || R(e, 0, r, 8), + n.write(e, t, r, i, 52, 8), + r + 8 + ); + } + ((s.prototype.slice = function (e, t) { + var r = this.length; + ((e = ~~e) < 0 ? (e += r) < 0 && (e = 0) : e > r && (e = r), + (t = void 0 === t ? r : ~~t) < 0 + ? (t += r) < 0 && (t = 0) + : t > r && (t = r), + t < e && (t = e)); + var n = this.subarray(e, t); + return ((n.__proto__ = s.prototype), n); + }), + (s.prototype.readUIntLE = function (e, t, r) { + ((e >>>= 0), (t >>>= 0), r || E(e, t, this.length)); + for (var n = this[e], i = 1, s = 0; ++s < t && (i *= 256); ) + n += this[e + s] * i; + return n; + }), + (s.prototype.readUIntBE = function (e, t, r) { + ((e >>>= 0), (t >>>= 0), r || E(e, t, this.length)); + for (var n = this[e + --t], i = 1; t > 0 && (i *= 256); ) + n += this[e + --t] * i; + return n; + }), + (s.prototype.readUInt8 = function (e, t) { + return ((e >>>= 0), t || E(e, 1, this.length), this[e]); + }), + (s.prototype.readUInt16LE = function (e, t) { + return ( + (e >>>= 0), + t || E(e, 2, this.length), + this[e] | (this[e + 1] << 8) + ); + }), + (s.prototype.readUInt16BE = function (e, t) { + return ( + (e >>>= 0), + t || E(e, 2, this.length), + (this[e] << 8) | this[e + 1] + ); + }), + (s.prototype.readUInt32LE = function (e, t) { + return ( + (e >>>= 0), + t || E(e, 4, this.length), + (this[e] | (this[e + 1] << 8) | (this[e + 2] << 16)) + + 16777216 * this[e + 3] + ); + }), + (s.prototype.readUInt32BE = function (e, t) { + return ( + (e >>>= 0), + t || E(e, 4, this.length), + 16777216 * this[e] + + ((this[e + 1] << 16) | (this[e + 2] << 8) | this[e + 3]) + ); + }), + (s.prototype.readIntLE = function (e, t, r) { + ((e >>>= 0), (t >>>= 0), r || E(e, t, this.length)); + for (var n = this[e], i = 1, s = 0; ++s < t && (i *= 256); ) + n += this[e + s] * i; + return (n >= (i *= 128) && (n -= Math.pow(2, 8 * t)), n); + }), + (s.prototype.readIntBE = function (e, t, r) { + ((e >>>= 0), (t >>>= 0), r || E(e, t, this.length)); + for ( + var n = t, i = 1, s = this[e + --n]; + n > 0 && (i *= 256); + ) + s += this[e + --n] * i; + return (s >= (i *= 128) && (s -= Math.pow(2, 8 * t)), s); + }), + (s.prototype.readInt8 = function (e, t) { + return ( + (e >>>= 0), + t || E(e, 1, this.length), + 128 & this[e] ? -1 * (255 - this[e] + 1) : this[e] + ); + }), + (s.prototype.readInt16LE = function (e, t) { + ((e >>>= 0), t || E(e, 2, this.length)); + var r = this[e] | (this[e + 1] << 8); + return 32768 & r ? 4294901760 | r : r; + }), + (s.prototype.readInt16BE = function (e, t) { + ((e >>>= 0), t || E(e, 2, this.length)); + var r = this[e + 1] | (this[e] << 8); + return 32768 & r ? 4294901760 | r : r; + }), + (s.prototype.readInt32LE = function (e, t) { + return ( + (e >>>= 0), + t || E(e, 4, this.length), + this[e] | + (this[e + 1] << 8) | + (this[e + 2] << 16) | + (this[e + 3] << 24) + ); + }), + (s.prototype.readInt32BE = function (e, t) { + return ( + (e >>>= 0), + t || E(e, 4, this.length), + (this[e] << 24) | + (this[e + 1] << 16) | + (this[e + 2] << 8) | + this[e + 3] + ); + }), + (s.prototype.readFloatLE = function (e, t) { + return ( + (e >>>= 0), + t || E(e, 4, this.length), + n.read(this, e, !0, 23, 4) + ); + }), + (s.prototype.readFloatBE = function (e, t) { + return ( + (e >>>= 0), + t || E(e, 4, this.length), + n.read(this, e, !1, 23, 4) + ); + }), + (s.prototype.readDoubleLE = function (e, t) { + return ( + (e >>>= 0), + t || E(e, 8, this.length), + n.read(this, e, !0, 52, 8) + ); + }), + (s.prototype.readDoubleBE = function (e, t) { + return ( + (e >>>= 0), + t || E(e, 8, this.length), + n.read(this, e, !1, 52, 8) + ); + }), + (s.prototype.writeUIntLE = function (e, t, r, n) { + ((e = +e), (t >>>= 0), (r >>>= 0), n) || + A(this, e, t, r, Math.pow(2, 8 * r) - 1, 0); + var i = 1, + s = 0; + for (this[t] = 255 & e; ++s < r && (i *= 256); ) + this[t + s] = (e / i) & 255; + return t + r; + }), + (s.prototype.writeUIntBE = function (e, t, r, n) { + ((e = +e), (t >>>= 0), (r >>>= 0), n) || + A(this, e, t, r, Math.pow(2, 8 * r) - 1, 0); + var i = r - 1, + s = 1; + for (this[t + i] = 255 & e; --i >= 0 && (s *= 256); ) + this[t + i] = (e / s) & 255; + return t + r; + }), + (s.prototype.writeUInt8 = function (e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || A(this, e, t, 1, 255, 0), + (this[t] = 255 & e), + t + 1 + ); + }), + (s.prototype.writeUInt16LE = function (e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || A(this, e, t, 2, 65535, 0), + (this[t] = 255 & e), + (this[t + 1] = e >>> 8), + t + 2 + ); + }), + (s.prototype.writeUInt16BE = function (e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || A(this, e, t, 2, 65535, 0), + (this[t] = e >>> 8), + (this[t + 1] = 255 & e), + t + 2 + ); + }), + (s.prototype.writeUInt32LE = function (e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || A(this, e, t, 4, 4294967295, 0), + (this[t + 3] = e >>> 24), + (this[t + 2] = e >>> 16), + (this[t + 1] = e >>> 8), + (this[t] = 255 & e), + t + 4 + ); + }), + (s.prototype.writeUInt32BE = function (e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || A(this, e, t, 4, 4294967295, 0), + (this[t] = e >>> 24), + (this[t + 1] = e >>> 16), + (this[t + 2] = e >>> 8), + (this[t + 3] = 255 & e), + t + 4 + ); + }), + (s.prototype.writeIntLE = function (e, t, r, n) { + if (((e = +e), (t >>>= 0), !n)) { + var i = Math.pow(2, 8 * r - 1); + A(this, e, t, r, i - 1, -i); + } + var s = 0, + o = 1, + a = 0; + for (this[t] = 255 & e; ++s < r && (o *= 256); ) + (e < 0 && 0 === a && 0 !== this[t + s - 1] && (a = 1), + (this[t + s] = (((e / o) >> 0) - a) & 255)); + return t + r; + }), + (s.prototype.writeIntBE = function (e, t, r, n) { + if (((e = +e), (t >>>= 0), !n)) { + var i = Math.pow(2, 8 * r - 1); + A(this, e, t, r, i - 1, -i); + } + var s = r - 1, + o = 1, + a = 0; + for (this[t + s] = 255 & e; --s >= 0 && (o *= 256); ) + (e < 0 && 0 === a && 0 !== this[t + s + 1] && (a = 1), + (this[t + s] = (((e / o) >> 0) - a) & 255)); + return t + r; + }), + (s.prototype.writeInt8 = function (e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || A(this, e, t, 1, 127, -128), + e < 0 && (e = 255 + e + 1), + (this[t] = 255 & e), + t + 1 + ); + }), + (s.prototype.writeInt16LE = function (e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || A(this, e, t, 2, 32767, -32768), + (this[t] = 255 & e), + (this[t + 1] = e >>> 8), + t + 2 + ); + }), + (s.prototype.writeInt16BE = function (e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || A(this, e, t, 2, 32767, -32768), + (this[t] = e >>> 8), + (this[t + 1] = 255 & e), + t + 2 + ); + }), + (s.prototype.writeInt32LE = function (e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || A(this, e, t, 4, 2147483647, -2147483648), + (this[t] = 255 & e), + (this[t + 1] = e >>> 8), + (this[t + 2] = e >>> 16), + (this[t + 3] = e >>> 24), + t + 4 + ); + }), + (s.prototype.writeInt32BE = function (e, t, r) { + return ( + (e = +e), + (t >>>= 0), + r || A(this, e, t, 4, 2147483647, -2147483648), + e < 0 && (e = 4294967295 + e + 1), + (this[t] = e >>> 24), + (this[t + 1] = e >>> 16), + (this[t + 2] = e >>> 8), + (this[t + 3] = 255 & e), + t + 4 + ); + }), + (s.prototype.writeFloatLE = function (e, t, r) { + return O(this, e, t, !0, r); + }), + (s.prototype.writeFloatBE = function (e, t, r) { + return O(this, e, t, !1, r); + }), + (s.prototype.writeDoubleLE = function (e, t, r) { + return j(this, e, t, !0, r); + }), + (s.prototype.writeDoubleBE = function (e, t, r) { + return j(this, e, t, !1, r); + }), + (s.prototype.copy = function (e, t, r, n) { + if (!s.isBuffer(e)) + throw new TypeError("argument should be a Buffer"); + if ( + (r || (r = 0), + n || 0 === n || (n = this.length), + t >= e.length && (t = e.length), + t || (t = 0), + n > 0 && n < r && (n = r), + n === r) + ) + return 0; + if (0 === e.length || 0 === this.length) return 0; + if (t < 0) throw new RangeError("targetStart out of bounds"); + if (r < 0 || r >= this.length) + throw new RangeError("Index out of range"); + if (n < 0) throw new RangeError("sourceEnd out of bounds"); + (n > this.length && (n = this.length), + e.length - t < n - r && (n = e.length - t + r)); + var i = n - r; + if ( + this === e && + "function" == typeof Uint8Array.prototype.copyWithin + ) + this.copyWithin(t, r, n); + else if (this === e && r < t && t < n) + for (var o = i - 1; o >= 0; --o) e[o + t] = this[o + r]; + else Uint8Array.prototype.set.call(e, this.subarray(r, n), t); + return i; + }), + (s.prototype.fill = function (e, t, r, n) { + if ("string" == typeof e) { + if ( + ("string" == typeof t + ? ((n = t), (t = 0), (r = this.length)) + : "string" == typeof r && ((n = r), (r = this.length)), + void 0 !== n && "string" != typeof n) + ) + throw new TypeError("encoding must be a string"); + if ("string" == typeof n && !s.isEncoding(n)) + throw new TypeError("Unknown encoding: " + n); + if (1 === e.length) { + var i = e.charCodeAt(0); + (("utf8" === n && i < 128) || "latin1" === n) && (e = i); + } + } else "number" == typeof e && (e &= 255); + if (t < 0 || this.length < t || this.length < r) + throw new RangeError("Out of range index"); + if (r <= t) return this; + var o; + if ( + ((t >>>= 0), + (r = void 0 === r ? this.length : r >>> 0), + e || (e = 0), + "number" == typeof e) + ) + for (o = t; o < r; ++o) this[o] = e; + else { + var a = s.isBuffer(e) ? e : s.from(e, n), + l = a.length; + if (0 === l) + throw new TypeError( + 'The value "' + e + '" is invalid for argument "value"', + ); + for (o = 0; o < r - t; ++o) this[o + t] = a[o % l]; + } + return this; + })); + var I = /[^+/0-9A-Za-z-_]/g; + function N(e) { + return e < 16 ? "0" + e.toString(16) : e.toString(16); + } + function P(e, t) { + var r; + t = t || 1 / 0; + for (var n = e.length, i = null, s = [], o = 0; o < n; ++o) { + if ((r = e.charCodeAt(o)) > 55295 && r < 57344) { + if (!i) { + if (r > 56319) { + (t -= 3) > -1 && s.push(239, 191, 189); + continue; + } + if (o + 1 === n) { + (t -= 3) > -1 && s.push(239, 191, 189); + continue; + } + i = r; + continue; + } + if (r < 56320) { + ((t -= 3) > -1 && s.push(239, 191, 189), (i = r)); + continue; + } + r = 65536 + (((i - 55296) << 10) | (r - 56320)); + } else i && (t -= 3) > -1 && s.push(239, 191, 189); + if (((i = null), r < 128)) { + if ((t -= 1) < 0) break; + s.push(r); + } else if (r < 2048) { + if ((t -= 2) < 0) break; + s.push((r >> 6) | 192, (63 & r) | 128); + } else if (r < 65536) { + if ((t -= 3) < 0) break; + s.push( + (r >> 12) | 224, + ((r >> 6) & 63) | 128, + (63 & r) | 128, + ); + } else { + if (!(r < 1114112)) throw new Error("Invalid code point"); + if ((t -= 4) < 0) break; + s.push( + (r >> 18) | 240, + ((r >> 12) & 63) | 128, + ((r >> 6) & 63) | 128, + (63 & r) | 128, + ); + } + } + return s; + } + function B(e) { + return t.toByteArray( + (function (e) { + if ( + (e = (e = e.split("=")[0]).trim().replace(I, "")).length < + 2 + ) + return ""; + for (; e.length % 4 != 0; ) e += "="; + return e; + })(e), + ); + } + function D(e, t, r, n) { + for ( + var i = 0; + i < n && !(i + r >= t.length || i >= e.length); + ++i + ) + t[i + r] = e[i]; + return i; + } + function F(e, t) { + return ( + e instanceof t || + (null != e && + null != e.constructor && + null != e.constructor.name && + e.constructor.name === t.name) + ); + } + function L(e) { + return e != e; + } + }).call(this); + }).call(this, e("buffer").Buffer); + }, + { "base64-js": 185, buffer: 220, ieee754: 439 }, + ], + 221: [ + function (e, t, r) { + "use strict"; + var n = e("safe-buffer").Buffer, + i = e("stream").Transform, + s = e("string_decoder").StringDecoder; + function o(e) { + (i.call(this), + (this.hashMode = "string" == typeof e), + this.hashMode + ? (this[e] = this._finalOrDigest) + : (this.final = this._finalOrDigest), + this._final && + ((this.__final = this._final), (this._final = null)), + (this._decoder = null), + (this._encoding = null)); + } + (e("inherits")(o, i), + (o.prototype.update = function (e, t, r) { + "string" == typeof e && (e = n.from(e, t)); + var i = this._update(e); + return this.hashMode + ? this + : (r && (i = this._toString(i, r)), i); + }), + (o.prototype.setAutoPadding = function () {}), + (o.prototype.getAuthTag = function () { + throw new Error("trying to get auth tag in unsupported state"); + }), + (o.prototype.setAuthTag = function () { + throw new Error("trying to set auth tag in unsupported state"); + }), + (o.prototype.setAAD = function () { + throw new Error("trying to set aad in unsupported state"); + }), + (o.prototype._transform = function (e, t, r) { + var n; + try { + this.hashMode ? this._update(e) : this.push(this._update(e)); + } catch (e) { + n = e; + } finally { + r(n); + } + }), + (o.prototype._flush = function (e) { + var t; + try { + this.push(this.__final()); + } catch (e) { + t = e; + } + e(t); + }), + (o.prototype._finalOrDigest = function (e) { + var t = this.__final() || n.alloc(0); + return (e && (t = this._toString(t, e, !0)), t); + }), + (o.prototype._toString = function (e, t, r) { + if ( + (this._decoder || + ((this._decoder = new s(t)), (this._encoding = t)), + this._encoding !== t) + ) + throw new Error("can't switch encodings"); + var n = this._decoder.write(e); + return (r && (n += this._decoder.end()), n); + }), + (t.exports = o)); + }, + { inherits: 440, "safe-buffer": 494, stream: 505, string_decoder: 218 }, + ], + 222: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/is-callable"), + i = e("../internals/try-to-string"), + s = TypeError; + t.exports = function (e) { + if (n(e)) return e; + throw new s(i(e) + " is not a function"); + }; + }, + { "../internals/is-callable": 285, "../internals/try-to-string": 349 }, + ], + 223: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/is-constructor"), + i = e("../internals/try-to-string"), + s = TypeError; + t.exports = function (e) { + if (n(e)) return e; + throw new s(i(e) + " is not a constructor"); + }; + }, + { + "../internals/is-constructor": 286, + "../internals/try-to-string": 349, + }, + ], + 224: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/is-callable"), + i = String, + s = TypeError; + t.exports = function (e) { + if ("object" == typeof e || n(e)) return e; + throw new s("Can't set " + i(e) + " as a prototype"); + }; + }, + { "../internals/is-callable": 285 }, + ], + 225: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/well-known-symbol"), + i = e("../internals/object-create"), + s = e("../internals/object-define-property").f, + o = n("unscopables"), + a = Array.prototype; + (void 0 === a[o] && s(a, o, { configurable: !0, value: i(null) }), + (t.exports = function (e) { + a[o][e] = !0; + })); + }, + { + "../internals/object-create": 306, + "../internals/object-define-property": 308, + "../internals/well-known-symbol": 357, + }, + ], + 226: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/object-is-prototype-of"), + i = TypeError; + t.exports = function (e, t) { + if (n(t, e)) return e; + throw new i("Incorrect invocation"); + }; + }, + { "../internals/object-is-prototype-of": 314 }, + ], + 227: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/is-object"), + i = String, + s = TypeError; + t.exports = function (e) { + if (n(e)) return e; + throw new s(i(e) + " is not an object"); + }; + }, + { "../internals/is-object": 289 }, + ], + 228: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/to-indexed-object"), + i = e("../internals/to-absolute-index"), + s = e("../internals/length-of-array-like"), + o = function (e) { + return function (t, r, o) { + var a, + l = n(t), + c = s(l), + u = i(o, c); + if (e && r != r) { + for (; c > u; ) if ((a = l[u++]) != a) return !0; + } else + for (; c > u; u++) + if ((e || u in l) && l[u] === r) return e || u || 0; + return !e && -1; + }; + }; + t.exports = { includes: o(!0), indexOf: o(!1) }; + }, + { + "../internals/length-of-array-like": 299, + "../internals/to-absolute-index": 340, + "../internals/to-indexed-object": 341, + }, + ], + 229: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-bind-context"), + i = e("../internals/function-uncurry-this"), + s = e("../internals/indexed-object"), + o = e("../internals/to-object"), + a = e("../internals/length-of-array-like"), + l = e("../internals/array-species-create"), + c = i([].push), + u = function (e) { + var t = 1 === e, + r = 2 === e, + i = 3 === e, + u = 4 === e, + h = 6 === e, + f = 7 === e, + d = 5 === e || h; + return function (p, m, b, g) { + for ( + var y, + v, + w = o(p), + _ = s(w), + x = n(m, b), + k = a(_), + S = 0, + M = g || l, + C = t ? M(p, k) : r || f ? M(p, 0) : void 0; + k > S; + S++ + ) + if ((d || S in _) && ((v = x((y = _[S]), S, w)), e)) + if (t) C[S] = v; + else if (v) + switch (e) { + case 3: + return !0; + case 5: + return y; + case 6: + return S; + case 2: + c(C, y); + } + else + switch (e) { + case 4: + return !1; + case 7: + c(C, y); + } + return h ? -1 : i || u ? u : C; + }; + }; + t.exports = { + forEach: u(0), + map: u(1), + filter: u(2), + some: u(3), + every: u(4), + find: u(5), + findIndex: u(6), + filterReject: u(7), + }; + }, + { + "../internals/array-species-create": 233, + "../internals/function-bind-context": 262, + "../internals/function-uncurry-this": 268, + "../internals/indexed-object": 280, + "../internals/length-of-array-like": 299, + "../internals/to-object": 344, + }, + ], + 230: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/to-absolute-index"), + i = e("../internals/length-of-array-like"), + s = e("../internals/create-property"), + o = Array, + a = Math.max; + t.exports = function (e, t, r) { + for ( + var l = i(e), + c = n(t, l), + u = n(void 0 === r ? l : r, l), + h = o(a(u - c, 0)), + f = 0; + c < u; + c++, f++ + ) + s(h, f, e[c]); + return ((h.length = f), h); + }; + }, + { + "../internals/create-property": 243, + "../internals/length-of-array-like": 299, + "../internals/to-absolute-index": 340, + }, + ], + 231: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-uncurry-this"); + t.exports = n([].slice); + }, + { "../internals/function-uncurry-this": 268 }, + ], + 232: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/is-array"), + i = e("../internals/is-constructor"), + s = e("../internals/is-object"), + o = e("../internals/well-known-symbol")("species"), + a = Array; + t.exports = function (e) { + var t; + return ( + n(e) && + ((t = e.constructor), + ((i(t) && (t === a || n(t.prototype))) || + (s(t) && null === (t = t[o]))) && + (t = void 0)), + void 0 === t ? a : t + ); + }; + }, + { + "../internals/is-array": 284, + "../internals/is-constructor": 286, + "../internals/is-object": 289, + "../internals/well-known-symbol": 357, + }, + ], + 233: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/array-species-constructor"); + t.exports = function (e, t) { + return new (n(e))(0 === t ? 0 : t); + }; + }, + { "../internals/array-species-constructor": 232 }, + ], + 234: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/well-known-symbol")("iterator"), + i = !1; + try { + var s = 0, + o = { + next: function () { + return { done: !!s++ }; + }, + return: function () { + i = !0; + }, + }; + ((o[n] = function () { + return this; + }), + Array.from(o, function () { + throw 2; + })); + } catch (e) {} + t.exports = function (e, t) { + try { + if (!t && !i) return !1; + } catch (e) { + return !1; + } + var r = !1; + try { + var s = {}; + ((s[n] = function () { + return { + next: function () { + return { done: (r = !0) }; + }, + }; + }), + e(s)); + } catch (e) {} + return r; + }; + }, + { "../internals/well-known-symbol": 357 }, + ], + 235: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-uncurry-this"), + i = n({}.toString), + s = n("".slice); + t.exports = function (e) { + return s(i(e), 8, -1); + }; + }, + { "../internals/function-uncurry-this": 268 }, + ], + 236: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/to-string-tag-support"), + i = e("../internals/is-callable"), + s = e("../internals/classof-raw"), + o = e("../internals/well-known-symbol")("toStringTag"), + a = Object, + l = + "Arguments" === + s( + (function () { + return arguments; + })(), + ); + t.exports = n + ? s + : function (e) { + var t, r, n; + return void 0 === e + ? "Undefined" + : null === e + ? "Null" + : "string" == + typeof (r = (function (e, t) { + try { + return e[t]; + } catch (e) {} + })((t = a(e)), o)) + ? r + : l + ? s(t) + : "Object" === (n = s(t)) && i(t.callee) + ? "Arguments" + : n; + }; + }, + { + "../internals/classof-raw": 235, + "../internals/is-callable": 285, + "../internals/to-string-tag-support": 347, + "../internals/well-known-symbol": 357, + }, + ], + 237: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/has-own-property"), + i = e("../internals/own-keys"), + s = e("../internals/object-get-own-property-descriptor"), + o = e("../internals/object-define-property"); + t.exports = function (e, t, r) { + for (var a = i(t), l = o.f, c = s.f, u = 0; u < a.length; u++) { + var h = a[u]; + n(e, h) || (r && n(r, h)) || l(e, h, c(t, h)); + } + }; + }, + { + "../internals/has-own-property": 275, + "../internals/object-define-property": 308, + "../internals/object-get-own-property-descriptor": 309, + "../internals/own-keys": 321, + }, + ], + 238: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/well-known-symbol")("match"); + t.exports = function (e) { + var t = /./; + try { + "/./"[e](t); + } catch (r) { + try { + return ((t[n] = !1), "/./"[e](t)); + } catch (e) {} + } + return !1; + }; + }, + { "../internals/well-known-symbol": 357 }, + ], + 239: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/fails"); + t.exports = !n(function () { + function e() {} + return ( + (e.prototype.constructor = null), + Object.getPrototypeOf(new e()) !== e.prototype + ); + }); + }, + { "../internals/fails": 260 }, + ], + 240: [ + function (e, t, r) { + "use strict"; + t.exports = function (e, t) { + return { value: e, done: t }; + }; + }, + {}, + ], + 241: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/descriptors"), + i = e("../internals/object-define-property"), + s = e("../internals/create-property-descriptor"); + t.exports = n + ? function (e, t, r) { + return i.f(e, t, s(1, r)); + } + : function (e, t, r) { + return ((e[t] = r), e); + }; + }, + { + "../internals/create-property-descriptor": 242, + "../internals/descriptors": 247, + "../internals/object-define-property": 308, + }, + ], + 242: [ + function (e, t, r) { + "use strict"; + t.exports = function (e, t) { + return { + enumerable: !(1 & e), + configurable: !(2 & e), + writable: !(4 & e), + value: t, + }; + }; + }, + {}, + ], + 243: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/to-property-key"), + i = e("../internals/object-define-property"), + s = e("../internals/create-property-descriptor"); + t.exports = function (e, t, r) { + var o = n(t); + o in e ? i.f(e, o, s(0, r)) : (e[o] = r); + }; + }, + { + "../internals/create-property-descriptor": 242, + "../internals/object-define-property": 308, + "../internals/to-property-key": 346, + }, + ], + 244: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/make-built-in"), + i = e("../internals/object-define-property"); + t.exports = function (e, t, r) { + return ( + r.get && n(r.get, t, { getter: !0 }), + r.set && n(r.set, t, { setter: !0 }), + i.f(e, t, r) + ); + }; + }, + { + "../internals/make-built-in": 300, + "../internals/object-define-property": 308, + }, + ], + 245: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/is-callable"), + i = e("../internals/object-define-property"), + s = e("../internals/make-built-in"), + o = e("../internals/define-global-property"); + t.exports = function (e, t, r, a) { + a || (a = {}); + var l = a.enumerable, + c = void 0 !== a.name ? a.name : t; + if ((n(r) && s(r, c, a), a.global)) l ? (e[t] = r) : o(t, r); + else { + try { + a.unsafe ? e[t] && (l = !0) : delete e[t]; + } catch (e) {} + l + ? (e[t] = r) + : i.f(e, t, { + value: r, + enumerable: !1, + configurable: !a.nonConfigurable, + writable: !a.nonWritable, + }); + } + return e; + }; + }, + { + "../internals/define-global-property": 246, + "../internals/is-callable": 285, + "../internals/make-built-in": 300, + "../internals/object-define-property": 308, + }, + ], + 246: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/global"), + i = Object.defineProperty; + t.exports = function (e, t) { + try { + i(n, e, { value: t, configurable: !0, writable: !0 }); + } catch (r) { + n[e] = t; + } + return t; + }; + }, + { "../internals/global": 274 }, + ], + 247: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/fails"); + t.exports = !n(function () { + return ( + 7 !== + Object.defineProperty({}, 1, { + get: function () { + return 7; + }, + })[1] + ); + }); + }, + { "../internals/fails": 260 }, + ], + 248: [ + function (e, t, r) { + "use strict"; + var n = "object" == typeof document && document.all, + i = void 0 === n && void 0 !== n; + t.exports = { all: n, IS_HTMLDDA: i }; + }, + {}, + ], + 249: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/global"), + i = e("../internals/is-object"), + s = n.document, + o = i(s) && i(s.createElement); + t.exports = function (e) { + return o ? s.createElement(e) : {}; + }; + }, + { "../internals/global": 274, "../internals/is-object": 289 }, + ], + 250: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/engine-is-deno"), + i = e("../internals/engine-is-node"); + t.exports = + !n && + !i && + "object" == typeof window && + "object" == typeof document; + }, + { + "../internals/engine-is-deno": 251, + "../internals/engine-is-node": 254, + }, + ], + 251: [ + function (e, t, r) { + "use strict"; + t.exports = + "object" == typeof Deno && Deno && "object" == typeof Deno.version; + }, + {}, + ], + 252: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/engine-user-agent"); + t.exports = + /ipad|iphone|ipod/i.test(n) && "undefined" != typeof Pebble; + }, + { "../internals/engine-user-agent": 256 }, + ], + 253: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/engine-user-agent"); + t.exports = /(?:ipad|iphone|ipod).*applewebkit/i.test(n); + }, + { "../internals/engine-user-agent": 256 }, + ], + 254: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/global"), + i = e("../internals/classof-raw"); + t.exports = "process" === i(n.process); + }, + { "../internals/classof-raw": 235, "../internals/global": 274 }, + ], + 255: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/engine-user-agent"); + t.exports = /web0s(?!.*chrome)/i.test(n); + }, + { "../internals/engine-user-agent": 256 }, + ], + 256: [ + function (e, t, r) { + "use strict"; + t.exports = + ("undefined" != typeof navigator && String(navigator.userAgent)) || + ""; + }, + {}, + ], + 257: [ + function (e, t, r) { + "use strict"; + var n, + i, + s = e("../internals/global"), + o = e("../internals/engine-user-agent"), + a = s.process, + l = s.Deno, + c = (a && a.versions) || (l && l.version), + u = c && c.v8; + (u && + (i = (n = u.split("."))[0] > 0 && n[0] < 4 ? 1 : +(n[0] + n[1])), + !i && + o && + (!(n = o.match(/Edge\/(\d+)/)) || n[1] >= 74) && + (n = o.match(/Chrome\/(\d+)/)) && + (i = +n[1]), + (t.exports = i)); + }, + { "../internals/engine-user-agent": 256, "../internals/global": 274 }, + ], + 258: [ + function (e, t, r) { + "use strict"; + t.exports = [ + "constructor", + "hasOwnProperty", + "isPrototypeOf", + "propertyIsEnumerable", + "toLocaleString", + "toString", + "valueOf", + ]; + }, + {}, + ], + 259: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/global"), + i = e("../internals/object-get-own-property-descriptor").f, + s = e("../internals/create-non-enumerable-property"), + o = e("../internals/define-built-in"), + a = e("../internals/define-global-property"), + l = e("../internals/copy-constructor-properties"), + c = e("../internals/is-forced"); + t.exports = function (e, t) { + var r, + u, + h, + f, + d, + p = e.target, + m = e.global, + b = e.stat; + if ((r = m ? n : b ? n[p] || a(p, {}) : (n[p] || {}).prototype)) + for (u in t) { + if ( + ((f = t[u]), + (h = e.dontCallGetSet ? (d = i(r, u)) && d.value : r[u]), + !c(m ? u : p + (b ? "." : "#") + u, e.forced) && void 0 !== h) + ) { + if (typeof f == typeof h) continue; + l(f, h); + } + ((e.sham || (h && h.sham)) && s(f, "sham", !0), o(r, u, f, e)); + } + }; + }, + { + "../internals/copy-constructor-properties": 237, + "../internals/create-non-enumerable-property": 241, + "../internals/define-built-in": 245, + "../internals/define-global-property": 246, + "../internals/global": 274, + "../internals/is-forced": 287, + "../internals/object-get-own-property-descriptor": 309, + }, + ], + 260: [ + function (e, t, r) { + "use strict"; + t.exports = function (e) { + try { + return !!e(); + } catch (e) { + return !0; + } + }; + }, + {}, + ], + 261: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-bind-native"), + i = Function.prototype, + s = i.apply, + o = i.call; + t.exports = + ("object" == typeof Reflect && Reflect.apply) || + (n + ? o.bind(s) + : function () { + return o.apply(s, arguments); + }); + }, + { "../internals/function-bind-native": 263 }, + ], + 262: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-uncurry-this-clause"), + i = e("../internals/a-callable"), + s = e("../internals/function-bind-native"), + o = n(n.bind); + t.exports = function (e, t) { + return ( + i(e), + void 0 === t + ? e + : s + ? o(e, t) + : function () { + return e.apply(t, arguments); + } + ); + }; + }, + { + "../internals/a-callable": 222, + "../internals/function-bind-native": 263, + "../internals/function-uncurry-this-clause": 267, + }, + ], + 263: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/fails"); + t.exports = !n(function () { + var e = function () {}.bind(); + return "function" != typeof e || e.hasOwnProperty("prototype"); + }); + }, + { "../internals/fails": 260 }, + ], + 264: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-bind-native"), + i = Function.prototype.call; + t.exports = n + ? i.bind(i) + : function () { + return i.apply(i, arguments); + }; + }, + { "../internals/function-bind-native": 263 }, + ], + 265: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/descriptors"), + i = e("../internals/has-own-property"), + s = Function.prototype, + o = n && Object.getOwnPropertyDescriptor, + a = i(s, "name"), + l = a && "something" === function () {}.name, + c = a && (!n || (n && o(s, "name").configurable)); + t.exports = { EXISTS: a, PROPER: l, CONFIGURABLE: c }; + }, + { + "../internals/descriptors": 247, + "../internals/has-own-property": 275, + }, + ], + 266: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-uncurry-this"), + i = e("../internals/a-callable"); + t.exports = function (e, t, r) { + try { + return n(i(Object.getOwnPropertyDescriptor(e, t)[r])); + } catch (e) {} + }; + }, + { + "../internals/a-callable": 222, + "../internals/function-uncurry-this": 268, + }, + ], + 267: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/classof-raw"), + i = e("../internals/function-uncurry-this"); + t.exports = function (e) { + if ("Function" === n(e)) return i(e); + }; + }, + { + "../internals/classof-raw": 235, + "../internals/function-uncurry-this": 268, + }, + ], + 268: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-bind-native"), + i = Function.prototype, + s = i.call, + o = n && i.bind.bind(s, s); + t.exports = n + ? o + : function (e) { + return function () { + return s.apply(e, arguments); + }; + }; + }, + { "../internals/function-bind-native": 263 }, + ], + 269: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/global"), + i = e("../internals/is-callable"), + s = function (e) { + return i(e) ? e : void 0; + }; + t.exports = function (e, t) { + return arguments.length < 2 ? s(n[e]) : n[e] && n[e][t]; + }; + }, + { "../internals/global": 274, "../internals/is-callable": 285 }, + ], + 270: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/classof"), + i = e("../internals/get-method"), + s = e("../internals/is-null-or-undefined"), + o = e("../internals/iterators"), + a = e("../internals/well-known-symbol")("iterator"); + t.exports = function (e) { + if (!s(e)) return i(e, a) || i(e, "@@iterator") || o[n(e)]; + }; + }, + { + "../internals/classof": 236, + "../internals/get-method": 273, + "../internals/is-null-or-undefined": 288, + "../internals/iterators": 298, + "../internals/well-known-symbol": 357, + }, + ], + 271: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-call"), + i = e("../internals/a-callable"), + s = e("../internals/an-object"), + o = e("../internals/try-to-string"), + a = e("../internals/get-iterator-method"), + l = TypeError; + t.exports = function (e, t) { + var r = arguments.length < 2 ? a(e) : t; + if (i(r)) return s(n(r, e)); + throw new l(o(e) + " is not iterable"); + }; + }, + { + "../internals/a-callable": 222, + "../internals/an-object": 227, + "../internals/function-call": 264, + "../internals/get-iterator-method": 270, + "../internals/try-to-string": 349, + }, + ], + 272: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-uncurry-this"), + i = e("../internals/is-array"), + s = e("../internals/is-callable"), + o = e("../internals/classof-raw"), + a = e("../internals/to-string"), + l = n([].push); + t.exports = function (e) { + if (s(e)) return e; + if (i(e)) { + for (var t = e.length, r = [], n = 0; n < t; n++) { + var c = e[n]; + "string" == typeof c + ? l(r, c) + : ("number" != typeof c && + "Number" !== o(c) && + "String" !== o(c)) || + l(r, a(c)); + } + var u = r.length, + h = !0; + return function (e, t) { + if (h) return ((h = !1), t); + if (i(this)) return t; + for (var n = 0; n < u; n++) if (r[n] === e) return t; + }; + } + }; + }, + { + "../internals/classof-raw": 235, + "../internals/function-uncurry-this": 268, + "../internals/is-array": 284, + "../internals/is-callable": 285, + "../internals/to-string": 348, + }, + ], + 273: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/a-callable"), + i = e("../internals/is-null-or-undefined"); + t.exports = function (e, t) { + var r = e[t]; + return i(r) ? void 0 : n(r); + }; + }, + { + "../internals/a-callable": 222, + "../internals/is-null-or-undefined": 288, + }, + ], + 274: [ + function (e, t, r) { + (function (e) { + (function () { + "use strict"; + var r = function (e) { + return e && e.Math === Math && e; + }; + t.exports = + r("object" == typeof globalThis && globalThis) || + r("object" == typeof window && window) || + r("object" == typeof self && self) || + r("object" == typeof e && e) || + (function () { + return this; + })() || + this || + Function("return this")(); + }).call(this); + }).call( + this, + "undefined" != typeof global + ? global + : "undefined" != typeof self + ? self + : "undefined" != typeof window + ? window + : {}, + ); + }, + {}, + ], + 275: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-uncurry-this"), + i = e("../internals/to-object"), + s = n({}.hasOwnProperty); + t.exports = + Object.hasOwn || + function (e, t) { + return s(i(e), t); + }; + }, + { + "../internals/function-uncurry-this": 268, + "../internals/to-object": 344, + }, + ], + 276: [ + function (e, t, r) { + "use strict"; + t.exports = {}; + }, + {}, + ], + 277: [ + function (e, t, r) { + "use strict"; + t.exports = function (e, t) { + try { + 1 === arguments.length ? console.error(e) : console.error(e, t); + } catch (e) {} + }; + }, + {}, + ], + 278: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/get-built-in"); + t.exports = n("document", "documentElement"); + }, + { "../internals/get-built-in": 269 }, + ], + 279: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/descriptors"), + i = e("../internals/fails"), + s = e("../internals/document-create-element"); + t.exports = + !n && + !i(function () { + return ( + 7 !== + Object.defineProperty(s("div"), "a", { + get: function () { + return 7; + }, + }).a + ); + }); + }, + { + "../internals/descriptors": 247, + "../internals/document-create-element": 249, + "../internals/fails": 260, + }, + ], + 280: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-uncurry-this"), + i = e("../internals/fails"), + s = e("../internals/classof-raw"), + o = Object, + a = n("".split); + t.exports = i(function () { + return !o("z").propertyIsEnumerable(0); + }) + ? function (e) { + return "String" === s(e) ? a(e, "") : o(e); + } + : o; + }, + { + "../internals/classof-raw": 235, + "../internals/fails": 260, + "../internals/function-uncurry-this": 268, + }, + ], + 281: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-uncurry-this"), + i = e("../internals/is-callable"), + s = e("../internals/shared-store"), + o = n(Function.toString); + (i(s.inspectSource) || + (s.inspectSource = function (e) { + return o(e); + }), + (t.exports = s.inspectSource)); + }, + { + "../internals/function-uncurry-this": 268, + "../internals/is-callable": 285, + "../internals/shared-store": 333, + }, + ], + 282: [ + function (e, t, r) { + "use strict"; + var n, + i, + s, + o = e("../internals/weak-map-basic-detection"), + a = e("../internals/global"), + l = e("../internals/is-object"), + c = e("../internals/create-non-enumerable-property"), + u = e("../internals/has-own-property"), + h = e("../internals/shared-store"), + f = e("../internals/shared-key"), + d = e("../internals/hidden-keys"), + p = a.TypeError, + m = a.WeakMap; + if (o || h.state) { + var b = h.state || (h.state = new m()); + ((b.get = b.get), + (b.has = b.has), + (b.set = b.set), + (n = function (e, t) { + if (b.has(e)) throw new p("Object already initialized"); + return ((t.facade = e), b.set(e, t), t); + }), + (i = function (e) { + return b.get(e) || {}; + }), + (s = function (e) { + return b.has(e); + })); + } else { + var g = f("state"); + ((d[g] = !0), + (n = function (e, t) { + if (u(e, g)) throw new p("Object already initialized"); + return ((t.facade = e), c(e, g, t), t); + }), + (i = function (e) { + return u(e, g) ? e[g] : {}; + }), + (s = function (e) { + return u(e, g); + })); + } + t.exports = { + set: n, + get: i, + has: s, + enforce: function (e) { + return s(e) ? i(e) : n(e, {}); + }, + getterFor: function (e) { + return function (t) { + var r; + if (!l(t) || (r = i(t)).type !== e) + throw new p("Incompatible receiver, " + e + " required"); + return r; + }; + }, + }; + }, + { + "../internals/create-non-enumerable-property": 241, + "../internals/global": 274, + "../internals/has-own-property": 275, + "../internals/hidden-keys": 276, + "../internals/is-object": 289, + "../internals/shared-key": 332, + "../internals/shared-store": 333, + "../internals/weak-map-basic-detection": 354, + }, + ], + 283: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/well-known-symbol"), + i = e("../internals/iterators"), + s = n("iterator"), + o = Array.prototype; + t.exports = function (e) { + return void 0 !== e && (i.Array === e || o[s] === e); + }; + }, + { + "../internals/iterators": 298, + "../internals/well-known-symbol": 357, + }, + ], + 284: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/classof-raw"); + t.exports = + Array.isArray || + function (e) { + return "Array" === n(e); + }; + }, + { "../internals/classof-raw": 235 }, + ], + 285: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/document-all"), + i = n.all; + t.exports = n.IS_HTMLDDA + ? function (e) { + return "function" == typeof e || e === i; + } + : function (e) { + return "function" == typeof e; + }; + }, + { "../internals/document-all": 248 }, + ], + 286: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-uncurry-this"), + i = e("../internals/fails"), + s = e("../internals/is-callable"), + o = e("../internals/classof"), + a = e("../internals/get-built-in"), + l = e("../internals/inspect-source"), + c = function () {}, + u = [], + h = a("Reflect", "construct"), + f = /^\s*(?:class|function)\b/, + d = n(f.exec), + p = !f.test(c), + m = function (e) { + if (!s(e)) return !1; + try { + return (h(c, u, e), !0); + } catch (e) { + return !1; + } + }, + b = function (e) { + if (!s(e)) return !1; + switch (o(e)) { + case "AsyncFunction": + case "GeneratorFunction": + case "AsyncGeneratorFunction": + return !1; + } + try { + return p || !!d(f, l(e)); + } catch (e) { + return !0; + } + }; + ((b.sham = !0), + (t.exports = + !h || + i(function () { + var e; + return ( + m(m.call) || + !m(Object) || + !m(function () { + e = !0; + }) || + e + ); + }) + ? b + : m)); + }, + { + "../internals/classof": 236, + "../internals/fails": 260, + "../internals/function-uncurry-this": 268, + "../internals/get-built-in": 269, + "../internals/inspect-source": 281, + "../internals/is-callable": 285, + }, + ], + 287: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/fails"), + i = e("../internals/is-callable"), + s = /#|\.prototype\./, + o = function (e, t) { + var r = l[a(e)]; + return r === u || (r !== c && (i(t) ? n(t) : !!t)); + }, + a = (o.normalize = function (e) { + return String(e).replace(s, ".").toLowerCase(); + }), + l = (o.data = {}), + c = (o.NATIVE = "N"), + u = (o.POLYFILL = "P"); + t.exports = o; + }, + { "../internals/fails": 260, "../internals/is-callable": 285 }, + ], + 288: [ + function (e, t, r) { + "use strict"; + t.exports = function (e) { + return null == e; + }; + }, + {}, + ], + 289: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/is-callable"), + i = e("../internals/document-all"), + s = i.all; + t.exports = i.IS_HTMLDDA + ? function (e) { + return "object" == typeof e ? null !== e : n(e) || e === s; + } + : function (e) { + return "object" == typeof e ? null !== e : n(e); + }; + }, + { "../internals/document-all": 248, "../internals/is-callable": 285 }, + ], + 290: [ + function (e, t, r) { + "use strict"; + t.exports = !1; + }, + {}, + ], + 291: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/is-object"), + i = e("../internals/classof-raw"), + s = e("../internals/well-known-symbol")("match"); + t.exports = function (e) { + var t; + return n(e) && (void 0 !== (t = e[s]) ? !!t : "RegExp" === i(e)); + }; + }, + { + "../internals/classof-raw": 235, + "../internals/is-object": 289, + "../internals/well-known-symbol": 357, + }, + ], + 292: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/get-built-in"), + i = e("../internals/is-callable"), + s = e("../internals/object-is-prototype-of"), + o = e("../internals/use-symbol-as-uid"), + a = Object; + t.exports = o + ? function (e) { + return "symbol" == typeof e; + } + : function (e) { + var t = n("Symbol"); + return i(t) && s(t.prototype, a(e)); + }; + }, + { + "../internals/get-built-in": 269, + "../internals/is-callable": 285, + "../internals/object-is-prototype-of": 314, + "../internals/use-symbol-as-uid": 351, + }, + ], + 293: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-bind-context"), + i = e("../internals/function-call"), + s = e("../internals/an-object"), + o = e("../internals/try-to-string"), + a = e("../internals/is-array-iterator-method"), + l = e("../internals/length-of-array-like"), + c = e("../internals/object-is-prototype-of"), + u = e("../internals/get-iterator"), + h = e("../internals/get-iterator-method"), + f = e("../internals/iterator-close"), + d = TypeError, + p = function (e, t) { + ((this.stopped = e), (this.result = t)); + }, + m = p.prototype; + t.exports = function (e, t, r) { + var b, + g, + y, + v, + w, + _, + x, + k = r && r.that, + S = !(!r || !r.AS_ENTRIES), + M = !(!r || !r.IS_RECORD), + C = !(!r || !r.IS_ITERATOR), + T = !(!r || !r.INTERRUPTED), + E = n(t, k), + A = function (e) { + return (b && f(b, "normal", e), new p(!0, e)); + }, + R = function (e) { + return S + ? (s(e), T ? E(e[0], e[1], A) : E(e[0], e[1])) + : T + ? E(e, A) + : E(e); + }; + if (M) b = e.iterator; + else if (C) b = e; + else { + if (!(g = h(e))) throw new d(o(e) + " is not iterable"); + if (a(g)) { + for (y = 0, v = l(e); v > y; y++) + if ((w = R(e[y])) && c(m, w)) return w; + return new p(!1); + } + b = u(e, g); + } + for (_ = M ? e.next : b.next; !(x = i(_, b)).done; ) { + try { + w = R(x.value); + } catch (e) { + f(b, "throw", e); + } + if ("object" == typeof w && w && c(m, w)) return w; + } + return new p(!1); + }; + }, + { + "../internals/an-object": 227, + "../internals/function-bind-context": 262, + "../internals/function-call": 264, + "../internals/get-iterator": 271, + "../internals/get-iterator-method": 270, + "../internals/is-array-iterator-method": 283, + "../internals/iterator-close": 294, + "../internals/length-of-array-like": 299, + "../internals/object-is-prototype-of": 314, + "../internals/try-to-string": 349, + }, + ], + 294: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-call"), + i = e("../internals/an-object"), + s = e("../internals/get-method"); + t.exports = function (e, t, r) { + var o, a; + i(e); + try { + if (!(o = s(e, "return"))) { + if ("throw" === t) throw r; + return r; + } + o = n(o, e); + } catch (e) { + ((a = !0), (o = e)); + } + if ("throw" === t) throw r; + if (a) throw o; + return (i(o), r); + }; + }, + { + "../internals/an-object": 227, + "../internals/function-call": 264, + "../internals/get-method": 273, + }, + ], + 295: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/iterators-core").IteratorPrototype, + i = e("../internals/object-create"), + s = e("../internals/create-property-descriptor"), + o = e("../internals/set-to-string-tag"), + a = e("../internals/iterators"), + l = function () { + return this; + }; + t.exports = function (e, t, r, c) { + var u = t + " Iterator"; + return ( + (e.prototype = i(n, { next: s(+!c, r) })), + o(e, u, !1, !0), + (a[u] = l), + e + ); + }; + }, + { + "../internals/create-property-descriptor": 242, + "../internals/iterators": 298, + "../internals/iterators-core": 297, + "../internals/object-create": 306, + "../internals/set-to-string-tag": 331, + }, + ], + 296: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/export"), + i = e("../internals/function-call"), + s = e("../internals/is-pure"), + o = e("../internals/function-name"), + a = e("../internals/is-callable"), + l = e("../internals/iterator-create-constructor"), + c = e("../internals/object-get-prototype-of"), + u = e("../internals/object-set-prototype-of"), + h = e("../internals/set-to-string-tag"), + f = e("../internals/create-non-enumerable-property"), + d = e("../internals/define-built-in"), + p = e("../internals/well-known-symbol"), + m = e("../internals/iterators"), + b = e("../internals/iterators-core"), + g = o.PROPER, + y = o.CONFIGURABLE, + v = b.IteratorPrototype, + w = b.BUGGY_SAFARI_ITERATORS, + _ = p("iterator"), + x = function () { + return this; + }; + t.exports = function (e, t, r, o, p, b, k) { + l(r, t, o); + var S, + M, + C, + T = function (e) { + if (e === p && j) return j; + if (!w && e && e in R) return R[e]; + switch (e) { + case "keys": + case "values": + case "entries": + return function () { + return new r(this, e); + }; + } + return function () { + return new r(this); + }; + }, + E = t + " Iterator", + A = !1, + R = e.prototype, + O = R[_] || R["@@iterator"] || (p && R[p]), + j = (!w && O) || T(p), + I = ("Array" === t && R.entries) || O; + if ( + (I && + (S = c(I.call(new e()))) !== Object.prototype && + S.next && + (s || c(S) === v || (u ? u(S, v) : a(S[_]) || d(S, _, x)), + h(S, E, !0, !0), + s && (m[E] = x)), + g && + "values" === p && + O && + "values" !== O.name && + (!s && y + ? f(R, "name", "values") + : ((A = !0), + (j = function () { + return i(O, this); + }))), + p) + ) + if ( + ((M = { + values: T("values"), + keys: b ? j : T("keys"), + entries: T("entries"), + }), + k) + ) + for (C in M) (w || A || !(C in R)) && d(R, C, M[C]); + else n({ target: t, proto: !0, forced: w || A }, M); + return ( + (s && !k) || R[_] === j || d(R, _, j, { name: p }), + (m[t] = j), + M + ); + }; + }, + { + "../internals/create-non-enumerable-property": 241, + "../internals/define-built-in": 245, + "../internals/export": 259, + "../internals/function-call": 264, + "../internals/function-name": 265, + "../internals/is-callable": 285, + "../internals/is-pure": 290, + "../internals/iterator-create-constructor": 295, + "../internals/iterators": 298, + "../internals/iterators-core": 297, + "../internals/object-get-prototype-of": 313, + "../internals/object-set-prototype-of": 318, + "../internals/set-to-string-tag": 331, + "../internals/well-known-symbol": 357, + }, + ], + 297: [ + function (e, t, r) { + "use strict"; + var n, + i, + s, + o = e("../internals/fails"), + a = e("../internals/is-callable"), + l = e("../internals/is-object"), + c = e("../internals/object-create"), + u = e("../internals/object-get-prototype-of"), + h = e("../internals/define-built-in"), + f = e("../internals/well-known-symbol"), + d = e("../internals/is-pure"), + p = f("iterator"), + m = !1; + ([].keys && + ("next" in (s = [].keys()) + ? (i = u(u(s))) !== Object.prototype && (n = i) + : (m = !0)), + !l(n) || + o(function () { + var e = {}; + return n[p].call(e) !== e; + }) + ? (n = {}) + : d && (n = c(n)), + a(n[p]) || + h(n, p, function () { + return this; + }), + (t.exports = { IteratorPrototype: n, BUGGY_SAFARI_ITERATORS: m })); + }, + { + "../internals/define-built-in": 245, + "../internals/fails": 260, + "../internals/is-callable": 285, + "../internals/is-object": 289, + "../internals/is-pure": 290, + "../internals/object-create": 306, + "../internals/object-get-prototype-of": 313, + "../internals/well-known-symbol": 357, + }, + ], + 298: [ + function (e, t, r) { + arguments[4][276][0].apply(r, arguments); + }, + { dup: 276 }, + ], + 299: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/to-length"); + t.exports = function (e) { + return n(e.length); + }; + }, + { "../internals/to-length": 343 }, + ], + 300: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/function-uncurry-this"), + i = e("../internals/fails"), + s = e("../internals/is-callable"), + o = e("../internals/has-own-property"), + a = e("../internals/descriptors"), + l = e("../internals/function-name").CONFIGURABLE, + c = e("../internals/inspect-source"), + u = e("../internals/internal-state"), + h = u.enforce, + f = u.get, + d = String, + p = Object.defineProperty, + m = n("".slice), + b = n("".replace), + g = n([].join), + y = + a && + !i(function () { + return 8 !== p(function () {}, "length", { value: 8 }).length; + }), + v = String(String).split("String"), + w = (t.exports = function (e, t, r) { + ("Symbol(" === m(d(t), 0, 7) && + (t = "[" + b(d(t), /^Symbol\(([^)]*)\)/, "$1") + "]"), + r && r.getter && (t = "get " + t), + r && r.setter && (t = "set " + t), + (!o(e, "name") || (l && e.name !== t)) && + (a + ? p(e, "name", { value: t, configurable: !0 }) + : (e.name = t)), + y && + r && + o(r, "arity") && + e.length !== r.arity && + p(e, "length", { value: r.arity })); + try { + r && o(r, "constructor") && r.constructor + ? a && p(e, "prototype", { writable: !1 }) + : e.prototype && (e.prototype = void 0); + } catch (e) {} + var n = h(e); + return ( + o(n, "source") || + (n.source = g(v, "string" == typeof t ? t : "")), + e + ); + }); + Function.prototype.toString = w(function () { + return (s(this) && f(this).source) || c(this); + }, "toString"); + }, + { + "../internals/descriptors": 247, + "../internals/fails": 260, + "../internals/function-name": 265, + "../internals/function-uncurry-this": 268, + "../internals/has-own-property": 275, + "../internals/inspect-source": 281, + "../internals/internal-state": 282, + "../internals/is-callable": 285, + }, + ], + 301: [ + function (e, t, r) { + "use strict"; + var n = Math.ceil, + i = Math.floor; + t.exports = + Math.trunc || + function (e) { + var t = +e; + return (t > 0 ? i : n)(t); + }; + }, + {}, + ], + 302: [ + function (e, t, r) { + "use strict"; + var n, + i, + s, + o, + a, + l = e("../internals/global"), + c = e("../internals/function-bind-context"), + u = e("../internals/object-get-own-property-descriptor").f, + h = e("../internals/task").set, + f = e("../internals/queue"), + d = e("../internals/engine-is-ios"), + p = e("../internals/engine-is-ios-pebble"), + m = e("../internals/engine-is-webos-webkit"), + b = e("../internals/engine-is-node"), + g = l.MutationObserver || l.WebKitMutationObserver, + y = l.document, + v = l.process, + w = l.Promise, + _ = u(l, "queueMicrotask"), + x = _ && _.value; + if (!x) { + var k = new f(), + S = function () { + var e, t; + for (b && (e = v.domain) && e.exit(); (t = k.get()); ) + try { + t(); + } catch (e) { + throw (k.head && n(), e); + } + e && e.enter(); + }; + (d || b || m || !g || !y + ? !p && w && w.resolve + ? (((o = w.resolve(void 0)).constructor = w), + (a = c(o.then, o)), + (n = function () { + a(S); + })) + : b + ? (n = function () { + v.nextTick(S); + }) + : ((h = c(h, l)), + (n = function () { + h(S); + })) + : ((i = !0), + (s = y.createTextNode("")), + new g(S).observe(s, { characterData: !0 }), + (n = function () { + s.data = i = !i; + })), + (x = function (e) { + (k.head || n(), k.add(e)); + })); + } + t.exports = x; + }, + { + "../internals/engine-is-ios": 253, + "../internals/engine-is-ios-pebble": 252, + "../internals/engine-is-node": 254, + "../internals/engine-is-webos-webkit": 255, + "../internals/function-bind-context": 262, + "../internals/global": 274, + "../internals/object-get-own-property-descriptor": 309, + "../internals/queue": 328, + "../internals/task": 339, + }, + ], + 303: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/a-callable"), + i = TypeError, + s = function (e) { + var t, r; + ((this.promise = new e(function (e, n) { + if (void 0 !== t || void 0 !== r) + throw new i("Bad Promise constructor"); + ((t = e), (r = n)); + })), + (this.resolve = n(t)), + (this.reject = n(r))); + }; + t.exports.f = function (e) { + return new s(e); + }; + }, + { "../internals/a-callable": 222 }, + ], + 304: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/is-regexp"), + i = TypeError; + t.exports = function (e) { + if (n(e)) + throw new i("The method doesn't accept regular expressions"); + return e; + }; + }, + { "../internals/is-regexp": 291 }, + ], + 305: [ + function (e, t, r) { + "use strict"; + var n = e("../internals/descriptors"), + i = e("../internals/function-uncurry-this"), + s = e("../internals/function-call"), + o = e("../internals/fails"), + a = e("../internals/object-keys"), + l = e("../internals/object-get-own-property-symbols"), + c = e("../internals/object-property-is-enumerable"), + u = e("../internals/to-object"), + h = e("../internals/indexed-object"), + f = Object.assign, + d = Object.defineProperty, + p = i([].concat); + t.exports = + !f || + o(function () { + if ( + n && + 1 !== + f( + { b: 1 }, + f( + d({}, "a", { + enumerable: !0, + get: function () { + d(this, "b", { value: 3, enumerable: !1 }); + }, + }), + { b: 2 }, + ), + ).b + ) + return !0; + var e = {}, + t = {}, + r = Symbol("assign detection"); + return ( + (e[r] = 7), + "abcdefghijklmnopqrst".split("").forEach(function (e) { + t[e] = e; + }), + 7 !== f({}, e)[r] || + "abcdefghijklmnopqrst" !== a(f({}, t)).join("") + ); + }) + ? function (e, t) { + for ( + var r = u(e), i = arguments.length, o = 1, f = l.f, d = c.f; + i > o; + ) + for ( + var m, + b = h(arguments[o++]), + g = f ? p(a(b), f(b)) : a(b), + y = g.length, + v = 0; + y > v; + ) + ((m = g[v++]), (n && !s(d, b, m)) || (r[m] = b[m])); + return r; + } + : f; + }, + { + "../internals/descriptors": 247, + "../internals/fails": 260, + "../internals/function-call": 264, + "../internals/function-uncurry-this": 268, + "../internals/indexed-object": 280, + "../internals/object-get-own-property-symbols": 312, + "../internals/object-keys": 316, + "../internals/object-property-is-enumerable": 317, + "../internals/to-object": 344, + }, + ], + 306: [ + function (e, t, r) { + "use strict"; + var n, + i = e("../internals/an-object"), + s = e("../internals/object-define-properties"), + o = e("../internals/enum-bug-keys"), + a = e("../internals/hidden-keys"), + l = e("../internals/html"), + c = e("../internals/document-create-element"), + u = e("../internals/shared-key"), + h = u("IE_PROTO"), + f = function () {}, + d = function (e) { + return "