ooxml-core 0.4.0 → 0.6.0

package/dist/xlsx/index.cjs

@@ -8220,10 +8220,10 @@ var DISTRIBUTION_MORE = [
     "The hypergeometric distribution.",
     5,
     5,
-    (k, n2, K, N, c2) => {
+    (k, n2, K3, N, c2) => {
       const kk = Math.trunc(k);
       const nn = Math.trunc(n2 ?? 0);
-      const KK = Math.trunc(K ?? 0);
+      const KK = Math.trunc(K3 ?? 0);
       const NN = Math.trunc(N ?? 0);
       if (kk < 0 || nn > NN || KK > NN || kk > Math.min(nn, KK)) fail(ERR.NUM);
       const pmf = (i) => combin(KK, i) * combin(NN - KK, nn - i) / combin(NN, nn);
@@ -11539,6 +11539,29 @@ function translateReferences(formula, dRow, dCol) {
   return translateFormula(formula, dRow, dCol);
 }
 
+// src/xlsx/read/password-hash.ts
+function modernHashAttributeNames(prefix = "") {
+  const name = (base) => prefix ? `${prefix}${base[0].toUpperCase()}${base.slice(1)}` : base;
+  return {
+    algorithmName: name("algorithmName"),
+    hashValue: name("hashValue"),
+    saltValue: name("saltValue"),
+    spinCount: name("spinCount")
+  };
+}
+function readModernHash(node, prefix = "") {
+  const names = modernHashAttributeNames(prefix);
+  const algorithmName = att(node, names.algorithmName);
+  const hashValue = att(node, names.hashValue);
+  const saltValue = att(node, names.saltValue);
+  if (!algorithmName || !hashValue || !saltValue) return void 0;
+  const hash = { algorithmName, hashValue, saltValue };
+  const spin2 = att(node, names.spinCount);
+  const spinCount = spin2 === void 0 || spin2.trim() === "" ? Number.NaN : Number(spin2);
+  if (Number.isFinite(spinCount)) hash.spinCount = spinCount;
+  return hash;
+}
+
 // src/xlsx/read/workbook-part.ts
 function parseWorkbookPart(xml) {
   const root = parseXml(xml, { label: "XLSX workbook" }).documentElement;
@@ -11566,16 +11589,19 @@ function parseWorkbookPart(xml) {
     if (name.name) definedNames.push(name);
   }
   const view = xFirst(xFirst(root, "bookViews"), "workbookView");
-  const password = att(xFirst(root, "workbookProtection"), "workbookPassword");
+  const protection = xFirst(root, "workbookProtection");
+  const password = att(protection, "workbookPassword");
+  const modernHash = readModernHash(protection, "workbook");
   const calcMode = att(xFirst(root, "calcPr"), "calcMode");
   return {
     ...password ? { workbookPasswordHash: password } : {},
+    ...modernHash ? { workbookModernHash: modernHash } : {},
     ...calcMode === "manual" ? { calcMode: "manual" } : {},
     sheets,
     definedNames,
     date1904: boolAttr(xFirst(root, "workbookPr"), "date1904", false),
     activeTab: numAttr(view, "activeTab") ?? 0,
-    structureLocked: boolAttr(xFirst(root, "workbookProtection"), "lockStructure", false),
+    structureLocked: boolAttr(protection, "lockStructure", false),
     fullCalcOnLoad: boolAttr(xFirst(root, "calcPr"), "fullCalcOnLoad", false)
   };
 }
@@ -11750,6 +11776,8 @@ function readProtection(node) {
   const protection = { sheet: boolAttr(node, "sheet", false) };
   const password = att(node, "password");
   if (password) protection.passwordHash = password;
+  const modernHash = readModernHash(node);
+  if (modernHash) protection.modernHash = modernHash;
   const allow = [];
   for (const attribute of Array.from(node.attributes)) {
     if (PROTECTION_META.has(attribute.name)) continue;
@@ -12657,6 +12685,7 @@ async function loadXlsx(input) {
   if (book.fullCalcOnLoad) workbook.fullCalcOnLoad = true;
   if (book.structureLocked) workbook.structureLocked = true;
   if (book.workbookPasswordHash) workbook.workbookPasswordHash = book.workbookPasswordHash;
+  if (book.workbookModernHash) workbook.workbookModernHash = book.workbookModernHash;
   if (book.calcMode) workbook.calcMode = book.calcMode;
   if (!sheets.length) throw new Error("XLSX workbook has no sheets");
   liftPrintAreas(workbook);
@@ -13561,6 +13590,18 @@ function themePart(theme2, sourceXml) {
   return `${XML_HEADER}${buildXml(doc).replace(/^<\?xml[^>]*\?>\s*/, "")}`;
 }
 
+// src/xlsx/write/password-hash.ts
+function modernHashValues(hash, prefix = "") {
+  if (!hash) return {};
+  const names = modernHashAttributeNames(prefix);
+  return {
+    [names.algorithmName]: hash.algorithmName,
+    [names.hashValue]: hash.hashValue,
+    [names.saltValue]: hash.saltValue,
+    [names.spinCount]: hash.spinCount === void 0 ? void 0 : String(hash.spinCount)
+  };
+}
+
 // src/xlsx/write/workbook-part.ts
 var KEPT_BEFORE_SHEETS = ["fileVersion", "fileSharing"];
 var KEPT_AFTER_SHEETS = ["functionGroups", "externalReferences"];
@@ -13611,18 +13652,17 @@ function workbookXml(workbook, sheets, activeTab, sourceXml) {
   out += raw(KEPT_BEFORE_SHEETS) || '<fileVersion appName="xl" lastEdited="7" lowestEdited="7" rupBuild="27328"/>';
   out += `<workbookPr${copyAttrs(kept.get("workbookPr"), ["date1904"])}${workbook.date1904 ? ' date1904="1"' : ""}/>`;
   if (workbook.structureLocked) {
-    const protection = kept.get("workbookProtection");
-    const sourceHash = protection?.getAttribute("workbookPassword") || void 0;
-    const skip = ["lockStructure", "workbookPassword"];
-    if (sourceHash !== workbook.workbookPasswordHash)
-      skip.push(
-        "workbookAlgorithmName",
-        "workbookHashValue",
-        "workbookSaltValue",
-        "workbookSpinCount"
-      );
+    const skip = [
+      "lockStructure",
+      "workbookPassword",
+      "workbookAlgorithmName",
+      "workbookHashValue",
+      "workbookSaltValue",
+      "workbookSpinCount"
+    ];
+    const modern = Object.entries(modernHashValues(workbook.workbookModernHash, "workbook")).filter((entry) => entry[1] !== void 0).map(([name, value]) => ` ${name}="${escapeAttr3(value)}"`).join("");
     const password = workbook.workbookPasswordHash ? ` workbookPassword="${escapeAttr3(workbook.workbookPasswordHash)}"` : "";
-    out += `<workbookProtection${copyAttrs(protection, skip)}${password} lockStructure="1"/>`;
+    out += `<workbookProtection${copyAttrs(kept.get("workbookProtection"), skip)}${modern}${password} lockStructure="1"/>`;
   }
   const view = kept.get("bookViews") ? elements(kept.get("bookViews"))[0] : void 0;
   out += `<bookViews><workbookView${copyAttrs(view, ["activeTab", "firstSheet", "xr2:uid"])}${activeTab ? ` activeTab="${activeTab}"` : ""}/></bookViews>`;
@@ -14229,18 +14269,15 @@ function colsXml(sheet, styleCount) {
   }
   return out.length ? `<cols>${out.join("")}</cols>` : "";
 }
-var HASH_ATTRS = ["algorithmName", "hashValue", "saltValue", "spinCount"];
 function protectionXml2(sheet) {
   const protection = sheet.protection;
   if (!protection) return "";
   const source2 = snapshotElement(sheet, "sheetProtection");
   if (source2 && sameModel(readProtection(source2), protection))
     return snapshotXml(sheet, "sheetProtection") ?? "";
-  const values = {};
-  if (protection.passwordHash !== void 0 && protection.passwordHash === att(source2, "password"))
-    for (const name of HASH_ATTRS) values[name] = att(source2, name);
-  else if (protection.passwordHash === void 0 && att(source2, "password") === void 0)
-    for (const name of HASH_ATTRS) values[name] = att(source2, name);
+  const values = modernHashValues(
+    protection.modernHash
+  );
   values["password"] = protection.passwordHash;
   values["sheet"] = protection.sheet || void 0;
   const allow = new Set(protection.allow ?? []);
@@ -16691,7 +16728,12 @@ function replaceOne(ctx, query, replacement, at) {
 }
 
 // src/xlsx/edit/history.ts
-var SETTING_KEYS = ["structureLocked", "workbookPasswordHash", "calcMode"];
+var SETTING_KEYS = [
+  "structureLocked",
+  "workbookPasswordHash",
+  "workbookModernHash",
+  "calcMode"
+];
 function captureSettings(workbook) {
   const out = {};
   for (const key of SETTING_KEYS) if (workbook[key] !== void 0) out[key] = workbook[key];
@@ -17670,6 +17712,583 @@ function setPrintOptions(ctx, s, patch) {
   );
 }
 
+// src/digest/algorithm-names.ts
+var CANONICAL_BY_LOOKUP_KEY = {
+  SHA1: "SHA-1",
+  SHA256: "SHA-256",
+  SHA384: "SHA-384",
+  SHA512: "SHA-512",
+  MD2: "MD2",
+  MD4: "MD4",
+  MD5: "MD5",
+  RIPEMD128: "RIPEMD-128",
+  RIPEMD160: "RIPEMD-160",
+  WHIRLPOOL: "WHIRLPOOL"
+};
+function normalizeDigestAlgorithmName(name) {
+  const key = name.toUpperCase().replace(/[-_\s]/g, "");
+  return Object.hasOwn(CANONICAL_BY_LOOKUP_KEY, key) ? CANONICAL_BY_LOOKUP_KEY[key] : void 0;
+}
+
+// src/digest/base64.ts
+var ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+var VALUES = new Map([...ALPHABET].map((char, index2) => [char, index2]));
+function encodeBase64(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = bytes[i + 1];
+    const c2 = bytes[i + 2];
+    const n2 = a << 16 | (b ?? 0) << 8 | (c2 ?? 0);
+    out += ALPHABET[n2 >> 18] + ALPHABET[n2 >> 12 & 63];
+    out += b === void 0 ? "=" : ALPHABET[n2 >> 6 & 63];
+    out += c2 === void 0 ? "=" : ALPHABET[n2 & 63];
+  }
+  return out;
+}
+function decodeBase64(text2) {
+  const compact3 = text2.replace(/\s+/g, "");
+  const body = compact3.replace(/={1,2}$/, "");
+  if (body.length % 4 === 1) return void 0;
+  if (compact3.length !== body.length && compact3.length % 4 !== 0) return void 0;
+  const out = new Uint8Array(Math.floor(body.length * 3 / 4));
+  let bits = 0;
+  let buffer = 0;
+  let index2 = 0;
+  for (const char of body) {
+    const value = VALUES.get(char);
+    if (value === void 0) return void 0;
+    buffer = (buffer << 6 | value) & 16777215;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[index2++] = buffer >> bits & 255;
+    }
+  }
+  return out;
+}
+
+// src/digest/sha256.ts
+var K = new Uint32Array([
+  1116352408,
+  1899447441,
+  3049323471,
+  3921009573,
+  961987163,
+  1508970993,
+  2453635748,
+  2870763221,
+  3624381080,
+  310598401,
+  607225278,
+  1426881987,
+  1925078388,
+  2162078206,
+  2614888103,
+  3248222580,
+  3835390401,
+  4022224774,
+  264347078,
+  604807628,
+  770255983,
+  1249150122,
+  1555081692,
+  1996064986,
+  2554220882,
+  2821834349,
+  2952996808,
+  3210313671,
+  3336571891,
+  3584528711,
+  113926993,
+  338241895,
+  666307205,
+  773529912,
+  1294757372,
+  1396182291,
+  1695183700,
+  1986661051,
+  2177026350,
+  2456956037,
+  2730485921,
+  2820302411,
+  3259730800,
+  3345764771,
+  3516065817,
+  3600352804,
+  4094571909,
+  275423344,
+  430227734,
+  506948616,
+  659060556,
+  883997877,
+  958139571,
+  1322822218,
+  1537002063,
+  1747873779,
+  1955562222,
+  2024104815,
+  2227730452,
+  2361852424,
+  2428436474,
+  2756734187,
+  3204031479,
+  3329325298
+]);
+var IV = [
+  1779033703,
+  3144134277,
+  1013904242,
+  2773480762,
+  1359893119,
+  2600822924,
+  528734635,
+  1541459225
+];
+var W = new Uint32Array(64);
+var rotr = (x, n2) => x >>> n2 | x << 32 - n2;
+function compress(h, view, offset2) {
+  for (let i = 0; i < 16; i++) W[i] = view.getUint32(offset2 + i * 4);
+  for (let i = 16; i < 64; i++) {
+    const a2 = W[i - 15];
+    const b2 = W[i - 2];
+    const s0 = rotr(a2, 7) ^ rotr(a2, 18) ^ a2 >>> 3;
+    const s1 = rotr(b2, 17) ^ rotr(b2, 19) ^ b2 >>> 10;
+    W[i] = W[i - 16] + s0 + W[i - 7] + s1 >>> 0;
+  }
+  let a = h[0], b = h[1], c2 = h[2], d = h[3], e = h[4], f = h[5], g = h[6], k = h[7];
+  for (let i = 0; i < 64; i++) {
+    const S1 = rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25);
+    const ch = e & f ^ ~e & g;
+    const t1 = k + S1 + ch + K[i] + W[i] >>> 0;
+    const S0 = rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22);
+    const maj = a & b ^ a & c2 ^ b & c2;
+    const t2 = S0 + maj >>> 0;
+    k = g;
+    g = f;
+    f = e;
+    e = d + t1 >>> 0;
+    d = c2;
+    c2 = b;
+    b = a;
+    a = t1 + t2 >>> 0;
+  }
+  h[0] = h[0] + a >>> 0;
+  h[1] = h[1] + b >>> 0;
+  h[2] = h[2] + c2 >>> 0;
+  h[3] = h[3] + d >>> 0;
+  h[4] = h[4] + e >>> 0;
+  h[5] = h[5] + f >>> 0;
+  h[6] = h[6] + g >>> 0;
+  h[7] = h[7] + k >>> 0;
+}
+function pad64(data) {
+  const padded = new Uint8Array(Math.ceil((data.length + 9) / 64) * 64);
+  padded.set(data);
+  padded[data.length] = 128;
+  const bits = data.length * 8;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(bits / 4294967296));
+  view.setUint32(padded.length - 4, bits >>> 0);
+  return view;
+}
+function wordsOut(h) {
+  const out = new Uint8Array(h.length * 4);
+  const view = new DataView(out.buffer);
+  for (let i = 0; i < h.length; i++) view.setUint32(i * 4, h[i]);
+  return out;
+}
+function sha256(data) {
+  const h = new Uint32Array(IV);
+  const view = pad64(data);
+  for (let offset2 = 0; offset2 < view.byteLength; offset2 += 64) compress(h, view, offset2);
+  return wordsOut(h);
+}
+
+// src/digest/sha1.ts
+var W2 = new Uint32Array(80);
+var rotl = (x, n2) => x << n2 | x >>> 32 - n2;
+function compress2(h, view, offset2) {
+  for (let i = 0; i < 16; i++) W2[i] = view.getUint32(offset2 + i * 4);
+  for (let i = 16; i < 80; i++) W2[i] = rotl(W2[i - 3] ^ W2[i - 8] ^ W2[i - 14] ^ W2[i - 16], 1);
+  let a = h[0], b = h[1], c2 = h[2], d = h[3], e = h[4];
+  for (let i = 0; i < 80; i++) {
+    let f;
+    let k;
+    if (i < 20) {
+      f = b & c2 | ~b & d;
+      k = 1518500249;
+    } else if (i < 40) {
+      f = b ^ c2 ^ d;
+      k = 1859775393;
+    } else if (i < 60) {
+      f = b & c2 | b & d | c2 & d;
+      k = 2400959708;
+    } else {
+      f = b ^ c2 ^ d;
+      k = 3395469782;
+    }
+    const t = rotl(a, 5) + f + e + k + W2[i] >>> 0;
+    e = d;
+    d = c2;
+    c2 = rotl(b, 30) >>> 0;
+    b = a;
+    a = t;
+  }
+  h[0] = h[0] + a >>> 0;
+  h[1] = h[1] + b >>> 0;
+  h[2] = h[2] + c2 >>> 0;
+  h[3] = h[3] + d >>> 0;
+  h[4] = h[4] + e >>> 0;
+}
+function sha1(data) {
+  const h = new Uint32Array([1732584193, 4023233417, 2562383102, 271733878, 3285377520]);
+  const view = pad64(data);
+  for (let offset2 = 0; offset2 < view.byteLength; offset2 += 64) compress2(h, view, offset2);
+  return wordsOut(h);
+}
+
+// src/digest/sha512.ts
+var K2 = new Uint32Array([
+  1116352408,
+  3609767458,
+  1899447441,
+  602891725,
+  3049323471,
+  3964484399,
+  3921009573,
+  2173295548,
+  961987163,
+  4081628472,
+  1508970993,
+  3053834265,
+  2453635748,
+  2937671579,
+  2870763221,
+  3664609560,
+  3624381080,
+  2734883394,
+  310598401,
+  1164996542,
+  607225278,
+  1323610764,
+  1426881987,
+  3590304994,
+  1925078388,
+  4068182383,
+  2162078206,
+  991336113,
+  2614888103,
+  633803317,
+  3248222580,
+  3479774868,
+  3835390401,
+  2666613458,
+  4022224774,
+  944711139,
+  264347078,
+  2341262773,
+  604807628,
+  2007800933,
+  770255983,
+  1495990901,
+  1249150122,
+  1856431235,
+  1555081692,
+  3175218132,
+  1996064986,
+  2198950837,
+  2554220882,
+  3999719339,
+  2821834349,
+  766784016,
+  2952996808,
+  2566594879,
+  3210313671,
+  3203337956,
+  3336571891,
+  1034457026,
+  3584528711,
+  2466948901,
+  113926993,
+  3758326383,
+  338241895,
+  168717936,
+  666307205,
+  1188179964,
+  773529912,
+  1546045734,
+  1294757372,
+  1522805485,
+  1396182291,
+  2643833823,
+  1695183700,
+  2343527390,
+  1986661051,
+  1014477480,
+  2177026350,
+  1206759142,
+  2456956037,
+  344077627,
+  2730485921,
+  1290863460,
+  2820302411,
+  3158454273,
+  3259730800,
+  3505952657,
+  3345764771,
+  106217008,
+  3516065817,
+  3606008344,
+  3600352804,
+  1432725776,
+  4094571909,
+  1467031594,
+  275423344,
+  851169720,
+  430227734,
+  3100823752,
+  506948616,
+  1363258195,
+  659060556,
+  3750685593,
+  883997877,
+  3785050280,
+  958139571,
+  3318307427,
+  1322822218,
+  3812723403,
+  1537002063,
+  2003034995,
+  1747873779,
+  3602036899,
+  1955562222,
+  1575990012,
+  2024104815,
+  1125592928,
+  2227730452,
+  2716904306,
+  2361852424,
+  442776044,
+  2428436474,
+  593698344,
+  2756734187,
+  3733110249,
+  3204031479,
+  2999351573,
+  3329325298,
+  3815920427,
+  3391569614,
+  3928383900,
+  3515267271,
+  566280711,
+  3940187606,
+  3454069534,
+  4118630271,
+  4000239992,
+  116418474,
+  1914138554,
+  174292421,
+  2731055270,
+  289380356,
+  3203993006,
+  460393269,
+  320620315,
+  685471733,
+  587496836,
+  852142971,
+  1086792851,
+  1017036298,
+  365543100,
+  1126000580,
+  2618297676,
+  1288033470,
+  3409855158,
+  1501505948,
+  4234509866,
+  1607167915,
+  987167468,
+  1816402316,
+  1246189591
+]);
+var IV_512 = [
+  1779033703,
+  4089235720,
+  3144134277,
+  2227873595,
+  1013904242,
+  4271175723,
+  2773480762,
+  1595750129,
+  1359893119,
+  2917565137,
+  2600822924,
+  725511199,
+  528734635,
+  4215389547,
+  1541459225,
+  327033209
+];
+var IV_384 = [
+  3418070365,
+  3238371032,
+  1654270250,
+  914150663,
+  2438529370,
+  812702999,
+  355462360,
+  4144912697,
+  1731405415,
+  4290775857,
+  2394180231,
+  1750603025,
+  3675008525,
+  1694076839,
+  1203062813,
+  3204075428
+];
+var W3 = new Uint32Array(160);
+function compress3(h, data, offset2) {
+  for (let i = 0; i < 32; i++) {
+    const o = offset2 + i * 4;
+    W3[i] = (data[o] << 24 | data[o + 1] << 16 | data[o + 2] << 8 | data[o + 3]) >>> 0;
+  }
+  for (let i = 16; i < 80; i++) {
+    const xh = W3[(i - 15) * 2];
+    const xl = W3[(i - 15) * 2 + 1];
+    const s0h = (xh >>> 1 | xl << 31) ^ (xh >>> 8 | xl << 24) ^ xh >>> 7;
+    const s0l = (xl >>> 1 | xh << 31) ^ (xl >>> 8 | xh << 24) ^ (xl >>> 7 | xh << 25);
+    const yh = W3[(i - 2) * 2];
+    const yl = W3[(i - 2) * 2 + 1];
+    const s1h = (yh >>> 19 | yl << 13) ^ (yl >>> 29 | yh << 3) ^ yh >>> 6;
+    const s1l = (yl >>> 19 | yh << 13) ^ (yh >>> 29 | yl << 3) ^ (yl >>> 6 | yh << 26);
+    let lo = (s0l >>> 0) + (s1l >>> 0) + W3[(i - 7) * 2 + 1] + W3[(i - 16) * 2 + 1];
+    const hi = s0h + s1h + W3[(i - 7) * 2] + W3[(i - 16) * 2] + Math.floor(lo / 4294967296);
+    lo >>>= 0;
+    W3[i * 2] = hi >>> 0;
+    W3[i * 2 + 1] = lo;
+  }
+  let ah = h[0], al = h[1], bh = h[2], bl = h[3], ch = h[4], cl = h[5], dh = h[6], dl = h[7];
+  let eh = h[8], el2 = h[9], fh = h[10], fl = h[11], gh = h[12], gl = h[13], hh = h[14], hl = h[15];
+  for (let i = 0; i < 80; i++) {
+    const S1h = (eh >>> 14 | el2 << 18) ^ (eh >>> 18 | el2 << 14) ^ (el2 >>> 9 | eh << 23);
+    const S1l = (el2 >>> 14 | eh << 18) ^ (el2 >>> 18 | eh << 14) ^ (eh >>> 9 | el2 << 23);
+    const chh = eh & fh ^ ~eh & gh;
+    const chl = el2 & fl ^ ~el2 & gl;
+    let t1l = (hl >>> 0) + (S1l >>> 0) + (chl >>> 0) + K2[i * 2 + 1] + W3[i * 2 + 1];
+    const t1h = hh + S1h + chh + K2[i * 2] + W3[i * 2] + Math.floor(t1l / 4294967296);
+    t1l >>>= 0;
+    const S0h = (ah >>> 28 | al << 4) ^ (al >>> 2 | ah << 30) ^ (al >>> 7 | ah << 25);
+    const S0l = (al >>> 28 | ah << 4) ^ (ah >>> 2 | al << 30) ^ (ah >>> 7 | al << 25);
+    const majh = ah & bh ^ ah & ch ^ bh & ch;
+    const majl = al & bl ^ al & cl ^ bl & cl;
+    let t2l = (S0l >>> 0) + (majl >>> 0);
+    const t2h = S0h + majh + Math.floor(t2l / 4294967296);
+    t2l >>>= 0;
+    hh = gh;
+    hl = gl;
+    gh = fh;
+    gl = fl;
+    fh = eh;
+    fl = el2;
+    let nl = (dl >>> 0) + t1l;
+    eh = dh + t1h + Math.floor(nl / 4294967296) >>> 0;
+    el2 = nl >>> 0;
+    dh = ch;
+    dl = cl;
+    ch = bh;
+    cl = bl;
+    bh = ah;
+    bl = al;
+    nl = t1l + t2l;
+    ah = t1h + t2h + Math.floor(nl / 4294967296) >>> 0;
+    al = nl >>> 0;
+  }
+  const add = (i, xh, xl) => {
+    const lo = (h[i + 1] >>> 0) + (xl >>> 0);
+    h[i] = h[i] + xh + Math.floor(lo / 4294967296) >>> 0;
+    h[i + 1] = lo >>> 0;
+  };
+  add(0, ah, al);
+  add(2, bh, bl);
+  add(4, ch, cl);
+  add(6, dh, dl);
+  add(8, eh, el2);
+  add(10, fh, fl);
+  add(12, gh, gl);
+  add(14, hh, hl);
+}
+function digest64(data, iv, bytes) {
+  const h = new Uint32Array(iv);
+  const padded = new Uint8Array(Math.ceil((data.length + 17) / 128) * 128);
+  padded.set(data);
+  padded[data.length] = 128;
+  const bits = data.length * 8;
+  const view = new DataView(padded.buffer);
+  view.setUint32(padded.length - 8, Math.floor(bits / 4294967296));
+  view.setUint32(padded.length - 4, bits >>> 0);
+  for (let offset2 = 0; offset2 < padded.length; offset2 += 128) compress3(h, padded, offset2);
+  const out = new Uint8Array(bytes);
+  const outView = new DataView(out.buffer);
+  for (let i = 0; i < bytes / 4; i++) outView.setUint32(i * 4, h[i]);
+  return out;
+}
+var sha512 = (data) => digest64(data, IV_512, 64);
+var sha384 = (data) => digest64(data, IV_384, 48);
+
+// src/digest/digest.ts
+var DIGESTS = {
+  "SHA-1": sha1,
+  "SHA-256": sha256,
+  "SHA-384": sha384,
+  "SHA-512": sha512
+};
+function digestFunction(name) {
+  const canonical = normalizeDigestAlgorithmName(name);
+  return canonical && canonical in DIGESTS ? DIGESTS[canonical] : void 0;
+}
+
+// src/digest/password-hash.ts
+var MAX_SPIN_COUNT = 1e7;
+var validSpinCount = (spinCount) => spinCount === void 0 || Number.isInteger(spinCount) && spinCount >= 0 && spinCount <= MAX_SPIN_COUNT;
+function spin(password, salt, spinCount, digest) {
+  const input = new Uint8Array(salt.length + password.length * 2);
+  input.set(salt);
+  for (let i = 0; i < password.length; i++) {
+    const code = password.charCodeAt(i);
+    input[salt.length + i * 2] = code & 255;
+    input[salt.length + i * 2 + 1] = code >> 8;
+  }
+  let value = digest(input);
+  const buffer = new Uint8Array(value.length + 4);
+  const view = new DataView(buffer.buffer);
+  for (let i = 0; i < spinCount; i++) {
+    buffer.set(value);
+    view.setUint32(value.length, i, true);
+    value = digest(buffer);
+  }
+  return value;
+}
+function hashBytes(password, { algorithmName, saltValue, spinCount }) {
+  const digest = digestFunction(algorithmName);
+  const salt = decodeBase64(saltValue);
+  if (!digest || !salt || !validSpinCount(spinCount)) return void 0;
+  return spin(password, salt, spinCount ?? 0, digest);
+}
+function hashPassword(password, options) {
+  const bytes = hashBytes(password, options);
+  return bytes && encodeBase64(bytes);
+}
+function verifyPasswordHash(password, hash) {
+  if (!digestFunction(hash.algorithmName)) return void 0;
+  const expected = decodeBase64(hash.hashValue);
+  const actual = expected && hashBytes(password, hash);
+  if (!expected || !actual || actual.length !== expected.length) return false;
+  let difference = 0;
+  for (let i = 0; i < actual.length; i++) difference |= actual[i] ^ expected[i];
+  return difference === 0;
+}
+
 // src/xlsx/edit/protection.ts
 function legacyPasswordHash(password) {
   let hash = 0;
@@ -17681,15 +18300,30 @@ function legacyPasswordHash(password) {
   hash ^= 52811;
   return hash.toString(16).toUpperCase();
 }
-var sameHash = (hash, password) => hash === void 0 || hash.toUpperCase() === legacyPasswordHash(password);
+var sameLegacyHash = (hash, password) => hash.toUpperCase() === legacyPasswordHash(password);
+function matchesHashes(modern, legacy, password) {
+  const verdict = modern ? verifyPasswordHash(password, modern) : void 0;
+  if (verdict !== void 0) return verdict;
+  if (legacy !== void 0) return sameLegacyHash(legacy, password);
+  return !modern;
+}
+var protectionOf = (sheet) => sheet && "rows" in sheet ? sheet.protection : sheet;
 function verifySheetPassword(sheet, password) {
-  const protection = sheet && "rows" in sheet ? sheet.protection : sheet;
+  const protection = protectionOf(sheet);
   if (!protection?.sheet) return true;
-  return sameHash(protection.passwordHash, password);
+  return matchesHashes(protection.modernHash, protection.passwordHash, password);
+}
+async function verifySheetPasswordAsync(sheet, password) {
+  return verifySheetPassword(sheet, password);
+}
+async function modernPasswordHash(password, hash, digest = "SHA-512") {
+  const value = hashPassword(password, { ...hash, algorithmName: digest });
+  if (value === void 0) throw new Error(`Cannot compute a ${digest} password hash`);
+  return value;
 }
 function verifyWorkbookPassword(workbook, password) {
   if (!workbook.structureLocked) return true;
-  return sameHash(workbook.workbookPasswordHash, password);
+  return matchesHashes(workbook.workbookModernHash, workbook.workbookPasswordHash, password);
 }
 var WRONG_PASSWORD = "The password you supplied is not correct.";
 function setSheetProtection(ctx, s, protection, password) {
@@ -17706,8 +18340,13 @@ function setSheetProtection(ctx, s, protection, password) {
         return;
       }
       const next = structuredClone(protection);
-      if (password) next.passwordHash = legacyPasswordHash(password);
-      else if (password === "") delete next.passwordHash;
+      if (password) {
+        next.passwordHash = legacyPasswordHash(password);
+        delete next.modernHash;
+      } else if (password === "") {
+        delete next.passwordHash;
+        delete next.modernHash;
+      }
       sheet.protection = next;
     },
     { sheet: s }
@@ -17722,9 +18361,11 @@ function setWorkbookProtection(ctx, locked, password) {
       workbook.structureLocked = true;
       if (password) workbook.workbookPasswordHash = legacyPasswordHash(password);
       else if (password === "") delete workbook.workbookPasswordHash;
+      if (password !== void 0) delete workbook.workbookModernHash;
     } else {
       delete workbook.structureLocked;
       delete workbook.workbookPasswordHash;
+      delete workbook.workbookModernHash;
     }
   });
 }
@@ -20500,6 +21141,7 @@ exports.mergeAt = mergeAt;
 exports.mergeFont = mergeFont;
 exports.mergeView = mergeView;
 exports.mixColors = mixColors;
+exports.modernPasswordHash = modernPasswordHash;
 exports.modulateLuminance = modulateLuminance;
 exports.moveReferencesInFormula = moveReferencesInFormula;
 exports.navigate = navigate;
@@ -20573,6 +21215,7 @@ exports.validateSheetName = validateSheetName;
 exports.validateTableName = validateTableName;
 exports.validationAt = validationAt;
 exports.verifySheetPassword = verifySheetPassword;
+exports.verifySheetPasswordAsync = verifySheetPasswordAsync;
 exports.verifyWorkbookPassword = verifyWorkbookPassword;
 exports.visibleCells = visibleCells;
 exports.wrappedLineCount = wrappedLineCount;