@fairblock/stabletrust 2.0.6 → 2.0.10

package/src/vendor/ts-ibe/age/age-encrypt-decrypt.js

@@ -0,0 +1,127 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { Buffer } from "buffer";
+import { hkdf } from "@noble/hashes/hkdf";
+import { sha256 } from "@noble/hashes/sha256";
+import { STREAM } from "./stream-cipher.js";
+import { NoOpEncDec } from "./no-op-encdec.js";
+import { readAge, writeAge } from "./age-reader-writer.js";
+import { sliceUntil, unpaddedBase64Buffer } from "./utils.js";
+import { createMacKey, random } from "./utils-crypto.js";
+var ageVersion = "age-encryption.org/v1";
+var headerMacMessage = "header"; // some plaintext used to generate the mac
+var hkdfBodyMessage = "payload"; // some plaintext used for generating the key for encrypting the body
+var fileKeyLengthBytes = 32;
+var bodyHkdfNonceLengthBytes = 16;
+var hkdfKeyLengthBytes = 32;
+// encrypts a plaintext payload using AGE by generating a fileKey
+// and passing the fileKey to another `EncryptionWrapper` for handling
+export function encryptAge(plaintext, wrapFileKey) {
+    if (wrapFileKey === void 0) { wrapFileKey = NoOpEncDec.wrap; }
+    return __awaiter(this, void 0, void 0, function () {
+        var fileKey, recipients, body;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, random(fileKeyLengthBytes)];
+                case 1:
+                    fileKey = _a.sent();
+                    return [4 /*yield*/, wrapFileKey(fileKey)];
+                case 2:
+                    recipients = _a.sent();
+                    return [4 /*yield*/, encryptedPayload(fileKey, plaintext)];
+                case 3:
+                    body = _a.sent();
+                    return [2 /*return*/, writeAge({
+                            fileKey: fileKey,
+                            version: ageVersion,
+                            recipients: recipients,
+                            headerMacMessage: headerMacMessage,
+                            body: body,
+                        })];
+            }
+        });
+    });
+}
+function encryptedPayload(fileKey, payload) {
+    return __awaiter(this, void 0, void 0, function () {
+        var nonce, hkdfKey, ciphertext;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0: return [4 /*yield*/, random(bodyHkdfNonceLengthBytes)];
+                case 1:
+                    nonce = _a.sent();
+                    hkdfKey = hkdf(sha256, fileKey, nonce, Buffer.from(hkdfBodyMessage, "utf8"), hkdfKeyLengthBytes);
+                    ciphertext = STREAM.seal(payload, hkdfKey);
+                    return [2 /*return*/, Buffer.concat([nonce, ciphertext])];
+            }
+        });
+    });
+}
+// decrypts a payload that has been encrypted using AGE can unwrap
+// any internal encryption by passing a `DecryptionWrapper` that can
+// provide the `fileKey` created during encryption
+export function decryptAge(payload, unwrapFileKey) {
+    if (unwrapFileKey === void 0) { unwrapFileKey = NoOpEncDec.unwrap; }
+    return __awaiter(this, void 0, void 0, function () {
+        var encryptedPayload, version, fileKey, header, expectedMac, actualMac, nonce, cipherText, hkdfKey, plaintext;
+        return __generator(this, function (_a) {
+            switch (_a.label) {
+                case 0:
+                    encryptedPayload = readAge(payload);
+                    version = encryptedPayload.header.version;
+                    if (version !== ageVersion) {
+                        throw Error("The payload version ".concat(version, " is not supported, only ").concat(ageVersion));
+                    }
+                    return [4 /*yield*/, unwrapFileKey(encryptedPayload.header.recipients)];
+                case 1:
+                    fileKey = _a.sent();
+                    header = sliceUntil(payload, "---");
+                    expectedMac = unpaddedBase64Buffer(createMacKey(fileKey, headerMacMessage, header));
+                    actualMac = encryptedPayload.header.mac;
+                    if (Buffer.compare(actualMac, expectedMac) !== 0) {
+                        throw Error("The MAC did not validate for the fileKey and payload!");
+                    }
+                    nonce = Buffer.from(encryptedPayload.body.slice(0, bodyHkdfNonceLengthBytes));
+                    cipherText = encryptedPayload.body.slice(bodyHkdfNonceLengthBytes);
+                    hkdfKey = hkdf(sha256, fileKey, nonce, Buffer.from(hkdfBodyMessage, "utf8"), hkdfKeyLengthBytes);
+                    plaintext = STREAM.open(cipherText, hkdfKey);
+                    return [2 /*return*/, Buffer.from(plaintext)];
+            }
+        });
+    });
+}
+//# sourceMappingURL=age-encrypt-decrypt.js.map

package/src/vendor/ts-ibe/age/age-reader-writer.js

@@ -0,0 +1,94 @@
+import { Buffer } from "buffer";
+import { chunked, unpaddedBase64 } from "./utils.js";
+import { createMacKey } from "./utils-crypto.js";
+// takes the model to be encrypted and encodes everything to a string
+// inserting newlines, other tags and the hmac as per the spec
+export function writeAge(input) {
+    var headerStr = header(input);
+    var macKey = mac(createMacKey(input.fileKey, input.headerMacMessage, headerStr));
+    var payload = Buffer.from(input.body).toString("binary");
+    return "".concat(headerStr, " ").concat(macKey, "\n").concat(payload);
+}
+// ends with a `---`, as this is included in the header when
+// calculating the MAC
+export function header(input) {
+    return "".concat(input.version, "\n").concat(recipients(input.recipients), "---");
+}
+var recipients = function (stanzas) {
+    return stanzas.map(function (it) { return recipient(it) + "\n"; });
+};
+var recipient = function (stanza) {
+    var type = stanza.type;
+    var encodedBody = unpaddedBase64(stanza.body);
+    var chunkedEncodedBody = chunked(encodedBody, 64).join("\n");
+    return "-> ".concat(type, "\n") + chunkedEncodedBody;
+};
+// The `---` preceding the MAC is technically part of the MAC-able text
+// so it's included in the header instead
+var mac = function (macStr) { return unpaddedBase64(macStr); };
+// parses an AGE encrypted string into a model object with all the
+// relevant parts encoded correctly
+// throws an error if things are missing, in the wrong place or cannot
+// be parsed
+export function readAge(input) {
+    var _a;
+    var _b = input.split("\n"), version = _b[0], lines = _b.slice(1);
+    var recipients = parseRecipients(lines);
+    var macStartingTag = "--- ";
+    var macLine = lines.shift();
+    if (!macLine || !macLine.startsWith(macStartingTag)) {
+        throw Error("Expected mac, but there were no more lines left!");
+    }
+    var mac = Buffer.from(macLine.slice(macStartingTag.length, macLine.length), "base64");
+    // any remaining newlines are actually part of the payload
+    var ciphertext = Buffer.from((_a = lines.join("\n")) !== null && _a !== void 0 ? _a : "", "binary");
+    return {
+        header: { version: version, recipients: recipients, mac: mac },
+        body: ciphertext,
+    };
+}
+// validates the code points of the characters of the args in line with the go implementation
+// see: https://github.com/FiloSottile/age/blob/8e3f74c283b2e9b3cd0ec661fa4008504e536d20/internal/format/format.go#L301
+function validateArguments(args) {
+    args.forEach(function (arg) {
+        for (var i = 0; i < arg.length; i++) {
+            var charCode = arg.charCodeAt(i);
+            if (charCode < 33 || charCode > 126) {
+                throw Error("Invalid character ".concat(arg[i], " in argument ").concat(arg));
+            }
+        }
+    });
+}
+// parses all the recipient stanzas from `lines`
+// modifies `lines`!!
+function parseRecipients(lines) {
+    var recipients = [];
+    for (var current = peek(lines); current != null && current.startsWith("->"); current = peek(lines)) {
+        var _a = current.slice(3, current.length).split(" "), type = _a[0], args = _a.slice(1);
+        lines.shift();
+        validateArguments(args);
+        var body = parseRecipientBody(lines);
+        if (!body) {
+            throw Error("expected stanza '".concat(type, " to have a body, but it didn't"));
+        }
+        recipients.push({ type: type, args: args, body: Buffer.from(body, "base64") });
+    }
+    if (recipients.length === 0) {
+        throw Error("Expected at least one stanza! (beginning with -->)");
+    }
+    return recipients;
+}
+function parseRecipientBody(lines) {
+    var body = "";
+    for (var next = peek(lines); next != null; next = peek(lines)) {
+        body += lines.shift();
+        if (next.length < 64) {
+            break;
+        }
+    }
+    return body;
+}
+function peek(arr) {
+    return arr[0];
+}
+//# sourceMappingURL=age-reader-writer.js.map

package/src/vendor/ts-ibe/age/armor.js

@@ -0,0 +1,52 @@
+import { Buffer } from "buffer";
+import { chunked } from "./utils.js";
+var header = "-----BEGIN AGE ENCRYPTED FILE-----";
+var footer = "-----END AGE ENCRYPTED FILE-----";
+// takes some payload and encodes it as armor with the AGE armor headers in lines of size `chunkSize`
+export function encodeArmor(input, chunkSize) {
+    if (chunkSize === void 0) { chunkSize = 64; }
+    var base64Input = Buffer.from(input, "binary").toString("base64");
+    var columnisedInput = chunked(base64Input, chunkSize).join("\n");
+    // if the last line is exactly 64 columns, add an extra newline
+    var paddedFooter = footer;
+    if (columnisedInput.length > 0 &&
+        columnisedInput[columnisedInput.length - 1].length === 64) {
+        paddedFooter = "\n" + footer;
+    }
+    return "".concat(header, "\n").concat(columnisedInput, "\n").concat(paddedFooter, "\n");
+}
+// takes an armored payload and decodes it if it is an AGE armor payload
+// and it satisfies some security properties
+export function decodeArmor(armor, chunkSize) {
+    if (chunkSize === void 0) { chunkSize = 64; }
+    // could start/end with space or newlines, let's strip them
+    armor = armor.trimStart();
+    var lengthBeforeEndTrim = armor.length;
+    armor = armor.trimEnd();
+    var lengthAfterTrim = armor.length;
+    // for compliance with the go age implementation, we deny more than 1024 whitespace chars:
+    // see: https://github.com/FiloSottile/age/blob/8e3f74c283b2e9b3cd0ec661fa4008504e536d20/armor/armor.go#L104
+    var trimmedWhitespace = lengthBeforeEndTrim - lengthAfterTrim;
+    if (trimmedWhitespace > 1024) {
+        throw Error("too much whitespace at the end of the armor payload");
+    }
+    if (!armor.startsWith(header)) {
+        throw Error("Armor cannot be decoded if it does not start with a header! i.e. ".concat(header));
+    }
+    if (!armor.endsWith(footer)) {
+        throw Error("Armor cannot be decoded if it does not end with a footer! i.e. ".concat(footer));
+    }
+    var base64Payload = armor.slice(header.length, armor.length - footer.length);
+    var lines = base64Payload.split("\n");
+    if (lines.some(function (line) { return line.length > chunkSize; })) {
+        throw Error("Armor to decode cannot have lines longer than ".concat(chunkSize, " (configurable) in order to stop padding attacks"));
+    }
+    if (lines[lines.length - 1].length >= chunkSize) {
+        throw Error("The last line of an armored payload must be less than ".concat(chunkSize, " (configurable) to stop padding attacks"));
+    }
+    return Buffer.from(base64Payload, "base64").toString("binary");
+}
+export function isProbablyArmored(input) {
+    return input.startsWith(header);
+}
+//# sourceMappingURL=armor.js.map

package/src/vendor/ts-ibe/age/no-op-encdec.js

@@ -0,0 +1,72 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var noOpType = "no-op";
+// if you wish to encrypt with AGE but simply pass the filekey in the recipient stanza, then use this
+// protip: you probably don't!
+var NoOpEncDec = /** @class */ (function () {
+    function NoOpEncDec() {
+    }
+    NoOpEncDec.wrap = function (filekey) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                return [2 /*return*/, [
+                        {
+                            type: noOpType,
+                            args: [],
+                            body: filekey,
+                        },
+                    ]];
+            });
+        });
+    };
+    NoOpEncDec.unwrap = function (recipients) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                if (recipients.length !== 1) {
+                    throw Error("NoOpEncDec only expects a single stanza!");
+                }
+                if (recipients[0].type !== noOpType) {
+                    throw Error("NoOpEncDec expects the type of the stanza to be ".concat(noOpType));
+                }
+                return [2 /*return*/, recipients[0].body];
+            });
+        });
+    };
+    return NoOpEncDec;
+}());
+export { NoOpEncDec };
+//# sourceMappingURL=no-op-encdec.js.map

package/src/vendor/ts-ibe/age/stream-cipher.js

@@ -0,0 +1,99 @@
+// largely taken from https://github.com/paulmillr/jage,
+// but hooking in a browser compatible ChaCha20 implementation
+// STREAM cipher
+// https://eprint.iacr.org/2015/189.pdf
+// age spec:
+// After the header the binary payload is nonce || STREAM[HKDF[nonce, "payload"](file key)](plaintext) where nonce is random(16) and STREAM is from Online Authenticated-Encryption and its Nonce-Reuse Misuse-Resistance with ChaCha20-Poly1305 in 64KiB chunks and a nonce structure of 11 bytes of big endian counter, and 1 byte of last block flag (0x00 / 0x01). (The STREAM scheme is similar to the one Tink and Miscreant use, but without nonce prefix as we use HKDF, and with ChaCha20-Poly1305 instead of AES-GCM because the latter is unreasonably hard to do well or fast without hardware support.)
+import { ChaCha20Poly1305 } from "@stablelib/chacha20poly1305";
+var CHUNK_SIZE = 64 * 1024; // 64 KiB
+var TAG_SIZE = 16; // Poly1305 MAC size
+var ENCRYPTED_CHUNK_SIZE = CHUNK_SIZE + TAG_SIZE;
+var NONCE_SIZE = 12; // STREAM nonce size
+// due to using a 32bit uint for the counter, this is the max
+// value the counter can be without risking a nonce reuse
+var COUNTER_MAX = Math.pow(2, 32) - 1;
+var STREAM = /** @class */ (function () {
+    function STREAM(key) {
+        this.key = key.slice();
+        this.nonce = new Uint8Array(NONCE_SIZE);
+        this.nonceView = new DataView(this.nonce.buffer);
+        this.counter = 0;
+    }
+    STREAM.seal = function (plaintext, privateKey) {
+        var stream = new STREAM(privateKey);
+        var chunks = Math.ceil(plaintext.length / CHUNK_SIZE);
+        var ciphertext = new Uint8Array(plaintext.length + chunks * TAG_SIZE);
+        for (var chunk64kb = 1; chunk64kb <= chunks; chunk64kb++) {
+            var start = chunk64kb - 1;
+            var end = chunk64kb;
+            var isLast = chunk64kb === chunks;
+            var input = plaintext.slice(start * CHUNK_SIZE, end * CHUNK_SIZE);
+            var output = ciphertext.subarray(start * ENCRYPTED_CHUNK_SIZE, end * ENCRYPTED_CHUNK_SIZE);
+            stream.encryptChunk(input, isLast, output);
+        }
+        stream.clear();
+        return ciphertext;
+    };
+    STREAM.open = function (ciphertext, privateKey) {
+        var stream = new STREAM(privateKey);
+        var chunks = Math.ceil(ciphertext.length / ENCRYPTED_CHUNK_SIZE);
+        var plaintext = new Uint8Array(ciphertext.length - chunks * TAG_SIZE);
+        for (var chunk64kb = 1; chunk64kb <= chunks; chunk64kb++) {
+            var start = chunk64kb - 1;
+            var end = chunk64kb;
+            var isLast = chunk64kb === chunks;
+            var input = ciphertext.slice(start * ENCRYPTED_CHUNK_SIZE, end * ENCRYPTED_CHUNK_SIZE);
+            var output = plaintext.subarray(start * CHUNK_SIZE, end * CHUNK_SIZE);
+            stream.decryptChunk(input, isLast, output);
+        }
+        stream.clear();
+        return plaintext;
+    };
+    STREAM.prototype.encryptChunk = function (chunk, isLast, output) {
+        if (chunk.length > CHUNK_SIZE)
+            throw new Error("Chunk is too big");
+        if (this.nonce[11] === 1)
+            throw new Error("Last chunk has been processed");
+        if (isLast)
+            this.nonce[11] = 1;
+        var ciphertext = new ChaCha20Poly1305(this.key).seal(this.nonce, chunk);
+        output.set(ciphertext);
+        this.incrementCounter();
+    };
+    STREAM.prototype.decryptChunk = function (chunk, isLast, output) {
+        if (chunk.length > ENCRYPTED_CHUNK_SIZE)
+            throw new Error("Chunk is too big");
+        if (this.nonce[11] === 1)
+            throw new Error("Last chunk has been processed");
+        if (isLast)
+            this.nonce[11] = 1;
+        var plaintext = new ChaCha20Poly1305(this.key).open(this.nonce, chunk);
+        if (plaintext == null) {
+            throw Error("Error during decryption!");
+        }
+        output.set(plaintext);
+        this.incrementCounter();
+    };
+    // Increments Big Endian Uint8Array-based counter.
+    // [0, 0, 0] => [0, 0, 1] ... => [0, 0, 255] => [0, 1, 0]
+    STREAM.prototype.incrementCounter = function () {
+        if (this.counter == COUNTER_MAX) {
+            throw new Error("Stream cipher counter has already hit max value! Aborting to avoid nonce reuse - tlock only supports payloads up to 256TB");
+        }
+        this.counter += 1;
+        this.nonceView.setUint32(7, this.counter, false);
+    };
+    STREAM.prototype.clear = function () {
+        function clear(arr) {
+            for (var i = 0; i < arr.length; i++) {
+                arr[i] = 0;
+            }
+        }
+        clear(this.key);
+        clear(this.nonce);
+        this.counter = 0;
+    };
+    return STREAM;
+}());
+export { STREAM };
+//# sourceMappingURL=stream-cipher.js.map

package/src/vendor/ts-ibe/age/utils-crypto.js

@@ -0,0 +1,60 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+import { Buffer } from "buffer";
+import { hkdf } from "@noble/hashes/hkdf";
+import { sha256 } from "@noble/hashes/sha256";
+import { hmac } from "@noble/hashes/hmac";
+import { randomBytes } from "crypto";
+export function createMacKey(fileKey, macMessage, headerText) {
+    // empty string salt as per the spec!
+    var hmacKey = hkdf(sha256, fileKey, "", Buffer.from(macMessage, "utf8"), 32);
+    return Buffer.from(hmac(sha256, hmacKey, Buffer.from(headerText, "utf8")));
+}
+// returns a string of n bytes read from a CSPRNG like /dev/urandom.
+export function random(n) {
+    return __awaiter(this, void 0, void 0, function () {
+        var bytes;
+        return __generator(this, function (_a) {
+            if (typeof window === "object" && "crypto" in window) {
+                return [2 /*return*/, window.crypto.getRandomValues(new Uint8Array(n))];
+            }
+            bytes = randomBytes(n);
+            return [2 /*return*/, new Uint8Array(bytes.buffer, bytes.byteOffset, bytes.byteLength)];
+        });
+    });
+}
+//# sourceMappingURL=utils-crypto.js.map

package/src/vendor/ts-ibe/age/utils.js

@@ -0,0 +1,59 @@
+import { Buffer } from "buffer";
+// as per the spec:
+// RFC 4648, Section 4
+// without = padding characters (sometimes referred to as "raw" or "unpadded" base64)
+export function unpaddedBase64(buf) {
+    var encodedBuf = Buffer.from(buf).toString("base64");
+    var lastIndex = encodedBuf.length - 1;
+    while (encodedBuf[lastIndex] === "=") {
+        lastIndex--;
+    }
+    return encodedBuf.slice(0, lastIndex + 1);
+}
+export function unpaddedBase64Buffer(buf) {
+    return Buffer.from(unpaddedBase64(buf), "base64");
+}
+/*
+    e.g. chunked("hello world", 2, ".") returns
+    ["he.", "ll.", "o .", "wo.", "rl.", "d."]
+ */
+export function chunked(input, chunkSize, suffix) {
+    if (suffix === void 0) { suffix = ""; }
+    var output = [];
+    var currentChunk = "";
+    for (var i = 0, chunks = 0; i < input.length; i++) {
+        currentChunk += input[i];
+        var posInChunk = i - chunks * chunkSize;
+        if (posInChunk === chunkSize - 1) {
+            output.push(currentChunk + suffix);
+            currentChunk = "";
+            chunks++;
+        }
+        else if (i === input.length - 1) {
+            output.push(currentChunk + suffix);
+        }
+    }
+    return output;
+}
+// slices the input string up to and including the first
+// occurrence of the string provided in `searchTerm`
+// returns the whole string if it's not found
+// e.g. sliceUntil("hello world", "ll") will return "hell"
+export function sliceUntil(input, searchTerm) {
+    var lettersMatched = 0;
+    var inputPointer = 0;
+    while (inputPointer < input.length && lettersMatched < searchTerm.length) {
+        if (input[inputPointer] === searchTerm[lettersMatched]) {
+            ++lettersMatched;
+        }
+        else if (input[inputPointer] === searchTerm[0]) {
+            lettersMatched = 1;
+        }
+        else {
+            lettersMatched = 0;
+        }
+        ++inputPointer;
+    }
+    return input.slice(0, inputPointer);
+}
+//# sourceMappingURL=utils.js.map