@sheetxl/mcp 0.0.0-stage → 0.8.0-beta.15

package/assets/_fUXIv6nKvgZkhxn.js

@@ -0,0 +1,23 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.15
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = class {
+	constructor(e) {
+		this._onExecute = e;
+	}
+	execute(e) {
+		return this._onExecute(e);
+	}
+	start() {
+		return Promise.resolve();
+	}
+	terminate() {}
+};
+async function t() {
+	const { compileModule: t } = await import("./BG5kgbDRXMc0re6W.js"), r = new e((e) => t(e));
+	return await r.start(), r;
+}
+export { t as createCompilerWorker };

package/assets/fDMpDhXp36CatF-G.js

@@ -0,0 +1,23 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.15
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+var e = { PIVOTBY: {
+	s: "Aggregate values by rows and columns.",
+	p: {
+		rowFields: { d: "The range or array containing the row fields." },
+		colFields: { d: "The range or array containing the column fields." },
+		values: { d: "The range or array containing the value fields." },
+		fn: { d: "The function used to do the aggregations: a LAMBDA, a function name such as SUM, or an array of them." },
+		fieldHeaders: { d: "A number between 0 and 3 that specifies whether the field data has headers and whether field headers should be return in the results." },
+		rowTotalDepth: { d: "Show totals for the row fields. 0 for none, 1 for grand totals, 2 for grand totals and first level subtotals, etc. A negative number shows them at the top." },
+		rowSortOrder: { d: "The column index to sort the row fields on. A negative index will sort in reverse order." },
+		colTotalDepth: { d: "Show totals for the column fields. 0 for none, 1 for grand totals, 2 for grand totals and first level subtotals, etc. A negative number shows them at the left." },
+		colSortOrder: { d: "The column index to sort the column fields on. A negative index will sort in reverse order." },
+		filterArray: { d: "An array of boolean where TRUE represents a row to retain." },
+		relativeTo: { d: "Defines what PERCENTOF is calculated relative to. 0 for column totals, 1 for row totals, 2 for the grand total, 3 for parent column totals, 4 for parent row totals." }
+	}
+} };
+export { e as default };

package/assets/hulrR0PldUxMJm_F.js

@@ -0,0 +1,504 @@
+/**
+* @license @sheetxl/mcp - MCP server exposing SheetXL spreadsheet operations as tools and resources. - v0.8.0-beta.15
+*
+* (C) 2026-present SheetXL Inc. & Michael T. Ford
+* License: The license can be found at https://www.sheetxl.com/license.
+*/
+import { D as e } from "./BQMDOjNBMjAx9WiW.js";
+import { t } from "./DB-tkqI6wFXDKEfB.js";
+var r, n, a = class e {
+	static {
+		this.SIGNATURE = [
+			208,
+			207,
+			17,
+			224,
+			161,
+			177,
+			26,
+			225
+		];
+	}
+	static {
+		this.FATSECT = 4294967293;
+	}
+	static {
+		this.DIFSECT = 4294967292;
+	}
+	static {
+		this.ENDOFCHAIN = 4294967294;
+	}
+	static {
+		this.FREESECT = 4294967295;
+	}
+	static {
+		this.NOSTREAM = 4294967295;
+	}
+	static {
+		this.SECTOR_SIZE = 512;
+	}
+	static {
+		this.MINI_SECTOR_SIZE = 64;
+	}
+	static {
+		this.MINI_CUTOFF = 4096;
+	}
+	static {
+		this.DIR_ENTRY_SIZE = 128;
+	}
+	static {
+		this.DIFAT_HEADER_COUNT = 109;
+	}
+	constructor() {
+		this.sectors = [], this.fat = [];
+	}
+	static write(t) {
+		return new e()._build(t);
+	}
+	allocate(t) {
+		const r = e.SECTOR_SIZE, n = Math.max(1, Math.ceil(t.byteLength / r)), a = this.sectors.length;
+		for (let i = 0; i < n; i++) {
+			const s = new Uint8Array(r);
+			s.set(t.subarray(i * r, Math.min((i + 1) * r, t.byteLength))), this.sectors.push(s), this.fat.push(i === n - 1 ? e.ENDOFCHAIN : a + i + 1);
+		}
+		return a;
+	}
+	_build(t) {
+		const { SECTOR_SIZE: r, MINI_SECTOR_SIZE: n, MINI_CUTOFF: a, ENDOFCHAIN: i, FREESECT: s, FATSECT: c, DIFSECT: o, NOSTREAM: y, DIR_ENTRY_SIZE: h, DIFAT_HEADER_COUNT: l } = e, p = [];
+		let f = 0;
+		const u = t.map((e) => {
+			if (e.data.byteLength >= a) return {
+				entry: e,
+				mini: !1,
+				start: -1
+			};
+			const t = f, r = Math.max(1, Math.ceil(e.data.byteLength / n)), i = new Uint8Array(r * n);
+			return i.set(e.data), p.push(i), f += r, {
+				entry: e,
+				mini: !0,
+				start: t
+			};
+		});
+		for (const e of u) e.mini || (e.start = 0 === e.entry.data.byteLength ? i : this.allocate(e.entry.data));
+		let w = i;
+		const d = f * n;
+		if (f > 0) {
+			const e = new Uint8Array(d);
+			let t = 0;
+			for (const r of p) e.set(r, t), t += r.byteLength;
+			w = this.allocate(e);
+		}
+		let g = i, b = 0;
+		if (f > 0) {
+			const e = r / 4;
+			b = Math.ceil(f / e);
+			const t = new Uint8Array(b * r), a = new DataView(t.buffer);
+			t.fill(255);
+			let s = 0;
+			for (const e of u) {
+				if (!e.mini) continue;
+				const t = Math.max(1, Math.ceil(e.entry.data.byteLength / n));
+				for (let e = 0; e < t; e++, s++) a.setUint32(4 * s, e === t - 1 ? i : s + 1, !0);
+			}
+			g = this.allocate(t), b = Math.ceil(t.byteLength / r);
+		}
+		const m = [];
+		m.push(this._directoryEntry({
+			name: "Root Entry",
+			type: 5,
+			child: t.length > 0 ? 1 : y,
+			start: w === i ? 0 : w,
+			size: d
+		}));
+		const A = u.map((e, t) => ({
+			place: e,
+			index: t
+		})).sort((e, t) => {
+			const r = e.place.entry.name, n = t.place.entry.name;
+			return r.length !== n.length ? r.length - n.length : r.toUpperCase() < n.toUpperCase() ? -1 : r.toUpperCase() > n.toUpperCase() ? 1 : 0;
+		}), S = /* @__PURE__ */ new Map();
+		A.forEach((e, t) => S.set(e.index, t + 1)), u.forEach((e, t) => {
+			const r = S.get(t) - 1, n = A[r + 1];
+			m.push(this._directoryEntry({
+				name: e.entry.name,
+				type: 2,
+				right: n ? S.get(n.index) : y,
+				start: e.mini ? e.start : e.start === i ? 0 : e.start,
+				size: e.entry.data.byteLength
+			}));
+		});
+		const U = [m[0]];
+		A.forEach((e) => U.push(m[e.index + 1]));
+		const E = r / h, V = Math.ceil(U.length / E), k = new Uint8Array(V * r);
+		for (let e = 0; e < V * E; e++) {
+			const t = U[e] ?? this._directoryEntry({
+				name: "",
+				type: 0
+			});
+			k.set(t, e * h);
+		}
+		const C = this.allocate(k), I = r / 4, H = I - 1, L = this.sectors.length;
+		let M = 1, z = 0;
+		for (let e = 0; e < 16; e++) {
+			const e = L + M + z, t = Math.max(1, Math.ceil(e / I)), r = t <= l ? 0 : Math.ceil((t - l) / H);
+			if (t === M && r === z) break;
+			M = t, z = r;
+		}
+		const D = [], T = [];
+		for (let e = 0; e < M; e++) D.push(L + e);
+		for (let e = 0; e < z; e++) T.push(L + M + e);
+		for (const e of D) this.fat[e] = c;
+		for (const e of T) this.fat[e] = o;
+		const K = new Uint8Array(M * r);
+		K.fill(255);
+		const O = new DataView(K.buffer);
+		for (let e = 0; e < this.fat.length; e++) O.setUint32(4 * e, this.fat[e], !0);
+		const R = new Uint8Array(r + (L + M + z) * r), $ = new DataView(R.buffer);
+		R.set(e.SIGNATURE, 0), $.setUint16(24, 62, !0), $.setUint16(26, 3, !0), $.setUint16(28, 65534, !0), $.setUint16(30, 9, !0), $.setUint16(32, 6, !0), $.setUint32(44, M, !0), $.setUint32(48, C, !0), $.setUint32(56, a, !0), $.setUint32(60, g, !0), $.setUint32(64, b, !0), $.setUint32(68, z > 0 ? T[0] : i, !0), $.setUint32(72, z, !0);
+		for (let e = 0; e < l; e++) $.setUint32(76 + 4 * e, e < M ? D[e] : s, !0);
+		for (let e = 0; e < L; e++) R.set(this.sectors[e], r + e * r);
+		R.set(K, r + D[0] * r);
+		for (let e = 0; e < z; e++) {
+			const t = r + T[e] * r;
+			for (let r = 0; r < H; r++) {
+				const n = l + e * H + r;
+				$.setUint32(t + 4 * r, n < M ? D[n] : s, !0);
+			}
+			$.setUint32(t + 4 * H, e === z - 1 ? i : T[e + 1], !0);
+		}
+		return R;
+	}
+	_directoryEntry(t) {
+		const { NOSTREAM: r } = e, n = new Uint8Array(e.DIR_ENTRY_SIZE), a = new DataView(n.buffer), i = t.name;
+		for (let e = 0; e < i.length && e < 31; e++) a.setUint16(2 * e, i.charCodeAt(e), !0);
+		return a.setUint16(64, i.length > 0 ? 2 * (Math.min(i.length, 31) + 1) : 0, !0), n[66] = t.type, n[67] = 1, a.setUint32(68, t.left ?? r, !0), a.setUint32(72, t.right ?? r, !0), a.setUint32(76, t.child ?? r, !0), a.setUint32(116, t.start ?? 0, !0), a.setUint32(120, t.size ?? 0, !0), a.setUint32(124, 0, !0), n;
+	}
+};
+(function(e) {
+	const t = (e) => {
+		const t = atob(e), r = new Uint8Array(t.length);
+		for (let e = 0; e < t.length; e++) r[e] = t.charCodeAt(e);
+		return r;
+	}, r = (e, t, r) => {
+		const n = ((e, t) => {
+			const r = new RegExp(`\\b${t}\\s*=\\s*"([^"]*)"`).exec(e);
+			return r ? r[1] : null;
+		})(e, t);
+		if (null === n) throw new Error(`Malformed encryption descriptor: <${r}> is missing '${t}'.`);
+		return n;
+	}, n = (e, n) => ({
+		saltValue: t(r(e, "saltValue", n)),
+		blockSize: parseInt(r(e, "blockSize", n), 10),
+		keyBits: parseInt(r(e, "keyBits", n), 10),
+		hashSize: parseInt(r(e, "hashSize", n), 10),
+		cipherAlgorithm: r(e, "cipherAlgorithm", n),
+		cipherChaining: r(e, "cipherChaining", n),
+		hashAlgorithm: r(e, "hashAlgorithm", n)
+	}), a = (e, t) => {
+		const r = new RegExp(`<(?:\\w+:)?${t}\\b[^>]*>`).exec(e);
+		return r ? r[0] : null;
+	}, i = (e) => {
+		let t = "";
+		for (let r = 0; r < e.byteLength; r++) t += String.fromCharCode(e[r]);
+		return btoa(t);
+	};
+	e.build = (e) => {
+		const t = `saltSize="${e.saltSize}" blockSize="${e.blockSize}" keyBits="${e.keyBits}" hashSize="${e.hashSize}" cipherAlgorithm="${e.cipherAlgorithm}" cipherChaining="${e.cipherChaining}" hashAlgorithm="${e.hashAlgorithm}"`, r = `<?xml version="1.0" encoding="UTF-8" standalone="yes"?>\r\n<encryption xmlns="http://schemas.microsoft.com/office/2006/encryption" xmlns:p="http://schemas.microsoft.com/office/2006/keyEncryptor/password" xmlns:c="http://schemas.microsoft.com/office/2006/keyEncryptor/certificate"><keyData ${t} saltValue="${i(e.keyDataSalt)}"/><dataIntegrity encryptedHmacKey="${i(e.encryptedHmacKey)}" encryptedHmacValue="${i(e.encryptedHmacValue)}"/><keyEncryptors><keyEncryptor uri="http://schemas.microsoft.com/office/2006/keyEncryptor/password"><p:encryptedKey spinCount="${e.spinCount}" ${t} saltValue="${i(e.encryptorSalt)}" encryptedVerifierHashInput="${i(e.encryptedVerifierHashInput)}" encryptedVerifierHashValue="${i(e.encryptedVerifierHashValue)}" encryptedKeyValue="${i(e.encryptedKeyValue)}"/></keyEncryptor></keyEncryptors></encryption>`, n = new TextEncoder().encode(r), a = new Uint8Array(8 + n.byteLength), s = new DataView(a.buffer);
+		return s.setUint16(0, 4, !0), s.setUint16(2, 4, !0), s.setUint32(4, 64, !0), a.set(n, 8), a;
+	}, e.parse = (e) => {
+		if (e.byteLength < 8) throw new Error("Malformed EncryptionInfo stream (too short).");
+		const i = new DataView(e.buffer, e.byteOffset, e.byteLength), s = i.getUint16(0, !0), c = i.getUint16(2, !0);
+		if (4 === s && 4 === c) {
+			const i = new TextDecoder().decode(e.subarray(8)), s = a(i, "keyData");
+			if (!s) throw new Error("Malformed encryption descriptor: no <keyData>.");
+			const c = a(i, "encryptedKey");
+			if (!c) throw new Error("This file is encrypted with a scheme SheetXL cannot open (no password key encryptor).");
+			const o = a(i, "dataIntegrity");
+			return {
+				scheme: "agile",
+				keyData: n(s, "keyData"),
+				passwordKeyEncryptor: {
+					...n(c, "encryptedKey"),
+					spinCount: parseInt(r(c, "spinCount", "encryptedKey"), 10),
+					encryptedVerifierHashInput: t(r(c, "encryptedVerifierHashInput", "encryptedKey")),
+					encryptedVerifierHashValue: t(r(c, "encryptedVerifierHashValue", "encryptedKey")),
+					encryptedKeyValue: t(r(c, "encryptedKeyValue", "encryptedKey"))
+				},
+				dataIntegrity: o ? {
+					encryptedHmacKey: t(r(o, "encryptedHmacKey", "dataIntegrity")),
+					encryptedHmacValue: t(r(o, "encryptedHmacValue", "dataIntegrity"))
+				} : null
+			};
+		}
+		return {
+			scheme: 2 === s ? "rc4-cryptoapi" : 2 === c ? "standard" : "rc4",
+			versionMajor: s,
+			versionMinor: c
+		};
+	};
+})(r || (r = {})), function(e) {
+	const t = {
+		verifierHashInput: new Uint8Array([
+			254,
+			167,
+			210,
+			118,
+			59,
+			75,
+			158,
+			121
+		]),
+		verifierHashValue: new Uint8Array([
+			215,
+			170,
+			15,
+			109,
+			48,
+			97,
+			52,
+			78
+		]),
+		keyValue: new Uint8Array([
+			20,
+			110,
+			11,
+			231,
+			171,
+			172,
+			208,
+			214
+		]),
+		hmacKey: new Uint8Array([
+			95,
+			178,
+			173,
+			1,
+			12,
+			185,
+			225,
+			246
+		]),
+		hmacValue: new Uint8Array([
+			160,
+			103,
+			127,
+			2,
+			178,
+			44,
+			132,
+			51
+		])
+	}, r = async () => globalThis.crypto, n = (e) => {
+		switch (e.toUpperCase().replace(/[^A-Z0-9]/g, "")) {
+			case "SHA1": return "SHA-1";
+			case "SHA256": return "SHA-256";
+			case "SHA384": return "SHA-384";
+			case "SHA512": return "SHA-512";
+			default: throw new Error(`Unsupported encryption hash algorithm '${e}'.`);
+		}
+	}, a = (e) => {
+		const t = new Uint8Array(e.byteLength);
+		return t.set(e), t;
+	}, i = (...e) => {
+		let t = 0;
+		for (const r of e) t += r.byteLength;
+		const r = new Uint8Array(t);
+		let n = 0;
+		for (const t of e) r.set(t, n), n += t.byteLength;
+		return r;
+	}, s = (e, t) => {
+		if (e.byteLength >= t) return a(e.subarray(0, t));
+		const r = new Uint8Array(t).fill(54);
+		return r.set(e), r;
+	}, c = (e) => {
+		const t = /* @__PURE__ */ new Uint8Array(4);
+		return new DataView(t.buffer).setUint32(0, e, !0), t;
+	}, o = async (e, t, ...r) => new Uint8Array(await e.subtle.digest(t, i(...r))), y = () => "function" == typeof MessageChannel ? new Promise((e) => {
+		const t = new MessageChannel();
+		t.port1.onmessage = () => {
+			t.port1.close(), t.port2.close(), e();
+		}, t.port2.postMessage(null);
+	}) : new Promise((e) => {
+		setTimeout(e, 0);
+	}), h = async (e, t, r, n, a) => {
+		const i = new Uint8Array(2 * t.length), s = new DataView(i.buffer);
+		for (let e = 0; e < t.length; e++) s.setUint16(2 * e, t.charCodeAt(e), !0);
+		let h = await o(e, n, r, i);
+		for (let t = 0; t < a; t++) h = await o(e, n, c(t), h), t % 2048 == 0 && await y();
+		return h;
+	}, l = async (e, t, r, n, a) => s(await o(e, n, t, r), a), p = async (e, t, r, n, a) => s(await o(e, n, t, c(r)), a), f = async (e, t, r, n, a) => s(await o(e, n, t, r), a), u = async (e, t, r, n) => {
+		const i = await e.subtle.importKey("raw", a(r), {
+			name: "HMAC",
+			hash: { name: t }
+		}, !1, ["sign"]);
+		return new Uint8Array(await e.subtle.sign("HMAC", i, a(n)));
+	}, w = async (e, t, r, n) => {
+		const s = a(n);
+		if (0 === s.byteLength) return s;
+		if (s.byteLength % 16 != 0) throw new Error("Malformed encrypted payload (not block aligned).");
+		const c = await e.subtle.importKey("raw", t, { name: "AES-CBC" }, !1, ["encrypt", "decrypt"]), o = a(s.subarray(s.byteLength - 16)), y = (/* @__PURE__ */ new Uint8Array(16)).fill(16), h = new Uint8Array(await e.subtle.encrypt({
+			name: "AES-CBC",
+			iv: o
+		}, c, y)).subarray(0, 16), l = await e.subtle.decrypt({
+			name: "AES-CBC",
+			iv: r
+		}, c, i(s, h));
+		return new Uint8Array(l);
+	};
+	e.resolveSecretKey = async (e, i) => {
+		const c = e.passwordKeyEncryptor;
+		if (!/^AES$/i.test(c.cipherAlgorithm) || !/CBC$/i.test(c.cipherChaining)) throw new Error(`Unsupported encryption cipher '${c.cipherAlgorithm}/${c.cipherChaining}'.`);
+		const y = await r(), p = n(c.hashAlgorithm), f = c.keyBits / 8, u = await h(y, i, c.saltValue, p, c.spinCount), d = s(c.saltValue, c.blockSize), g = await l(y, u, t.verifierHashInput, p, f), b = await w(y, g, d, c.encryptedVerifierHashInput), m = await l(y, u, t.verifierHashValue, p, f), A = await w(y, m, d, c.encryptedVerifierHashValue), S = await o(y, p, b);
+		let U = S.byteLength > A.byteLength ? 1 : 0;
+		for (let e = 0; e < A.byteLength; e++) U |= (e < S.byteLength ? S[e] : 0) ^ A[e];
+		if (0 !== U) return null;
+		const E = await l(y, u, t.keyValue, p, f), V = await w(y, E, d, c.encryptedKeyValue);
+		return a(V.subarray(0, e.keyData.keyBits / 8));
+	};
+	const d = async (e, t, r, n) => {
+		const i = a(n);
+		if (0 === i.byteLength) return i;
+		if (i.byteLength % 16 != 0) throw new Error("Malformed plaintext (not block aligned).");
+		const s = await e.subtle.importKey("raw", t, { name: "AES-CBC" }, !1, ["encrypt"]), c = new Uint8Array(await e.subtle.encrypt({
+			name: "AES-CBC",
+			iv: r
+		}, s, i));
+		return a(c.subarray(0, i.byteLength));
+	}, g = (e, t) => e % t === 0 ? e : e + (t - e % t), b = 4096;
+	e.decryptPackage = async (e, t, a) => {
+		if (a.byteLength < 8) throw new Error("Malformed EncryptedPackage stream (too short).");
+		const i = await r(), { keyData: s } = e, c = n(s.hashAlgorithm), o = new DataView(a.buffer, a.byteOffset, a.byteLength), y = o.getUint32(0, !0) + 4294967296 * o.getUint32(4, !0), h = a.subarray(8), l = new Uint8Array(Math.min(y, h.byteLength));
+		let f = 0;
+		for (let e = 0; e * b < h.byteLength; e++) {
+			const r = e * b;
+			let n = h.subarray(r, Math.min(r + b, h.byteLength));
+			const a = n.byteLength % s.blockSize;
+			if (a) {
+				const e = new Uint8Array(n.byteLength + s.blockSize - a);
+				e.set(n), n = e;
+			}
+			const o = await p(i, s.saltValue, e, c, s.blockSize), y = await w(i, t, o, n), u = Math.min(y.byteLength, l.byteLength - f);
+			if (u <= 0) break;
+			l.set(y.subarray(0, u), f), f += u;
+		}
+		return l.subarray(0, f);
+	}, e.verifyIntegrity = async (e, a, i) => {
+		const s = e.dataIntegrity;
+		if (!s) return !0;
+		const c = await r(), { keyData: o } = e, y = n(o.hashAlgorithm), h = (await w(c, a, await f(c, o.saltValue, t.hmacKey, y, o.blockSize), s.encryptedHmacKey)).subarray(0, o.hashSize), l = (await w(c, a, await f(c, o.saltValue, t.hmacValue, y, o.blockSize), s.encryptedHmacValue)).subarray(0, o.hashSize), p = await u(c, y, h, i);
+		if (p.byteLength < o.hashSize) return !1;
+		let d = 0;
+		for (let e = 0; e < o.hashSize; e++) d |= l[e] ^ p[e];
+		return 0 === d;
+	};
+	const m = e.DEFAULTS = {
+		hashAlgorithm: "SHA512",
+		cipherAlgorithm: "AES",
+		cipherChaining: "ChainingModeCBC",
+		saltSize: 16,
+		blockSize: 16,
+		keyBits: 256,
+		hashSize: 64,
+		spinCount: 1e5
+	};
+	e.encrypt = async (e, a) => {
+		const i = await r(), c = n(m.hashAlgorithm), y = m.keyBits / 8, w = (e) => {
+			const t = new Uint8Array(e);
+			return i.getRandomValues(t), t;
+		}, A = w(y), S = w(m.saltSize), U = w(m.saltSize), E = w(m.saltSize), V = await h(i, a, U, c, m.spinCount), k = s(U, m.blockSize), C = await l(i, V, t.verifierHashInput, c, y), I = await d(i, C, k, E), H = await o(i, c, E), L = await l(i, V, t.verifierHashValue, c, y), M = new Uint8Array(g(H.byteLength, m.blockSize));
+		M.set(H);
+		const z = await d(i, L, k, M), D = await l(i, V, t.keyValue, c, y), T = await d(i, D, k, A), K = e.byteLength, O = Math.max(1, Math.ceil(K / b)), R = new Uint8Array(g(K, m.blockSize) || m.blockSize);
+		for (let t = 0; t < O; t++) {
+			const r = t * b, n = e.subarray(r, Math.min(r + b, K)), a = new Uint8Array(g(n.byteLength, m.blockSize));
+			a.set(n);
+			const s = await p(i, S, t, c, m.blockSize);
+			R.set(await d(i, A, s, a), r);
+		}
+		const $ = new Uint8Array(8 + R.byteLength), _ = new DataView($.buffer);
+		_.setUint32(0, K >>> 0, !0), _.setUint32(4, Math.floor(K / 4294967296), !0), $.set(R, 8);
+		const x = w(m.hashSize), N = new Uint8Array(g(x.byteLength, m.blockSize));
+		N.set(x);
+		const v = await d(i, A, await f(i, S, t.hmacKey, c, m.blockSize), N), F = await u(i, c, x, $), B = new Uint8Array(g(F.byteLength, m.blockSize));
+		return B.set(F), {
+			keyDataSalt: S,
+			encryptorSalt: U,
+			encryptedVerifierHashInput: I,
+			encryptedVerifierHashValue: z,
+			encryptedKeyValue: T,
+			encryptedHmacKey: v,
+			encryptedHmacValue: await d(i, A, await f(i, S, t.hmacValue, c, m.blockSize), B),
+			encryptedPackage: $
+		};
+	};
+}(n || (n = {}));
+var i = [
+	208,
+	207,
+	17,
+	224,
+	161,
+	177,
+	26,
+	225
+], s = "EncryptionInfo", c = "EncryptedPackage", o = (e) => {
+	if (!((e) => {
+		if (e.byteLength < i.length) return !1;
+		const t = new Uint8Array(e, 0, i.length);
+		for (let e = 0; e < i.length; e++) if (t[e] !== i[e]) return !1;
+		return !0;
+	})(e)) return null;
+	let r;
+	try {
+		r = t.read(new Uint8Array(e));
+	} catch {
+		return null;
+	}
+	const n = r.readStream(s), a = r.readStream(c);
+	return n && a ? {
+		info: n,
+		encryptedPackage: a
+	} : null;
+}, y = {
+	key: "offcrypto",
+	description: "Office Document Encryption",
+	detect: (e) => null !== o(e),
+	async decode(t, a) {
+		const i = o(t);
+		if (!i) throw new Error("Not an encrypted Office container.");
+		const s = r.parse(i.info);
+		if ("agile" !== s.scheme) throw new Error(`This file uses ${((e) => {
+			switch (e) {
+				case "standard": return "Standard ECMA-376 encryption (Office 2007)";
+				case "rc4-cryptoapi": return "RC4 CryptoAPI encryption (Office 2002-2003)";
+				case "rc4": return "RC4/XOR obfuscation (Office 97-2000)";
+				default: return e;
+			}
+		})(s.scheme)}, which SheetXL cannot open yet. Re-save it from Excel to upgrade it to the current encryption.`);
+		const c = await n.resolveSecretKey(s, a);
+		if (!c) throw new e();
+		if (s.dataIntegrity && !await n.verifyIntegrity(s, c, i.encryptedPackage)) throw new Error("This file failed its integrity check — it has been altered or is damaged since it was encrypted.");
+		const y = await n.decryptPackage(s, c, i.encryptedPackage);
+		return y.buffer.slice(y.byteOffset, y.byteOffset + y.byteLength);
+	},
+	async encode(e, t) {
+		if (!t) throw new Error("A password is required to encrypt.");
+		const i = await n.encrypt(new Uint8Array(e), t), o = r.build({
+			...n.DEFAULTS,
+			keyDataSalt: i.keyDataSalt,
+			encryptorSalt: i.encryptorSalt,
+			encryptedVerifierHashInput: i.encryptedVerifierHashInput,
+			encryptedVerifierHashValue: i.encryptedVerifierHashValue,
+			encryptedKeyValue: i.encryptedKeyValue,
+			encryptedHmacKey: i.encryptedHmacKey,
+			encryptedHmacValue: i.encryptedHmacValue
+		}), y = a.write([{
+			name: s,
+			data: o
+		}, {
+			name: c,
+			data: i.encryptedPackage
+		}]);
+		return y.buffer.slice(y.byteOffset, y.byteOffset + y.byteLength);
+	}
+};
+export { y as OffCryptoEncryption };