ooxml-core 0.4.0 → 0.6.0

package/dist/digest/index.mjs

@@ -0,0 +1,581 @@
+// 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, index) => [char, index]));
+function encodeBase64(bytes) {
+  let out = "";
+  for (let i = 0; i < bytes.length; i += 3) {
+    const a = bytes[i];
+    const b = bytes[i + 1];
+    const c = bytes[i + 2];
+    const n = a << 16 | (b ?? 0) << 8 | (c ?? 0);
+    out += ALPHABET[n >> 18] + ALPHABET[n >> 12 & 63];
+    out += b === void 0 ? "=" : ALPHABET[n >> 6 & 63];
+    out += c === void 0 ? "=" : ALPHABET[n & 63];
+  }
+  return out;
+}
+function decodeBase64(text) {
+  const compact = text.replace(/\s+/g, "");
+  const body = compact.replace(/={1,2}$/, "");
+  if (body.length % 4 === 1) return void 0;
+  if (compact.length !== body.length && compact.length % 4 !== 0) return void 0;
+  const out = new Uint8Array(Math.floor(body.length * 3 / 4));
+  let bits = 0;
+  let buffer = 0;
+  let index = 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[index++] = 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, n) => x >>> n | x << 32 - n;
+function compress(h, view, offset) {
+  for (let i = 0; i < 16; i++) W[i] = view.getUint32(offset + 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], c = 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 & c ^ b & c;
+    const t2 = S0 + maj >>> 0;
+    k = g;
+    g = f;
+    f = e;
+    e = d + t1 >>> 0;
+    d = c;
+    c = b;
+    b = a;
+    a = t1 + t2 >>> 0;
+  }
+  h[0] = h[0] + a >>> 0;
+  h[1] = h[1] + b >>> 0;
+  h[2] = h[2] + c >>> 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 offset = 0; offset < view.byteLength; offset += 64) compress(h, view, offset);
+  return wordsOut(h);
+}
+
+// src/digest/sha1.ts
+var W2 = new Uint32Array(80);
+var rotl = (x, n) => x << n | x >>> 32 - n;
+function compress2(h, view, offset) {
+  for (let i = 0; i < 16; i++) W2[i] = view.getUint32(offset + 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], c = h[2], d = h[3], e = h[4];
+  for (let i = 0; i < 80; i++) {
+    let f;
+    let k;
+    if (i < 20) {
+      f = b & c | ~b & d;
+      k = 1518500249;
+    } else if (i < 40) {
+      f = b ^ c ^ d;
+      k = 1859775393;
+    } else if (i < 60) {
+      f = b & c | b & d | c & d;
+      k = 2400959708;
+    } else {
+      f = b ^ c ^ d;
+      k = 3395469782;
+    }
+    const t = rotl(a, 5) + f + e + k + W2[i] >>> 0;
+    e = d;
+    d = c;
+    c = rotl(b, 30) >>> 0;
+    b = a;
+    a = t;
+  }
+  h[0] = h[0] + a >>> 0;
+  h[1] = h[1] + b >>> 0;
+  h[2] = h[2] + c >>> 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 offset = 0; offset < view.byteLength; offset += 64) compress2(h, view, offset);
+  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, offset) {
+  for (let i = 0; i < 32; i++) {
+    const o = offset + 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], el = 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 | el << 18) ^ (eh >>> 18 | el << 14) ^ (el >>> 9 | eh << 23);
+    const S1l = (el >>> 14 | eh << 18) ^ (el >>> 18 | eh << 14) ^ (eh >>> 9 | el << 23);
+    const chh = eh & fh ^ ~eh & gh;
+    const chl = el & fl ^ ~el & 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 = el;
+    let nl = (dl >>> 0) + t1l;
+    eh = dh + t1h + Math.floor(nl / 4294967296) >>> 0;
+    el = 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, el);
+  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 offset = 0; offset < padded.length; offset += 128) compress3(h, padded, offset);
+  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;
+}
+function digestSync(name, data) {
+  return digestFunction(name)?.(data);
+}
+
+// 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;
+}
+
+export { MAX_SPIN_COUNT, decodeBase64, digestFunction, digestSync, encodeBase64, hashPassword, normalizeDigestAlgorithmName, sha1, sha256, sha384, sha512, verifyPasswordHash };

package/dist/digest/password-hash.d.ts

@@ -0,0 +1,30 @@
+/**
+ * An ECMA-376 agile password hash as Office stores it on protection elements (`sheetProtection`,
+ * `workbookProtection`, `p:modifyVerifier`, ...): digest name, base64 salt and hash, and the
+ * number of extra rounds (absent means none).
+ */
+export interface PasswordHash {
+    algorithmName: string;
+    hashValue: string;
+    saltValue: string;
+    spinCount?: number;
+}
+/**
+ * The largest `spinCount` honoured. Excel writes 100,000; anything far beyond that is a
+ * malformed or hostile file, and hashing it would freeze the thread.
+ */
+export declare const MAX_SPIN_COUNT = 10000000;
+/**
+ * The base64 ECMA-376 agile hash of `password` for the given salt, spin count and digest, as
+ * Excel, Word and PowerPoint store it. `undefined` when the digest is not one {@link digestSync}
+ * computes, the salt is not base64, or the spin count is negative, fractional, non-finite or
+ * above {@link MAX_SPIN_COUNT}.
+ */
+export declare function hashPassword(password: string, options: Omit<PasswordHash, 'hashValue'>): string | undefined;
+/**
+ * Whether `password` matches `hash`, comparing decoded bytes (so white space or missing base64
+ * padding in the file does not matter). `undefined` when the digest is not one this module
+ * computes; `false` (never a throw) for a malformed salt, hash or spin count.
+ */
+export declare function verifyPasswordHash(password: string, hash: PasswordHash): boolean | undefined;
+//# sourceMappingURL=password-hash.d.ts.map

package/dist/digest/password-hash.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"password-hash.d.ts","sourceRoot":"","sources":["../../src/digest/password-hash.ts"],"names":[],"mappings":"AAGA;;;;GAIG;AACH,MAAM,WAAW,YAAY;IAC5B,aAAa,EAAE,MAAM,CAAC;IACtB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,EAAE,MAAM,CAAC;IAClB,SAAS,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;GAGG;AACH,eAAO,MAAM,cAAc,WAAa,CAAC;AA0CzC;;;;;GAKG;AACH,wBAAgB,YAAY,CAC3B,QAAQ,EAAE,MAAM,EAChB,OAAO,EAAE,IAAI,CAAC,YAAY,EAAE,WAAW,CAAC,GACtC,MAAM,GAAG,SAAS,CAGpB;AAED;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,OAAO,GAAG,SAAS,CAQ5F"}

package/dist/digest/sha1.d.ts

@@ -0,0 +1,3 @@
+/** The SHA-1 digest (20 bytes) of `data`. */
+export declare function sha1(data: Uint8Array): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=sha1.d.ts.map

package/dist/digest/sha1.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha1.d.ts","sourceRoot":"","sources":["../../src/digest/sha1.ts"],"names":[],"mappings":"AA6CA,6CAA6C;AAC7C,wBAAgB,IAAI,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC,WAAW,CAAC,CAK9D"}

package/dist/digest/sha256.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Pads `data` the Merkle-Damgard way SHA-1 and SHA-256 share (0x80, zeros, 64-bit big-endian
+ * bit length) into whole 64-byte blocks.
+ */
+export declare function pad64(data: Uint8Array): DataView;
+/** Writes the state words `h` big-endian into a new byte array. */
+export declare function wordsOut(h: Uint32Array): Uint8Array<ArrayBuffer>;
+/** The SHA-256 digest (32 bytes) of `data`. */
+export declare function sha256(data: Uint8Array): Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=sha256.d.ts.map

package/dist/digest/sha256.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha256.d.ts","sourceRoot":"","sources":["../../src/digest/sha256.ts"],"names":[],"mappings":"AAiEA;;;GAGG;AACH,wBAAgB,KAAK,CAAC,IAAI,EAAE,UAAU,GAAG,QAAQ,CAShD;AAED,mEAAmE;AACnE,wBAAgB,QAAQ,CAAC,CAAC,EAAE,WAAW,GAAG,UAAU,CAAC,WAAW,CAAC,CAKhE;AAED,+CAA+C;AAC/C,wBAAgB,MAAM,CAAC,IAAI,EAAE,UAAU,GAAG,UAAU,CAAC,WAAW,CAAC,CAKhE"}

package/dist/digest/sha512.d.ts

@@ -0,0 +1,5 @@
+/** The SHA-512 digest (64 bytes) of `data`. */
+export declare const sha512: (data: Uint8Array) => Uint8Array<ArrayBuffer>;
+/** The SHA-384 digest (48 bytes) of `data`: the SHA-512 core with its own IV, truncated. */
+export declare const sha384: (data: Uint8Array) => Uint8Array<ArrayBuffer>;
+//# sourceMappingURL=sha512.d.ts.map

package/dist/digest/sha512.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"sha512.d.ts","sourceRoot":"","sources":["../../src/digest/sha512.ts"],"names":[],"mappings":"AAkJA,+CAA+C;AAC/C,eAAO,MAAM,MAAM,GAAI,MAAM,UAAU,KAAG,UAAU,CAAC,WAAW,CAA+B,CAAC;AAEhG,4FAA4F;AAC5F,eAAO,MAAM,MAAM,GAAI,MAAM,UAAU,KAAG,UAAU,CAAC,WAAW,CAA+B,CAAC"}

package/dist/docx/block-parser.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"block-parser.d.ts","sourceRoot":"","sources":["../../src/docx/block-parser.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAY,KAAK,EAAsB,MAAM,YAAY,CAAC;AACxF,OAAO,EAON,KAAK,UAAU,EAEf,MAAM,UAAU,CAAC;AAKlB,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAqIjE,iBAAS,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,CAgG/D;AAED,iBAAS,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,KAAK,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACvC,SAAS,EAAE,UAAU,EACrB,QAAQ,SAAK,EACb,OAAO,CAAC,EAAE,cAAc,GACtB,KAAK,EAAE,CAcT;AAYD,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,CAAC"}
+{"version":3,"file":"block-parser.d.ts","sourceRoot":"","sources":["../../src/docx/block-parser.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAY,KAAK,EAAsB,MAAM,YAAY,CAAC;AACxF,OAAO,EAON,KAAK,UAAU,EAEf,MAAM,UAAU,CAAC;AAKlB,OAAO,EAAgB,KAAK,cAAc,EAAE,MAAM,cAAc,CAAC;AAsIjE,iBAAS,cAAc,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,SAAS,CAwG/D;AAED,iBAAS,UAAU,CAAC,IAAI,EAAE,UAAU,EAAE,EAAE,EAAE,MAAM,GAAG,KAAK,CAEvD;AAED;;;;GAIG;AACH,wBAAgB,wBAAwB,CACvC,SAAS,EAAE,UAAU,EACrB,QAAQ,SAAK,EACb,OAAO,CAAC,EAAE,cAAc,GACtB,KAAK,EAAE,CAcT;AAYD,OAAO,EAAE,cAAc,EAAE,UAAU,EAAE,CAAC"}